Java的注解

1.什么是注解
    语法： @注解名称
    注解的作用：代替配置文件，如xml
    servlet3.0中，就可以用写web.xml,可以使用注解来配置
    注解是由框架来读取的，是给程序看的，而注释是给人看的

2.注解的使用
    *定义注解:框架的工作
    *使用注解:程序员的工作
    *读取注解:框架的工作

3.定义注解类
    class A{}//定义类
    interface B{}//定义接口
    enum C//定义枚举
    @interface MyAnno1{} 就像所有的类都是Object的子类，那么所有的注解都是Annotation的子类

4.使用注解
    注解的作用目标
        *类(接口,枚举)
        *方法
        *参数
        *局部变量
        *构造器
        *包

5.注解的属性
    5.1定义属性的语法：类型 类型名称();
    @interface MyAnno1{
       int a();
       String b();
    }

    5.2在使用注解时，需要给注解的属性赋值
        @MyAnno1(a=100,b="hello")//给注解属性赋值
        public class Demo2 {

        }
    5.3可以在定义注解属性时，给注解属性默认值
        @interface MyAnno2{
            int aa() default 100;//给注解属性默认值
            String bb();
        }
    5.4名为value属性的特权
        如果只给注解中名称为value的属性赋值，那么“value=”可以省略
        例如 @MyAnno3(100)等于 @MyAnno3(value=100)

    5.5注解的属性类型
        *八种基本类型(Integer等包装类型不可以)
        *Class类型
        *枚举类型(enum)
        *注解类型
        *String类型
        *以上任意一种类型的基本数组类型
        /**
         * 注解属性的使用
         * @author ygh
         * 2017年1月19日
         */
        @MyAnno1(
            a=100,
            b="hello",
            c = Demo1.class,
            d=@MyAnno2(a=100,b="ygh"),
            e = MyEnum.A,
            f={"hello","world"}//如果数组的元素为1,那么{}可以省略，可以写成f="hello"
        )
        public class Demo3 {

        }

        @interface MyAnno1{
            int a();
            String b();
            Class c();
            MyAnno2 d();
            MyEnum e();
            String[] f();
        }

        @interface MyAnno2{
            int a();
            String b();
        }

        enum MyEnum{
            A,B,C
        }
6.注解的目标限定以及保存策略
    6.1注解的目标限定:让一个注解只能作用在类上，不能作用在方法上，使用 @Target注解来限定
    @MyAnno1
    public class Demo4 {

        
    //    @MyAnno1//报错，因为限定注解只能作用在类和方法上
        private int a;
        @MyAnno1
        public void fun1(){}
    }

    @Target(value = { ElementType.TYPE, ElementType.METHOD })
    @interface MyAnno1 {
    }

    6.2注解的保存策略
        *源代码文件(SOURCE):注解只在源码中，当编译时就自动忽略了
        *字节码文件(CLASS):注解在源码中，当编译时会存在在class字节码文件中，但JVM加载类时，就好忽略
        *JVM(RUNTIME):注解在源代码中，当编译时会存在在class字节码文件中，并且在JVM加载类时，会把注解加载到JVM内存中（它是唯一可反射注解！）
        

        @Retention(RetentionPolicy.RUNTIME)//设置注解的保留策略
        @interface MyAnno1 {
        }

package cn.itcast.annotation.demo1;

@MyAnno1//注解可以放在类(接口和枚举)上
public class Demo1 {

    @MyAnno1//注解可以放在构造器
    public Demo1(){}
    @MyAnno1//注解可以放在成员变量上面
    private Integer a;
    @MyAnno1//注解可以放在方法上
    public void fun1(@MyAnno1 String str){//注解可以放在方法的形参上
        @MyAnno1//注解可以放在局部变量上
        int a[];
        
//        @MyAnno1 //不能在执行语句上，不让报错
        System.out.println("hello");
    }
}

/**
 * 定义注解，所有的注解都是
 * @author ygh
 * 2017年1月19日
 */
@interface MyAnno1{
    
}

package cn.itcast.annotation.demo2;

@MyAnno1(a=100,b="hello")//给注解属性赋值
@MyAnno2(bb="hello")//有默认值的注解属性可以不赋值
@MyAnno3(100)//如果只给注解中名称为value的属性赋值，那么“value=”可以省略
public class Demo2 {

}

/**
 * 注解属性的定义
 * @author ygh
 * 2017年1月19日
 */
@interface MyAnno1{
   int a();
   String b();
}

@interface MyAnno2{
    int aa() default 100;//给注解属性默认值
    String bb();
}

@interface MyAnno3{
    int value();
    String cc() default "ygh";
}

/**
 * 注解属性的使用
 * @author ygh
 * 2017年1月19日
 */
@MyAnno1(
    a=100,
    b="hello",
    c = Demo1.class,
    d=@MyAnno2(a=100,b="ygh"),
    e = MyEnum.A,
    f={"hello","world"}//如果数组的元素为1,那么{}可以省略，可以写成f="hello"
)
public class Demo3 {

}

@interface MyAnno1{
    int a();
    String b();
    Class c();
    MyAnno2 d();
    MyEnum e();
    String[] f();
}

@interface MyAnno2{
    int a();
    String b();
}

enum MyEnum{
    A,B,C
}

package cn.itcast.annotation.demo4;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@MyAnno1
public class Demo4 {

    
//    @MyAnno1//报错，因为限定注解只能作用在类和方法上
    private int a;
    @MyAnno1
    public void fun1(){}
}

@Target(value = { ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)//设置注解的保留策略
@interface MyAnno1 {
}

@Target注解的源代码

/*
 * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang.annotation;

/**
 * Indicates the kinds of program element to which an annotation type
 * is applicable.  If a Target meta-annotation is not present on an
 * annotation type declaration, the declared type may be used on any
 * program element.  If such a meta-annotation is present, the compiler
 * will enforce the specified usage restriction.
 *
 * For example, this meta-annotation indicates that the declared type is
 * itself a meta-annotation type.  It can only be used on annotation type
 * declarations:
 * <pre>
 *    &#064;Target(ElementType.ANNOTATION_TYPE)
 *    public &#064;interface MetaAnnotationType {
 *        ...
 *    }
 * </pre>
 * This meta-annotation indicates that the declared type is intended solely
 * for use as a member type in complex annotation type declarations.  It
 * cannot be used to annotate anything directly:
 * <pre>
 *    &#064;Target({})
 *    public &#064;interface MemberType {
 *        ...
 *    }
 * </pre>
 * It is a compile-time error for a single ElementType constant to
 * appear more than once in a Target annotation.  For example, the
 * following meta-annotation is illegal:
 * <pre>
 *    &#064;Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD})
 *    public &#064;interface Bogus {
 *        ...
 *    }
 * </pre>
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}

@Target中ElementType的源代码

/*
 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang.annotation;

/**
 * A program element type.  The constants of this enumerated type
 * provide a simple classification of the declared elements in a
 * Java program.
 *
 * <p>These constants are used with the {@link Target} meta-annotation type
 * to specify where it is legal to use an annotation type.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE
}

@Retention的源代码

/*
 * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang.annotation;

/**
 * Indicates how long annotations with the annotated type are to
 * be retained.  If no Retention annotation is present on
 * an annotation type declaration, the retention policy defaults to
 * {@code RetentionPolicy.CLASS}.
 *
 * <p>A Retention meta-annotation has effect only if the
 * meta-annotated type is used directly for annotation.  It has no
 * effect if the meta-annotated type is used as a member type in
 * another annotation type.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    RetentionPolicy value();
}

@Retention中RetentionPolicy 源代码

/*
 * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang.annotation;

/**
 * Annotation retention policy.  The constants of this enumerated type
 * describe the various policies for retaining annotations.  They are used
 * in conjunction with the {@link Retention} meta-annotation type to specify
 * how long annotations are to be retained.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
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,

    /**
     * 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
}