1
public class Proxy implements java.io.Serializable {
2
    // 生成代理类实例
3
    public static Object newProxyInstance(
4
        ClassLoader loader,        // 类加载器
5
        Class<?>[] interfaces,     // 代理类需要实现的接口
6
        InvocationHandler h        // 方法调用处理器
7
    ) throws IllegalArgumentException;
8

9
    // 判断某个类是否是代理类
10
    public static boolean isProxyClass(Class<?> cl);
11

12
    // 获取某个代理类的 InvocationHandler
13
    public static InvocationHandler getInvocationHandler(Object proxy);
14

15
    // 获取代理类的 Class 对象
16
    public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces);
17
}

1
public interface InvocationHandler {
2
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
3
}

1
import java.lang.reflect.*;
2

3
// 1. 定义业务接口
4
interface UserService {
5
    void addUser(String name);
6
    String getUser(int id);
7
    void deleteUser(int id);
8
}
9

10
// 2. 实现类
11
class UserServiceImpl implements UserService {
12
    @Override
13
    public void addUser(String name) {
14
        System.out.println("添加用户: " + name);
15
    }
16

17
    @Override
18
    public String getUser(int id) {
19
        System.out.println("获取用户: " + id);
20
        return "User-" + id;
21
    }
22

23
    @Override
24
    public void deleteUser(int id) {
25
        System.out.println("删除用户: " + id);
26
    }
27
}
28

29
// 3. 调用处理器
30
class LoggingInvocationHandler implements InvocationHandler {
31
    private Object target; // 被代理的目标对象
32

33
    public LoggingInvocationHandler(Object target) {
34
        this.target = target;
35
    }
36

37
    @Override
38
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
39
        // 前置增强
40
        System.out.println("=== 方法调用开始 ===");
41
        System.out.println("调用方法: " + method.getName());
42
        System.out.println("方法参数: " + java.util.Arrays.toString(args));
43
        long startTime = System.currentTimeMillis();
44

45
        try {
46
            // 调用目标方法
47
            Object result = method.invoke(target, args);
48

49
            // 后置增强
50
            long endTime = System.currentTimeMillis();
51
            System.out.println("方法执行成功");
52
            System.out.println("执行耗时: " + (endTime - startTime) + "ms");
53
            System.out.println("返回结果: " + result);
54
            System.out.println("=== 方法调用结束 ===\n");
55

56
            return result;
57
        } catch (Exception e) {
58
            System.out.println("方法执行异常: " + e.getMessage());
59
            throw e;
60
        }
61
    }
62
}
63

64
// 4. 测试动态代理
65
public class JDKProxyDemo {
66
    public static void main(String[] args) {
67
        // 创建目标对象
68
        UserService target = new UserServiceImpl();
69

70
        // 创建代理对象
71
        UserService proxy = (UserService) Proxy.newProxyInstance(
72
            target.getClass().getClassLoader(),    // 类加载器
73
            target.getClass().getInterfaces(),     // 接口数组
74
            new LoggingInvocationHandler(target)   // 调用处理器
75
        );
76

77
        // 使用代理对象
78
        proxy.addUser("张三");
79
        String user = proxy.getUser(1);
80
        proxy.deleteUser(1);
81

82
        // 验证代理对象的类型
83
        System.out.println("代理对象类型: " + proxy.getClass().getName());
84
        System.out.println("是否为Proxy的实例: " + (proxy instanceof Proxy));
85
        System.out.println("实现的接口: " + java.util.Arrays.toString(proxy.getClass().getInterfaces()));
86
    }
87
}

1
public class ProxyAPIDemo {
2
    public static void demonstrateProxyAPI() {
3
        UserService target = new UserServiceImpl();
4

5
        // 1. Proxy.newProxyInstance() - 创建代理实例
6
        UserService proxy = (UserService) Proxy.newProxyInstance(
7
            target.getClass().getClassLoader(),
8
            new Class<?>[]{UserService.class},
9
            new LoggingInvocationHandler(target)
10
        );
11

12
        // 2. Proxy.getProxyClass() - 获取代理类
13
        Class<?> proxyClass = Proxy.getProxyClass(
14
            UserService.class.getClassLoader(),
15
            UserService.class
16
        );
17
        System.out.println("代理类: " + proxyClass.getName());
18

19
        // 3. Proxy.isProxyClass() - 检查是否为代理类
20
        boolean isProxy = Proxy.isProxyClass(proxy.getClass());
21
        System.out.println("是否为代理类: " + isProxy);
22

23
        // 4. Proxy.getInvocationHandler() - 获取调用处理器
24
        InvocationHandler handler = Proxy.getInvocationHandler(proxy);
25
        System.out.println("调用处理器: " + handler.getClass().getName());
26
    }
27
}

1
public class ProxyFactory {
2

3
    /**
4
     * 创建带日志功能的代理
5
     */
6
    public static <T> T createLoggingProxy(T target) {
7
        return createProxy(target, new LoggingInvocationHandler(target));
8
    }
9

10
    /**
11
     * 创建带性能监控的代理
12
     */
13
    public static <T> T createPerformanceProxy(T target) {
14
        return createProxy(target, new PerformanceInvocationHandler(target));
15
    }
16

17
    /**
18
     * 创建带事务管理的代理
19
     */
20
    public static <T> T createTransactionProxy(T target) {
21
        return createProxy(target, new TransactionInvocationHandler(target));
22
    }
23

24
    /**
25
     * 创建多重代理（支持多个增强功能）
26
     */
27
    public static <T> T createMultiProxy(T target, InvocationHandler... handlers) {
28
        Object proxy = target;
29

30
        // 逐层包装
31
        for (InvocationHandler handler : handlers) {
32
            proxy = Proxy.newProxyInstance(
33
                proxy.getClass().getClassLoader(),
34
                proxy.getClass().getInterfaces(),
35
                handler
36
            );
37
        }
38

39
        return (T) proxy;
40
    }
41

42
    /**
43
     * 通用代理创建方法
44
     */
45
    @SuppressWarnings("unchecked")
46
    private static <T> T createProxy(T target, InvocationHandler handler) {
47
        return (T) Proxy.newProxyInstance(
48
            target.getClass().getClassLoader(),
49
            target.getClass().getInterfaces(),
50
            handler
51
        );
52
    }
53
}
54

55
// 性能监控处理器
56
class PerformanceInvocationHandler implements InvocationHandler {
57
    private Object target;
58

59
    public PerformanceInvocationHandler(Object target) {
60
        this.target = target;
61
    }
62

63
    @Override
64
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
65
        long start = System.nanoTime();
66

67
        Object result = method.invoke(target, args);
68

69
        long end = System.nanoTime();
70
        double duration = (end - start) / 1_000_000.0; // 转换为毫秒
71

72
        System.out.printf("⏱️ 方法 %s 执行耗时: %.2f ms%n", method.getName(), duration);
73

74
        return result;
75
    }
76
}
77

78
// 事务管理处理器
79
class TransactionInvocationHandler implements InvocationHandler {
80
    private Object target;
81

82
    public TransactionInvocationHandler(Object target) {
83
        this.target = target;
84
    }
85

86
    @Override
87
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
88
        // 开启事务
89
        System.out.println("🔄 开始事务");
90

91
        try {
92
            Object result = method.invoke(target, args);
93

94
            // 提交事务
95
            System.out.println("✅ 提交事务");
96
            return result;
97

98
        } catch (Exception e) {
99
            // 回滚事务
100
            System.out.println("❌ 回滚事务");
101
            throw e;
102
        }
103
    }
104
}

1
public class MultiProxyDemo {
2
    public static void main(String[] args) {
3
        // 创建目标对象
4
        UserService target = new UserServiceImpl();
5

6
        // 创建多重代理：日志 + 性能监控 + 事务管理
7
        UserService multiProxy = ProxyFactory.createMultiProxy(
8
            target,
9
            new LoggingInvocationHandler(target),
10
            new PerformanceInvocationHandler(target),
11
            new TransactionInvocationHandler(target)
12
        );
13

14
        System.out.println("=== 多重代理测试 ===");
15
        multiProxy.addUser("李四");
16
    }
17
}

1
// 注意：需要添加CGLIB依赖
2
// <dependency>
3
//     <groupId>cglib</groupId>
4
//     <artifactId>cglib</artifactId>
5
//     <version>3.3.0</version>
6
// </dependency>
7

8
import net.sf.cglib.proxy.*;
9
import java.lang.reflect.Method;
10

11
// 目标类（无需实现接口）
12
class UserManager {
13
    public void addUser(String name) {
14
        System.out.println("UserManager: 添加用户 " + name);
15
    }
16

17
    public String getUser(int id) {
18
        System.out.println("UserManager: 获取用户 " + id);
19
        return "User-" + id;
20
    }
21

22
    // final方法无法被代理
23
    public final void finalMethod() {
24
        System.out.println("这是final方法");
25
    }
26

27
    // private方法无法被代理
28
    private void privateMethod() {
29
        System.out.println("这是private方法");
30
    }
31
}
32

33
// CGLIB方法拦截器
34
class UserManagerInterceptor implements MethodInterceptor {
35
    @Override
36
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
37
        System.out.println("CGLIB前置增强: " + method.getName());
38

39
        // 调用父类方法（原始方法）
40
        Object result = proxy.invokeSuper(obj, args);
41

42
        System.out.println("CGLIB后置增强: " + method.getName());
43
        return result;
44
    }
45
}
46

47
// CGLIB代理演示
48
public class CGLibProxyDemo {
49
    public static void main(String[] args) {
50
        // 创建增强器
51
        Enhancer enhancer = new Enhancer();
52

53
        // 设置父类
54
        enhancer.setSuperclass(UserManager.class);
55

56
        // 设置回调
57
        enhancer.setCallback(new UserManagerInterceptor());
58

59
        // 创建代理对象
60
        UserManager proxy = (UserManager) enhancer.create();
61

62
        // 使用代理对象
63
        proxy.addUser("王五");
64
        String user = proxy.getUser(2);
65

66
        System.out.println("代理对象类型: " + proxy.getClass().getName());
67
        System.out.println("父类: " + proxy.getClass().getSuperclass().getName());
68
    }
69
}

1
// 方法过滤器
2
class SelectiveMethodInterceptor implements MethodInterceptor {
3
    @Override
4
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
5
        // 只代理特定方法
6
        if (method.getName().startsWith("add")) {
7
            System.out.println("拦截add方法: " + method.getName());
8
            Object result = proxy.invokeSuper(obj, args);
9
            System.out.println("add方法执行完成");
10
            return result;
11
        }
12

13
        // 其他方法直接执行
14
        return proxy.invokeSuper(obj, args);
15
    }
16
}
17

18
// 回调过滤器
19
class MyCallbackFilter implements CallbackFilter {
20
    @Override
21
    public int accept(Method method) {
22
        // 根据方法返回不同的回调索引
23
        if (method.getName().startsWith("add")) {
24
            return 0; // 使用第一个回调
25
        } else if (method.getName().startsWith("get")) {
26
            return 1; // 使用第二个回调
27
        }
28
        return 2; // 使用第三个回调（NoOp表示不代理）
29
    }
30
}
31

32
public class AdvancedCGLibDemo {
33
    public static void main(String[] args) {
34
        Enhancer enhancer = new Enhancer();
35
        enhancer.setSuperclass(UserManager.class);
36

37
        // 设置多个回调
38
        enhancer.setCallbacks(new Callback[]{
39
            new SelectiveMethodInterceptor(),           // 索引0：add方法的拦截器
40
            new PerformanceMethodInterceptor(),         // 索引1：get方法的拦截器
41
            NoOp.INSTANCE                               // 索引2：不做任何处理
42
        });
43

44
        // 设置回调过滤器
45
        enhancer.setCallbackFilter(new MyCallbackFilter());
46

47
        UserManager proxy = (UserManager) enhancer.create();
48

49
        proxy.addUser("赵六");    // 会被第一个拦截器处理
50
        proxy.getUser(3);        // 会被第二个拦截器处理
51
    }
52
}
53

54
// 性能监控拦截器
55
class PerformanceMethodInterceptor implements MethodInterceptor {
56
    @Override
57
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
58
        long start = System.currentTimeMillis();
59

60
        Object result = proxy.invokeSuper(obj, args);
61

62
        long end = System.currentTimeMillis();
63
        System.out.println("方法 " + method.getName() + " 执行时间: " + (end - start) + "ms");
64

65
        return result;
66
    }
67
}

1
// 切面注解
2
@Retention(RetentionPolicy.RUNTIME)
3
@Target(ElementType.METHOD)
4
@interface LogExecution {
5
    String value() default "";
6
}
7

8
@Retention(RetentionPolicy.RUNTIME)
9
@Target(ElementType.METHOD)
10
@interface Transactional {
11
    boolean readOnly() default false;
12
}
13

14
// 业务服务
15
class OrderService {
16
    @LogExecution("订单创建")
17
    @Transactional
18
    public void createOrder(String orderId) {
19
        System.out.println("创建订单: " + orderId);
20
        // 模拟可能的异常
21
        if (orderId.equals("ERROR")) {
22
            throw new RuntimeException("订单创建失败");
23
        }
24
    }
25

26
    @LogExecution("订单查询")
27
    @Transactional(readOnly = true)
28
    public String getOrder(String orderId) {
29
        System.out.println("查询订单: " + orderId);
30
        return "Order-" + orderId;
31
    }
32
}
33

34
// AOP代理处理器
35
class AOPInvocationHandler implements InvocationHandler {
36
    private Object target;
37

38
    public AOPInvocationHandler(Object target) {
39
        this.target = target;
40
    }
41

42
    @Override
43
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
44
        // 处理@LogExecution注解
45
        LogExecution logAnnotation = method.getAnnotation(LogExecution.class);
46
        if (logAnnotation != null) {
47
            System.out.println("📝 [LOG] 开始执行: " + logAnnotation.value());
48
        }
49

50
        // 处理@Transactional注解
51
        Transactional txAnnotation = method.getAnnotation(Transactional.class);
52
        boolean inTransaction = false;
53

54
        if (txAnnotation != null) {
55
            System.out.println("🔄 [TX] 开启事务 (只读: " + txAnnotation.readOnly() + ")");
56
            inTransaction = true;
57
        }
58

59
        try {
60
            // 执行目标方法
61
            Object result = method.invoke(target, args);
62

63
            // 事务提交
64
            if (inTransaction) {
65
                System.out.println("✅ [TX] 事务提交");
66
            }
67

68
            // 日志记录
69
            if (logAnnotation != null) {
70
                System.out.println("📝 [LOG] 执行成功: " + logAnnotation.value());
71
            }
72

73
            return result;
74

75
        } catch (Exception e) {
76
            // 事务回滚
77
            if (inTransaction) {
78
                System.out.println("❌ [TX] 事务回滚");
79
            }
80

81
            // 错误日志
82
            if (logAnnotation != null) {
83
                System.out.println("📝 [LOG] 执行失败: " + logAnnotation.value() + " - " + e.getCause().getMessage());
84
            }
85

86
            throw e;
87
        }
88
    }
89
}
90

91
// 简化版IoC容器
92
class SimpleContainer {
93
    public static <T> T getBean(Class<T> clazz) {
94
        try {
95
            T target = clazz.getDeclaredConstructor().newInstance();
96

97
            // 检查是否需要AOP增强
98
            boolean needAOP = hasAOPAnnotations(clazz);
99

100
            if (needAOP) {
101
                // 返回代理对象
102
                return createAOPProxy(target);
103
            }
104

105
            return target;
106
        } catch (Exception e) {
107
            throw new RuntimeException("创建Bean失败", e);
108
        }
109
    }
110

111
    private static boolean hasAOPAnnotations(Class<?> clazz) {
112
        for (Method method : clazz.getDeclaredMethods()) {
113
            if (method.isAnnotationPresent(LogExecution.class) ||
114
                method.isAnnotationPresent(Transactional.class)) {
115
                return true;
116
            }
117
        }
118
        return false;
119
    }
120

121
    @SuppressWarnings("unchecked")
122
    private static <T> T createAOPProxy(T target) {
123
        // 这里简化处理，实际Spring会根据情况选择JDK或CGLIB
124
        return (T) Proxy.newProxyInstance(
125
            target.getClass().getClassLoader(),
126
            target.getClass().getInterfaces().length > 0 ?
127
                target.getClass().getInterfaces() :
128
                new Class[]{target.getClass()},
129
            new AOPInvocationHandler(target)
130
        );
131
    }
132
}
133

134
// 测试简化版AOP
135
public class SimpleAOPDemo {
136
    public static void main(String[] args) {
137
        OrderService orderService = SimpleContainer.getBean(OrderService.class);
138

139
        System.out.println("=== 正常订单创建 ===");
140
        orderService.createOrder("ORDER001");
141

142
        System.out.println("\n=== 订单查询 ===");
143
        String order = orderService.getOrder("ORDER001");
144

145
        System.out.println("\n=== 异常订单创建 ===");
146
        try {
147
            orderService.createOrder("ERROR");
148
        } catch (Exception e) {
149
            System.out.println("捕获异常: " + e.getCause().getMessage());
150
        }
151
    }
152
}