前言

Java进阶课程的第六篇，也是最后一篇，junit单元测试,反射,注解,动态代理相关内容

---

包含知识点

 junit单元测试

反射

1.内部类Student：

包含私有/公共字段和方法

包含默认构造器和私有构造器

2.获取Class对象的三种方式：

.class 语法直接获取

通过对象实例的getClass()方法获取

最常用的Class.forName()动态加载方式

3.反射创建对象：

通过无参构造器创建实例

访问私有构造器创建实例（需要设置setAccessible(true)）

4.字段操作：

访问公共字段直接修改值

访问私有字段需要设置可访问权限

5.方法调用：

调用公共方法

调用私有方法需要设置可访问权限

演示带参数方法的调用

6.类结构信息获取：

获取类名和方法列表

区分getMethods()和getDeclaredMethods()的区别

7.关键点说明：

setAccessible(true)可以突破私有成员的访问限制，但会破坏封装性

反射操作需要处理各种异常（本示例直接抛出简化代码）

反射的性能较低，适合框架开发等需要高度灵活性的场景

反射可以访问到类的完整结构信息，包括注解、泛型等

注解

1.自定义注解：
使用@interface关键字来定义一个新的注解类型。例如：public @interface MyInterface {}。
注解可以包含成员变量（也称作元素），这些成员变量可以有默认值或必须在使用时提供值。
元注解（Meta-annotations）：
@Target指定注解的应用目标（如方法、字段等）。例如：@Target({ElementType.METHOD})表示该注解只能应用于方法上。
@Retention定义了注解的生命周期，RetentionPolicy.RUNTIME表示该注解将在运行时保留，可以通过反射读取。
2.注解的使用：
注解可以直接应用到类、方法或字段上，通过在它们之前加上注解名称并提供必要的参数值。例如：@MyTest(count = 2)。
3.反射与注解：
利用Java的反射机制，可以在运行时检查类、方法或字段上的注解。例如，通过method.isAnnotationPresent(MyTest.class)判断方法是否被特定注解标记，并通过method.getDeclaredAnnotation(MyTest.class)获取注解实例。
反射还可以用于调用带有注解的方法，如示例中method.invoke(ad)执行被@MyTest注解标记的方法。
4.注解属性的默认值：
注解成员可以设置默认值，如果在使用注解时不提供值，则会使用默认值。例如：int count() default 1;。
5.特殊属性value：
如果注解只有一个名为value的成员，在使用注解时可以省略成员名直接提供值。例如：@MyInterface("delete")相当于@MyInterface(value="delete")。

动态代理

1.业务接口 (UserService)

定义代理类和真实类共同遵守的规范

动态代理只能基于接口实现

2.真实对象 (UserServiceImpl)

实际业务逻辑的实现类

包含需要被增强的核心逻辑

3.调用处理器 (LoggingHandler)

实现InvocationHandler接口

持有真实对象引用（目标对象）

invoke()方法中实现统一代理逻辑

通过反射调用真实方法（method.invoke()）

可以添加前置/后置增强逻辑（如日志、事务等）

4.代理对象创建 (Proxy.newProxyInstance)

参数1：类加载器（通常使用接口的类加载器）

参数2：代理类需要实现的接口数组

参数3：调用处理器实例

返回实现指定接口的代理对象

5.动态代理特点：

运行时动态生成代理类（通过ProxyGenerator生成）

代理类名通常为$Proxy+数字

继承Proxy类（所以不能代理类，只能代理接口）

实现了指定的业务接口

方法调用会被路由到InvocationHandler

6.典型应用场景：

AOP编程（日志、事务、权限控制）

RPC框架调用

服务接口的监控统计

单元测试Mock对象

7.注意事项：

代理对象的方法调用都会经过invoke方法

在invoke方法中谨慎使用proxy参数，容易引发递归调用

性能相比静态代理略低（反射调用）

无法代理final类和final方法

---

具体代码

 junit单元测试

package ADV_0;import org.junit.Test;class StringUtil {//业务类的一个方法public static void printNumber(String name){if(name == null){System.out.println("参数为null");return;}System.out.println("名字长度是：" + name.length());}
}// 测试类：junit单元测试框架，对业务类方法进行测试
public class StringUtilTest {// 测试方法：必公开public，无参，无返回值// 测试方法必须加上@Test注解（Junit核心）@Testpublic void testPrint() {StringUtil.printNumber("微光zc"); // 5// 测试用例，测试核心，各种情况下的测试StringUtil.printNumber("");StringUtil.printNumber(null);}
}

反射

package ADV_0;import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;/*** Java反射机制示例类* 演示如何通过反射操作类信息、创建对象、访问字段和调用方法*/
public class ADVZc5 {// 示例用内部类static class Student {private String name;public int age;public Student() {this.name = "Default";this.age = 18;}private Student(String name) {this.name = name;this.age = 20;}public void showInfo() {System.out.println("Student: " + name + ", " + age);}private void setAge(int age) {this.age = age;}}public static void main(String[] args) throws Exception {System.out.println("加载类，获取类的字节码：Class对象");System.out.println("获取类的构造器：Constructor对象");System.out.println("获取类的成员变量：Field对象");System.out.println("获取类的成员方法：MMethod对象");// 1. 获取Class对象的三种方式// 方式一：通过类名.class获取Class<Student> clazz1 = Student.class;// 方式二：通过对象.getClass()获取Student student = new Student();Class<? extends Student> clazz2 = student.getClass();// 方式三：通过Class.forName()获取（最常用）Class<?> clazz3 = Class.forName("ADV_0.ADVZc6$Student"); // 内部类需要用$符号System.out.println("三个Class对象是否相同：" + (clazz1 == clazz2 && clazz2 == clazz3));// 2. 通过反射创建对象// 使用无参构造器Constructor<?> constructor1 = clazz1.getDeclaredConstructor();Student s1 = (Student) constructor1.newInstance();s1.showInfo();// 使用私有构造器（需要设置可访问）Constructor<?> constructor2 = clazz1.getDeclaredConstructor(String.class);constructor2.setAccessible(true); // 突破私有访问限制Student s2 = (Student) constructor2.newInstance("Alice");s2.showInfo();// 3. 访问字段// 访问公共字段Field ageField = clazz1.getField("age");ageField.set(s1, 25); // 等价于 s1.age = 25System.out.print("修改公共字段后：");s1.showInfo();// 访问私有字段（需要设置可访问）Field nameField = clazz1.getDeclaredField("name");nameField.setAccessible(true);nameField.set(s1, "Bob"); // 等价于 s1.name = "Bob"System.out.print("修改私有字段后：");s1.showInfo();// 4. 调用方法// 调用公共方法Method showInfoMethod = clazz1.getMethod("showInfo");System.out.print("反射调用方法：");showInfoMethod.invoke(s2);// 调用私有方法（需要设置可访问）Method setAgeMethod = clazz1.getDeclaredMethod("setAge", int.class);setAgeMethod.setAccessible(true);setAgeMethod.invoke(s2, 30);System.out.print("修改私有字段后：");s2.showInfo();// 5. 获取类结构信息System.out.println("\n类结构信息：");System.out.println("类名：" + clazz1.getName());System.out.println("简单类名：" + clazz1.getSimpleName());System.out.println("公共方法列表：");for (Method method : clazz1.getMethods()) {System.out.println("  " + method.getName());}System.out.println("声明字段列表：");for (Field field : clazz1.getDeclaredFields()) {System.out.println("  " + field.getName());}System.out.println("===反射的基本作用===");// 1、类的全部成分的获取// 2、可以破坏封装性// 3、可以绕过泛型的约束System.out.println("===反射的应用：做框架的通用技术===");}
}

注解

package ADV_0;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;public class ADVZc6 {// 自定义注解public @interface MyInterface {String name();int age() default 18;String[] address();}
}@Target({ElementType.METHOD}) // 表示注解的作用目标为方法
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
@interface MyTest {int count() default 1; // 表示注解的属性
}
@Target({ElementType.METHOD, ElementType.FIELD}) // 表示注解的作用目标为方法,成员变量
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
@interface MyTest1 {
}@Target({ElementType.METHOD, ElementType.TYPE}) // 表示注解的作用目标为方法,成员变量
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
@interface MyTest2 {String value();double height() default 169.5;String[] address();
}@ADVZc6.MyInterface(name = "赵丽颖", age = 18, address = {"北京", "上海"})
//@MyInterface(age = "delete")
//@MyInterface("delete") // 特殊属性value，在使用时如果只有一个value属性，value名称可以不写
class AnnotationDemo1 {@ADVZc6.MyInterface(name = "王菲", age = 52, address = {"北京", "香港"})public static void main( String[] args ) {// 目标：自定义注解。int a;}
}//@MyTest1
class AnnotationDemo2 {private int age;//@MyTest1public AnnotationDemo2(){}public static void main(String[] args) {//元注解的作用}public void getAgeTest(){}
}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);}}}}// 测试方法：public 无参 无返回值@MyTestpublic void test1(){System.out.println("test1方法执行了");}public void test2(){System.out.println("test2方法执行了");}@MyTest(count = 2)public void test3(){System.out.println("test3方法执行了");}@MyTestpublic void test4(){System.out.println("test4方法执行了");}
}

package ADV_0;import org.junit.Test;import java.lang.reflect.Method;
import java.util.Arrays;public class AnnotationDemo3 {//解析注解@Testpublic void parseClass() throws Exception {// 1.获取类对象Class c1 = Demo.class;// 2、使用isAnnotationPresent判断这个类上是否陈列了注解MyTest2if (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);}}@Testpublic void parseMethod() throws Exception {// 1.获取类对象Class c1 = Demo.class;// 2、获取方法对象Method method = c1.getMethod("go");// 3、使用isAnnotationPresent判断这个方法上是否陈列了注解MyTest2if (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);}}
}

动态代理

package ADV_0;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** 动态代理示例代码* 包含：接口定义、真实对象、调用处理器、客户端演示*/
public class ADVZc7 {// 1. 定义业务接口interface UserService {void addUser(String username);String getUser(int userId);}// 2. 真实对象（被代理类）static class UserServiceImpl implements UserService {@Overridepublic void addUser(String username) {System.out.println("真实方法: 添加用户 " + username);}@Overridepublic String getUser(int userId) {return "真实用户" + userId;}}// 3. 调用处理器（实现InvocationHandler）static class LoggingHandler implements InvocationHandler {private final Object target;  // 持有真实对象引用public LoggingHandler(Object target) {this.target = target;}/*** 代理方法调用的核心逻辑* @param proxy  代理对象（慎用）* @param method 被调用的方法对象* @param args   方法参数*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 前置增强System.out.println("[日志] 开始执行方法: " + method.getName());// 反射调用真实对象的方法Object result = method.invoke(target, args);// 后置增强System.out.println("[日志] 方法执行完成: " + method.getName());return result;}}public static void main(String[] args) {// 4. 创建真实对象UserService realService = new UserServiceImpl();// 5. 创建调用处理器InvocationHandler handler = new LoggingHandler(realService);// 6. 动态生成代理对象UserService proxyService = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), // 类加载器new Class[]{UserService.class},     // 代理接口数组handler                             // 调用处理器);// 7. 通过代理对象调用方法proxyService.addUser("张三");System.out.println("查询结果：" + proxyService.getUser(1001));// 打印代理类信息System.out.println("\n代理类名称: " + proxyService.getClass().getName());System.out.println("代理类父类: " + proxyService.getClass().getSuperclass());System.out.println("代理类实现的接口: ");for (Class<?> inter : proxyService.getClass().getInterfaces()) {System.out.println(" - " + inter.getName());}}
}