关键词：
作者：京东零售 秦浩然
引子
举个栗子，众所周知，我们是可以在京东上购买机票的。 但机票是航司提供的，我们本质上是代理销售而已。
那为什么航司要让我们代理销售呢？
我们又是如帮他做代理的呢？
别急，本文将展开说说他们之间的关系。。。
一个有梦想的航司
从前有个航司打算开展线上销售机票业务，于是设计了如下系统。系统完成后，业务正常开展了。。。
航司销售机票的接口：
public interface SellAirTicket
/**
* 销售机票
* @param price
*/
void sellAirTicket(int price);
航司销售机票的接口实现类：
public class SellAirTicketImpl implements SellAirTicket
@Override
public void sellAirTicket(int price)
System.out.println("航司销售机票，价格：" + price);
测试：
public class MainClass
public static void main(String[] args)
SellAirTicket sellAirTicket = new SellAirTicketImpl();
sellAirTicket.sellAirTicket(666);
测试结果：
航司销售机票，价格：666
业务蒸蒸日上，问题接踵而至
随着业务发展的越来越好，新的问题出现了。
黄牛天天爬接口，系统风险出现了；卖完票没有统计结果，卖成啥样也不知道。
于是航司想增加售前风控、售后统计。加上这些功能后，业务又继续稳步发展了。。。
航司销售机票的接口：
public interface SellAirTicket
/**
* 销售机票
* @param price
*/
void sellAirTicket(int price);
航司销售机票的接口实现类：
public class SellAirTicketImpl implements SellAirTicket
@Override
public void sellAirTicket(int price)
System.out.println("航司售前风控。。。");
System.out.println("航司销售机票，价格：" + price);
System.out.println("航司售后统计。。。");
测试：
public class MainClass
public static void main(String[] args)
SellAirTicket sellAirTicket = new SellAirTicketImpl();
sellAirTicket.sellAirTicket(666);
测试结果：
航司售前风控。。。
航司销售机票，价格：666
航司售后统计。。。
人员捉襟见肘，业务被迫拆分
后来航司发现，就这么点人，又想做风控，又想卖机票，又想做统计，根本忙不过来。
那怎么解决呢？ 航司只想专心卖票，不想做这些跟卖票无关的工作，那只能找个代理公司了。
于是，航司找到了JD代替自己做这些工作，自己就负责专心卖票。。。
航司销售机票的接口：
public interface SellAirTicket
/**
* 销售机票
* @param price
*/
void sellAirTicket(int price);
航司销售机票的接口实现类：
public class SellAirTicketImpl implements SellAirTicket
@Override
public void sellAirTicket(int price)
System.out.println("航司销售机票，价格：" + price);
JD平台代理航司销售机票实现类：
public class SellAirTicketProxy implements SellAirTicket
/**
* 航司售票接口
*/
private SellAirTicket sellAirTicket;
@Override
public void sellAirTicket(int price)
System.out.println("JD售前风控。。。");
sellAirTicket.sellAirTicket(price);
System.out.println("JD售后统计。。。");
public SellAirTicketProxy(SellAirTicket sellAirTicket)
this.sellAirTicket = sellAirTicket;
测试：
public class MainClass
public static void main(String[] args)
SellAirTicket sellAirTicket = new SellAirTicketImpl();
SellAirTicket sellAirTicketProxy = new SellAirTicketProxy(sellAirTicket);
sellAirTicketProxy.sellAirTicket(666);
测试结果：
JD售前风控。。。
航司销售机票，价格：666
JD售后统计。。。
朴素的一对一合作方式，静态代理
以上流程对与航司而言，由JD帮助自己关注风控、统计，自已可以专心的卖票，看着很好的样子。
但是JD平台只能给航司卖票，其余的也干不了，航司与JD的关系属于静态绑定的关系，即：被代理类与代理类属于静态绑定的关系，称之为“静态代理”。
据此，我们可以给代理模式下个定义：
【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式
代理模式的优点：
1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
3. 对于用户（调用者）而言，使用的方式没有区别，有和可以做到低成本替换；
代理模式的缺点：
1. 每个被代理类都要有一个代理类，大大增加了代码量；
保险出现，代理公司高瞻远瞩
某天，保险公司也被风控、统计逻辑搞的焦头烂额，听说航司找了个代理，于是也找到了JD，让JD给他们做代理。
JD想：总不能谁来找我，我就给谁做一套代理系统吧，那我得做多少套，反正他们都是找我做风控、统计的，那我能不能做一套系统，给他们所有的人用呢，说干就干。。。
保险公司销售保险的接口：
public interface SellInsurance
/**
* 销售保险
* @param price
*/
void sellInsurance(int price);
保险公司销售保险的接口实现类：
public class SellInsuranceImpl implements SellInsurance
@Override
public void sellInsurance(int price)
System.out.println("保险公司销售保险，价格：" + price);
JD平台代理的风控、统计实现类：
public class SellDynamicProxy
/**
* 获取传入目标对象的代理对象
* @param target
* @return
*/
public Object createProxy(Object target)
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), //目标对象使用类加载器
target.getClass().getInterfaces(), //目标对象实现的接口的类型
new DynamicProxyHandler(target)); //目标对象事件处理器
/**
* 目标对象的事件处理器
*/
private class DynamicProxyHandler implements InvocationHandler
//被代理对象
private Object target;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
System.out.println("JD售前风控。。。");
method.invoke(target, args);
System.out.println("JD售后统计。。。");
return null;
public DynamicProxyHandler(Object object)
this.target = object;
测试：
public class MainClass
public static void main(String[] args)
//创建动态代理平台
SellDynamicProxy dynamicProxy = new SellDynamicProxy();
//代理销售机票
SellAirTicket airTicketProxy = (SellAirTicket) dynamicProxy.createProxy(new SellAirTicketImpl());
airTicketProxy.sellAirTicket(600);
//代理销售保险
SellInsurance insuranceProxy = (SellInsurance) dynamicProxy.createProxy(new SellInsuranceImpl());
insuranceProxy.sellInsurance(30);
测试结果：
JD售前风控。。。
航司销售机票，价格：600
JD售后统计。。。
JD售前风控。。。
保险公司销售保险，价格：30
JD售后统计。。。
进阶的一对多合作方式，动态代理
到这里航司、保险公司都找到了自己的代理，JD平台也完成了风控、统计代理平台的搭建。再有人来找自己，JD平台都可以满足代理需求，现在看来，已经很完美了。
被代理的商家与JD属于动态绑定的关系，即：被代理类与代理类属于动态绑定的关系，称之为“动态代理”，由于此代理功能依赖JDK提供的Proxy、InvocationHandler类，也成为“JDK动态代理”。
据此，我们可以补充代理模式的定义：
【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式
代理模式的优点：
1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
3. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；
4. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；
代理模式的缺点：
1. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；
2. JDK动态代理基于JDK的反射原理实现，降低了执行效率；
酒店出现，代理公司意外降临
平静的日子没过多久，一天某酒店找来了，要求给他们做代理，做就做呗。轻车又熟路。。。
酒店销售房间：
public class SellHotel
/**
* 销售酒店
* @param price
*/
public void sellHotel(int price)
System.out.println("酒店销售房间，价格：" + price);
测试：
public class MainClass
public static void main(String[] args)
//创建动态代理平台
SellDynamicProxy dynamicProxy = new SellDynamicProxy();
//代理销售酒店
SellHotel sellHotel = (SellHotel) dynamicProxy.createProxy(new SellHotel());
sellHotel.sellHotel(300);
测试结果：
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be
cast to demo.pattern.proxy.SellHotel at demo.pattern.proxy.MainClass.main(MainClass.java:14)
怎么回事，平台不好用了！代理公司闭关修炼，查一下问题。。。
优秀代理公司的自我修养
以前给别人代理都好使，这次给酒店代理为何就不行了呢？ 一个优秀的代理，有问题就要解决问题。。。
先看异常，代理类不能被强转为目标类型，但是为何之前的都好使？
思考：只有生成的代理类属于目标类型，才能强转，那就需要代理类实现目标类的接口，那问题就可能是这样了，验证一下。
原理分析：JDK代理对象是如何实现的？
让我们先看下源码：
/**
* 获取传入目标对象的代理对象
* @param target
* @return
*/
public Object createProxy(Object target)
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), //目标对象使用类加载器
target.getClass().getInterfaces(), //目标对象实现的接口的类型
new DynamicProxyHandler(target)); //目标对象事件处理器
/**
* 创建代理类源码
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null)
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs); //生成代理类的字节码对象
/*
* Invoke its constructor with the designated invocation handler.
*/
try
if (sm != null)
checkNewProxyPermission(Reflection.getCallerClass(), cl);
final Constructor<?> cons = cl.getConstructor(constructorParams); //获取参数为事件处理器的构造器
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers()))
AccessController.doPrivileged(new PrivilegedAction<Void>()
public Void run()
cons.setAccessible(true);
return null;
);
return cons.newInstance(new Object[]h); //用词构造器，传入的事件处理器，构造代理类
catch (IllegalAccessException|InstantiationException e)
throw new InternalError(e.toString(), e);
catch (InvocationTargetException e)
Throwable t = e.getCause();
if (t instanceof RuntimeException)
throw (RuntimeException) t;
else
throw new InternalError(t.toString(), t);
catch (NoSuchMethodException e)
throw new InternalError(e.toString(), e);
/**
* Generate a proxy class. Must call the checkProxyAccess method
* to perform permission checks before calling this.
* 生成代理类的字节码对象
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces)
if (interfaces.length > 65535)
throw new IllegalArgumentException("interface limit exceeded");
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces); //这里获取字节码对象
/**
* 这里获取字节码对象
*/
public V get(K key, P parameter)
Objects.requireNonNull(parameter);
expungeStaleEntries();
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null)
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null)
valuesMap = oldValuesMap;
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); //这里创建字解码对象
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true)
if (supplier != null)
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null)
return value;
// else no supplier in cache
// or a supplier that returned null (could be a cleared CacheValue
// or a Factory that wasnt successful in installing the CacheValue)
// lazily construct a Factory
if (factory == null)
factory = new Factory(key, parameter, subKey, valuesMap);
if (supplier == null)
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null)
// successfully installed Factory
supplier = factory;
// else retry with winning supplier
else
if (valuesMap.replace(subKey, supplier, factory))
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
else
// retry with current supplier
supplier = valuesMap.get(subKey);
/**
* A factory function that generates, defines and returns the proxy class given
* the ClassLoader and array of interfaces.
*
* Proxy类的内部类，就是为了创建代理对象的字节码对象
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces)
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces)
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
Class<?> interfaceClass = null;
try
interfaceClass = Class.forName(intf.getName(), false, loader);
catch (ClassNotFoundException e)
if (interfaceClass != intf)
throw new IllegalArgumentException(
intf + " is not visible from class loader");
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface())
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null)
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces)
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags))
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf(.);
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null)
proxyPkg = pkg;
else if (!pkg.equals(proxyPkg))
throw new IllegalArgumentException(
"non-public interfaces from different packages");
if (proxyPkg == null)
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( //这里生成需要的字节码对象
proxyName, interfaces, accessFlags);
try
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
catch (ClassFormatError e)
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
上面分析一堆，那我们来了看看得到的代理类到底是啥，为啥他就能执行那个我们的目标类的方法。同时，还得目标类实现接口？
/**
* 我们自己生成一份目标类字节码文件
* @throws IOException
*/
public static void transClass() throws IOException
SellAirTicketImpl sellAirTicket = new SellAirTicketImpl();
byte[] bts = ProxyGenerator.generateProxyClass("$Proxy0", sellAirTicket.getClass().getInterfaces());
File file = new File("E:\\test","$Proxy0.class");
if (!file.exists())
file.createNewFile();
FileOutputStream fos = new FileOutputStream(file);
fos.write(bts);
fos.flush();
fos.close();
将我们的字节码文件在此反编译：http://javare.cn，得到我们的代理类：
import demo.pattern.proxy.SellAirTicket;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements SellAirTicket
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws //代理类的构造器，将事件处理器传入，交给父类Proxy
super(var1);
public final boolean equals(Object var1) throws
try
return ((Boolean)super.h.invoke(this, m1, new Object[]var1)).booleanValue();
catch (RuntimeException | Error var3)
throw var3;
catch (Throwable var4)
throw new UndeclaredThrowableException(var4);
public final String toString() throws
try
return (String)super.h.invoke(this, m2, (Object[])null);
catch (RuntimeException | Error var2)
throw var2;
catch (Throwable var3)
throw new UndeclaredThrowableException(var3);
public final void sellAirTicket(int var1) throws
try
super.h.invoke(this, m3, new Object[]Integer.valueOf(var1)); //执行目标方法时，调用父类的事件处理器
catch (RuntimeException | Error var3)
throw var3;
catch (Throwable var4)
throw new UndeclaredThrowableException(var4);
public final int hashCode() throws
try
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
catch (RuntimeException | Error var2)
throw var2;
catch (Throwable var3)
throw new UndeclaredThrowableException(var3);
static
try
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("demo.pattern.proxy.SellAirTicket").getMethod("sellAirTicket", new Class[]Integer.TYPE); //获取接口类型的目标方法
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
catch (NoSuchMethodException var2)
throw new NoSuchMethodError(var2.getMessage());
catch (ClassNotFoundException var3)
throw new NoClassDefFoundError(var3.getMessage());
到此为止真相大白了，原来代理类继承了Proxy父类，同时实现了目标类的接口，这就将我们的目标方法与定义的事件处理器联系起来了。
同时，由于java的单继承模式，导致了代理类只能继承Proxy类，那这样的话，就只好通过目标类的接口来关联目标类了。
小结：JDK动态代理
据此，我们可以再次补充代理模式的定义：
【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式
代理模式的优点：
1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
3. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；
4. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；
代理模式的缺点：
1. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；
2. JDK动态代理基于JDK的反射原理实现，降低了执行效率；
3. JDK动态代理是基于接口的代理，要求目标类必须实现目标接口；
好的合作伙伴就是不抛弃不放弃
到这里，问题是搞明白了，就是酒店的问题，但是好的合作伙伴就是应该不抛弃，不放弃。
酒店跟我们合作，我们就要帮助他们解决困难。那怎么办呢？酒店没接口，JDK代理又非要接口，那我们就不用JDK代理了！
这时，基于类的代理方式就应运而生了—— cglib为我们提供了基于类的动态代理模式。
导Jar包：cglib-3.2.5.jar（cglib核心包）、asm-3.3.1.jar（字节码处理框架）
public class CglibDynamicProxy implements MethodInterceptor
//目标对象
private Object target;
/**
*给目标对象创建一个代理对象
*/
public Object getProxyInstance()
//工具类
Enhancer en = new Enhancer();
//设置父类
en.setSuperclass(target.getClass());
//设置回调函数
en.setCallback(this);
//创建子类代理对象
return en.create();
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable
System.out.println("cglib售前风控。。。");
final Object invoke = method.invoke(target, objects);
System.out.println("cglib售后统计。。。");
return invoke;
public CglibDynamicProxy(Object target)
this.target = target;
测试
public static void main(String[] args)
//创建销售酒店代理
CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(new SellHotel());
SellHotel sellHotel = (SellHotel) cglibDynamicProxy.getProxyInstance();
sellHotel.sellHotel(300);
测试结果
cglib售前风控。。。
酒店销售房间，价格：300
cglib售后统计。。。
原理分析：cglib代理对象是如何实现的？
那为啥cglib就不用目标类实现接口了呢？让我们看看代理类。
public static void main(String[] args)
//代理类class文件存入本地磁盘
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:\\testCglib");
//创建销售酒店代理
CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(new SellHotel());
SellHotel sellHotel = (SellHotel) cglibDynamicProxy.getProxyInstance();
sellHotel.sellHotel(300);
反编译结果
/**
* 代理类反编译结果
*/
public class SellHotel$$EnhancerByCGLIB$$2624d6e3 extends SellHotel implements Factory
private boolean CGLIB$BOUND;
public static Object CGLIB$FACTORY_DATA;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0; //方法拦截器
private static final Method CGLIB$sellHotel$0$Method; //被代理方法
private static final MethodProxy CGLIB$sellHotel$0$Proxy; //代理方法
private static final Object[] CGLIB$emptyArgs;
private static final Method CGLIB$equals$1$Method;
private static final MethodProxy CGLIB$equals$1$Proxy;
private static final Method CGLIB$toString$2$Method;
private static final MethodProxy CGLIB$toString$2$Proxy;
private static final Method CGLIB$hashCode$3$Method;
private static final MethodProxy CGLIB$hashCode$3$Proxy;
private static final Method CGLIB$clone$4$Method;
private static final MethodProxy CGLIB$clone$4$Proxy;
static void CGLIB$STATICHOOK1()
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
Class var0 = Class.forName("demo.pattern.proxy.SellHotel$$EnhancerByCGLIB$$2624d6e3"); //代理类
Class var1; //被代理类
CGLIB$sellHotel$0$Method = ReflectUtils.findMethods(new String[]"sellHotel", "(I)V", (var1 = Class.forName("demo.pattern.proxy.SellHotel")).getDeclaredMethods())[0];
CGLIB$sellHotel$0$Proxy = MethodProxy.create(var1, var0, "(I)V", "sellHotel", "CGLIB$sellHotel$0");
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());
CGLIB$equals$1$Method = var10000[0];
CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
CGLIB$toString$2$Method = var10000[1];
CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
CGLIB$hashCode$3$Method = var10000[2];
CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
CGLIB$clone$4$Method = var10000[3];
CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
final void CGLIB$sellHotel$0(int var1)
super.sellHotel(var1);
public final void sellHotel(int var1) //代理类重写的方法
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; //方法拦截器
if(this.CGLIB$CALLBACK_0 == null)
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
if(var10000 != null) //执行方法拦截器
var10000.intercept(this, CGLIB$sellHotel$0$Method, new Object[]new Integer(var1), CGLIB$sellHotel$0$Proxy);
else
super.sellHotel(var1);
final boolean CGLIB$equals$1(Object var1)
return super.equals(var1);
public final boolean equals(Object var1)
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if(this.CGLIB$CALLBACK_0 == null)
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
if(var10000 != null)
Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]var1, CGLIB$equals$1$Proxy);
return var2 == null?false:((Boolean)var2).booleanValue();
else
return super.equals(var1);
final String CGLIB$toString$2()
return super.toString();
public final String toString()
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if(this.CGLIB$CALLBACK_0 == null)
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
return var10000 != null?(String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy):super.toString();
final int CGLIB$hashCode$3()
return super.hashCode();
public final int hashCode()
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if(this.CGLIB$CALLBACK_0 == null)
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
if(var10000 != null)
Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
return var1 == null?0:((Number)var1).intValue();
else
return super.hashCode();
final Object CGLIB$clone$4() throws CloneNotSupportedException
return super.clone();
protected final Object clone() throws CloneNotSupportedException
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if(this.CGLIB$CALLBACK_0 == null)
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
return var10000 != null?var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy):super.clone();
public static MethodProxy CGLIB$findMethodProxy(Signature var0)
String var10000 = var0.toString();
switch(var10000.hashCode())
case -508378822:
if(var10000.equals("clone()Ljava/lang/Object;"))
return CGLIB$clone$4$Proxy;
break;
case 1826985398:
if(var10000.equals("equals(Ljava/lang/Object;)Z"))
return CGLIB$equals$1$Proxy;
break;
case 1913648695:
if(var10000.equals("toString()Ljava/lang/String;"))
return CGLIB$toString$2$Proxy;
break;
case 1979480752:
if(var10000.equals("sellHotel(I)V"))
return CGLIB$sellHotel$0$Proxy;
break;
case 1984935277:
if(var10000.equals("hashCode()I"))
return CGLIB$hashCode$3$Proxy;
return null;
public SellHotel$$EnhancerByCGLIB$$2624d6e3()
CGLIB$BIND_CALLBACKS(this);
public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0)
CGLIB$THREAD_CALLBACKS.set(var0);
public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0)
CGLIB$STATIC_CALLBACKS = var0;
private static final void CGLIB$BIND_CALLBACKS(Object var0)
SellHotel$$EnhancerByCGLIB$$2624d6e3 var1 = (SellHotel$$EnhancerByCGLIB$$2624d6e3)var0;
if(!var1.CGLIB$BOUND)
var1.CGLIB$BOUND = true;
Object var10000 = CGLIB$THREAD_CALLBACKS.get();
if(var10000 == null)
var10000 = CGLIB$STATIC_CALLBACKS;
if(CGLIB$STATIC_CALLBACKS == null)
return;
var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
public Object newInstance(Callback[] var1)
CGLIB$SET_THREAD_CALLBACKS(var1);
SellHotel$$EnhancerByCGLIB$$2624d6e3 var10000 = new SellHotel$$EnhancerByCGLIB$$2624d6e3();
CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
return var10000;
public Object newInstance(Callback var1)
CGLIB$SET_THREAD_CALLBACKS(new Callback[]var1);
SellHotel$$EnhancerByCGLIB$$2624d6e3 var10000 = new SellHotel$$EnhancerByCGLIB$$2624d6e3();
CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
return var10000;
public Object newInstance(Class[] var1, Object[] var2, Callback[] var3)
CGLIB$SET_THREAD_CALLBACKS(var3);
SellHotel$$EnhancerByCGLIB$$2624d6e3 var10000 = new SellHotel$$EnhancerByCGLIB$$2624d6e3;
switch(var1.length)
case 0:
var10000.<init>();
CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
return var10000;
default:
throw new IllegalArgumentException("Constructor not found");
public Callback getCallback(int var1)
CGLIB$BIND_CALLBACKS(this);
MethodInterceptor var10000;
switch(var1)
case 0:
var10000 = this.CGLIB$CALLBACK_0;
break;
default:
var10000 = null;
return var10000;
public void setCallback(int var1, Callback var2)
switch(var1)
case 0:
this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
default:
public Callback[] getCallbacks()
CGLIB$BIND_CALLBACKS(this);
return new Callback[]this.CGLIB$CALLBACK_0;
public void setCallbacks(Callback[] var1)
this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
static
CGLIB$STATICHOOK1();
到此，我们知道cglib代理是帮我们新建了一个代理类，此代理类继承自目标类获取目标方法，同时重写了目标方法。
总结：JDK、cglib动态代理
据此，我们可以总结代理模式的定义：
【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式。
代理模式的优点：
1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；
2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；
3. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；
4. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；
5. cglib动态代理可基于实现类做代理，可以解决JDK代理依赖接口的问题；
代理模式的缺点：
1. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；
2. JDK动态代理基于JDK的反射原理实现，降低了执行效率；
3. JDK动态代理是基于接口的代理，要求目标类必须实现目标接口；
代理模式分类：
1. 静态代理；
2. JDK动态代理（基于目标类的接口生成代理类做代理）；
3. cglib动态代理（基于目标类生成子类做代理，同时也支持基于接口的代理）；
代理模式的使用场景
我们知道，Spring的AOP就是依赖于动态代理模式实现的，那我们在日常的开发中有哪些地方能用到代理呢？
•事物
•日志
•监控
•统计
•鉴权
•限流
•缓存
•环境隔离
java动态代理实现与原理详细分析
...于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。 一、代理模式 代理模式是常用的java设计模式，他的特征是代... 查看详情
java动态代理实现与原理详细分析
...于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。 一、代理模式 代理模式是常用的java设计模式，他的特征是代... 查看详情
java动态代理实现与原理详细分析
一、代理模式代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系... 查看详情
设计模式----代理模式(代码片段)
代理模式代理模式示例代码静态代理静态代理简单实现动态代理动态代理的介绍原理代码模拟动态代理流程动态代理jdk源码流程分析相关的类和接口代理机制及其特点InvocationHandler接口和Proxy类详解JDK动态代理总结Cglib代理介绍mav... 查看详情
06设计模式-代理模式(代码片段)
1.5.深入分析代理模式1.5.1.深度分析代理模式【上】时长：46min学习目标： 》代理模式的应用场景及实现原理 》区分静态代理与动态代理 》cglib和jdkProxy实现动态代理的区别 》手写实现定义的动态代理 》springAo... 查看详情
一文搞懂│工厂模式单例模式策略模式适配器模式观察者模式的原理和使用(代码片段)
✨目录🎈工厂模式🎈单例模式🎈策略模式🎈适配器模式🎈观察者模式🎈工厂模式工厂模式的原理作用：就是你只要传你需要的类进去，你就能得到他的实例化对象其实工厂就是帮你实例化你所... 查看详情
一文搞懂│工厂模式单例模式策略模式适配器模式观察者模式的原理和使用(代码片段)
✨目录🎈工厂模式🎈单例模式🎈策略模式🎈适配器模式🎈观察者模式🎈工厂模式工厂模式的原理作用：就是你只要传你需要的类进去，你就能得到他的实例化对象其实工厂就是帮你实例化你所... 查看详情
设计模式-动态代理原理及模仿jdkproxy写一个属于自己的动态代理(代码片段)
本篇文章代码内容较多，讲的可能会有些粗糙，大家可以选择性阅读。本篇文章的目的是简单的分析动态代理的原理及模仿JDKProxy手写一个动态代理以及对几种代理做一个总结。对于代理模式的介绍和讲解，网上已经有很多优质... 查看详情
设计模式之jdk动态代理源码分析(代码片段)
这里查看JDK1.8.0_65的源码，通过debug学习JDK动态代理的实现原理 大概流程1、为接口创建代理类的字节码文件2、使用ClassLoader将字节码文件加载到JVM3、创建代理类实例对象，执行对象的目标方法 动态代理涉及到的主要类：... 查看详情
javajdk动态代理（aop）使用及实现原理分析
...？五、结论一、什么是代理？代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行... 查看详情
插件化知识详细分解及原理之代理，hook，反射
...分为静态代理和动态代理。代理模式也是平时比较常用的设计模式之一，代理模式有代码简洁，高扩展性的特性.主要目的就是为访问者提供一个代理，以达到限制某个对象的访问，也就是说想访问一个对象 查看详情
搞懂redis持久化,rdb模式aof模式工作原理详解及操作(代码片段)
redis持久化Redis虽然是一个内存级别的缓存程序，也就是redis是使用内存进行数据的缓存的，但是其可以将内存的数据按照一定的策略保存到硬盘上，从而实现数据持久保存的目的目前redis支持两种不同方式的数据持久化保存机制... 查看详情
设计模式——代理模式
所谓代理模式，简单地说将原来直接由客户实现或者调用功能代码块通过一个中间代理的对象去调用或者实现，目的是可以降低非业务代码对业务代码的污染以及提高代码复用性及可维护性。 一般Java代理模式编写有以下几... 查看详情
06设计模式-代理模式(代码片段)
...间起到中介作用，起到功能增强的作用。 属于结构型设计模式。 代理之生活理解： 可以参照中介来理解。如：租房中介，用户需要租房子，但是找不到或没时间找房子【用户功能不够强大】，那么，就找到一个代理... 查看详情
转载javajdk动态代理（aop）使用及实现原理分析
...权归作者和CSDN共有一、什么是代理？代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消 查看详情
一篇搞懂nginx与django部署(代码片段)
文章目录前言环境nginx模式nginx的http模式反向代理模式nginx基本使用下载安装nginx基本命令nginx配置文件Http配置文件nginx与Django部署静态文件转发django反向代理django代理runserver代理uwsgi在Linux当中前言nginx是啥我想都不要多说了，... 查看详情
深入理解代理模式原理与技术(代码片段)
...理以控制对这个对象的访问。23种常用的面向对象软件的设计模式之一。代理模式分为静态代理、动态代理。如何理解代理模式？思考抽象问题最好的办法就是具体化！比如我们需要为一个业务方法在执行前后记录日志，为了达... 查看详情
java动态代理原理
...于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。 一、代理模式 代理模式是常用的java设计模式，他的特征是代... 查看详情