java-注解-自定义注解-注解解析

注解

1.注解概述

• 注解是JDK1.5的新特性。
• 标记(注解)可以加在包，类，字段，方法，方法参数以及局部变量上。
• 注解是给编译器或JVM看的，编译器或JVM可以根据注解来完成对应的功能。

注解的作用:

​ 1.使用javadoc生成帮助文档：里边可以包含注解**@author和@version**

​ 2.编译检查：@Override @FunctionalInterface

​ 3.框架的配置(框架=代码+配置):框架的时候讲

2.自定义注解(重点)

/*
    自定义注解:定义一个没有属性的注解
    格式:
        public @interface 注解名{
        }
    注意:
        注解使用的也是.java文件,编译生成的也是.class文件
        注解和类和接口和枚举都同一个层次
 */
public @interface MyAnnotation01 {
}

/*
    自定义注解:定义含有属性的注解
        注解的属性,可以看成是抽象方法,但是有默认值
    定义格式:
        public @interface 注解名{
            修饰符 数据类型 属性名();
            修饰符 数据类型 属性名() default 默认值;
        }
        注意:
            1.属性的修饰符固定使用public abstract,可以省略不写,不写默认也是;建议写出,可以增强语句的可读性
            2.属性的数据类型:
                a.基本数据类型(4类8种):byte,short,int,long,float,double,char,boolean
                b.引用类型:String类型,反射类型(Class),注解类型,枚举类型
                c.以及以上所有的类型的一维数组
 */
public @interface MyAnnotation02 {
    //定义一个int类型的属性
    public abstract int a();

    //定一个double类型的属性,并给属性赋默认值8.8
    public abstract double d() default 8.8;

    //定义一个String数组类型的属性
    public abstract String[] arr();

    //定义反射类型的属性(了解)
    //public abstract Class clazz();
    //定义注解类型的属性(了解)
    //public abstract MyAnnotation01 my01();
    //定义枚举类型的属性(了解)
    //public abstract Color c() default Color.RED;
}

/*
    定义枚举
        枚举中的成员变量都是常量
 */
public enum Color {
    /*
        public static final Color RED = new Color();
        public static final Color GREEN = new Color();
     */
    RED,GREEN
}

3.使用自定义注解(重点)

/*
    使用自定义注解
    注解可以使用的位置:
        包上,类上|接口上,成员变量上,成员方法上,构造方法上,局部变量上,方法的参数上...
    注意:
        同一个位置,同名的注解只能使用一次
        不同的位置,同名的注解可以使用多次
    注解的使用格式:
        1.没有属性的注解,通过@注解名可以直接使用
        2.有属性的注解必须使用键值对的方式,给注解中的所有属性赋值之后,才能使用
        格式:
            @注解名(属性名=属性值,属性名=属性值,..属性名=属性值)
            a.有默认值的属性,可以不用赋值,使用默认值
            b.给多个属性赋值中间要使用逗号分隔开
            c.属性是数组类型,属性值需要使用{ }包裹起来;数组只有一个值,可以省略{ }
                arr = {"a","b","c"}  arr={"a"}==> arr="a"
            d.注解中只有一个属性,属性的名叫value,那么赋值的时候可以省略属性名,直接写属性值
              或者注解有其他属性,但是必须有默认值
                value=10==> 10
 */
@MyAnnotation01
@MyAnnotation02(a=10,d=1.1,arr={"a","b","c"})
public class UseMyAnnotation {

    @MyAnnotation01
    @MyAnnotation02(a = 100,arr="aa")
    @MyAnnotation03(aaa=10,value = 20)
    private String name;
    private int age;

    @MyAnnotation01
    @MyAnnotation03(10)
    public UseMyAnnotation() {
    }

    public UseMyAnnotation(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @MyAnnotation01
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//定义只有一个属性的注解,属性名叫value
//也可以有其他的属性,但是属性必须有默认值
public @interface MyAnnotation03 {
    public abstract int aaa() default 100;
    public abstract int value();
}

4.注解练习_定义和使用Book注解

/*
    定义一个注解：Book
        - 包含属性：String value()   书名
        - 包含属性：double price()  价格，默认值为 100
        - 包含属性：String[] authors() 多位作者
 */
public @interface Book {
    //书名
    public abstract String value();
    //价格，默认值为 100
    public abstract double price() default 100;
    //多位作者
    public abstract String[] authors();
}

/*
    使用自定义注解Book
 */

@Book(value = "钢铁是怎样炼成的",authors = "奥斯托洛夫斯基")
public class UseBook {
    @Book(value = "java编程思想",price = 88.8,authors = {"aaa","bbb"})
    public String name;
}

5.元注解

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

/*
    元注解:java已经定义好的注解,可以用来修饰自定义的注解
    1.@Target
        作用：用来标识注解使用的位置，如果没有使用该注解标识，则自定义的注解可以使用在任意位置。
        属性:
            ElementType[] value:只有一个属性名字叫value,使用的时候,给属性赋值直接写属性值即可
            java.lang.annotation.ElementType:是一个枚举,枚举中定义的变量都是常量
                TYPE，类，接口
                FIELD, 成员变量
                METHOD, 成员方法
                PARAMETER, 方法参数
                CONSTRUCTOR, 构造方法
                LOCAL_VARIABLE, 局部变量
      2.@Retention
            作用：用来标识注解的生命周期(有效范围)
            属性:
                RetentionPolicy value:只有一个属性名字叫value,使用的时候,给属性赋值直接写属性值即可
                java.lang.annotation.RetentionPolicy:是一个枚举,枚举中定义的变量都是常量
                     SOURCE：注解只作用在源码阶段(.java文件中)，生成的字节码文件(.class文件中)中不存在
                     CLASS：注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值
                     RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段
 */
@Target({ElementType.TYPE,ElementType.METHOD})//声明自定义注解可以使用在类上和方法上
@Retention(RetentionPolicy.RUNTIME)//声明自定义注解生命周期在.java文件中.class文件中和内存中都有效
public @interface Book {
    //书名
    public abstract String value();
    //价格，默认值为 100
    public abstract double price() default 100;
    //多位作者
    public abstract String[] authors();
}

6.注解解析

import com.zl.demo03Annotation.MyAnnotation01;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;

/*
    注解解析:
        获取注解的属性值
    注解解析底层使用的都是反射技术
    java.lang.reflect.AnnotatedElement接口:在接口中定义了注解解析相关的方法
    接口的实现类:实现类都重写了接口中的方法,都可以使用
        AccessibleObject, Class, Constructor, Field, Method, Package
    接口中的方法:
        boolean isAnnotationPresent(Class annotationClass):判断指定的对象上(Class, Constructor, Field, Method)是否有指定的注解
            参数:
                Class annotationClass:判断哪个注解,就传递哪个注解的class文件对象
                    判断类上,方法上...有没有Book注解,就需要传递Book.class
            返回值:
                有指定的注解,返回true
                没有指定的注解,返回false
        T getAnnotation(Class<T> annotationClass) 获取对象上(Class, Constructor, Field, Method)指定的注解
            参数:
                Class<T> annotationClass:获取哪个注解,就传递哪个注解的class文件对象
                    获取类上,方法上...有没有Book注解,就需要传递Book.class
            返回值:
                T:返回指定的注解,获取不到返回null
        了解:
            Annotation[] getAnnotations()  获取对象上所有公共的注解
            Annotation[] getDeclaredAnnotations() 获取对象上所有声明的注解
 */
@MyAnnotation01
@Book(value = "西游记",price = 66.6,authors = "吴承恩")
public class Demo01ParseAnnotation {

    @Book(value = "水浒传",authors = "施耐庵")
    public void method(){}

    /*
        解析类上的注解
        实现步骤:
            1.获取类的class文件对象
            2.使用class文件对象中的方法isAnnotationPresent判断类上是否有指定的Book注解
            3.如果类上有Book注解,使用class文件对象中的方法getAnnotation获取到Book注解
            4.使用注解名.属性名()获取注解的属性值
     */
    @Test
    public void parseClassAnnotation() throws ClassNotFoundException {
        //1.获取类的class文件对象
        Class clazz = Class.forName("com.zl.demo05Annotation.Demo01ParseAnnotation");
        //2.使用class文件对象中的方法isAnnotationPresent判断类上是否有指定的Book注解
        boolean b = clazz.isAnnotationPresent(Book.class);
        System.out.println(b);
        //3.如果类上有Book注解,使用class文件对象中的方法getAnnotation获取到Book注解
        if(b){
            Book book = (Book)clazz.getAnnotation(Book.class);
            //4.使用注解名.属性名()获取注解的属性值
            String value = book.value();
            System.out.println(value);
            double price = book.price();
            System.out.println(price);
            String[] authors = book.authors();
            System.out.println(Arrays.toString(authors));
        }
    }

    /*
        解析方法上的注解
        实现步骤:
            1.获取类的class文件对象
            2.使用class文件对象中的方法getMethods获取类中所有的公共成员方法,返回一个Method数组
            3.遍历Method数组,获取每一个Method对象
            4.使用Method对象中的方法isAnnotationPresent判断方法上是否有Book注解
            5.如果方法上有Book注解,使用Method对象中的方法getAnnotation获取Book注解
            6.使用注解名.属性名()获取属性的值
     */
    @Test
    public void parseMethodAnnotation(){
        //1.获取类的class文件对象
        Class clazz = Demo01ParseAnnotation.class;
        //2.使用class文件对象中的方法getDeclaredMethods获取类中所有的成员方法,返回一个Method数组
        Method[] methods = clazz.getDeclaredMethods();
        //3.遍历Method数组,获取每一个Method对象
        for (Method method : methods) {
            //4.使用Method对象中的方法isAnnotationPresent判断方法上是否有Book注解
            boolean b = method.isAnnotationPresent(Book.class);
            //System.out.println(method.getName()+"-->"+b);
            if(b){
                //5.如果方法上有Book注解,使用Method对象中的方法getAnnotation获取Book注解
                Book book = method.getAnnotation(Book.class);
                //6.使用注解名.属性名()获取属性的值
                System.out.println(book.value());
                System.out.println(book.price());
                System.out.println(Arrays.toString(book.authors()));
            }
        }
    }
}

7.注解和反射的综合演示

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

//1.自定义一个注解叫MyTest,使用元注解修饰MyTest注解(只能在方法上使用,运行期有效)
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
}

//2.定义一个测试类,在测试类中定义多个方法,让部分方法使用MyTest注解
public class DemoMyTest {
    public void show01(){
        System.out.println("show01方法");
    }

    @MyTest
    public void show02(){
        System.out.println("show02方法");
    }

    @MyTest
    public void show03(){
        System.out.println("show03方法");
    }

    public void show04(){
        System.out.println("show04方法");
    }

    @MyTest
    public void show05(){
        System.out.println("show05方法");
    }
}

import java.lang.reflect.Method;

/*
    注解和反射的综合案例
    需求:
        模拟Junit测试的@Test
        添加了@Test注解的方法,可以运行
        没有添加@Test注解的方法,不可以运行
    分析:
        1.自定义一个注解叫MyTest,使用元注解修饰MyTest注解(只能在方法上使用,运行期有效)
        2.定义一个测试类,在测试类中定义多个方法,让部分方法使用MyTest注解
        3.获取测试类的class文件对象
        4.使用class文件对象中的方法newInstance实例化对象
        5.使用class文件对象中的方法getMethods获取测试类中所有的成员方法,返回一个Method数组
        6.遍历Method数组,获取每一个Method对象
        7.使用Method对象中的方法isAnnotationPresent判断,Method上是否有指定的MyTest注解
        8.如果Method对象上有MyTest注解,使用invoke方法,运行Method
 */
public class Demo01AnnotationTest {
    public static void main(String[] args) throws Exception {
        //3.获取测试类的class文件对象
        Class clazz = Class.forName("com.zl.demo06AnnotationTest.DemoMyTest");
        //4.使用class文件对象中的方法newInstance实例化对象
        Object obj = clazz.newInstance();
        //5.使用class文件对象中的方法getMethods获取测试类中所有的成员方法,返回一个Method数组
        Method[] methods = clazz.getDeclaredMethods();
        //6.遍历Method数组,获取每一个Method对象
        for (Method method : methods) {
            //7.使用Method对象中的方法isAnnotationPresent判断,Method上是否有指定的MyTest注解
            if(method.isAnnotationPresent(MyTest.class)){
                //8.如果Method对象上有MyTest注解,使用invoke方法,运行Method
                method.invoke(obj);
            }
        }
    }
}