代理模式 proxy - 图1

代理(Proxy)是一种设计模式,提供了间接对目标对象进行访问的方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的功能上,增加额外的功能补充,即扩展目标对象的功能.符合开闭原则，即在对既有代码不改动的情况下，增加代码进行功能的扩展。

背景

歌手与经纪人之间就是被代理和代理的关系,歌手出演活动的时候，歌手就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的经纪人。这就是典型的代理模式

分析

代理模式实现分为三种:

  • 静态代理
  • 动态代理
  • cglib代理

静态代理

  1. 抽象主题类
  1. public interface Subject {
  2.     /**
  3.      * 接口方法
  4.      */
  5.     public void request();
  6. }
  1. 具体主题类
  1. public class ConcreteSubject implements Subject {
  2.     /**
  3.      * 具体的业务逻辑实现
  4.      */
  5.     @Override
  6.     public void request() {
  7.         //业务处理逻辑
  8.     }
  9. }
  1. 代理类
  1. public class Proxy implements Subject {
  3.     /**
  4.      * 要代理的实现类
  5.      */
  6.     private Subject subject = null;
  8.     /**
  9.      * 默认代理自己
  10.      */
  11.     public Proxy() {
  12.         this.subject = new Proxy();
  13.     }
  15.     public Proxy(Subject subject) {
  16.         this.subject = subject;
  17.     }
  19.     /**
  20.      * 构造函数，传递委托者
  21.      *
  22.      * @param objects 委托者
  23.      */
  24.     public Proxy(Object... objects) {
  25.     }
  27.     /**
  28.      * 实现接口方法
  29.      */
  30.     @Override
  31.     public void request() {
  32.         this.before();
  33.         this.subject.request();
  34.         this.after();
  35.     }
  37.     /**
  38.      * 预处理
  39.      */
  40.     private void before() {
  41.         //do something
  42.     }
  44.     /**
  45.      * 后处理
  46.      */
  47.     private void after() {
  48.         //do something
  49.     }
  50. }
  1. 客户端类
  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Subject subject = new ConcreteSubject();
  4.         Proxy proxy = new Proxy(subject);
  5.         proxy.request();
  6.     }
  7. }

动态代理

静态代理的意思呢，通过上面的案例就可以发现，他只能代理一个对象，可以理解为一个经纪人只能代理一个歌手的活动，这样就会产生很多的代理人。所以我们想办法通过一个代理类完成全部的代理功能，那么我们就需要用动态代理.
动态代理就是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象。

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类的支持。

java.lang.reflect.InvocationHandler接口的定义

  1. package java.lang.reflect;
  2. public interface InvocationHandler {
  3.     public Object invoke(Object proxy, Method method, Object[] args)
  4.         throws Throwable;
  5. }

参数解释：

  • Object proxy 被代理对象
  • Method method 要调用的方法
  • Object[] args 方法调用时所需要的参数

java.lang.reflect.Proxy类的定义

  1. public class Proxy implements java.io.Serializable {
  3.     private static final long serialVersionUID = -2222568056686623797L;
  5.     /** parameter types of a proxy class constructor */
  6.     private static final Class<?>[] constructorParams =
  7.         { InvocationHandler.class };
  9.     /**
  10.      * a cache of proxy classes
  11.      */
  12.     private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
  13.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
  15.     /**
  16.      * the invocation handler for this proxy instance.
  17.      * @serial
  18.      */
  19.     protected InvocationHandler h;
  21.     /**
  22.      * Prohibits instantiation.
  23.      */
  24.     private Proxy() {
  25.     }
  26.     ········
  27.     //中间其他方法就不介绍了
  28.     //主要是这个创建的方法
  29.     @CallerSensitive
  30.     public static Object newProxyInstance(ClassLoader loader,
  31.                                           Class<?>[] interfaces,
  32.                                           InvocationHandler h) throws IllegalArgumentException {
  33.         Objects.requireNonNull(h);
  35.         final Class<?>[] intfs = interfaces.clone();
  36.         final SecurityManager sm = System.getSecurityManager();
  37.         if (sm != null) {
  38.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  39.         }
  41.         /*
  42.          * Look up or generate the designated proxy class.
  43.          */
  44.         Class<?> cl = getProxyClass0(loader, intfs);
  46.         /*
  47.          * Invoke its constructor with the designated invocation handler.
  48.          */
  49.         try {
  50.             if (sm != null) {
  51.                 checkNewProxyPermission(Reflection.getCallerClass(), cl);
  52.             }
  54.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  55.             final InvocationHandler ih = h;
  56.             if (!Modifier.isPublic(cl.getModifiers())) {
  57.                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
  58.                     public Void run() {
  59.                         cons.setAccessible(true);
  60.                         return null;
  61.                     }
  62.                 });
  63.             }
  64.             return cons.newInstance(new Object[]{h});
  65.         } catch (IllegalAccessException|InstantiationException e) {
  66.             throw new InternalError(e.toString(), e);
  67.         } catch (InvocationTargetException e) {
  68.             Throwable t = e.getCause();
  69.             if (t instanceof RuntimeException) {
  70.                 throw (RuntimeException) t;
  71.             } else {
  72.                 throw new InternalError(t.toString(), t);
  73.             }
  74.         } catch (NoSuchMethodException e) {
  75.             throw new InternalError(e.toString(), e);
  76.         }
  77.     }
  78. }

参数说明：

  • ClassLoader loader 类的加载器
  • Class<?>[] interfaces 得到全部的接口
  • InvocationHandler h 得到InvocationHandler接口的子类的实例

主要就是利用反射构建出代理类

例子

下面就是例子

  1. 目标接口类
  1. //目标类接口
  2. interface ISinger{
  3.     void singing();
  4. }
  1. 目标歌手类
  1. //目标类
  2. class Zxy implements ISinger{
  4.     @Override
  5.     public void singing() {
  6.         System.out.println("张学友唱歌");
  7.     }
  8. }
  1. 代理功能
  1. class SingerUtils{
  2.     public static void method1() {
  3.         System.out.println("增强方式一");
  4.     }
  6.     public static void method2() {
  7.         System.out.println("增强方式二");
  8.     }
  9. }
  1. 代理人预编译处理
  1. class SingerInvocationHandle implements InvocationHandler{
  2.     private Object target;
  3.     public void setTarget(Object target) {
  4.         this.target = target;
  5.     }
  6.     @Override
  7.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  8.             SingerUtils.method1();
  9.             method.invoke(target, args);
  10.             SingerUtils.method2();
  11.             return null;
  12.     }
  13. }
  1. 创建代理人
  1.  class SingerProxyFactory{
  2.     public static Object getProxy(Object target) {
  3.         SingerInvocationHandle handle = new SingerInvocationHandle();
  4.         handle.setTarget(target);
  5.         Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handle);
  6.         return proxy;
  7.     }
  8.  }
  1. 测试
  1. public class ProxyDemo {
  2.     public static void main(String[] args) {
  3.       //张学友要开演唱会，首先张学友得唱歌
  4.       ISinger zxy = new Zxy();
  5.       //但是呢，唱歌有一些列的事情要准备，要找场地，音响，要卖门票等等事情，这就需要代理人来做，所以就创建一个歌手的代理人来办这些事情
  6.       ISinger proxy =(ISinger) SingerProxyFactory.getProxy(zxy);
  7.       //演唱会开始
  8.       proxy.run();
  9.     }
  11. }

cglib代理

上面的代码中有个相同点就是都要求目标对象是实现一个接口的对象,然而并不是任何对象都会实现一个接口，也存在没有实现任何的接口的对象,这时就可以使用继承目标类以目标对象子类的方式实现代理,这种方法就叫做:Cglib代理，也叫作子类代理。

cglib 依赖第三方的jar实现

实现方式
只列举关键代码

  1.     //实例化一个增强器，也就是cglib中的一个class generator
  2.     Enhancer enhancer = new Enhancer();
  3.     //设置目标类
  4.     enhancer.setSuperclass(XXX.class);
  5.     //设置拦截对象，这里直接使用匿名内部类写法
  6.     enhancer.setCallback(new MethodInterceptor() {
  7.         @Override
  8.         public Object intercept(Object object , Method method, Object[] args, MethodProxy proxy) throws Throwable {
  9.             //todo 要做的前置处理
  11.             //使用proxy的invokeSuper方法来调用目标类的方法
  12.             proxy.invokeSuper(object, args);
  13.             // todo 要做的后置处理
  14.             return null;
  15.         }
  17.     });
  20.  //然后调用时,用enhancer 创建出代理目标对象
  22.  XXX xxx = (XXX) enhancer.create();
  23.  xxx.run();