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手记