Python 官方文档:入门教程 => 点击学习
目录1. 面向切面编程2. aop核心概念3. AOP的实现4. spring 对AOP支持4.1 支持@Aspect4.2 声明一个切面4.3 声明一个切入点4.4 声明增强5.
AOP通过提供另一种思考程序结构的方式来补充了面向对象编程(OOP)。OOP中模块化的基本单元是类(class),而AOP中模块化的基本单元是切面(aspect)。可以这么理解,OOP是解决了纵向的代码复用问题,AOP是解决了横向的代码复用问题。
Spring的关键组件之一是AOP框架。虽然Spring ioc容器不依赖于AOP,意味着如果你不想使用AOP,则可以不使用AOP,但AOP补充了Spring ioC以提供一个非常强大的中间件解决方案。
Spring AOP包括以下类型的增强:
AOP的两种实现方式:静态织入(以AspectJ为代表)和动态代理(Spring AOP实现)
AspectJ是一个采用Java实现的AOP框架,它能够对代码进行编译(在编译期进行),让代码具有AspectJ的AOP功能,当然它也可支持动态代理的方式;
Spring AOP实现:通过动态代理技术来实现,Spring2.0集成了AspectJ,主要用于PointCut的解析和匹配,底层的技术还是使用的Spring1.x中的动态代理来实现。
Spring AOP采用了两种混合的实现方式:JDK动态代理和CGLib动态代理。
JDK动态代理:Spring AOP的首选方法。每当目标对象实现一个接口时,就会使用JDK动态代理。目标对象必须实现接口。
CGLIB:如果目标对象没有实现接口,则可以使用CGLIB代理。
Spring可以使用两种方式来实现AOP:基于注解式配置和基于XML配置
下面介绍基于注解配置的形式
如果是Spring Framework,需要使用aspectjweaver.jar包,然后创建我们自己的AppConfig,如下,并加上@EnableAspectJAutoProxy注解开启AOP代理自动配置(Spring Boot默认是开启的,则不需要增加配置),
如下:
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}
@Aspect //告诉Spring 这是一个切面
@Component //交给Spring容器管理
public class MyAspect {
}
可以使用@Aspect来定义一个类作为切面,但是这样,该类并不会自动被Spring加载,还是需要加上@Component注解
一个切入点的生命包含两个部分:一个包含名称和任何参数的签名和一个切入点的表达式,这个表达式确定了我们对哪些方法的执行感兴趣。
我们以拦截Controller层中的MyController中的test方法为例子,代码如下:
@RestController
@RequestMapping("/my")
public class MyController {
@GetMapping("/test")
public void test() {
System.out.println("test 方法");
}
}
下面定义一个名为controller的切入点,该切入点与上述的test方法相匹配,切入点需要用@Pointcut注解来标注,如下:
//表达式
@Pointcut("execution (public * com.yc.SpringBoot.controller.MyController.test())")
public void controller(){}; //签名
切入点表达式的格式如下:
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
execution(方法修饰符(可选) 返回类型 类路径 方法名 参数 异常模式(可选))
AspectJ描述符如下:
AspectJ描述符 | 描述 |
arg() | 限制连接点匹配参数为指定类型的执行方法 |
@args() | 限制连接点匹配参数由指定注解标注的执行方法 |
execution() | 用于匹配是连接点的执行方法 |
this() | 限制连接点匹配的AOP代理的bean引用为指定类型的类 |
target | 限制连接点匹配目标对象为指定类型的类 |
@target() | 限制连接点匹配特定的执行对象,这些对象对应的类要具有指定类型的注解 |
within() | 限制连接点匹配指定的类型 |
@within() | 限制连接点匹配指定注解所标注的类型 |
@annotationn | 限定匹配带有指定注解的连接点 |
常用的主要是:execution()
AspectJ类型匹配的通配符:
within() | 限制连接点匹配指定的类型 |
@within() | 限制连接点匹配指定注解所标注的类型 |
@annotationn | 限定匹配带有指定注解的连接点 |
常用的匹配规则:
表达式 | 内容 |
execution(public * *(..)) | 匹配所有public方法 |
execution(* set*(..)) | 匹配所有方法名开头为set的方法 |
execution(* com.xyz.service.AccountService.*(..)) | 匹配AccountService下的所有方 |
execution(* com.xyz.service.*.*(..)) | 匹配service包下的所有方法 |
execution(* com.xyz.service..*.*(..)) | 匹配service包或其子包下的所有方法 |
@annotation(org.springframework.transaction.annotation.Transactional) | 匹配所有打了@Transactional注解的方法 |
bean(*Service) | 匹配命名后缀为Service的类的方法 |
增强与切点表达式相关联,并且在与切点匹配的方法之前、之后或者前后执行。
在3当中已经对各类增强做了绍,这里就不详细展开了,下面直接罗列了各种增强的声明,用于拦截MyController中的各个方法
@Aspect //告诉Spring 这是一个切面
@Component //告诉Spring容器需要管理该对象
public class MyAspect {
//通过规则确定哪些方法是需要增强的
@Pointcut("execution (public * com.yc.springboot.controller.MyController.*(..))")
public void controller() {
}
//前置增强
@Before("controller()")
public void before(JoinPoint joinPoint) {
System.out.println("before advice");
}
//返回增强
@AfterReturning(
pointcut = "controller()",
returning = "retVal"
)
public void afterReturning(Object retVal) {
System.out.println("after returning advice, 返回结果 retVal:" + retVal);
}
//异常增强
@AfterThrowing(
pointcut = "controller()",
throwing = "ex"
)
public void afterThrowing(Exception ex) {
System.out.println("after throwing advice, 异常 ex:" + ex.getMessage());
}
//后置增强
@After("controller()")
public void after(JoinPoint joinPoint) {
System.out.println("after advice");
}
//环绕增强
@Around("controller()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("before advice");
//相当于是before advice
Object reVal = null;
try {
reVal = joinPoint.proceed();
} catch (Exception e) {
//相当于afterthrowing advice
System.out.println("afterthrowing advice");
}
//相当于是after advice
System.out.println("after advice");
return reVal;
}
}
需要注意的是:
下面为Mycontroller测试类:
@RestController
@RequestMapping("/my")
public class MyController {
@GetMapping("/testBefore")
public void testBefore() {
System.out.println("testBefore 业务方法");
}
@GetMapping("/testAfterReturning")
public String testAfterReturning() {
System.out.println("testAfterReturning 业务方法");
return "我是一个返回值";
}
@GetMapping("/testAfterThrowing")
public void testAfterThrowing() {
System.out.println("testAfterThrowing 业务方法");
int a = 0;
int b = 1 / a;
}
@GetMapping("/testAfter")
public void testAfter() {
System.out.println("testAfter 业务方法");
}
@GetMapping("/around")
public void around() {
System.out.println("around 业务方法");
}
}
打印日志是AOP的一个常见应用场景,我们可以对Controller层向外提供的接口做统一的日志拦截,用日志记录请求参数、返回参数、请求时长以及异常信息,方便我们线上排查问题,下面是核心类LogAspect的实现
@Aspect
@Component
public class LogAspect {
@Resource
private IdWorker idWorker;
@Pointcut("execution (public * com.yc.core.controller.*.*(..))")
public void log(){}
@Around("log()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
//获得执行方法的类和名称
String className = joinPoint.getTarget().getClass().getName();
//获得方法名
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
String methodName = signature.getMethod().getName();
//获得参数
Object[] args = joinPoint.getArgs();
long requestId = idWorker.nextId();
//打印参数
LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.tojsONString(args));
long startTime = System.currentTimeMillis();
//执行业务方法
Object result = null;
try {
result = joinPoint.proceed();
} catch (Exception e) {
LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦:" + LogAspect.getStackTrace(e));
}
long endTime = System.currentTimeMillis();
//打印结果
LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时:" + (endTime - startTime) + "ms,result:" + JSONObject.toJSONString(result));
//返回
return result;
}
public static String getStackTrace(Throwable throwable)
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
try
{
throwable.printStackTrace(pw);
return sw.toString();
} finally
{
pw.close();
}
}
}
但是上面的日志是针对所有controller层中的方法进行了日志拦截,如果我们有些方法不想进行日志输出,比如文件上传的接口、大量数据返回的接口,这个时候定义切入点的时候可以使用@annotation描述符来匹配加了特定注解的方法,步骤如下:
1. 先定义一个日志注解Log
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}
2.用@annotation定义切入点
@Pointcut("@annotation(com.yc.core.annotation.Log)")
public void logAnnotation(){}
3.在想做日志输出的方法上使用注解Log
@Log
@PostMapping(value = "testannotation")
public AOPTestVO testannotation(@RequestBody AOPTestDTO aopTestDTO) {
AOPTestVO aopTestVO = new AOPTestVO();
aopTestVO.setCode(1);
aopTestVO.setMsg("哈哈哈");
return aopTestVO;
}
这样,我们就可以自定义哪些方法需要日志输出了
后来有同事提到,如果这是针对Controller层的拦截,但是Service层也有自定义的日志输出,怎么在Service层获取到上述的requestId呢?
其实就是我们拦截之后,是否可以针对方法的参数进行修改呢?其实注意是看
result = joinPoint.proceed();
我们发现ProceedingJoinPoint还有另外一个带有参数的proceed方法,定义如下:
public Object proceed(Object[] args) throws Throwable;
我们可以利用这个方法,在环绕增强中去增加requestId,这样后面的增强方法或业务方法中就能获取到这个requestId了。
首先,我们先定义一个基类AOPBaseDTO,只有一个属性requestId
@Data
@apiModel("aop参数基类")
public class AOPBaseDTO {
@ApiModelProperty(value = "请求id", hidden = true)
private long requestId;
}
然后我们让Controller层接口的参数AOPTestDTO继承上述AOPBaseDTO,如下:
@Data
@ApiModel("aop测试类")
public class AOPTestDTO extends AOPBaseDTO{
@ApiModelProperty(value = "姓名")
private String name;
@ApiModelProperty(value = "年龄")
private int age;
}
最后在环绕的增强中添加上requestId,如下:
@Around("logAnnotation()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
//获得执行方法的类和名称
String className = joinPoint.getTarget().getClass().getName();
//获得方法名
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
String methodName = signature.getMethod().getName();
//获得参数
Object[] args = joinPoint.getArgs();
long requestId = idWorker.nextId();
for(int i = 0; i < args.length; i++) {
if (args[i] instanceof AOPBaseDTO) {
//增加requestId
((AOPBaseDTO) args[i]).setRequestId(requestId);
}
}
//打印参数
LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.toJSONString(args));
long startTime = System.currentTimeMillis();
//执行业务方法
Object result = null;
try {
result = joinPoint.proceed(args);
} catch (Exception e) {
LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦:" + LogAspect.getStackTrace(e));
}
long endTime = System.currentTimeMillis();
//打印结果
LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时:" + (endTime - startTime) + "ms,result:" + JSONObject.toJSONString(result));
//返回
return result;
}
我们运行起代码,访问一下,下面是运行结果:
可以看到,我们的业务方法中已经能获取到requestId,如果Service层需要,可以通过传递AOPTestDTO,从中获取。
到此这篇关于Spring面向切面编程AOP详情的文章就介绍到这了,更多相关Spring面向切面编程内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!
--结束END--
本文标题: Spring面向切面编程AOP详情
本文链接: https://www.lsjlt.com/news/168271.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑,方便收藏和打印~
2024-03-01
2024-03-01
2024-03-01
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
0