反射, 注解, 动态代理

文章目录

- 单元测试
- - 什么是单元测试
  - 咱们之前是如何进行单元测试的？有啥问题？
  - 现在使用方法进行测试
  - 优点
  - Junit单元测试的使用步骤
  - 删除不需要的jar包
  - 总结
- 反射
- - 认识反射、获取类
  - - 什么是反射
    - 反射具体学什么？
    - 反射第一步：或者Class对象
  - 获取类中的成分、并对其进行操作
  - - 获取类中构造器
    - 获取类的成员变量
    - 获取类的成员方法
  - 作用、应用场景
  - - 使用反射做一个简易版的框架
- 注解
- - 注解概述
  - - 注解概述-自定义注解
    - 注解概述-注解的原理
    - 注解的作用
  - 元注解
  - - 元注解是什么
  - 注解的解析
  - - 如何解析注解？
    - 解析注解的案例
    - 总结
  - 作用、应用场景
- 动态代理(设计模式)
- - 程序为什么需要代理？代理长什么样？
  - - 什么是代理
    - 如何为Java对象创建一个代理对象？
    - 代码
    - 代码运行流程
  - 解决实际问题、掌握使用代理的好处

这些是源码、框架、架构师层面的技术

单元测试

什么是单元测试

就是针对最小的功能单元:方法，编写测试代码对其进行正确性测试。也就是测试类中方法的正确性的。

咱们之前是如何进行单元测试的？有啥问题？

只能在main方法编写测试代码，去调用其他方法进行测试。
无法实现自动化测试，一个方法测试失败，可能影响其他方法的测试。(报错就无法继续进行了)
无法得到测试的报告，需要程序员自己去观察测试是否成功。(一个一个写main方法进行测试很麻烦)

现在使用方法进行测试

可以用来对方法进行测试，它是第三方公司开源出来的（很多开发工具已经集成了Junit框架，比如IDEA）

优点

可以灵活的编写测试代码，可以针对某个方法执行测试，也支持一键完成对全部方法的自动化测试，且各自独立。
不需要程序员去分析测试的结果，会自动生成测试报告出来。如果测试良好则是绿色；如果测试失败，则是红色。
单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。

在这里插入图片描述

Junit单元测试的使用步骤

需求

某个系统，有多个业务方法，请使用Junit单元测试框架，编写测试代码，完成对这些方法的正确性测试。
具体步骤

将Junit框架的jar包导入到项目中（注意：IDEA集成了Junit框架，不需要我们自己手工导入了）
为需要测试的业务类，定义对应的测试类，并为每个业务方法，编写对应的测试方法（必须：公共、无参、无返回值）
测试方法上必须声明@Test注解，然后在测试方法中，编写代码调用被测试的业务方法进行测试；
开始测试：选中测试方法，右键选择“JUnit运行” ，如果测试通过则是绿色；如果测试失败，则是红色

业务

// StringUtil.java
/**
 * 字符串工具类
 */
public class StringUtil {
    public static void printNumber(String name){
        if(name == null){
            System.out.println("参数为null！请注意");
            return;
        }
        System.out.println("名字长度是：" + name.length());
    }

    /**
     * 求字符串的最大索引
     */
    public static int getMaxIndex(String data){
        if(data == null || "".equals(data)) {
            return -1;
        }
        return data.length() - 1;
    }
}

测试

// StringUtilTest.java
import org.junit.Assert;
import org.junit.Test;

// 测试类：junit单元测试框架，对业务类中的业务方法进行正确性测试。
public class StringUtilTest {
    // 测试方法：必须是公开public，无参，无返回值。
    // 测试方法必须加上@Test注解（Junit框架的核心步骤）
    @Test
    public void testPrinNumber() {
        // 测试步骤：
        StringUtil.printNumber("张三abc"); // 5
        // 测试用例
        StringUtil.printNumber("");
        StringUtil.printNumber(null);
    }

    @Test
    public void testGetMaxIndex() {
        // 测试步骤：
        int index = StringUtil.getMaxIndex("abcdefg"); // 6
        // 测试用例
        int index2 = StringUtil.getMaxIndex("");
        int index3 = StringUtil.getMaxIndex(null);

        System.out.println(index);
        System.out.println(index2);
        System.out.println(index3);

        // 做断言：断言结果是否与预期结果一致
        // assertEquals("手写错误提示",预期结果，实际结果);
        Assert.assertEquals("本轮测试失败，业务获取的最大索引有问题！请检查",6, index);
        Assert.assertEquals("本轮测试失败，业务获取的最大索引有问题！请检查",-1, index2);
        Assert.assertEquals("本轮测试失败，业务获取的最大索引有问题！请检查",-1, index3);
    }
}

在这里插入图片描述

删除不需要的jar包

在这里插入图片描述

总结

1 Junit单元测试是做什么的？

测试类中方法的正确性的。

2 Junit单元测试的优点是什么？

JUnit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。
JUnit可以生测试报告，如果测试良好则是绿色；如果测试失败，则是红色。
单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。

3 JUnit单元测试的实现过程是什么样的？

必须导入Junit框架的jar包。
定义的测试方法必须是无参数无返回值，且公开的方法。
测试方法使用@Test注解标记。

4 JUnit测试某个方法，测试全部方法怎么处理？成功的标志是什么

测试某个方法直接右键该方法启动测试。
测试全部方法，可以选择类或者模块启动。
红色失败，绿色通过。

反射

认识反射、获取类

什么是反射

反射就是：加载类，并允许以编程的方式解剖类中的各种成分（成员变量、方法、构造器等）。
比如idea中当你.一个对象为什么会有提示，这就是用了反射。反射可以解剖类的所有成员变量和方法。
在这里插入图片描述

反射具体学什么？

学习获取类的信息、操作它们
1、反射第一步：加载类，获取类的字节码：Class对象
2、获取类的构造器：Constructor对象
3、获取类的成员变量：Field对象
4、获取类的成员方法：Method对象

全部认识完后，再看反射的应用场景
在这里插入图片描述

反射第一步：或者Class对象

1、反射第一步：加载类，获取类的Class对象

在这里插入图片描述
获取Class对象的三种方式

Class c1 = 类名.class
调用Class提供方法：public static Class forName(String package)；
Object提供的方法： public Class getClass()； Class c3 = 对象.getClass();

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        // 目标：掌握反射第一步操作：或者类的Class对象。（获取类本身）。
        // 1、获取类本身：类.class
        Class c1 = Student.class;
        System.out.println(c1);// class com.itheima.demo2reflect.Student

        // 2、获取类本身：Class.forName("类的全类名")
        Class c2 = Class.forName("com.itheima.demo2reflect.Student");
        System.out.println(c2);// class com.itheima.demo2reflect.Student

        // 3、获取类本身：对象.getClass()
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3);// class com.itheima.demo2reflect.Student

        System.out.println(c1 == c2); // true
        System.out.println(c2 == c3); // true
    }
}
// student类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private String name;
    private int age;
    private String hobby;
}

获取类中的成分、并对其进行操作

获取类中构造器

Class提供了从类中获取构造器的方法。

方法	说明
Constructor<?>[] getConstructors()	获取全部构造器（只能获取public修饰的）
Constructor<?>[] getDeclaredConstructors()	获取全部构造器（只要存在就能拿到）
Constructor<T> getConstructor(Class<?>… parameterTypes)	获取某个构造器（只能获取public修饰的）
Constructor<T> getDeclaredConstructor(Class<?>… parameterTypes)	获取某个构造器（只要存在就能拿到）

获取类构造器的作用：依然是初始化对象返回

Constructor提供的方法	说明
T newInstance(Object… initargs)	调用此构造器对象表示的构造器，并传入参数，完成对象的初始化并返回
public void setAccessible(boolean flag)	设置为true，表示禁止检查访问控制（暴力反射）

获取类的成员变量

Class提供了从类中获取成员变量的方法。

方法	说明
public Field[] getFields()	获取类的全部成员变量（只能获取public修饰的）
public Field[] getDeclaredFields()	获取类的全部成员变量（只要存在就能拿到）
public Field getField(String name)	获取类的某个成员变量（只能获取public修饰的）
public Field getDeclaredField(String name)	获取类的某个成员变量（只要存在就能拿到）

获取到成员变量的作用：依然是赋值、取值。

方法	说明
void set(Object obj, Object value)：	赋值
Object get(Object obj)	取值
public void setAccessible(boolean flag)	设置为true，表示禁止检查访问控制（暴力反射）

获取类的成员方法

Class提供了从类中获取成员方法的API。

方法	说明
Method[] getMethods()	获取类的全部成员方法（只能获取public修饰的）
Method[] getDeclaredMethods()	获取类的全部成员方法（只要存在就能拿到）
Method getMethod(String name, Class<?>… parameterTypes)	获取类的某个成员方法（只能获取public修饰的）
Method getDeclaredMethod(String name, Class<?>… parameterTypes)	获取类的某个成员方法（只要存在就能拿到）

成员方法的作用：依然是执行

Method提供的方法	说明
public Object invoke(Object obj, Object… args)	触发某个对象的该方法执行。
public void setAccessible(boolean flag)	设置为true，表示禁止检查访问控制（暴力反射）

public class Dog {
    private String name;
    private int age;
    private String hobby;
    private Dog() {
        System.out.println("无参数构造器执行了~~");
    }
    private Dog(String name) {
        System.out.println("1个参数有参数构造器执行了~~");
        this.name = name;
    }
    public Dog(String name, int age) {
        System.out.println("2个参数有参数构造器执行了~~");
        this.name = name;
        this.age = age;
    }

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

    public String eat(String name){
        System.out.println("狗吃" + name);
        return "狗说：谢谢！谢谢！汪汪汪！";
    }

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

    public String getHobby() {
        return hobby;
    }

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

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

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectDemo2 {
    @Test
    public void getClassInfo(){
        // 目标：获取类的信息。
        // 1、反射第一步：或者Class对象，代表拿到类。
        Class c1 = Student.class;
        System.out.println(c1.getName()); // 类名的全类名 com.itheima.demo2reflect.Student
        System.out.println(c1.getSimpleName()); // 类名 Student
    }

    // 2、获取类的构造器对象并对其进行操作。
    @Test
    public void getConstructorInfo() throws Exception {
        // 目标：获取类的构造器对象并对其进行操作。
        // 1、反射第一步：或者Class对象，代表拿到类。
        Class c1 = Dog.class;
        // 2、获取构造器对象。
        Constructor[] cons = c1.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con.getName() + "(" + con.getParameterCount() + ")");
        }
        // com.itheima.demo2reflect.Dog(0)
        // com.itheima.demo2reflect.Dog(1)
        // com.itheima.demo2reflect.Dog(2)
        System.out.println("----------------------------------------------------------------");
        // 3、获取单个构造器
        Constructor con = c1.getDeclaredConstructor(); // 无参数构造器
        System.out.println(con.getName() + "(" + con.getParameterCount() + ")");
        //com.itheima.demo2reflect.Dog(0)

        Constructor con2 = c1.getDeclaredConstructor(String.class, int.class); // 2个参数的有参数构造器
        System.out.println(con2.getName() + "(" + con2.getParameterCount() + ")");
        // com.itheima.demo2reflect.Dog(2)

        // 4、获取构造器的作用依然是创建对象：创建对象。
        // 我们完全可以new Dog() 这里之所以不用new Dog()，是为了之后的学习打下基础。
        // 暴力反射：暴力反射可以访问私有的构造器、方法、属性。
        con.setAccessible(true); // 绕过访问权限，直接访问！
        Dog d1 = (Dog) con.newInstance();
        System.out.println(d1);
        // 无参数构造器执行了~~
        // Dog{name='null', age=0, hobby='null'}

        Dog d2 = (Dog)con2.newInstance("小黑", 3);
        System.out.println(d2);
        // 2个参数有参数构造器执行了~~
        // Dog{name='小黑', age=3, hobby='null'}
    }

    // 3、获取类的成员变量对象并对其进行操作。
    @Test
    public void getFieldInfo() throws Exception {
        // 目标：获取类的成员变量对象并对其进行操作。
        // 1、反射第一步：或者Class对象，代表拿到类。
        Class c1 = Dog.class;
        // 2、获取成员变量对象。
        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + "(" + field.getType().getName() + ")");
        }
        // name(java.lang.String)
        // age(int)
        // hobby(java.lang.String)
        // 3、获取单个成员变量对象。
        Field field = c1.getDeclaredField("hobby");
        System.out.println(field.getName() + "(" + field.getType().getName() + ")");
        // hobby(java.lang.String)

        Field field2 = c1.getDeclaredField("age");
        System.out.println(field2.getName() + "(" + field2.getType().getName() + ")");
        // age(int)

        // 4、获取成员变量的目的依然是取值和赋值。
        Dog d = new Dog("泰迪", 3);// 2个参数有参数构造器执行了~~
        field.setAccessible(true); // 绕过访问权限，直接访问！
        field.set(d, "社交");  //  相当于 d.setHobby("社交");
        System.out.println(d);// Dog{name='泰迪', age=3, hobby='社交'}

        String hobby = (String) field.get(d); // 相当于 d.getHobby();
        System.out.println(hobby);// 社交

    }

    // 4、获取类的成员方法对象并对其进行操作。
    @Test
    public void getMethodInfo() throws Exception {
        // 目标：获取类的成员方法对象并对其进行操作。
        // 1、反射第一步：或者Class对象，代表拿到类。
        Class c1 = Dog.class;
        // 2、获取成员方法对象。
        Method[] methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() + "(" + method.getParameterCount() + ")");
        }
        // eat(0)
        // eat(1)
        // setHobby(1)
        // getHobby(0)
        // getAge(0)
        // setAge(1)
        // 3、获取单个成员方法对象。
        Method m1 = c1.getDeclaredMethod("eat");// 获取是无参数的eat方法
        Method m2 = c1.getDeclaredMethod("eat", String.class);// 获取是有参数的eat方法
        System.out.println(m1.getName() + "(" + m1.getParameterCount() + ")");// getName(0)
        System.out.println(m2.getName() + "(" + m2.getParameterCount() + ")");// toString(0)
        System.out.println("--------------------------------------");
        // 4、获取成员方法的目的依然是调用方法。
        Dog d = new Dog("泰迪", 3);// 2个参数有参数构造器执行了~~
        m1.setAccessible(true); // 绕过访问权限，直接访问！
        Object rs1 = m1.invoke(d); // 唤醒对象d的eat方法执行，相当于 d.eat(); //狗吃骨头！
        System.out.println(rs1); // null

        Object rs2 = m2.invoke(d, "牛肉"); // 唤醒对象d的eat带String参数的方法执行，相当于 d.eat("牛肉");
        // 狗吃牛肉
        System.out.println(rs2);// 狗说：谢谢！谢谢！汪汪汪！
    }
}

作用、应用场景

反射的作用？

基本作用：可以得到一个类的全部成分然后操作。
可以破坏封装性。
可以绕过泛型的约束
最重要的用途是：适合做Java的框架，基本上，主流的框架都会基于反射设计出一些通用的功能。

在这里插入图片描述

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

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        // 3、可以绕过泛型的约束。
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("令狐冲");
        list.add("东方不败");
//        list.add(9.9);// 报错
//        list.add(true);

        Class c1 = list.getClass(); // c1 == ArrayList.class
        // 这是编译后，类名.class
        // 获取 ArrayList 类的add方法
        Method add = c1.getDeclaredMethod("add", Object.class);
        // 编译好后的文件已经把泛型擦除了， 所以这里可以添加任意类型的数据。
        // 触发list集合对象的add方法执行。
        add.invoke(list, 9.9); // 翻墙
        add.invoke(list, true); // 翻墙

        System.out.println(list);
        // [张无忌, 令狐冲, 东方不败, 9.9, true]
    }
}

使用反射做一个简易版的框架

需求：
对于任意一个对象，该框架都可以把对象的字段名和对应的值，保存到文件中去。
在这里插入图片描述
实现步骤

定义一个方法，可以接收任意对象。
每收到一个对象后，使用反射获取该对象的Class对象，然后获取全部的成员变量。
遍历成员变量，然后提取成员变量在该对象中的具体值。
把成员变量名、和其值，写出到文件中去即可。

反射有啥作用？
可以在运行时得到一个类的全部成分然后操作。
可以破坏封装性。（很突出）
也可以破坏泛型的约束性。（很突出）
更重要的用途是适合：做Java高级框架
基本上主流框架都会基于反射设计一些通用技术功能。

// 框架
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;

public class SaveObjectFrameWork {
    // 保存任意对象的静态方法
    public static void saveObject(Object obj) throws Exception {

        PrintStream ps = new PrintStream(new FileOutputStream("day-15\\src\\com\\itheima\\demo2reflect\\obj.txt", true));
        // obj 可能是学生  老师  狗
        // 只有反射可以直到对象有多少个字段：
        // 1. 获取Class对象
        Class c = obj.getClass();
        String simpleName = c.getSimpleName();
        ps.println("==============" + simpleName + "====================");
        // 2. 获取Class对象的所有字段。
        Field[] fields = c.getDeclaredFields();
        // 3. 遍历字段
        for (Field field : fields) {
            // 4. 获取字段的值
            // 4.1 获取字段名称
            String fieldName = field.getName();
            // 4.2 获取字段的值
            field.setAccessible(true); // 暴力反射
            Object fieldValue = field.get(obj) + "";
            // 5. 打印到文件中去
            ps.println(fieldName + "=" + fieldValue);
       }
       ps.close();
    }
}

// 编写入口方法
public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        // 目标：搞清楚反射的应用：做框架的通用技术。
        Dog d = new Dog("小黑", 3);
        SaveObjectFrameWork.saveObject(d);

        // 创建学生对象
        Student s = new Student("小明", 18, "爱问问题");
        SaveObjectFrameWork.saveObject(s);

        // 创建老师对象
        Teacher t = new Teacher("小红", 19, "java、前端、动漫", 3000, "422期", '女', "12345678901");
        SaveObjectFrameWork.saveObject(t);

    }
}

==============Dog====================
name=小黑
age=3
hobby=null
==============Student====================
name=小明
age=18
hobby=爱问问题
==============Teacher====================
name=小红
age=19
hobby=java、前端、动漫
salary=3000.0
className=422期
sex=女
phone=12345678901

注解

注解概述

就是Java代码里的特殊标记，比如：@Override、@Test等，作用是：让其他程序根据注解信息来决定怎么执行该程序。
注意：注解可以用在类上、构造器上、方法上、成员变量上、参数上、等位置处。
在这里插入图片描述

注解概述-自定义注解

自定义注解
就是自己定义注解。

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

@MyBook(name = "赵丽颖", age = 18, address = {"北京", "上海"})
public class AnnotationDemo1 {
    @MyBook(name = "王菲", age = 52, address = {"北京", "香港"})
    public static void main( String[] args ) {
        // 目标：自定义注解。
        int a;
    }
}

// 自定义注解
public @interface MyBook {
    String name();
    int age() default 18;
    String[] address();
}

特殊属性名： value
如果注解中只有一个value属性，使用注解时，value名称可以不写!!

public  @interface A {
    String value(); // 特殊属性value，在使用时如果只有一个value属性，value名称可以不写
    String hobby() default "打篮球"; // 当这个有默认值，value名称也可以不写
}

// @A(value = "delete")
//@A("delete") // 特殊属性value，在使用时如果只有一个value属性，value名称可以不写
//@A(value = "delete", hobby = "打篮球")
@A("delete")
public class AnnotationDemo1 {
    public static void main( @A("delete") String[] args ) {
        // 目标：自定义注解。
        @A("delete")
        int a;
    }
}

注解概述-注解的原理

在这里插入图片描述
注解本质是一个接口，Java中所有注解都是继承了Annotation接口的。
@注解(…)：其实就是一个实现类对象，实现了该注解以及Annotation接口。

注解的作用

对Java中类、方法、成员变量做标记，然后进行特殊处理。
例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行

元注解

元注解是什么

指的是：注解(动词)注解(名词)的注解(名词)。

在这里插入图片描述
元注解是什么？
注解注解的注解
各自的作用是什么？
@Target约束自定义注解可以标记的范围。
@Retention用来约束自定义注解的存活范围。

//@MyTest1
public class AnnotationDemo2 {

    @MyTest1
    private int age;

//    @MyTest1
    public AnnotationDemo2(){
    }

    @MyTest1
    public static void main(String[] args) {
        // 目标：搞清楚元注解的作用。
    }
    @MyTest1
    public void getAgeTest(){
    }
}

// 元注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD}) // 表示注解的作用目标为方法,成员变量
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
public @interface MyTest1 {  }

注解的解析

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

如何解析注解？

指导思想：要解析谁上面的注解，就应该先拿到谁。
比如要解析类上面的注解，则应该先获取该类的Class对象，再通过Class对象解析其上面的注解。
比如要解析成员方法上的注解，则应该获取到该成员方法的Method对象，再通过Method对象解析其上面的注解。
Class 、 Method 、 Field , Constructor、都实现了AnnotatedElement接口，它们都拥有解析注解的能力。

AnnotatedElement 接口提供了解析注解的方法	说明
public Annotation[] getDeclaredAnnotations()	获取当前对象上面的注解。
public T getDeclaredAnnotation(Class annotationClass)	获取指定的注解对象
public boolean isAnnotationPresent(Class annotationClass)	判断当前对象上是否存在某个注解

解析注解的案例

定义注解MyTest4，要求如
- 包含属性：String value()
- 包含属性：double aaa()，默认值为 100
- 包含属性：String[] bbb()
- 限制注解使用的位置：类和成员方法上
- 指定注解的有效范围：一直到运行时
定义一个类叫：Demo，在类中定义一个test1方法，并在该类和其方法上使用MyTest4注解
定义AnnotationTest3测试类，解析Demo类中的全部注解。

// 第一步
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.TYPE}) // 表示注解的作用目标为方法,成员变量
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
public @interface MyTest2 {
    String value();
    double height() default 169.5;
    String[] address();
}

// 第二步
@MyTest2(value = "刘亦菲", address = {"北京", "上海", "深圳"})
public class Demo {
    @MyTest2(value = "欧阳娜娜", address = {"湖南", "湖北"})
    public void go(){
    }
}

// 第三步
import org.junit.Test;
import java.lang.reflect.Method;
import java.util.Arrays;

public class AnnotationDemo3 {
    // 目标：解析注解
    @Test
    public void parseClass() throws Exception {
        // 1.获取类对象
        Class c1 = Demo.class;
        // 2、使用isAnnotationPresent判断这个类上是否陈列了注解MyTest2
        if (c1.isAnnotationPresent(MyTest2.class)) {
            // 3、获取注解对象
            MyTest2 myTest2 = (MyTest2) c1.getDeclaredAnnotation(MyTest2.class);

            // 4、获取注解属性值
            String[] address = myTest2.address();
            double height = myTest2.height();
            String value = myTest2.value();

            // 5、打印注解属性值
            System.out.println(Arrays.toString(address));
            System.out.println(height);
            System.out.println(value);
            // [北京, 上海, 深圳]
            // 169.5
            // 刘亦菲
        }
    }

    @Test
    public void parseMethod() throws Exception {
        // 1.获取类对象
        Class c1 = Demo.class;
        // 2、获取方法对象
        Method method = c1.getMethod("go");
        // 3、使用isAnnotationPresent判断这个方法上是否陈列了注解MyTest2
        if (method.isAnnotationPresent(MyTest2.class)) {
            // 4、获取注解对象
            MyTest2 myTest2 = method.getDeclaredAnnotation(MyTest2.class);

            // 5、获取注解属性值
            String[] address = myTest2.address();
            double height = myTest2.height();
            String value = myTest2.value();

            // 6、打印注解属性值
            System.out.println(Arrays.toString(address));
            System.out.println(height);
            System.out.println(value);
            // [湖南, 湖北]
            // 169.5
            // 欧阳娜娜
        }
    }
}

总结

什么是注解的解析？注解解析的步骤是啥？

方法
Annotation[] getDeclaredAnnotations()
T getDeclaredAnnotation(Class<T> annotationClass)
boolean isAnnotationPresent(Class<Annotation> annotationClass)

作用、应用场景

使用注解开发出一个简易版的Junit框架

需求

定义若干个方法，只要加了MyTest注解，就会触发该方法执行。
分析

定义一个自定义注解MyTest，只能注解方法，存活范围是一直都在。
定义若干个方法，部分方法加上@MyTest注解修饰，部分方法不加。
模拟一个junit程序，可以触发加了@MyTest注解的方法执行。

import java.lang.reflect.Method;
public class AnnotationDemo4 {
    // 目标：搞清楚注解的应用场景：模拟junit框架。有MyTest注解的方法就执行，没有的就不执行。
    public static void main(String[] args) throws Exception {
        AnnotationDemo4 ad = new AnnotationDemo4();
        // 1、获取类对象
        Class c = AnnotationDemo4.class;
        // 2、获取所有方法
        Method[] methods = c.getMethods();
        // 3、遍历所有方法，判断方法上是否有MyTest注解，有就执行，没有就不执行。
        for (Method method : methods) {
            // 4、判断方法上是否有MyTest注解
            if (method.isAnnotationPresent(MyTest.class)) {
                // 获取到这个方法的注解
                MyTest myTest = method.getDeclaredAnnotation(MyTest.class);
                int count = myTest.count();
                // 5、有就执行这个method方法
                for (int i = 0; i < count; i++) {
                    method.invoke(ad);
                }
                // test3方法执行了
                // test3方法执行了
                // test1方法执行了
                // test4方法执行了
            }
        }
    }
    // 测试方法：public 无参 无返回值
    @MyTest
    public void test1(){
        System.out.println("test1方法执行了");
    }

    public void test2(){
        System.out.println("test2方法执行了");
    }

    @MyTest(count = 2)
    public void test3(){
        System.out.println("test3方法执行了");
    }

    @MyTest
    public void test4(){
        System.out.println("test4方法执行了");
    }
}

// 注解。
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD}) // 表示注解的作用目标为方法
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
public @interface MyTest {
    int count() default 1; // 表示注解的属性
}

动态代理(设计模式)

程序为什么需要代理？代理长什么样？

什么是代理

在这里插入图片描述
歌手自己准备场地话筒收钱

当歌手忙不过来时。

歌手自己找个代理，让代理帮自己准备场地，准备话筒，并为歌手安排行程等等。

如何为Java对象创建一个代理对象？

java.lang.reflect.Proxy类：提供了为对象产生代理对象的方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
参数一：用于指定用哪个类加载器，去加载生成的代理类
参数二：指定接口，这些接口用于指定生成的代理长什么，也就是有哪些方法
参数三：用来指定生成的代理对象要干什么事情

代码

// 接口：StarService
package com.itheima.demo4proxy;
// 明星行为接口
public interface StarService {
    void sing(String name);
    String dance();
}

// Star.java
package com.itheima.demo4proxy;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Star implements StarService{
    private String name;

    @Override
    public void sing(String name) {
        System.out.println(this.name + "表演唱歌：" + name);
    }

    @Override
    public String dance() {
        System.out.println(this.name + "表演跳舞：魅力四射！" );
        return "谢谢！谢谢！";
    }
}

// ProxyUtil.java
package com.itheima.demo4proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 代理工具类：中介公司，专门负责创建代理对象并返回给别人使用
 */
public class ProxyUtil {
    // 创建一个明星对象的代理对象返回。
    public static StarService createProxy(Star s){
        /**
         * 参数一：用于执行用哪个类加载器去加载生成的代理类。
         * 参数二：用于指定代理类需要实现的接口: 明星类实现了哪些接口，代理类就实现哪些接口
         * 参数三：用于指定代理类需要如何去代理（代理要做的事情）。
         */
        StarService proxy = (StarService) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                s.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 用来声明代理对象要干的事情。
                        // 参数一： proxy接收到代理对象本身（暂时用处不大）
                        // 参数二： method代表正在被代理的方法
                        // 参数三： args代表正在被代理的方法的参数
                        String methodName = method.getName();
                        if("sing".equals(methodName)){
                            System.out.println("准备话筒，收钱20万！");
                        }else if("dance".equals(methodName)){
                            System.out.println("准备场地，收钱100万！");
                        }
                        // 真正干活（把真正的明星对象叫过来正式干活）
                        // 找真正的明星对象来执行被代理的行为：method方法
                        Object result = method.invoke(s, args);
                        return result;
                    }
                });
        return proxy;
    }
}

package com.itheima.demo4proxy;

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        // 目标：创建代理对象。
        // 1、准备一个明星对象：设计明星类。
        Star star = new Star("章若楠");
        // 2、为章若楠创建一个专属与她的代理对象。
        StarService proxy = ProxyUtil.createProxy(star);
        proxy.sing("《红昭愿》");
        System.out.println(proxy.dance());
    }
}

代码运行流程

在这里插入图片描述

Java提供了什么API帮我们创建代理？
Proxy的newProxyInstance方法。

newIProxyInstance方法在创建代理时，需要接几个参数，每个参数的含义是什么？

参数一：用于执行用哪个类加载器去加载生成的代理类。
参数二：用于指定代理类需要实现的接口: 明星类实现了哪些接口，代理类就实现哪些接口
参数三：用于指定代理类需要如何去代理（代理要做的事情）。

通过invokehandler的invoke方法指定代理干的事时，这个invoke会被谁调用？要接哪几个参数？
谁去调用触发谁的方法。
参数一： proxy接收到代理对象本身（暂时用处不大）
参数二： method代表正在被代理的方法
参数三： args代表正在被代理的方法的参数

解决实际问题、掌握使用代理的好处

使用代理优化用户管理类

场景
某系统有一个用户管理类，包含用户登录，删除用户，查询用户等功能，系统要求统计每个功能的执行耗时情况，以便后期观察程序性能。

需求
现在，某个初级程序员已经开发好了该模块，请观察该模块的代码，找出目前存在的问题，并对其进行改造。

package com.itheima.demo05proxy2;
/**
 *  用户业务接口
 */
public interface UserService {
    // 登录功能
    void login(String loginName,String passWord) throws Exception;
    // 删除用户
    void deleteUsers() throws Exception;
    // 查询用户，返回数组的形式。
    String[] selectUsers() throws Exception;
    String[] selectUsers2() throws Exception;
}

package com.itheima.demo05proxy2;
/**
 * 用户业务实现类（面向接口编程）
 */
public class UserServiceImpl implements UserService{
    @Override
    public void login(String loginName, String passWord) throws Exception {
        // ----------------------
        if("admin".equals(loginName) && "123456".equals(passWord)){
            System.out.println("您登录成功，欢迎光临本系统~");
        }else {
            System.out.println("您登录失败，用户名或密码错误~");
        }
        Thread.sleep(1000);
        // --------------------------
    }

    @Override
    public void deleteUsers() throws Exception{
        System.out.println("成功删除了1万个用户~");
        Thread.sleep(1500);
    }

    @Override
    public String[] selectUsers() throws Exception{
        System.out.println("查询出了3个用户");
        String[] names = {"张全蛋", "李二狗", "牛爱花"};
        Thread.sleep(500);

        return names;
    }

    @Override
    public String[] selectUsers2() throws Exception {
        System.out.println("查询出了3000个用户");
        String[] names = {"张全蛋2", "李二狗2", "牛爱花2"};
        Thread.sleep(2500);

        return names;
    }
}

package com.itheima.demo05proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {
    public static <T> T createProxy(T obj) {
        T proxy = (T) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long start = System.currentTimeMillis(); // 记录开始时间 1970年1月1日0时0分0秒 走到此刻的总毫秒值
                        // 真正调用业务对象被代理的方法
                        Object result = method.invoke(obj, args);

                        long end = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时："+(end-start)/1000.0+"秒");
                        return result;
                    }
                });
        return proxy;
    }
}

package com.itheima.demo05proxy2;

import java.util.Arrays;

/**
 * 目标：使用动态代理解决实际问题，并掌握使用代理的好处。
 */
public class Test {
    public static void main(String[] args) throws Exception{
        // 1、创建用户业务对象。
        UserService userService = ProxyUtil.createProxy(new UserServiceImpl());

        // 2、调用用户业务的功能。
        userService.login("admin", "123456");

        userService.deleteUsers();

        String[] names = userService.selectUsers();
        System.out.println("查询到的用户是：" + Arrays.toString(names));

        String[] names2 = userService.selectUsers2();
        System.out.println("查询到的用户是：" + Arrays.toString(names2));
    }
}

您登录成功，欢迎光临本系统~
login方法耗时：1.007秒
成功删除了1万个用户~
deleteUsers方法耗时：1.506秒
查询出了3个用户
selectUsers方法耗时：0.515秒
查询到的用户是：[张全蛋, 李二狗, 牛爱花]
查询出了3000个用户
selectUsers2方法耗时：2.514秒
查询到的用户是：[张全蛋2, 李二狗2, 牛爱花2]