文章目录

• 单元测试
• • 单元测试概述
  • 单元测试快速入门
  • 单元测试常用注解
• 反射
• • 反射概述
  • 反射获取类对象
  • 反射获取构造器对象
  • 反射获取成员变量对象
  • 反射获取方法对象
  • 反射的作用-绕过编译阶段为集合添加数据
  • 反射的作用-通用框架的底层原理
• 注解
• • 注解概述
  • 自定义注解
  • 元注解
  • 注解解析
  • • 案例：注解解析的案例
  • 注解的应用场景一：Junit框架
• 动态代理

单元测试

单元测试概述

单元测试

• 单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。

目前测试方法是怎么进行 的，存在什么问题。

• 只有一个main方法，如果一个方法的测试失败了，其他方法测试都会受到影响。
• 无法得到测试的结果报告，需要程序员自己去观察测试是否成功。
• 无法实现自动化测试。

Junit单元测试框架

• Junit是使用Java语言实现的单元测试框架，它是开源的。
• 几乎所有的IDE工具都集成了Junit，Junit目前最新版本是5

Junit优点

• Junit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。
• Junit可以生成全部方法的测试报告。
• 单元测试中的某个方法测试失效了，不会影响其他测试方法的测试。

小结

1. Junit单元测试是做什么的？
   • 测试类中方法的正确性
2. Junit单元测试的优点是什么？
   • Junit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。
   • Junit可以生成测试报告，如果测试良好则是绿色；如果测试失败则是红色。
   • 单元测试中的某个测试方法失败了，不会影响其他测试方法的测试。

单元测试快速入门

步骤：单元测试快速入门

需求：使用单元测试进行业务方法预期结果、正确性测试

分析：

1. 将Junit的jar包导入到项目中
   • IDEA通常整合好了Junit框架，一般不需要导入。
   • 如果IDEA没有整合好，需要自己手动导入Junit的2个jar包到模块
2. 编写测试方法：该测试方法必须是公共的无参数无返回值的非静态方法
3. 在测试方法上使用@Test注解：标注该方法是一个测试方法
4. 在测试方法中完成被测试方法的预期正确性测试
5. 选择测试方法，选择“Junit运行” ， 如果测试良好则是绿色；如果测试失败，则是红色

/**
 * 业务方法
 */
public class UserService {
    public String loginName(String loginName, String passWord) {
        if ("admin".equals(loginName) && "12345".equals(passWord)) {
            return "登录成功";
        } else {
            return "用户名或者密码有问题！";
        }
    }
    public void selectNames(){
        System.out.println(10/0);
        System.out.println("查询全部用户名称成功！");
    }
}

/**
    测试类
 */
public class TestUserService {
    /**
        测试方法
        注意点：
            1.必须是公开的，无参数，无返回值的方法
            2.测试方法必须使用@Test注解标记
     */
    @Test
    public void testLoginName(){
        UserService userService = new UserService();
        String rs = userService.loginName("admin","123456");

        //进行预期结果的正确性测试：断言
        Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);
    }

    @Test
    public void testSelectNames(){
        UserService userService = new UserService();
        userService.selectNames();
    }
}
output:

output:

单元测试常用注解

Junit常用注解（Junit 4.xxxx版本)

• 开始执行的方法：初始化资源。
• 执行完之后的方法：释放资源。

/**
    测试类
 */
public class TestUserService {
    //修饰实例方法的
    @Before
    public void before(){
        System.out.println("======before方法执行一次=======");
    }

    @After
    public void after(){
        System.out.println("========after方法执行一次=========");
    }

    //修饰静态方法的
    @BeforeClass
    public static void beforeClass(){
        System.out.println("========beforeClass方法执行一次=========");
    }

    @AfterClass
    public static void afterClass(){
        System.out.println("========afterClass方法执行一次=========");
    }
    /**
        测试方法
        注意点：
            1.必须是公开的，无参数，无返回值的方法
            2.测试方法必须使用@Test注解标记
     */
    @Test
    public void testLoginName(){
        UserService userService = new UserService();
        String rs = userService.loginName("admin","123456");

        //进行预期结果的正确性测试：断言
        Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);
    }

    @Test
    public void testSelectNames(){
        UserService userService = new UserService();
        userService.selectNames();
    }
}
output:
========beforeClass方法执行一次=========
======before方法执行一次=======
查询全部用户名称成功！
========after方法执行一次=========
========afterClass方法执行一次=========

Junit常用注解（Junit 5.xxxx版本)

• 开始执行的方法：初始化资源
• 执行完之后的方法：释放资源

反射

反射概述

• 反射是指对于任何一个Class类，在“运行的时候”都可以直接得到这个类的全部成分
• 在运行时，可以直接得到这个类的构造器对象：Constructor
• 在运行时，可以直接得到这个类的成员变量对象：Filed
• 在运行时，可以直接得到这个类的成员方法对象：Method
• 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。

反射的关键：

• 反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。

HelloWorld.java -> javac -> HelloWorld.class
Class c = HelloWorld.class;

1. 反射的基本作用、关键？
   • 反射是在运行时获取类的字节码文件对象：然后可以解析类中的全部成分
   • 反射的核心思想和关键就是：得到编译以后的class文件对象。

反射获取类对象

反射的第一步：获取Class类的对象

public class Test {
    public static void main(String[] args) throws Exception {
        //1.Class类中的一个静态方法：forName(全限名：类名+包名）
        Class c = Class.forName("com.csl.d2_reflect_class.Student");
        System.out.println(c);//Student.class

        //2.类名.class
        Class c2 = Student.class;
        System.out.println(c2);

        //3.对象.getClass()   获取对象对应类的Class对象
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3);
    }
}
public class Student {
}
output:
class com.csl.d2_reflect_class.Student
class com.csl.d2_reflect_class.Student
class com.csl.d2_reflect_class.Student

1. 反射的第一步是什么？
   • 获取Class类对象，如此才可以解析类的全部成分。
2. 获取Class类的对象的三种方式。
   • 方式一：Class c1 = Class.forName(“全类名”);
   • 方式二：Class c2 = 类名.class
   • 方式三：Class c3 = 对象.getClass();

反射获取构造器对象

使用反射技术获取构造器对象并使用

• 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
• Class类中用于获取构造器的方法

public class TestStudent01 {
    //1.getConstructors:
    //获取全部的构造器：只能获取public修饰的构造器
    //Constructor[] getConstuctors()
    @Test
    public void getConstructors() {
        //a.第一步，获取类对象
        Class c = Student.class;
        //b.提取类中的全部构造器对象(这里只能拿public修饰的）
        Constructor[] constructors = c.getConstructors();
        //c.遍历构造器、
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    //2.getDeclaredConstructors();
    //获取全部的构造器，无所谓权限是否可及
    @Test
    public void getDeclraredConstructors() {
        //a.第一步获取类对象
        Class c = Student.class;
        //b.提取类中的全部构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        //c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    //3.getConstructors(Class... parameterTypes)
    //获取某个构造器：只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception {
        //a.获取类对象
        Class c = Student.class;
        //b.定位单个构造器对象(按照参数定位无参数的构造器）
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
    }

    //4.getDeclaredConstructor
    //获取某个构造器：只要存在的都可以拿到不考虑修饰符
    @Test
    public void getDeclaredConstructor() throws Exception {
        //a.获取类对象
        Class c = Student.class;
        //b.定位某个有参构造器
        Constructor cons2 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons2.getName() + "===>" + cons2.getParameterCount());
    }
}

使用反射技术获取构造器对象并使用

• 获取构造器的作用依然是初始化一个对象返回。

Constructor类中用于创建对象的方法

public class Student {
    private String name;
    private int age;

    private Student() {
        System.out.println("无参构造器执行！");
    }

    public Student(String name, int age) {
        System.out.println("有参构造器执行！");
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestStudent02 {
    //1.调用一个构造器得到一个类的对象返回
    @Test
    public void getDeclaredConstructor() throws Exception {
        //a.获取类对象
        Class c = Student.class;
        //b,定位单个构造器对象（按照参数定位无参构造器）
        Constructor cons1 = c.getDeclaredConstructor();
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

        //如果遇到了私有的构造器，可以暴力反射
        cons1.setAccessible(true);//权限打开

        Student s = (Student) cons1.newInstance();
        System.out.println(s);

        //c.定位某个有参构造器
        Constructor cons2 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons2.getName() + "===>" + cons2.getParameterCount());
        Student s1 = (Student) cons2.newInstance("至尊宝", 777);
        System.out.println(s1);
    }
}
output:
com.csl.d3_reflect_constructor.Student===>0
无参构造器执行！
Student{name='null', age=0}
com.csl.d3_reflect_constructor.Student===>2
有参构造器执行！
Student{name='至尊宝', age=777}

1. 利用反射技术获取构造器对象的方式
   • getDeclaredConstructors( )
   • getDeclaredConstructor(Class<?>… parameterTypes)
2. 反射得到的构造器可以做什么？
   • 依然是创建对象的
     • public newInstance(Object… initargs)
   • 如果是非public的构造器，需要打开权限(暴力反射)，然后再创建对象
     • setAccessible(boolean)
     • 反射可以破坏封装性，私有的也可以执行了。

反射获取成员变量对象

使用反射技术获取成员变量对象并使用

• 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
• Class类中用于获取成员变量的方法

public class FiledDemo01 {
    /**
     * 1.获取全部的成员变量
     * Filed[] getDeclaredFileds()
     * 获得所有成员变量对应的Filed对象，只要申明了就能拿到
     */
    @Test
    public void getDeclaredFileds() {
        //a.定位Class对象
        Class c = Student.class;
        //b.定位全部成员变量
        Field[] fields = c.getDeclaredFields();
        //c.遍历一下
        for (Field field : fields) {
            System.out.println(field.getName() + "===>" + field.getType());
        }
    }

    /**
        2.获取某个成员变量对象Filed getDeclaredFiled(String name)
     */
    @Test
    public void getDeclaredFeild()throws Exception{
        //a.定位Class对象
        Class c = Student.class;
        //b,根据名称定位某个成员变量
        Field filed = c.getDeclaredField("age");
        System.out.println(filed.getName()+"===>"+filed.getType());//age===>int
    }
}
output:
age===>int
name===>class java.lang.String
age===>int
schoolName===>class java.lang.String
COUNTTRY===>class java.lang.String

• 获取成员变量的作用依然是在某个对象中取值、赋值

Filed类中用于取值、赋值的方法

/**
 * 反射获取成员变量：取值和赋值
 */
public class FiledDemo02 {
    @Test
    public void setFiled() throws Exception {
        //a.反射第一步，获取类对象
        Class c = Student.class;
        //b.提取某个成员变量
        Field ageF = c.getDeclaredField("age");
        ageF.setAccessible(true);//暴力打开权限
        //c.赋值
        Student s = new Student();
        ageF.set(s,18);//s.setAge(18)
        System.out.println(s);

        //d.取值
        int age = (int) ageF.get(s);
        System.out.println(age);
    }
}
output:
无参构造器执行！
Student{name='null', age=18}
18

小结

1. 利用反射技术获取成员变量的方式
   • getDeclaredFileds( )
   • getDeclaredFiled(String name)
2. 反射得到成员变量可以做什么？
   • 依然是在某个对象中取值和赋值
     • void set(Object obj,Object value):
     • Object get(Object obj)
   • 如果成员变量是非public的，需要打开权限(暴力反射)，然后再取值、赋值
     • setAccessiable(boolean)

反射获取方法对象

使用反射技术获取方法对象并使用

• Class类中用于获取成员方法的方法

public class Dog {
    private String name;

    public Dog() {
    }

    public void run() {
        System.out.println("狗跑的贼快~~~");
    }

    public void eat() {
        System.out.println("狗吃骨头");
    }

    private String eat(String name) {
        System.out.println("狗吃" + name);
        return "吃的很开心！";
    }

    public static void inAddr(){
        System.out.println("我正在自学黑马的课程");
    }

    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

/**
 * 1, 获得类中的所有成员方法对象
 */
@Test
public void getDeclaredMethods() {
    //a.获取类对象
    Class c = Dog.class;
    //b.提取全部方法
    Method[] m = c.getDeclaredMethods();
    //c.遍历全部方法
    for (Method method : m) {
        System.out.println(method.getName() + "返回值类型 " +
                method.getReturnType()+"参数个数 " + method.getParameterCount());
    }
}
output:
getName返回值类型class java.lang.String参数个数0
run返回值类型void参数个数0
setName返回值类型void参数个数1
eat返回值类型class java.lang.String参数个数1
eat返回值类型void参数个数0
inAddr返回值类型void参数个数0

• 获取成员方法的作用依然是在某个对象中进行执行此方法

Method类中用于触发执行的方法

    /**
        2,获取某个方法对象
     */
    @Test
    public void getDeclaredMethod()throws Exception{
        //a.获取类对象
        Class c = Dog.class;
        //b.提取单个方法
        Method m1 = c.getDeclaredMethod("eat");
        Method m2 = c.getDeclaredMethod("eat", String.class);

        m1.setAccessible(true);
        //c.触发方法的执行
        Dog d = new Dog();
        Object result = m1.invoke(d);
        System.out.println(result);

        m2.setAccessible(true);
        Object result2 = m2.invoke(d,"骨头");
        System.out.println(result2);
    }
}
output:
狗吃骨头
null
狗吃骨头
吃的很开心！

小结：

1. 利用反射技术获取成员方法对象的方式

• 获取类中成员方法对象
  • getDeclaredMethods( )
  • getDeclaredMethod(String name,Class<?>… parameterTypes)

2. 反射得到成员方法可以做什么？

• 依然是在某个对象中触发该方法执行
  • Object invoke(Object obj, Object… args)
• 如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
  • setAccessible(boolean)

反射的作用-绕过编译阶段为集合添加数据

• 反射的作用是在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。

ArrayList<Integer> list = new ArrayList<>();
list.add(100);
list.add("csl");//报错
list.add(99);

• 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真是类型都是ArrayList了，泛型相当于被擦除了。。

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        //反射实现泛型擦除后，加入其它的类型
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();

        System.out.println(list1.getClass());
        System.out.println(list2.getClass());

        System.out.println(list1.getClass() == list2.getClass());//ArrayList.class

        System.out.println("=================");
        ArrayList<Integer> list3 = new ArrayList<>();
        list3.add(22);
        list3.add(23);
//        list2.add("csl");
        Class c = list3.getClass();//ArrayList.class ==> public boolean add(E e)
        //定义c类中的add方法
        Method add = c.getDeclaredMethod("add",Object.class);
        boolean rs = (boolean) add.invoke(list3, "csl");
        System.out.println(rs);
        System.out.println(list3);

        ArrayList list4 = list3;
        list4.add("csl");
        list4.add(false);
        System.out.println(list3);
    }
}
output:
class java.util.ArrayList
class java.util.ArrayList
true
=================
true
[22, 23, csl]
[22, 23, csl, csl, false]

1.反射为何可以给约定了泛型 的集合存入其他类型的元素？

• 编译成class文件进入编译阶段的时候，泛型会自动擦除。
• 反射是作用在运行时的技术，此时已经不存在泛型了。

反射的作用-通用框架的底层原理

案例：反射做通用框架

需求：给你任意一个对象，在不清楚对象字段的情况下，可以把对象的字段名称和对应值存储到文件中去。

分析：

1. 定义一个方法，可以接受任意类型的对象。
2. 每次接收到一个对象后，需要解析这个对象的全部成员变量名称。
3. 这个对象可能是任意的，那么怎样才可以知道这个对象的全部成员变量名称呢？
4. 使用反射获取对象的Class类对象，然后获取全部的成员变量信息
5. 遍历成员变量信息，然后提取本成员变量在对象中的具体值。
6. 存入成员变量名称和值到文件中去即可

• 任意定义一个学生类，老师类

public class Student {
    private String name;
    private char sex;
    private int age;
    private String className;
    private String hobby;

    public Student() {
    }

    public Student(String name, char sex, int age, String className, String hobby) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.className = className;
        this.hobby = hobby;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                ", className='" + className + '\'' +
                ", hobby='" + hobby + '\'' +
                '}';
    }
}

public class Teacher {
    private String name;
    private double saraly;
    private char sex;

    public Teacher() {
    }

    public Teacher(String name, double saraly, char sex) {
        this.name = name;
        this.saraly = saraly;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public double getSaraly() {
        return saraly;
    }

    public void setSaraly(double saraly) {
        this.saraly = saraly;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", saraly=" + saraly +
                ", sex=" + sex +
                '}';
    }
}

• 编写一个工具类

public class MybatisUtil {
    /**
     * 保存任意类型的对象
     *
     * @param obj
     */
    public static void save(Object obj) {
        try (
                PrintStream ps = new PrintStream(new FileOutputStream("junit-reflect-annotation-proxy-app/src/data.txt", true));
        ) {
            //1.提取这个对象的全部成员变量，只有反射可以解决
            Class c = obj.getClass();
            ps.println("===========" + c.getSimpleName() + "==========");//(c.getSimpleName()获取当前类， c.getName获取全限名：包名+类名）
            //2.提取全部类的成员变量
            Field[] fields = c.getDeclaredFields();
            //3.遍历，获取成员变量的信息
            for (Field field : fields) {
                String name = field.getName();
                //提取本成员变量在obj对象中的值（取值）
                field.setAccessible(true);
                String value = field.get(obj) + "";
                ps.println(name + "=" + value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

• 来测试

/**
    提供一个通用框架，支持保存所有对象的信息
 */
public class ReflectDemo {
    public static void main(String[] args) {
        Student s = new Student("csl",'男',25,"十三班","钓鱼");
        MybatisUtil.save(s);

        Teacher t = new Teacher("王老师",6666,'女');
        MybatisUtil.save(t);
    }
}
output:
===========Student==========
===========Teacher==========
===========Student==========
name=csl
sex=男
age=25
className=十三班
hobby=钓鱼
===========Teacher==========
name=王老师
saraly=6666.0
sex=女

小结

——反射的作用

• 可以在运行时得到一个类的全部成分然后操作。
• 也可以破坏封装性
• 也可以破坏泛型的约束性
• 更适合的用途适合：做Java高级框架

注解

注解概述

• Java注解（Annotation）又称Java标注，是JDK5.0引入的一种注释机制。
• Java语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。

注解的作用是什么呢？

• 对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底作何种处理由业务需求来决定。
• 例如：Junit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

自定义注解

自定义注解——格式

• 就是自己做一个注解来使用

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

• 自定义一个注解

public @interface MyBook {
    String name();
    String[] authors();
    double price();
}

/**
    自定义注解
 */
@MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)
public class AnnotationDemo1 {

    @MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)
    private AnnotationDemo1(){

    }

    @MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)
    public static void main(String[] args) {
        
     @MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)
        int age = 23;
    }
}

特殊属性

• value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写！！
• 但是如果有多个属性，且多个属性没有默认值，那么value名称是不能省略的。

元注解

• 元注解：就是注解 注解的注解。

元注解有两个：

• @Target：约束自定义注解只能在哪些地方使用
• @Retention：申明注解的声明周期

/**
    元注解
 */
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest {
}

//@MyTest//报错
public class AnnotationDemo2 {
    @MyTest
    public AnnotationDemo2(){

    }
    @MyTest
    public static void main(String[] args) {
    }
}

@Target中可以使用的值定义在ElementType枚举类中，常用值如下

• TYPE，类，接口
• FIELD，成员变量
• METHOD，成员方法
• PARAMETER，方法参数
• CONSTRUCTOR，构造器
• LOCAL_VARIBLE，局部变量

@Retention中可以使用的值定义在RetentionPolicy枚举类中，常用值如下

• SOURCE：注解只作用在源码阶段，生成的字节码文件中不存在
• ClASS：注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值。
• RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）

注解解析

注解的解析

• 注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。

与注解解析相关的接口

• Annotation：注解的顶级接口，注解都是Annotation类型的对象
• AnnotatedElement：该接口定义了与注解解析相关的解析方法

• 所有类成分Class，Method，Field，Constructor，都实现了AnnotatedElement接口他们都拥有解析注解的能力：

解析注解的技巧

• 注解在哪个成分上，我们就先拿哪个成分对象。
• 比如注解作用成员方法，则要获得该成员方法对于的Method对象，再来拿上面的注解
• 类和成员变量如上

案例：注解解析的案例

**需求：**注解解析的案例

分析：

1. 定义注解Book ，要求如下：
   1. 包含属性：String value( ) 书名
   2. 包含属性：double price( ) 价格
   3. 包含属性： String[ ] authors( ) 多位作者
   4. 限制注解使用的位置：类和成员方法上
   5. 指定注解的有效范围：RUNTIME
2. 定义BookStores类，在类和成员方法上使用Book注解
3. 定义AnnotationDemo01测试类获取Book注解上的数据

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface Book {
    String value();//书名
    double price();//价格
    String[] authors();//多位作者
}

/**
 * 完成注解的解析
 */
public class AnnotationDemo03 {
    @Test
    public void parseClass() {
        //a.先得到类对象
        Class c = BookStore.class;
        //b.判断这个类上是否有Book.class这个注解
        if (c.isAnnotationPresent(Book.class)) {
            Book book = (Book) c.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.authors()));
        }
    }
    @Test
    public void parseMethod() throws Exception {
        //a.先得到类对象
        Class c = BookStore.class;
        Method m = c.getDeclaredMethod("test");
        //b，判断这个类上是否有这个注解
        if (m.isAnnotationPresent(Book.class)){
            //c.直接获取注解对象
            Book book = (Book) m.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.authors()));
        }
    }
}

@Book(value = "《开端》", price = 100.9, authors = {"赵今麦", "白敬亭"})
class BookStore {

    @Book(value = "《葫芦娃》", price = 99.0, authors = {"水娃", "小金刚", "铁头娃"})
    public void test() {
    }
}

output:
《开端》
100.9
[赵今麦, 白敬亭]
《葫芦娃》
99.0
[水娃, 小金刚, 铁头娃]

注解的应用场景一：Junit框架

模拟Junit框架

需求：

• 定义若干个方法，只要加了MyTes1t注解，就可以在启动时被触发执行

分析：

1. 定义一个自定义注解MyTest1，只能注解方法，存活范围一直都在。
2. 定义若干个方法，只要有@MyTest1注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行

@Target({ElementType.METHOD})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest1 {
}

public class AnnotationDemo4 {
    @MyTest1
    public void test1(){
        System.out.println("========test1========");
    }

    public void test2(){
        System.out.println("========test2========");
    }

    @MyTest1
    public void test3(){
        System.out.println("========test3========");
    }

    public static void main(String[] args) throws Exception {
        AnnotationDemo4 t = new AnnotationDemo4();
        //a.获取类对象
        Class c = AnnotationDemo4.class;
        //b.提取全部方法
        Method[] methods = c.getDeclaredMethods();
        //c.遍历方法，判断方法中是否有该注解，有就跑它
        for (Method method : methods) {
            if (method.isAnnotationPresent(MyTest1.class)){
                method.invoke(t);
            }
        }
    }
}
output:
========test3========
========test1========

动态代理

案例：模拟企业业务功能开发，并完成每个功能的性能统计

需求：

• 模拟某企业用户管理业务，需要包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。

分析：

• 定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。
• 定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时。
• 定义测试类，创建实现类现象，调用方法。

/**
    模拟用户业务功能
 */
public interface UserSerivce {
    String login(String loginName,String passWord);
    void selectUsers();
    boolean delUsers();
}

package com.csl.d9_proxy;

public class UserSerivceImpl implements UserSerivce {
    @Override
    public String login(String loginName, String passWord) {
        long startTime = System.currentTimeMillis();
        try {
            Thread.sleep(1000);
            if ("admin".equals(loginName) && "12345".equals(passWord)) {
                return "success";
            }
            return "登录名或密码有问题！";
        } catch (Exception e) {
            e.printStackTrace();
            return "error";
        } finally {
            long endTime = System.currentTimeMillis();
            System.out.println("login方法耗时：" + (endTime - startTime) / 1000.0 + "s");
        }
    }

    @Override
    public void selectUsers() {
        long startTime = System.currentTimeMillis();
        System.out.println("查询了一百个用户！");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("selectUsers方法耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    @Override
    public boolean delUsers() {
        long startTime = System.currentTimeMillis();
        try {
            System.out.println("删除了一百个数据！");
            Thread.sleep(500);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            long endTime = System.currentTimeMillis();
            System.out.println("delUsers方法耗时：" + (endTime - startTime) / 1000.0 + "s");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        UserSerivce userSerivce = new UserSerivceImpl();
        System.out.println(userSerivce.login("admin", "12345"));
        userSerivce.selectUsers();
        System.out.println(userSerivce.delUsers());
    }
}
output:
login方法耗时：1.019s
success
查询了一百个用户！
selectUsers方法耗时：2.011s
删除了一百个数据！
delUsers方法耗时：0.502s
true

动态代理

• 代理就是被代理者没有能力或者不愿意去完成某件事，需要找个人替自己去完成这件事，动态代理就是用来对业务功能（方法）进行代理的。

关键步骤

1. 必须有接口，实现类要实现接口（代理通常是基于接口实现的）

2. 创建一个实现类对象，该对象为业务对象，紧接着为业务对象做一个代理对象

/**
    模拟用户业务功能
 */
public interface UserSerivce {
    String login(String loginName,String passWord);
    void selectUsers();
    boolean delUsers();
}

package com.csl.d9_proxy;

public class UserSerivceImpl implements UserSerivce {
    @Override
    public String login(String loginName, String passWord) {
        try {
            Thread.sleep(1000);
            if ("admin".equals(loginName) && "12345".equals(passWord)) {
                return "success";
            }
            return "登录名或密码有问题！";
        } catch (Exception e) {
            e.printStackTrace();
            return "error";
        }
    }

    @Override
    public void selectUsers() {

        System.out.println("查询了一百个用户！");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public boolean delUsers() {
        try {
            System.out.println("删除了一百个数据！");
            Thread.sleep(500);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

package com.csl.d9_proxy;

public class Test {
    public static void main(String[] args) {
        UserSerivce userSerivce = ProxyUtil.getProxy(new UserSerivceImpl());
        System.out.println(userSerivce.login("admin", "12345"));
        userSerivce.selectUsers();
        System.out.println(userSerivce.delUsers());
    }
}
output:
login方法耗时：1.012s
success
查询了一百个用户！
selectUsers方法耗时：2.01s
删除了一百个数据！
delUsers方法耗时：0.502s
true

/**
 * public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
 * 参数一：类加载器，负责加载代理类到内存中使用
 * 参数二：获取被代理对象实现的全部接口。代理要为全部接口的全部方法进行代理
 * 参数三：代理的核心处理逻辑
 */
public class ProxyUtil {
    /**
     * 生成业务对象的代理对象
     *
     * @param obj
     * @return
     */
    public static <T> T getProxy(T obj) {
        //  返回了一个代理对象
        return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //参数一：代理对象本身
                        //参数二：正在被代理的方法
                        //参数三：被代理方法应该传入的参数
                        long startTime = System.currentTimeMillis();
                        // 马上触发方法的真正执行(触发真正的业务功能）
                        Object result = method.invoke(obj, args);
                        long endTime = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时：" + (endTime - startTime) / 1000.0 + "s");

                        //把业务功能方法执行的结果返回给调用者
                        return result;
                    }
                });

    }
}

动态代理的优点

• 非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接口本身做代理。
• 可以为被代理对象的所有方法做代理
• 可以在不改变方法源码的情况下，实现对方法功能的增强。
• 不仅简化了编程工作、提高了软件系统的可拓展性，同时也提高了开发效率。