脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot整合Aop

SpringBoot整合Aop全过程

 更新时间：2024年10月17日 17:06:23   作者：小疙瘩的编程之路  
AOP（面向切面编程）技术可以高效地解决日志记录、事务管理、权限控制等问题,日志记录通过自定义注解和切面类,自动记录方法调用详情,减少重复代码,事务管理方面,通过AOP可以在不改变业务代码的情况下,实现事务的自动开启、提交和回滚,保证数据一致性

AOP 可以做什么？

  • 1. 日志记录
  • 自动记录方法的调用、参数、返回值和异常等信息，减少了在每个方法中添加日志代码的需要。
  • 2. 管理事务
  • 在方法执行前后自动处理事务的开启、提交和回滚，确保数据的一致性和完整性。
  • 3. 权限控制
  • 实现方法的访问控制，检查用户权限，确保只有授权用户才能执行特定操作。
  • 4. 性能监控
  • 自动收集方法的执行时间、调用次数等性能指标，帮助开发者进行性能分析和优化。
  • 5. 缓存管理
  • 实现方法结果的缓存，减少重复计算，提高系统性能。
  • 6. 异常处理
  • 统一处理方法执行中的异常，简化异常捕获和处理逻辑。
  • 7. 输入验证
  • 在方法执行前对输入参数进行验证，保证数据的有效性和完整性。
  • 8. 动态代理
  • 创建代理对象，在不修改原有类的情况下添加额外的行为。

应用场景

  • Web开发：用于请求处理、事务管理、安全控制等。
  • 企业应用：在服务层实现统一的日志和异常处理。
  • 微服务：在服务之间进行统一的监控和熔断处理。

日志记录

1.准备工作

首先需要导入AOP依赖

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.50</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

然后需要创建日志记录数据库和实体类还有在Mapper层实现插入数据方法

  • 实体类
//操作日志实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {
    private Integer id; //主键ID
    private Integer operateUser; //操作人ID
    private LocalDateTime operateTime; //操作时间
    private String className; //操作类名
    private String methodName; //操作方法名
    private String methodParams; //操作方法参数
    private String returnValue; //操作方法返回值
    private Long costTime; //操作耗时
}
  • Mapper接口
@Mapper
public interface OperateLogMapper {

    //插入日志数据
    @Insert("insert into operate_log (operate_user, operate_time, class_name, method_name, method_params, return_value, cost_time) " +
            "values (#{operateUser}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime});")
    public void insert(OperateLog log);

}

2.创建自定义注解和切面类

因为我们要记录的操作日志是对于数据的增，删，改所以采用@annotation来指定要为连接点的方法。

而且在涉及到消耗时间的字段，所以需要采用@Around通知类型

  • 自定义注解类
@Retention(RetentionPolicy.RUNTIME)//运行时有效
@Target(ElementType.METHOD)//作用在方法上
public @interface Log {
}

3.实现日志记录(Around)

首先需要需要记录的操作接口方法前加上@Log注解

接下来在切面类中实现操作日志记录：

‌

@Aspect
@Component
public class LogAsper {
    @Autowired
    private OperateLogMapper operateLogMapper;
    @Autowired
    private HttpServletRequest request;

    @Around("@annotation(com.ly.springbootdemotlias.anno.Log)")//匹配加了Log注解的方法
    public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
        OperateLog operateLog = new OperateLog();
        //获取操作人id，通过获取并解析jwt令牌
        String jwt = request.getHeader("token");
        Claims claims = JwtUtils.parseJwt((jwt));
        Integer operateUser =(Integer) claims.get("id");
        operateLog.setOperateUser(operateUser);
        //获取操作时间
        operateLog.setOperateTime(LocalDateTime.now());
        //获取操作类名
        operateLog.setClassName(joinPoint.getTarget().getClass().getName());
        //获取操作方法名
        operateLog.setMethodName(joinPoint.getSignature().getName());
        //获取操作方法参数
        operateLog.setMethodParams(Arrays.toString(joinPoint.getArgs()));
        //获取开始时间
        long begin = System.currentTimeMillis();
        //获取操作方法返回值
        Object result = joinPoint.proceed();
        String returnValue = JSONObject.toJSONString(result);
        operateLog.setReturnValue(returnValue.toString());
        //获取操作结束时间
        long end = System.currentTimeMillis();
        //获取操作耗时
        operateLog.setCostTime((end-begin));
        operateLogMapper.insert(operateLog);
        return  result;

    }
}

管理事务

1. 添加依赖

在 pom.xml 中添加 MyBatis-Plus 和 AOP 的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.0</version> <!-- 根据需要选择版本 -->
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

2. 配置 MyBatis-Plus

在 application.yml 中配置 MyBatis-Plus 和数据源：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_database
    username: your_username
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver
  mybatis-plus:
    mapper-locations: classpath*:/mappers/**/*.xml

3. 创建事务切面

创建一个事务切面类：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Aspect
@Component
public class TransactionAspect {

    @Transactional
    @Around("execution(* com.yourpackage.service..*(..))") // 指定需要事务的业务逻辑包
    public Object manageTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        Object result;
        try {
            result = joinPoint.proceed(); // 执行目标方法
            return result;
        } catch (Exception e) {
            throw e; // 抛出异常以触发回滚
        }
    }
}

4. 示例业务逻辑类

创建一个服务类，使用 MyBatis-Plus 进行数据库操作：

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {

    public void createUser(User user) {
        this.save(user); // 调用 MyBatis-Plus 的 save 方法
    }
}

5. 用户实体和 Mapper

  • 定义用户实体：
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

@TableName("users") // 数据库表名
public class User {
    @TableId
    private Long id;
    private String name;

    // getters and setters
}
  • Mapper 接口：
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserMapper extends BaseMapper<User> {
    // 可以自定义额外的方法
}

6. 创建控制器

在控制器中调用 UserService 的 createUser 方法：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    public String createUser(@RequestBody User user) {
        userService.createUser(user); // 调用 UserService 的 createUser 方法
        return "User created successfully"; // 返回成功消息
    }
}

7. 启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

心得

  • 通过以上步骤，你可以在 Spring Boot 项目中整合 AOP 和 MyBatis-Plus，实现简单而有效的事务管理。
  • 这样，无论是在正常情况下提交事务，还是在出现异常时回滚事务，都能得到很好的支持。

为什么做事务，做事务有啥用

  • 事务确保一组操作要么全部成功，要么全部失败，从而保持数据的一致性和完整性。
  • 它们在处理银行转账、订单处理等场景时尤其重要，可以防止数据不一致、部分更新或系统故障导致的数据丢失。
  • 通过事务，确保即使在异常情况下，数据状态依然可靠。

那为什么要结合aop去做事务

  • 结合 AOP（面向切面编程）可以将事务管理的逻辑与业务逻辑分离，提高代码的可维护性和可读性。
  • 通过 AOP，可以在不修改业务代码的情况下，集中管理事务，简化代码结构，并实现事务的自动化管理，减少重复代码，提高开发效率。

权限控制

1. 添加依赖

在 pom.xml 中添加 AOP 相关依赖：

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

2. 创建权限注解

定义一个自定义注解 @RequiresPermission：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermission {
    String value();
}

3. 创建切面类

创建切面类，使用 @Aspect 注解来定义切面，处理权限控制逻辑：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class PermissionAspect {

    @Autowired
    private UserService userService; // 获取用户服务

    @Around("@annotation(requiresPermission)") // 拦截使用 @RequiresPermission 注解的方法
    public Object checkPermission(ProceedingJoinPoint joinPoint, RequiresPermission requiresPermission) throws Throwable {
        String requiredPermission = requiresPermission.value(); // 获取所需权限

        // 权限检查逻辑
        if (!hasPermission(requiredPermission)) {
            throw new SecurityException("Permission denied: " + requiredPermission);
        }

        return joinPoint.proceed(); // 执行目标方法
    }

    private boolean hasPermission(String permission) {
        User currentUser = userService.getCurrentUser(); // 获取当前用户

        if (currentUser == null) {
            return false; // 用户未登录
        }

        return currentUser.getPermissions().contains(permission); // 检查权限
    }
}

在使用 AOP 时，@RequiresPermission 注解是一个标记，它本身并不直接传递参数。Spring AOP 在拦截带有该注解的方法时，会自动创建该注解的实例，并将其作为参数传递给

checkPermission 方法。这是通过 AOP 框架的代理机制实现的，而不是通过显式调用。具体来说，当被注解的方法被调用时，AOP 会拦截这个调用并注入相应的注解信息。

permission 参数来源于 @RequiresPermission 注解的 value() 方法。在 checkPermission 方法中，当该方法拦截到一个使用 @RequiresPermission 注解的方法时，Spring AOP 会将该注解的实例作为第二个参数传递给 checkPermission 方法。因此，你可以通过调用 requiresPermission.value() 来获取注解中定义的权限字符串。

4. 使用权限注解

在需要进行权限控制的方法上使用自定义注解

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/admin")
    @RequiresPermission("ADMIN_ACCESS")
    public String adminAccess() {
        return "Welcome, admin!";
    }
}

5. 配置 Spring Boot

确保 Spring Boot 应用程序能够扫描到切面和自定义注解。通常情况下，只需在主类中添加 @EnableAspectJAutoProxy 注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableAspectJAutoProxy
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@EnableAspectJAutoProxy 注解的作用是启用 Spring 的 AOP（面向切面编程）支持，允许使用 AspectJ 的代理机制来实现切面。具体来说，它有以下几个功能：

1.启用代理

它告诉 Spring 创建代理对象，这些代理对象可以拦截方法调用并执行切面逻辑。

2.支持注解

当你在代码中使用注解（如 @Around、@Before 等）时，@EnableAspectJAutoProxy 会使这些注解生效，从而实现方法拦截和切面逻辑的执行。

3.简化配置

通过添加这个注解，开发者不需要额外的 XML 配置，只需通过注解来定义切面和增强，减少了配置的复杂性。

在主类中添加这个注解后，Spring Boot 应用会自动扫描到切面类并将其注册到应用上下文中，从而实现所需的 AOP 功能。

AOP的五种通知类型包括‌

  • 前置通知（@Before）‌
  • 后置通知（@After）‌
  • 返回通知（@AfterReturning）‌
  • 异常通知（@AfterThrowing）‌
  • 环绕通知（@Around）‌

每种通知类型都有其特定的用途和场景，可以根据实际需求选择使用。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • ZooKeeper开发实际应用案例实战

    ZooKeeper开发实际应用案例实战

    这篇文章主要为大家介绍了ZooKeeper开发的实际应用案例实战，文中附含详细开发应用源码，有需要的朋友可以借鉴参考下，希望能够有所帮助
    2022-01-01
  • Java 用反射设置对象的属性值实例详解

    Java 用反射设置对象的属性值实例详解

    这篇文章主要介绍了Java 用反射设置对象的属性值实例详解的相关资料,需要的朋友可以参考下
    2017-05-05
  • Spring Boot 中常用的注解@RequestParam及基本用法

    Spring Boot 中常用的注解@RequestParam及基本用法

    @RequestParam 是 Spring Framework 和 Spring Boot 中常用的注解之一,用于从请求中获取参数值,本文给大家介绍Spring Boot 中常用的注解@RequestParam,感兴趣的朋友一起看看吧
    2023-10-10
  • 详解Spring Security中的HttpBasic登录验证模式

    详解Spring Security中的HttpBasic登录验证模式

    HttpBasic登录验证模式是Spring Security实现登录验证最简单的一种方式，也可以说是最简陋的一种方式，这篇文章主要介绍了Spring Security的HttpBasic登录验证模式,需要的朋友可以参考下
    2019-11-11
  • Spring Cloud Stream微服务消息框架原理及实例解析

    Spring Cloud Stream微服务消息框架原理及实例解析

    这篇文章主要介绍了Spring Cloud Stream微服务消息框架原理及实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-06-06
  • Java常见内存溢出异常分析与解决

    Java常见内存溢出异常分析与解决

    本篇文章主要分析了JAVA程序内存溢出问题原因,较为详细的说明了java导致程序内存溢出的原因与解决方法,感兴趣的小伙伴们可以参考一下。
    2016-10-10
  • vscode快速引入第三方jar包发QQ邮件

    vscode快速引入第三方jar包发QQ邮件

    这篇文章主要介绍了vscode快速引入第三方jar包发QQ邮件，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-06-06
  • 轻松掌握Java注解，让编程更智能、更优雅

    轻松掌握Java注解，让编程更智能、更优雅

    轻松掌握Java注解？没问题！想要让你的Java代码更具可读性、维护性,同时提升开发效率？本指南将带你快速入门Java注解的世界,只需短短几分钟,你就能揭秘这个强大的编程工具,让编写有声明性逻辑的代码变得轻而易举,赶快一起来探索吧！
    2024-01-01
  • JAVA Static关键字的用法

    JAVA Static关键字的用法

    这篇文章主要介绍了JAVA Static关键字的用法，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
    2020-07-07
  • Java 归并排序算法、堆排序算法实例详解

    Java 归并排序算法、堆排序算法实例详解

    这篇文章主要介绍了Java 归并排序算法、堆排序算法实例详解,需要的朋友可以参考下
    2017-05-05

最新评论