设计模式(九)：代理模式(结构型模式)

Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问，通过代理可以增强被代理对象的功能。

场景：假设你喜欢国外某个商户的某件商品，你又不能自己直接从这个商户手里购买，或者你能联系上该商户，但是一系列的额外工作，你觉得麻烦，不想自己完成，假设国内正好有这么个代理商，他能够帮你完成人民币兑换美元，从海外商户那里购买商品，完成海关关税缴纳，以及物流运输等等工作。你觉得多付点钱也没关系。那么这个代理商就是我们本次讨论的代理模式。

根据该场景，本文实现了三种方式：一、自定义代理类，实现静态代理  二、通过jdk反射实现动态代理  三、通过cglib实现动态代理。

jdk与cglib（Code Generation Library）实现动态代理的区别

1.实现方式：
JDK Proxy：反射
CGLib ：CGLib 是基于 ASM（一个 Java 字节码操作框架）
2.JDK Proxy 和 CGLib 的区别
JDK Proxy 是 Java 语言自带的功能，无需通过加载第三方类实现；
Java 对 JDK Proxy 提供了稳定的支持，并且会持续的升级和更新 JDK Proxy，例如 Java 8 版本中的 - - JDK Proxy 性能相比于之前版本提升了很多；
JDK Proxy 是通过拦截器加反射的方式实现的；
JDK Proxy 只能代理继承接口的类；
CGLib 是第三方提供的工具，基于 ASM 实现的，性能比较高；
CGLib 无需通过接口来实现，它是通过实现子类的方式来完成调用的。

一、自定义代理类，实现静态代理 

package com.figo.study2024.pattern.proxy;

/**
 * @ClassName:OrderService
 * @PackageName:com.figo.study2024.pattern.proxy
 * @Description:订单服务接口
 * @Date:2024/2/28 9:09
 * @Author:figo
 */
public interface OrderService {
    public void order();
}




package com.figo.study2024.pattern.proxy;

/**
 * @ClassName:OverSeasOrderService
 * @PackageName:com.figo.study2024.pattern.proxy
 * @Description:实现接口的订单服务类
 * @Date:2024/2/28 9:10
 * @Author:figo
 */
public class OverSeasOrderService implements OrderService{

    @Override
    public void order() {
        System.out.println("从海外商户那里下单");
    }
}


package com.figo.study2024.pattern.proxy;

/**
 * @ClassName:ProxyOrderService
 * @PackageName:com.figo.study2024.pattern.proxy
 * @Description:自定义静态代理类
 * @Date:2024/2/28 9:13
 * @Author:figo
 */
public class ProxyOrderService implements OrderService{
    //海外商户下单服务，被代理对象
    OverSeasOrderService overSeasOrderService;
    //构造函数中,初始化被代理对象
    public ProxyOrderService()
    {
        synchronized (this) {
            if (overSeasOrderService == null) {
                overSeasOrderService = new OverSeasOrderService();
            }
        }
    }

    @Override
    public void order() {
        System.out.println("----------------自定义代理类实现静态代理------------------");

        //先兑换成美元(相当于在被代理对象调用前的功能增强)
        exchangeDollars();
        //用美元向海外商户下单(调用被代理对象)
        overSeasOrderService.order();
        //海关交税再运输到客户手中(相当于在被代理对象调用后的功能增强)
        taxAndTransport();
    }

    public void exchangeDollars()
    {
        System.out.println("人民币兑换美元");
    }

    public void taxAndTransport()
    {
        System.out.println("交完关税进行货物运输到客户手中");
    }
}


客户端测试：

package com.figo.study2024.pattern.proxy;

/**
 * @ClassName:ClientTest
 * @PackageName:com.figo.study2024.pattern.proxy
 * @Description:代理设计模式客户端调用
 * @Date:2024/2/28 9:32
 * @Author:figo
 */
public class ClientTest {
    public static void main(String[] args) {
        //方法1.自定义静态代理对象
        ProxyOrderService proxyOrderService=new ProxyOrderService();
        proxyOrderService.order();
        //方法2.调用jdk动态代理对象
        JdkProxyOrderServiceFactory jdkProxyOrderServiceFactory=new JdkProxyOrderServiceFactory();
        jdkProxyOrderServiceFactory.getProxyObject().order();
        //方法3.调用cglib动态代理对象
        CglibProxyOrderServiceFactory cglibProxyOrderServiceFactory=new CglibProxyOrderServiceFactory();
        cglibProxyOrderServiceFactory.getProxyObject().order();
    }
}

二、通过jdk反射实现动态代理 

package com.figo.study2024.pattern.proxy;

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

/**
 * @ClassName:JdkProxyOrderService
 * @PackageName:com.figo.study2024.pattern.proxy
 * @Description:jdk动态代理类
 * @Date:2024/2/28 9:39
 * @Author:figo
 */
public class JdkProxyOrderServiceFactory {
    //被代理对象必须实现接口，否则需要使用cglib来实现动态代理
    private OverSeasOrderService overSeasOrderService = new OverSeasOrderService();
    public  OrderService getProxyObject() {
        //使用Proxy获取代理对象
        /*
            newProxyInstance()方法参数说明：
                ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
                Class<?>[] interfaces ： 真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口
                InvocationHandler h ： 代理对象的调用处理程序
         */
        OrderService orderService = (OrderService) Proxy.newProxyInstance(overSeasOrderService.getClass().getClassLoader(),
                overSeasOrderService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /*
                        InvocationHandler中invoke方法参数说明：
                            proxy ： 代理对象
                            method ： 对应于在代理对象上调用的接口方法的 Method 实例
                            args ： 代理对象调用接口方法时传递的实际参数
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("----------------jdk反射java.lang.reflect实现动态代理------------------");
                        //先兑换成美元(相当于在被代理对象调用前的功能增强)
                        exchangeDollars();
                        //用美元向海外商户下单(调用被代理对象order方法)
                        Object result = method.invoke(overSeasOrderService, args);
                        //海关交税再运输到客户手中(相当于在被代理对象调用后的功能增强)
                        taxAndTransport();
                        return result;
                    }
                });
        return orderService;
    }

    public void exchangeDollars()
    {
        System.out.println("人民币兑换美元");
    }

    public void taxAndTransport()
    {
        System.out.println("交完关税进行货物运输到客户手中");
    }
}

三、通过cglib实现动态代理

添加依赖

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

package com.figo.study2024.pattern.proxy;

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

import java.lang.reflect.Method;

/**
 * @ClassName:CglibProxyOrderServiceFactory
 * @PackageName:com.figo.study2024.pattern.proxy
 * @Description:cglib动态代理类
 * @Date:2024/2/28 11:03
 * @Author:figo
 */
public class CglibProxyOrderServiceFactory implements MethodInterceptor {

    private OverSeasOrderService target = new OverSeasOrderService();

    public OrderService getProxyObject() {
        //创建增强类Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        OverSeasOrderService obj = (OverSeasOrderService) enhancer.create();
        return obj;
    }

    /*
        intercept拦截方法参数说明：
            o ： 代理对象
            method ： 真实对象中的方法的Method实例
            args ： 实际参数
            methodProxy ：代理对象中的方法的method实例
     */
    @Override
    public OverSeasOrderService intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("----------------cglib(Code Generation Library)实现动态代理------------------");
        //先兑换成美元(相当于在被代理对象调用前的功能增强)
        exchangeDollars();
        //用美元向海外商户下单(调用被代理对象order方法)
        OverSeasOrderService result = (OverSeasOrderService) methodProxy.invokeSuper(o, args);
        //海关交税再运输到客户手中(相当于在被代理对象调用后的功能增强)
        taxAndTransport();
        return result;
    }
    public void exchangeDollars()
    {
        System.out.println("人民币兑换美元");
    }

    public void taxAndTransport()
    {
        System.out.println("交完关税进行货物运输到客户手中");
    }
}