引言：反射——Java的动态灵魂
反射（Reflection）是Java语言的一个重要特性，它允许程序在运行时获取类的信息并操作类的属性和方法。这种“查看自身”的能力，让Java具备了动态性，是框架开发、测试工具、动态代理等高级特性的基石。
一、反射基础：Class对象的奥秘
1.1 获取Class对象的三种方式
public class ReflectionBasic {
public static void main(String[] args) throws ClassNotFoundException {
System.out.println("=== 获取Class对象的三种方式 ===");
// 方式1：通过类的.class属性（最安全，性能最好）
Class<String> stringClass1 = String.class;
System.out.println("String.class: " + stringClass1);
// 方式2：通过对象的getClass()方法
String str = "Hello";
Class<? extends String> stringClass2 = str.getClass();
System.out.println("str.getClass(): " + stringClass2);
// 方式3：通过Class.forName()（最灵活，但可能抛出ClassNotFoundException）
Class<?> stringClass3 = Class.forName("java.lang.String");
System.out.println("Class.forName(): " + stringClass3);
// 验证三种方式获取的是同一个Class对象
System.out.println("\n是否是同一个Class对象？");
System.out.println("stringClass1 == stringClass2: " + (stringClass1 == stringClass2));
System.out.println("stringClass2 == stringClass3: " + (stringClass2 == stringClass3));
// 基本数据类型的Class
System.out.println("\n=== 基本数据类型的Class ===");
System.out.println("int.class: " + int.class);
System.out.println("Integer.TYPE: " + Integer.TYPE); // 与int.class相同
System.out.println("Integer.class: " + Integer.class); // 包装类的Class
System.out.println("int.class == Integer.TYPE: " + (int.class == Integer.TYPE));
System.out.println("int.class == Integer.class: " + (int.class == Integer.class));
// 数组的Class
System.out.println("\n=== 数组的Class ===");
int[] intArray = new int[10];
String[] strArray = new String[5];
System.out.println("int[].class: " + intArray.getClass());
System.out.println("String[].class: " + strArray.getClass());
System.out.println("int[][].class: " + int[][].class);
// 判断是否为数组
System.out.println("\n是否为数组？");
System.out.println("intArray是数组: " + intArray.getClass().isArray());
System.out.println("String是数组: " + String.class.isArray());
}
}
1.2 类的基本信息获取
import java.lang.reflect.Modifier;
public class ClassInfoDemo {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("java.util.ArrayList");
System.out.println("=== ArrayList类的基本信息 ===");
// 获取完整类名
System.out.println("完整类名: " + clazz.getName());
System.out.println("简单类名: " + clazz.getSimpleName());
System.out.println("规范类名: " + clazz.getCanonicalName());
// 获取包信息
Package pkg = clazz.getPackage();
System.out.println("包名: " + pkg.getName());
// 获取修饰符
int modifiers = clazz.getModifiers();
System.out.println("\n修饰符信息:");
System.out.println("是否为public: " + Modifier.isPublic(modifiers));
System.out.println("是否为abstract: " + Modifier.isAbstract(modifiers));
System.out.println("是否为final: " + Modifier.isFinal(modifiers));
System.out.println("修饰符字符串: " + Modifier.toString(modifiers));
// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println("\n父类: " + superClass.getName());
// 获取实现的接口
Class<?>[] interfaces = clazz.getInterfaces();
System.out.println("实现的接口 (" + interfaces.length + " 个):");
for (Class<?> iface : interfaces) {
System.out.println(" - " + iface.getName());
}
// 获取类加载器
ClassLoader classLoader = clazz.getClassLoader();
System.out.println("\n类加载器: " + classLoader);
System.out.println("父类加载器: " + classLoader.getParent());
// 其他信息
System.out.println("\n其他信息:");
System.out.println("是否为接口: " + clazz.isInterface());
System.out.println("是否为枚举: " + clazz.isEnum());
System.out.println("是否为注解: " + clazz.isAnnotation());
System.out.println("是否为数组: " + clazz.isArray());
System.out.println("是否为基本类型: " + clazz.isPrimitive());
}
// 自定义一个复杂的类用于演示
public static class DemoClass extends ArrayList<String>
implements Serializable, Cloneable {
private static final long serialVersionUID = 1L;
private String privateField;
public int publicField;
protected List<String> protectedField;
public DemoClass() {}
private DemoClass(String arg) {}
public void publicMethod() {}
private void privateMethod() {}
protected void protectedMethod() {}
public static void staticMethod() {}
// 内部类
class InnerClass {}
static class StaticInnerClass {}
}
}
二、操作字段（Field）
2.1 获取和操作字段
import java.lang.reflect.Field;
import java.util.Arrays;
public class FieldOperation {
// 定义一个用于演示的类
static class Person {
private String name;
private int age;
public String publicField = "公有字段";
protected String protectedField = "受保护字段";
static final String CONSTANT = "常量";
private static int count = 0;
public Person(String name, int age) {
this.name = name;
this.age = age;
count++;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age +
", publicField='" + publicField +
"', count=" + count + "}";
}
}
public static void main(String[] args) throws Exception {
Person person = new Person("张三", 25);
System.out.println("原始对象: " + person);
Class<?> clazz = Person.class;
System.out.println("\n=== 1. 获取所有字段 ===");
// 获取所有声明的字段（包括私有字段）
Field[] allFields = clazz.getDeclaredFields();
System.out.println("所有字段 (" + allFields.length + " 个):");
for (Field field : allFields) {
System.out.println(" " + Modifier.toString(field.getModifiers()) +
" " + field.getType().getSimpleName() +
" " + field.getName());
}
// 获取所有公有字段（包括从父类继承的）
Field[] publicFields = clazz.getFields();
System.out.println("\n公有字段 (" + publicFields.length + " 个):");
for (Field field : publicFields) {
System.out.println(" " + field.getName());
}
System.out.println("\n=== 2. 访问私有字段 ===");
// 获取私有字段
Field nameField = clazz.getDeclaredField("name");
Field ageField = clazz.getDeclaredField("age");
// 设置可访问性（暴力反射）
nameField.setAccessible(true);
ageField.setAccessible(true);
// 读取字段值
String nameValue = (String) nameField.get(person);
int ageValue = ageField.getInt(person); // 使用类型特定的get方法
System.out.println("读取私有字段:");
System.out.println(" name: " + nameValue);
System.out.println(" age: " + ageValue);
// 修改字段值
nameField.set(person, "李四");
ageField.setInt(person, 30);
System.out.println("修改后: " + person);
System.out.println("\n=== 3. 访问静态字段 ===");
Field countField = clazz.getDeclaredField("count");
countField.setAccessible(true);
// 静态字段可以传入null作为对象参数
int countValue = countField.getInt(null);
System.out.println("静态字段 count: " + countValue);
// 修改静态字段
countField.set(null, 100);
System.out.println("修改静态字段后: " + person);
System.out.println("\n=== 4. 访问常量（final字段） ===");
Field constantField = clazz.getDeclaredField("CONSTANT");
constantField.setAccessible(true);
// 尝试修改final字段（Java 12+有限制）
try {
System.out.println("常量值: " + constantField.get(null));
// 移除final修饰符
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(constantField, constantField.getModifiers() & ~Modifier.FINAL);
// 修改常量值
constantField.set(null, "修改后的常量");
System.out.println("修改后的常量: " + constantField.get(null));
} catch (Exception e) {
System.out.println("修改常量失败: " + e.getMessage());
}
System.out.println("\n=== 5. 字段类型和注解信息 ===");
for (Field field : allFields) {
System.out.println("\n字段: " + field.getName());
System.out.println(" 类型: " + field.getType());
System.out.println(" 泛型类型: " + field.getGenericType());
System.out.println(" 注解: " + Arrays.toString(field.getAnnotations()));
// 判断字段类型
if (field.getType().isPrimitive()) {
System.out.println(" 是基本类型");
}
if (field.getType().isArray()) {
System.out.println(" 是数组类型");
}
}
}
}
2.2 复杂字段操作
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;
public class ComplexFieldOperation {
// 复杂类型演示类
static class ComplexClass {
private int[] intArray = {1, 2, 3};
private String[][] stringMatrix = {{"a", "b"}, {"c", "d"}};
private List<String> stringList = Arrays.asList("Java", "Python", "C++");
private Map<Integer, String> intStringMap = new HashMap<>();
private Set<? extends Number> numberSet = new HashSet<>(Arrays.asList(1, 2.5, 3L));
{
intStringMap.put(1, "One");
intStringMap.put(2, "Two");
}
}
public static void main(String[] args) throws Exception {
ComplexClass obj = new ComplexClass();
Class<?> clazz = ComplexClass.class;
System.out.println("=== 复杂字段操作演示 ===");
// 处理数组字段
Field intArrayField = clazz.getDeclaredField("intArray");
intArrayField.setAccessible(true);
int[] intArray = (int[]) intArrayField.get(obj);
System.out.println("\n1. 数组字段操作:");
System.out.println(" 数组长度: " + Array.getLength(intArray));
System.out.println(" 第一个元素: " + Array.get(intArray, 0));
// 修改数组元素
Array.set(intArray, 0, 100);
System.out.println(" 修改后的数组: " + Arrays.toString(intArray));
// 创建新数组
int[] newArray = (int[]) Array.newInstance(int.class, 5);
System.out.println(" 新创建的数组: " + Arrays.toString(newArray));
// 处理二维数组
Field matrixField = clazz.getDeclaredField("stringMatrix");
matrixField.setAccessible(true);
String[][] matrix = (String[][]) matrixField.get(obj);
System.out.println("\n2. 多维数组操作:");
System.out.println(" 矩阵维度: " + matrix.length + "x" + matrix[0].length);
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.println(" matrix[" + i + "][" + j + "] = " + matrix[i][j]);
}
}
// 处理泛型集合字段
Field listField = clazz.getDeclaredField("stringList");
listField.setAccessible(true);
List<String> list = (List<String>) listField.get(obj);
System.out.println("\n3. 泛型集合字段:");
System.out.println(" List内容: " + list);
// 获取泛型参数类型
Type genericType = listField.getGenericType();
if (genericType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) genericType;
System.out.println(" 原始类型: " + pType.getRawType());
System.out.println(" 泛型参数: " + Arrays.toString(pType.getActualTypeArguments()));
}
// 修改集合内容
list.add("JavaScript");
System.out.println(" 修改后的List: " + listField.get(obj));
// 处理Map字段
Field mapField = clazz.getDeclaredField("intStringMap");
mapField.setAccessible(true);
Map<Integer, String> map = (Map<Integer, String>) mapField.get(obj);
System.out.println("\n4. Map字段操作:");
System.out.println(" Map内容: " + map);
// 通过反射调用Map方法
map.put(3, "Three");
System.out.println(" 添加元素后: " + map);
// 处理通配符泛型字段
Field setField = clazz.getDeclaredField("numberSet");
setField.setAccessible(true);
Set<? extends Number> set = (Set<? extends Number>) setField.get(obj);
System.out.println("\n5. 通配符泛型字段:");
System.out.println(" Set内容: " + set);
// 获取通配符边界
Type wildcardType = setField.getGenericType();
if (wildcardType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) wildcardType;
Type[] actualTypes = pType.getActualTypeArguments();
if (actualTypes[0] instanceof java.lang.reflect.WildcardType) {
java.lang.reflect.WildcardType wildcard =
(java.lang.reflect.WildcardType) actualTypes[0];
System.out.println(" 上界: " + Arrays.toString(wildcard.getUpperBounds()));
System.out.println(" 下界: " + Arrays.toString(wildcard.getLowerBounds()));
}
}
System.out.println("\n=== 6. 深度复制对象 ===");
ComplexClass copy = deepCopy(obj);
System.out.println(" 原始对象: " + obj);
System.out.println(" 复制对象: " + copy);
// 验证是否深度复制
intArrayField.setAccessible(true);
int[] originalArray = (int[]) intArrayField.get(obj);
int[] copiedArray = (int[]) intArrayField.get(copy);
originalArray[0] = 999; // 修改原始对象的数组
System.out.println(" 修改原始数组后:");
System.out.println(" 原始数组: " + Arrays.toString(originalArray));
System.out.println(" 复制数组: " + Arrays.toString(copiedArray));
System.out.println(" 是否独立: " + (originalArray != copiedArray));
}
// 简单的深度复制实现（仅用于演示）
private static ComplexClass deepCopy(ComplexClass original) throws Exception {
ComplexClass copy = new ComplexClass();
Class<?> clazz = ComplexClass.class;
for (Field field : clazz.getDeclaredFields()) {
field.setAccessible(true);
Object value = field.get(original);
if (value == null) {
field.set(copy, null);
} else if (value instanceof int[]) {
// 复制int数组
int[] originalArray = (int[]) value;
int[] copiedArray = new int[originalArray.length];
System.arraycopy(originalArray, 0, copiedArray, 0, originalArray.length);
field.set(copy, copiedArray);
} else if (value instanceof List) {
// 复制List
List<?> originalList = (List<?>) value;
List<Object> copiedList = new ArrayList<>(originalList);
field.set(copy, copiedList);
} else if (value instanceof Map) {
// 复制Map
Map<?, ?> originalMap = (Map<?, ?>) value;
Map<Object, Object> copiedMap = new HashMap<>(originalMap);
field.set(copy, copiedMap);
} else if (value instanceof Cloneable) {
// 尝试调用clone方法
try {
Method cloneMethod = value.getClass().getMethod("clone");
Object cloned = cloneMethod.invoke(value);
field.set(copy, cloned);
} catch (Exception e) {
field.set(copy, value); // 回退到浅复制
}
} else {
// 其他类型使用浅复制
field.set(copy, value);
}
}
return copy;
}
}
三、操作方法（Method）
3.1 方法反射基础
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Arrays;
public class MethodReflection {
// 演示类
static class Calculator {
public int add(int a, int b) {
return a + b;
}
private int multiply(int a, int b) {
return a * b;
}
protected double divide(double a, double b) {
return a / b;
}
public static String staticMethod(String input) {
return "Static: " + input;
}
public void varargsMethod(String... args) {
System.out.println("Varargs: " + Arrays.toString(args));
}
public <T> T genericMethod(T input) {
return input;
}
public void exceptionMethod() throws IOException, RuntimeException {
throw new RuntimeException("测试异常");
}
}
public static void main(String[] args) throws Exception {
Calculator calc = new Calculator();
Class<?> clazz = Calculator.class;
System.out.println("=== 方法反射操作 ===");
// 获取所有方法
System.out.println("\n1. 获取所有方法:");
Method[] allMethods = clazz.getDeclaredMethods();
for (Method method : allMethods) {
System.out.println(" " + Modifier.toString(method.getModifiers()) +
" " + method.getReturnType().getSimpleName() +
" " + method.getName() +
Arrays.toString(method.getParameters()));
}
// 获取公有方法（包括继承的）
System.out.println("\n2. 获取公有方法（包括继承）:");
Method[] publicMethods = clazz.getMethods();
System.out.println(" 公有方法数量: " + publicMethods.length);
for (int i = 0; i < Math.min(5, publicMethods.length); i++) {
Method m = publicMethods[i];
System.out.println(" " + m.getName() + " (来自 " + m.getDeclaringClass().getSimpleName() + ")");
}
System.out.println("\n3. 调用公有方法:");
Method addMethod = clazz.getMethod("add", int.class, int.class);
int result = (int) addMethod.invoke(calc, 10, 20);
System.out.println(" 调用add(10, 20): " + result);
System.out.println("\n4. 调用私有方法:");
Method multiplyMethod = clazz.getDeclaredMethod("multiply", int.class, int.class);
multiplyMethod.setAccessible(true);
int product = (int) multiplyMethod.invoke(calc, 5, 6);
System.out.println(" 调用multiply(5, 6): " + product);
System.out.println("\n5. 调用静态方法:");
Method staticMethod = clazz.getMethod("staticMethod", String.class);
String staticResult = (String) staticMethod.invoke(null, "Hello"); // 静态方法传入null
System.out.println(" 调用staticMethod: " + staticResult);
System.out.println("\n6. 调用可变参数方法:");
Method varargsMethod = clazz.getMethod("varargsMethod", String[].class);
// 注意：调用可变参数方法时，参数需要包装成Object数组
varargsMethod.invoke(calc, (Object) new String[]{"A", "B", "C"});
System.out.println("\n7. 调用泛型方法:");
Method genericMethod = clazz.getMethod("genericMethod", Object.class);
// 泛型方法调用时，类型参数会被擦除，返回Object类型
Object genericResult = genericMethod.invoke(calc, "泛型测试");
System.out.println(" 调用genericMethod: " + genericResult);
System.out.println("\n8. 方法详细信息:");
for (Method method : allMethods) {
System.out.println("\n 方法: " + method.getName());
System.out.println(" 返回类型: " + method.getReturnType());
System.out.println(" 泛型返回类型: " + method.getGenericReturnType());
System.out.println(" 参数数量: " + method.getParameterCount());
System.out.println(" 参数类型: " + Arrays.toString(method.getParameterTypes()));
System.out.println(" 泛型参数类型: " + Arrays.toString(method.getGenericParameterTypes()));
System.out.println(" 异常类型: " + Arrays.toString(method.getExceptionTypes()));
System.out.println(" 注解: " + Arrays.toString(method.getAnnotations()));
// 检查方法特性
System.out.println(" 是否为可变参数: " + method.isVarArgs());
System.out.println(" 是否为桥接方法: " + method.isBridge());
System.out.println(" 是否为合成方法: " + method.isSynthetic());
System.out.println(" 是否为默认方法: " + method.isDefault());
}
System.out.println("\n9. 异常处理:");
Method exceptionMethod = clazz.getMethod("exceptionMethod");
try {
exceptionMethod.invoke(calc);
} catch (Exception e) {
System.out.println(" 捕获到异常: " + e.getCause().getClass().getSimpleName());
System.out.println(" 异常信息: " + e.getCause().getMessage());
}
System.out.println("\n10. 性能考虑 - 方法缓存:");
// 反复获取方法实例
long startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
clazz.getMethod("add", int.class, int.class);
}
long endTime = System.nanoTime();
System.out.println(" 不缓存获取方法耗时: " + (endTime - startTime) / 1000000 + "ms");
// 缓存方法实例
startTime = System.nanoTime();
Method cachedMethod = clazz.getMethod("add", int.class, int.class);
for (int i = 0; i < 100000; i++) {
cachedMethod.invoke(calc, 1, 2);
}
endTime = System.nanoTime();
System.out.println(" 缓存方法调用耗时: " + (endTime - startTime) / 1000000 + "ms");
}
}
3.2 动态代理和AOP实现
import java.lang.reflect.*;
import java.util.*;
public class DynamicProxyAOP {
// 业务接口
interface UserService {
void addUser(String username);
void deleteUser(String username);
String getUser(String username);
}
// 具体实现
static class UserServiceImpl implements UserService {
private Map<String, String> users = new HashMap<>();
@Override
public void addUser(String username) {
users.put(username, "default_password");
System.out.println("添加用户: " + username);
}
@Override
public void deleteUser(String username) {
users.remove(username);
System.out.println("删除用户: " + username);
}
@Override
public String getUser(String username) {
return users.get(username);
}
}
// 日志切面
static class LogAspect {
public void before(Method method, Object[] args) {
System.out.println("[日志] 开始执行: " + method.getName() +
", 参数: " + Arrays.toString(args));
}
public void after(Method method, Object result) {
System.out.println("[日志] 执行完成: " + method.getName() +
", 结果: " + result);
}
public void afterThrowing(Method method, Throwable throwable) {
System.out.println("[日志] 执行异常: " + method.getName() +
", 异常: " + throwable.getMessage());
}
}
// 权限切面
static class SecurityAspect {
private Set<String> allowedMethods = new HashSet<>(Arrays.asList("getUser"));
public boolean checkPermission(Method method) {
String methodName = method.getName();
if (allowedMethods.contains(methodName)) {
System.out.println("[权限] 允许执行: " + methodName);
return true;
} else {
System.out.println("[权限] 拒绝执行: " + methodName);
return false;
}
}
}
// 性能监控切面
static class PerformanceAspect {
private Map<String, Long> executionTimes = new HashMap<>();
public void startTiming(Method method) {
executionTimes.put(method.getName(), System.currentTimeMillis());
}
public void endTiming(Method method) {
Long startTime = executionTimes.get(method.getName());
if (startTime != null) {
long duration = System.currentTimeMillis() - startTime;
System.out.println("[性能] " + method.getName() +
" 执行耗时: " + duration + "ms");
}
}
}
// AOP代理处理器
static class AOPHandler implements InvocationHandler {
private final Object target;
private final LogAspect logAspect;
private final SecurityAspect securityAspect;
private final PerformanceAspect performanceAspect;
public AOPHandler(Object target) {
this.target = target;
this.logAspect = new LogAspect();
this.securityAspect = new SecurityAspect();
this.performanceAspect = new PerformanceAspect();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 1. 前置通知
logAspect.before(method, args);
performanceAspect.startTiming(method);
Object result = null;
try {
// 2. 权限检查
if (!securityAspect.checkPermission(method)) {
throw new SecurityException("权限不足");
}
// 3. 执行目标方法
result = method.invoke(target, args);
// 4. 后置通知
logAspect.after(method, result);
return result;
} catch (InvocationTargetException e) {
// 5. 异常通知
Throwable targetException = e.getTargetException();
logAspect.afterThrowing(method, targetException);
throw targetException;
} finally {
// 6. 最终通知
performanceAspect.endTiming(method);
System.out.println("[AOP] 方法执行结束\n");
}
}
}
public static void main(String[] args) {
System.out.println("=== 动态代理和AOP实现 ===\n");
// 创建目标对象
UserService realService = new UserServiceImpl();
// 创建代理对象
UserService proxyService = (UserService) Proxy.newProxyInstance(
UserService.class.getClassLoader(),
new Class[]{UserService.class},
new AOPHandler(realService)
);
// 使用代理对象
System.out.println("1. 测试正常流程:");
try {
proxyService.addUser("Alice");
} catch (Exception e) {
System.out.println("捕获异常: " + e.getClass().getSimpleName());
}
System.out.println("\n2. 测试权限控制:");
try {
proxyService.getUser("Alice");
} catch (Exception e) {
System.out.println("捕获异常: " + e.getClass().getSimpleName());
}
System.out.println("\n3. 测试带返回值的方法:");
String user = proxyService.getUser("Bob");
System.out.println("获取用户: " + user);
System.out.println("\n=== 动态代理的元信息 ===");
System.out.println("代理类: " + proxyService.getClass().getName());
System.out.println("代理类的父类: " + proxyService.getClass().getSuperclass().getName());
System.out.println("代理类实现的接口:");
for (Class<?> iface : proxyService.getClass().getInterfaces()) {
System.out.println(" - " + iface.getName());
}
// 检查代理类
if (Proxy.isProxyClass(proxyService.getClass())) {
System.out.println("\n这是一个代理类");
InvocationHandler handler = Proxy.getInvocationHandler(proxyService);
System.out.println("代理处理器: " + handler.getClass().getName());
}
System.out.println("\n=== 更复杂的AOP场景 ===");
// 方法级别的AOP配置
Map<String, List<String>> methodAspects = new HashMap<>();
methodAspects.put("addUser", Arrays.asList("log", "security", "transaction"));
methodAspects.put("getUser", Arrays.asList("log", "cache"));
// 创建可配置的AOP处理器
ConfigurableAOPHandler configHandler = new ConfigurableAOPHandler(
realService, methodAspects
);
UserService configurableProxy = (UserService) Proxy.newProxyInstance(
UserService.class.getClassLoader(),
new Class[]{UserService.class},
configHandler
);
System.out.println("\n使用可配置AOP代理:");
configurableProxy.addUser("Charlie");
configurableProxy.getUser("Charlie");
}
// 可配置的AOP处理器
static class ConfigurableAOPHandler implements InvocationHandler {
private final Object target;
private final Map<String, List<String>> methodAspects;
public ConfigurableAOPHandler(Object target, Map<String, List<String>> methodAspects) {
this.target = target;
this.methodAspects = methodAspects;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
List<String> aspects = methodAspects.getOrDefault(methodName,
Arrays.asList("log")); // 默认只有日志切面
System.out.println("\n执行方法: " + methodName);
System.out.println("应用的切面: " + aspects);
// 执行前置切面
for (String aspect : aspects) {
switch (aspect) {
case "log":
System.out.println("[前置日志] " + methodName);
break;
case "security":
System.out.println("[安全检查] " + methodName);
break;
case "transaction":
System.out.println("[事务开始] " + methodName);
break;
case "cache":
System.out.println("[缓存检查] " + methodName);
break;
}
}
// 执行目标方法
Object result = method.invoke(target, args);
// 执行后置切面
for (String aspect : aspects) {
switch (aspect) {
case "log":
System.out.println("[后置日志] " + methodName);
break;
case "transaction":
System.out.println("[事务提交] " + methodName);
break;
case "cache":
System.out.println("[缓存更新] " + methodName);
break;
}
}
return result;
}
}
}
四、构造器和对象创建
4.1 构造器反射
import java.lang.reflect.*;
import java.util.Arrays;
public class ConstructorReflection {
// 演示类
static class ComplexObject {
private String name;
private int value;
private List<String> items;
public ComplexObject() {
this.name = "默认";
this.value = 0;
this.items = new ArrayList<>();
}
public ComplexObject(String name) {
this.name = name;
this.value = 0;
this.items = new ArrayList<>();
}
private ComplexObject(int value) {
this.name = "私有构造器";
this.value = value;
this.items = new ArrayList<>();
}
protected ComplexObject(String name, int value) {
this.name = name;
this.value = value;
this.items = new ArrayList<>();
}
public ComplexObject(String name, int value, List<String> items) {
this.name = name;
this.value = value;
this.items = items;
}
@Override
public String toString() {
return "ComplexObject{name='" + name + "', value=" + value +
", items=" + items + "}";
}
}
public static void main(String[] args) throws Exception {
System.out.println("=== 构造器反射 ===\n");
Class<ComplexObject> clazz = ComplexObject.class;
// 获取所有构造器
System.out.println("1. 所有构造器:");
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(" " + Modifier.toString(constructor.getModifiers()) +
" " + clazz.getSimpleName() +
Arrays.toString(constructor.getParameterTypes()));
}
// 获取公有构造器
System.out.println("\n2. 公有构造器:");
Constructor<?>[] publicConstructors = clazz.getConstructors();
for (Constructor<?> constructor : publicConstructors) {
System.out.println(" " + constructor);
}
System.out.println("\n3. 使用无参构造器创建对象:");
Constructor<ComplexObject> noArgConstructor = clazz.getConstructor();
ComplexObject obj1 = noArgConstructor.newInstance();
System.out.println(" 创建的对象: " + obj1);
System.out.println("\n4. 使用带参数构造器创建对象:");
Constructor<ComplexObject> paramConstructor =
clazz.getConstructor(String.class, int.class, List.class);
ComplexObject obj2 = paramConstructor.newInstance("测试", 100,
Arrays.asList("A", "B", "C"));
System.out.println(" 创建的对象: " + obj2);
System.out.println("\n5. 使用私有构造器创建对象:");
Constructor<ComplexObject> privateConstructor =
clazz.getDeclaredConstructor(int.class);
privateConstructor.setAccessible(true);
ComplexObject obj3 = privateConstructor.newInstance(999);
System.out.println(" 使用私有构造器创建: " + obj3);
System.out.println("\n6. 构造器的详细信息:");
for (Constructor<?> constructor : constructors) {
System.out.println("\n 构造器: " + constructor);
System.out.println(" 参数数量: " + constructor.getParameterCount());
System.out.println(" 参数类型: " + Arrays.toString(constructor.getParameterTypes()));
System.out.println(" 泛型参数: " + Arrays.toString(constructor.getGenericParameterTypes()));
System.out.println(" 注解: " + Arrays.toString(constructor.getAnnotations()));
System.out.println(" 是否为可变参数: " + constructor.isVarArgs());
System.out.println(" 是否为合成构造器: " + constructor.isSynthetic());
}
System.out.println("\n7. 构造器参数名获取:");
// 注意：默认情况下无法获取参数名，需要编译时添加-parameters参数
try {
for (Constructor<?> constructor : constructors) {
Parameter[] parameters = constructor.getParameters();
System.out.println("\n 构造器: " + constructor);
for (Parameter param : parameters) {
System.out.println(" 参数: " + param.getName() +
" (类型: " + param.getType().getSimpleName() +
", 真实名称: " + param.isNamePresent() + ")");
}
}
} catch (Exception e) {
System.out.println(" 无法获取参数名: " + e.getMessage());
System.out.println(" 提示：使用javac -parameters编译源文件以启用参数名保留");
}
System.out.println("\n8. 异常处理:");
try {
// 尝试使用错误的参数类型
Constructor<ComplexObject> wrongConstructor =
clazz.getConstructor(String.class, String.class); // 第二个参数应该是int
} catch (NoSuchMethodException e) {
System.out.println(" 找不到匹配的构造器: " + e.getMessage());
}
// 实例化时处理异常
Constructor<ComplexObject> exceptionConstructor =
clazz.getDeclaredConstructor(String.class);
try {
// 模拟构造器抛出异常
ComplexObject obj = exceptionConstructor.newInstance((Object) null);
} catch (InvocationTargetException e) {
System.out.println(" 构造器抛出异常: " + e.getTargetException().getMessage());
}
System.out.println("\n9. 数组和复杂对象的创建:");
// 创建对象数组
ComplexObject[] array = (ComplexObject[]) Array.newInstance(clazz, 3);
for (int i = 0; i < array.length; i++) {
array[i] = clazz.newInstance(); // 使用无参构造器
}
System.out.println(" 创建的对象数组: " + Arrays.toString(array));
// 创建内部类实例
System.out.println("\n10. 内部类的反射创建:");
try {
// 非静态内部类
Class<?> innerClass = Class.forName("ConstructorReflection$InnerClassDemo");
Constructor<?> innerConstructor = innerClass.getDeclaredConstructor(
ConstructorReflection.class, String.class
);
innerConstructor.setAccessible(true);
Object innerInstance = innerConstructor.newInstance(new ConstructorReflection(), "内部类");
System.out.println(" 创建的内部类: " + innerInstance);
} catch (Exception e) {
System.out.println(" 内部类创建失败: " + e.getMessage());
}
}
// 内部类演示
class InnerClassDemo {
private String name;
public InnerClassDemo(String name) {
this.name = name;
}
@Override
public String toString() {
return "InnerClassDemo{name='" + name + "'}";
}
}
}
五、注解和泛型反射
5.1 注解反射
import java.lang.annotation.*;
import java.lang.reflect.*;
// 自定义注解
@Retention(RetentionPolicy.RUNTIME) // 运行时保留
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD}) // 可以注解类、方法、字段
@Repeatable(Author.Authors.class) // 可重复注解
@interface Author {
String name();
String date() default "2024-01-01";
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Authors {
Author[] value();
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Range {
int min() default 0;
int max() default 100;
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Loggable {
String level() default "INFO";
}
// 使用注解的类
@Author(name = "张三", date = "2024-01-15")
@Author(name = "李四", date = "2024-01-20") // 可重复注解
class AnnotatedClass {
@Range(min = 0, max = 150)
private int age;
@Deprecated // 内置注解
public void oldMethod() {}
@Loggable(level = "DEBUG")
public void importantMethod() {
System.out.println("执行重要方法");
}
@SuppressWarnings("unchecked") // 源码级别注解，运行时不可见
public void methodWithWarning() {}
}
public class AnnotationReflection {
public static void main(String[] args) throws Exception {
System.out.println("=== 注解反射 ===\n");
Class<AnnotatedClass> clazz = AnnotatedClass.class;
// 1. 类上的注解
System.out.println("1. 类上的注解:");
Annotation[] classAnnotations = clazz.getAnnotations();
for (Annotation annotation : classAnnotations) {
System.out.println(" " + annotation.annotationType().getName());
// 处理自定义注解
if (annotation instanceof Author) {
Author author = (Author) annotation;
System.out.println(" 作者: " + author.name() + ", 日期: " + author.date());
}
}
// 获取特定注解
Author[] authors = clazz.getAnnotationsByType(Author.class);
System.out.println("\n 所有Author注解 (" + authors.length + " 个):");
for (Author author : authors) {
System.out.println(" - " + author.name() + " (" + author.date() + ")");
}
// 2. 字段上的注解
System.out.println("\n2. 字段上的注解:");
Field ageField = clazz.getDeclaredField("age");
Range range = ageField.getAnnotation(Range.class);
if (range != null) {
System.out.println(" age字段范围: " + range.min() + " ~ " + range.max());
}
// 3. 方法上的注解
System.out.println("\n3. 方法上的注解:");
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println("\n 方法: " + method.getName());
// 获取所有注解
Annotation[] methodAnnotations = method.getAnnotations();
for (Annotation ann : methodAnnotations) {
System.out.println(" 注解: " + ann.annotationType().getSimpleName());
if (ann instanceof Loggable) {
Loggable loggable = (Loggable) ann;
System.out.println(" 日志级别: " + loggable.level());
}
}
// 检查是否有特定注解
if (method.isAnnotationPresent(Deprecated.class)) {
System.out.println(" 已过时的方法");
}
}
// 4. 注解默认值
System.out.println("\n4. 注解默认值:");
try {
// 通过反射获取注解的默认值
Method levelMethod = Loggable.class.getMethod("level");
Object defaultValue = levelMethod.getDefaultValue();
System.out.println(" Loggable.level默认值: " + defaultValue);
} catch (Exception e) {
e.printStackTrace();
}
// 5. 运行时处理注解 - 验证字段值
System.out.println("\n5. 运行时注解处理 - 字段验证:");
AnnotatedClass obj = new AnnotatedClass();
ageField.setAccessible(true);
ageField.setInt(obj, 200); // 设置超出范围的值
// 验证字段值
if (range != null) {
int value = ageField.getInt(obj);
if (value < range.min() || value > range.max()) {
System.out.println(" 验证失败: age字段值 " + value + " 超出范围");
} else {
System.out.println(" 验证通过");
}
}
// 6. 动态创建注解代理
System.out.println("\n6. 动态创建注解:");
Annotation dynamicAnnotation = createDynamicAnnotation();
System.out.println(" 动态创建的注解: " + dynamicAnnotation);
System.out.println(" 注解类型: " + dynamicAnnotation.annotationType());
// 7. 注解继承
System.out.println("\n7. 注解继承测试:");
// @Inherited元注解可以让子类继承父类的注解
checkInheritedAnnotations();
}
// 动态创建注解
private static Annotation createDynamicAnnotation() {
return new Author() {
@Override
public String name() {
return "动态作者";
}
@Override
public String date() {
return "2024-01-01";
}
@Override
public Class<? extends Annotation> annotationType() {
return Author.class;
}
};
}
// 检查注解继承
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited // 可继承的注解
@interface InheritedAnnotation {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface NonInheritedAnnotation {
String value();
}
@InheritedAnnotation("父类")
@NonInheritedAnnotation("父类")
class ParentClass {}
class ChildClass extends ParentClass {}
private static void checkInheritedAnnotations() {
System.out.println(" 父类注解:");
for (Annotation ann : ParentClass.class.getAnnotations()) {
System.out.println(" - " + ann.annotationType().getSimpleName());
}
System.out.println(" 子类继承的注解:");
for (Annotation ann : ChildClass.class.getAnnotations()) {
System.out.println(" - " + ann.annotationType().getSimpleName());
}
// 检查特定注解
System.out.println(" 子类是否有@InheritedAnnotation: " +
ChildClass.class.isAnnotationPresent(InheritedAnnotation.class));
System.out.println(" 子类是否有@NonInheritedAnnotation: " +
ChildClass.class.isAnnotationPresent(NonInheritedAnnotation.class));
}
}
5.2 泛型反射
import java.lang.reflect.*;
import java.util.*;
public class GenericReflection {
// 泛型类
static class GenericClass<T extends Number & Comparable<T>> {
private T value;
private List<T> list;
private Map<String, T> map;
public GenericClass(T value) {
this.value = value;
this.list = new ArrayList<>();
this.map = new HashMap<>();
}
public <U extends CharSequence> U process(U input) {
return input;
}
public T getValue() {
return value;
}
public void setList(List<? extends T> list) {
this.list = new ArrayList<>(list);
}
}
// 泛型子类
static class IntegerGenericClass extends GenericClass<Integer> {
public IntegerGenericClass(Integer value) {
super(value);
}
@Override
public Integer getValue() {
return super.getValue() * 2;
}
}
public static void main(String[] args) throws Exception {
System.out.println("=== 泛型反射 ===\n");
// 1. 类的泛型参数
System.out.println("1. 类的泛型参数:");
Class<GenericClass> rawClass = GenericClass.class;
TypeVariable<Class<GenericClass>>[] typeParams = rawClass.getTypeParameters();
for (TypeVariable<Class<GenericClass>> param : typeParams) {
System.out.println(" 泛型参数: " + param.getName());
System.out.println(" 边界:");
for (Type bound : param.getBounds()) {
System.out.println(" - " + bound);
}
System.out.println(" 声明处: " + param.getGenericDeclaration());
}
// 2. 子类的泛型信息
System.out.println("\n2. 子类的泛型信息:");
Class<IntegerGenericClass> subClass = IntegerGenericClass.class;
Type genericSuperclass = subClass.getGenericSuperclass();
if (genericSuperclass instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) genericSuperclass;
System.out.println(" 原始类型: " + pType.getRawType());
System.out.println(" 实际类型参数:");
for (Type actualType : pType.getActualTypeArguments()) {
System.out.println(" - " + actualType);
}
System.out.println(" 所有者类型: " + pType.getOwnerType());
}
// 3. 字段的泛型类型
System.out.println("\n3. 字段的泛型类型:");
Field listField = GenericClass.class.getDeclaredField("list");
Type listFieldType = listField.getGenericType();
if (listFieldType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) listFieldType;
System.out.println(" list字段类型:");
System.out.println(" 原始类型: " + pType.getRawType());
System.out.println(" 参数类型: " + Arrays.toString(pType.getActualTypeArguments()));
}
Field mapField = GenericClass.class.getDeclaredField("map");
Type mapFieldType = mapField.getGenericType();
System.out.println(" map字段泛型类型: " + mapFieldType);
// 4. 方法的泛型返回类型和参数
System.out.println("\n4. 方法的泛型信息:");
Method processMethod = GenericClass.class.getDeclaredMethod("process", CharSequence.class);
System.out.println(" process方法:");
System.out.println(" 泛型返回类型: " + processMethod.getGenericReturnType());
System.out.println(" 返回类型: " + processMethod.getReturnType());
TypeVariable<Method>[] methodTypeParams = processMethod.getTypeParameters();
for (TypeVariable<Method> param : methodTypeParams) {
System.out.println(" 方法泛型参数: " + param.getName());
for (Type bound : param.getBounds()) {
System.out.println(" 边界: " + bound);
}
}
System.out.println(" 参数类型:");
Type[] paramTypes = processMethod.getGenericParameterTypes();
for (Type paramType : paramTypes) {
System.out.println(" - " + paramType);
}
// 5. 桥接方法
System.out.println("\n5. 桥接方法:");
Method getValueMethod = IntegerGenericClass.class.getMethod("getValue");
System.out.println(" getValue方法:");
System.out.println(" 是否为桥接方法: " + getValueMethod.isBridge());
System.out.println(" 返回类型: " + getValueMethod.getReturnType());
System.out.println(" 泛型返回类型: " + getValueMethod.getGenericReturnType());
// 查找所有桥接方法
Method[] allMethods = IntegerGenericClass.class.getDeclaredMethods();
for (Method method : allMethods) {
if (method.isBridge()) {
System.out.println(" 发现桥接方法: " + method);
}
}
// 6. 通配符类型
System.out.println("\n6. 通配符类型:");
Method setListMethod = GenericClass.class.getDeclaredMethod("setList", List.class);
Type[] setListParamTypes = setListMethod.getGenericParameterTypes();
for (Type paramType : setListParamTypes) {
if (paramType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) paramType;
Type[] actualTypes = pType.getActualTypeArguments();
for (Type actualType : actualTypes) {
if (actualType instanceof WildcardType) {
WildcardType wildcard = (WildcardType) actualType;
System.out.println(" 发现通配符:");
System.out.println(" 上界: " + Arrays.toString(wildcard.getUpperBounds()));
System.out.println(" 下界: " + Arrays.toString(wildcard.getLowerBounds()));
}
}
}
}
// 7. 类型变量解析
System.out.println("\n7. 类型变量解析:");
try {
// 创建类型变量映射
Map<TypeVariable<?>, Type> typeMap = new HashMap<>();
// 对于子类，T被解析为Integer
Type superclass = subClass.getGenericSuperclass();
if (superclass instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) superclass;
TypeVariable<?>[] typeVars = ((Class<?>) pt.getRawType()).getTypeParameters();
Type[] actualTypes = pt.getActualTypeArguments();
for (int i = 0; i < typeVars.length; i++) {
typeMap.put(typeVars[i], actualTypes[i]);
}
}
// 解析字段类型
Type resolvedListType = resolveType(listField.getGenericType(), typeMap);
System.out.println(" 解析后的list字段类型: " + resolvedListType);
} catch (Exception e) {
e.printStackTrace();
}
// 8. 实际应用：JSON序列化中的泛型处理
System.out.println("\n8. 实际应用：处理泛型集合:");
processGenericCollections();
}
// 解析类型变量
private static Type resolveType(Type type, Map<TypeVariable<?>, Type> typeMap) {
if (type instanceof TypeVariable) {
return typeMap.getOrDefault(type, type);
} else if (type instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) type;
Type[] actualTypes = pType.getActualTypeArguments();
Type[] resolvedTypes = new Type[actualTypes.length];
for (int i = 0; i < actualTypes.length; i++) {
resolvedTypes[i] = resolveType(actualTypes[i], typeMap);
}
return new ParameterizedType() {
@Override
public Type[] getActualTypeArguments() {
return resolvedTypes;
}
@Override
public Type getRawType() {
return pType.getRawType();
}
@Override
public Type getOwnerType() {
return pType.getOwnerType();
}
@Override
public String toString() {
Type rawType = getRawType();
Type[] args = getActualTypeArguments();
StringBuilder sb = new StringBuilder();
sb.append(rawType);
if (args.length > 0) {
sb.append("<");
for (int i = 0; i < args.length; i++) {
if (i > 0) sb.append(", ");
sb.append(args[i]);
}
sb.append(">");
}
return sb.toString();
}
};
}
return type;
}
// 处理泛型集合的实际例子
private static void processGenericCollections() throws Exception {
// 模拟从JSON解析的数据
String jsonData = "["Java", "Python", "C++"]";
// 目标类型：List<String>
Type targetType = new TypeToken<List<String>>() {}.getType();
System.out.println(" 目标类型: " + targetType);
if (targetType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) targetType;
System.out.println(" 原始类型: " + pType.getRawType());
System.out.println(" 元素类型: " + pType.getActualTypeArguments()[0]);
// 模拟创建对应类型的集合
Class<?> rawClass = (Class<?>) pType.getRawType();
Type elementType = pType.getActualTypeArguments()[0];
System.out.println(" 创建 " + rawClass.getSimpleName() +
"<" + elementType + "> 实例");
// 在实际的JSON库中，这里会根据elementType来解析每个元素
}
}
// 用于获取泛型类型的辅助类
static abstract class TypeToken<T> {
private final Type type;
protected TypeToken() {
Type superclass = getClass().getGenericSuperclass();
if (superclass instanceof Class) {
throw new RuntimeException("缺少类型参数");
}
this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
}
public Type getType() {
return type;
}
}
}
总结：反射的最佳实践
反射的优势：
- 灵活性：可以在运行时动态创建对象、调用方法
- 框架支持：是Spring、Hibernate等框架的基础
- 工具开发：IDE、调试器、测试工具都依赖反射
