SpringBoot使用AOP(针对注解)

最新推荐文章于 2024-07-16 11:12:33 发布

我用漂亮的押韵形容被掠夺一空的爱情

最新推荐文章于 2024-07-16 11:12:33 发布

阅读量1.6k

点赞数

分类专栏：常用框架文章标签： springBoot aop 功能增强

本文链接：https://blog.csdn.net/weixin_43854141/article/details/101378656

版权

常用框架专栏收录该内容

16 篇文章 0 订阅

订阅专栏

SpringBoot使用AOP(针对注解)

AOP简介

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP是一个概念，并没有设定具体语言的实现，它能克服那些只有单继承特性语言的缺点，spring2.0之后整合AspectJ第三方AOP技术。
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
主要功能:
日志记录、事务处理、性能统计、安全控制、异常处理、缓存处理、持久化操作、资源池等
主要意图
将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码
AOP与OOP区别
OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。
AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。
AOP相关术语
目标对象target

   需要被增强的对象，由于spring aop是通过代理模式实现，从而这个对象永远是被代理对象。

连接点(join point)

   指那些被拦截到的点，在spring中这些点指的是方法，因为spring只支持方法类型的连接点,(被增强类中的方法[要不要增强不一定,但是都可以增强])

切入点(pointcut)

   表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，

   它定义了相应的 Advice 将要发生的地方简单说切入点是指我们要对哪些连接点进行拦截的定义,(已配置,被增强类中的方法[执行增强的连接点])

通知(advice)

   指拦截到连接点之后所要做的事情就是通知，通知分为前置通知，后置通知，异常通知，最终通知，环绕通知.(增强的代码)

引介introduction

   引介是一种特殊的通知，在不修改类代码的前提下，introduction可以在运行期为类动态地添加一些方法或属性

切面aspect
```
   是切入点和通知的结合
```
织入weaving

   织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期，类装载期，运行期进行。

   Spring采用动态织入，而aspectj采用静态织入

代理Proxy

   一个类被AOP织入增强后，就产生一个结果代理类

AOP底层实现
AOP分为静态AOP和动态AOP。静态AOP是指AspectJ实现的AOP，他是将切面代码直接编译到Java类文件中。动态AOP是指将切面代码进行动态织入实现的AOP。
Spring的AOP为动态AOP，实现的技术为： JDK提供的动态代理技术和 CGLIB(动态字节码增强技术)
传统的spring aop开发中它支持增强(advice)有五种:
1. 前置通知目标方法执行前增强 org.springframework.aop.MethodBeforeAdvice
1. 后置通知目标方法执行后增强 org.springframework.aop.AfterReturningAdvice
1. 环绕通知目标方法执行前后进行增强 org.aopalliance.intercept.MethodInterceptor
1. 异常抛出通知目标方法抛出异常后的增强 org.springframework.aop.ThrowsAdvice
1. 引介通知在目标类中添加一些新的方法或属性

SpringBoot中使用AOP

在pom文件中加入AOP依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.1.7.RELEASE</version>
        </dependency>

新建一个切面类

/**
 * @Description
 * 其中：
 * * @Aspect 表明是一个切面类
 * * @Component 将当前类注入到Spring容器内
 * * @Pointcut 切入点，其中execution用于使用切面的连接点。使用方法：execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选)) ，可以使用通配符匹配字符，*可以匹配任意字符。
 * * @Before 在方法前执行
 * * @After 在方法后执行
 * * @AfterReturning 在方法执行后返回一个结果后执行
 * * @AfterThrowing 在方法执行过程中抛出异常的时候执行
 * * @Around 环绕通知，就是可以在执行前后都使用，这个方法参数必须为ProceedingJoinPoint，proceed()方法就是被切面的方法，上面四个方法可以使用JoinPoint，JoinPoint包含了类名，被切面的方法名，参数等信息。
 * @Author 
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019-09-25
 */
@Aspect
@Component
public class IndexAspect {

    @Pointcut("execution(public * com.mmz.springboot.controller.aop.aopannotation.*.*(..))")
    public void LogAspect(){}

    @Before("LogAspect()")
    public void doBefore(JoinPoint joinPoint){
        System.out.println("doBefore");
    }

    @After("LogAspect()")
    public void doAfter(JoinPoint joinPoint){
        System.out.println("doAfter");
    }

    @AfterReturning("LogAspect()")
    public void doAfterReturning(JoinPoint joinPoint){
        System.out.println("doAfterReturning");
    }

    @AfterThrowing("LogAspect()")
    public void deAfterThrowing(JoinPoint joinPoint){
        System.out.println("deAfterThrowing");
    }

    @Around("LogAspect()")
    public Object deAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("deAround");
        return joinPoint.proceed();
    }
}

利用自定义注解使用AOP

/**
 * 新建自定义注解，新建注解与新建接口类似，将interface改为@interface即可。
 */
@Target({ElementType.METHOD, ElementType.TYPE}) //定义注解修饰的目标,方法/类
@Retention(RetentionPolicy.RUNTIME) //定义注解的生命周期(SOURCE源码级别,CLASS编译期级别,RUNTIME运行期级别)
public @interface DoneTime{
    String param() default "";
}

创建自定义注解对应切面(在使用注解的地方，利用环绕通知可做进一步的逻辑处理 )

/**
 * @Description  创建自定义注解对应切面
 * @Author zhoumm
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019-09-25
 */

@Aspect
@Component
public class DoneTimeAspect {
    @Around("@annotation(doneTime)")  //对指定注解使用环绕通知
    public Object around(ProceedingJoinPoint joinPoint, DoneTime doneTime) throws Throwable {
        System.out.println("方法开始时间是:"+new Date());
        Object o = joinPoint.proceed();
        System.out.println("方法结束时间是:"+new Date()) ;
        return o;
    }
}

创建一个IndexController进行测试（两个接口进行效果对比）

/**
 * @Description
 * @Author 
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019-09-25
 */

@Api(value = "aop", description = "aop测试样例文档")
@RestController
@RequestMapping("/aop")
@Slf4j
@Validated
public class IndexController {

    @GetMapping("/index")
    @DoneTime(param = "IndexController")
    public String index(){
        System.out.println("方法执行");
        return "hello guodegang";
    }

    @GetMapping("/index2")
    public String index2(){
        System.out.println("方法2执行");
        return "hello yuqian";
    }
}

浏览器访问 http://localhost:8787/aop/index1，控制台如下：

方法开始时间是:Wed Sep 25 17:16:02 CST 2019
deAround
doBefore
方法执行
doAfter
doAfterReturning
方法结束时间是:Wed Sep 25 17:16:02 CST 2019

浏览器访问 http://localhost:8787/aop/index2，控制台如下：

deAround
doBefore
方法2执行
doAfter
doAfterReturning

我用漂亮的押韵形容被掠夺一空的爱情

关注

0
点赞
踩
12

收藏

觉得还不错? 一键收藏
2
评论
SpringBoot使用AOP(针对注解)

SpringBoot使用AOP(针对注解)AOP简介AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度...
复制链接

扫一扫

专栏目录