Java设计模式-代理模式

代理模式定义：给目标对象提供一个代理对象，并且由代理对象控制对目标对象的访问。

代理模式分为两类：静态代理、动态代理。

• 静态代理：在编译期间就确定代理类，代理类和被代理类在编译时就已经确定，需要针对每个被代理类编写一个代理类。
• 动态代理：在运行时动态生成代理类。Java 中主要有基于接口的 JDK 动态代理和基于类的 CGLIB 动态代理。JDK 动态代理要求被代理类必须实现接口，通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现。CGLIB 代理不需要被代理类实现接口，通过继承被代理类来创建代理对象，被代理类不能为 final 类。

代理模式的应用场景：

功能增强：

• 日志记录与性能监控：在不修改原有业务逻辑的情况下，通过代理在方法调用前后记录日志或监控性能。
• 事务管理：在业务方法执行前后添加事务开启和提交等逻辑。

控制访问：

• 远程代理：控制访问远程对象，为一个位于不同机器的 JVM 上的对象提供一个本地的代理对象，如远程方法调用（RMI）。
• 虚拟代理：根据实际需要创建开销很大的对象，先创建一个消耗相对较小的对象表示较大的对象，大对象只在需要时才会被真正创建。
• 保护代理：进行权限控制，用于对象有不同访问权限的情况。

代理模式的主要优点：

• 职责清晰：将核心业务逻辑和辅助功能分离，如将日志记录、权限控制等功能从核心业务中分离到代理类中。
• 解耦合：客户端和目标对象之间通过代理对象进行交互，降低了两者之间的耦合度。
• 可扩展性好：可以在不修改目标类代码的情况下，通过代理类方便地添加新功能。
• 便于维护和管理：将横切关注点（如日志、事务等）集中在代理类中，便于统一维护和管理。
• 增强代码的可测试性：在单元测试中，可以使用代理对象模拟目标对象的行为，方便对相关代码进行测试。

代理模式Java样例：

静态代理：

// 定义接口
interface Rent {
    void rent();
}

// 目标类
class Host implements Rent {
    // 房东出租房子的方法
    @Override
    public void rent() {
        System.out.println("房东出租房子。");
    }
}

// 代理类
class StaticProxy implements Rent {
    // 持有目标对象的引用
    private Rent rent;

    // 构造方法，传入目标对象
    public StaticProxy(Rent rent) {
        this.rent = rent;
    }

    // 实现rent方法，在调用目标对象的方法前后添加额外逻辑
    @Override
    public void rent() {
        seeHouse();
        rent.rent();
    }

    // 代理类的额外方法，带房客看房
    public void seeHouse() {
        System.out.println("中介带房客看房子。");
    }
}

// 测试类
class Test {
    public static void main(String[] args) {
        // 创建目标对象
        Rent host = new Host();
        // 创建代理对象，将目标对象传入
        StaticProxy proxy = new StaticProxy(host);
        // 通过代理对象调用方法
        proxy.rent();
    }
}

动态代理-JDK 动态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义接口
interface Rent {
    void rent();
}

// 目标类
class Host implements Rent {
    // 房东出租房子的方法
    @Override
    public void rent() {
        System.out.println("房东出租房子。");
    }
}

// 代理实例的调用处理程序，实现InvocationHandler接口
class ProxyInvocationHandler implements InvocationHandler {
    // 被代理的对象
    private Object target;

    // 设置被代理的对象
    public void setTarget(Object target) {
        this.target = target;
    }

    // 当通过代理对象调用方法时，会调用此方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用目标对象的方法前添加额外逻辑
        System.out.println("中介带房客看房子。");
        // 调用目标对象的方法
        Object result = method.invoke(target, args);
        // 在调用目标对象的方法后添加额外逻辑
        System.out.println("中介帮助签合同。");
        return result;
    }
}

// 测试类
class Test {
    public static void main(String[] args) {
        // 创建目标对象
        Host host = new Host();
        // 创建代理实例的调用处理程序
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        // 设置被代理的对象
        handler.setTarget(host);
        // 创建代理对象
        Rent proxy = (Rent) Proxy.newProxyInstance(
                host.getClass().getClassLoader(),
                host.getClass().getInterfaces(),
                handler
        );
        // 通过代理对象调用方法
        proxy.rent();
    }
}

动态代理-CGLIB 动态代理

1 在pom中添加cglib的依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

2 定义目标类

public class UserService {
    public void addUser(String username) {
        System.out.println("User " + username + " added.");
    }
}

3 使用cglib创建代理类

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibDemo {
    public static void main(String[] args) {
        // 创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        // 设置要代理的目标类
        enhancer.setSuperclass(UserService.class);
        // 设置回调函数，即方法拦截器
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable {
                // 在调用目标方法前执行的逻辑
                System.out.println("Before method: " + method.getName());
                // 调用目标类的方法
                Object result = proxy.invokeSuper(obj, args);
                // 在调用目标方法后执行的逻辑
                System.out.println("After method: " + method.getName());
                return result;
            }
        });
        // 创建代理对象
        UserService userService = (UserService) enhancer.create();
        // 调用代理对象的方法
        userService.addUser("Alice");
    }
}