Java动态代理实现原理

发布时间: 2025-03-22 09:45

↑

# Java动态代理实现原理

动态代理是Java反射机制的一个重要应用，它允许在运行时创建一个实现了指定接口的代理类。本文将详细介绍Java动态代理的实现原理、使用方法和实践应用。

## 动态代理基础

### 1. 什么是动态代理

```java
public class DynamicProxyDemo {
    // 定义接口
    interface UserService {
        void addUser(String name);
        String getUser(int id);
    }
    
    // 实现类
    static class UserServiceImpl implements UserService {
        @Override
        public void addUser(String name) {
            System.out.println("Adding user: " + name);
        }
        
        @Override
        public String getUser(int id) {
            return "User " + id;
        }
    }
    
    public static void main(String[] args) {
        // 创建目标对象
        UserService target = new UserServiceImpl();
        
        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method,
                                   Object[] args) throws Throwable {
                    System.out.println("Before method: " +
                                     method.getName());
                    Object result = method.invoke(target, args);
                    System.out.println("After method: " +
                                     method.getName());
                    return result;
                }
            });
        
        // 使用代理对象
        proxy.addUser("John");
        String user = proxy.getUser(1);
    }
}
```

动态代理特点：
1. 运行时创建代理类
2. 无需手写代理类
3. 可以代理多个接口
4. 统一处理代理方法

## 实现原理

### 1. JDK动态代理

```java
public class JDKProxyDemo {
    // 自定义InvocationHandler
    static class LoggingHandler implements InvocationHandler {
        private final Object target;
        
        public LoggingHandler(Object target) {
            this.target = target;
        }
        
        @Override
        public Object invoke(Object proxy, Method method,
                           Object[] args) throws Throwable {
            // 前置处理
            System.out.println("[LOG] Before " + method.getName());
            
            // 调用目标方法
            Object result = method.invoke(target, args);
            
            // 后置处理
            System.out.println("[LOG] After " + method.getName());
            
            return result;
        }
    }
    
    public static void main(String[] args) {
        // 创建目标对象
        List<String> target = new ArrayList<>();
        
        // 创建代理对象
        List<String> proxy = (List<String>) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LoggingHandler(target));
        
        // 使用代理对象
        proxy.add("Hello");
        proxy.get(0);
    }
}
```

实现步骤：
1. 创建InvocationHandler
2. 获取类加载器
3. 获取接口数组
4. 生成代理类

### 2. 代理类生成

```java
public class ProxyGenerationDemo {
    public static void main(String[] args) {
        // 保存代理类字节码
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles",
                          "true");
        
        // 创建代理对象
        Interface proxy = (Interface) Proxy.newProxyInstance(
            Interface.class.getClassLoader(),
            new Class<?>[] { Interface.class },
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method,
                                   Object[] args) {
                    return null;
                }
            });
        
        // 查看代理类信息
        System.out.println(proxy.getClass().getName());
        System.out.println(Arrays.toString(
            proxy.getClass().getInterfaces()));
    }
    
    interface Interface {
        void method();
    }
}
```

生成过程：
1. 生成类名
2. 创建类字节码
3. 实现接口方法
4. 添加字段和构造器

## CGLIB动态代理

### 1. 基本用法

```java
public class CGLibProxyDemo {
    // 目标类
    static class UserService {
        public void addUser(String name) {
            System.out.println("Adding user: " + name);
        }
        
        public String getUser(int id) {
            return "User " + id;
        }
    }
    
    // 方法拦截器
    static class LoggingInterceptor implements MethodInterceptor {
        @Override
        public Object intercept(Object obj, Method method,
                              Object[] args, MethodProxy proxy)
                              throws Throwable {
            System.out.println("Before: " + method.getName());
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("After: " + method.getName());
            return result;
        }
    }
    
    public static void main(String[] args) {
        // 创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new LoggingInterceptor());
        
        // 创建代理对象
        UserService proxy = (UserService) enhancer.create();
        
        // 使用代理对象
        proxy.addUser("John");
        proxy.getUser(1);
    }
}
```

CGLIB特点：
1. 继承方式实现
2. 可以代理类
3. 性能较好
4. 不需要接口

### 2. 高级特性

```java
public class CGLibAdvancedDemo {
    // 多个回调
    static class MultipleCallback {
        static class Service {
            public void method1() {
                System.out.println("Method 1");
            }
            
            public void method2() {
                System.out.println("Method 2");
            }
        }
        
        public static void main(String[] args) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(Service.class);
            
            // 设置多个回调
            enhancer.setCallbacks(new Callback[] {
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object obj, Method method,
                                          Object[] args,
                                          MethodProxy proxy)
                                          throws Throwable {
                        System.out.println("Callback 1");
                        return proxy.invokeSuper(obj, args);
                    }
                },
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object obj, Method method,
                                          Object[] args,
                                          MethodProxy proxy)
                                          throws Throwable {
                        System.out.println("Callback 2");
                        return proxy.invokeSuper(obj, args);
                    }
                }
            });
            
            // 设置回调过滤器
            enhancer.setCallbackFilter(new CallbackFilter() {
                @Override
                public int accept(Method method) {
                    if (method.getName().equals("method1")) {
                        return 0;
                    } else {
                        return 1;
                    }
                }
            });
            
            Service proxy = (Service) enhancer.create();
            proxy.method1();
            proxy.method2();
        }
    }
}
```

高级特性：
1. 多重回调
2. 回调过滤
3. 延迟加载
4. 命名策略

## 实践应用

### 1. AOP实现

```java
public class AOPDemo {
    // 定义注解
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    static @interface LogExecutionTime {}
    
    // 目标类
    static class UserService {
        @LogExecutionTime
        public void slowMethod() throws InterruptedException {
            Thread.sleep(1000);
        }
        
        public void fastMethod() {
            // 快速方法
        }
    }
    
    // 代理处理器
    static class TimeLoggingHandler implements InvocationHandler {
        private final Object target;
        
        public TimeLoggingHandler(Object target) {
            this.target = target;
        }
        
        @Override
        public Object invoke(Object proxy, Method method,
                           Object[] args) throws Throwable {
            if (method.isAnnotationPresent(LogExecutionTime.class)) {
                long start = System.currentTimeMillis();
                Object result = method.invoke(target, args);
                long end = System.currentTimeMillis();
                System.out.println(method.getName() +
                    " took " + (end - start) + "ms");
                return result;
            }
            return method.invoke(target, args);
        }
    }
    
    public static void main(String[] args) throws Exception {
        UserService target = new UserService();
        UserService proxy = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class<?>[] { UserService.class },
            new TimeLoggingHandler(target));
        
        proxy.slowMethod();
        proxy.fastMethod();
    }
}
```

AOP应用：
1. 方法拦截
2. 性能监控
3. 事务管理
4. 安全控制

### 2. 动态代理最佳实践

```java
public class ProxyBestPracticesDemo {
    // 1. 代理工厂
    static class ProxyFactory {
        public static <T> T createProxy(T target,
                                       Class<?>... interfaces) {
            return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                interfaces,
                new LoggingHandler(target));
        }
    }
    
    // 2. 可重用的InvocationHandler
    static class LoggingHandler implements InvocationHandler {
        private final Object target;
        private final Logger logger = Logger.getLogger(
            LoggingHandler.class.getName());
        
        public LoggingHandler(Object target) {
            this.target = target;
        }
        
        @Override
        public Object invoke(Object proxy, Method method,
                           Object[] args) throws Throwable {
            try {
                logger.info("Entering " + method.getName());
                Object result = method.invoke(target, args);
                logger.info("Exiting " + method.getName());
                return result;
            } catch (Exception e) {
                logger.severe("Exception in " + method.getName());
                throw e;
            }
        }
    }
    
    // 3. 使用示例
    public static void main(String[] args) {
        // 创建代理
        List<String> list = new ArrayList<>();
        List<String> proxy = ProxyFactory.createProxy(list,
            List.class);
        
        // 使用代理
        try {
            proxy.add("test");
            proxy.get(0);
        } catch (Exception e) {
            // 异常处理
        }
    }
}
```

最佳实践：
1. 使用代理工厂
2. 异常处理
3. 资源管理
4. 性能考虑

## 总结

通过本文，我们详细了解了Java动态代理的核心内容：

1. 基本概念
   - 动态代理的定义
   - JDK动态代理
   - CGLIB动态代理

2. 实现原理
   - 代理类生成
   - 方法调用过程
   - 性能特点

3. 实践应用
   - AOP实现
   - 最佳实践
   - 注意事项

在实际开发中，我们需要：

1. 理解动态代理的工作原理
2. 选择合适的代理方式
3. 注意性能影响
4. 遵循最佳实践

掌握这些知识对于实现面向切面编程和提高代码质量至关重要。

元素码农