java自定义注解详细了解

java的注解用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。

注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

1、元注解

元注解是指注解的注解。包括  @Retention @Target @Document @Inherited四种。

1.1、@Retention: 定义注解的保留策略

@Retention(RetentionPolicy.SOURCE)   //注解仅存在于源码中，在class字节码文件中不包含

@Retention(RetentionPolicy.CLASS)     // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，

@Retention(RetentionPolicy.RUNTIME)  // 注解会在class字节码文件中存在，在运行时可以通过反射获取到

 

1.2、@Target：定义注解的作用目标

其定义的源码为： 

 

1 @Documented
2 @Retention(RetentionPolicy.RUNTIME)
3 @Target(ElementType.ANNOTATION_TYPE)
4 public @interface Target {
5     ElementType[] value();
6 }

@Target(ElementType.TYPE)   //接口、类、枚举、注解

@Target(ElementType.FIELD) //字段、枚举的常量

@Target(ElementType.METHOD) //方法

@Target(ElementType.PARAMETER) //方法参数

@Target(ElementType.CONSTRUCTOR)  //构造函数

@Target(ElementType.LOCAL_VARIABLE)//局部变量

@Target(ElementType.ANNOTATION_TYPE)//注解

@Target(ElementType.PACKAGE) ///包   

 由以上的源码可以知道，他的elementType 可以有多个，一个注解可以为类的，方法的，字段的等等

1.3、@Document：说明该注解将被包含在javadoc中

 

1.4、@Inherited：说明子类可以继承父类中的该注解

 

下面是注解的工作原理案例：

1、注解接口：

package com.laoxu.test.day01.annotationDemo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
 * 注解接口
 * @author Administrator
 *
 */
import java.lang.annotation.RetentionPolicy;
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    public enum annoType{util,entity,serveice,model};//枚举
    public annoType classType() default annoType.util;
    public static final int id = -1;
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface HelloWord{
    public String name() default "";
}

　2、注解工作及测试类：

package com.laoxu.test.day01.annotationDemo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.apache.commons.lang3.StringUtils;

import com.laoxu.test.day01.annotationDemo.MyAnnotation.annoType;
/**
 * 通过java的反射机制使用注解
 * @author Administrator
 *
 */
public class AnnotationTest {
    public static void main(String[] args) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
        ParseAnnotation parseAnnotation = new ParseAnnotation();
        parseAnnotation.parseMethod(TestDemo.class);
        parseAnnotation.parseType(TestDemo.class);
        
    }
}
/**
 * 测试类
 */
@MyAnnotation
class TestDemo {
    @HelloWord(name = "小米")
    @MyAnnotation(classType = annoType.serveice)
    public void getName(String name) {
        if (StringUtils.isBlank(name)) {
            System.out.println("say hello word");
        } else {
            System.out.println("this is the test Demo: " + name);
        }
    }
}
/**
 * 通过反射机制，解析当前类的注解，并将注解参数执行    
 * @author Administrator
 *
 */
class ParseAnnotation{
    /**
     * 解析方法的注解
     * @param clazz
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    public void parseMethod(Class<?> clazz) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        Object obj = clazz.newInstance();
        /*
         * 通过反射获取操作类的所有方法
         */
        Method[] methods = clazz.getDeclaredMethods();
        String name = "";
        /*
         * 遍历方法，将获取注解，并执行参数
         */
        for (Method method : methods) {
            /*
             * HelloWord的注解
             */
            HelloWord say = method.getAnnotation(HelloWord.class);
            if(say!=null){
                name = say.name();
                method.invoke(obj, name);
            }
            /*
             * MyAnnotation的注解解析
             */
            MyAnnotation anno = method.getAnnotation(MyAnnotation.class);
            if(anno!=null){
                if(MyAnnotation.annoType.util.equals(anno.classType())){
                    System.out.println("this is a util method");
                }else{
                    System.out.println("this is a : " + anno.classType() + " method");
                }
            }else{
                System.out.println("no myannotaion method!");
            }
        }
    }
    /**
     * 解析类的注解
     * @param clazz
     */
    public void parseType(Class<?> clazz){
        MyAnnotation anno = clazz.getAnnotation(MyAnnotation.class);
        if(anno!=null){
            if(MyAnnotation.annoType.util.equals(anno.classType())){
                System.out.println("this is a util class");
            }else{
                System.out.println("this is a : " + anno.classType() + " class");
            }
        }else{
            System.out.println("no myannotaion class !");
        }
    }
}