1 从静态代理到动态代理
举个例子,有些人到了适婚年龄,会被父母催婚。而现在在各种压力之下,很多人都选择晚婚晚育。于是着急的父母就开始到处为子女相亲,比子女自己还着急。下面来看代码实现。创建顶层接口IPerson的代码如下。
public interface IPerson {
void findLove();
}
儿子张三要找对象,实现ZhangSan类。
public class ZhangSan implements IPerson {
public void findLove() {
System.out.println("儿子张三提出要求");
}
}
父亲张老三要帮儿子张三相亲,实现ZhangLaosan类。
public class ZhangLaosan implements IPerson {
private ZhangSan zhangsan;
public ZhangLaosan(ZhangSan zhangsan) {
this.zhangsan = zhangsan;
}
public void findLove() {
System.out.println("张老三开始物色");
zhangsan.findLove();
System.out.println("开始交往");
}
}
来看客户端测试代码。
public class Test {
public static void main(String[] args) {
ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
zhangLaosan.findLove();
}
}
运行结果如下图所示。
但是,上面的场景有个弊端,就是自己的父亲只会帮自己的子女去物色对象,别人家的孩子是不会管的。但社会上这项业务发展成了一个产业,出现了媒婆、婚介所等,还有各种各样的定制套餐。如果还使用静态代理成本就太高了,需要一个更加通用的解决方案,满足任何单身人士找对象的需求。这就由静态代理升级到了动态代理。采用动态代理基本上只要是人(IPerson)就可以提供相亲服务。动态代理的底层实现一般不用我们亲自去实现,已经有很多现成的API。在Java生态中,目前普遍使用的是JDK自带的代理和CGLib提供的类库。首先基于JDK的动态代理支持来升级一下代码。
首先创建媒婆(婚介所)类JdkMeipo。
public class JdkMeipo implements InvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("双方同意,开始交往");
}
private void before() {
System.out.println("我是媒婆,已经收集到你的需求,开始物色");
}
}
然后创建一个类ZhaoLiu。
public class ZhaoLiu implements IPerson {
public void findLove() {
System.out.println("符合赵六的要求");
}
public void buyInsure() {
}
}
最后客户端测试代码如下。
public static void main(String[] args) {
JdkMeipo jdkMeipo = new JdkMeipo();
IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
zhaoliu.findLove();
}
运行结果如下图所示。
2 三层架构中的静态代理
小伙伴们可能会觉得还是不知道如何将代理模式应用到业务场景中,我们来看一个实际的业务场景。在分布式业务场景中,通常会对数据库进行分库分表,分库分表之后使用Java操作时就可能需要配置多个数据源,我们通过设置数据源路由来动态切换数据源。首先创建Order订单类。
public class Order {
private Object orderInfo;
private Long createTime;
private String id;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Long getCreateTime() {
return createTime;
}
public void setCreateTime(Long createTime) {
this.createTime = createTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
创建OrderDao持久层操作类。
public class OrderDao {
public int insert(Order order){
System.out.println("OrderDao创建Order成功!");
return 1;
}
}
创建IOrderService接口。
public interface IOrderService {
int createOrder(Order order);
}
创建OrderService实现类。
public class OrderService implements IOrderService {
private OrderDao orderDao;
public OrderService(){
//如果使用Spring,则应该是自动注入的
//为了使用方便,我们在构造方法中直接将orderDao初始化
orderDao = new OrderDao();
}
@Override
public int createOrder(Order order) {
System.out.println("OrderService调用orderDao创建订单");
return orderDao.insert(order);
}
}
然后使用静态代理,主要完成的功能是:根据订单创建时间自动按年进行分库。根据开闭原则,我们修改原来写好的代码逻辑,通过代理对象来完成。创建数据源路由对象,使用ThreadLocal的单例实现DynamicDataSourceEntry类。
//动态切换数据源
public class DynamicDataSourceEntry {
//默认数据源
public final static String DEFAULT_SOURCE = null;
private final static ThreadLocal<String> local = new ThreadLocal<String>();
private DynamicDataSourceEntry(){}
//清空数据源
public static void clear() {
local.remove();
}
//获取当前正在使用的数据源名字
public static String get() {
return local.get();
}
//还原当前切换的数据源
public static void restore() {
local.set(DEFAULT_SOURCE);
}
//设置已知名字的数据源
public static void set(String source) {
local.set(source);
}
//根据年份动态设置数据源
public static void set(int year) {
local.set("DB_" + year);
}
}
创建切换数据源的代理类OrderServiceSaticProxy。
public class OrderServiceStaticProxy implements IOrderService {
private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private IOrderService orderService;
public OrderServiceStaticProxy(IOrderService orderService){
this.orderService = orderService;
}
public int createOrder(Order order) {
before();
Long time = order.getCreateTime();
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");
DynamicDataSourceEntry.set(dbRouter);
orderService.createOrder(order);
after();
return 0;
}
private void before(){
System.out.println("Proxy before method.");
}
private void after(){
System.out.println("Proxy after method.");
}
}
来看客户端测试代码。
public static void main(String[] args) {
try {
Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2017/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
orderService.createOrder(order);
}catch (Exception e){
e.printStackTrace();;
}
}
运行结果如下图所示。
由上图可知,结果符合预期。再来回顾一下类图,看是否与我们最先画的一致,如下图所示。
动态代理和静态代理的基本思路是一致的,只不过动态代理的功能更强大,随着业务的扩展,适应性更强。
3 使用动态代理实现无感知切换数据源
在理解了上面的案例后,再来看数据源动态路由业务,帮助小伙伴们加深对动态代理的印象。创建动态代理的类OrderServiceDynamicProxy,代码如下。
public class OrderServiceDynamicProxy implements InvocationHandler {
private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private Object target;
public Object getInstance(Object target){
this.target = target;
Class<?> clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before(args[0]);
Object object = method.invoke(target,args);
after();
return object;
}
private void before(Object target){
try {
System.out.println("Proxy before method.");
Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");
DynamicDataSourceEntry.set(dbRouter);
}catch (Exception e){
e.printStackTrace();
}
}
private void after(){
System.out.println("Proxy after method.");
}
}
编写客户端测试代码如下。
public static void main(String[] args) {
try {
Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2018/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().
getInstance(new OrderService());
orderService.createOrder(order);
}catch (Exception e){
e.printStackTrace();
}
}
由上面代码可以看出,依然能够达到相同的运行效果。但是,使用动态代理实现之后,不仅能实现Order的数据源动态路由,还可以实现其他任何类的数据源路由。当然,有一个比较重要的约定,必须实现getCreateTime()方法,因为路由规则是根据时间来运算的。可以通过接口规范达到约束的目的,在此不再举例。
4 手写JDK动态代理核心原理
不仅知其然,还得知其所以然。既然JDK动态代理的功能如此强大,那么它是如何实现的呢?现在来探究一下原理,并模仿JDK动态代理手写一个属于自己的动态代理。
我们都知道JDK动态代理采用字节重组,重新生成对象来替代原始对象,以达到动态代理的目的。JDK动态代理生成对象的步骤如下。
(1)获取被代理对象的引用,并且获取它的所有接口,反射获取。
(2)JDK动态代理类重新生成一个新的类,同时新的类要实现被代理类实现的所有接口。
(3)动态生成Java代码,新加的业务逻辑方法由一定的逻辑代码调用(在代码中体现)。
(4)编译新生成的Java代码.class文件。
(5)重新加载到JVM中运行。
以上过程就叫作字节码重组。JDK中有一个规范,在ClassPath下只要是$开头的.class文件,一般都是自动生成的。那么有没有办法看到代替后的对象的“真容”呢?做一个这样的测试,将内存中的对象字节码通过文件流输出到一个新的.class文件,然后使用反编译工具查看源码。
public static void main(String[] args) {
try {
IPerson obj = (IPerson)new JdkMeipo().getInstance(new Zhangsan());
obj.findLove();
//通过反编译工具查看源代码
byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IPerson.class});
FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
os.write(bytes);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
运行以上代码,可以在E盘找到一个 P r o x y 0. c l a s s 文 件 。 使 用 J a d 反 编 译 , 得 到 Proxy0.class文件。使用Jad反编译,得到 Proxy0.class文件。使用Jad反编译,得到Proxy0.jad文件,打开文件看到如下内容。
import com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson;
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 IPerson {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
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 void findLove() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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 buyInsure() throws {
try {
super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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")});
m3 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
.getMethod("findLove", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m4 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
.getMethod("buyInsure", new Class[0]);
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());
}
}
}
我们发现,$Proxy0继承了Proxy类,同时实现了Person接口,而且重写了findLove()等方法。在静态代码块中用反射查找到了目标对象的所有方法,而且保存了所有方法的引用,重写的方法用反射调用目标对象的方法。小伙伴们此时一定会好奇:这些代码是从哪里来的?其实是JDK自动生成的。现在我们不依赖JDK,自己来动态生成源码、动态完成编译,然后替代目标对象并执行。
创建GPInvocationHandler接口。
public interface GPInvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
创建GPProxy类。
/**
* 用来生成源码的工具类
* Created by Tom.
*/
public class GPProxy {
public static final String ln = "\r\n";
public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces,
GPInvocationHandler h){
try {
//1.动态生成源码.java文件
String src = generateSrc(interfaces);
//2.Java文件输出磁盘
String filePath = GPProxy.class.getResource("").getPath();
File f = new File(filePath + "$Proxy0.java");
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//3.把生成的.java文件编译成.class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
Iterable iterable = manage.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
task.call();
manage.close();
//4.编译生成的.class文件加载到JVM中
Class proxyClass = classLoader.findClass("$Proxy0");
Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
f.delete();
//5.返回字节码重组以后的新的代理对象
return c.newInstance(h);
}catch (Exception e){
e.printStackTrace();
}
return null;
}
private static String generateSrc(Class<?>[] interfaces){
StringBuffer sb = new StringBuffer();
sb.append(GPProxy.class.getPackage() + ";" + ln);
sb.append("import " + interfaces[0].getName() + ";" + ln);
sb.append("import java.lang.reflect.*;" + ln);
sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
sb.append("GPInvocationHandler h;" + ln);
sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);
sb.append("this.h = h;");
sb.append("}" + ln);
for (Method m : interfaces[0].getMethods()){
Class<?>[] params = m.getParameterTypes();
StringBuffer paramNames = new StringBuffer();
StringBuffer paramValues = new StringBuffer();
StringBuffer paramClasses = new StringBuffer();
for (int i = 0; i < params.length; i++) {
Class clazz = params[i];
String type = clazz.getName();
String paramName = toLowerFirstCase(clazz.getSimpleName());
paramNames.append(type + " " + paramName);
paramValues.append(paramName);
paramClasses.append(clazz.getName() + ".class");
if(i > 0 && i < params.length-1){
paramNames.append(",");
paramClasses.append(",");
paramValues.append(",");
}
}
sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
sb.append("try{" + ln);
sb.append("Method m = " + interfaces[0].getName() + ".class. getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
sb.append("}catch(Error _ex) { }");
sb.append("catch(Throwable e){" + ln);
sb.append("throw new UndeclaredThrowableException(e);" + ln);
sb.append("}");
sb.append(getReturnEmptyCode(m.getReturnType()));
sb.append("}");
}
sb.append("}" + ln);
return sb.toString();
}
private static Map<Class,Class> mappings = new HashMap<Class, Class>();
static {
mappings.put(int.class,Integer.class);
}
private static String getReturnEmptyCode(Class<?> returnClass){
if(mappings.containsKey(returnClass)){
return "return 0;";
}else if(returnClass == void.class){
return "";
}else {
return "return null;";
}
}
private static String getCaseCode(String code,Class<?> returnClass){
if(mappings.containsKey(returnClass)){
return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()";
}
return code;
}
private static boolean hasReturnValue(Class<?> clazz){
return clazz != void.class;
}
private static String toLowerFirstCase(String src){
char [] chars = src.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
}
创建GPClassLoader类。
public class GPClassLoader extends ClassLoader {
private File classPathFile;
public GPClassLoader(){
String classPath = GPClassLoader.class.getResource("").getPath();
this.classPathFile = new File(classPath);
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String className = GPClassLoader.class.getPackage().getName() + "." + name;
if(classPathFile != null){
File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
if(classFile.exists()){
FileInputStream in = null;
ByteArrayOutputStream out = null;
try{
in = new FileInputStream(classFile);
out = new ByteArrayOutputStream();
byte [] buff = new byte[1024];
int len;
while ((len = in.read(buff)) != -1){
out.write(buff,0,len);
}
return defineClass(className,out.toByteArray(),0,out.size());
}catch (Exception e){
e.printStackTrace();
}
}
}
return null;
}
}
创建GPMeipo类。
public class GpMeipo implements GPInvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("双方同意,开始交往");
}
private void before() {
System.out.println("我是媒婆,已经收集到你的需求,开始物色");
}
}
客户端测试代码如下。
public static void main(String[] args) {
GpMeipo gpMeipo = new GpMeipo();
IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());
zhangsan.findLove();
}
至此,手写JDK动态代理就完成了。小伙伴们是不是又多了一个面试用的“撒手锏”呢?
5 CGLib动态代理API原理分析
简单看一下CGLib动态代理的使用,还是以媒婆为例,创建CglibMeipo类。
public class CGlibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
//相当于JDK中的Proxy类,是完成代理的工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆,我要给你找对象,现在已经确认你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("双方同意,准备办婚事");
}
}
创建单身客户类Customer。
public class Customer {
public void findLove(){
System.out.println("符合要求");
}
}
这里有一个小细节,CGLib动态代理的目标对象不需要实现任何接口,它是通过动态继承目标对象实现动态代理的,客户端测试代码如下。
public static void main(String[] args) {
try {
//JDK采用读取接口的信息
//CGLib覆盖父类方法
//目的都是生成一个新的类,去实现增强代码逻辑的功能
//JDK Proxy对于用户而言,必须要有一个接口实现,目标类相对来说复杂
//CGLib可以代理任意一个普通的类,没有任何要求
//CGLib生成代理的逻辑更复杂,调用效率更高,生成一个包含了所有逻辑的FastClass,不再需 要反射调用
//JDK Proxy生成代理的逻辑简单,执行效率相对要低,每次都要反射动态调用
//CGLib有一个缺点,CGLib不能代理final的方法
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
System.out.println(obj);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
CGLib动态代理的实现原理又是怎样的呢?我们可以在客户端测试代码中加上一句代码,将CGLib动态代理后的.class文件写入磁盘,然后反编译来一探究竟,代码如下。
public static void main(String[] args) {
try {
//使用CGLib的代理类可以将内存中的.class文件写入本地磁盘
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://cglib_proxy_class/");
Customer obj = (Customer)new CglibMeipo().getInstance(Customer.class);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
重新执行代码,我们会发现在E://cglib_proxy_class目录下多了三个.class文件,如下图所示。
通过调试跟踪发现,Customer E n h a n c e r B y C G L I B EnhancerByCGLIB EnhancerByCGLIB3feeb52a.class就是CGLib动态代理生成的代理类,继承了Customer类。
package com.tom.pattern.proxy.dynamicproxy.cglibproxy;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.*;
public class Customer$$EnhancerByCGLIB$$3feeb52a extends Customer
implements Factory
{
...
final void CGLIB$findLove$0()
{
super.findLove();
}
public final void findLove()
{
CGLIB$CALLBACK_0;
if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
JVM INSTR pop ;
CGLIB$BIND_CALLBACKS(this);
CGLIB$CALLBACK_0;
_L2:
JVM INSTR dup ;
JVM INSTR ifnull 37;
goto _L3 _L4
_L3:
break MISSING_BLOCK_LABEL_21;
_L4:
break MISSING_BLOCK_LABEL_37;
this;
CGLIB$findLove$0$Method;
CGLIB$emptyArgs;
CGLIB$findLove$0$Proxy;
intercept();
return;
super.findLove();
return;
}
...
}
我们重写了Customer类的所有方法,通过代理类的源码可以看到,代理类会获得所有从父类继承来的方法,并且会有MethodProxy与之对应,比如Method CGLIB$findLove 0 0 0Method、MethodProxy CGLIB$findLove 0 0 0Proxy等方法在代理类的findLove()方法中都有调用。
//代理方法(methodProxy.invokeSuper()方法会调用)
final void CGLIB$findLove$0()
{
super.findLove();
}
//被代理方法(methodProxy.invoke()方法会调用
//这就是为什么在拦截器中调用methodProxy.invoke会发生死循环,一直在调用拦截器)
public final void findLove()
{
...
//调用拦截器
intercept();
return;
super.findLove();
return;
}
调用过程为:代理对象调用this.findLove()方法→调用拦截器→methodProxy.invokeSuper()→ CGLIB$findLove$0→被代理对象findLove()方法。
此时,我们发现MethodInterceptor拦截器就是由MethodProxy的invokeSuper()方法调用代理方法的,因此,MethodProxy类中的代码非常关键,我们分析它具体做了什么。
package net.sf.cglib.proxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import net.sf.cglib.core.AbstractClassGenerator;
import net.sf.cglib.core.CodeGenerationException;
import net.sf.cglib.core.GeneratorStrategy;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;
import net.sf.cglib.reflect.FastClass.Generator;
public class MethodProxy {
private Signature sig1;
private Signature sig2;
private MethodProxy.CreateInfo createInfo;
private final Object initLock = new Object();
private volatile MethodProxy.FastClassInfo fastClassInfo;
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
MethodProxy proxy = new MethodProxy();
proxy.sig1 = new Signature(name1, desc);
proxy.sig2 = new Signature(name2, desc);
proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
return proxy;
}
...
private static class CreateInfo {
Class c1;
Class c2;
NamingPolicy namingPolicy;
GeneratorStrategy strategy;
boolean attemptLoad;
public CreateInfo(Class c1, Class c2) {
this.c1 = c1;
this.c2 = c2;
AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();
if(fromEnhancer != null) {
this.namingPolicy = fromEnhancer.getNamingPolicy();
this.strategy = fromEnhancer.getStrategy();
this.attemptLoad = fromEnhancer.getAttemptLoad();
}
}
}
...
}
继续看invokeSuper()方法。
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
this.init();
MethodProxy.FastClassInfo fci = this.fastClassInfo;
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException var4) {
throw var4.getTargetException();
}
}
...
private static class FastClassInfo {
FastClass f1;
FastClass f2;
int i1;
int i2;
private FastClassInfo() {
}
}
上面代码调用获取代理类对应的FastClass,并执行代理方法。还记得之前生成的三个.class文件吗?Customer
E
n
h
a
n
c
e
r
B
y
C
G
L
I
B
EnhancerByCGLIB
EnhancerByCGLIB3feeb52a
F
a
s
t
C
l
a
s
s
B
y
C
G
L
I
B
FastClassByCGLIB
FastClassByCGLIB6aad62f1.class就是代理类的FastClass,Customer
F
a
s
t
C
l
a
s
s
B
y
C
G
L
I
B
FastClassByCGLIB
FastClassByCGLIB2669574a.class就是被代理类的FastClass。
CGLib动态代理执行代理方法的效率之所以比JDK高,是因为CGlib采用了FastClass机制,它的原理简单来说就是:为代理类和被代理类各生成一个类,这个类会为代理类或被代理类的方法分配一个index(int类型);这个index被当作一个入参,FastClass可以直接定位要调用的方法并直接进行调用,省去了反射调用,因此调用效率比JDK代理通过反射调用高。下面我们来反编译一个FastClass。
public int getIndex(Signature signature)
{
String s = signature.toString();
s;
s.hashCode();
JVM INSTR lookupswitch 11: default 223
…
JVM INSTR pop ;
return -1;
}
//部分代码省略
//根据index直接定位执行方法
public Object invoke(int i, Object obj, Object aobj[])
throws InvocationTargetException
{
(Customer)obj;
i;
JVM INSTR tableswitch 0 10: default 161
goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12
_L2:
eat();
return null;
_L3:
findLove();
return null;
…
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
FastClass并不是跟代理类一起生成的,而是在第一次执行MethodProxy的invoke()或invokeSuper()方法时生成的,并被放在了缓存中。
//MethodProxy的invoke()或invokeSuper()方法都调用了init()方法
private void init() {
if(this.fastClassInfo == null) {
Object var1 = this.initLock;
synchronized(this.initLock) {
if(this.fastClassInfo == null) {
MethodProxy.CreateInfo ci = this.createInfo;
MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
//如果在缓存中,则取出;如果没在缓存中,则生成新的FastClass
fci.f1 = helper(ci, ci.c1);
fci.f2 = helper(ci, ci.c2);
fci.i1 = fci.f1.getIndex(this.sig1);//获取方法的index
fci.i2 = fci.f2.getIndex(this.sig2);
this.fastClassInfo = fci;
}
}
}
}
至此,我们基本清楚了CGLib动态代理的原理,对代码细节感兴趣的小伙伴们可以自行深入研究。
6 CGLib和JDK Proxy对比分析
(1)JDK动态代理实现了被代理对象的接口,CGLib动态代理继承了被代理对象。
(2)JDK动态代理和CGLib动态代理都在运行期生成字节码,JDK动态代理直接写Class字节码,CGLib动态代理使用ASM框架写Class字节码。CGLib动态代理实现更复杂,生成代理类比JDK动态代理效率低。
(3)JDK动态代理调用代理方法是通过反射机制调用的,CGLib动态代理是通过FastClass机制直接调用方法的,CGLib动态代理的执行效率更高。
关注微信公众号『 Tom弹架构 』回复“设计模式”可获取完整源码。
本文为“Tom弹架构”原创,转载请注明出处。技术在于分享,我分享我快乐!
如果本文对您有帮助,欢迎关注和点赞;如果您有任何建议也可留言评论或私信,您的支持是我坚持创作的动力。关注微信公众号『 Tom弹架构 』可获取更多技术干货!