20天深度复习JavaSE的详细笔记(十九)——单元测试、反射、注解

Demo19-Java高级技术：单元测试、反射、注解

1.Junit单元测试

1.1单元测试概述

1.单元测试:

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

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

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

3.Junit单元测试框架

• JUnit是使用Java语言实现的单元测试框架，它是开源的，Java开发者都应当学习并使用JUnit编写单元测试
• 此外，几乎所有的IDE工具都集成了JUnit，这样我们就可以直接在IDE中编写并运行JUnit测试，JUnit目前最新版本是5

4.Junit优点

• JUnit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。

• Junit可以生成全部方法的测试报告。如果测试良好是绿色;如果测试失败是红色

• 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。

1.2单元测试快速入门及常用注解

1.Junit单元测试步骤:

• 将Unit的jar包导入到项目中

  • IDEA通常整合好了Junit框架,一般不需要导入,只要我们在第一次使用的时候联网,IDEA就会自动将Junit的jar包下载,从此以后再使用时也不需要自己导入jar包了

  • 如果IDEA没有整合好,需要自己手动导入如下两个Junit的jar包到模块

• 编写测试方法:该测试方法必须是公共的无参数无返回值的非静态方法

• 在测试方法上使用@Test注解：标注该方法是一个测试方法

• 在测试方法中完成被测试方法的预期正确性测试。

• 选中测试方法，选择“JUnit运行” ，如果测试良好则是绿色；如果测试失败，则是红色

2.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方法执行一次===");
    }
	
    //测试方法
    @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();
    }
}

public class UserService {
    public String loginName(String loginName , String passWord){
        if("admin".equals(loginName) && "123456".equals(passWord)){
            return "登录成功";
        }else {
            return "用户名或者密码有问题";
        }
    }
    public void selectNames(){
        System.out.println(10/2);
        System.out.println("查询全部用户名称成功~~");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2.反射

2.1认识反射

1.反射概述:

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

2.反射的关键:

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

  HelloWorld.java -> javac -> HelloWorld.class

  Class c = HelloWorld.class;

3.总结:反射的基本作用,关键:

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

2.2反射获取类对象

将java文件编译成字节码文件,有人会将字节码文件提取到内存中去,这样就得到了Class对象

• 类名.class：JVM将使用类装载器，将类装入内存(前提是:该类还未装入内存)，不做类的初始化工作，返回Class的对象
• Class.forName(“类全限名字符串”)：装入类，并做类的静态初始化，返回Class的对象
• 实例对象.getClass()：对类进行静态初始化、非静态初始化；返回引用运行时真正所指的对象(因为:子对象的引用会赋给父对象的引用变量中,如Animal a = new Dog();)所属的类的Class的对象

生成Class对象的过程：

• 当我们编写一个新的java类时,JVM就会帮我们编译成class对象,存放在同名的.class文件中。在运行时，当需要生成这个类的class对象，JVM就会检查此类是否已经装载内存中。
  • 若是装载，看是否还需要做类的初始化(1.静态初始化或2.静态初始化,非静态初始化或3.非静态初始化),如果需要,就初始化完成后由返回class对象,如果不需要,直接返回class对象
  • 若是没有装载，则把.class文件以特定方式(1.不做类的初始化或2.做类的静态初始化或3.做类的静态初始化,非静态初始化)然后装入到内存中并返回class对象

public class GetClassTest {
    @Test
    public void test() throws ClassNotFoundException {
        Class<?> clz = Person.class;
        System.out.println("//");
        clz = Class.forName("com.itheima.d2_reflect_class.Person");
        System.out.println("//");
        clz = new Person().getClass();
    }
}

public class Person {
    static {
        System.out.println("Person：静态代码块");
    }
    {
        System.out.println("Person：动态代码块");
    }
    public Person(){
        System.out.println("Person：构造方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

执行结果:

//
Person：静态代码块
//
Person：动态代码块
Person：构造方法

2.3反射获取构造器对象并用该构造器对象创建实例对象

Class类中用于获取构造器的方法:

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

public class TestStudent01 {
    @Test
    public void getConstructors(){
        Class c = Student.class;
        // 提取类中的全部的构造器对象(这里只能拿public修饰的构造器)
        Constructor[] constructors = c.getConstructors();
        System.out.println("=====test1======");
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    @Test
    public void getDeclaredConstructors(){
        Class c = Student.class;
        Constructor[] constructors = c.getDeclaredConstructors();//任何权限的构造器都可以拿到
        System.out.println("=====test2======");
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

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

    @Test
    public void getDeclaredConstructor() throws Exception {
        Class c = Student.class;
        System.out.println("=====test4======");
        // 定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // 定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
        cons1.setAccessible(true);//权限被打开
        Student s1 = (Student) cons1.newInstance("孙悟空");//参数类型是Objec类型
        System.out.println(s1);
    }
}

public class Student {
    private String name;
    public Student(){
        System.out.println("无参数构造器执行！");
    }
    private Student(String name) {
        System.out.println("有参数构造器执行！");
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

注意:

• 第43行cons.setAccessible(true);是为了取消访问检查
  • 这样的话私有的也可以执行了,所以说反射可以破坏封装性
  • 如果是非public的构造器,需要用这行代码暴力反射打开权限,且只能变量cons1使用,下次再执行c.getDeclaredConstructor().newInstance(“孙悟空”);获得新的私有构造器对象并创建实例对象时仍需这行代码打开权限,否则就报错
• 第44行cons1.newInstance(“孙悟空”)参数类型是Object类型
  • 我认为这个构造器参数是String类型,但我这里传的是Object类型,所以我认为底层会做类型强转

2.4反射获取成员变量对象

Class类中用于获取成员变量的方法:

public class FieldDemo01 {
    @Test
    public void getDeclaredFields(){
        Class c = Student.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + "==>" + field.getType());
        }
    }

    @Test
    public void getDeclaredField() throws Exception {
        Class c = Student.class;
        Field f = c.getDeclaredField("age");
        System.out.println(f.getName() +"===>" + f.getType());

        // 和构造器对象的setAccessible方法作用一样,都是暴力打开权限,且只对f有用
        f.setAccessible(true);

        // 赋值
        Student s = new Student();
        f.set(s , 18);
        System.out.println(s);

        // 取值
        int age = (int) f.get(s);
        System.out.println(age);
    }
}

public class Student {
    private String name;
    private int age;
    public static String schoolName;
    public static final String  COUNTTRY = "中国";
    public Student(){
        System.out.println("无参数构造器执行！");
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

• 第22行f.set(s , 18);
  • 以前是对象给变量赋值:s.setAge(18);,现在是:变量对对象说:对象,来把我改成18.关系反转了,故称为反射
  • 两个形参都是Object类型,我认为和构造器的cons1.newInstance(“孙悟空”)一样,内部会进行强转

2.5反射获取方法对象

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

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

public class MethodDemo01 {
    @Test
    public void getDeclaredMethods(){
        Class c = Dog.class;
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
        }
    }
    
    @Test
    public void getDeclardMethod() throws Exception {
        Class c = Dog.class;
        Method m = c.getDeclaredMethod("eat");
        Method m2 = c.getDeclaredMethod("eat", String.class);

        // 暴力打开权限了
        m.setAccessible(true);
        m2.setAccessible(true);
        
        Dog d = new Dog();
        // 注意：方法如果是没有结果回来的，那么返回的是null.
        Object result = m.invoke(d);
        System.out.println(result);

        Object result2 = m2.invoke(d, "骨头");
        System.out.println(result2);
    }
}

public class Dog {
    public Dog(){
    }
    private void eat(){
        System.out.println("狗吃骨头");
    }
    private String eat(String name){
        System.out.println("狗吃" + name);
        return "吃的很开心！";
    }
    public static void inAddr(){
        System.out.println("在非洲学习Java!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

2.6反射的作用

2.6.1绕过编译阶段为集合添加数据

• 反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的
  • 因为:泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。
    • 为什么编译后ArrayList,ArrayList等等的真实类型都是ArrayList呢,因为官方想实现运行时只需要一个ArrayList集合变量即可存储各种类型的数据,这样就避免了内存浪费(否则:假如源码代码中有ArrayList和ArrayList两种类型的变量,那运行时就要创建ArrayList和ArrayList两个类,并创建两个对应的集合对象存储对应的数据占用空间)

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 需求：反射实现泛型擦除后，加入其他类型的元素
        ArrayList<String> lists1 = new ArrayList<>();
        ArrayList<Integer> lists2 = new ArrayList<>();

        System.out.println(lists1.getClass());
        System.out.println(lists2.getClass());

        System.out.println(lists1.getClass() ==  lists2.getClass());//true,证明了:运行时真实类型都是ArrayList

        System.out.println("---------------------------");
        ArrayList<Integer> lists3 = new ArrayList<>();
        lists3.add(23);
        lists3.add(22);
        // lists3.add("中国");//报错,因为有泛型约束

        Class c = ArrayList.class; // ArrayList.class  ===> public boolean add(E e)
        // 定位c类中的add方法
        Method add = c.getDeclaredMethod("add", Object.class);
        boolean rs = (boolean) add.invoke(lists3, "中国");
        System.out.println(rs);
        System.out.println(lists3);

        //下面这种方式也可以突破泛型,并且不需要用反射
        ArrayList list4 = lists3;
        list4.add("外国");
        list4.add(false);
        System.out.println(lists3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

• 反射为何可以给约定了泛型的集合存入其他类型的元素？
  • 编译成Class文件进入运行阶段的时候，泛型会自动擦除。
  • 反射是作用在运行时的技术，此时已经不存在泛型了。

2.6.2通用框架的底层原理

利用反射做通用框架:

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

分析:

• 定义一个方法,可以接收任意类的对象
• 每次收到一个对象后,需要解析这个对象的全部成员变量名称
  • 这个对象可能是任意的,那么怎么样才可以知道这个对象的全部成员变量名称呢:
    • 使用反射获取对象的Class类对象,然后获取全部成员变量信息
    • 遍历成员变量信息,然后提取本成员变量在对象中的具体值

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        Student s = new Student("猪八戒",'男',1000,"西天跑路1班","吃，睡");
        MybatisUtil.save(s);
        Teacher t = new Teacher("波仔",'男',6000);
        MybatisUtil.save(t);
    }
}

public class MybatisUtil {
    public static void save(Object obj){
        try (
                PrintStream ps = new PrintStream(new FileOutputStream("Demo23-junit-reflect-annotation-proxy/src/data.txt", true));
        ){
            // 1、获得Class对象
            Class c = obj.getClass();
            // c.getSimpleName()获取当前类名   c.getName获取全限名：包名+类名
            ps.println("================" + c.getSimpleName() + "================");

            // 2、提取它的全部成员变量的值并打印
            Field[] fields = c.getDeclaredFields();
            // 3、获取成员变量的信息
            for (Field field : fields) {
                String name = field.getName();
                // 提取本成员变量在obj对象中的值（取值）
                field.setAccessible(true);
                //如果强转为字符串会报错,因为获得的值可能真实数据类型是int,double,强转报错
                String value = field.get(obj) + "";
                ps.println(name  + "=" + value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Student {
    private String name;
    private char sex;
    private int age;
    private String className;
    private String hobby;
    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 class Teacher {
    private String name;
    private char sex;
    private double salary;
    public Teacher(String name, char sex, double salary) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

反射的作用:

• 可以在运行时得到一个类的全部成分然后操作
• 可以破坏封装性(很突出)
• 可以破坏泛型的约束性(很突出)
• 更重要的用途是适合:做java高级框架

3.注解

3.1认识注解

• 注解概述:
  • java注解又称为java标注,是JDK5引入的一种注释机制
  • java语言中的类,构造器,方法,成员变量,参数等都可以被注解进行注释
• 注解的作用:
  • 对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定
    • 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行

3.2自定义注解

格式:

public @interface 注解名称 {

​ public 属性类型 属性名() default 默认值;

}

• public是默认的,可以不写
• 属性类型支持任意的数据类型
• 特殊属性:
  • value属性,如果只有一个value属性的情况下,使用value属性的时候可以省略value名称不写
  • 如果有多个属性,且只有value没有默认值,此时使用value属性的时候可以省略value名称不写
  • 但是如果有多个属性,且多个属性没有默认值,那么value名称是不能省略的

@Book("/delete")
public class AnnotationDemo1 {
    @Book(value = "/delete")
    private AnnotationDemo1(){
    }
    @Book(value = "/delete", price = 25.5)
    public static void main(String[] args) {
        @Book("/delete")
        int age = 21;
    }
}

public @interface Book {
    String value(); // 特殊属性
    double price() default 9.9;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.3元注解

元注解就是放在注解上面的注解(是用来注解注解的注解)

常用元注解有两个:

• @Target:约束自定义注解只能在哪些地方使用
• @Retention:申明注解的声明周期
  • 很多注解默认在运行阶段就消失了,可以用这个注解申明它永远活着

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

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

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

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

3.4注解解析

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

与注解解析相关的接口:

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

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

---

解析注解的技巧:

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

注解解析的案例:

需求:

• 定义注解Bookk，要求如下：
  • 包含属性：String value() 书名
  • 包含属性：double price() 价格，默认值为 100
  • 包含属性：String[] authors() 多位作者
  • 限制注解使用的位置：类和成员方法上
  • 指定注解的有效范围：RUNTIME
• 定义BookStore类，在类和成员方法上使用Bookk注解
• 定义AnnotationDemo01测试类获取Bookk注解上的数据

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bookk {
    String value();
    double price() default 100;
    String[] author();
}

public class AnnotationDemo3 {
    @Test
    public void parseClass(){
        // a.先得到类对象
        Class c = BookStore.class;
        // b.判断这个类上面是否存在这个注解
        if(c.isAnnotationPresent(Bookk.class)){
            //c.直接获取该注解对象
            Bookk book = (Bookk) c.getDeclaredAnnotation(Bookk.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.author()));
        }
    }

    @Test
    public void parseMethod() throws NoSuchMethodException {
        // a.先得到类对象
        Class c = BookStore.class;

        Method m = c.getDeclaredMethod("test");

        // b.判断这个类上面是否存在这个注解
        if(m.isAnnotationPresent(Bookk.class)){
            //c.直接获取该注解对象
            Bookk book = (Bookk) m.getDeclaredAnnotation(Bookk.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.author()));
        }
    }
}

@Bookk(value = "《情深深雨濛濛》", price = 99.9, author = {"琼瑶", "dlei"})
class BookStore{
    @Bookk(value = "《三少爷的剑》", price = 399.9, author = {"古龙", "熊耀华"})
    public void test(){
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

3.5注解的应用场景-模拟Junit框架

需求:定义若干个方法,只要加了MyTest注解,就可以在启动时被触发执行

分析:

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

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

public class AnnotationDemo4 {
    public void test1(){
        System.out.println("===test1===");
    }
    @MyTest
    public void test2(){
        System.out.println("===test2===");
    }
    @MyTest
    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.遍历方法，看是否有MyTest注解，有就跑它
        for (Method method : methods) {
            if(method.isAnnotationPresent(MyTest.class)){
                // 跑它
                method.invoke(t);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

• 上述案例中一旦有测试方法不满足公开,无参,无返回值,那么编写就会很麻烦,这也是为什么Junit单元测试规定测试方法必须公开,无参,无返回值,和我们一样,是为了简化编写框架的流程

4.动态代理

4.1动态代理概述,快速入门

1.什么是代理:

• 一个对象,用来对被代理对象的行为额外做一些辅助工作

2.代理主要干什么,他是如何工作的:

3.如何创建动态代理:

• java中代理的代表类是:java.lang.reflect.Proxy
  • Proxy提供了一个静态方法,用于为对象产生一个代理对象返回

public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):为对象(生成)返回一个代理对象

• 参数一:定义代理类的类加载器
  • newProxyInstance方法内部会先为我们生成一个代理类,再通过代理类产生一个代理对象,所以要给方法一个类加载器,好让他底层通过类加载器生成一个代理类,进而得到代理对象
• 参数二:代理类要实现的接口列表
  • 这可能也就是为什么java规定动态代理中我们必须要设计接口:因为方法明确规定是要接口列表
• 参数三:将方法调用分派到的处理程序(代理对象的核心处理程序)

public class Test {
    public static void main(String[] args) {
        //1.创建一个对象(杨超越),java规定动态代理中我们必须要设计接口
        Star s = new Star("杨超越");

        //为杨超越对象生成一个代理对象(经纪人)
        Skill s2 = StarAgentProxy.getProxy(s);
        s2.jump();
        System.out.println(s2.sing());
    }
}

public interface Skill {
    void jump();
    int sing();
}

public class Star implements Skill{
    private String name;
    public Star(String name) {
        this.name = name;
    }
    @Override
    public void jump() {
        System.out.println(name + "开始跳舞");
    }
    @Override
    public int sing() {
        System.out.println(name + "开始唱歌");
        return 23333;
    }
}

public class StarAgentProxy {
    public static Skill getProxy(Skill obj) {
        /*
        public static Object newProxyInstance(
              ClassLoader loader,
              Class[] interfaces,
              InvocationHandler h)
         */
        //为杨超越这个对象生成一个代理对象
        return (Skill)Proxy.newProxyInstance(
                obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(),
            new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("收首付款");

                //真正的让杨超越去唱歌和跳舞
                //method:正在被调用的方法对象 args:代表这个方法的参数
                Object rs = method.invoke(obj, args);//如果方法无返回值那么rs就是null

                System.out.println("收尾款,把杨超越接回来");
                return rs;
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

• 第43行return (Skill)Proxy.newProxyInstance(…
  • 因为以后用户是调用代理对象唱歌跳舞,代理对象再调用真正的杨超越对象唱歌跳舞,所以稍微想一下就能知道:newProxyInstance方法内部肯定是会让代理对象实现Skill接口的,而newProxyInstance方法返回的代理对象是Object类型,所以需要强制类型转换

总结:

• 在java中实现动态代理的步骤是什么:
  • 必须存在接口
  • 被代理对象需要实现接口
  • 使用Proxy类提供的方法,得到对象的代理对象
• 通过代理对象调用方法,执行流程是什么样的:
  • 先走向代理
  • 代理可以为方法额外做一些辅助工作
  • 开发真正触发对象的方法的执行
  • 回到代理中,由代理负责返回结果给方法的调用者

4.2动态代理的应用案例:做性能分析

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

分析:

• 定义一个UserService表示用户业务接口,规定必须完成用户登录,用户删除,用户查询功能
• 定义一个实现类UserServiceImpl实现UserService,并完成相关功能
• 创建一个实现类的对象,该对象为业务对象,紧接着为业务对象做一个代理对象

public interface UserService {
    String login(String loginName , String passWord) ;
    void selectUsers();
    boolean deleteUsers();
}

public class UserServiceImpl implements UserService{
    @Override
    public String login(String loginName, String passWord) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if("admin".equals(loginName) && "1234".equals(passWord)) {
            return "success";
        }
        return "登录名和密码可能有毛病";

    }
    @Override
    public void selectUsers() {
        System.out.println("查询了100个用户数据！");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public boolean deleteUsers() {
        try {
            System.out.println("删除100个用户数据！");
            Thread.sleep(500);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

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 startTimer = System .currentTimeMillis();
                        // 马上触发方法的真正执行。(触发真正的业务功能)
                        Object result = method.invoke(obj, args);

                        long endTimer = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时：" + (endTimer - startTimer) / 1000.0 + "s");

                        // 把业务功能方法执行的结果返回给调用者
                        return result;
                    }
                });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

动态代理的优点:

• 可以在不改变方法源码的情况下，实现对方法功能的增强

• 简化了编程工作、提高了软件系统的可扩展性，同时也提高了开发效率

• 可以为被代理对象的所有方法做代理

• 非常的灵活:

  • 支持任意接口类型的实现类对象做代理
    • 因为可以将创建并返回代理对象的方法(本案例就是getProxy方法)设计为泛型方法,此时就可以创建任意接口类型的实现类对象的代理对象
  • 也可以直接为接口本身做代理(以后学)