注解学习篇

---

注解的本质是一个接口，应用注解 就是 实现接口的过程；
解析注解 就是 解析注解接口的实现类的内容。

注解学习篇一

定义

注解(Annotation)

就是java代码里的特殊标记，比如：@Override、@Test等。

作用是：让其他程序 根据注解信息 来决定 怎么执行该程序。

运用举例

  

  

注：上面的注解 意在 通知 Junit框架 该方法 需要执行单元测试。

作用位置

注解可以用在类上、构造器上、方法上、成员变量上、参数上、等位置处。

自定义注解

就是自己定义注解。

格式

public @interface 注解名称 {
    public 属性类型 属性名() default 默认值
}

注：特殊属性名：value

如果注解中只有一个value属性(属性名为value)，使用注解时，value名称可以不写!!!

举例

自定义注解一(MyTest1)

package com.xie.annotation;

/**
 * 自定义注解
 * */
public @interface MyTest1 {
    /**
     * 自定义注解的属性
     * */
    String aaa();
    /**
     * 有默认值
     * */
    boolean bbb() default true;
    String[] ccc();
}

自定义注解二(MyTest1)

package com.xie.annotation;

/**
 * 特殊属性 value为名的属性
 * */
public @interface MyTest2 {
    /**
     * 自定义注解的属性
     * */
    String value();
    int age() default 20;
}

应用举例

package com.xie.annotation.test;

import com.xie.annotation.MyTest1;
import com.xie.annotation.MyTest2;

/**
 * 标记类
 * */
//@MyTest2(value = "天")
//@MyTest2(value = "天",age = 23)
@MyTest2("天")
@MyTest1(aaa = "Mrxie",ccc = {"Java", "JavaScript", "HTML"})
public class AnnotationTest1 {
    /**
     * 标记方法
     * */
    @MyTest1(aaa = "后端", bbb = false, ccc = {"前端", "JavaScript", "HTML"})
    public void test() {

    }
}

注解本质

  

  

@注解(…) 本质上 就是一个实现类，接口的实现类。

元注解

举例

  

  

定义

指的是：修饰注解的注解。

常用的元注解

@Target

@Target

注：限定自定义注解的作用范围。

  

  

@Retention

@Retention

注：声明自定义注解的生存周期。

  

  

举例

自定义注解(MyTest3)

package com.xie.annotation;

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

/**
 * 自定义注解
 *
 * @Target 声明此注解可以用于类和方法上，而不能用于成员变量上
 * @Retention 声明此注解可以一直保留到运行时
 * 上面所指的此注解 指的是 该自定义注解 MyTest3
 * */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyTest3 {
}

应用举例

package com.xie.annotation.test;

import com.xie.annotation.MyTest3;

/**
 * 目标：认识元注解，搞清楚 元注解 的作用。
 * */

@MyTest3
public class AnnotationTest2 {
    /**
     * 不能作用于成员变量上
     * */
    // @MyTest3
    private String name;
    @MyTest3
    public void test() {

    }
}

注解的解析

就是判断 类上、方法上、成员变量上 是否存在 注解，并把注解里的内容 给解析出来。

如何解析注解

指导思想：要解析 谁上面的注解，就应该 先拿到 谁。

1. 比如要解析 类上面的注解，则应该先获取该类的Class对象，再通过CLass对象解析 其上面的注解。

2. 比如 要解析 成员方法上的注解，则应该获取到该成员方法的Method对象，再通过 Method对象 解析其上面的注解。

3. 成员变量 同上描述。

4. Class、Method、Field、Constructor、都实现了 AnnotatedElement接口，它们 都拥有 解析注解的能力。

  

  

注：上图解析注解方法对于类，成员变量等是通用的。

解析注解案例

案例要求
  

  

定义注解

package com.xie.annotation;

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

/**
 * 自定义注解
 * */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest4 {
    String value();
    double bbb() default 100;
    String[] ccc();
}

应用注解

package com.xie.annotation;

@MyTest4(value = "中国四大名著", bbb = 99.99 ,ccc = { "西游记", "红楼梦", "三国演义", "水浒传"})
public class Demo {
    @MyTest4(value = "玄幻小说", bbb = 199.99 ,ccc = { "斗罗大陆", "完美世界", "吞噬星空", "斗破苍穹"})
    public void test() {

    }
}

测试解析过程

package com.xie.annotation.test;

import com.xie.annotation.Demo;
import com.xie.annotation.MyTest4;
import org.junit.Test;

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

/**
 * 掌握注解的解析
 * */
public class annotationTest3 {
    /**
     * 解析类上的注解
     * */
    @Test
    public void parseClass() {
        // 1，先得到Class对象
        Class c = Demo.class;
        // 2，解析类上的注解
        // 3，判断类上是否包含了某个注解 是否包含了MyTest4注解
        if (c.isAnnotationPresent(MyTest4.class)) {
            MyTest4 myTest4 = (MyTest4) c.getDeclaredAnnotation(MyTest4.class);
            // 打印注解中的属性或内容
            System.out.println(myTest4.value());
            System.out.println(myTest4.bbb());
            System.out.println(Arrays.toString(myTest4.ccc()));
        }
    }

    /**
     * 解析方法上的注解
     * */
    @Test
    public void parseMethod() throws NoSuchMethodException {
        // 1，先得到Class对象
        Class c = Demo.class;
        // 2，获取Method对象
        Method m = c.getDeclaredMethod("test");
        // 2，解析方法上的注解
        // 3，判断方法上是否包含了某个注解 是否包含了MyTest4注解
        if (m.isAnnotationPresent(MyTest4.class)) {
            MyTest4 myTest4 = (MyTest4) m.getDeclaredAnnotation(MyTest4.class);
            // 打印注解中的属性或内容
            System.out.println(myTest4.value());
            System.out.println(myTest4.bbb());
            System.out.println(Arrays.toString(myTest4.ccc()));
        }
    }
}

注解的应用场景

注：注解是用来配合反射等技术来制作框架的

制作简易版的Junit框架

需求及过程分析

  

  

测试实现

package com.xie.annotation.test;

import com.xie.annotation.MyTest;
import java.lang.reflect.Method;

/**
 * 目标：模拟Junit框架的设计
 * */
public class AnnotationTest4 {
    /**
     * 不加注解
     * */
    public void test1() {
        System.out.println("----------------test1启动执行了!!!----------------");
    }

    /**
     * 加注解
     * */
    @MyTest()
    public void test2() {
        System.out.println("----------------test2启动执行了!!!----------------");
    }

    /**
     * 不加注解
     * */
    public void test3() {
        System.out.println("----------------test3启动执行了!!!----------------");
    }

    /**
     * 加注解
     * */
    @MyTest()
    public void test4() {
        System.out.println("----------------test4启动执行了!!!----------------");
    }

    /**
     * 借助main方法，来启动测试
     * */
    public static void main(String[] args) throws Exception {
        // 1，创建所需对象
        AnnotationTest4 a = new AnnotationTest4();
        // 2，得到Class类
        Class<AnnotationTest4> c = AnnotationTest4.class;
        // 3，获取该类中的全部成员方法
        Method[] methods = c.getDeclaredMethods();
        // 4，遍历该数组中的每一个成员方法，判断是否存在@MyTest()注解
        // 存在就会触发方法执行
        for (Method method : methods) {
            if (method.isAnnotationPresent(MyTest.class)) {
                // 通过进来，就触发方法的执行
                method.invoke(a);
            }
        }
    }
}

参考视频

黑马磊哥