spring系列之AOP---及5大通知实战

最新推荐文章于 2024-07-10 21:09:35 发布
最新推荐文章于 2024-07-10 21:09:35 发布
阅读量199 收藏
点赞数
分类专栏： springBoot 文章标签： aop实战 aop5大通知
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43606738/article/details/102554735
版权

什么是AOP
AOP为Aspect Oriented Programming的缩写
意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

aop应用场景: 日志, 事务等, 抽离共同性质的逻辑,在主业务中某个点切入进去, 但不妨碍业务逻辑的执行

来看一下springAOP中的几个概念

Aspect（切面）： Aspect 声明类似于 Java 中的类声明, 表明这个是一个切面，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

在AOP中切面就是与业务逻辑独立，但又垂直存在于业务逻辑的代码结构中的通用功能组合；切面与业务逻辑相交的点就是切点；连接点就是把业务逻辑离散化后的关键节点；切点属于连接点，是连接点的子集；Advice（增强）就是切面在切点上要执行的功能增加的具体操作；在切点上可以把要完成增强操作的目标对象（Target）连接到切面里，这个连接的方式就叫织入。

注解方式声明一个切点

	/**
     * 声明一个切点
     */
    @Pointcut("execution(* com.hc.springaopdemo.controller.*.*(..))")
    private void webLog(){}

Advice 的类型
before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码),对应注解 @Before(value = "webLog()"). webLog()是自己定义的一个切点
after return advice, 在一个 join point 正常返回后执行的 advice, 对应注解@AfterReturning(returning = "o", pointcut = "webLog()")
after throwing advice, 当一个 join point 抛出异常后执行的 advice, 对应注解@AfterThrowing(value = "webLog()", throwing = "exception")
after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice, 对应注解@After(value = "webLog()")
around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice,环绕通知,对应注解@around(value = "webLog()")
introduction，introduction可以为原有的对象增加新的属性和方法。

最强环绕通知用法,盗用一段代码, 最强通知注解,同时搞定前面4个通知

在这里插入图片描述

举一个例子, 每天都要吃饭, 吃饭是主业务, 吃饭有分早中晚3餐,每餐吃的东西不同,甚至有人吃的更多,这些就是主业务
吃饭前洗手,吃饭后洗碗,吃饭时刚好发地震了(异常)报告异常,不管吃没吃完我总知道自己吃了多少, 这些都是早中晚餐都需要做的事情, 不可能将这些事情都在早中晚餐中都写一遍,这样的话显得有点冗余, 这时候aop就发生作用了

实战代码–记录某个方法的调用日志:
这里创建springBoot项目,因为简单 哈哈

创建一个实体类

package com.hc.springaopdemo.entity;

public class User {
    private Integer id;
    private String name;
    private Integer age;

    public User() {
    }

    public User(Integer id ,String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

service就不写了 就简单写个controller业务

package com.hc.springaopdemo.controller;

import com.hc.springaopdemo.annotation.Logs;
import com.hc.springaopdemo.entity.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;

@RestController
@RequestMapping("user")
public class UserController {

    /**
     * 模拟数据库数据
     */
    static HashMap<Integer, User> map = new HashMap<>();
    static{
        User u1 = new User(1,"name1",1);
        User u2 = new User(2,"name2",2);
        User u3 = new User(3,"name3",3);
        User u4 = new User(4,"name4",4);
        User u5 = new User(5,"name5",5);
        map.put(u1.getId(),u1);
        map.put(u2.getId(),u2);
        map.put(u3.getId(),u3);
        map.put(u4.getId(),u4);
        map.put(u5.getId(),u5);
    }

    @Logs
    @RequestMapping(value = "/getUser",method = RequestMethod.GET)
    public Object findById(Integer id){
        //int i = 1/0;
        User u = map.get(id);
        if(u == null){
            return "用户不存在";
        }
        return u;
    }
}

启动项目, http://localhost:8080/user/getUser?id=1, 其实就可以得到想要的user数据, 如何在不改变主业务代码的情况下记录该方法的调用日志记录

自定义一个注解
只作为一个标记来判断哪个方法需要开启日志记录(毕竟中餐不洗手也能吃饭)

package com.hc.springaopdemo.annotation;

import java.lang.annotation.*;

/**
 * Demo class
 * 方法调用日志记录
 * @author hc
 * @date 2019/10/14
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Logs {
	//这里就不定义什么参数了,只作为一个标记用
}

定义切面类

package com.hc.springaopdemo.aop;

import com.google.gson.Gson;
import com.hc.springaopdemo.annotation.Logs;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;

@Aspect//这个注解的作用是:将一个类定义为一个切面类
@Component//这个注解的作用：把切面类加入到IOC容器中
@Order(1)//这个注解的作用是:标记切面类的处理优先级,i值越小,优先级别越高.PS:可以注解类,也能注解到方法上
@Slf4j
public class AspectDemo {

    static Gson gson = new Gson();

    /**
     * 声明一个切点
     */
    @Pointcut("execution(* com.hc.springaopdemo.controller.*.*(..))")
    private void webLog(){}

    /**
     * 请求前通知
     * @Before(value = "webLog()") 这个注解的作用是:在切点webLog()前执行方法,内容为指定的切点
     * JoinPoint 切入点对象, 因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
     */
    @Before(value = "webLog()")
    public void methodBefore(JoinPoint joinPoint) {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();

        MethodSignature joinPointObject = (MethodSignature) joinPoint.getSignature();
        //获得请求的方法
        Method method = joinPointObject.getMethod();

        //如果方法上有Logs这个注解,则记录这个方法的调用日志
        if(hasAnnotationOnMethod(method, Logs.class)){
            //打印请求内容
            log.info("================请求内容===============");
            log.info("请求地址:" + request.getRequestURI().toString());
            log.info("请求方式" + request.getMethod());
            log.info("请求类方法" + joinPoint.getSignature());
            log.info("请求类方法参数" + Arrays.toString(joinPoint.getArgs()));
            log.info("================请求内容================");
        }
    }

    /**
     * 业务正常执行完后通知
     * @AfterReturning(returning = "o", pointcut = "webLog()") 这个注解的作用是:在切入点,return后执行,如果想对某些方法的返回参数进行处理,可以在这操作
     */
    @AfterReturning(returning = "o", pointcut = "webLog()")
    public void methodAfterReturing(JoinPoint joinPoint,Object o) {
        log.info("------------正常返回内容--------------");
        log.info("Response内容:" + gson.toJson(o));
        log.info("------------正常返回内容--------------");

    }

    /**
     * 业务异常时通知
     */
    @AfterThrowing(value = "webLog()", throwing = "exception")
    public void methodAfterException(JoinPoint joinPoint,Exception exception){
        log.info("*************异常返回内容*************");
        log.info("业务异常: "+exception.getMessage());
        log.info("*************异常返回内容*************");
    }

    /**
     * 无论业务是否异常,都通知
     */
    @After(value = "webLog()")
    public void methodAfter(JoinPoint joinPoint){
        log.info("++++++++++++发不发生异常都返回++++++++++++");
        log.info("不管业务有没有发生异常,都执行");
        log.info("++++++++++++发不发生异常都返回++++++++++++");
    }

    /**
     * 判断某方法上是否含有某注解
     * @param method
     * @param annotationClazz
     * @return
     */
    private boolean hasAnnotationOnMethod(Method method, Class annotationClazz){
        //使用反射获取注解信息
        Annotation a = method.getAnnotation(annotationClazz);
        if (a == null){
            return false;
        }
        return true;
    }
}

启动项目访问 , 这里来个正常的,不人为制造异常, 后面的环绕通知人为造个异常
在这里插入图片描述
注意输出顺序

环绕通知按照上面那张图片来改就完了
当使用@Around处理时，我们需要将切点参数定义为ProceedingJoinPoint类型，该类是JoinPoint的子类。
代码

package com.hc.springaopdemo.aop;

import com.google.gson.Gson;
import com.hc.springaopdemo.annotation.Logs;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;

@Aspect//这个注解的作用是:将一个类定义为一个切面类
@Component//这个注解的作用：把切面类加入到IOC容器中
@Order(1)//这个注解的作用是:标记切面类的处理优先级,i值越小,优先级别越高.PS:可以注解类,也能注解到方法上
@Slf4j
public class AspectDemo2 {

    static Gson gson = new Gson();

    /**
     * 声明一个切点
     */
    @Pointcut("execution(* com.hc.springaopdemo.controller.*.*(..))")
    private void webLog(){}


    /**
     * 请求前通知
     * @Before(value = "webLog()") 这个注解的作用是:在切点webLog()前执行方法,内容为指定的切点
     * JoinPoint 切入点对象, 因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
     */
    @Around(value = "webLog()")
    public Object methodAround(ProceedingJoinPoint joinPoint) throws Throwable{
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();

        MethodSignature joinPointObject = (MethodSignature) joinPoint.getSignature();
        //获得请求的方法
        Method method = joinPointObject.getMethod();
        //如果方法上有Logs这个注解,则记录这个方法的调用日志
        if(hasAnnotationOnMethod(method, Logs.class)){
            //打印请求内容
            log.info("==============请求前内容=============");
            log.info("请求地址:" + request.getRequestURI().toString());
            log.info("请求方式" + request.getMethod());
            log.info("请求类方法" + joinPoint.getSignature());
            log.info("请求类方法参数" + Arrays.toString(joinPoint.getArgs()));
            log.info("==============请求前内容==============");
        }

        try {

            log.info("------------正常返回内容--------------");
            log.info("Response内容:" + gson.toJson(joinPoint.proceed()));
            log.info("------------正常返回内容--------------");

        }catch (Exception e){
            log.info("*************异常返回内容*************");
            log.info("业务异常: "+e.getMessage());
            log.info("*************异常返回内容*************");
        }

        log.info("++++++++++++发不发生异常都返回++++++++++++");
        log.info("不管业务有没有发生异常,都执行");
        log.info("++++++++++++发不发生异常都返回++++++++++++");


        return joinPoint.proceed();

    }

    /**
     * 判断某方法上是否含有某注解
     * @param method
     * @param annotationClazz
     * @return
     */
    private boolean hasAnnotationOnMethod(Method method, Class annotationClazz){
        //使用反射获取注解信息
        Annotation a = method.getAnnotation(annotationClazz);
        if (a == null){
            return false;
        }
        return true;
    }

}

启动项目看一下结果, 我这里造了一个异常,看异常后,后面的输出不
在这里插入图片描述

weixin_43606738
关注
专栏目录
AOP的实战（统一功能处理模块）
lucky_1314520的博客
08-03 313
我们要对一部分方法进行拦截，而另一部分方法不拦截，如注册方法和登录方法是不拦截的，这样的话排除方法的规则很难定义，甚至没办法定义。用户登录权限的发展从之前每个方法中自己验证用户登录权限，到现在统一的用户登录验证处理，它是一个逐渐完善和逐渐优化的过程。每个方法中都要单独写用户登录验证的方法，即使封装成公共方法，也一样要传参调用和在方法中进行判断。这些用户登录验证的方法和接下来要实现的业务几何没有任何关联，但每个方法中都要写一遍。此时用户登录权限的验证方法就会执行，这就是拦截器的实现原理。
Spring实战 | Spring AOP
qq_34193201的博客
10-17 152
Spring AOP（面向切面编程）是Spring框架中的一个关键特性之一。它提供了一种在应用程序中以非侵入式方式实现横切关注点的方法。AOP通过在应用程序中定义切面（Aspect）和连接点（Join Point）来实现，切面定义了横切关注点的行为，而连接点则表示在应用程序中可以插入切面的位置。使用Spring AOP，您可以将横切关注点（如日志记录、性能监视、事务管理等）与业务逻辑相分离，以提高应用程序的可维护性和灵活性。
彻底征服 Spring AOP 之 实战篇
weixin_34388207的博客
11-13 126
接上一小节彻底征服 Spring AOP 之 理论篇 Spring AOP 实战 看了上面这么多的理论知识, 不知道大家有没有觉得枯燥哈. 不过不要急, 俗话说理论是实践的基础, 对 Spring AOP 有了基本的理论认识后, 我们来看一下下面几个具体的例子吧.下面的几个例子是我在工作中所遇见的比较常用的 Spring AOP 的使用场...
【鸿蒙实战开发】AOP面向切面编程实战
最新发布
HarmonyOS_666的博客
07-10 699
对于Android、Java Web 开发者来说， AOP编程思想并不陌生。AOP的使用核心在于要找到 Aspect（切面），然后再根据自己的需要，对某个“业务操作进”行 前置或者后置的处理，甚至可以替换“该业务操作”。AOP的操作粒度就是方法级别， 一个方法包括 接收数据、处理数据和返回数据这么三个部分：AOP 在这三个阶段都可以添加自己的逻辑处理。Java中常见的AOP框架有很多：AspectJ、SpringAOP、Javassist、Guice、Byte Buddy等。
Aop实战
tmax52HZ的博客
09-18 181
Java动态代理AOP实战
AOP实战
li_tiantian的博客
05-19 270
AOP实战 一、定义AOP切面 package com.aop.service; ​ import com.alibaba.fastjson.JSONObject; import com.tf56.core.BizReturn; import com.tf56.core.exception.BizError; import com.tf56.hermesContract.exception.BusinessException; import lombok.extern.slf4j.Slf4j; imp
Spring AOP的五大通知
qq_44804494的博客
11-15 343
Pointcut定义 直接案例看一哈 首先一个接口，里面若干方法 package com.ym.dao; public interface IMathEnt { public int addUser(int i,int j); public int subUser(int i,int j); public int rideUser(int i,int j); public int ...
spring-aop-4.0.0.RELEASE
05-31
Spring AOP 4.0.0.RELEASE版本为开发者带来了更强大的面向切面编程能力，尤其在注解装配方面，极大地提升了开发效率。理解并掌握这些核心概念和实践技巧，能够帮助我们更好地利用Spring AOP构建健壮且易于维护的...
2024-spring-aop学习项目
01-26
本项目资料旨在帮助开发者全面、深入地掌握Spring AOP的核心概念与实践技巧，为2024年春季的学习之旅提供坚实的理论基础和技术支持。 一、Spring AOP概述 Spring AOP是Spring框架中的一个关键特性，它通过将关注点...
spring-aop
08-14
总结，Spring AOP通过注解方式提供了一种简洁而直观的方式来实现面向切面编程，极大地简化了我们的代码，提高了代码的可读性和可维护性。通过理解和熟练掌握这些注解，我们能够更好地利用Spring AOP解决实际开发中的...
Spring-AOP（前置/后置/环绕）通知的例子
04-22
在这个例子中，我们将深入探讨Spring AOP中的前置通知、后置通知以及环绕通知的实现方式。 前置通知（Before Advice）在目标方法执行前触发，通常用于执行验证、初始化等操作。在Spring AOP中，我们可以使用`@...
Spring AOP的五种通知方式代码实例
08-25
主要介绍了Spring AOP的五种通知方式代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【大白话系列】-- AOP实战
Gilgame的博客
08-06 623
本文主要介绍如何优雅的在Spring Boot中使用自定义注解，AOP切面统一打印出入参日志 一. 首先看看切面日志输出效果： 从上图中可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数： URL: 请求接口地址； Description: 接口的中文说明信息； HTTP Method: 请求的方法，是 POST, GET, 还是 DELETE 等； Class Method: 被请求的方法路径 : 包名 + 方法名; IP: 请求.
AOP-项目实战
gpx2001的博客
06-26 226
项目需求：由于系统由多方公司联合开发，其他公司的相关接口可能偶尔网络不通，或者处于调试阶段，导致我方开发人员由于外部接口错误从而无法相关模块的开发，这里就可以使用Aop+自定义主键去实现接口拦截，从而返回正确响应参数。开启，有需要的话也可以关闭，pointCut()指定该切面的作用域，这里是用于注解，around()为处理接口拦截的具体业务。首先，我们可以自定义一个注解，这里的jsonFilePath用来指定文件（该文件包含正确的返回信息）的存放位置。
spring-AOP实战（最新，实用，简单，爆炸！！！！！）
狗蛋儿_312的博客
05-23 1154
废话不多说直接开始干（注：本文前提是你已经倒入了其他启动项目所有需要的spring包，且配置好）没有的话请去我的github下载（包含aopdemo）：下载项目第一步：倒入AOP相关jar包，本文实用POM                &lt;spring.version&gt;4.1.1.RELEASE&lt;/spring.version&gt;                 &lt;as...
Spring AOP项目实战
技术分享
07-12 1172
本文主要介绍了Spring AOP的基础知识以及在项目中实际使用场景以及代码实现
Spring AOP的八个概念、五个通知类型、AOP的第一种实现方式
qq_35091777的博客
10-27 2596
Spring AOP的八个概念： 连接点：在程序执行中特定的方法eg:需要绑定日志：create切入点--站在应用程序角度思考：由连接点组成的集合：    eg:多个模块的所有的create方法关注点--站在开发者角度思考：其实就是连接点：程序员所关心的共性的功能：方法执行的过程中是否能够绑定日志切面：由多个切入点所构成的集合aop:aspect目标对象：aopservice/iocse
Android面向切面（AOP）编程实战
qq_36523667的博客
12-24 3195
转载自https://www.jianshu.com/p/b96a68ba50db AOP:面向切面编程(Aspect-Oriented Programming)。如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。 Aspect介绍篇：Android中的AOP编程 这里通过几个小例子，讲解在Android开发中，如何运用AOP的方式，进
SpringAop实战
zhengxc博客
11-03 564
SpringAop实战1、什么是AOP1.1 spring Aop的应用1.2 开启spring支持1.3 声明一个切面1.4 声明一个切入点1.5 声明一个通知1.6 JoinPoint Api2、@EnableAspectJAutoProxy配置注意事项2.1 AopProxy2.2 proxyTargetClass 作用2.3 exposeProxy 作用 1、什么是AOP 与OOP对比,面...
深入理解Spring2-AOP：实战教程与核心原理解析
"Spring2-AOP入门实例教程，旨在引导读者掌握Spring AOP（面向切面编程）的基本概念和实践操作。本书由蔡世友、吴嘉俊、冯煜和张钰合著，内容丰富，包括Spring框架的原理、设计思想以及J2EE开发的实践应用。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值