作者：京东零售 秦浩然
引子
举个栗子，众所周知，我们是可以在京东上购买机票的。 但机票是航司提供的，我们本质上是代理销售而已。
那为什么航司要让我们代理销售呢？
我们又是如帮他做代理的呢？
别急，本文将展开说说他们之间的关系。。。
一个有梦想的航司
从前有个航司打算开展线上销售机票业务，于是设计了如下系统。系统完成后，业务正常开展了。。。
航司销售机票的接口：
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 wasn't 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就是依赖于动态代理模式实现的，那我们在日常的开发中有哪些地方能用到代理呢？
•事物
•日志
•监控
•统计
•鉴权
•限流
•缓存
•环境隔离