动态代理模式

代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用

1、静态代理模式

静态代理的特点

1、目标角色固定

2、在应用程序执行前就得到目标角色

3、代理对象会增强目标对象的行为 (添加一些方法)

4、有可能存在多个代理 引起"类爆炸"（缺点）

类爆炸，为一种委托对象都要添加代码。

接口

public interface Abstract1 {
    void getGoods1();
}

public interface Abstract2 {
    void getGoods2();
}

委托类

public class Delegate01 implements Abstract1 {
    public void getGoods1() {
        System.out.println("GOODs1购买中。。。");
    }
}

public class Delegate02 implements Abstract2{
    public void getGoods2() {
        System.out.println("Goods2购买中。。。");
    }
}

静态代理类

/**
 * 实现的委托越多，类就越冗余
 */
public class StacicProxy implements Abstract1,Abstract2{
    private Delegate01 delegate01;
    private Delegate02 delegate02;

    public StacicProxy(Delegate01 delegate01, Delegate02 delegate02) {
        this.delegate01 = delegate01;
        this.delegate02 = delegate02;
    }

    public void getGoods1() {
        beforePreprocessor();
        delegate01.getGoods1();
        afterPreprocessor();
    }

    public void getGoods2() {
        beforePreprocessor();
        delegate02.getGoods2();
        afterPreprocessor();
    }
    private void beforePreprocessor(){
        System.out.println("找专门代购。。");
    }
    private void afterPreprocessor(){
        System.out.println("交易完成。。");
    }
}

客户类

public class Client {
    public static void main(String[] args) {
        Delegate01 delegate01 = new Delegate01();
        Delegate02 delegate02 = new Delegate02();
        StacicProxy proxy = new StacicProxy(delegate01,delegate02);
        proxy.getGoods1();
    }
}

动态代理

相比于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制可以生成任意类型的动态代理类。代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。

动态代理的两种实现方式：

1. JDK 动态代理

2. CGLIB动态代理

动态代理的特点
1、目标对象不固定
2、在应用程序执行时动态创建目标对象
3、代理对象会增强目标对象的行为

DynamicProxy（JDK）

public class DynamicProxy implements InvocationHandler {
    //代理对象
    private Object delegate;

    public Object getDelegate() {
        return delegate;
    }

    public void setDelegate(Object delegate) {
        this.delegate = delegate;
    }
    //前置增强
    private void beforePreprocessor(){
        System.out.println("找专门代购。。");
    }
    //后置增强
    private void afterPreprocessor(){
        System.out.println("交易完成。。");
    }

    //通过Proxy获取动态代理对象
    public Object getProxyInstance(){
       return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),delegate.getClass().getInterfaces(),this);
    }

    //通过动态代理对象对方法增强
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        beforePreprocessor();
        Object ret = method.invoke(delegate, args);
        afterPreprocessor();
        return ret;
    }
}

DynamicProxy （Cglib）

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

public class DynamicProxy2 implements MethodInterceptor {
    //代理对象
    private Object delegate;

    public Object getDelegate() {
        return delegate;
    }

    public void setDelegate(Object delegate) {
        this.delegate = delegate;
    }
    //前置增强
    private void beforePreprocessor(){
        System.out.println("找专门代购。。");
    }
    //后置增强
    private void afterPreprocessor(){
        System.out.println("交易完成。。");
    }

    //通过Proxy获取动态代理对象
    public Object getProxyInstance(){
        // 通过Enhancer对象的create()方法可以生成一个类，用于生成代理对象
        Enhancer enhancer = new Enhancer();
        // 设置父类 (将目标类作为其父类)
        enhancer.setSuperclass(delegate.getClass());
        // 设置拦截器 回调对象为本身对象
        enhancer.setCallback(this);
        // 生成一个代理类对象，并返回
        return enhancer.create();
    }

    //通过动态代理对象对方法增强
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        beforePreprocessor();
        Object ret = methodProxy.invoke(delegate, objects);
        afterPreprocessor();
        return ret;
    }
}

Client

public class Client {
    public static void main(String[] args) {
        //委托类1
        Delegate01 delegate01 = new Delegate01();
        //委托类2
        Delegate02 delegate02 = new Delegate02();

        //动态代理类
//        DynamicProxy dynamicProxy = new DynamicProxy();
        DynamicProxy2 dynamicProxy = new DynamicProxy2();

        //对委托1
        dynamicProxy.setDelegate(delegate01);
        Abstract1 proxyInstance = (Abstract1)dynamicProxy.getProxyInstance();
        proxyInstance.getGoods1();
        System.out.println("========================================");
        //对委托2
        dynamicProxy.setDelegate(delegate02);
        Abstract2 proxyInstance2 = (Abstract2)dynamicProxy.getProxyInstance();
        proxyInstance2.getGoods2();
    }
}

JDK代理与CGLIB代理的区别

1、JDK动态代理实现接口，Cglib动态代理继承思想
2、JDK动态代理（目标对象存在接口时）执行效率高于Ciglib
3、如果目标对象有接口实现，选择JDK代理，如果没有接口实现选择Cglib代理