设计模式5-代理模式

一、概念

结构型模式

给某一对象提供给一个代理类，并由代理对象控制对原对象的引用。

代理模式实现（三要素）

 一句话：客户端通过代理类来调用目标方法，代理类会将所有的方法调用分派到目标对象上反射执行，还可以在分派过程中添加"前置通知"和后置处理。

• 一个接口，接口中的方法是具体要实现的；
• 一个被代理类，实现上述接口， 这是真正去执行接口中方法的类；
• 一个代理类，实现上述接口，同时分装被代理类对象，帮助被代理类去实现方法。

 代理模式分为静态代理模式和动态代理模式，首先我们来看下静态代理模式。

二、静态代理模式

这里模拟的是网站的访问。几乎所有的Web项目尤其是大型网站，不可能采用集中式的架构的，必定是采用分布式架构。 对于分布式架构，但用户发起请求的时候，请求指向的并不是最终的服务器端，而是代理服务器，比如Nginx，用以负载均衡。

示例：用户访问网站->代理服务器->最终服务器。先定义一个服务器接口Server，简单定义一个方法：

/**
 * 服务器接口，用于获取网站数据
 */
public interface Server {

    /**
     * 根据url获取页面标题
     */
    String getPageTitle(String url);

}

例如我们访问的是百度，所以定义一个BdServer（此处采用简单的if...else判定，便于理解）:

public class BdServer implements Server{
    public BdServer() {
        System.out.println("BdServer Constructor");
    }

    @Override
    public String getPageTitle(String url) {
        if ("https://www.baidu.com/".equals(url)) {
            return "百度首页";
        } else if ("http://top.baidu.com/?fr=mhd_card".equals(url)) {
            return "百度风云榜";
        }
        System.out.println("url not match.");
        return "无页面标题";
    }
}

若不采用代理，那么访问网站，就会直接new BdServer()出来并且调用getPageTitle(String url)方法即可；

由于分布式架构的存在，因此我们这里要写一个NginxProxy，作为一个代理，到时候用户直接访问的是NginxProxy而不是和BdServer打交道，由NginxProxy负责和最终的BdServer打交道。

/**
 * Nginx代理
 */
public class NginxProxy implements Server {

    /**
     * 服务器列表
     */
    private static final List<String> SERVER_ADDRESSES = Lists.newArrayList("192.168.1.1", "192.168.1.2", "192.168.1.3");

    private Server server;

    public NginxProxy(Server server) {
        this.server = server;
    }

    @Override
    public String getPageTitle(String url) {
        // 这里就简单传了一个url，正常请求传入的是Request，使用UUID模拟请求原始Ip
        String remoteIp = UUID.randomUUID().toString();
        // 路由选择算法这里简单定义为对remoteIp的Hash值的绝对值取模
        int index = Math.abs(remoteIp.hashCode()) % SINA_SERVER_ADDRESSES.size();
        // 选择服务器Ip
        String realIp = SERVER_ADDRESSES.get(index);

        return "【页面标题：" + server.getPageTitle(url) + "】,【来源Ip：" + realIp + "】";
    }

}

这里同样为了简单起见，服务器列表写死几个ip，同时由于只传一个url而不是具体的Request，每次随机一个UUID，对UUID的HashCode绝对值取模，模拟这次请求被路由到哪台服务器上。

调用方法：

/**
 * 静态代理测试
 */
public class StaticProxyTest {

    @Test
    public void testStaticProxy() {
        Server bdServer = new BdServer();
        Server nginxProxy = new NginxProxy(bdaServer );
        System.out.println(nginxProxy.getPageTitle("https://www.baidu.com/"));
    }

}

第8行表示的是要访问的是百度服务器，第9行表示的是用户实际访问的是Nginx代理而不是真实的百度服务器，由于百度服务器和代理服务器实际上都是服务器，因此他们可以使用相同的接口Server。

以上就是一个静态代理的例子，即用户不和最终目标对象角色（BdServer）打交道，而是和代理对象角色（NginxProxy）打交道，由代理对象角色（NginxProxy）控制用户的访问。

但静态代理也有相应的缺点：

• 静态代理的特点是静态代理的代理类是程序员创建的，在程序运行之前静态代理的.class文件已经存在了。
• 从静态代理模式的代码来看，静态代理模式确实有一个代理对象来控制实际对象的引用，并通过代理对象来使用实际对象。这种模式在代理量较小的时候还可以，但是代理量一大起来，就存在着两个比较大的缺点：

           1）静态代理的内容，即NginxProxy的路由选择这几行代码，只能服务于Server接口而不能服务于其他接口，如果其它接口想用这几行代码，比如新增一个静态代理类。久而久之，由于静态代理的内容无法复用，必然造成静态代理类的不断庞大

           2）Server接口里面如果新增了一个方法，比如getPageData(String url)方法，实际对象实现了这个方法，代理对象也必须新增方法getPageData(String url)，去给getPageData(String url)增加代理内容（假如需要的话）

三、动态代理

动态代理有两种方式，利用JDK中的代理类Proxy实现动态代理（只能针对接口生成代理类，不可为某一个类生成代理类，底层反射机制）以及使用CGLIB（一种字节码增强技术，底层继承实现）来为某一个类或接口实现代理。

1、利用JDK中的代理类Proxy实现动态代理

JDK动态代理是由JDK的java.lang.reflect.*包提供支持的， 只针对接口生成代理类，使用的是JDK自带的Proxy类+InvocationHandler接口invoke反射调用，提供的代理类提供真实对象的绑定和代理方法。

实现：

• 通过实现InvocationHandler接口来自定义自己的InvocationHandler（该接口只有一个方法）；
• 通过Proxy.getProxyClass获取动态代理类；
• 通过反射机制获取代理类的构造方法，方法签名为getConstructor（InvocationHandler.class);
• 通过构造函数获得代理对象并将自定义的InvocationHandler实例对象作为参数传入；
• 通过代理对象调用目标方法。

在举例前着重看下InvacationHandler接口和Proxy类

InvocationHandler接口（只有一个方法）

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

• proxy：代理类对象
• method：被代理的方法
• args：被代理的方法的参数列表

Proxy 类

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException

• loader:类加载器
• interfaces：代理类实现的所有接口
• h：InvocationHandler接口的一个实例  this当前对象

因为我们想使用jdk动态代理 必须是 代理类 实现 InvocationHandler！ 它让我们传递父接口 我们传递 自身！

 

示例

将上述的NginxProxy.java改为以下的NginxInvacationHandler.java

/**
 * Nginx InvocationHandler
 */
public class NginxInvocationHandler implements InvocationHandler {

    /**
     * 服务器列表
     */
    private static final List<String> SERVER_ADDRESSES = Lists.newArrayList("192.168.1.1", "192.168.1.2", "192.168.1.3");

    private Object object;

    public NginxInvocationHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String remoteIp = UUID.randomUUID().toString();
        int index = Math.abs(remoteIp.hashCode()) % SERVER_ADDRESSES.size();
        String realIp = SERVER_ADDRESSES.get(index);

        StringBuilder sb = new StringBuilder();
        sb.append("【页面标题：");
        sb.append(method.invoke(object, args)); //这里的method.invoke执行的就是BdServer中的getPageTitle方法,使用的反射
        sb.append("】,【来源Ip：");
        sb.append(realIp );
        sb.append("】");
        return sb.toString();
    }

}

 此处增加一个反射示例：

public class A {
    
    public void foo(String name) {
    System.out.println("Hello, " + name);
    }
}

通过TestClassLoader类来反射调用A上的方法
public class TestClassLoad {
    
    public static void main(String[] args) throws Exception {
      
        //获得代理类
        Class<?> clz = Class.forName("com.jincou.study.A");
        //获得代理类对象
        Object o = clz.newInstance();
        //获得foo方法
         Method m = clz.getMethod("foo", String.class);
        //执行foot方法
         m.invoke(o,"张三");
   }
}

这里就将选择服务器的逻辑抽象成为了公共的代码了，因为调用的是Object里面的method，Object是所有类的超类，因此并不限定非要是Sever，A、B、C都是可以的，因此这个NginxInvocationHandler可以灵活地被各个地方给复用。

调用：

  /**
   * 动态代理测试
  */
  public class DynamicProxyTest {
  
      @Test
      public void testDynamicProxy() {
          Server bdServer = new BdServer();
          InvocationHandler invocationHandler = new NginxInvocationHandler(bdServer);
         //将自定义的InvocationHandler示例传入，获取动态代理对象，此处的Server.class不可替换成实现类如BdServer.class，不然会报Exception in thread "main" java.lang.IllegalArgumentException: proxy.DynamicBdServer is not an interface
         Server proxy = (Server)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{Server.class}, invocationHandler);
    
        //通过代理对象调用目标方法
         System.out.println(proxy.getPageTitle("https://www.baidu.com/"));
     }
 
 }

以上第11行是封装好的创建动态代理对象的方法，也可采用如下方式获取代理对象：

//获取动态代理类（proxyClazz:class com.sun.proxy.$Proxy0)
Class<?> proxyClazz = Proxy.getProxyClass(this.getClass().getClassLoader(),Server.class); 

//获得代理类的构造函数，并传入参数类型InvocationHandler.class (constructor: public com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler
Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);

//通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入(Server:com.frieda.pattern.NginxInvacationHandler$BdServer@12b42d12)
Server server = (Server) constructor.newInstance(new NginxInvocationHandler(new BdServer()));

以上第一步已获得了代理对象，代理对象的名称是：$Proxy0；

第二部发现代理类的构造函数需要传入一个java.lang.reflect.InvacationHandler类；

第三部通过构造函数创建对象，构造函数里传入NginxInvacationHandler类，而它是现实InvacationHandler接口 。

以上就是通过反射机制来实现创建类的。

Proxy本身也是JDK提供给开发者的，使用Proxy的newProxyInstance方法可以产生对目标接口的一个代理，至于代理的内容，即InvocatoinHandler的实现。

2、通过CGLIB实现动态代理

Cglib，也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

Cglib是一个强大的、高性能的代码生成包，它可以在运行期扩展java类与实现java接口，它广泛被许多AOP框架使用，为他们提供方法的拦截。

Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.。

 

要实现CGLIB代理，需要实现MEthodInterceptor的代理方法。

依赖jar（Spring的核心包中已经包括了Cglib功能， spring-core）：

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

实现：

• 声明增强类实例，用于生产代理类；
  • Enhancer enhancer = new Enhancer();
• 设置被代理类字节码，CGLIB根据字节码生成被代理类的子类；
  • enhancer.setSuperclass(target.getClass());
• 设置回调函数，即一个方法拦截；
  • enhancer.setCallback(this);
• 创建代理。
  • return (A)enhancer.create();

同样在举例前着重看下MethodInterceptor接口和Enhancer类

MethodInterceptor接口

public Object intercept(Object obj, Method method,Object[] args,MethodProxy proxy) throws Throwable;

intercept是所有拦截器执行的方法，类似于jdk动态代理中的invoke

Enhancer类

设置委托类和代理类的公共接口或者公共的父类

 public void setSuperclass(Class superclass) {
                  if (superclass != null && superclass.isInterface()) {
                      setInterfaces(new Class[]{ superclass });
                  } else if (superclass != null && superclass.equals(Object.class)) {
                      // affects choice of ClassLoader
                      this.superclass = null;
                  } else {
                      this.superclass = superclass;
                  }
              }

代理类执行完毕 通知委托类

public void setCallback(final Callback callback) {
                      setCallbacks(new Callback[]{ callback });
                  }

在Enhancer类的父类AbstractClassGenerator中有一个方法 创建我们需要的代理类

protected Object create(Object key)

示例

/**
 * CGLIB动态代理
 */
public class CglibProxy implements MethodInterceptor {

    /**
     *
     * @param clazz Class类
     * @param argTypes
     * @param args
     * @return Class的动态代理对象
     */
    public Object getInstance(Class clazz, Class[] argTypes, Object[] args){
        //CGLIB enchancer增强类对象
        Enhancer enhancer = new Enhancer();
        //设置增强类型
        enhancer.setSuperclass(clazz);
        //定义代理对象为当前对象，要求当前对象实现MethodInterceptor
        enhancer.setCallback(this);
        //生产并返回代理对象(argTypes, atgs 为构造函数参数）
        return enhancer.create(argTypes, args);
    }


    /**
     *
     * @param proxy 代理对象
     * @param method 方法
     * @param args 方法参数
     * @param methodProxy 方法代理
     * @return
     * @throws Throwable 抛出异常
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用真实对象前");

        //CGLIB反射调用真实对象方法
        Object result = methodProxy.invokeSuper(proxy, args);

        System.out.println("调用真实对象后");

        return result;
    }

}

 

关于cglib动态代理中invokeSuper和invoke的区别参考：https://blog.csdn.net/z69183787/article/details/106878203/

调用示例

    public static void main(String[] args) {
        CglibProxy cglibProxy = new CglibProxy();
        Class[] argumentTypes = new Class[]{};
        Object[] arguments = new Object[]{};
        //获取动态代理对象
        BdServer server = (BdServer) cglibProxy.getInstance(BdServer.class, argumentTypes ,arguments);
        server.getPageTitle("2222");

    }

结果：

BdServer Constructor
调用真实对象前
url not match.
调用真实对象后

 注意：

1、代理的类不能为final,否则报错， 如上述BdServer不能用final修饰， 否则报错“Exception in thread "main" java.lang.IllegalArgumentException: Cannot subclass final class class com.frieda.zxm.spring.pattern.strategy.BdServer”。

2、目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.。

  例如上述BdServer中getPageUrl方法采用static或final修饰，结果为:

BdServer Constructor
url not match.

 四、代理模式在Java中的应用以及解读

MyBatis的Mapper就是一个接口，它采用的就是JDK的动态代理；

在MyBatis中通常在延迟加载的时候回用到CGLIB的动态代理；

Spring AOP（面向切面编程），扩展功能不能修改源代码，采用横向抽取机制，取代了传统纵向继承体系重复代码。

那分别在什么场景下使用JDK动态代理和CGLIB动态代理？

• 　如果加入容器的目标对象有实现接口,用JDK代理
• 　如果目标对象没有实现接口,用Cglib代理 　　
• 　如果目标对象实现了接口，且强制使用cglib代理，则会使用cglib代理

 

强制使用CGLIB动态代理（没有实践过~）

Spring中强制使用Cglib代理

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

SpringBoot中强制使用Cglib代理