java 设计模式 代理模式

代理模式

代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式通过为真实对象创建一个代理对象，来间接访问该对象，从而在一定程度上控制或优化对实际对象的访问。

代理模式主要类型

代理模式分为两种主要类型：静态代理和动态代理。

静态代理

静态代理是指在编译时就已经生成了代理类，代理类和真实类实现相同的接口，并且代理类在编译时就已经确定下来。

特点：代理类在编译时就已经创建好，代理类和目标类的代码是相对固定的。
缺点：每增加一个目标类，就需要创建一个相应的代理类，增加了代码量，难以扩展。

示例

public interface Service {
    void performAction();
}

public class ServiceImpl implements Service {
    @Override
    public void performAction() {
        System.out.println("Performing action in ServiceImpl");
    }
}

public class ServiceProxy implements Service {
    private Service service;
    
    public ServiceProxy(Service service) {
        this.service = service;
    }
    
    @Override
    public void performAction() {
        System.out.println("Before action");
        service.performAction();
        System.out.println("After action");
    }
}

实际上就是创建个代理类，在代理类中重新被代理方法，调用被代理方法，并在方法前后实现增强

动态代理

动态代理是在程序运行时创建代理类的，这意味着代理类并不是在编译时就存在，而是根据目标类生成的。动态代理可以在运行时根据目标对象的类型来创建代理。

动态代理主要有两种方式：JDK 动态代理 和 CGLIB 动态代理。

JDK动态代理

JDK 动态代理只能代理实现了接口的类。在代理对象创建时，JDK 动态代理会基于反射机制动态生成代理类，并将目标对象的调用委托给代理类。

示例

Proxy.newProxyInstance 会创建一个代理对象，所有对 proxyService.performAction() 的调用都会被转发到 ServiceInvocationHandler 中的 invoke 方法。

public interface Service {
    void performAction();
}

public class ServiceImpl implements Service {
    @Override
    public void performAction() {
        System.out.println("Performing action in ServiceImpl");
    }
}

// 创建动态代理的实现类
public class ServiceInvocationHandler implements InvocationHandler {
    private Object target;
    
    public ServiceInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before action");
        Object result = method.invoke(target, args);
        System.out.println("After action");
        return result;
    }
}

// 生成代理对象
public class Main {
    public static void main(String[] args) {
        Service service = new ServiceImpl();
        Service proxyService = (Service) Proxy.newProxyInstance(
                service.getClass().getClassLoader(), 
                service.getClass().getInterfaces(), 
                new ServiceInvocationHandler(service)
        );
        proxyService.performAction();
    }
}

CGLIB动态代理

CGLIB 动态代理（Code Generation Library）是通过继承目标类并重写其中的方法来创建代理类。与 JDK 动态代理不同，CGLIB 不需要目标类实现接口，能够代理没有接口的类。
CGLIB 代理是通过继承目标类来生成一个代理类。目标类的方法会被代理类重写，进而可以在方法执行前后加入一些额外的逻辑。

示例

Enhancer 用来创建代理对象，它会动态地生成 Service 类的子类，并重写 performAction 方法。代理类会在调用真实方法之前和之后执行额外的逻辑。

public class Service {
    public void performAction() {
        System.out.println("Performing action in Service");
    }
}

// 使用 CGLIB 创建代理类
public class ServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before action");
        Object result = proxy.invokeSuper(obj, args);  // 调用真实的方法
        System.out.println("After action");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service.class);
        enhancer.setCallback(new ServiceInterceptor());
        
        Service proxyService = (Service) enhancer.create();
        proxyService.performAction();
    }
}

总结

静态代理：在编译时就创建好的代理类，通常需要手动编写，且不具有灵活性。

动态代理：代理类在运行时动态生成，有 JDK 动态代理和 CGLIB 动态代理两种方式。Spring AOP 中主要使用动态代理来实现切面编程。

1. JDK 动态代理：要求目标类实现接口，只能对接口方法进行代理。
2. CGLIB 动态代理：不需要目标类实现接口，可以代理没有接口的类，生成目标类的子类。

springboot项目中哪些地方用到了代理模式

在 Spring Boot 项目中，代理模式被广泛应用于多个地方，主要集中在以下几个方面：

Spring AOP：事务管理、日志、权限控制等。
依赖注入：懒加载、作用域代理、事务控制。
数据库访问：JPA/Hibernate 的懒加载、事务管理等。
Spring Security：权限控制、认证验证。
Spring Cache：缓存处理。
Bean 后处理器：自动代理和增强功能的实现。

Spring Boot 利用代理模式有效地实现了很多横切关注点（如事务、缓存、安全、日志等）的处理，让开发者可以专注于业务逻辑，而无需关心这些通用功能的实现。