代理模式

定义：为其他对象提供一种代理，以控制对这个对象的访问，代理对象在客户端和目标对象之间起到中介作用，达到代码增强的目的

适用场景

1. 保护目标对象
2. 增强目标对象

优点：

1. 将代理对象和真实被调用的目标对象分离，一定程度上降低了系统的耦合程度

2. 可以保护目标对象，增强目标对象的功能

缺点：

1. 使用代理模式会增加系统的复杂度

2. 在客户端和目标对象之间增加了一个代理对象，会导致请求处理速度变慢

代理模式中的角色

• Subject：抽象主题角色，抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类
• RealSubject：真实主题角色，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象
• Proxy：代理主题角色，代理类，其内部持有RealSubject的引用，因此具备它的代理权，客户端调用代理对象的方法的同时也会调用被代理对象的方法，该类会在这个方法前后增加一些代码

静态代理

硬编码，显示声明被代理的对象，有具体的代理类

public interface ISubject {
    void request();
}

public class ConcreteSubject implements ISubject {
    public void request() {
        System.out.println("执行具体逻辑");
    }
}

public class ProxySubject implements ISubject {
    private ConcreteSubject concreteSubject;
    
    public ProxySubject(ConcreteSubject concreteSubject) {
        this.concreteSubject = concreteSubject;
    }
    
    public void request() {
        System.out.println("执行逻辑的前置操作");
        concreteSubject.request();
        System.out.println("执行逻辑的后置操作");
    }
}

动态代理

动态配置和替换被代理对象，在内存中把代理类创建出来

jdk实现

实现目标类的接口

import java.lang.reflect.Proxy

public class JdkProxy implements InvocationHandler {
    private ISubject target;
    
    public ISubject getInstance(ISubject target) {
        this.target = target;
        Class<?> clazz = target.getClass();
        return (ISubject) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //target的所有方法执行的时候都会执行这个前置和后置的逻辑
        System.out.println("执行逻辑的前置操作");
        Object object = method.invoke(this.target, args);
        System.out.println("执行逻辑的后置操作");
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        JdkProxy jdkProxy = new JdkProxy();
        ISubject subject = jdkProxy.getInstance(new ConcreteSubject());
        subject.request();
    }
}

CGLib实现

使用之前需要引入依赖，继承目标类

<dependency>
	<groupId>cglib</groupId>
    <artifactId>cglib-nodep</artifactId>
    <version>2.2</version>
</dependency>

public class CglibProxy implements MethodInterceptor {
    public Object getInstance(Class<?> clazz) {
        //不需要传入接口，只需要传入一个具体的类，因为cglib会根据class拿到所有方法，然后生成一个代理类继承所有的方法
    	Enhancer enhancer = new Enhancer();
    	enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //target的所有方法执行的时候都会执行这个前置和后置的逻辑
        System.out.println("执行逻辑的前置操作");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("执行逻辑的后置操作");
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        ConcreteSubject concreteSubject = (ConcreteSubject) new CglibProxy().getInstance(ConcreteSubject.class);
        concreteSubject.request();
    }
}

JDK实现与CGLib实现的区别

• JDK 采用实现接口的方式，要求被代理的对象必须实现一个接口，对用户而言，依赖更强，调用也更为复杂；CGLib 采用继承的方式，覆盖父类的方法（不能覆盖被 final 修饰的方法），对目标类没有任何要求。思想：通过字节码重组，生成一个新的对象
• JDK 生成的逻辑比较简单，使用反射，执行效率低；CGLib 没有用到反射，执行效率高

静态代理和动态代理的区别

• 静态代理需要手动编码生成代理类，然后也需要手动操作完成代理操作，如果被代理类增加了新的方法，代理类也要同步更新，违背开闭原则
• 动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则
• 如果动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码

Spring中的代理选择原则

• 当 bean 有实现接口时，Spring会选择 JDK 实现的动态代理方式，Spring 会优先使用这个方式

• 当 bean 没有实现接口时，Spring会选择 CGLib 实现的动态代理方式

• 也可以通过配置来强制使用 CGLib 的方式

  <aop:aspectj-autoproxy proxy-target-class="true"/>