Spring-AOP&事务

转载 已于 2024-12-02 16:46:20 修改 · 186 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.bilibili.com/video/BV1Fi4y1S7ix?p=40
文章标签：

#spring #java #后端

于 2022-12-10 21:08:49 首次发布
本文详细介绍了面向切面编程(AOP)的概念及其在Spring框架中的应用方式。包括AOP的基本原理、切入点表达式的书写技巧、不同类型的AOP通知及其实现方法，并通过具体案例展示了如何利用AOP提升代码复用性和维护性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、AOP简介

（一）核心概念

AOP（Aspect Oriented Programming）面向切面编程，一种编程思想，指导开发者如何组织程序结构。
作用：在不惊动原始设计的基础上为其进行功能增强。
在这里插入图片描述
在这里插入图片描述

（二）入门案例

  1. 导入坐标（spring的aop默认包含在context包中，所以不用导那个）
        <!-- 复制aop，aspectj公司的aop做的比spring好，所以整合 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

  1. 创建连接点方法（就是正常写需要用的方法）

  2. 创建通知和通知类（见第四步）

  3. 定义切入点（在通知类中），将通知和切入点绑定（即切面）

//告诉Spring要加载这个类
@Component
//告诉Spring这个类用来做AOP
@Aspect
public class MyAdvice {
	//定义切入点，私有且无参无返回值 
    @Pointcut("execution(void com.fn.dao.BookDao.update())")
    private void pt() {
    }

	//将切入点和通知进行绑定
    @Before(("pt()"))
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}
  1. 在SpringConfig中告诉Spirng，要用注解开发AOP。
    @EnableAspectJAutoProxy

二、AOP工作流程

在这里插入图片描述

三、AOP切入点表达式

（一）语法格式

在这里插入图片描述
在这里插入图片描述

（二）通配符

在这里插入图片描述

（三）书写技巧

在这里插入图片描述

四、AOP通知类型

  1. @Before：通知方法在原始切入点方法前运行。
  2. @After：通知方法在原始切入点方法后运行。
  3. @Around常用：通知方法在原始切入点方法前后运行。
    eg:
    @Around("pt()")
    //如果原始方法有返回值，这里就写Object，没有就void
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("原始切入点前的动作");
        //等价于原始切入点方法里的内容（如果原始方法有返回值，这里接收，并跟着返回）
        Object ret = pjp.proceed();
        System.out.println("原始切入点后的动作");
        return ret;
    }

使用@Around注意事项
在这里插入图片描述
4. @AfterReturning：通知方法在原始切入点方法正常执行完毕后运行（即原始方法没有异常或其他中断时执行）。
5. @AfterThrowing：通知方法在原始切入点方法出现异常后运行（原始方法出异常了才执行）。

案例

数据库万次查询效率：
在这里插入图片描述

五、AOP通知获取数据

在这里插入图片描述

（一）形参

在这里插入图片描述

  • JoinPoint代表连接点，可以获取连接点的信息，如方法名、参数等，但无法控制目标方法的执行。
  • ProceedingJoinPoint 继承自JoinPoint，同时还可以控制目标方法的执行，通过调用proceed()方法来继续执行目标方法。

（二）返回值

只有@AfterReturning和@Around有返回值
在这里插入图片描述

（三）异常

在这里插入图片描述

（四）案例

  • 各个类之间大量相同的功能，可以提出来做成AOP。
    在这里插入图片描述

步骤：

  1. 创建@interface类型的注解。
import java.lang.annotation.*;

/**
 * @Author: fn
 * @Date: 2024/11/28 14:09
 * @Description: 登录时，密码失败次数限制
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EnableLoginLimit {

    /**
     * 允许密码错误次数
     *
     * @return {int}
     */
    int allowErrorCount() default 5;

    /**
     * 锁定账户时长(分钟)
     *
     * @return {int}
     */
    int lockMinutes() default 10;
}
  1. 创建通知类 --> 在类中定义切入点同注解绑定 --> 定义切面方法写增强逻辑。
import cn.hutool.core.text.StrFormatter;
import com.hisi.cloud.authority.controller.RewriteTokenEndpoint;
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.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.oauth2.common.exceptions.InvalidGrantException;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @Author: fn
 * @Date: 2024/11/28 14:21
 * @Description: EnableLoginLimit AOP
 **/
@Slf4j
@Aspect
@Component
public class EnableLoginLimitAspect {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // 登录传参用户名字段
    private static final String USER_NAME_PARAM = "username";
    // 登录失败redis key
    private static final String PWD_ERROR_PREFIX = "login:pwdFailureLimit:%s";
    private static final String DISABLED_TEXT = "User is disabled";

    /***
     * 切入点
     * execution(public * com.hisi.base.controller.*.*(..)) 解释：
     * 第一个* 任意返回类型
     * 第三个* 类下的所有方法
     * ()中间的.. 任意参数
     *
     * annotation() 解释：
     * 标记了@EnableLoginLimit 注解的方法
     */
    @Pointcut("execution(public * com.hisi.cloud.authority.controller.RewriteTokenEndpoint.postAccessToken(..)) && @annotation(com.hisi.cloud.authority.configuration.login.EnableLoginLimit)")
    private void loginLimitPointcut() {

    }

    /**
     * 定义切面
     * 假的登录限制，因为是在spring security比对密码抛出异常后，才进行的切面
     */
    @Around("loginLimitPointcut()")
    public Object loginLimitAspectMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取注解参数
        EnableLoginLimit targetAnnotation = this.getTargetAnnotation(joinPoint);
        if (targetAnnotation == null) {
            return new RewriteTokenEndpoint.SwaggerEnhancer<>(400, null, "未获取到目标Annotation信息");
        }
        int allowErrorCount = targetAnnotation.allowErrorCount();
        int lockMinutes = targetAnnotation.lockMinutes();

        // 获取方法入参
        Object[] param = joinPoint.getArgs();
        Map<String, String> parameters = (Map<String, String>) param[1];
        String userName = parameters.get(USER_NAME_PARAM);
        try {
            // 执行连接点方法，如果密码错误，spring security会抛出InvalidGrantException异常
            Object proceed = joinPoint.proceed();
            // 没有异常清空redis错误计数
            stringRedisTemplate.delete(getKey(userName));
            return proceed;
        } catch (InvalidGrantException e) {
            if (e.getMessage().contains(DISABLED_TEXT)) {
                return new RewriteTokenEndpoint.SwaggerEnhancer<>(400, null, "用户已禁用");
            }
            Long errorCount = stringRedisTemplate.opsForValue().increment(getKey(userName));
            stringRedisTemplate.expire(getKey(userName), lockMinutes, TimeUnit.MINUTES);
            String resultMessage = "";
            if (errorCount != null && errorCount > allowErrorCount) {
                resultMessage = StrFormatter.format("密码错误超过{}次，账户已被锁定，请{}分钟后再试", allowErrorCount, lockMinutes);
            } else {
                resultMessage = StrFormatter.format("密码已错误{}次，超过{}次将锁定账户", errorCount, allowErrorCount);
            }
            return new RewriteTokenEndpoint.SwaggerEnhancer<>(400, null, resultMessage);
        }
    }

    private String getKey(String key) {
        return String.format(PWD_ERROR_PREFIX, key);
    }

    /**
     * 获取连接点上注解
     *
     * @param joinPoint
     * @return
     */
    private EnableLoginLimit getTargetAnnotation(JoinPoint joinPoint) {
        try {
            EnableLoginLimit annotation = null;
            if (joinPoint.getSignature() instanceof MethodSignature) {
                Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
                if (method != null) {
                    annotation = method.getAnnotation(EnableLoginLimit.class);
                }
            }
            return annotation;
        } catch (Exception e) {
            log.warn("获取 {}.{} 的 @EnableLoginLimit 注解失败", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName(), e);
            return null;
        }
    }

}

六、事务

（一）简介

第一步：业务层使用@Transactional注解
在这里插入图片描述
第二步：设置事务管理器（比如在JbdcConfig中写）
在这里插入图片描述
第三步：在SpringConfig开启注解式事务驱动@EnableTransactionManagement
在这里插入图片描述

（二）Spring事务原理

在这里插入图片描述
在这里插入图片描述

事务传播行为

简介：

事务的相关属性
在这里插入图片描述

对于propagation，有以下七种值：

在这里插入图片描述
七种传播行为详解

在Spring AOP切面中启用新事务
aabbyyz的博客
10-19 1566
分享一下我的偶像大神的人工智能教程！http://blog.csdn.net/jiangjunshow 也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！ 在工作中有一个在切面中需要记录一下操作日志的需求，而且要求这些操作日志要存入数据库，并且无论业务层有什么异常，日志照常记录，那就不能沿用业务层的事务，而是需要新启一个事务了。 ...
spring-aop-jar
12-14
Spring AOP模块提供了实现AOP规范的功能，它允许开发者定义“切面”来封装系统中的横切关注点，如日志、事务管理等。该jar文件包含了Spring AOP的核心类和接口，如`org.springframework.aop.*`包下的`...
4.spring的aop之@After
u013571243的专栏
12-15 711
定义一个切面 @Aspect public class AfterAdviceTest { // 匹配org.crazyit.app.service包下所有类的、 // 所有方法的执行作为切入点 @After("execution(* org.crazyit.app.service.*.*(..))") public void release() { System.out.print
Spring Aop @After (后置通知)的使用场景？
最新发布
专注于技术分享
06-19 572
After是 Spring AOP 中的另一种通知（Advice）类型，通常被称为“后置通知”或“最终通知”。无论目标方法是正常执行完成，还是在执行过程中抛出了异常，@After通知中的代码总是会在目标方法执行之后被执行。最经典的类比就是 Java 中的语句块里的 finally部分。@After的行为和finally块的行为几乎一模一样。@After特性描述执行时机无论成功或失败，总是在目标方法执行之后执行。核心用途资源释放上下文清理、最终日志记录等收尾工作。行为类似Java 的。
Spring Spring AOP的@After方法
qq_35677589的博客
03-10 1325
@After 最终通知，在源代码方法的后面执行
Spring AOP定义AfterReturning增加实例分析
08-25
主要介绍了Spring AOP定义AfterReturning增加,结合实例形式分析了Spring面相切面AOP定义AfterReturning增加相关操作技巧与使用注意事项,需要的朋友可以参考下
关于spring aop 中的 after thowing
weixin_34007879的博客
08-20 154
前几天想做一个异常的处理机制,就自定义了一些异常,然后在service层中使用aop中的after thowing来截取自定义的异常,处理之后在抛出,(因为开始以为,只是想截取service中的异常所以没有必要使用aop中的环绕),处理之后会把所有的异常都整合掉一个总的异常类中再抛给controller层在做返回视图操作. 但最近发现这个 after thowi...
java-aop&amp;jdbcTempalte
06-24
Java AOP（面向切面编程）是一种编程技术，它允许程序员定义“切面”，这些切面封装了特定的横切关注点，如日志、事务管理等，然后将这些关注点与业务逻辑分离。在Java中，Spring框架提供了强大的AOP支持。 1. **...
spring-aop
03-17
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了强大的横切关注点管理能力。在传统的面向对象编程中，我们往往需要在多个类或方法中重复编写...
spring-aop.xsd
11-28
Spring AOP是Spring框架的重要组成部分，它提供了面向切面编程的能力，使得开发者可以在不修改源代码的情况下对程序进行横切关注点（如日志、事务管理等）的处理。`spring-aop.xsd`文件是Spring AOP配置的XML Schema...
spring-aop-3.0.xsd spring-beans-3.0 spring-context-3.0.xsd spring-mvc-3.1.xsd
03-18
Spring AOP（面向切面编程）是 Spring 框架的一个重要部分，它允许开发者在不修改源代码的情况下，实现跨切面的关注点，如日志、事务管理等。`spring-aop-3.0.xsd` 是 Spring AOP 的 XML 配置文件，定义了与 AOP ...
Spring AOP(四)之After增强处理
owen_william的博客
03-06 5102
Spring还提供了一个After增强处理，它与AfterReturning增强处理有点相似，但也有区别： 1)        AfterReturing增强处理只有在目标方法成功完成后才会被织入。 2)        After增强处理不管目标方法如何结束（包括成功完成和遇到异常中止两种情况），它都会被织入。 下面的程序，我们定义一个After增强处理。 // 定义一个切面 @Aspec
Spring AOP详解
~ Caesar's wish书屋 ~
11-30 396
AOP      AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层
Spring AOP
m0_37637141的博客
08-30 249
通知：通知定义了切面是什么以及何时使用，除了描述切面要完成的工作，还解决了何时执行这个工作的问题，Spring切面定义了5中通知类型： 前置通知（Before）：在目标方法被调用之前调用通知功能 后置通知（After）：在目标方法完成之后调用通知功能，此时不会关心方法的输出是什么 返回通知（AfterReturning）：在目标方法成功执行之后调用通知 异常通知（AfterThrowing...
Spring面试（三）AOP
weixin_45773632的博客
03-16 1184
文章目录1. 什么是AOP？2. Spring AOP术语3. advice(增强)的类型4. @Pointcut() 的execution表达式 1. 什么是AOP？ AOP (Aspect Oriented Programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一一个热点，也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度
浅谈Spring AOP
小白成长记录
09-22 1031
浅谈Spring AOP介绍AOP(Aspect Oriented Programming)即面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.这种在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程.面向切面编程（AOP）是从动态角度考虑程序运行过程. 举例: 遍布在整个系统的权限校验、日志输出这两种服务其实和我们开发的功能是相互独立的，不存
【Spring第九篇】AOP
...
04-13 918
文章目录AOP核心概念AOP:切点表达式AOP:使用切点表达式@annotation通知分类获取被增强方法相关信息【不使用自动注入】AOP方式一：使用配置文件方法【不使用自动注入】AOP方式二：自定义切点【不使用自动注入】AOP方式三:使用注解方法 导包 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId&gt
Java练习（十）：Spring应用之AOP的@Before, @After操作（简单工程示例）
sulia1234567890的博客
09-18 8955
目录 1. 背景概念 1.1 定义 1.2 AOP的本质 1.3 AOP的实现 1.4各个名称的概念详解 2. 示例工程 2.1 maven的配置文件： pom.xml 2.2 bean配置文件： bean_aop.xml 2.3 接口和类的代码 2.3.1 接口：UserService 2.3.2实现接口的类：UserServiceImpl 2.3.3Before类：BeforeLog 2.3.4After类：AfterLog 2.4 测试类 1. 背景概念 1....
深入理解Spring-AOP的实战代码解析
7. AOP和事务管理：在Spring中，AOP被广泛用于声明式事务管理。这部分内容会涉及到如何使用AOP来控制事务的边界。 8. 自定义注解：可能会包含如何定义自定义注解，并结合AOP使用这些注解来编写切面的示例。 9. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值