Java进阶six junit单元测试,反射,注解,动态代理
前言
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核心）
@Test
public 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 = 25
System.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;
//@MyTest1
public 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 无参 无返回值
@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方法执行了");
}
}
package ADV_0;
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);
}
}
@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);
}
}
}
动态代理
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 {
@Override
public void addUser(String username) {
System.out.println("真实方法: 添加用户 " + username);
}
@Override
public 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 方法参数
*/
@Override
public 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());
}
}
}