模組日誌的實作方式大致有三種：
#AOP 自訂註解實作
輸出指定格式日誌日誌掃描實作
在介面中透過程式碼侵入的方式，在業務邏輯處理之後，呼叫方法記錄日誌。
這裡我們主要討論下第3種實作方式。
假設我們需要實作一個使用者登入之後記錄登入日誌的動作。
呼叫關係如下：
這裡的核心程式碼是在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 事務傳播行為來建立新事務，在新事務中執行記錄日誌的操作，可能會導致以下問題：
由於資料庫預設事務隔離等級是可重複讀，表示事物之間讀取不到未提交的內容，所以也會導致讀取不到主事務中新增或修改的資料資訊；
如果開啟的新事務和先前的事務操作了同一個表，就會導致鎖定表。
什麼都不做，直接同步呼叫：問題最多，可能導致以下幾個問題：
@RestController
public class LoginController {
@Autowired
private LoginService loginService;
@RequestMapping("/login")
public String login(String username, String pwd) {
loginService.login(username, pwd);
return "succeed";
}
}/**
* <p> @Title Action
* <p> @Description 自定义动作函数式接口
*
* @author ACGkaka
* @date 2023/4/26 13:55
*/
public interface Action {
/**
* 执行动作
*/
void doSomething();
}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();
}
});
}
}@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);
});
});
}
}@Service
public class LoginLogService {
/** 记录日志 */
@Async
@Transactional(rollbackFor = Exception.class)
public void recordLog(String username) {
// TODO: 实现记录日志逻辑...
}
}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.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;
}
}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;
}
}
}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);
});
});
}
}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);
});
}
}以上是SpringBoot怎麼實作模組日誌入庫的詳細內容。更多資訊請關注PHP中文網其他相關文章！
