开发者

SpringBoot实现模块日志入库的项目实践

开发者 https://www.devze.com 2023-04-30 10:26 出处：网络 作者： ACGkaka_
目录1.简述2.LoginController3.Action4.TransactionUtils5.LoginService6.LoginLogService6.1 @Async实现异步6.2 自定义线程池实现异步7.其他解决方案7.1 使用编程式事务来代替@Transactional参考地址：模块调用之后
相关专题：SpringBoot 模块日志SpringBoot 模块日志入库
目录
  • 1.简述
  • 2.LoginController
  • 3.Action
  • 4.TransactionUtils
  • 5.LoginService
  • 6.LoginLogService
    • 6.1 @Async实现异步
    • 6.2 自定义线程池实现异步
  • 7.其他解决方案
    • 7.1 使用编程式事务来代替@Transactional
  • 参考地址：

    模块调用之后，记录模块的相关日志，看似简单，其实暗藏玄机。

    1.简述

    模块日志的实现方式大致有三种：

    • AOP + 自定义注解实现
    • 输出指定格式日志 + 日志扫描实现
    • 在接口中通过代码侵入的方式，在业务逻辑处理之后，调用方法记录日志。

    这里我们主要讨论下第3种实现方式。

    假设我们需要实现一个用户登录之后记录登录日志的操作。

    调用关系如下：

    SpringBoot实现模块日志入库的项目实践

    这里的核心代码是在 LoginService.login() 方法中设置了在事务结束后执行：

    // 指定事务提交后执行
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
  // 不需要事务提交前的操作，可以不用重写这个方法
  @Override
  public void beforeCommit(boolean readOnly) {
    System.out.println("事务提交前执行");
  }
  @Override
  public void afterCommit() {
    System.out.println("事务提交后执行");
  }
});

    在这里，我们把这段代码封装成了工具类，参考：4.TransactionUtils。

    如果在 LoginService.login() 方法中开启了事务，不指定事务提交后指定的话，日志处理的方法做异步和做新事务都会有问题：

    • 做异步：由于主事务可能没有执行完毕，导致可能读取不到主事务中新增或修改的数据信息；
    • 做新事物：可以通过 Propagation.REQUIRES_NEW 事务传播行为来创建新事务，在新事务中执行记录日志的操作，可能会导致如下问题：
      • 由于数据库默认事务隔离级别是可重复读，意味着事物之间读取不到未提交的内容，所以也会导致读取不到主事务中新增或修改的数据信息；
      • 如果开启的新事务和之前的事务操作了同一个表，就会导致锁表。
    • 什么都不做，直接同步调用：问题最多，可能导致如下几个问题：
      • 不捕获异常，直接导致接口所有操作回滚；
      • 捕获异常，部分数据库，如：PostgreSQL，同一事务中，只要有一次执行失败，就算捕获异常，剩余的数据库操作也会全部失败，抛出异常；
      • 日志记录耗时增加接口响应时间，影响用户体验。

    2.LoginController

    @RestController
public class LoginController {
  @Autowired
  private LoginService loginService;
  @RequestMapping("/login")
  public String login(String username, String pwd) {
    loginService.login(username, pwd);
    return "succeed";
  }
}

    3.Action

    /**
* <p> @Title Action
* <p> @Description 自定义动作函数式接口
*
* @author ACGkaka
* @date 2023/4/26 13:55
*/
public interface Action {
    /**
    * 执行动作
    */
    void DOSomething();
}

    4.TransactionUtils

    import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* <p> @Title TransactionUtils
* <p> @Description 事务同步工具类
*
* @author ACGkaka
* @date 2023/4/26 13:45
*/
public class TransactionUtils {
  /**
  * 提交事务前执行
  */
  public static void beforeTransactionCommit(Action action) {
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
      @Override
      public void beforeCommit(boolean readOnly) {
        // 异步执行
        action.doSomething();
      }
    });
  }
  /**
  * 提交事务后异步执行
  */
  public static void afterTransactionCommit(Action action) {
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
      @Override
      public void afterCommit() {
        // 异步执行
        action.doSomething();
      }
    });
  }
}

    5.LoginService

    @Service
public class LoginService {
  @Autowired
  private LoginLogService loginLogService;
  /** 登录 */
  @Transactional(rollbackFor = Exception.class)
  public void login(String username, String pwd) {
    // 用户登录
    // TODO: 实现登录逻辑..
    // 事务提交后执行
    TransactionUtil.afterTransactionCommit(() -> {
      // 异步执行
      taskExecutor.execute(() -> {
      // 记录日志
      loginLogService.recordLog(username);
      });
    });
  }
}

    6.LoginLogService

    6.1 @Async实现异步

    @Service
public class LoginLogService {
    /** 记录日志 */
    @Async
    @Transactional(rollbackFor = Exception.class)
    public void recordLog(String username) {
        // TODO: 实现记录日志逻辑...
    }
}

    注意：@Async 需要配合 @EnableAsync 使用，@EnableAsync 添加到启动类、配置类、自定义线程池类上均可。

    补充：由于 @Async 注解会动态创建一个继承类来扩展方法的实现，所以可能会导致当前类注入Bean容器失败 BeanCurrentlyInCreationException，可以使用如下方式：自定义线程池 + @Autowired

    6.2 自定义线程池实现异步

    1）自定义线程池

    AsyncTaskExecutorConfig.Java

    import com.demo.async.ContextCopyingDecorator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExwxOOOecutor;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;
/**
* <p> @Title AsyncTaskExecutorConfig
* <p> @Description 异步线程池配置
*
* @author ACGkaka
* @date 2023/4/24 19:48
*/
@EnableAsync
@Configuration
public class AsyncTaskExecutorConfig {
  /**
  * 核心线程数（线程池维护线程的最小数量）
  */
  private int corePoolSize = 10;
  /**
  * 最大线程数（线程池维护线程的最大数量）
  */
  private int maxPoolSize = 200;
  /**
  * 队列最大长度
  */
  private int queueCapacity = 10;
  @Bean
  public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(corePoolSize);
    executor.setMaxPoolSize(maxPoolSize);
    executor.setQueueCapacity(queueCapacity);
    executor.setThreadNamePrefix("MyExecutor-");
    // for passing in request scope context 转换请求范围的上下文
    executor.setTaskDecorator(new ContextCopyingDecorator());
    // rejection-policy：当pool已经达到max size的时候，如何处理新任务
    // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.setWaitForTasksToCompleteOnShutdown(true);
    executor.initialize();
    return executor;
  }
}

    2）复制上下文请求

    ContextCopyingDecorator.java

    import org.slf4j.MDC;
import org.springframework.core.task.TaskDecorator;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import j编程客栈ava.util.Map;
/**
* <p> @Title ContextCopyingDecorator
* <p> @Description 上下文拷贝装饰者模式
*
* @author ACGkaka
* @date 2023/4/24 20:20
*/
public class ContextCopyingDecorator implements TaskDecorator {
  @Override
  public Runnable decorate(Runnable runnable) {
    try {
      // 从父线程中获取上下文，然后应用到子线程中
      RequestAttributes requestAttributes = RequestContextHolder.currentRequestAttributes();
      Map<String, String> previous = MDC.getCopyOfContextMap();
      SecurityContext securityContext = SecurityContextHolder.getContext();
      return () -> {
        try {
          if (previous == null) {
            MDC.clear();
          } else {
            MDC.setContextMap(previous);
          }
          RequestContextHolder.setRequestAttributes(requestAttributes);
          SecurityContextHolder.setContext(securityContext);
          runnable.run();
        } finally {
          // 清除请求数据
          MDC.clear();
          RequestContextHolder.resetRequestAttributes();
          SecurityContextHolder.clearContext();
        }
      };
    } catch (IllegalStateException e) {
      return runnable;
    }
  }
}

    3）自定义线程池实现异步 LoginService

    import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
@Service
public class LoginService {
  @Autowired
  private LoginLogService loginLogService;
  @Qualifier("taskExecutor")
  @Autowired
  private TaskExecutor taskExecutor;
  /** 登录 */
  @Transactional(rollbackFor = Exception.class)
  public void login(String username, String pwd) {
    // 用户登录
    // TODO: 实现登录逻辑..
    // 事务提交后执行
    TransactionUtil.af编程客栈terTransactionCommit(() -> {
      // 异步执行
      taskExecutor.execute(() -> {
 编程客栈     // 记录日志
      loginLogService.recordLog开发者_JS学习(username);
      });
    });
  }
}

    7.其他解决方案

    7.1 使用编程式事务来代替@Transactional

    我们还可以使用TransactionTemplate来代替 @Transactional 注解：

    import org.springframework.transaction.support.TransactionTemplate;
@Service
public class LoginService {
  @Autowired
  private LoginLogService loginLogService;
  @Autowired
  private TransactionTemplate transactionTemplate;
  /** 登录 */
  public void login(String username, String pwd) {
    // 用户登录
    transactionTemplate.execute(status->{
   // TODO: 实现登录逻辑..
    });
    // 事务提交后异步执行
    taskExecutor.execute(() -> {
    // 记录日志
    loginLogService.recordLog(username);编程客栈
    });
  }
}

    经测试：

    这种实现方式抛出异常后，事务也可以正常回滚

    正常执行之后也可以读取到事务执行后的内容，可行。

    别看日志记录好实现，坑是真的多，这里记录的只是目前遇到的问题。

    参考地址：

    1.SpringBoot 关于异步与事务一起使用的问题

    到此这篇关于SpringBoot实现模块日志入库的项目实践的文章就介绍到这了,更多相关SpringBoot 模块日志入库内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

    0

    上一篇:

    :下一篇

    更多 开发 相关资讯：

    精彩评论

    暂无评论...
    登录 注册
    Qedev.com
    验证码 换一张
    取 消

      关注公众号

      热门标签

      图文推荐

      mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

      mysql字符集引起的java.sql.SQLException:Incorrect string value:问题
      解决Feign异步调用丢失上下文问题

      解决Feign异步调用丢失上下文问题
      一文教会你使用Python来下一场雪

      一文教会你使用Python来下一场雪
      利用python调整Excel行高和列宽的操作示例

      利用python调整Excel行高和列宽的操作示例
      Python字符串检索方式

      Python字符串检索方式
      Android中常见内存泄漏的场景和解决方案详解

      Android中常见内存泄漏的场景和解决方案详解
      python解析网页上的json数据并保存到EXCEL

      python解析网页上的json数据并保存到EXCEL
      使用wxPython创建一个文件夹结构生成器

      使用wxPython创建一个文件夹结构生成器

      开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

      法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

      Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9