SpringAOP之底层原理
参考：https://www.jianshu.com/p/8ccdbe00ff06
我的个人博客：https://machine4869.gitee.io/
AOP概述
- aop：面向切面（方面）编程，扩展功能不修改源代码实现
- AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
- aop底层使用动态代理实现
AOP演变过程图解
AOP相关术语
- Joinpoint(连接点): 类里面可以被增强的方法，这些方法称为连接点
- Pointcut(切入点): 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
- Advice(通知/增强):所谓通知是指拦截到Joinpoint之后**所要做的事情**就是通知.通知分为前置通知,后置通知,异常通知,最终通知（在后置通知之后执行）,环绕通知(切面要完成的功能)
- Aspect(切面): 是切入点和通知（引介）的结合
- Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类**动态地添加**一些方法或Field.
- Target(目标对象):代理的目标对象(要增强的类)
- Weaving(织入):是把增强应用到目标的过程. 把advice 应用到 target的过程
- Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
java代理：JDK静态代理，JDK动态代理、CGLIB动态代理
JDK-静态代理
- 不改变目标对象的前提下，实现了对目标对象的功能扩展
- 缺点：代理对象要实现接口所有方法，一旦接口增加方法，代理对象和目标对象都要进行相应的修改，增加维护成本。
demo
接口
package com.mxx.proxy;
public interface AdminService {
/**
* 更新
*/
void update();
/**
* 查找
* @return
*/
Admin find();
}
实现类
package com.mxx.proxy;
public class AdminServiceImpl implements AdminService {
@Override
public void update() {
System.out.println("目标对象-执行更新操作");
}
@Override
public Admin find() {
System.out.println("目标对象-执行find操作");
return new Admin("小王",18);
}
}
代理类
package com.mxx.proxy;
public class AdminServiceProxy implements AdminService {
private AdminService adminService;
public AdminServiceProxy(AdminService adminService) {
this.adminService = adminService;
}
@Override
public void update() {
System.out.println("代理对象-判断是否有权限update");
adminService.update();
System.out.println("代理对象-记录日志（用户信息、修改时间...）");
}
@Override
public Admin find() {
System.out.println("代理对象-判断是否有权限update");
Admin admin = adminService.find();
// 修改
admin.setAge(19);
return admin;
}
}
测试
package com.mxx.proxy;
public class ProxyTest {
public static void main(String[] args) {
AdminService adminService = new AdminServiceImpl();
AdminServiceProxy adminServiceProxy = new AdminServiceProxy(adminService);
adminServiceProxy.update();
System.out.println("----------------------");
adminServiceProxy.find();
}
}
结果
代理对象-判断是否有权限update
目标对象-执行更新操作
代理对象-记录日志（用户信息、修改时间...）
----------------------
代理对象-判断是否有权限update
目标对象-执行find操作
JDK-动态代理
Java反射机制与动态代理
- 一句话，反射机制就是动态加载对象，即可以加载一个运行时才得知名称的 class，获得其完整结构（该class在编译期间不存在）。
- jdk动态代理是基于java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler两个类来完问成的，使用了JAVA反射机制。
jdk动态代理
- jdk动态代理，解决静态代理对象必须实现接口的所有方法的问题，动态代理对象不用继承target对象接口
- 要求target对象是一个接口的实现对象
- 使用java.lang.reflect.Proxy，在JVM内存中动态的构建Proxy对象
demo
动态代理类
package com.mxx.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class AdminServiceDynamicProxy {
public static AdminService getProxy(AdminService adminService){
// ClassLoader loader：指定当前target对象使用类加载器
// Class<?>[] interfaces：target对象实现的接口的类型
// InvocationHandler invocationHandler: 执行target对象的方法时，会触发事件处理器的方法，会把当前执行target对象的方法作为参数传入。
AdminService proxy = (AdminService)Proxy.newProxyInstance(
adminService.getClass().getClassLoader(),
adminService.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 当代理对象调用方法时，会触发invoke方法进行增强
* @param proxy
* @param method 被增强的方法
* @param args
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理方法-权限判断");
// 对特定方法增强
if("find".equals(method.getName())){
// 让方法执行，返回值为方法返回类型
Admin admin = (Admin)method.invoke(adminService, args);
admin.setAge(19);
System.out.println("代理方法：修改admin年龄 "+admin.getAge());
return admin;
}else {
Object object = method.invoke(adminService, args);
System.out.println("代理方法-记录日志");
return object;
}
}
});
return proxy;
}
}
测试
@Test
public void testDynamicProxy(){
// target对象
AdminService adminService = new AdminServiceImpl();
// proxy对象
AdminService proxy = AdminServiceDynamicProxy.getProxy(adminService);
// proxy调用方法
proxy.update();
System.out.println("-------------------");
Admin admin = proxy.find();
}
结果
代理方法-权限判断
目标方法-执行更新操作
代理方法-记录日志
-------------------
代理方法-权限判断
目标方法-执行find操作
代理方法：修改admin年龄 19
cglib-动态代理
为什么需要cglib?
JDK动态代理要求target对象是一个接口的实现对象，假如target对象只是一个单独的对象，并没有实现任何接口，会报错：
// BookServiceImpl没有实现接口，使用jdk自带的动态代理方式会报错
java.lang.ClassCastException: com.sun.proxy.$Proxy4 cannot be cast to com.mxx.proxy.BookServiceImpl
这时候就会用到Cglib代理(Code Generation Library)，即通过构建一个子类对象，从而实现对target对象的代理，因此目标对象不能是final类(报错)，且目标对象的方法不能是final或static（不执行代理功能）。
demo
pom
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
target对象
// 没有实现接口
public class BookServiceImpl {
public void update(){
System.out.println("目标方法：update操作");
}
}
cglib代理对象
package com.mxx.proxy;
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 BookServiceCglibProxy {
public static BookServiceImpl getProxy(BookServiceImpl bookService){
Enhancer enhancer = new Enhancer();
// 设置要增强的父类
enhancer.setSuperclass(BookServiceImpl.class);
// 设置回调函数
enhancer.setCallback(new MethodInterceptor() {
// 代理对象的任意方法执行，回调函数就会执行
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
Object object = method.invoke(bookService);
System.out.println("代理方法-增强");
return object;
}
});
// 将代理（子类）强转为父类返回
return (BookServiceImpl)enhancer.create();
}
}
测试
@Test
public void testCglibProxy(){
// target对象
BookServiceImpl bookServiceImpl = new BookServiceImpl();
// proxy对象
BookServiceImpl proxy = BookServiceCglibProxy.getProxy(bookServiceImpl);
// proxy调用方法
proxy.update();
}
结果
目标方法：update操作
代理方法-增强
区别：静态代理和动态代理
- 静态代理：代理类.class在编译期间就存在，代理类通过实现target接口的所有方法，进行增强。
- 动态代理：运行时创建，基于反射机制。
区别：jdk动态代理和cglib代理
- jdk自带：JDK动态代理只能对实现了接口的target类生成代理，而不能针对类。
- CGLIB是针对类实现代理，主要是对指定的类生成一个子类，并覆盖其中方法实现增强，所以对于final类或方法，是无法继承的。
Spring AOP如何选用动态代理？
- 当Bean实现接口时，Spring就会用JDK动态代理实现AOP。
- 当Bean没有实现接口时，Spring使用CGlib动态代理实现AOP。
- 可以配置强制使用CGlib。
扫一扫
271
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
