【java】【高级技术】单元测试&&反射&&注解&&动态代理

原创 已于 2023-08-15 19:49:48 修改 · 316 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
java

当前文章被收录于：

java
83 篇文章 35 人学习
订阅专栏 查看详情
于 2023-08-02 20:29:50 首次发布

目录

1 单元测试

1.1 概述

1.2 Junit框架快速入门

 1.3 案例1--Junit初体验​编辑

1.3.1 准备一个被测类 StringUnit

 1.3.2 为被测试类StringUnit定义一个对应的测试类StringUnitTest

 1.3.3 引入junit框架（在StringUnitTest操作）

 1.3.4 在测试方法执行测试

 1.3.5 查看结果

1.4 案例2 -- Junit--断言机制

1.4.1 准备一个被测类 StringUnit

 1.4.2 为被测试类StringUnit定义一个对应的测试类StringUnitTest

 1.4.3 执行，查看断言的效果

1.5 执行范围

1.5.1 方法上面执行

1.5.2 类上面执行

1.5.3 模块上面执行

1.6 Junit框架的常见注解（Junit4.XXX版本）

1.6.1 准备一个被测类 StringUnit

 1.6.2 为被测试类StringUnit定义一个对应的测试类StringUnitTest

 1.6.3 执行，查看运行结果

1.7 Junit框架的常见注解（Junit5.XXX版本）

2 反射（了解）

2.1 认识反射、获取类

2.1.1 Student类

2.1.2 TestClass1主函数

2.2 获取类的构造器

2.2.1 获取类构造器

2.2.1.1Cat类

 2.2.1.2 主函数 TestConstructor

 2.2.2 获取类构造器的作用

2.2.2.1 Cat类

 2.2.2.2 主函数 TestConstructor

2.3 获取类的成员变量

2.3.1 获取类的成员变量 

2.3.1.1 Cat2类

 2.3.1.2 主函数

 2.3.2 获取类的成员变量 作用

2.3.2.2 Cat2类

 2.3.2.2 主函数

2.4 获取类的成员方法

2.4.1 获取类的成员方法

2.4.1.1 Cat3类

 2.4.1.2 主函数

2.4.2 获取类的成员方法的作用

2.4.2.1 Cat3类

 2.4.2.2 主函数

2.5 作用、变量

2.5.1 Teacher类

 2.5.2 Student2类

2.5.3 ObjectFrame类

2.5.4 主方法

3 注解

3.1 概述、自定义注解

 3.1.1 注解MyTest1

 3.1.2 注解MyTest2（不要复制 MyTest1，我复制发现有问题）

 3.1.3 创建类AnnotationTest1 使用注解

3.2 注解的原理​编辑

3.3 元注解

3.4 注解的解析

 3.4.1 MyTest4 注解

 3.4.2 Demo类

 3.4.3 AnnotationTest3测试类

3.5 应用场景  -模拟Junit框架设计 

 3.5.1 MyTest注解

 3.5.2 测试方法AnnotationTest4

4 动态代理

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

 4.1.1 Star接口

 4.1.2 BigStar类

 4.1.3 ProxyUtil代理类

 4.1.4 主函数Test

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

4.2.1 接口UserService

4.2.2 实现接口类UserServiceImpl

4.2.3 代理工具类ProxyUtil

4.2.4 主函数Test

前言：单元测试Junit框架入门、反射、注解、动态代理使用

1 单元测试

1.1 概述

1.2 Junit框架快速入门

 1.3 案例1--Junit初体验

1.3.1 准备一个被测类 StringUnit

package com.runa;

public class StringUnit {

    public static void printNumber( String name){
        if(name == null){
            System.out.println(0);
            return; //停掉方法
        }

        System.out.println("名字的长度是：" + name.length());
    }



}

 1.3.2 为被测试类StringUnit定义一个对应的测试类StringUnitTest

package com.runa;

import org.junit.Test;

public class StringUnitTest {
    @Test //测试方法
    public void testPrintNumber(){
        StringUnit.printNumber("春天的菠菜");
        StringUnit.printNumber(null);
    }

  

}

 1.3.3 引入junit框架（在StringUnitTest操作）

在@Test 注释上按住Alt+ Enter，选择JUnit4

 OK

 1.3.4 在测试方法执行测试

 1.3.5 查看结果

 

 

1.4 案例2 -- Junit--断言机制

1.4.1 准备一个被测类 StringUnit

package com.runa;

public class StringUnit {

    public static void printNumber( String name){
        if(name == null){
            System.out.println(0);
            return; //停掉方法
        }

        System.out.println("名字的长度是：" + name.length());
    }

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

}

 1.4.2 为被测试类StringUnit定义一个对应的测试类StringUnitTest

package com.runa;

import org.junit.Assert;
import org.junit.Test;

public class StringUnitTest {
    @Test //测试方法
    public void testPrintNumber(){
        StringUnit.printNumber("春天的菠菜");
        StringUnit.printNumber(null);
    }

    @Test //测试方法
    public void testGetMaxIndex(){
        int index1 = StringUnit.getMaxIndex(null);
        System.out.println(index1);
        int index2 =StringUnit.getMaxIndex("春天的菠菜");
        // 断言机制，程序员可以通过预测业务方法的结果
        Assert.assertEquals("不一致，方法有bug",4,index2);

    }

}

 1.4.3 执行，查看断言的效果

1.5 执行范围

1.5.1 方法上面执行

执行这个方法测试

1.5.2 类上面执行

执行这个类测试

1.5.3 模块上面执行

执行这个模块的测试

 

 

 

1.6 Junit框架的常见注解（Junit4.XXX版本）

 

1.6.1 准备一个被测类 StringUnit

package com.runa;

public class StringUnit {

    public static void printNumber( String name){
        if(name == null){
            System.out.println(0);
            return; //停掉方法
        }

        System.out.println("名字的长度是：" + name.length());
    }

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

}

 1.6.2 为被测试类StringUnit定义一个对应的测试类StringUnitTest

package com.runa;

import org.junit.*;

public class StringUnitTest {
    @Before
    public void test1(){
        System.out.println("每个测试方法开始的执行--------》Before");
    }

    @After
    public void test2(){
        System.out.println("每个测试方法结束的执行--------》After");
    }

    @BeforeClass
    public static void test3(){
        System.out.println("每个静态方法开始的执行--------》BeforeClass");
    }

    @AfterClass
    public static void test4(){
        System.out.println("每个静态方法结束的执行--------》AfterClass");
    }



    @Test //测试方法
    public void testPrintNumber(){
        StringUnit.printNumber("春天的菠菜");
        StringUnit.printNumber(null);
    }

    @Test //测试方法
    public void testGetMaxIndex(){
        int index1 = StringUnit.getMaxIndex(null);
        System.out.println(index1);
        int index2 =StringUnit.getMaxIndex("春天的菠菜");
        // 断言机制，程序员可以通过预测业务方法的结果
        Assert.assertEquals("不一致，方法有bug",4,index2);

    }

}

 1.6.3 执行，查看运行结果

1.7 Junit框架的常见注解（Junit5.XXX版本）

2 反射（了解）

2.1 认识反射、获取类

  

 

2.1.1 Student类

package com.reflect;

public class Student {



}

2.1.2 TestClass1主函数

package com.reflect;

public class TestClass1 {
    public static void main(String[] args) throws Exception {
        // 第一种方式
        Class c1 = Student.class;
        System.out.println(c1.getName()); // 全类名
        System.out.println(c1.getSimpleName());// 简名

        // 第二种方式
        Class  c2 = Class.forName("com.reflect.Student");
        System.out.println(c2.getName());
        System.out.println(c1 == c2);//三种方式都是同一对象

        // 第三种方式
        Student s = new Student();
        Class  c3 = s.getClass();
        System.out.println(c3.getName());
        System.out.println(c3 == c2); //三种方式都是同一对象

    }
}

 

  

2.2 获取类的构造器

2.2.1 获取类构造器

2.2.1.1Cat类
package com.reflect;

public class Cat {

    private String name;
    private int age;
   

    public Cat() {
    }

    public Cat(String name, int age) {
        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;
    }

    
}
 2.2.1.2 主函数 TestConstructor
package com.reflect;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class TestConstructor {
    // 查询全部构造器
    @Test
    public void  testGetConstructors(){
        //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        // 获取类的全部构造器
        Constructor[] constructors = c.getDeclaredConstructors(); // c.getConstructors();  只能获取public修饰的的构造器
        // 遍历数组中的每个构造器对象
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->" + constructor.getParameterCount()); //查询构造器名和 有几个查询
        }
    }


    // 查询单个构造器，有参和无参的两种类型
    @Test
    public void testGetConstructor() throws Exception {
        //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        // 获取某个构造器，：无参的构造器
        Constructor constructor = c.getDeclaredConstructor(); // c.getConstructor(); 只能获取public修饰的
        System.out.println(constructor.getName() + "--->" + constructor.getParameterCount()); //查询构造器名和 有几个查询

        // 获取某个构造器，：有参的构造器
        Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class); // c.getConstructor(); 只能获取public修饰的
        System.out.println(constructor2.getName() + "--->" + constructor2.getParameterCount()); //查询构造器名和 有几个查询
    }
}

 

 2.2.2 获取类构造器的作用

2.2.2.1 Cat类
package com.reflect;

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

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

    public Cat() {
        System.out.println("无参数构造器执行了");
    }

    public Cat(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;
    }

  
}
 2.2.2.2 主函数 TestConstructor
package com.reflect;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class TestConstructor {
    // 查询全部构造器
    @Test
    public void  testGetConstructors(){
        //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        // 获取类的全部构造器
        Constructor[] constructors = c.getDeclaredConstructors(); // c.getConstructors();  只能获取public修饰的的构造器
        // 遍历数组中的每个构造器对象
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->" + constructor.getParameterCount()); //查询构造器名和 有几个查询
        }
    }


    // 查询单个构造器，有参和无参的两种类型
    @Test
    public void testGetConstructor() throws Exception {
        //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        // 获取某个构造器，：无参的构造器
        Constructor constructor = c.getDeclaredConstructor(); // c.getConstructor(); 只能获取public修饰的
        System.out.println(constructor.getName() + "--->" + constructor.getParameterCount()); //查询构造器名和 有几个查询
        constructor.setAccessible(true); // 禁止检查访问权限
        Cat cat = (Cat) constructor.newInstance();
        System.out.println(cat);

        // 获取某个构造器，：有参的构造器
        Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class); // c.getConstructor(); 只能获取public修饰的
        System.out.println(constructor2.getName() + "--->" + constructor2.getParameterCount()); //查询构造器名和 有几个查询
        constructor2.setAccessible(true); // 禁止检查访问权限
        Cat cat2 = (Cat) constructor2.newInstance("TOM", 3);
        System.out.println(cat2);
    }
}

 

2.3 获取类的成员变量

2.3.1 获取类的成员变量 

2.3.1.1 Cat2类
package com.reflect;

public class Cat2 {
    public static int a;
    public static final String COUNTY = "中国";
    private String name;
    private int age;

    public Cat2() {
        System.out.println("无参数构造器执行了");
    }

    public Cat2(String name, int age) {
        System.out.println("有参数构造器执行了");
        this.name = name;
        this.age = age;
    }
    public static int getA() {
        return a;
    }

    public static void setA(int a) {
        Cat2.a = a;
    }

    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;
    }
}
 2.3.1.2 主函数
package com.reflect;

import org.junit.Test;

import java.lang.reflect.Field;

public class TestField {
    @Test
    public void testGetField() throws Exception {
        //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat2.class;

        // 2 获取类的全部成员变量
        Field[] fields = c.getDeclaredFields(); //c.getFields(); 只能拿public修饰的
        // 遍历
        for (Field field : fields) {
            System.out.println(field.getName() + "类型： " + field.getType());
        }

        // 3 获取单个成员变量
        Field field = c.getDeclaredField("name"); //c.getField(); 只能拿public修饰的
        System.out.println(field.getName() + "类型： " + field.getType());


    }

}

 

 2.3.2 获取类的成员变量 作用

2.3.2.2 Cat2类
package com.reflect;

public class Cat2 {
    public static int a;
    public static final String COUNTY = "中国";
    private String name;
    private int age;

    public Cat2() {
        System.out.println("无参数构造器执行了");
    }

    public Cat2(String name, int age) {
        System.out.println("有参数构造器执行了");
        this.name = name;
        this.age = age;
    }
    public static int getA() {
        return a;
    }

    public static void setA(int a) {
        Cat2.a = a;
    }

    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 "Cat2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 2.3.2.2 主函数
package com.reflect;

import org.junit.Test;

import java.lang.reflect.Field;

public class TestField {
    @Test
    public void testGetField() throws Exception {
        //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat2.class;

        // 2 获取类的全部成员变量
        Field[] fields = c.getDeclaredFields(); //c.getFields(); 只能拿public修饰的
        // 遍历
        for (Field field : fields) {
            System.out.println(field.getName() + "类型： " + field.getType());
        }

        // 3 获取单个成员变量
        Field field = c.getDeclaredField("name"); //c.getField(); 只能拿public修饰的
        System.out.println(field.getName() + "类型： " + field.getType());

        // 赋值
        Cat2 cat = new Cat2();
        field.setAccessible(true); // 暴力反射，禁止访问控制权限
        field.set(cat, "咖啡猫");
        System.out.println(cat);

        // 取值
        String  name = (String) field.get(cat);
        System.out.println(name);


    }

}

 

2.4 获取类的成员方法

 

2.4.1 获取类的成员方法

2.4.1.1 Cat3类
package com.reflect;

public class Cat3 {
    public static int a;
    public static final String COUNTY = "中国";
    private String name;
    private int age;

    public Cat3() {
        System.out.println("无参数构造器执行了");
    }

    public Cat3(String name, int age) {
        System.out.println("有参数构造器执行了");
        this.name = name;
        this.age = age;
    }
    private void run(){
        System.out.println("跑得很快~~~~");
    }
    public void eat(){
        System.out.println("爱吃鱼~~~~");
    }

    private String eat(String name){
       return "最爱吃：" + name;

    }

    public static int getA() {
        return a;
    }

    public static void setA(int a) {
        Cat3.a = a;
    }

    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 "Cat2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 2.4.1.2 主函数
package com.reflect;

import org.junit.Test;

import java.lang.reflect.Method;

public class TestMethod {
    @Test
    public void testGetMethods() throws Exception {
            //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat3.class;
        
        // 2 获取全部类的全部成员方法
        Method[] declaredMethods = c.getDeclaredMethods();
        // 3 遍历
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName() + "-->"
                    + declaredMethod.getParameterCount()
                    + "-->" + declaredMethod.getReturnType());

        }
        System.out.println("=================");
        // 4 获取某个方法对象
        Method run = c.getDeclaredMethod("run"); //拿run方法 无参数
        System.out.println(run.getName() + "-->"
                + run.getParameterCount()
                + "-->" + run.getReturnType());

        Method eat = c.getDeclaredMethod("eat",String.class); //拿eat方法 有参数
        System.out.println(eat.getName() + "-->"
                + eat.getParameterCount()
                + "-->" + eat.getReturnType());

    }
}

 

2.4.2 获取类的成员方法的作用

2.4.2.1 Cat3类
package com.reflect;

public class Cat3 {
    public static int a;
    public static final String COUNTY = "中国";
    private String name;
    private int age;

    public Cat3() {
        System.out.println("无参数构造器执行了");
    }

    public Cat3(String name, int age) {
        System.out.println("有参数构造器执行了");
        this.name = name;
        this.age = age;
    }
    private void run(){
        System.out.println("跑得很快~~~~");
    }
    public void eat(){
        System.out.println("爱吃鱼~~~~");
    }

    private String eat(String name){
       return "最爱吃：" + name;

    }

    public static int getA() {
        return a;
    }

    public static void setA(int a) {
        Cat3.a = a;
    }

    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 "Cat2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 2.4.2.2 主函数
package com.reflect;

import org.junit.Test;

import java.lang.reflect.Method;

public class TestMethod {
    @Test
    public void testGetMethods() throws Exception {
            //1   反射第一步：必须先得到这个类的Class对象
        Class c = Cat3.class;
        
        // 2 获取全部类的全部成员方法
        Method[] declaredMethods = c.getDeclaredMethods();
        // 3 遍历
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName() + "-->"
                    + declaredMethod.getParameterCount()
                    + "-->" + declaredMethod.getReturnType());

        }
        System.out.println("=================");
        // 4 获取某个方法对象
        Method run = c.getDeclaredMethod("run"); //拿run方法 无参数
        System.out.println(run.getName() + "-->"
                + run.getParameterCount()
                + "-->" + run.getReturnType());

        Method eat = c.getDeclaredMethod("eat",String.class); //拿eat方法 有参数
        System.out.println(eat.getName() + "-->"
                + eat.getParameterCount()
                + "-->" + eat.getReturnType());

        Cat3 cat = new Cat3();
        run.setAccessible(true); // 禁止检查访问权限
        Object rs = run.invoke(cat); //调用无参数的run方法。用cat对象歘调用的
        System.out.println(rs);


        Cat3 cat2 = new Cat3();
        eat.setAccessible(true); // 禁止检查访问权限
        Object rs2 = eat.invoke(cat2,"鱼儿"); //调用有参数的eat方法。用cat对象歘调用的
        System.out.println(rs2);

    }
}

 

 

2.5 作用、变量

  

2.5.1 Teacher类

 

package com.reflect;

public class Teacher {
    private String name;
    private Double salary;

    public Teacher() {
    }

    public Teacher(String name, Double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }
}

 2.5.2 Student2类

package com.reflect;

public class Student2 {
    private String name;
    private int age;
    private char sex;
    private double height;
    private String hobby;

    public Student2() {
    }

    public Student2(String name, int age, char sex, double height, String hobby) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.hobby = hobby;
    }

    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 char getSex() {
        return sex;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getHobby() {
        return hobby;
    }

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

2.5.3 ObjectFrame类

package com.reflect;

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;

public class ObjectFrame {
    // 目标：保存任务对象的字段和其数据到文件中去
    public static void saveObject(Object obj) throws Exception {
        PrintStream ps = new PrintStream(new FileOutputStream("C:\\Users\\cheng\\IdeaProjects\\FirstJava\\opp-junit\\src\\data.txt", true));  // 这个地方没有使用相对路径成功，未找到原因
        // obj   是任意对象，到底有多少个字段要保存
        Class c = obj.getClass();
        String cName = c.getSimpleName();
        ps.println("-------------------" + cName + "--------------------");
        // 2 从这个类中提取它的全部成员变量
        Field[] fields = c.getDeclaredFields();
        // 3 遍历
        for (Field field : fields) {
            // 4 拿到成员变量的命中
            String name = field.getName();
            // 5 拿到这个成员遍历在对象中的数据
            field.setAccessible(true); // 禁止检查访问控制
            String value = field.get(obj) + "";
            ps.println(name + "=" + value);
        }
        ps.close();

    }
}

2.5.4 主方法

package com.reflect;

import org.junit.Test;

public class TestFrame {
    @Test
    public void save() throws  Exception{
        Student2 s1 = new Student2("菠菜", 30, '男' , 175, "实战");
        Teacher t1 = new Teacher("黑泽",999.88);

        // 需求：把任意对象的字段名和其对应的值等信息，保存到文件当中去
        ObjectFrame.saveObject(s1);
        ObjectFrame.saveObject(t1);
    }
}

 

3 注解

3.1 概述、自定义注解

 

 3.1.1 注解MyTest1

package com.annotation;

public @interface MyTest1 {
    String aaa();
    boolean bbb() default true;
    String[] ccc();
}

 3.1.2 注解MyTest2（不要复制 MyTest1，我复制发现有问题）

package com.annotation;

public @interface MyTest2 {
    String value();
}

 3.1.3 创建类AnnotationTest1 使用注解

package com.annotation;

@MyTest1(aaa="牛魔王",ccc={"HTML", "JAVA"})
//@MyTest2(value = "孙悟空")
@MyTest2("孙悟空")
public class AnnotationTest1 {
    @MyTest1(aaa="牛魔王",bbb = false, ccc={"python", "HTML", "JAVA"})
    public void test1(){

    }
}

3.2 注解的原理

   

3.3 元注解

 

 

  

3.4 注解的解析

 3.4.1 MyTest4 注解

package com.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 aaa() default 100;
    String[] bbb();
}

 3.4.2 Demo类

package com.annotation;
@MyTest4(value = "孙悟空", aaa = 100.01, bbb = {"紫霞仙子", "春天的菠菜"})
public class Demo {

    @MyTest4(value = "白骨精", aaa = 120.01, bbb = {"猪八戒", "春天的菠菜"})
    public void test1(){

    }
}

 3.4.3 AnnotationTest3测试类

package com.annotation;

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 解析类上的注解
        // 判断类上是否包含某个注解
        if(c.isAnnotationPresent(MyTest4.class)){
            MyTest4 myTest4 = (MyTest4) c.getDeclaredAnnotation(MyTest4.class);
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(Arrays.toString(myTest4.bbb()));
        }
    }

    @Test
    public void parseMethod() throws Exception{
        // 1   先获得class对象
        Class c = Demo.class;
        // 2 再获得方法对象
        Method method = c.getDeclaredMethod("test1");
        // 2 解析方法上的注解
        // 判断方法上是否包含某个注解
        if(method.isAnnotationPresent(MyTest4.class)){
            MyTest4 myTest4 = (MyTest4) method.getDeclaredAnnotation(MyTest4.class);
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(Arrays.toString(myTest4.bbb()));
        }
    }

}

 

 

3.5 应用场景  -模拟Junit框架设计 

 3.5.1 MyTest注解

package com.annotation;

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

 3.5.2 测试方法AnnotationTest4

package com.annotation;

import java.lang.reflect.Method;

public class AnnotationTest4 {
//    @MyTest
    public void test1(){
        System.out.println("==============test1============");
    }

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

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

//    @MyTest
    public void test4(){
        System.out.println("==============test4============");
    }

    public static void main(String[] args) throws Exception{
        AnnotationTest4 a = new AnnotationTest4();
        // 启动程序
        // 1 得到class对象
        Class c = AnnotationTest4.class;
        // 2 提取全部成员方法
        Method[] methods = c.getDeclaredMethods();
        // 3 遍历数组的每个方法，看方法是否存在MyTest注解,存在触发执行
        for (Method method : methods) {
            if(method.isAnnotationPresent(MyTest.class)){
                //  说明当前方法上存在MyTest注解，触发执行
                method.invoke(a);

            }
        }


    }
}

 

 

4 动态代理

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

 

 

 4.1.1 Star接口

package com.proxy;

public interface Star {
    String sing(String name);
    void dance();
}

 4.1.2 BigStar类

package com.proxy;

public class BigStar implements Star{
    private String name;

    public BigStar(String name) {
        this.name = name;
    }
    public String sing(String name){
        System.out.println(this.name + "正在唱" + name);
        return "谢谢！谢谢";
    }

    public void dance(){
        System.out.println(this.name + "正在优雅的跳舞");
    }
}

 4.1.3 ProxyUtil代理类

package com.proxy;

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

public class ProxyUtil {
    public static Star creatProxy(BigStar bigStar){
        // 参数1  用于指定一个类加载器
        // 参数2  指定生成的代理长生么样子，也就是有哪些方法
        // 参数3  用来指定生成的代理对象要干什么事情
        Star starProxy = (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                new Class[]{Star.class}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 代理对象要做的事情，会在这里写代码
                        if(method.getName().equals("sing")){
                            System.out.println("准备话筒,收钱100万");
                        }else if(method.getName().equals("dance")){
                            System.out.println("准备场地，收钱200万");
                        }
                        return method.invoke(bigStar, args);
                    }
                });
        return starProxy;
    }
}

 4.1.4 主函数Test

package com.proxy;

public class Test {
    public static void main(String[] args) {
        BigStar s = new BigStar("春天的菠菜");
        Star starProxy = ProxyUtil.creatProxy(s);
        String rs = starProxy.sing("柠檬树");
        System.out.println(rs);
        System.out.println("-------------------");
        starProxy.dance();
    }
}

 

 

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

4.2.1 接口UserService

 

package com.proxy2;

public interface UserService {
    // 登录功能
    void login(String loginName, String password) throws Exception;

    // 删除用户
    void deleteUsers() throws Exception;
    // 查询用户，返回数组形式
    String[] selectUsers() throws Exception;
}

4.2.2 实现接口类UserServiceImpl

package com.proxy2;

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("你登录失败，用户名或密码错误~");
        }

    }

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


    }

    @Override
    public String[] selectUsers() throws Exception {
        System.out.println("查询出了3个用户");
        String[] names = {"邱淑贞", "小玛丽", "黑泽"};
        Thread.sleep(500);
        return names;
    }
}

4.2.3 代理工具类ProxyUtil

package com.proxy2;

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

public class ProxyUtil {
    public static UserService createProxy(UserService userService){
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                new Class[]{UserService.class}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if(method.getName().equals("login") || method.getName().equals("deleteUsers")
                                || method.getName().equals("selectUsers")){
                            long startTime = System.currentTimeMillis();
                            Object rs = method.invoke(userService, args);

                            long endTime = System.currentTimeMillis();
                            System.out.println(method.getName() + "方法执行耗时：" + (endTime - startTime) / 1000.0 + "s");
                            return rs;
                        }else{
                            Object rs = method.invoke(userService, args);
                            return rs;
                        }
                    }
                });
        return userServiceProxy;
    }
}

4.2.4 主函数Test

package com.proxy2;

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

public class ProxyUtil {
    public static UserService createProxy(UserService userService){
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                new Class[]{UserService.class}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if(method.getName().equals("login") || method.getName().equals("deleteUsers")
                                || method.getName().equals("selectUsers")){
                            long startTime = System.currentTimeMillis();
                            Object rs = method.invoke(userService, args);

                            long endTime = System.currentTimeMillis();
                            System.out.println(method.getName() + "方法执行耗时：" + (endTime - startTime) / 1000.0 + "s");
                            return rs;
                        }else{
                            Object rs = method.invoke(userService, args);
                            return rs;
                        }
                    }
                });
        return userServiceProxy;
    }
}

标签
#java
Java反射机制、代理模式和装饰器模式以及IOC、Tcp3次握手4次挥手
の博客
03-23 262
1.反射机制 2.挥手握手
Java动态代理及其应用案例
m0_65731386的博客
03-28 650
Java动态代理是一种很有用的技术，它可以很方便地实现AOP编程、RPC框架、单元测试等功能。在使用Java动态代理时，我们需要注意被代理对象必须实现一个接口，同时需要编写一个实现了接口的代理处理器类。通过动态地生成代理类，并将其绑定到被代理对象上，我们就可以很方便地实现方法的增强、远程方法调用等功能。
Java进阶-测试方法
qq_56999608的博客
03-04 1982
来学习一下软件测试相关的方法，了解一下黑盒测试和白盒测试，以及后面要用到的JUnit单元测试。JUnit单元测试也属于白盒测试，这次内容较少且相对简单。
Java测试类的编写与使用
qq_53361043的博客
12-14 8218
Java测试类 初学Java，有什么不对不好的地方，希望大家能多多指教 一，Java测试类的编写 大家好，今天从课本上看到一个题目，其中要用到测试类的知识，在刚开始学习 Java的时候，我也对测试类非常困扰，今天我们就来好好聊一聊Java的测试类。 ...
java单元测试之junit之实战
热门推荐
mcrwayfun，欢迎你
03-21 4万+
1 编写该文章的起因 博主是一枚小新，经常挖坑填坑。最近在工作中遇到了这样一种情况。某天小伙伴说博主写得一个方法有问题，并且相应的测试类也跑不通。博主一直秉着磨刀不误砍柴工的思想，测试类都是写得好好地并且能杠杠运行的！怀着好奇，经过一番debug，发现某句代码抛出了空指针，如下 String url = linkedService.getUrlById(id); getUrlById是通...
Java基础——高级技术
weixin_68853331的博客
11-16 617
特殊属性名：value，如果注解中只有一个value属性，使用注解时，value名称可以不写！！
【Java基础四】
qq_61915513的博客
04-26 843
标准ASCII字符集ASCII(American Standard Code for Information Interchange):美国信息交换标准代码,包括了英文、符号等.标准ASCI使用1个字节存储一个字符,首位是0，总共可表示128个字符,对美国佬来说完全够用.GBK(汉字内码扩展规范,国标)汉字编码字符集,包含了2万多个汉字等字符,GBK中一个中文字符编码成两个字节的形式存储.注意:GBK兼容了ASCII字符集.GBK规定:汉字的第一个字节的第一位须是1。
Java反射的终极理解与应用！
weixin_51980608的博客
04-08 468
今天实习的时候，因为我需要预留一个回调地址接收别人的处理结果，但是结果集有点复杂，一层套一层，所以我一直纠结于该用什么对象去接收，怎么定义成员变量。绕了半天别人说不用在乎这些，问我知不知道什么是反射，我脑袋里似乎想到了什么但又不是很明白所以当时搪塞了过去，下来准备去看看反射。最初接触Java的时候包括到现在一直没有自己用过反射，但是听说过，很多厉害一点的东西包括框架都会用到反射（spring、mybatis、rocketmq等等）。所以Java要进阶，必须懂反射。
Java提高与实践
Moliay的博客
11-09 274
IO流 IO流概述 文件字节输入流：每次读取一个字节 package fileStream; import java.io.*; public class HelloFileInputStream { public static void main(String[] args) throws IOException { //创建文件字节输入流 管道，与源文件接通 //写法一 //InputStream is = new FileInpu
每周小记——Spring框架
weixin_57655687的博客
05-19 1534
本文解析了Spring框架的四大核心机制：工厂模式通过BeanFactory和ApplicationContext实现Bean生命周期管理，奠定IoC容器基础；控制反转与依赖注入将对象创建权移交容器，通过配置解耦组件，提升系统灵活性；面向切面编程基于代理模式（静态/JDK动态/CGLIB）实现横切关注点（如日志、事务）与业务逻辑分离，并总结了五种通知类型及其配置方法。文章系统阐述了Spring如何通过设计模式优化Java企业级开发，强化代码可维护性与模块化，凸显其在现代架构中的关键作用
一款针对Spring漏洞框架进行快速利用的图形化工具
LiBai'S BLOG
06-29 343
一款针对Spring漏洞框架进行快速利用的图形化工具。
TDA4系统启动流程
最新发布
weixin_34799243的博客
07-01 34
本文描述了基于TIFS、Main R5和A53处理器的系统启动流程。启动过程分为三个阶段：首先由ROM引导加载tiboot3.bin并进行认证，然后加载系统固件到TIFS核心；接着R5 SPL进行DDR配置并加载tispl.bin，同时启动A53处理器；最后A53运行ATF/OPTEE安全固件和SPL，最终加载U-Boot并进入命令行界面。整个过程采用分层验证机制，包含X.509证书认证环节，确保启动链的安全性。
电商系统不是技术堆叠：LikeShop如何用分层Hold住复杂业务？
Zmq83906955的博客
06-29 524
Java开发语音👩‍💻、一键部署、文档清晰📄、小程序、代码规范
Java while 循环
2601_95592363的博客
06-29 203
truefalse。
Java写入Doris全方案演进汇总（原生HTTP｜高阶封装｜官方SDK｜第三方生态SDK｜终极选型对比）
苍煜
06-26 348
✅ 优点：零依赖、最轻量、任何环境可运行❌ 缺点：无连接池、频繁创建销毁连接、无失败重试、不处理FE307重定向、不支持GZIP压缩、无日志、无异常兜底、不支持高并发如果不写重定向，http客户端底层会自动请求，但是有概率丢失请求头，自定义Heade，丢失报文等，所以不推荐生产使用1、极致精简：删除冗余重复代码、统一工具方法、结构清晰，无多余逻辑2、注释全覆盖：每一个请求头、每一步逻辑、核心机制全部附带通俗释义，新手也能看懂3、补齐完整调用Demo：含Authorization鉴权生成、
信创版Java医院影像管理系统PACS （springboot+vue）
源码技术栈的博客
06-27 362
医院影像管理系统实现全流程数字化管理，覆盖放射、超声、病理三大专科。系统采用Vue3+SpringBoot技术架构，支持DICOM标准，包含从登记、检查、诊断到归档的完整工作流程。重点解析了DR、CT、MR、US、PATH、PET等主流检查技术的成像原理与临床适用场景：DR用于骨骼筛查，CT是急诊首选，MR擅长软组织成像，US无创实时，PATH是肿瘤诊断金标准，PET可显示代谢活性。系统实现影像数据全生命周期管理，提升诊疗效率与数据安全性。
【数据结构】排序算法（二）：交换排序——从冒泡到快排的分治进化
weixin_61091020的博客
06-28 6650
交换排序——冒泡排序，快速排序
知识点之企业知识库RAG（一）
IManiy的博客
06-26 236
本文详细解析了阿里企业知识库RAG二面的10道真题，涵盖了数据清洗、文档切片、表格处理、权限过滤、增量更新、多路召回、答案引用、拒答机制、效果评估及常见踩坑点等核心内容。这些题目不仅考察了RAG系统的技术实现，更强调了数据治理和工程闭环的重要性。通过深入分析每一道题目的技术细节和实际应用场景，我们能够更好地理解企业在构建RAG系统时所面临的挑战，并掌握相应的解决方案。
08 一文讲清楚memory，claude.md与skill
m0_73980980的博客
06-29 347
文章摘要（149字）： Claude Code通过四层记忆架构解决Agent失忆问题：1) 永久索引（MEMORY.md）自动记录关键偏好；2) 按需深度加载，通过轻量级调用注入相关记忆；3) 实时配置（CLAUDE.md）动态加载项目环境；4) 档案层（Transcripts）支持搜索但不加载历史。结合自动记忆提取与定期整理的Auto Dream机制，实现记忆持久化与认知优化，确保跨会话一致性。该设计平衡了上下文限制与长期记忆需求，通过分层策略提升Agent的连续性表现。
SpringBoot 实现 QPS 监控：从原理到高性能实战
专注分享原创技术干货。大厂资深架构师，多年技术架构与技术管理经验，多年面试官经验。一对一技术指导培训，带你从小白到入门到架构设计到技术管理。关注我，免费领取学习资料。一对一免费面试指导，快速拿offer。
06-30 401
以下是文章摘要： 摘要：微服务架构下高并发QPS监控方案设计 本文提出一种基于滑动窗口算法的高性能QPS监控方案，重点解决传统固定窗口统计存在的临界点问题和数据精度不足的缺陷。方案采用Spring Boot+Micrometer技术栈，核心创新点包括： 数据结构优化：结合环形缓冲区(RingBuffer)与LongAdder实现无锁化计数，相比AtomicInteger性能提升5-8倍（JMH基准测试） 动态维度支持：通过ConcurrentHashMap维护URI维度的独立计数器，支持业务级细粒度监控 时
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

春天的菠菜

一毛两毛也是动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值