搞懂设计模式——代理模式 + 原理分析

作者：京东零售 秦浩然

引子

举个栗子，众所周知，我们是可以在京东上购买机票的。 但机票是航司提供的，我们本质上是代理销售而已。

那为什么航司要让我们代理销售呢？

我们又是如帮他做代理的呢？

别急，本文将展开说说他们之间的关系。。。

一个有梦想的航司

从前有个航司打算开展线上销售机票业务，于是设计了如下系统。系统完成后，业务正常开展了。。。

航司销售机票的接口：

1public interface SellAirTicket {
2
3    /**
4     * 销售机票
5     * @param price
6     */
7    void sellAirTicket(int price);
8}

航司销售机票的接口实现类：

1public class SellAirTicketImpl implements SellAirTicket {
2
3    @Override
4    public void sellAirTicket(int price) {
5        System.out.println("航司销售机票，价格：" + price);
6    }
7}

测试：

1public class MainClass {
2
3    public static void main(String[] args) {
4        SellAirTicket sellAirTicket = new SellAirTicketImpl();
5        sellAirTicket.sellAirTicket(666);
6    }
7}

测试结果：

航司销售机票，价格：666

业务蒸蒸日上，问题接踵而至

随着业务发展的越来越好，新的问题出现了。

黄牛天天爬接口，系统风险出现了；卖完票没有统计结果，卖成啥样也不知道。

于是航司想增加售前风控、售后统计。加上这些功能后，业务又继续稳步发展了。。。

航司销售机票的接口：

1public interface SellAirTicket {
2
3    /**
4     * 销售机票
5     * @param price
6     */
7    void sellAirTicket(int price);
8}

航司销售机票的接口实现类：

1public class SellAirTicketImpl implements SellAirTicket {
2
3    @Override
4    public void sellAirTicket(int price) {
5        System.out.println("航司售前风控。。。");
6        System.out.println("航司销售机票，价格：" + price);
7        System.out.println("航司售后统计。。。");
8    }
9}

测试：

1public class MainClass {
2
3    public static void main(String[] args) {
4        SellAirTicket sellAirTicket = new SellAirTicketImpl();
5        sellAirTicket.sellAirTicket(666);
6    }
7}

测试结果：

1航司售前风控。。。
2航司销售机票，价格：666
3航司售后统计。。。   

人员捉襟见肘，业务被迫拆分

后来航司发现，就这么点人，又想做风控，又想卖机票，又想做统计，根本忙不过来。

那怎么解决呢？ 航司只想专心卖票，不想做这些跟卖票无关的工作，那只能找个代理公司了。

于是，航司找到了JD代替自己做这些工作，自己就负责专心卖票。。。

航司销售机票的接口：

1public interface SellAirTicket {
2
3    /**
4     * 销售机票
5     * @param price
6     */
7    void sellAirTicket(int price);
8}

航司销售机票的接口实现类：

1public class SellAirTicketImpl implements SellAirTicket {
2
3    @Override
4    public void sellAirTicket(int price) {
5        System.out.println("航司销售机票，价格：" + price);
6    }
7}

JD平台代理航司销售机票实现类：

1public class SellAirTicketProxy implements SellAirTicket {
2
3    /**
4     * 航司售票接口
5     */
6    private SellAirTicket sellAirTicket;
7
8    @Override
9    public void sellAirTicket(int price) {
10        System.out.println("JD售前风控。。。");
11        sellAirTicket.sellAirTicket(price);
12        System.out.println("JD售后统计。。。");
13    }
14
15    public SellAirTicketProxy(SellAirTicket sellAirTicket) {
16        this.sellAirTicket = sellAirTicket;
17    }
18}

测试：

1public class MainClass {
2
3    public static void main(String[] args) {
4        SellAirTicket sellAirTicket = new SellAirTicketImpl();
5        SellAirTicket sellAirTicketProxy = new SellAirTicketProxy(sellAirTicket);
6        sellAirTicketProxy.sellAirTicket(666);
7    }
8}

测试结果：

1JD售前风控。。。
2航司销售机票，价格：666
3JD售后统计。。。

朴素的一对一合作方式，静态代理

以上流程对与航司而言，由JD帮助自己关注风控、统计，自已可以专心的卖票，看着很好的样子。

但是JD平台只能给航司卖票，其余的也干不了，航司与JD的关系属于静态绑定的关系，即：被代理类与代理类属于静态绑定的关系，称之为“静态代理”。

据此，我们可以给代理模式下个定义：

1【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式 
2
3代理模式的优点：
41. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
52. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
63. 对于用户（调用者）而言，使用的方式没有区别，有和可以做到低成本替换；
7
8代理模式的缺点：
91. 每个被代理类都要有一个代理类，大大增加了代码量；

保险出现，代理公司高瞻远瞩

某天，保险公司也被风控、统计逻辑搞的焦头烂额，听说航司找了个代理，于是也找到了JD，让JD给他们做代理。

JD想：总不能谁来找我，我就给谁做一套代理系统吧，那我得做多少套，反正他们都是找我做风控、统计的，那我能不能做一套系统，给他们所有的人用呢，说干就干。。。

保险公司销售保险的接口：

1public interface SellInsurance {
2
3    /**
4     * 销售保险
5     * @param price
6     */
7    void sellInsurance(int price);
8}

保险公司销售保险的接口实现类：

1public class SellInsuranceImpl implements SellInsurance {
2
3    @Override
4    public void sellInsurance(int price) {
5        System.out.println("保险公司销售保险，价格：" + price);
6    }
7}

JD平台代理的风控、统计实现类：

1public class SellDynamicProxy {
2
3    /**
4     * 获取传入目标对象的代理对象
5     * @param target
6     * @return
7     */
8    public Object createProxy(Object target) {
9        return Proxy.newProxyInstance(
10                target.getClass().getClassLoader(), //目标对象使用类加载器
11                target.getClass().getInterfaces(),  //目标对象实现的接口的类型
12                new DynamicProxyHandler(target));   //目标对象事件处理器
13    }
14
15    /**
16     * 目标对象的事件处理器
17     */
18    private class DynamicProxyHandler implements InvocationHandler {
19
20        //被代理对象
21        private Object target;
22
23        @Override
24        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
25            System.out.println("JD售前风控。。。");
26            method.invoke(target, args);
27            System.out.println("JD售后统计。。。");
28            return null;
29        }
30
31        public DynamicProxyHandler(Object object) {
32            this.target = object;
33        }
34    }
35}

测试：

1public class MainClass {
2
3    public static void main(String[] args) {
4        //创建动态代理平台
5        SellDynamicProxy dynamicProxy = new SellDynamicProxy();
6        //代理销售机票
7        SellAirTicket airTicketProxy = (SellAirTicket) dynamicProxy.createProxy(new SellAirTicketImpl());
8        airTicketProxy.sellAirTicket(600);
9        //代理销售保险
10        SellInsurance insuranceProxy = (SellInsurance) dynamicProxy.createProxy(new SellInsuranceImpl());
11        insuranceProxy.sellInsurance(30);
12    }
13}

测试结果：

1JD售前风控。。。
2航司销售机票，价格：600
3JD售后统计。。。
4JD售前风控。。。
5保险公司销售保险，价格：30
6JD售后统计。。。

进阶的一对多合作方式，动态代理

到这里航司、保险公司都找到了自己的代理，JD平台也完成了风控、统计代理平台的搭建。再有人来找自己，JD平台都可以满足代理需求，现在看来，已经很完美了。

被代理的商家与JD属于动态绑定的关系，即：被代理类与代理类属于动态绑定的关系，称之为“动态代理”，由于此代理功能依赖JDK提供的Proxy、InvocationHandler类，也成为“JDK动态代理”。

据此，我们可以补充代理模式的定义：

1【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式 
2
3代理模式的优点：
41. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
52. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
63. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；
74. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；
8
9代理模式的缺点：
101. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；
112. JDK动态代理基于JDK的反射原理实现，降低了执行效率；  

酒店出现，代理公司意外降临

平静的日子没过多久，一天某酒店找来了，要求给他们做代理，做就做呗。轻车又熟路。。。

酒店销售房间：

1public class SellHotel {
2
3    /**
4     * 销售酒店
5     * @param price
6     */
7    public void sellHotel(int price) {
8        System.out.println("酒店销售房间，价格：" + price);
9    }
10}  

测试：

1public class MainClass {
2
3    public static void main(String[] args) {
4        //创建动态代理平台
5        SellDynamicProxy dynamicProxy = new SellDynamicProxy();
6        //代理销售酒店
7        SellHotel sellHotel = (SellHotel) dynamicProxy.createProxy(new SellHotel());
8        sellHotel.sellHotel(300);
9    }
10}  

测试结果：

1Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be 
2cast to demo.pattern.proxy.SellHotel at demo.pattern.proxy.MainClass.main(MainClass.java:14)

怎么回事，平台不好用了！代理公司闭关修炼，查一下问题。。。

优秀代理公司的自我修养

以前给别人代理都好使，这次给酒店代理为何就不行了呢？ 一个优秀的代理，有问题就要解决问题。。。

先看异常，代理类不能被强转为目标类型，但是为何之前的都好使？

思考：只有生成的代理类属于目标类型，才能强转，那就需要代理类实现目标类的接口，那问题就可能是这样了，验证一下。

原理分析：JDK代理对象是如何实现的？

让我们先看下源码：

1/**
2 * 获取传入目标对象的代理对象
3 * @param target
4 * @return
5 */
6public Object createProxy(Object target) {
7    return Proxy.newProxyInstance(
8            target.getClass().getClassLoader(), //目标对象使用类加载器
9            target.getClass().getInterfaces(),  //目标对象实现的接口的类型
10            new DynamicProxyHandler(target));   //目标对象事件处理器
11}
12
13
14/**
15 * 创建代理类源码
16 */
17public static Object newProxyInstance(ClassLoader loader,
18                                      Class<?>[] interfaces,
19                                      InvocationHandler h)
20    throws IllegalArgumentException
21{
22    Objects.requireNonNull(h);
23
24    final Class<?>[] intfs = interfaces.clone();
25    final SecurityManager sm = System.getSecurityManager();
26    if (sm != null) {
27        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
28    }
29
30    /*
31     * Look up or generate the designated proxy class.
32     */
33    Class<?> cl = getProxyClass0(loader, intfs);  //生成代理类的字节码对象
34
35    /*
36     * Invoke its constructor with the designated invocation handler.
37     */
38    try {
39        if (sm != null) {
40            checkNewProxyPermission(Reflection.getCallerClass(), cl);
41        }
42
43        final Constructor<?> cons = cl.getConstructor(constructorParams);   //获取参数为事件处理器的构造器
44        final InvocationHandler ih = h;
45        if (!Modifier.isPublic(cl.getModifiers())) {
46            AccessController.doPrivileged(new PrivilegedAction<Void>() {
47                public Void run() {
48                    cons.setAccessible(true);
49                    return null;
50                }
51            });
52        }
53        return cons.newInstance(new Object[]{h});   //用词构造器，传入的事件处理器，构造代理类
54    } catch (IllegalAccessException|InstantiationException e) {
55        throw new InternalError(e.toString(), e);
56    } catch (InvocationTargetException e) {
57        Throwable t = e.getCause();
58        if (t instanceof RuntimeException) {
59            throw (RuntimeException) t;
60        } else {
61            throw new InternalError(t.toString(), t);
62        }
63    } catch (NoSuchMethodException e) {
64        throw new InternalError(e.toString(), e);
65    }
66}
67
68
69/**
70 * Generate a proxy class.  Must call the checkProxyAccess method
71 * to perform permission checks before calling this.
72 * 生成代理类的字节码对象
73 */
74private static Class<?> getProxyClass0(ClassLoader loader,
75                                       Class<?>... interfaces) {
76    if (interfaces.length > 65535) {
77        throw new IllegalArgumentException("interface limit exceeded");
78    }
79
80    // If the proxy class defined by the given loader implementing
81    // the given interfaces exists, this will simply return the cached copy;
82    // otherwise, it will create the proxy class via the ProxyClassFactory
83    return proxyClassCache.get(loader, interfaces);     //这里获取字节码对象
84}
85
86/**
87 * 这里获取字节码对象
88 */
89public V get(K key, P parameter) {
90    Objects.requireNonNull(parameter);
91
92    expungeStaleEntries();
93
94    Object cacheKey = CacheKey.valueOf(key, refQueue);
95
96    // lazily install the 2nd level valuesMap for the particular cacheKey
97    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
98    if (valuesMap == null) {
99        ConcurrentMap<Object, Supplier<V>> oldValuesMap
100            = map.putIfAbsent(cacheKey,
101                              valuesMap = new ConcurrentHashMap<>());
102        if (oldValuesMap != null) {
103            valuesMap = oldValuesMap;
104        }
105    }
106
107    // create subKey and retrieve the possible Supplier<V> stored by that
108    // subKey from valuesMap
109    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));    //这里创建字解码对象
110    Supplier<V> supplier = valuesMap.get(subKey);
111    Factory factory = null;
112
113    while (true) {
114        if (supplier != null) {
115            // supplier might be a Factory or a CacheValue<V> instance
116            V value = supplier.get();
117            if (value != null) {
118                return value;
119            }
120        }
121        // else no supplier in cache
122        // or a supplier that returned null (could be a cleared CacheValue
123        // or a Factory that wasn't successful in installing the CacheValue)
124
125        // lazily construct a Factory
126        if (factory == null) {
127            factory = new Factory(key, parameter, subKey, valuesMap);
128        }
129
130        if (supplier == null) {
131            supplier = valuesMap.putIfAbsent(subKey, factory);
132            if (supplier == null) {
133                // successfully installed Factory
134                supplier = factory;
135            }
136            // else retry with winning supplier
137        } else {
138            if (valuesMap.replace(subKey, supplier, factory)) {
139                // successfully replaced
140                // cleared CacheEntry / unsuccessful Factory
141                // with our Factory
142                supplier = factory;
143            } else {
144                // retry with current supplier
145                supplier = valuesMap.get(subKey);
146            }
147        }
148    }
149}
150
151
152/**
153 * A factory function that generates, defines and returns the proxy class given
154 * the ClassLoader and array of interfaces.
155 * 
156 * Proxy类的内部类，就是为了创建代理对象的字节码对象
157 */
158private static final class ProxyClassFactory
159    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
160{
161    // prefix for all proxy class names
162    private static final String proxyClassNamePrefix = "$Proxy";
163
164    // next number to use for generation of unique proxy class names
165    private static final AtomicLong nextUniqueNumber = new AtomicLong();
166
167    @Override
168    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
169
170        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
171        for (Class<?> intf : interfaces) {
172            /*
173             * Verify that the class loader resolves the name of this
174             * interface to the same Class object.
175             */
176            Class<?> interfaceClass = null;
177            try {
178                interfaceClass = Class.forName(intf.getName(), false, loader);
179            } catch (ClassNotFoundException e) {
180            }
181            if (interfaceClass != intf) {
182                throw new IllegalArgumentException(
183                    intf + " is not visible from class loader");
184            }
185            /*
186             * Verify that the Class object actually represents an
187             * interface.
188             */
189            if (!interfaceClass.isInterface()) {
190                throw new IllegalArgumentException(
191                    interfaceClass.getName() + " is not an interface");
192            }
193            /*
194             * Verify that this interface is not a duplicate.
195             */
196            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
197                throw new IllegalArgumentException(
198                    "repeated interface: " + interfaceClass.getName());
199            }
200        }
201
202        String proxyPkg = null;     // package to define proxy class in
203        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
204
205        /*
206         * Record the package of a non-public proxy interface so that the
207         * proxy class will be defined in the same package.  Verify that
208         * all non-public proxy interfaces are in the same package.
209         */
210        for (Class<?> intf : interfaces) {
211            int flags = intf.getModifiers();
212            if (!Modifier.isPublic(flags)) {
213                accessFlags = Modifier.FINAL;
214                String name = intf.getName();
215                int n = name.lastIndexOf('.');
216                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
217                if (proxyPkg == null) {
218                    proxyPkg = pkg;
219                } else if (!pkg.equals(proxyPkg)) {
220                    throw new IllegalArgumentException(
221                        "non-public interfaces from different packages");
222                }
223            }
224        }
225
226        if (proxyPkg == null) {
227            // if no non-public proxy interfaces, use com.sun.proxy package
228            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
229        }
230
231        /*
232         * Choose a name for the proxy class to generate.
233         */
234        long num = nextUniqueNumber.getAndIncrement();
235        String proxyName = proxyPkg + proxyClassNamePrefix + num;
236
237        /*
238         * Generate the specified proxy class.
239         */
240        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  //这里生成需要的字节码对象
241            proxyName, interfaces, accessFlags);
242        try {
243            return defineClass0(loader, proxyName,
244                                proxyClassFile, 0, proxyClassFile.length);
245        } catch (ClassFormatError e) {
246            /*
247             * A ClassFormatError here means that (barring bugs in the
248             * proxy class generation code) there was some other
249             * invalid aspect of the arguments supplied to the proxy
250             * class creation (such as virtual machine limitations
251             * exceeded).
252             */
253            throw new IllegalArgumentException(e.toString());
254        }
255    }
256}

上面分析一堆，那我们来了看看得到的代理类到底是啥，为啥他就能执行那个我们的目标类的方法。同时，还得目标类实现接口？

1/**
2 * 我们自己生成一份目标类字节码文件
3 * @throws IOException
4 */
5public static void transClass() throws IOException {
6    SellAirTicketImpl sellAirTicket = new SellAirTicketImpl();
7    byte[] bts = ProxyGenerator.generateProxyClass("$Proxy0", sellAirTicket.getClass().getInterfaces());
8    File file = new File("E:\test","$Proxy0.class");
9    if (!file.exists()){
10        file.createNewFile();
11    }
12    FileOutputStream fos = new FileOutputStream(file);
13    fos.write(bts);
14    fos.flush();
15    fos.close();
16}

将我们的字节码文件在此反编译：**http://javare.cn**，得到我们的代理类：

1import demo.pattern.proxy.SellAirTicket;
2import java.lang.reflect.InvocationHandler;
3import java.lang.reflect.Method;
4import java.lang.reflect.Proxy;
5import java.lang.reflect.UndeclaredThrowableException;
6
7public final class $Proxy0 extends Proxy implements SellAirTicket {
8
9   private static Method m1;
10   private static Method m2;
11   private static Method m3;
12   private static Method m0;
13
14
15   public $Proxy0(InvocationHandler var1) throws  {     //代理类的构造器，将事件处理器传入，交给父类Proxy
16      super(var1);
17   }
18
19   public final boolean equals(Object var1) throws  {
20      try {
21         return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
22      } catch (RuntimeException | Error var3) {
23         throw var3;
24      } catch (Throwable var4) {
25         throw new UndeclaredThrowableException(var4);
26      }
27   }
28
29   public final String toString() throws  {
30      try {
31         return (String)super.h.invoke(this, m2, (Object[])null);
32      } catch (RuntimeException | Error var2) {
33         throw var2;
34      } catch (Throwable var3) {
35         throw new UndeclaredThrowableException(var3);
36      }
37   }
38
39   public final void sellAirTicket(int var1) throws  {
40      try {
41         super.h.invoke(this, m3, new Object[]{Integer.valueOf(var1)});     //执行目标方法时，调用父类的事件处理器
42      } catch (RuntimeException | Error var3) {
43         throw var3;
44      } catch (Throwable var4) {
45         throw new UndeclaredThrowableException(var4);
46      }
47   }
48
49   public final int hashCode() throws  {
50      try {
51         return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
52      } catch (RuntimeException | Error var2) {
53         throw var2;
54      } catch (Throwable var3) {
55         throw new UndeclaredThrowableException(var3);
56      }
57   }
58
59   static {
60      try {
61         m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
62         m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
63         m3 = Class.forName("demo.pattern.proxy.SellAirTicket").getMethod("sellAirTicket", new Class[]{Integer.TYPE});  //获取接口类型的目标方法
64         m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
65      } catch (NoSuchMethodException var2) {
66         throw new NoSuchMethodError(var2.getMessage());
67      } catch (ClassNotFoundException var3) {
68         throw new NoClassDefFoundError(var3.getMessage());
69      }
70   }
71}

到此为止真相大白了，原来代理类继承了Proxy父类，同时实现了目标类的接口，这就将我们的目标方法与定义的事件处理器联系起来了。

同时，由于java的单继承模式，导致了代理类只能继承Proxy类，那这样的话，就只好通过目标类的接口来关联目标类了。

小结：JDK动态代理

据此，我们可以再次补充代理模式的定义：

1【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式 
2
3代理模式的优点：
41. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
52. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
63. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；
74. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；
8
9代理模式的缺点：
101. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；
112. JDK动态代理基于JDK的反射原理实现，降低了执行效率；  
123. JDK动态代理是基于接口的代理，要求目标类必须实现目标接口；

好的合作伙伴就是不抛弃不放弃

到这里，问题是搞明白了，就是酒店的问题，但是好的合作伙伴就是应该不抛弃，不放弃。

酒店跟我们合作，我们就要帮助他们解决困难。那怎么办呢？酒店没接口，JDK代理又非要接口，那我们就不用JDK代理了！

这时，基于类的代理方式就应运而生了—— cglib为我们提供了基于类的动态代理模式。

导Jar包：cglib-3.2.5.jar（cglib核心包）、asm-3.3.1.jar（字节码处理框架）

1public class CglibDynamicProxy implements MethodInterceptor {
2
3    //目标对象
4    private Object target;
5
6    /**
7     *给目标对象创建一个代理对象
8     */
9    public Object getProxyInstance(){
10        //工具类
11        Enhancer en = new Enhancer();
12        //设置父类
13        en.setSuperclass(target.getClass());
14        //设置回调函数
15        en.setCallback(this);
16        //创建子类代理对象
17        return en.create();
18    }
19
20
21    @Override
22    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
23        System.out.println("cglib售前风控。。。");
24        final Object invoke = method.invoke(target, objects);
25        System.out.println("cglib售后统计。。。");
26        return invoke;
27    }
28
29    public CglibDynamicProxy(Object target) {
30        this.target = target;
31    }
32}

测试

1    public static void main(String[] args) {
2        //创建销售酒店代理
3        CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(new SellHotel());
4        SellHotel sellHotel = (SellHotel) cglibDynamicProxy.getProxyInstance();
5        sellHotel.sellHotel(300);
6    }

测试结果

1    cglib售前风控。。。
2    酒店销售房间，价格：300
3    cglib售后统计。。。

原理分析：cglib代理对象是如何实现的？

那为啥cglib就不用目标类实现接口了呢？让我们看看代理类。

1public static void main(String[] args) {
2    //代理类class文件存入本地磁盘
3    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:\testCglib");
4    //创建销售酒店代理
5    CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(new SellHotel());
6    SellHotel sellHotel = (SellHotel) cglibDynamicProxy.getProxyInstance();
7    sellHotel.sellHotel(300);
8}

反编译结果

1/**
2 * 代理类反编译结果
3 */
4public class SellHotel$$EnhancerByCGLIB$$2624d6e3 extends SellHotel implements Factory {
5
6   private boolean CGLIB$BOUND;
7   public static Object CGLIB$FACTORY_DATA;
8   private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
9   private static final Callback[] CGLIB$STATIC_CALLBACKS;
10   private MethodInterceptor CGLIB$CALLBACK_0;      //方法拦截器
11   private static final Method CGLIB$sellHotel$0$Method;    //被代理方法
12   private static final MethodProxy CGLIB$sellHotel$0$Proxy;    //代理方法
13   private static final Object[] CGLIB$emptyArgs;
14   private static final Method CGLIB$equals$1$Method;
15   private static final MethodProxy CGLIB$equals$1$Proxy;
16   private static final Method CGLIB$toString$2$Method;
17   private static final MethodProxy CGLIB$toString$2$Proxy;
18   private static final Method CGLIB$hashCode$3$Method;
19   private static final MethodProxy CGLIB$hashCode$3$Proxy;
20   private static final Method CGLIB$clone$4$Method;
21   private static final MethodProxy CGLIB$clone$4$Proxy;
22
23
24   static void CGLIB$STATICHOOK1() {
25      CGLIB$THREAD_CALLBACKS = new ThreadLocal();
26      CGLIB$emptyArgs = new Object[0];
27      Class var0 = Class.forName("demo.pattern.proxy.SellHotel$$EnhancerByCGLIB$$2624d6e3");    //代理类
28      Class var1;   //被代理类
29      CGLIB$sellHotel$0$Method = ReflectUtils.findMethods(new String[]{"sellHotel", "(I)V"}, (var1 = Class.forName("demo.pattern.proxy.SellHotel")).getDeclaredMethods())[0];
30      CGLIB$sellHotel$0$Proxy = MethodProxy.create(var1, var0, "(I)V", "sellHotel", "CGLIB$sellHotel$0");
31      Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
32      CGLIB$equals$1$Method = var10000[0];
33      CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
34      CGLIB$toString$2$Method = var10000[1];
35      CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
36      CGLIB$hashCode$3$Method = var10000[2];
37      CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
38      CGLIB$clone$4$Method = var10000[3];
39      CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
40   }
41
42   final void CGLIB$sellHotel$0(int var1) {
43      super.sellHotel(var1);
44   }
45
46   public final void sellHotel(int var1) {  //代理类重写的方法
47      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;       //方法拦截器
48      if(this.CGLIB$CALLBACK_0 == null) {
49         CGLIB$BIND_CALLBACKS(this);
50         var10000 = this.CGLIB$CALLBACK_0;
51      }
52
53      if(var10000 != null) {    //执行方法拦截器
54         var10000.intercept(this, CGLIB$sellHotel$0$Method, new Object[]{new Integer(var1)}, CGLIB$sellHotel$0$Proxy);
55      } else {
56         super.sellHotel(var1);
57      }
58   }
59
60   final boolean CGLIB$equals$1(Object var1) {
61      return super.equals(var1);
62   }
63
64   public final boolean equals(Object var1) {
65      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
66      if(this.CGLIB$CALLBACK_0 == null) {
67         CGLIB$BIND_CALLBACKS(this);
68         var10000 = this.CGLIB$CALLBACK_0;
69      }
70
71      if(var10000 != null) {
72         Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
73         return var2 == null?false:((Boolean)var2).booleanValue();
74      } else {
75         return super.equals(var1);
76      }
77   }
78
79   final String CGLIB$toString$2() {
80      return super.toString();
81   }
82
83   public final String toString() {
84      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
85      if(this.CGLIB$CALLBACK_0 == null) {
86         CGLIB$BIND_CALLBACKS(this);
87         var10000 = this.CGLIB$CALLBACK_0;
88      }
89
90      return var10000 != null?(String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy):super.toString();
91   }
92
93   final int CGLIB$hashCode$3() {
94      return super.hashCode();
95   }
96
97   public final int hashCode() {
98      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
99      if(this.CGLIB$CALLBACK_0 == null) {
100         CGLIB$BIND_CALLBACKS(this);
101         var10000 = this.CGLIB$CALLBACK_0;
102      }
103
104      if(var10000 != null) {
105         Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
106         return var1 == null?0:((Number)var1).intValue();
107      } else {
108         return super.hashCode();
109      }
110   }
111
112   final Object CGLIB$clone$4() throws CloneNotSupportedException {
113      return super.clone();
114   }
115
116   protected final Object clone() throws CloneNotSupportedException {
117      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
118      if(this.CGLIB$CALLBACK_0 == null) {
119         CGLIB$BIND_CALLBACKS(this);
120         var10000 = this.CGLIB$CALLBACK_0;
121      }
122
123      return var10000 != null?var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy):super.clone();
124   }
125
126   public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
127      String var10000 = var0.toString();
128      switch(var10000.hashCode()) {
129      case -508378822:
130         if(var10000.equals("clone()Ljava/lang/Object;")) {
131            return CGLIB$clone$4$Proxy;
132         }
133         break;
134      case 1826985398:
135         if(var10000.equals("equals(Ljava/lang/Object;)Z")) {
136            return CGLIB$equals$1$Proxy;
137         }
138         break;
139      case 1913648695:
140         if(var10000.equals("toString()Ljava/lang/String;")) {
141            return CGLIB$toString$2$Proxy;
142         }
143         break;
144      case 1979480752:
145         if(var10000.equals("sellHotel(I)V")) {
146            return CGLIB$sellHotel$0$Proxy;
147         }
148         break;
149      case 1984935277:
150         if(var10000.equals("hashCode()I")) {
151            return CGLIB$hashCode$3$Proxy;
152         }
153      }
154
155      return null;
156   }
157
158   public SellHotel$$EnhancerByCGLIB$$2624d6e3() {
159      CGLIB$BIND_CALLBACKS(this);
160   }
161
162   public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
163      CGLIB$THREAD_CALLBACKS.set(var0);
164   }
165
166   public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
167      CGLIB$STATIC_CALLBACKS = var0;
168   }
169
170   private static final void CGLIB$BIND_CALLBACKS(Object var0) {
171      SellHotel$$EnhancerByCGLIB$$2624d6e3 var1 = (SellHotel$$EnhancerByCGLIB$$2624d6e3)var0;
172      if(!var1.CGLIB$BOUND) {
173         var1.CGLIB$BOUND = true;
174         Object var10000 = CGLIB$THREAD_CALLBACKS.get();
175         if(var10000 == null) {
176            var10000 = CGLIB$STATIC_CALLBACKS;
177            if(CGLIB$STATIC_CALLBACKS == null) {
178               return;
179            }
180         }
181
182         var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
183      }
184
185   }
186
187   public Object newInstance(Callback[] var1) {
188      CGLIB$SET_THREAD_CALLBACKS(var1);
189      SellHotel$$EnhancerByCGLIB$$2624d6e3 var10000 = new SellHotel$$EnhancerByCGLIB$$2624d6e3();
190      CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
191      return var10000;
192   }
193
194   public Object newInstance(Callback var1) {
195      CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
196      SellHotel$$EnhancerByCGLIB$$2624d6e3 var10000 = new SellHotel$$EnhancerByCGLIB$$2624d6e3();
197      CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
198      return var10000;
199   }
200
201   public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
202      CGLIB$SET_THREAD_CALLBACKS(var3);
203      SellHotel$$EnhancerByCGLIB$$2624d6e3 var10000 = new SellHotel$$EnhancerByCGLIB$$2624d6e3;
204      switch(var1.length) {
205      case 0:
206         var10000.<init>();
207         CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
208         return var10000;
209      default:
210         throw new IllegalArgumentException("Constructor not found");
211      }
212   }
213
214   public Callback getCallback(int var1) {
215      CGLIB$BIND_CALLBACKS(this);
216      MethodInterceptor var10000;
217      switch(var1) {
218      case 0:
219         var10000 = this.CGLIB$CALLBACK_0;
220         break;
221      default:
222         var10000 = null;
223      }
224
225      return var10000;
226   }
227
228   public void setCallback(int var1, Callback var2) {
229      switch(var1) {
230      case 0:
231         this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
232      default:
233      }
234   }
235
236   public Callback[] getCallbacks() {
237      CGLIB$BIND_CALLBACKS(this);
238      return new Callback[]{this.CGLIB$CALLBACK_0};
239   }
240
241   public void setCallbacks(Callback[] var1) {
242      this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
243   }
244
245   static {
246      CGLIB$STATICHOOK1();
247   }
248}

到此，我们知道cglib代理是帮我们新建了一个代理类，此代理类继承自目标类获取目标方法，同时重写了目标方法。

再通过我们定义的拦截器调用我们的目标方法，以此来达到代理目标方法的目的。

总结：JDK、cglib动态代理

据此，我们可以总结代理模式的定义：

1【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式。 
2
3代理模式的优点：
41. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
52. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
63. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；
74. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；
85. cglib动态代理可基于实现类做代理，可以解决JDK代理依赖接口的问题；
9
10代理模式的缺点：
111. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；
122. JDK动态代理基于JDK的反射原理实现，降低了执行效率；  
133. JDK动态代理是基于接口的代理，要求目标类必须实现目标接口；
14
15代理模式分类：
161. 静态代理；
172. JDK动态代理（基于目标类的接口生成代理类做代理）；
183. cglib动态代理（基于目标类生成子类做代理，同时也支持基于接口的代理）；

代理模式的使用场景

我们知道，Spring的AOP就是依赖于动态代理模式实现的，那我们在日常的开发中有哪些地方能用到代理呢？

•事物

•日志

•监控

•统计

•鉴权

•限流

•缓存

•环境隔离