文章目录
前言
温习一下动态代理的知识,如果对java的动态代理无所了解的话,那么对AOP源码的分析就无从谈起。
代理模式可分为静态代理和动态代理两种。而动态代理又有JDK、CGLIB动态代理之分。下面我们逐步分析这几种代理。
1. 静态代理
接口和实现类,接口只模拟了两个接口方法,账户查询和账户更新,并在实现类里进行了打印。
package com.lyc.cn.v2.day04.proxy.proxy;
/**
* 账户接口
*/
public interface Count {
// 查询账户
void queryCount();
// 修改账户
void updateCount();
}
package com.lyc.cn.v2.day04.proxy.proxy;
/**
* @author: LiYanChao
* @create: 2018-10-21 12:07
*/
public class CountImpl implements Count {
@Override
public void queryCount() {
System.out.println("==查询账户");
}
@Override
public void updateCount() {
System.out.println("==更新账户");
}
}
代理类:
package com.lyc.cn.v2.day04.proxy.proxy;
/**
* 代理类
* @author: LiYanChao
* @create: 2018-10-21 12:08
*/
public class CountProxy implements Count {
private CountImpl countImpl;
/**
* 覆盖默认构造器
*/
public CountProxy(CountImpl countImpl) {
this.countImpl = countImpl;
}
@Override
public void queryCount() {
System.out.println("==查询账户开始");
// 调用真正的查询账户方法
countImpl.queryCount();
System.out.println("==查询账户结束");
}
@Override
public void updateCount() {
System.out.println("==更新账户开始");
// 调用真正的修改账户操作
countImpl.updateCount();
System.out.println("==更新账户结束");
}
}
测试类:
@Test
public void test1() {
// 静态代理
CountImpl countImpl = new CountImpl();
CountProxy countProxy = new CountProxy(countImpl);
countProxy.updateCount();
System.out.println("\n*******\n");
countProxy.queryCount();
}
执行结果:
==更新账户开始
==更新账户
==更新账户结束
*******
==查询账户开始
==查询账户
==查询账户结束
该中模式比较简单,不再做过多的分析。就是硬编码,采用代理模式,手动实现一个代理类。
硬编码的缺点是什么?就是一旦代码需要变更,需要重新编译后才能生效。
2. JDK动态代理
JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建,JVM根据传进来的业务实现类对象以及方法名 ,动态地创建了一个代理类的class文件并被字节码引擎执行,然后通过该代理类对象进行方法调用。
我们需要做的,只需指定代理类的预处理、调用后操作即可。JDK的动态代理需要实现InvocationHandler
接口,并重写invoke()
方法。并且被代理的类必须要实现一个接口,接口类型不限制,来看具体的例子:
即将被代理的接口和类:
package com.lyc.cn.v2.day04.proxy.jdk;
public interface JDKAnimal {
void sayHello();
}
package com.lyc.cn.v2.day04.proxy.jdk;
public class JDKDog implements JDKAnimal {
@Override
public void sayHello() {
System.out.println("我是一只猫");
}
}
自定义InvocationHandler:
package com.lyc.cn.v2.day04.proxy.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyInvocationHandler implements InvocationHandler {
// 目标对象
private Object target;
/**
* 构造方法
* @param target 目标对象
*/
public MyInvocationHandler(Object target) {
super();
this.target = target;
}
/**
* @param proxy JDK动态生成的最终代理对象
* @param method 调用真实对象的某个方法的Method对象
* @param args 调用真实对象某个方法时接受的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("==代理方法开始执行");
Object invoke = method.invoke(target, args);
System.out.println("==代理方法结束执行");
return invoke;
}
/**
* 获取目标对象的代理对象
* @return 代理对象
*/
public Object getProxy() {
/**
* 参数:
* 1、获取当前线程的类加载
* 2、获取接口
* 3、当前对象
*/
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
target.getClass().getInterfaces(),
this);
}
}
测试类:
public class MainClass {
public static void main(String[] args) {
// JDK动态代理
MyInvocationHandler handler = new MyInvocationHandler(new JDKDog());
JDKAnimal proxy = (JDKAnimal) handler.getProxy();
proxy.sayHello();
}
}
执行结果:
==代理方法开始执行
我是一只猫
==代理方法结束执行
2.1 JDK动态代理原理分析
利用Java的反射技术(Java Reflection),在运行时创建一个实现某些给定接口的新类(也称“动态代理类”)及其实例(对象),代理的是接口(Interfaces),不是类(Class),也不是抽象类。在运行时才知道具体的实现,spring aop就是此原理。
在MyInvocationHandler类中,通过实现InvocationHandler并重写invoke方法,实现了对JDKDog类的动态代理。但是这里大家一定会有一个疑问,在测试类中通过JDKAnimal proxy = (JDKAnimal) handler.getProxy();
获取了代理类的实例,但是当调用proxy.sayHello();
方法时,却会调用MyInvocationHandler的invoke方法
,要解开这个谜题,就需要了解一下代理类是如何生成、生成的代理类是什么样子的、是如何被实例化的。
2.1.1 Proxy.newProxyInstance方法简析
打开MyInvocationHandler类的getProxy方法,查看Proxy.newProxyInstance方法源码:
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.
*/
//[0] 查找或生成一个代理类
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//[2]构造器
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;
}
});
}
// [3]反射创建生成代理类的实例
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);
}
}
[1].调用getProxyClass0()方法获得代理类
[2].构造器
[3].利用反射,创建代理类的实例
2.2.1.1 getProxyClass0()
实现动态代理的核心方法,动态代理的思路便是生成一个新类,调用getProxyClass0()便成为了生成新类,getProxyClass0()方法直接取proxyClassCache缓存中的代理类,proxyClassCache是一个代理类的缓存变量,如果这个缓存里有这个代理类,就直接返回代理类,如果没有,就会通过ProxyClassFactory创建代理对象。
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
// 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);
}
2.2.1.1 ProxyClassFactory
ProxyClassFactory是Proxy里的一个内部类,用来生成代理类,apply()方法的最后会调用ProxyGenerator.generateProxyClass()
方法来完成生成字节码的操作:
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
}
}
ProxyGenerator.generateProxyClass()
可以生成一个字节码文件,那么通过查看该字节码文件,我们就能明白原理了!
2.1.2 查看代理的字节码文件
默认情况下,jvm是不会保存这个字节码文件的,是个临时文件,生成后会删除掉,我们可以通过系统参数,让其保存。
JDK1.8下:
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
不同版本JDK可能参数略有不同,比如:System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”,“true”);
public static void main(String[] args) {
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
// JDK动态代理
MyInvocationHandler handler = new MyInvocationHandler(new JDKDog());
JDKAnimal proxy = (JDKAnimal) handler.getProxy();
proxy.sayHello();
}
默认路径是工程目录/com\sun\proxy\$Proxy0.class
,JD-GUI工具 可以实现对.class文件的反编译,该软件支持windows、linux、macOS。用JD-GUI打开生成的$Proxy.class
文件
package com.lyc.cn.v2.day04.proxy.jdk;
/**
* 反编译代理.class文件
* @author: LiYanChao
* @create: 2018-11-02 15:01
*/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy extends Proxy implements JDKAnimal {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject) {
try {
return ((Boolean) this.h.invoke(this, m1, new Object[]{paramObject})).booleanValue();
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
/**
* 代理类中实现了sayHello接口
*/
public final void sayHello() {
try {
this.h.invoke(this, m3, null);
return;
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString() {
try {
return (String) this.h.invoke(this, m2, null);
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode() {
try {
return ((Integer) this.h.invoke(this, m0, null)).intValue();
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.lyc.cn.v2.day04.proxy.jdk.JDKAnimal").getMethod("sayHello", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
// return 会报错,注释掉即可。
//return;
} catch (NoSuchMethodException localNoSuchMethodException) {
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
} catch (ClassNotFoundException localClassNotFoundException) {
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}
代理类$Proxy被声明为final类,继承Proxy类并实现了JDKAnimal接口,重写了equals、toString、hashCode等方法,当然最重要的还是实现了JDKAnimal接口中的sayHello方法,并通过静态代码块拿到了sayHello方法的信息,看到sayHello方法体:
看到这里相信大家对前面提到的疑问已经恍然大悟了,这个代理对象调用了MyInvocationHandler的invoke()方法。
new $Proxy(handler)
构造函数接受的就是我们自定义的MyInvocationHandler,所以当代码运行到$Proxy
的sayHello方法时,this.h.invoke(this, m3, null);
this.h就是MyInvocationHandler的实例,所以自然就会调用到invoke方法了,因为JDKAnimal proxy = (JDKAnimal) handler.getProxy();
获取到的是代理类的实例,而不是JDKAnimal的实例
并且从字节码文件能看到,实现了JDKAnimal接口,入下图所示:
因此,动态代理的前提是目标类必须实现一个接口!
2.1.2.1 指定代理的字节码文件路径
原文这个例子是为了指定代理的字节码文件路径,替换DEFAULT_FILE_PATH
变量的路径为你期望的路径即可。
原理是手动写个测试方法,调用ProxyGenerator.generateProxyClass(),该方法是生成代理字节码文件的核心方法,该方法接收一个路径,即字节码的路径:
package com.lyc.cn.v2.day04.proxy.jdk;
import org.junit.Test;
import sun.misc.ProxyGenerator;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author: LiYanChao
* @create: 2018-11-02 14:11
*/
public class GenJdkProxyClass {
/**
* 生成代理类的名称
*/
private static String DEFAULT_CLASS_NAME = "$Proxy";
/**
* 默认生成的文件全路径
*/
private static String DEFAULT_FILE_PATH = "/Users/liyanchao/Desktop/" + DEFAULT_CLASS_NAME + ".class";
/**
* 使用ProxyGenerator生成代理类.class文件
* @param path 文件路径
*/
public static void genProxyClass(String path) {
byte[] classFile = ProxyGenerator.generateProxyClass(DEFAULT_CLASS_NAME, new Class[]{JDKAnimal.class});
FileOutputStream fos = null;
try {
fos = new FileOutputStream(path);
fos.write(classFile);
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void TestGenProxyClass() {
GenJdkProxyClass.genProxyClass(DEFAULT_FILE_PATH);
}
}
2.2 CGLIB动态代理
CGLIB是针对类来实现代理的,原理是对指定的业务类生成一个子类,并覆盖其中业务方法实现代理。因为采用的是继承,所以不能对final修饰的类进行代理。 在使用的时候需要引入cglib和asm的jar包,并实现MethodInterceptor接口。
Cglib动态代理所需要的jar,一共有两个(asm-3.3.1和cglib-2.2.2)
被代理类,没有实现任何接口:
package com.lyc.cn.v2.day04.proxy.cglib;
public class CglibCat {
public void sayHello() {
System.out.println("我是一只猫。。。");
}
}
自定义MethodInterceptor:
package com.lyc.cn.v2.day04.proxy.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class MyCglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
// 这里的目标类型为Object,则可以接受任意一种参数作为被代理类,实现了动态代理
public Object getInstance(Class clazz) {
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
// 返回代理对象
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("==代理方法开始执行");
Object result = methodProxy.invokeSuper(proxy, args);
System.out.println("==代理方法结束执行");
return result;
}
}
测试类:
public class MainClass {
public static void main(String[] args) {
// CGLIB动态代理
CglibCat cat = (CglibCat) new MyCglibProxy().getInstance(CglibCat.class);
cat.sayHello();
}
}
CGLib采用了非常底层的字节码技术( ASM),其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。
3. 总结
总而言之,动态代理技术是AOP的基础也是核心,大家一定要先把JDK、CGLIB动态代理搞明白之后,再去看AOP的源码,才能达到事半功倍的效果。
3.1 Cglib和jdk动态代理的区别?
1、Jdk动态代理:利用拦截器(必须实现InvocationHandler)加上反射机制生成一个代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理
可以理解为利用java的反射技术,新生成一个java类,继承了Proxy 类,实现了某个接口,需要重新编译为class文件。生成的代码过程快,但是执行稍慢,早jdk早期,性能尤其差
public final class $Proxy extends Proxy implements JDKAnimal {
2、 Cglib动态代理:利用ASM框架,对代理对象类生成的class文件加载进来,通过修改其字节码生成子类来处理
特点是生成的子类,不是通过java类编译过来的,而是字节码技术,在原有的字节码上修改的,生成的代理过程速度慢,但是执行慢
3.2 什么时候用cglib什么时候用jdk动态代理?
1、目标对象生成了接口, 默认用JDK动态代理
2、如果目标对象使用了接口,可以强制使用cglib
通过参数,可以修改策略
3、如果目标对象没有实现接口,必须采用cglib库,Spring会自动在JDK动态代理和cglib之间转换
3.3 JDK动态代理和cglib字节码生成的区别?
1、JDK动态代理只能对实现了接口的类生成代理,而不能针对类
2、Cglib是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法,并覆盖其中方法的增强,但是因为采用的是继承,所以该类或方法最好不要生成final,对于final类或方法,是无法继承的
3.3 Cglib比JDK快?
1、cglib底层是ASM字节码生成框架,生成代理类的过程耗时,但是执行速度快,早期jdk6之之前,执行速度比jdk动态代理快很多
2、在jdk6之后逐步对JDK动态代理进行了优化,在1.8的时候JDK的效率与cglib差不多,甚至略高于cglib