Spring AOP切面使用详细解析
相关文章：
SpringBoot AOP切面的使用
一步一步手绘Spring AOP运行时序图（Spring AOP 源码分析）
架构师系列内容：架构师学习笔记（持续更新））
Spring AOP 应用场景
AOP 是 OOP 的延续，是 Aspect Oriented Programming 的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP 可以说也是这种目标的一种实现。我们现在做的一些非业务，如：日志、事务、安全等都会写在业务代码中(也即是说，这些非业务类横切于业务类)，但这些代码往往是重复，复制——粘贴式的代码会给程序的维护带来不便，AOP 就实现了把这些业务需求与系统需求分开来做。这种解决的方式也称代理机制。
AOP 中必须明白的几个概念
切面（Aspect）
官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。“切面”在ApplicationContext 中
连接点（Joinpoint） ：程序执行过程中的某一行为，例如，MemberService .get 的调用或者MemberService .delete 抛出异常等行为。
通知（Advice）
“切面”对于某个“连接点”所产生的动作。其中，一个“切面”可以包含多个“Advice”。
切入点（Pointcut）
匹配连接点的断言，在 AOP 中通知和一个切入点表达式关联。切面中的所有通知所关注的连接点，都由切入点表达式来决定。
目标对象（Target Object）
被一个或者多个切面所通知的对象。例如，AServcieImpl 和 BServiceImpl，当然在实际运行时，SpringAOP 采用代理实现，实际 AOP 操作的是 TargetObject 的代理对象。
AOP 代理（AOP Proxy）
在 Spring AOP 中有两种代理方式，JDK 动态代理和 CGLib 代理。默认情况下，TargetObject 实现了接口时，则采用 JDK 动态代理；反之，采用 CGLib 代理。强制使用 CGLib 代理需要将
通知（Advice）类型：
前置通知（Before Advice）
在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext中在
后置通知（After Advice）
当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext 中在
返回后通知（After Return Advice）
在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext 中在
环绕通知（Around Advice）
包围一个连接点的通知，类似 Web 中 Servlet 规范中的 Filter 的 doFilter 方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext 中在
异常通知（After Throwing Advice）
在方法抛出异常退出时执行的通 知 。 ApplicationContext 中 在
开启AOP方法
使用 Spring AOP 可以基于两种方式，一种是比较方便和强大的注解方式，另一种则是中规中矩的 xml配置方式
注解方式
使用注解配置 Spring AOP 总体分为两步：
第一步是在 xml 文件中声明激活自动扫描组件功能，同时激活自动代理功能（来测试 AOP 的注解功能）：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.jarvisy.demo"/>
<context:annotation-config/>
beans>
配置开启AOP：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<aop:aspectj-autoproxy />
beans>
参数详解：
proxy-target-class 属性，默认为false，表示使用jdk动态代理织入增强，当配为true时，表示使用CGLib动态代理技术织入增强。不过即使设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。
相关源码：
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
/**
* Determine whether the supplied {@link AdvisedSupport} has only the
* {@link org.springframework.aop.SpringProxy} interface specified
* (or no proxy interfaces specified at all).
*/
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
Class<?>[] ifcs = config.getProxiedInterfaces();
return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
}
}
expose-proxy 属性 默认为false 控制代理的暴露方式,解决内部调用不能使用代理的场景。
第二步是为 Aspect 切面类添加注解：
package com.jarvisy.demo.aop;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
//声明这是一个组件
@Component
//声明这是一个切面 Bean
@Aspect
@Slf4j
public class AnnotationAspect {
//配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
@Pointcut("execution(* com.jarvisy.demo.controller.*(..))")
public void aspect() {
}
/*
* 配置前置通知,使用在方法 aspect()上注册的切入点
* 同时接受 JoinPoint 切入点对象,可以没有该参数
*/
@Before("aspect()")
public void before(JoinPoint joinPoint) {
log.info("before 通知 " + joinPoint);
}
//配置后置通知,使用在方法 aspect()上注册的切入点
@After("aspect()")
public void after(JoinPoint joinPoint) {
log.info("after 通知 " + joinPoint);
}
//配置环绕通知,使用在方法 aspect()上注册的切入点
@Around("aspect()")
public void around(JoinPoint joinPoint) {
long start = System.currentTimeMillis();
try {
((ProceedingJoinPoint) joinPoint).proceed();
long end = System.currentTimeMillis();
log.info("around 通知 " + joinPoint + "\tUse time : " + (end - start) + " ms!");
} catch (Throwable e) {
long end = System.currentTimeMillis();
log.info("around 通知 " + joinPoint + "\tUse time : " + (end - start) + " ms with exception : " + e.getMessage());
}
}
//配置后置返回通知,使用在方法 aspect()上注册的切入点
@AfterReturning("aspect()")
public void afterReturn(JoinPoint joinPoint) {
log.info("afterReturn 通知 " + joinPoint);
}
//配置抛出异常后通知,使用在方法 aspect()上注册的切入点
@AfterThrowing(pointcut = "aspect()", throwing = "ex")
public void afterThrow(JoinPoint joinPoint, Exception ex) {
log.info("afterThrow 通知 " + joinPoint + "\t" + ex.getMessage());
}
}
测试代码：
添加相关测试的类
package com.jarvisy.demo.aop.service;
import com.jarvisy.demo.aop.Member;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* 业务操作类
*/
@Slf4j
@Service
public class MemberService {
public Member get(long id) {
log.info("getMemberById method . . .");
return new Member();
}
public Member get() {
log.info("getMember method . . .");
return new Member();
}
public void save(Member member) {
log.info("save member method . . .");
}
public boolean delete(long id) throws Exception {
log.info("delete method . . .");
throw new Exception("spring aop ThrowAdvice演示");
}
}
package com.jarvisy.demo.aop;
public class Member {
}
package com.jarvisy.demo.aop;
import com.jarvisy.demo.aop.service.MemberService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@ContextConfiguration(locations = {"classpath*:application-context.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
public class AnnotationTest {
@Autowired
MemberService memberService;
/*@Autowired
ApplicationContext app;*/
@Test
// @Ignore
public void test() {
System.out.println("=====这是一条华丽的分割线======");
// AnnotationAspect aspect = app.getBean(AnnotationAspect.class);
// System.out.println(aspect);
memberService.save(new Member());
System.out.println("=====这是一条华丽的分割线======");
try {
memberService.delete(1L);
} catch (Exception e) {
//e.printStackTrace();
}
}
}
运行效果：
可以看到，正如我们预期的那样，虽然我们并没有对 MemberService 类包括其调用方式做任何改变，但是 Spring 仍然拦截到了其中方法的调用，或许这正是 AOP 的魔力所在。
xml 配置方式
xml配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<bean id="xmlAspect" class="com.jarvisy.demo.aop.aspect.XmlAspect">bean>
<aop:config>
<aop:aspect ref="xmlAspect">
<aop:pointcut expression="execution(* com.jarvisy.demo.aop.service..*(..))" id="simplePointcut"/>
<aop:before pointcut-ref="simplePointcut" method="before"/>
<aop:after pointcut-ref="simplePointcut" method="after"/>
<aop:after-returning pointcut-ref="simplePointcut" method="afterReturn"/>
<aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/>
<aop:around pointcut-ref="simplePointcut" method="around"/>
aop:aspect>
aop:config>
beans>
XmlAspect类：
package com.jarvisy.demo.aop.aspect;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
* XML版Aspect切面Bean(理解为TrsactionManager)
*/
@Slf4j
public class XmlAspect {
/*
* 配置前置通知,使用在方法aspect()上注册的切入点
* 同时接受JoinPoint切入点对象,可以没有该参数
*/
public void before(JoinPoint joinPoint) {
// System.out.println(joinPoint.getArgs()); //获取实参列表
// System.out.println(joinPoint.getKind()); //连接点类型，如method-execution
// System.out.println(joinPoint.getSignature()); //获取被调用的切点
// System.out.println(joinPoint.getTarget()); //获取目标对象
// System.out.println(joinPoint.getThis()); //获取this的值
log.info("before " + joinPoint);
}
//配置后置通知,使用在方法aspect()上注册的切入点
public void after(JoinPoint joinPoint) {
log.info("after " + joinPoint);
}
//配置环绕通知,使用在方法aspect()上注册的切入点
public void around(JoinPoint joinPoint) {
long start = System.currentTimeMillis();
try {
((ProceedingJoinPoint) joinPoint).proceed();
long end = System.currentTimeMillis();
log.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms!");
} catch (Throwable e) {
long end = System.currentTimeMillis();
log.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms with exception : " + e.getMessage());
}
}
//配置后置返回通知,使用在方法aspect()上注册的切入点
public void afterReturn(JoinPoint joinPoint) {
log.info("afterReturn " + joinPoint);
}
//配置抛出异常后通知,使用在方法aspect()上注册的切入点
public void afterThrow(JoinPoint joinPoint, Exception ex) {
log.info("afterThrow " + joinPoint + "\t" + ex.getMessage());
}
}
再附上获取参数Aspect切面写法
package com.jarvisy.demo.aop.aspect;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
* 获取参数Aspect切面Bean
*/
//声明这是一个组件
@Component
//声明这是一个切面Bean
//@Aspect
@Slf4j
public class ArgsAspect {
//配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
@Pointcut("execution(* com.jarvisy.demo.aop.service..*(..))")
public void aspect() {
}
//配置前置通知,拦截返回值为com.gupaoedu.vip.model.Member的方法
@Before("execution(com.jarvisy.demo.aop.Member com.jarvisy.demo.aop.service..*(..))")
public void beforeReturnUser(JoinPoint joinPoint) {
log.info("beforeReturnUser " + joinPoint);
}
//配置前置通知,拦截参数为com.gupaoedu.vip.model.Member的方法
@Before("execution(* com.jarvisy.demo.aop.service..*(com.jarvisy.demo.aop.Member))")
public void beforeArgUser(JoinPoint joinPoint) {
log.info("beforeArgUser " + joinPoint);
}
//配置前置通知,拦截含有long类型参数的方法,并将参数值注入到当前方法的形参id中
@Before("aspect()&&args(id)")
public void beforeArgId(JoinPoint joinPoint, long id) {
log.info("beforeArgId " + joinPoint + "\tID:" + id);
}
}
Spring AOP 有两个难点，第一点在于理解 AOP 的理念和相关概念，第二点在于灵活掌握和使用切入点表达式。
切入点表达式的配置规则
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?
//例子
execution(*com.spring.service.*.*(..))
参数含义
modifiers-pattern：方法的操作权限
ret-type-pattern：返回值
declaring-type-pattern：方法所在的包
name-pattern：方法名
parm-pattern：参数名
throws-pattern：异常
其中 ， 除 ret-type-pattern 和 name-pattern 之 外 ， 其 他 都 是 可 选 的 。 上 例 中 ，表示 com.spring.service 包下，返回值为任意类型；方法名任意；参数不作限制的所有方法。
通知参数
可以通过 args 来绑定参数，这样就可以在通知（Advice）中访问具体参数了。例如，
<aop:config>
<aop:aspect ref="xmlAspect">
<aop:pointcut id="simplePointcut"
expression="execution(* com.jarvisy.demo.aop.service..*(..)) and args(msg,..)" />
<aop:after pointcut-ref="simplePointcut" Method="after"/>
aop:aspect>
aop:config>
上面的代码 args(msg,…)是指将切入点方法上的第一个 String 类型参数添加到参数名为 msg 的通知的入参上，这样就可以直接使用该参数啦。
在上面的 Aspect 切面 Bean 中已经看到了，每个通知方法第一个参数都是 JoinPoint。其实，在 Spring中，任何通知（Advice）方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint 类型用以接受当前连接点对象。
JoinPoint 接口提供了一系列有用的方法，
比如 ：
getArgs() （返回方法参数）、
getThis() （返回代理对象）、
getTarget() （返回目标）、
getSignature() （返回正在被通知的方法相关信息）、
toString() （打印出正在被通知的方法的有用信息）