Springboot中@AOP的理解与使用

最新推荐文章于 2022-10-25 09:51:47 发布
最新推荐文章于 2022-10-25 09:51:47 发布
阅读量444 收藏 3
点赞数 1
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52043417/article/details/127155190
版权

1.认识aop

1.何为aop

  1. aop全称 Aspect Oriented Programming ,面向切面,Aop的主要实现就是针对业务处理过程的切面进行,它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果
  2. 通俗的来比喻，你可以使用aop来帮你完成一些繁杂的工作，而你只需要专注于业务逻辑，好比你吃饭，穿衣服都可以雇一个人来帮你，你只需要去做自己要处理的事情。

2.aop相关名词

  • 切面**(Aspect)😗* 一个关注点的模块化,以@Aspect的形式放在类上面声明一个切面
  • 链接点**(Joinpoint)😗* 在程序执行过程中某个特定的点，比如方法调用前执行的操作或者是处理异常都可以算作是链接点
  • 通知**(Advice): **需要完成的工作叫做通知及，就是写的业务逻辑中，比如事务，日志等先定义好再拿去用
    • 主要包括五个注解:Before,After,AfterReturning,AfterThrowing,Around
    • @Before: 在切点方法前执行
    • @After: 在切点方法后执行
    • @AfterReturning: 切点方法返回后执行
    • @AfterThrowing: 在切点方法抛出异常后执行
    • @Around: 环绕增强,执行后使用此注解会影响@AfterThrowing这个注解
  • 切点**(Pointcut): **筛选出的链接点，如果说通知定义了切面的动作或者执行时机的话，切点则定义了执行的地点，切入点表达式如何和连接点匹配是AOP的核心
  • 引入**(Introduction) 😗* 在不改变一个现有类的代码的情况下，为该类添加熟悉和方法
  • 目标对象**(Target Object) 😗*被一个或者多个切面通知的对象,也被称为adviced被通知对象
  • AOP代理**(AOP Proxy) 😗*用来实现切面契约，如通知方法执行等
  • 织入**(Weaving) 😗*把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象

3.实战

  1. 添加aop依赖
<!--引入AOP依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.1.6.RELEASE</version>
</dependency>
  1. 创建LogAspect 日志记录类
@Aspect
@Component
public class LogAspect {
	//切入点
    @Pointcut("execution(public * com.yang.respringboot.re.controller.*.*(..))")
    public void webLog(){}

    @Before("webLog()")
    public void deBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 记录下请求内容
        System.out.println("URL : " + request.getRequestURL().toString());
        System.out.println("HTTP_METHOD : " + request.getMethod());
        System.out.println("IP : " + request.getRemoteAddr());
        System.out.println("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        System.out.println("ARGS : " + Arrays.toString(joinPoint.getArgs()));

    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        System.out.println("方法的返回值 : " + ret);
    }

    //后置异常通知
    @AfterThrowing("webLog()")
    public void throwss(JoinPoint jp){
        System.out.println("方法异常时执行.....");
    }

    //后置最终通知,final增强，不管是抛出异常或者正常退出都会执行
    @After("webLog()")
    public void after(JoinPoint jp){
        System.out.println("方法最后执行.....");
    }

    //环绕通知,环绕增强，相当于MethodInterceptor
    @Around("webLog()")
    public Object arround(ProceedingJoinPoint pjp) {
        System.out.println("方法环绕start.....");
        try {
            Object o =  pjp.proceed();
            System.out.println("方法环绕proceed，结果是 :" + o);
            return o;
        } catch (Throwable e) {
            e.printStackTrace();
            return null;
        }
    }

}
  1. Controller类
@RestController
public class AopController {

    @RequestMapping("/first")
    public Object first() {
        return "first controller";
    }

    @RequestMapping("/doError")
    public Object error() {
        return 1 / 0;
    }

}
  1. 运行结果
URL : http://localhost:8085/first
HTTP_METHOD : GET
IP : 127.0.0.1
CLASS_METHOD : com.yang.respringboot.re.controller.AopController.first
ARGS : []
方法的返回值 : first controller
方法最后执行.....
方法环绕proceed，结果是 :first controller

//doError
方法环绕start.....
URL : http://localhost:8085/doError
HTTP_METHOD : GET
IP : 127.0.0.1
CLASS_METHOD : com.yang.respringboot.re.controller.AopController.error
ARGS : []
方法异常时执行.....
方法最后执行.....

2.真正的实战

1.我们来看一下ruoyi的日志功能

1.定义一个日志注解
/**
 * 自定义操作日志记录注解
 * 
 * @author ruoyi
 *
 */
@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log
{
    /**
     * 模块 
     */
    public String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 操作人类别
     */
    public OperatorType operatorType() default OperatorType.MANAGE;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;

    /**
     * 是否保存响应的参数
     */
    public boolean isSaveResponseData() default true;
}
2.定义操作类型enum类
  1. 业务操作类型
/**
 * 业务操作类型
 * 
 * @author ruoyi
 */
public enum BusinessType
{
    /**
     * 其它
     */
    OTHER,

    /**
     * 新增
     */
    INSERT,

    /**
     * 修改
     */
    UPDATE,

    /**
     * 删除
     */
    DELETE,

    /**
     * 授权
     */
    GRANT,

    /**
     * 导出
     */
    EXPORT,

    /**
     * 导入
     */
    IMPORT,

    /**
     * 强退
     */
    FORCE,

    /**
     * 生成代码
     */
    GENCODE,
    
    /**
     * 清空数据
     */
    CLEAN,
}
  1. 操作人 OperatorType
/**
 * 操作人类别
 * 
 * @author ruoyi
 */
public enum OperatorType
{
    /**
     * 其它
     */
    OTHER,

    /**
     * 后台用户
     */
    MANAGE,

    /**
     * 手机端用户
     */
    MOBILE
}
3.定义切面类
/**
 * 操作日志记录处理
 * 
 * @author ruoyi
 */
@Aspect
@Component
public class LogAspect
{
    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult)
    {
        handleLog(joinPoint, controllerLog, null, jsonResult);
    }

    /**
     * 拦截异常操作
     * 
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e)
    {
        handleLog(joinPoint, controllerLog, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult)
    {
        try
        {
            // 获取当前的用户
            LoginUser loginUser = SecurityUtils.getLoginUser();

            // *========数据库日志=========*//
            SysOperLog operLog = new SysOperLog();
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            // 请求的地址
            String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
            operLog.setOperIp(ip);
            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            if (loginUser != null)
            {
                operLog.setOperName(loginUser.getUsername());
            }

            if (e != null)
            {
                operLog.setStatus(BusinessStatus.FAIL.ordinal());
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 设置请求方式
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult);
            // 保存数据库
            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
        }
        catch (Exception exp)
        {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     * 
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception
    {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData())
        {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, operLog);
        }
        // 是否需要保存response，参数和值
        if (log.isSaveResponseData() && StringUtils.isNotNull(jsonResult))
        {
            operLog.setJsonResult(StringUtils.substring(JSON.toJSONString(jsonResult), 0, 2000));
        }
    }

    /**
     * 获取请求的参数，放到log中
     * 
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception
    {
        String requestMethod = operLog.getRequestMethod();
        if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod))
        {
            String params = argsArrayToString(joinPoint.getArgs());
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        }
        else
        {
            Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000));
        }
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray)
    {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0)
        {
            for (Object o : paramsArray)
            {
                if (StringUtils.isNotNull(o) && !isFilterObject(o))
                {
                    try
                    {
                        Object jsonObj = JSON.toJSON(o);
                        params += jsonObj.toString() + " ";
                    }
                    catch (Exception e)
                    {
                    }
                }
            }
        }
        return params.trim();
    }

    /**
     * 判断是否需要过滤的对象。
     * 
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o)
    {
        Class<?> clazz = o.getClass();
        if (clazz.isArray())
        {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        }
        else if (Collection.class.isAssignableFrom(clazz))
        {
            Collection collection = (Collection) o;
            for (Object value : collection)
            {
                return value instanceof MultipartFile;
            }
        }
        else if (Map.class.isAssignableFrom(clazz))
        {
            Map map = (Map) o;
            for (Object value : map.entrySet())
            {
                Map.Entry entry = (Map.Entry) value;
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
                || o instanceof BindingResult;
    }
}
YangYoungAcor
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot整合Aop.zip
03-10
SpringBoot 整合 AOP 的实践与理解 在软件开发中，随着系统复杂性的增加，重复的代码和逻辑处理往往成为维护的痛点。为了解决这一问题，面向切面编程（Aspect-Oriented Programming，简称 AOP）应运而生。AOP 的...
Spring @Aspect、@Before、@After 注解实现 AOP 切面功能
蚩尤后裔-汪茂雄
08-22 6万+
Spring AOP 注解概述 1、Spring 的 AOP 功能除了在配置文件中配置一大堆的配置，比如切入点、表达式、通知等等以外，使用注解的方式更为方便快捷，特别是 Spring boot 出现以后，基本不再使用原先的 beans.xml 等配置文件了，而都推荐注解编程。 @Aspect 切面声明，标注在类、接口（包括注解类型）或枚举上。 @Pointcut 切入点声明，即切入到哪些目标类的目标方法。 value 属性指定切入点表达式，默认为 ""，用于被通知注解引用
AOP -- 注解 @Aspect 、@Pointcut
徐本锡的专栏
11-17 49万+
写在前面：在开发过程中，需要对每个方法执行时进行日志记录、返回值的解析，简单整理一下有关AOP的相关知识点。 1.基本概念 1.1.切面类 @Aspect 定义切面类，加上@Aspect、@Component注解；（下文有展示） 1.2.切点 @Pointcut (1)指定切面方法 execution表达式 第一个*表示匹配任意的方法返回值， ..(两个点)表示零个或多个， 第一个..表示module包及其子包, 第二个*表示所有类, 第三个*表示所有方法， 第二个..表示方法..
Spring核心AOP详解
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-30 395
这就到bean初始化后置操作了，如下代码所示，从缓存中获取这个bean，如果这个bean不在中，则调用，这个方法会在必要情况下根据策略决定用cglib或者jdk代理完成某些需要被代理的类的创建。= null) {// 如果这个bean不在代理缓存中，则进行增强= bean) {
AOP注解的使用
weixin_46245201的博客
10-25 587
AOP指的是程序运行期间动态的将某段代码切入到指定位置进行运行的编程。
Aop的使用(通知，日志存储等)
LC的博客
01-08 5112
AOP是面向切面的横向的编程，在不影响原来业务的基础上，实现动态的增强。 通知顺序： 先环绕放行前，前置，环绕放行后，后置@After，最终@AfterReturning（对方法的结果做处理） 一、实现AOP方式： 1.使用原生的spring API接口。 2.自定义类，把这个类作为切面，其中的方法在切点前或后执行。 二、具体操作 1.首先,要使用AOP需要导入包 <dependency> <groupId>org.aspectj</groupId> &
Springboot接口项目如何使用AOP记录日志
08-19
Springboot 接口项目如何使用 AOP 记录日志 在软件开发中，日志记录是一项非常重要的任务，它...在本文中，我们只是简单地介绍了使用 AOP 记录日志的基本思路和实现方式，希望可以帮助大家更好地理解和应用 AOP 技术。
SpringBoot使用AOP注解记录操作日志
最新发布
04-30
首先，我们需要理解AOP的基本概念。AOP允许我们定义“切面”，这些切面可以在特定的“连接点”（如方法调用）上执行自定义的行为，如日志记录。在Spring Boot中，我们可以使用`@Aspect`注解来声明一个切面类，然后...
SpringBoot AOP各种注解、自定义注解、鉴权使用案例（免费下载）
02-24
在SpringBoot中，AOP的使用更为简洁，它简化了配置过程，使得开发者可以更专注于业务逻辑。 首先，我们来看看SpringBoot AOP中的各种注解。最基础的是`@Aspect`，用于标记一个类为切面类，这个类中会包含切点...
SpringBoot使用AOP完成多数据源切换
09-29
本文将详细讲解如何使用SpringBoot结合AOP（面向切面编程）来实现多数据源的动态切换。 首先，理解SpringBoot的核心是Spring框架，它提供了一个便捷的方式来配置和管理应用。在Spring中，数据源可以通过`@Bean`注解...
Spring AOP配置 AOP的注解及使用
酆都城博客
08-10 1324
AOP的注解及使用 aop使用注解功能 先要在applicationContext.xml配置文件中 扫描总包目录 <context:component-scan base-package="com.itheima"/> 开启aop的注解驱动 <aop:aspectj-autoproxy/> 这是必须要有的，没有就不能使用注解 注解开发AOP制作步骤 在XML格式基础上 导入坐标（伴随spring-context坐标导入已经依赖导入完成） 开启AOP注解支持 配
什么是AOP，AOP的作用是什么？常见AOP功能
诗水人间
02-18 15万+
AOP全称（Aspect Oriented Programming）面向切片编程的简称 AOP的定义： AOP通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术，简称AOP。是spring框架的一个重要内容，是OOP（面向对象编程）的衍生模范型。 AOP的作用： 利用AOP对业务逻辑的各个部分进行隔离，降低业务逻辑的耦合性，提高程序的可重用型...
Spring BOOT AOP是什么
上后谈感情的博客
07-03 774
AOP
AOP
鱼乐1024
09-04 411
AOP代理过程 简单理解AOP的概念 @AfterReturning(“execution(* com.zxl.examples.service….(…))”) 通知：@AfterReturning这个就是通知，一共五个 切点：execution(* com.zxl.examples.service….(…))这个筛选条件就是切点 切面：通知+切点 连接点：符合上面筛选条件的方法就是连接点 说明...
AOP详解
qq_46138160的博客
01-05 397
什么是AOP AOP是一个切面编程的思想，就是能够让我们在不影响主业务功能的前提下， 横切扩展新的功能。比如本章演示的切面日志功能，在不影响主业务流程的情况下打印一些日志。 AOP中的术语 aspect（切面）:切面由pointcut和advice组成，是横切逻辑定义和连接点定义的组成; jointpoint（连接点）:连接点是应用程序提供给切面插入的地方，可以添加新的方法 advice（增强）:是织入到连接点上的一段程序，另外它还拥有连接点的相关信息,advice是我们切面功能的实现，它通知程序新的行为
【Spring注解】AOP
flora
01-11 659
Spring注解 AOPAOP的使用@EnableAspectJAutoProxyAnnotationAwareAspectJAutoProxyCreator的定义信息beandefinition的注册AnnotationAwareAspectJAutoProxyCreator 的注册父类创建ioc容器registerBeanPostProcessors 注册BeanPostProcessor创建BeanPostProcessor对象BeanFactoryAware实现了BeanFactoryAware的s
Spring AOP 实现原理
热门推荐
KevinJom的专栏
09-24 57万+
什么是AOP AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从
AOP-通用的API日志实例
Richy的博客
06-23 1158
AOP-通用的API日志实例 序分析方案AOP实现最后 序 最近项目里整了一个通用的API日志。感觉挺不错的，整理一下分享出来。 接口大概时间图如下: 分析 除了【业务处理】，其它的处理都与业务无关。可以考虑把通用的部分抽离出来，【业务处理】单独处理。可以用两种方案去处理。 方案 **1：**使用抽象类。提供一个方法，从【开始】处理到【结束】。【业务处理】设一个抽像方法（无实现）。每个接口都继承抽象类。接口类重写抽业务处理抽象方法。 **2：**使用AOP，开发人员只管【业务处理】。通过AOP的方式在【业
Spring的AOP面向切面编程
Smile2you的博客
08-09 190
什么是AOP？ 1.AOP概念介绍 　　所谓AOP，即Aspect orientied program,就是面向方面(切面)的编程。 　　　功能： 让关注点代码与业务代码分离！ 关注点:          　重复代码就叫做关注点； 业务代码： 　　　　核心业务的代码 业务代码与关注点代码分离，好处？             　　 --&gt; 关注点代码写一次即可；      ...
SpringBoot AOP编程示例
08-05
当您使用Spring Boot AOP（面向切面编程）时，可以通过创建切面、定义切点和编写通知来实现横切关注点的功能。下面是一个简单的示例，演示如何使用Spring Boot AOP编程： 1. 首先，确保在pom.xml文件中添加了`spring-boot-starter-aop`依赖项： ```xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 2. 创建一个切面类`LoggingAspect`，使用`@Aspect`注解标记为切面： ```javaimport org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; @Aspect@Componentpublic class LoggingAspect { @Before("execution(* com.example.demo.*.*(..))") public void beforeAdvice() { System.out.println("Before executing the method..."); } } ``` 在上述代码中，`@Before`注解指定了在执行匹配切点的方法之前要执行的通知。`execution(* com.example.demo.*.*(..))`是一个切点表达式，它表示匹配`com.example.demo`包下的所有类的所有方法。 3. 创建一个简单的示例类`DemoController`： ```javaimport org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestControllerpublic class DemoController { @GetMapping("/hello") public String hello() { return "Hello, World!"; } } ``` 4. 运行Spring Boot应用程序，您将看到在访问`/hello`接口时，控制台将输出`Before executing the method...`的信息。 这个示例展示了一个简单的切面，它在执行匹配切点的方法之前打印出一条消息。您可以根据自己的需求编写更复杂的切面和通知。 希望这个示例能帮助您理解如何在Spring Boot中使用AOP编程。如果您有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值