java注解

java注解篇

什么是注解？

注释是给开发者看的，可以提升代码的可阅读性和可维护性，但是对于java编译器和虚拟机来说是没有意义的，编译后的字节码文件中没有任何注释信息。 而注解和注释有些类似，不过注解是给编译器和虚拟机看的。编译器和虚拟机可以在运行过程中获取注解信息，然后根据注解信息做各种想做的事。

注解如何使用？

• 定义注解
• 使用注解
• 通过注解获取信息做各种想做的事

定义注解

下面定义了一个自定义注解：

public @interface Anno0 {
    String value() default "";
}

注解的定义需要注意：

• 注解的定义和普通的类，接口一样，不过注解的关键字是 @interface。
• 注解的方法修饰符必须且只能为public, 不能有其他的修饰符如static，final，private等。默认为public。
• 注解的方法类型只能为基本数据类型、枚举、Class、String、注解及以上类型的一维数组类型。
• 方法名后的()不是定义参数的地方，也不能在里面定义任何参数。如value()、name()。方法名表示注解的属性。
• defult表示默认值, 默认值得类型必须和前面定义的类型一样。如value属性的类型是String, 默认值是空的字符串 ""。
• 如果没有默认值，使用注解时，必须要为属性赋值。如果只有一个属性时，将属性名设为value，使用时可以省略属性名。如下：

public @interface Anno1 {
    
    String value();

    String name() default "";
}
public @interface Anno2 {

    String name();
}
// 注解的使用
@Anno1(value = "value属性没有默认值必须要传值")
public class AnnoTest {
}
@Anno1(value = "value属性没有默认值必须要传值",name = "覆盖掉默认的name属性值")
public class AnnoTest {
}
@Anno0("不写赋值的属性名称时，默认给value赋值，必须保证有value这个属性")
public class AnnoTest {
}
@Anno2(name = "必须有属性名为value()时，才可以忽略不写属性名,括号内直接赋值")
public class AnnoTest {
}

使用注解

使用target注解标注注解的使用范围：

@Target(ElementType.TYPE)
public @interface Anno0 {

    String value() default "";
}

ElementType取值：

public enum ElementType {
    /** 类、接口（包括注解类型）、枚举类上 */
    TYPE,

    /** 字段（包括常量）上 */
    FIELD,

    /** 方法上 */
    METHOD,

    /** 方法参数上 */
    PARAMETER,

    /** 构造方法上 */
    CONSTRUCTOR,

    /** 本地变量上 */
    LOCAL_VARIABLE,

    /** 注解上 */
    ANNOTATION_TYPE,

    /** 包上 */
    PACKAGE,

    /**
     * 类型参数上
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * 使用到类型的任意语句中
     * @since 1.8
     */
    TYPE_USE
}

使用Retention注解表示该注解的生效范围

@Retention(RetentionPolicy.RUNTIME)
public @interface Anno0 {

    String value() default "";
}

RetentionPolicy的取值：

public enum RetentionPolicy {
    /**
     * 只在源码中生效，编译及运行时就丢失了，也就是class文件中就不存在了。
     */
    SOURCE,

    /**
     * 注解会被保留在编译后的class文件中,但是不会被保留在VM虚拟机在运行阶段
     */
    CLASS,

    /**
     * 注解在源码，class字节码以及运行阶段都存在
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

正常情况下，自定义注解上都要标注target和retention注解。

无参数

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno2 {
}
// 使用注解
@Anno2
public class AnnoTest {
}

一个参数的

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno0 {

    String value() default "";
}
@Anno0("属性名为value可以省略")
public class AnnoTest {
}

多个参数

public @interface Anno1 {

    String value();

    String name() default "";
}

@Anno1(value = "属性名为value可以省略",name = "多个参数注解要指定属性名")
public class AnnoTest {
}

数组类型参数

public @interface Anno3 {
    
    String[] name() default {};
}

@Anno3(name = {"数组类型", "以逗号分隔", "大括号{}包裹"})
public class AnnoTest {
}
// 当只有一个值时可以省略大括号
@Anno3(name= "数组类型")
public class AnnoTest {
}
// 当属性名为value时，可以省略
@Anno3({"数组类型", "属性值为value省略"})
public class AnnoTest {
}
// 只有一个值
@Anno3("数组类型")
public class AnnoTest {
}

不同ElementType的用法

// Type 类型可以用在类，接口，注解，枚举类型上
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno4 {
    
    String name();
}
@Anno4(name = "用在注解上")
public @interface AnnoTest{}
@Anno4(name = "用在类上")
class TypeTest{}
@Anno4(name = "用在接口上")
interface InterfaceTest{}
@Anno4(name = "用在枚举上")
enum EnumTest{}                                                                                                                                  

@Target({ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR, 
        ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno5 {
    String name();
}
public class AnnotationTest {

    @Anno5(name = "作用在字段上")
    private String name;
    
    @Anno5(name = "作用在构造方法上")
    AnnotationTest(){}

    @Anno5(name = "作用在方法上")
    void fun1(@Anno5(name = "作用在参数上") String param) {
        
        @Anno5(name = "作用在本地变量") 
        int i = 1;
    }
}

jdk8新增了TYPE_PARAMETER和TYPE_USE类型

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno6 {

    String value() default "";
}

abstract class Test<@Anno6("作用在泛型参数上=TYPE_PARAMETER") K,V>{

    abstract K fun1(V v);
}
class Test1{
    public static void main(String[] args) {
        
        Test<@Anno6("作用在类型参数上=TYPE_USE")String, Integer> test = new Test<String, Integer>() {
            @Override
            @Anno6("作用在类型参数上=TYPE_USE") String fun1( @Anno6("作用在类型参数上=TYPE_USE")Integer integer) {
                return String.valueOf(integer);
            }
        };
    }
}

注解信息的获取

为了运行时能准确获取注解的信息，Java在java.lang.reflect反射包下新增了AnnotatedElement接口，他主要用于表示目前正在虚拟机中运行的程序中已 使用注解的元素，通过该接口提供的方法可以利用反射技术读取注解信息。 

• Package: 用来表示包信息
• Class: 用来表示类信息
• Constructor: 用来表示构造方法信息
• Field: 用来表示类中的属性信息
• Method: 用来表示方法信息
• Parameter: 用来表示方法参数信息
• TypeVariable: 用来表示类型变量信息,如类上定义的泛型类型变量，方法上定义的泛型变量

AnnonatedElement常用方法

返回值	方法名称	说明
A extends Annotation	getAnnotation(Class AnnotationClass)	该元素如果存在指定类型的注解，则返回该注解，否则返回null
Annotation[]	getAnnotations()	返回此元素上的所有注解，包括从父类上继承的
boolean	isAnnotationPresent(Class<? extends Annotation> annotationClass)	如果指定类型的注解存在此元素上，则返回true，否则false
Annotation[]	getDeclaredAnnotations()	返回直接存在此元素上的所有注解，不包括父类继承的注解。

使用案例：

public class AnnotationUseTest {
    public static void main(String[] args) {

        Anno4 anno4 = A.class.getAnnotation(Anno4.class);
        System.out.println("获取类A上的Anno4注解信息:" + anno4.name());
        Annotation[] annotations = A.class.getAnnotations();
        System.out.println("获取类A上的所有注解：");
        for (Annotation annotation : annotations) {
            System.out.println("类A上的注解：" + annotation);
        }
        Anno4 annotation = AnnoTest.class.getAnnotation(Anno4.class);
        System.out.println("获取AnnoTest注解上的Anno4注解的信息:" + annotation);

        Field desc = ReflectionUtils.findField(A.class, "desc");
        Optional.ofNullable(desc).ifPresent(a -> {
            System.out.println("字段上的注解:" + a.getAnnotation(Anno5.class));
            System.out.println(a.getAnnotatedType().getAnnotation(Anno6.class));
        });

        Constructor<?> constructor = A.class.getDeclaredConstructors()[0];
        Anno5 annotation1 = constructor.getAnnotation(Anno5.class);
        System.out.println("构造方法上的注解：" + annotation1);

        Method setDesc = ReflectionUtils.findMethod(A.class, "setDesc", String.class);
        Optional<Method> method = Optional.ofNullable(setDesc);
        method.ifPresent(f -> System.out.println("方法上的注解：" + f.getAnnotation(Anno5.class)));
        Annotation annotation2 = method.map(f -> f.getParameters()[0]).map(f -> f.getAnnotations()[0]).get();
        System.out.println("作用在方法参数上：" + annotation2);

        Anno6 annotation3 = B.class.getTypeParameters()[0].getAnnotation(Anno6.class);
        System.out.println("类型参数上的注解--TYPE_PARAMETER：" + annotation3);

        Method test = ReflectionUtils.findMethod(A.class, "test");
        Optional.ofNullable(test).ifPresent(f ->
                System.out.println(f.getAnnotatedReturnType().getAnnotation(Anno6.class))
        );

    }
}

@Anno4(name = "用在类上的注解")
class A {

    @Anno5(name = "用在类属性上")
    private @Anno6("用在成员变量类型上--TYPE_USE") String desc;

    @Anno5(name = "用在构造方法上")
    A() {
    }

    @Anno5(name = "用在方法上")
    void setDesc(@Anno5(name = "用在方法参数上") String desc) {
        @Anno5(name = "用在本地变量上") Integer aa = 0;

        this.desc = desc;
    }

    @Anno6("用在返回类型上") String test() {
        @Anno6("用在局部变量类型上--TYPE_USE") String name = "aaa";
        return "";
    }
}

interface B<@Anno6("作用在类型参数上") String>{

}

@Inherit 类之间注解的继承

首先看这个注解的源码：

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

根据ElementType的值可以知道这个注解是专门作用在注解上的。
作用：让子类可以继承父类中被@Inherited修饰的注解。注意是继承父类的，如果接口上的注解也用@Inherited修饰了，那么接口的实现类无法继承这个注解 首先我们看不加这个注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno7 {
    
    String[] notes() default {};

    String desc() default "";
}

自定义一个注解。首先来看不加这个注解的效果

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno7 {

    String[] notes() default {};

    String desc() default "";
}

@Anno7(desc = "不加Inherited")
abstract class AbstractAnno7{

}
public class Anno7Test extends AbstractAnno7 {

    public static void main(String[] args) {
            Annotation[] annotations = Anno7Test.class.getAnnotations();
            // annotations数组为空数组，因此无结果打印
            for (Annotation annotation : annotations) {
                System.out.println(annotation);
            }
        }

}

可以看到我们获取不到父类的注解信息。下面在试试加上这个注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Anno7 {

    String[] notes() default {};

    String desc() default "";
}

再次执行上面的main方法：

@Anno7(desc = "加Inherited")
abstract class AbstractAnno7{

}
public class Anno7Test extends AbstractAnno7 {

    public static void main(String[] args) {
        Annotation[] annotations = Anno7Test.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);//@com.xiazhi.annocation.Anno7(desc=加Inherited, notes=[])
        }
    }
}

再试下在接口上使用该注解：

@Anno7(desc = "使用在接口上")
interface IAnno7{}
public class Anno7Test implements IAnno7 {

    public static void main(String[] args) {
        Annotation[] annotations = Anno7Test.class.getAnnotations();
        // 无结果
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }

}

Repeatable 重复使用注解

定义注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno8 {
}

看下面一段代码：

@Anno8
@Anno8 // 这里会报错
public class Anno8Test {
}

默认情况下，注解是不允许重复使用的，如果我们想像上面一样重复使用注解，需要添加Repeatable注解 看一下Repeatable注解：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    /**
     * Indicates the <em>containing annotation type</em> for the
     * repeatable annotation type.
     * @return the containing annotation type
     */
    Class<? extends Annotation> value();
}

注意value是没有默认值的，因此使用时要对value属性赋值。值是一个容器注解。容器注解的定义要求如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno8s {

    Anno8[] value();
}

容器注解必须有一个value参数，参数类型为子注解类型的数组。 使用Repeatable注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Anno8s.class)
public @interface Anno8 {
}

@Anno8
@Anno8
public class Anno8Test {
}

此时使用重复注解就不会报错了。

spring对于注解的增强

要先导入spring-core的依赖。 首先我们来看一个问题：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface A1{
    String value() default "a1";
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A1
@interface B1{
    String value() default "b1";
}

@B1("hello")
public class DemoTest {

    public static void main(String[] args) {
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(DemoTest.class, B1.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(DemoTest.class,A1.class));
    }
}

AnnotatedElementUtils是spring封装的工具类。此时有个问题，如果我们像要在给B1赋值的时候同时给B1上的A1设置值，是没有办法的，这是由于注解定义 无法继承导致的。Spring通过Aliasfor注解解决了这个问题。 通过Aliasfor解决上面的问题：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface A1{
    String value() default "a1";
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A1
@interface B1{

    String value() default "b1";

    @AliasFor(value = "value",annotation = A1.class)
    String a1Value();
}

@B1(value = "hello", a1Value = "给A1的value赋值")
public class DemoTest {

    public static void main(String[] args) {
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(DemoTest.class, B1.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(DemoTest.class, A1.class));
    }
}

运行结果：

@com.xiazhi.annocation.B1(value=hello, a1Value=给A1的value赋值)
@com.xiazhi.annocation.A1(value=给A1的value赋值)

我们看一下使用Aliasfor的地方的代码：

@AliasFor(value = "value",annotation = A1.class)
String a1Value();

annatation表示要给哪儿个注解赋值，value表示注解的方法，本例中我们要将a1Value()的值赋值给A1注解的value方法。

Aliasfor 注解

看一下Aliasfor注解：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface AliasFor {
    @AliasFor("attribute")
    String value() default "";

    @AliasFor("value")
    String attribute() default "";

    Class<? extends Annotation> annotation() default Annotation.class;
}

在value和attribute方法上使用了Aliasfor注解，说明给value赋值时同时就会给attribute赋值，给attribute赋值时同时会给value赋值

在同一个注解中使用Aliasfor

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface An{

    @AliasFor("value")
    String name() default "";

    @AliasFor("name") //如果不指定annotation属性，则默认是当前注解，如果不指定value和attribute，则自动将修饰的参数作为value和attribute的值
    String value() default "";
}

@An(value = "hello")//同一个注解内设置Aliasfor注解时，如果给两个属性都赋值会报错
public class DemoTest2 {

    public static void main(String[] args) {
        An mergedAnnotation = AnnotatedElementUtils.getMergedAnnotation(DemoTest2.class, An.class);
        System.out.println(mergedAnnotation);
    }
}