作者:京东零售 秦浩然
引子
举个栗子,众所周知,我们是可以在京东上购买机票的。 但机票是航司提供的,我们本质上是代理销售而已。
那为什么航司要让我们代理销售呢?
我们又是如帮他做代理的呢?
别急,本文将展开说说他们之间的关系。。。
一个有梦想的航司
从前有个航司打算开展线上销售机票业务,于是设计了如下系统。系统完成后,业务正常开展了。。。
航司销售机票的接口:
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() {
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
上面分析一堆,那我们来了看看得到的代理类到底是啥,为啥他就能执行那个我们的目标类的方法。同时,还得目标类实现接口?
/**
* 我们自己生成一份目标类字节码文件
* @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.();
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就是依赖于动态代理模式实现的,那我们在日常的开发中有哪些地方能用到代理呢?
•事物
•日志
•监控
•统计
•鉴权
•限流
•缓存
•环境隔离