C#中的Attribute和Java中的Annotation

在之前的博客中介绍过C#的Attribute(特性），简单的说，特性主要就是利用反射技术，在运行期获取关注类的相关标注信息，然后利用这些标注信息对关注的类进行处理，最近因为工作的原因，需要看一下Java，Java和C#其实是非常想象的两种语言，其实语言很多都相像，都在互相学习么，在Java中有注解这个名词，其实就是C#中的Attribute，原理和C#一样，利用反射技术获取运行时类的信息。

如果想要了解注解所表示的意思，那么必须提供一个能够解析这个注解的工具，这个应该不用做过多的解释，今天抽空，看了网上的例子，然后自己写了一个Java的实例，自己封装了一个注解处理类,当然不通用，话不u盾偶说了，直接上代码。相关的类都在下面

package com.liuyu.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.annotation.*;

public class AnnotationUtil {

    public static void getFruitInfo(Class<?> clazz) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{

        String strFruitName=" 水果名称：";

        String strFruitColor=" 水果颜色：";

        String strFruitProvicer="供应商信息：";

        Field[] fields = clazz.getDeclaredFields();

        for(Field field :fields){

            if(field.isAnnotationPresent(Fruite.class)){

                Fruite fruitName = (Fruite) field.getAnnotation(Fruite.class);

                strFruitName=strFruitName+fruitName.value();

                System.out.println(strFruitName);

            }

            else if(field.isAnnotationPresent(Fruite.class)){

                FruitColor fruitColor= (FruitColor) field.getAnnotation(FruitColor.class);

                 Method md= getGetMethod(clazz, field.getName());

                Object s=   md.invoke(clazz,fruitColor.fruitColor());

                System.out.println(s.toString());

                strFruitColor=strFruitColor+fruitColor.fruitColor().toString();

                System.out.println(strFruitColor);

            }

            else if(field.isAnnotationPresent(Provider.class)){

                Provider fruitProvider= (Provider) field.getAnnotation(Provider.class);

                  Method mdSet= getSetMethod(clazz, field.getName());

                  Method mdGet= getGetMethod(clazz, field.getName());

                  Object sValue;

                try {

                      Object g=    clazz.newInstance();

                       mdSet.invoke(g,new Object[]{fruitProvider.id()+fruitProvider.name()+fruitProvider.address()});

                     sValue=  mdGet.invoke(g, new Object[]{});

                     System.out.println(sValue.toString());

                } catch (InstantiationException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                strFruitProvicer=" 供应商编号："+fruitProvider.id()+" 供应商名称："+fruitProvider.name()+" 供应商地址："+fruitProvider.address();

                System.out.println(strFruitProvicer);

            }

        }

    }

    @SuppressWarnings({ "rawtypes", "unchecked" })

    public static Method getGetMethod(Class objectClass, String fieldName) {

        StringBuffer sb = new StringBuffer();

        sb.append("get");

        sb.append(fieldName.substring(0, 1).toUpperCase());

        sb.append(fieldName.substring(1));

        try {

            return objectClass.getMethod(sb.toString());

        } catch (Exception e) {

        }

        return null;

    }

    @SuppressWarnings("rawtypes")

    public static Method getSetMethod( Class objectClass, String fieldName) {       

        try {       

            Class[] parameterTypes = new Class[1];       

            Field field = objectClass.getDeclaredField(fieldName);       

            parameterTypes[0] = field.getType();       

            StringBuffer sb = new StringBuffer();       

            sb.append("set");       

            sb.append(fieldName.substring(0, 1).toUpperCase());       

            sb.append(fieldName.substring(1));       

            @SuppressWarnings("unchecked")

            Method method = objectClass.getMethod(sb.toString(), parameterTypes);       

            return method;       

        } catch (Exception e) {       

            e.printStackTrace();       

        }       

        return null;       

    }       

    public static void invokeSet(Object o, String fieldName, Object value) {       

        Method method = getSetMethod(o.getClass(), fieldName);       

        try {       

            method.invoke(o, new Object[] { value });       

        } catch (Exception e) {       

            e.printStackTrace();       

        }       

    }       

    /**    

     * 执行get方法    

     *     

     * @param o执行对象    

     * @param fieldName属性    

     */       

    public static Object invokeGet(Object o, String fieldName) {       

        Method method = getGetMethod(o.getClass(), fieldName);       

        try {       

            return method.invoke(o, new Object[0]);       

        } catch (Exception e) {       

            e.printStackTrace();       

        }       

        return null;       

    }  

}

package com.liuyu.Annotation;

import java.lang.annotation.Documented;

import java.lang.annotation.Retention;

import java.lang.annotation.Target;

import java.lang.annotation.*;

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface Provider {

    /**

     * 供应商编号

     * @return

     */

    public int id() default -1;

    /**

     * 供应商名称

     * @return

     */

    public String name() default "";

    /**

     * 供应商地址

     * @return

     */

    public String address() default "";

}

package com.liuyu.Annotation;

import java.lang.annotation.*;

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface FruitColor {

     public enum Color{ BULE,RED,GREEN}

     Color fruitColor() default Color.GREEN;

package com.liuyu.main;

import com.liuyu.Annotation.*;

import com.liuyu.Annotation.FruitColor.Color;

import java.lang.annotation.*;

public class FruitTest {

    @Fruite("Apple")

    private String appleName;

    @FruitColor(fruitColor=Color.RED)

    private String appleColor;

    @Provider(id=1,name="陕西红富士集团",address="陕西省西安市延安路89号红富士大厦")

    private String appleProvider;

    public void setAppleColor(String appleColor) {

        this.appleColor = appleColor;

    }

    public String getAppleColor() {

        return appleColor;

    }

    public void setAppleName(String appleName) {

        this.appleName = appleName;

    }

    public String getAppleName() {

        return appleName;

    }

    public void setAppleProvider(String appleProvider) {

        this.appleProvider = appleProvider;

    }

    public String getAppleProvider() {

        return appleProvider;

    }

    public void displayName(){

        System.out.println("水果的名字是：苹果");

    }

}

package com.liuyu.main;

import java.lang.reflect.InvocationTargetException;

import com.liuyu.Annotation.*;

public class maintest {

    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        AnnotationUtil.getFruitInfo(FruitTest.class);

    }

}

以下是C#的一个例子，网上来的。可以和上面的比较下，很类似。

下面的代码定义了一个名字为widebright的自定义的属性，然后还有测试使用的例子，用到了“反射”了，其实我也接触不多“反射”这个东西，就是个提供运行时获取类结构等的支持的东西了，还可以用来动态加载库等，好像。

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Reflection;

namespace WindowsFormsApplication1

{

    //这里利用AttributeUsage 来设置我们的自定义属性的应用范围,这里定义的可以用于类，结构和方法的声明

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method,

       AllowMultiple = true)] // multiuse attribute

    class widebright : Attribute //从Attribute 继承，写一个自定义属性

    {

        private string strname;

        public widebright(string name)

        {

            strname = name;

        }

        //添加一个允许外部访问的属性

        public string Name

        {

            get { return strname; }

            set { strname = Name; }

        }

    }

    //写一个测试类

    [widebright("widebright")]

    class widebrightTestClass

    {

        private string name = "hahaa";

        [widebright("test1")]

        public void TestMethod()

        {

            System.Console.WriteLine("哈哈，第一个测试通过");

        }

        [widebright("test2")]

        public void TestMethod2(string parm)

        {

            System.Console.WriteLine("哈哈，第二个测试通过,传过来的参数是:{0}", parm);

        }

        public void TestMethod3()

        {

            System.Console.WriteLine("哈哈，第三个测试，name的值为{0}", this.name);

        }

    }

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

        private void Form1_Load(object sender, EventArgs e)

        {

            widebrightTestClass testClass = new widebrightTestClass();

            //在程序运行时，获取自己添加进去的“自定义属性”

            Type type = testClass.GetType();

            testClass.TestMethod3 ();

            //利用反射 运行时修改对象的私有属性

            BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Instance);

            type.GetField ("name",flags ).SetValue (testClass,"widebright");

            //再次调用方法，应该可以看到name私有属性确实被修改成widebright了

            testClass.TestMethod3 ();

            foreach (Attribute attr in   type.GetCustomAttributes(false))

            {

                if (attr.GetType() == typeof(widebright))

                {

                    System.Console.WriteLine("testClass 对象具有 widebrihgt这个自定义属性");

                }

            }

            //测试 widebright”自定义属性“时候存在，获取type的所有方法

            foreach (MethodInfo mInfo in type.GetMethods())

            {

                 foreach (Attribute attr in

                    Attribute.GetCustomAttributes(mInfo))

                {

                    // Check for the AnimalType attribute.

                    if (attr.GetType() == typeof(widebright))

                    {

                        Console.WriteLine(

                            " {0}方法有一个 名字为{1} 的\"widebright\" 属性.",

                            mInfo.Name, ((widebright)attr).Name );

                           if (((widebright)attr).Name == "test2" )

                           {

                               //动态调用testClass对象的方法

                               mInfo.Invoke(testClass, new string [] {((widebright)attr).Name});

                           }

                            else

                           {

                               //第一个方法没有参数，所以传个null给他

                               mInfo.Invoke (testClass, null);

                           }

                    }else{

                          Console.WriteLine(

                            " {0}方法不具有\"widebright\" 属性.",

                            mInfo.Name );

                    }

               }

        }

      }

    }

运行程序后将打印：

哈哈，第三个测试，name的值为hahaa

哈哈，第三个测试，name的值为widebright

testClass 对象具有 widebrihgt这个自定义属性

TestMethod方法有一个 名字为test1 的"widebright" 属性.

哈哈，第一个测试通过

TestMethod2方法有一个 名字为test2 的"widebright" 属性.

哈哈，第二个测试通过,传过来的参数是:test2

很有意思用法，呵呵， widebright手记

巴特西

C#中的Attribute和Java中的Annotation

最新文章

热门文章