How SpringBoot implements module log storage-javaTutorial-php.cn

1. Brief description

There are roughly three ways to implement module logs:

AOP custom annotation implementation
Output the specified format log Log scanning implementation
#In the interface through code intrusion, after the business logic is processed, the method is called to record the log.

Here we mainly discuss the third implementation method.

Suppose we need to implement an operation of recording login logs after a user logs in.

The calling relationship is as follows:

How SpringBoot implements module log storage

The core code here is set in the LoginService.login() method to be executed after the transaction ends:

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

Copy after login

Here, we encapsulate this code into a tool class, reference: 4.TransactionUtils.

If a transaction is enabled in the LoginService.login() method and is not specified after the transaction is submitted, there will be problems with the asynchronous log processing method and new transactions:

Doing asynchronously: Since the main transaction may not be completed, the newly added or modified data information in the main transaction may not be read;
Doing new things: You can use Propagation .REQUIRES_NEW transaction propagation behavior to create a new transaction, and performing logging operations in the new transaction may cause the following problems:

Because the database default transaction isolation level is repeatable Reading means that uncommitted content cannot be read between things, so the newly added or modified data information in the main transaction cannot be read;
If it is turned on If the new transaction operates on the same table as the previous transaction, it will cause the table to be locked.

Do nothing and call directly synchronously: the most problematic problem, which may cause the following problems:

No Catching exceptions will directly lead to the rollback of all operations on the interface;
Catching exceptions, for some databases, such as PostgreSQL, as long as one execution fails in the same transaction, even if the exception is caught, the remaining databases will All operations will fail and an exception will be thrown;
Logging is time-consuming and increases the interface response time, affecting the user experience.

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";
    }
}

Copy after login

3.Action

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

Copy after login

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();
            }
        });
    }
}

Copy after login

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);
            });
        });
    }
}

Copy after login

6.LoginLogService

6.1 @Async implements asynchronous

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

Copy after login

Note: @Async needs to be used in conjunction with @EnableAsync. @EnableAsync is added to the startup class, configuration class, and custom thread pool All categories are available.

Supplement: Since the @Async annotation will dynamically create an inherited class to extend the method implementation, it may cause the current class to fail to inject into the Bean container BeanCurrentlyInCreationException. You can use the following method: Custom thread pool @Autowired

6.2 Custom thread pool to implement asynchronous

1) Custom thread pool

AsyncTaskExecutorConfig.java

import com.demo.async.ContextCopyingDecorator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
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;
    }
}

Copy after login

2) Copy context request

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 java.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;
        }
    }
}

Copy after login

3) Custom thread pool to implement asynchronous 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.afterTransactionCommit(() -> {
            // 异步执行
            taskExecutor.execute(() -> {
                // 记录日志
                loginLogService.recordLog(username);
            });
        });
    }
}

Copy after login

7. Other solutions

7.1 Use programmatic transactions instead of @Transactional

We can also use TransactionTemplate instead of @Transactional Note:

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);
        });
    }
}

Copy after login

After testing:

After this implementation throws an exception, the transaction can also be rolled back normally

Normal After execution, you can also read the content of the transaction execution, which is feasible.

Regardless of how easy it is to implement logging, there are really many pitfalls. What is recorded here is only the problems encountered so far.

The above is the detailed content of How SpringBoot implements module log storage. For more information, please follow other related articles on the PHP Chinese website!