AOP介绍
AOP(Aspect Oriented Programming):⾯向切⾯编程,它是⼀种思想,它是对某⼀类事情的集中处理。⽐如⽤户登录权限的效验,没学 AOP 之前,我们所有需要判断⽤户登录的⻚⾯(中的⽅法),都要各⾃实现或调⽤⽤户验证的⽅法,然⽽有了 AOP 之后,我们只需要在某⼀处配置⼀下,所有需要判断⽤户登录⻚⾯(中的⽅法)就全部可以实现⽤户登录验证了,不再需要每个⽅法中都写相同的⽤户登录验证了。
⽽ AOP 是⼀种思想,⽽ Spring AOP 是⼀个框架,提供了⼀种对 AOP 思想的实现,它们的关系和IoC 与 DI 类似.
想象⼀个场景,我们在做后台系统时,除了登录和注册等⼏个功能不需要做⽤户登录验证之外,其他⼏乎所有⻚⾯调⽤的前端控制器( Controller)都需要先验证⽤户登录的状态,那这个时候我们要怎么处理呢?
我们的处理⽅式是每个 Controller 都要写⼀遍⽤户登录验证,然⽽当你的功能越来越多,那么你要写的登录验证也越来越多,⽽这些⽅法⼜是相同的,这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢?答案是有的,对于这种功能统⼀,且使⽤的地⽅较多的功能,就可以考虑 AOP来统⼀处理了。
除了统⼀的⽤户登录判断之外,AOP 还可以实现:
也就是说使⽤ AOP 可以扩充多个对象的某个能⼒,所以 AOP 可以说是 OOP(Object Oriented Programming,⾯向对象编程)的补充和完善。
Spring AOP 学习主要分为以下 3 个部分:
切⾯由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包括了连接点的定义。
切⾯是包含了:通知、切点和切⾯的类,相当于 AOP 实现的某个功能的集合
应⽤执⾏过程中能够插⼊切⾯的⼀个点,这个点可以是⽅法调⽤时,抛出异常时,甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中,并添加新的⾏为。
连接点相当于需要被增强的某个 AOP 功能的所有⽅法
Pointcut 是匹配 Join Point 的谓词。
Pointcut 的作⽤就是提供⼀组规则(使⽤ AspectJ pointcut expression language 来描述)来匹配 Join Point,给满⾜规则的 Join Point 添加 Advice。
切点相当于保存了众多连接点的⼀个集合(如果把切点看成⼀个表,⽽连接点就是表中⼀条⼀条的数据)
切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中,切⾯的⼯作被称之为通知。
通知:定义了切⾯是什么,何时使⽤,其描述了切⾯要完成的⼯作,还解决何时执⾏这个⼯作的问题。
Spring 切⾯类中,可以在⽅法上使⽤以下注解,会设置⽅法为通知⽅法,在满⾜条件后会通知本⽅法进⾏调⽤:
Spring AOP 来实现⼀下 AOP 的功能,完成的⽬标是拦截所有 UserController ⾥⾯的⽅法,每次调⽤ UserController 中任意⼀个⽅法时,都执⾏相应的通知事件。
Spring AOP 的实现步骤如下:
添加 AOP 框架⽀持 ,在 pom.xml 中添加如下配置:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
定义切⾯和切点
切点指的是具体要处理的某⼀类问题,⽐如⽤户登录权限验证就是⼀个具体的问题,记录所有⽅法的执⾏⽇志就是⼀个具体的问题,切点定义的是某⼀类问题。
Spring AOP 切点的定义如下,在切点中我们要定义拦截的规则,具体实现如下
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Slf4j
//@Component //演示统一功能, 暂时先去掉
@Aspect //定义了一个切面
public class LoginAspect {
@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
public void pointcut(){ }
}
其中 pointcut ⽅法为空⽅法,它不需要有⽅法体,此⽅法名就是起到⼀个“标识”的作⽤,标识下⾯的通知⽅法具体指的是哪个切点(因为切点可能有很多个)
AspectJ ⽀持三种通配符
execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)
execution(* com.cad.demo.User.(…)) :匹配 User 类⾥的所有⽅法。
execution( com.cad.demo.User+.(…)) :匹配该类的⼦类包括该类的所有法。
execution( com.cad..(…)) :匹配 com.cad 包下的所有类的所有⽅法。
execution(* com.cad….(…)) :匹配 com.cad 包下、⼦孙包下所有类的所有法。
execution(* addUser(String, int)) :匹配 addUser ⽅法,且第⼀个参数类型是 String,第⼆个参数类型是 int。
3. 定义通知
@Slf4j
//@Component //演示统一功能, 暂时先去掉
@Aspect //定义了一个切面
public class LoginAspect {
@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
public void pointcut(){ }
@Before("pointcut()")
public void doBefore(){
log.info("do before....");
}
@After("pointcut()")
public void doAfter(){
log.info("do after...");
}
@AfterReturning("pointcut()")
public void doAfterReturning(){
log.info("do after returning...");
}
@AfterThrowing("pointcut()")
public void doAfterThrowing(){
log.info("do after throwing");
}
// @Around("pointcut()")
// public Object doAround(ProceedingJoinPoint joinPoint){
// Object oj = null;
// log.info("环绕通知执行之前...");
// log.info(joinPoint.getSignature().toLongString());
// try {
// oj = joinPoint.proceed();//调用目标方法
// } catch (Throwable e) {
// throw new RuntimeException(e);
// }
// log.info("环绕通知执行之后....");
// return oj;
// }
/**
* 使用 AOP 统计 UserController 每个方法的执行时间。
* @param joinPoint 连接点
* @return
*/
@Around("pointcut()")
public Object doAround(ProceedingJoinPoint joinPoint){
Object oj = null;
long start = System.currentTimeMillis();
try {
oj = joinPoint.proceed();//调用目标方法
} catch (Throwable e) {
throw new RuntimeException(e);
}
log.info(joinPoint.getSignature().toString()+"耗时:"+(System.currentTimeMillis()-start));
return oj;
}
@Before("execution(* com.example.demo.controller.TestController.*(..))")
public void before2(){
log.info("before2....");
}
}
Spring AOP 是构建在动态代理基础上,因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截。
Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下,实现了接⼝的类,使⽤ AOP 会基于 JDK ⽣成代理类,没有实现接⼝的类,会基于 CGLIB ⽣成代理类
织⼊(Weaving):代理的⽣成时机
织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程,切⾯在指定的连接点被织⼊到⽬标对象中.
在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊:
编译期:切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的。
类加载期:切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器
(ClassLoader),它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊(load-time weaving. LTW)就⽀持以这种⽅式织⼊切⾯。
运⾏期:切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下,在织⼊切⾯时,AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。
此种实现在设计模式上称为动态代理模式,在实现的技术⼿段上,都是在 class 代码运⾏期,动态的织⼊字节码。
我们学习 Spring 框架中的AOP,主要基于两种⽅式:JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法,在运⾏期,动态的织⼊字节码⽣成代理类。
定义:为其他对象提供⼀种代理以控制对这个对象的访问。在某些情况下,⼀个对 象不适合或者不能直接引⽤另⼀个对象,⽽代理对象可以在客户端和⽬标对象之间起到中介的作⽤。
代理模式分为静态代理和动态代理
静态代理中,我们对⽬标对象的每个⽅法的增强都是⼿动完成的,⾮常不灵活(⽐如接⼝⼀旦新增加⽅法,⽬标对象和代理对象都要进⾏修改)且麻烦(需要对每个⽬标类都单独写⼀个代理类)。 实际应⽤场景⾮常⾮常少,⽇常开发⼏乎看不到使⽤静态代理的场景。
上⾯我们是从实现和应⽤⻆度来说的静态代理,从 JVM 层⾯来说, 静态代理在编译时就将接⼝、实现类、代理类这些都变成了⼀个个实际的 class ⽂件。
静态代理实现步骤:
public interface PayService {
void pay();
}
public class AliPayService implements PayService{
@Override
public void pay() {
System.out.println("ali pay....");
}
}
public class StaticProxy implements PayService{
private final PayService payService;
public StaticProxy(PayService payService) {
this.payService = payService;
}
@Override
public void pay() {
System.out.println("before...");
payService.pay();
System.out.println("after...");
}
}
public static void main(String[] args) {
PayService service = new AliPayService();
PayService proxy = new StaticProxy(service);
proxy.pay();
}
相⽐于静态代理来说,动态代理更加灵活。我们不需要针对每个⽬标类都单独创建⼀个代理类,并且也不需要我们必须实现接⼝,我们可以直接代理实现类( CGLIB 动态代理机制)。
从 JVM ⻆度来说,动态代理是在运⾏时动态⽣成类字节码,并加载到 JVM 中的。
说到动态代理,不得不提的是Spring AOP,它的实现依赖了动态代理。动态代理在我们⽇常开发中使⽤的相对较少,但是在框架中的⼏乎是必⽤的⼀⻔技术。学会了动态代理之后,对于我们理解和学习各种框架的原理也⾮常有帮助。
就 Java 来说,动态代理的实现⽅式有很多种,⽐如 JDK 动态代理、CGLIB 动态代理等等。
public class JDKInvocationHandler implements InvocationHandler {
//目标对象即就是被代理对象
private Object target;
public JDKInvocationHandler(Object target) {
this.target = target;
}
//proxy代理对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//1.安全检查
System.out.println("安全检查");
//2.记录日志
System.out.println("记录日志");
//3.时间统计开始
System.out.println("记录开始时间");
//通过反射调用被代理类的方法
Object retVal = method.invoke(target, args);
//4.时间统计结束
System.out.println("记录结束时间");
return retVal;
}
}
public static void main(String[] args) {
PayService target= new AliPayService();
//创建一个代理类:通过被代理类、被代理实现的接口、方法调用处理器来创建
PayService proxy = (PayService) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
new Class[]{PayService.class},
new JDKInvocationHandler(target)
);
proxy.pay();
}
public class CGLIBInterceptor implements MethodInterceptor {
//被代理对象
private Object target;
public CGLIBInterceptor(Object target){
this.target = target;
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//1.安全检查
System.out.println("安全检查");
//2.记录日志
System.out.println("记录日志");
//3.时间统计开始
System.out.println("记录开始时间");
//通过cglib的代理方法调用
Object retVal = methodProxy.invoke(target, args);
//4.时间统计结束
System.out.println("记录结束时间");
return retVal;
}
}
public static void main(String[] args) {
PayService target= new AliPayService();//目标对象
PayService proxy= (PayService) Enhancer.create(target.getClass(),new CGLIBInterceptor(target));//创建代理对象
proxy.pay();
}