文章目录
使用Spring AOP
AOP简介
AOP(Aspect Orient Programming)，一般称为面向切面编程，是对面向对象编程的补充，用于处理系统中分布于各个模块的横切关注点，比如数据库事物、日志、权限控制、缓存等。AOP代理主要有两种实现方式：1.静态代理，2.动态代理。静态代理是在编译阶段就织入代理类，代表框架为AspectJ。动态代理是在运行期间才织入代理，代表框架Spring AOP。今天我们主要讲的是Spring AOP的动态代理采用两种代理机制：CGLib动态代理和JDK动态代理
使用方式
创建一个SpringBoot项目，使用AOP进行日志记录，通过修改配置项可以切换JDK动态代理或者CGLib动态代理。
| 代理方式 | 特点 |
|---|---|
| JDK动态代理 | 1.通过实现接口进行代理，所以只能代理接口 2.生成代理速度快 3.通过反射调用，效率会低一些 |
| CGLib动态代理 | 1.通过继承的方式实现动态代理，所以可以代理实现类但不能代理final标识的类 2.通过FastClass机制，直接进行调用执行效率会比较高 |
#采用JDK动态代理
spring.aop.proxy-target-class=false
#采用CGLib动态代理
#spring.aop.proxy-target-class=true
创建一个接口HomeService
public interface HomeService {
String getHomeInfo();
}
HomeService 的实现类
@Service
public class HomeServiceImpl implements HomeService {
@Override
public String getHomeInfo() {
return "homeInfo";
}
}
定义一个切面
@Aspect
@Component
public class LogAdvice {
Logger logger = LoggerFactory.getLogger(LogAdvice.class);
@Pointcut("execution (* com.github.xuejike.springaop.service.HomeService.*(..))")
public void pointcut() {
}
@Around("pointcut()")
public void around(ProceedingJoinPoint pjp) throws Throwable {
String methodName = pjp.getSignature().getName();
String clsName = pjp.getTarget().getClass().getName();
logger.info("代理对象：{}",AopContext.currentProxy().getClass().getName());
logger.info("开始调用:{}->{}",clsName,methodName);
//执行方法
pjp.proceed();
logger.info("调用结束:{}->{}",clsName,methodName);
}
}
控制台Jdk动态代理日志
2019-01-03 15:39:58.417 INFO 25024 --- [nio-8080-exec-1] c.g.xuejike.springaop.aop.LogAdvice : 代理对象：com.sun.proxy.$Proxy57
2019-01-03 15:39:58.417 INFO 25024 --- [nio-8080-exec-1] c.g.xuejike.springaop.aop.LogAdvice : 开始调用:com.github.xuejike.springaop.service.impl.HomeServiceImpl->getHomeInfo
2019-01-03 15:39:58.417 INFO 25024 --- [nio-8080-exec-1] c.g.xuejike.springaop.aop.LogAdvice : 调用结束:com.github.xuejike.springaop.service.impl.HomeServiceImpl->getHomeInfo
采用CGLib动态代理的控制台日志
2019-01-03 15:44:26.934 INFO 25180 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet'
2019-01-03 15:44:26.952 INFO 25180 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet : Completed initialization in 18 ms
2019-01-03 15:44:27.012 INFO 25180 --- [nio-8080-exec-1] c.g.xuejike.springaop.aop.LogAdvice : 代理对象：com.github.xuejike.springaop.service.impl.HomeServiceImpl$$EnhancerBySpringCGLIB$$107d3088
2019-01-03 15:44:27.012 INFO 25180 --- [nio-8080-exec-1] c.g.xuejike.springaop.aop.LogAdvice : 开始调用:com.github.xuejike.springaop.service.impl.HomeServiceImpl->getHomeInfo
2019-01-03 15:44:27.016 INFO 25180 --- [nio-8080-exec-1] c.g.xuejike.springaop.aop.LogAdvice : 调用结束:com.github.xuejike.springaop.service.impl.HomeServiceImpl->getHomeInfo
JDK动态代理原理
手动实现动态代理
- 创建动态代理类JDKDynamicProxy
public class JDKDynamicProxy implements InvocationHandler {
Logger logger = LoggerFactory.getLogger(JDKDynamicProxy.class);
//代理的目标对象
protected Object target;
public JDKDynamicProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
logger.info("调用之前:->{}->{}",target.getClass().getName(),method.getName());
//调用方法
Object result = method.invoke(target, args);
logger.info("调用之后");
return result;
}
public <T>T getProxy(Class<T> interfaceCls){
//根据接口创建代理类
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), new Class[]{interfaceCls}, this);
}
}
2.使用动态代理并导出代理类class文件
public static void main(String[] args) {
//输出自动生成的代理对象
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
HomeServiceImpl homeService = new HomeServiceImpl();
JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy(homeService);
//指定接口生成代理对象
HomeService proxy = jdkDynamicProxy.getProxy(HomeService.class);
String homeInfo = proxy.getHomeInfo();
}
18:15:24.744 [main] INFO com.github.xuejike.springaop.aop.JDKDynamicProxy - 调用之前:->com.github.xuejike.springaop.service.impl.HomeServiceImpl->getHomeInfo
18:15:24.749 [main] INFO com.github.xuejike.springaop.aop.JDKDynamicProxy - 调用之后
源码分析
通过查看jdk生成的代理类，我们可以看到代理类源码和执行过程。
public final class $Proxy0 extends Proxy implements HomeService {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
//通过构造函数，传入动态代理处理的对象JDKDynamicProxy
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});
} 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 String getHomeInfo() throws {
try {
//调用JDKDynamicProxy的invoke方法，并传入当前代理对象，被调用方法对象，参数
return (String)super.h.invoke(this, m3, (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);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
//通过反射获取到，被代理的Method对象
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.github.xuejike.springaop.service.HomeService").getMethod("getHomeInfo");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
生成代理对象的过程分析
1.获取并创建代理对象
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);
}
//生成代理class并加载
Class<?> cl = getProxyClass0(loader, intfs);
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;
}
});
}
//通过构造方法生成对象，并将JDKDynamicProxy作为参数传入
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);
}
}
2.生成代理对象的Class文件
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//一次性生成代理接口不能超过65535
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//通过缓存获取Class类
return proxyClassCache.get(loader, interfaces);
}
3.生成Class文件并加载到虚拟机
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 {
//加载代理接口的Class
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/* * 检查接口，只能代理接口 */
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;
/* * 生成Class文件的字节 */
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//加载Class文件字节
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());
}
}
}
CGLib动态代理原理
手动实现动态代理
public class CglibDynamicProxy implements MethodInterceptor {
Logger logger = LoggerFactory.getLogger(JDKDynamicProxy.class);
/** * 业务类对象 */
private Object target;
public <T> T getInstance(T target){
this.target = target;
//创建加强器，用来创建动态代理类
Enhancer enhancer = new Enhancer();
//为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
enhancer.setSuperclass(target.getClass());
//设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
enhancer.setCallback(this);
// 创建动态代理类对象并返回
return (T) enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
logger.info("调用之前:->{}->{}",target.getClass().getName(),method.getName());
//调用业务类（父类中）的方法
Object result = methodProxy.invokeSuper(o, args);
System.out.println("调用后操作—");
return result;
}
}
运行并生成代理文件
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\class");
HomeServiceImpl homeService = new HomeServiceImpl();
CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy();
HomeServiceImpl proxyInstance = cglibDynamicProxy.getInstance(homeService);
proxyInstance.getHomeInfo();
运行日志
CGLIB debugging enabled, writing to 'D:\class'
10:29:53.836 [main] INFO com.github.xuejike.springaop.aop.JDKDynamicProxy - 调用之前:->com.github.xuejike.springaop.service.impl.HomeServiceImpl->getHomeInfo
调用后操作——————
源码分析
1.在D://class中找到生成的class文件并使用反编译工具进行反编译。
//通过继承目标类，并生成代理对象
public class HomeServiceImpl$$EnhancerByCGLIB$$268c2282 extends HomeServiceImpl 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 Object CGLIB$CALLBACK_FILTER;
private static final Method CGLIB$getHomeInfo$0$Method;
private static final MethodProxy CGLIB$getHomeInfo$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("com.github.xuejike.springaop.service.impl.HomeServiceImpl$$EnhancerByCGLIB$$268c2282");
Class var1;
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");
CGLIB$getHomeInfo$0$Method = ReflectUtils.findMethods(new String[]{"getHomeInfo", "()Ljava/lang/String;"}, (var1 = Class.forName("com.github.xuejike.springaop.service.impl.HomeServiceImpl")).getDeclaredMethods())[0];
CGLIB$getHomeInfo$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "getHomeInfo", "CGLIB$getHomeInfo$0");
}
final String CGLIB$getHomeInfo$0() {
return super.getHomeInfo();
}
public final String getHomeInfo() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
//拦截器为空，则绑定拦截器
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
//拦截器为空，则调用父类，不为空则调用拦截器。
return var10000 != null ? (String)var10000.intercept(this, CGLIB$getHomeInfo$0$Method, CGLIB$emptyArgs, CGLIB$getHomeInfo$0$Proxy) : super.getHomeInfo();
}
static {
CGLIB$STATICHOOK1();
}
}
在调用代理接口的intercept方法时，我们会调用methodProxy.invokeSuper 方法，来执行代理目标的函数。
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
init();
FastClassInfo fci = fastClassInfo;
//通过fastClass调用其invoke方法来执行目标函数
return fci.f2.invoke(fci.i2, obj, args);
}
catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
通过反编译自动生成的FastClass文件可以看到是直接调用的方法。
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
HomeServiceImpl var10000 = (HomeServiceImpl)var2;
int var10001 = var1;
try {
switch(var10001) {
case 0:
//直接调用目标函数
return var10000.getHomeInfo();
case 1:
return new Boolean(var10000.equals(var3[0]));
case 2:
return var10000.toString();
case 3:
return new Integer(var10000.hashCode());
}
} catch (Throwable var4) {
throw new InvocationTargetException(var4);
}
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
