注解实现原理

一、什么是注解？

      对于很多初次接触的开发者来说应该都有这个疑问？Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
　　Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

二、注解的用处：

      1、生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等
      2、跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2 依赖注入，未来java 开发，将大量注解配置，具有很大用处;
      3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。

三、注解的原理：

　　注解本质是一个继承了Annotation 的特殊接口，其具体实现类是Java 运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java 运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler 的invoke 方法。该方法会从memberValues 这个Map 中索引出对应的值。而memberValues 的来源是Java 常量池。

四、元注解：

java.lang.annotation 提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：
   @Documented – 注解是否将包含在JavaDoc中
   @Retention – 什么时候使用该注解
   @Target – 注解用于什么地方
   @Inherited – 是否允许子类继承该注解

  1.）@Retention – 定义该注解的生命周期
  ●   RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
  ●   RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
  ●   RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

  2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。可用的ElementType 参数包括
  ● ElementType.CONSTRUCTOR: 用于描述构造器
  ● ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
  ● ElementType.LOCAL_VARIABLE: 用于描述局部变量
  ● ElementType.METHOD: 用于描述方法
  ● ElementType.PACKAGE: 用于描述包
  ● ElementType.PARAMETER: 用于描述参数
  ● ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明

 3.)@Documented – 一个简单的Annotations 标记注解，表示是否将注解信息添加在java 文档中。

 4.)@Inherited – 定义该注释和子类的关系
     @Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的annotation 类型被用于一个class，则这个annotation 将被用于该class 的子类。

五、常见标准的Annotation：

  1.）Override
      java.lang.Override 是一个标记类型注解，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时，java 编译器将以一个编译错误来警示。
  2.）Deprecated
     Deprecated 也是一种标记类型注解。当一个类型或者类型成员使用@Deprecated 修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的“延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated，但编译器仍然要报警。
 3.）SuppressWarnings
     SuppressWarning 不是一个标记类型注解。它有一个类型为String[] 的成员，这个成员的值为被禁止的警告名。对于javac 编译器来讲，被-Xlint 选项有效的警告名也同样对@SuppressWarings 有效，同时编译器忽略掉无法识别的警告名。
　　@SuppressWarnings("unchecked")

六、自定义注解：

自定义注解类编写的一些规则:
  1. Annotation 型定义为@interface, 所有的Annotation 会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
  2. 参数成员只能用public 或默认(default) 这两个访问权修饰
  3. 参数成员只能用基本类型byte、short、char、int、long、float、double、boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组.
  4. 要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法
  5. 注解也可以没有定义成员,，不过这样注解就没啥用了
PS:自定义注解需要使用到元注解

package com.wxy.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType; 
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**   
*  定义注解Test
*  注解中含有两个元素 id 和 description
*  description元素有默认值"no description"  
*   @create-time     2011-8-12   下午02:22:28   
*   @revision          $Id
*/
 
//该注解用于方法声明
@Target(ElementType.METHOD)
//VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息
@Retention(RetentionPolicy.RUNTIME)
//将此注解包含在javadoc中
@Documented
//允许子类继承父类中的注解
@Inherited
public @interface Test { 
    public int id();
    public String description() default "no description";
}

package com.wxy.annotation;
import java.lang.reflect.Method;
/**
*   使用注解和解析注解
*  
*   @creator            xiaoyu.wang   
*   @create-time     2011-8-12   下午03:49:17   
*   @revision          $Id
*/
public class Test_1{
    /**
     * 被注释的三个方法
     */
    @Test(id = 1, description = "hello method1")
    public void method1() {
    }
    @Test(id = 2)
    public void method2() {
    }
    @Test(id = 3, description = "last method3")
    /**
     * 解析注释，将Test_1类所有被注解方法的信息打印出来
     * @param args
     */
    public static void main(String[] args) {
        Method[] methods = Test_1.class.getDeclaredMethods();
        for (Method method : methods) {
            //判断方法中是否有指定注解类型的注解
            boolean hasAnnotation = method.isAnnotationPresent(Test.class);
            if (hasAnnotation) {
                //根据注解类型返回方法的指定类型注解
                Test annotation = method.getAnnotation(Test.class);
                System.out.println("Test(method=" + method.getName() + ",id=" + annotation.id()
                                   + ",description=" + annotation.description() + ")");
            }
        }
    }
}

六、spring中注解@Resource源码分析

package com.wxy.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Retention(RetentionPolicy.RUNTIME)
@Target( { ElementType.FIELD, ElementType.METHOD })
public @interface WxyResource {
    String name() default "";
}

public class PeopleServiceBean implements PeopleService {
    private PeopleDao peopleDao;
    private String    name = "wxy";
    private Integer   id   = 1;
    /** 
     * @param peopleDao the peopleDao to set
     */
    @WxyResource
    public void setPeopleDao(PeopleDao peopleDao) {
        this.peopleDao = peopleDao;
    }
    …
}

public class WxyClassPathXMLApplicationContext {
 
    //存放BeanDefinition的列表，在beans.xml中定义的bean可能不止一个
    private final List<BeanDefinition> beanDefines = new ArrayList<BeanDefinition>();
    //将类名作为索引，将创建的Bean对象存入到Map中
    private final Map<String, Object>  sigletons   = new HashMap<String, Object>();
    public WxyClassPathXMLApplicationContext(String fileName) {
        //读取xml配置文件
        this.readXML(fileName);
        //实例化bean
        this.instanceBeans();
        //处理注解方式
        this.annotationInject();
        //注入对象
        this.injectObject();
    }
    /** 
     * 使用注解方式注入对象方法实现
     * @throws IntrospectionException 
     */
    private void annotationInject() {
        //循环所有bean对象
        for (String beanName : sigletons.keySet()) {
            //获取bean对象
            Object bean = sigletons.get(beanName);
            //如果bean不为空,取得bean的属性
            if (bean != null) {
                try {
                    //按属性注入
                    PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass())
                        .getPropertyDescriptors();
                    for (PropertyDescriptor properdesc : ps) {
                        //获取属性的setter方法
                        Method setter = properdesc.getWriteMethod();
                        //判断注解是否存在
                        if (setter != null && setter.isAnnotationPresent(WxyResource.class)) {
                            //取得注解
                            WxyResource resource = setter.getAnnotation(WxyResource.class);
                            Object value = null;
                            //如果按名字找到
                            if (resource.name() != null && !"".equals(resource.name())) {
                                //取得容器中的bean对象
                                value = sigletons.get(resource.name());
 
                            } else {//没有按名字找到，按类型寻找
                                //取得容器中的bean对象
                                value = sigletons.get(resource.name());
                                if (value == null) {
                                    for (String key : sigletons.keySet()) {
                                        if (properdesc.getPropertyType().isAssignableFrom(
                                            sigletons.get(key).getClass())) {
                                            value = sigletons.get(key);
                                            break;
                                        }
                                    }
                                }
                            }
                            //把引用对象注入到属性
                            setter.setAccessible(true); 
                            setter.invoke(bean, value);
                        }
                    }
                    //按字段注入
                    Field[] fields = bean.getClass().getDeclaredFields();
                    for (Field field : fields) {
                        //如果注解存在
                        if (field.isAnnotationPresent(WxyResource.class)) {
                            //取得注解
                            WxyResource resource = field.getAnnotation(WxyResource.class);
                            Object value = null;
                            //如果按名字找到
                            if (resource.name() != null && !"".equals(resource.name())) {
                                //取得容器中的bean对象
                                value = sigletons.get(resource.name());
                            } else {//没有按名字找到，按类型寻找
                                //取得容器中的bean对象
                                value = sigletons.get(field.getName());
                                if (value == null) {
                                    for (String key : sigletons.keySet()) {
                                        if (field.getType().isAssignableFrom(
                                            sigletons.get(key).getClass())) {
                                            value = sigletons.get(key);
                                            break;
                                        }
                                    }
                                }
                            }
                            //允许访问private 
                            field.setAccessible(true);
                            field.set(bean, value);
                        }
                    }
                } catch (IntrospectionException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    /** 
     *为bean对象的属性注入值
     */
　　private void injectObject() {
　　　　….
　　}
　　….
}

public class MyTest { 
    /**
     * @param args
     */
    public static void main(String[] args) {
        //MyIOC容器实例化
        WxyClassPathXMLApplicationContext ac = new WxyClassPathXMLApplicationContext("beans.xml");
        PeopleService peopleService = (PeopleService) ac.getBean("peopleService");
        peopleService.save();
    }
}

注解代表的是某种业务意义，注解背后处理器的工作原理如上源码实现：首先解析所有属性，判断属性上是否存在指定注解，如果存在则根据搜索规则取得bean，然后利用反射原理注入。如果标注在字段上面，也可以通过字段的反射技术取得注解，根据搜索规则取得bean，然后利用反射技术注入。

以上内容作为笔记转自

　　https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html

　　https://www.cnblogs.com/fanheyan/articles/5691659.html

后续自己封装框架的业务操作日志，会借助自定义注解来封装，如有时间，会继续分享封装的思想。