Java 注解Annotation研究

眼前主流框架还支持注解。比如Android平台及之
Retrofit,EventBus,Butterknife等
Java Web: Spring MVC ,MyBatis等.注解是于Java SDK 1.5
开始起步以的,使用注解到底有啊补呢?

对配置文件要加上较多逻辑代码来处理,而注解只待注解元
数据就是可以区分,代码整洁,阅读性好,减少配置文件等。

annotation.png

假设达到图所示:
Java的笺注分为初注解和专业注解。

  • 业内注解:系统提供的注解

@Deprecated
:表示都过,不引进使用.比如你产生一个措施现在莫思量用了,但是其他人调用了,删掉会潜移默化外代码。这样用这个符号来说明.

@Documented
@Retention(RetentionPolicy.RUNTIME)//运行期runtime
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})//范围
public @interface Deprecated {
}

@Deprecated
public void test(){
}

@Override 主要作用是掩父类方法

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)//在源文件中出现,在编译后会被编译器丢弃
public @interface Override {
}

比如android onCreate智,覆盖父类方法

 @Override
 protected void onCreate(Bundle savedInstanceState) {
}

比如java toString()方法,覆盖java lang toString方法

 @Override
  public String toString() {
        return super.toString();
   }

@SupressWarning 关闭不当的编译器警告信息
比如

  • 头条注解:可以团结定义注解

@Retention 代表用以什么级别保存该注解信息,标记有下3只参数可选

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,//注解将被编译器丢弃

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,//注解在class文件可用,但是会VM丢弃

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME//VM运行期也会保留注解,可用用反射机制可用读取对应的数据
}

@Target 表示于描述的注释用于什么地方,可用运用到地方如下

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();//这边是一个ElementType数组
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,//用于描述类,接口 或枚举声明

    /** Field declaration (includes enum constants) */
    FIELD,//用于描述域

    /** Method declaration */
    METHOD,//用于描述方法

    /** Formal parameter declaration */
    PARAMETER,//用于描述参数

    /** Constructor declaration */
    CONSTRUCTOR,//用于描述构造器

    /** Local variable declaration */
    LOCAL_VARIABLE,//用于描述局部变量

    /** Annotation type declaration */
    ANNOTATION_TYPE,//用于描述Annotation type

    /** Package declaration */
    PACKAGE,//描述包

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Documented用于描述其它类型的annotation应该被用作为标明的主次成员的公共API,因此得以被如javadoc此类的工具文档化。Documented是一个标记注解,没有成员.

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

@Inherited
元注解是一个号注解,@Inherited阐述了某被标的项目是深受持续的,则这annotation将受用来该class的子类。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

由定义自己的Annotation 格式如下
public @interface 注解名 {定义体}

定义体里面一般如下图所示:

anntion2.png

选举个栗子写个Demo吧:
概念一个Person Annotation 里面定义了2个点子 say 和move 方法.

@Target({ElementType.METHOD,ElementType.TYPE,ElementType.LOCAL_VARIABLE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonAnnotation {
   public String say() default "hello";
   public String move() default "walk";
  Sex  sex() default Sex.MAN;//枚举类型
}

概念一个UserAnnotation 定义name, age 和 PersonAnnotation annotation

@Target({ElementType.METHOD , ElementType.TYPE,ElementType.FIELD,ElementType.LOCAL_VARIABLE})//可以修饰方法,实例变量,local 变量
@Retention(RetentionPolicy.RUNTIME)
public @interface UserAnnotation {
    String name() default "";
    String age() default "";
    PersonAnnotation person();//使用了Annotation类型
}

定义性别enum.

public enum Sex {
    MAN,WOMEN,OTHER
}

地方的代码定义的是,那怎么使与否?答案是反射,直接上代码吧
定义User类

@UserAnnotation//因为在Target定义了ElementType.TYPE可以修饰类
public class User {
    @UserAnnotation(name = "Star")//因为在Target中定义了ElementType.FIELD就可以定义在实例变量中拉
    protected String name;
    @UserAnnotation(age = 100)
    int age;
    @UserAnnotation(name = "wong" , age = 1000)
    protected String value;
    @UserAnnotation(name = "GEAK",age = 90)//因为在Target中定义了ElementType.METHOD
    public void getUserInfo(String name,int age){
        System.out.println("the name is:"+name+"\tthe age is:"+age);
    }
    public void getInfo(){
        System.out.println("=======getInfo start=====");
        System.out.println("the name is:"+this.name+"\tthe age is:"+this.age);
        System.out.println("=======getInfo end=====");
    }


}

概念了协调的首家数据,下面是测试怎么使用

    @Test
    public void test() {
        //User user = new User();
        System.out.println("startTest");
        Class<User> u = User.class;
        try {
            Method method = u.getMethod("getUserInfo", new Class[]{String.class, int.class});
            UserAnnotation userAnnotation = method.getAnnotation(UserAnnotation.class);
            System.out.println("the name is:" + userAnnotation.name() + "the age is:" + userAnnotation.age());
            if (method != null) {
                method.invoke(u.newInstance(), userAnnotation.name(), userAnnotation.age());
            }
            Field fields[] = u.getDeclaredFields();
            Field f = u.getDeclaredField("value");
            UserAnnotation userAnnotation1 = f.getAnnotation(UserAnnotation.class);
            System.out.println("the f name is:" + userAnnotation1.name() + "the f age is:" + userAnnotation1.age());
            for (Field field : fields) {
                if (field.isAnnotationPresent(UserAnnotation.class)) {
                    System.out.println("the name is:" + field.getName());
                    UserAnnotation annotation = field.getAnnotation(UserAnnotation.class);
                    if (annotation != null) {
                        System.out.println("the name is:" + annotation.name() + "the age is:" + annotation.age());
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

获取相应的User Class ,有脚两栽办法

  • 获取Class相关
    1.Class<User> u = User.class; //通过Class直接拿走
    2.Class<User> u = Class.forName(“User”);//通过name获取

  • Class中要运用的措施
    Method[] getMethods() //获取具有的艺术包括父类的不二法门
    Field[] getFields() //获取具有实例变量包括父类的实例
    Field[] getDeclaredFields()//获取具有的法子不包括父类的办法
    Method[] getDeclaredMethods()//获取具有实例变量不包括父类的实例

  • 获取Annotation
    Method.getAnnotation(Annatation.class)//获取方式方面的Annotation
    Field.getAnnotation(Annatation.class)//获取filed上的Annotation

得结果:

the name is:GEAKthe age is:90 //获取到方法上的Annotation
the name is:GEAK    the age is:90//获取到方法上的Annotation
the f name is:wongthe f age is:1000//利用反射的机制来调用方法
the name is:name
the name is:Starthe age is:10//获取对应实例的name上的Annotation
the name is:age
the name is:the age is:100
the name is:value
the name is:wongthe age is:1000

总结:
透过Annotation和反光机制来拓展客观之配备你的源代码.这样就算可以省去大部分底if
else或者初始化等工作.

网站地图xml地图