系统重构对架构上的一些优化思路

对于全局日志的记录，大多数人都能立马想到使用aop环绕通知进行记录，如果现在有需求需要对用户的操作记录留痕呢？此文章就是在全局日志的基础上实现操作留痕

## 操作留痕

### 操作留痕的理论基础

信息安全的基本原则之一是“可追溯性”，即任何操作都应有迹可循。通过记录员工的操作行为，可以确保在发生数据泄露或其他安全事件时，能够迅速定位问题源头，采取相应措施。

行为分析是通过对员工日常操作行为的记录和分析，识别异常行为，从而预防潜在风险。管理层面则需要根据这些数据制定相应的管理策略，确保员工行为符合公司规范。

法律法规对数据保护和信息安全有明确要求。员工操作留痕不仅是企业内部管理的需要，也是满足外部合规要求的必要手段。

### 实现方式

实现的方式多种多样，常见的有2种方式：

* 后端提供接口，前端每次操作都异步调用接口进行留痕
* 由后端在接口调用的时候自动留痕

本文就是基于后端实现一套【高性能的操作日志留痕】，基于后端去实现操作留痕都会不可避免地对原代码有侵入性，但是我们要想出入侵性最低的方案 - 基于注解去实现。

对于不熟悉 AOP 的伙伴，可以先到官方文档上看下基本的使用 - [Spring AOP 官方文档](https://docs.spring.io/spring-framework/reference/core/aop/ataspectj.html)

### 数据采集方式

1、通过注解声明`功能模块`、`操作`，由后端controller接口上声明

> 优点：便于后端问题排查  
> 缺点：存在代码冗余，由于接口的复用性太多，定义功能模块与操作（新增编辑删除）等无法说明页面操作，例如app与erp都调用同一个接口查询列表，或者新增提交，一个接口就无法区分，只能重写的controller接口进行区分。

2、注解标记记录留痕，由前端请求头中声明`功能模块`、`操作`，后端进行采集 (⭐️ **推荐**）

> 优点：操作留痕更精确  
> 缺点：多负担一些网络IO的传输

相关信息

UTF-8编码中一个汉字也就是3-4个字节，一次接口调用一般在10个汉字左右，按照多的来算，平均每次调用40字节，对于消耗的那点网络IO可以忽略不计，推荐采用第二种方案进行数据采集

### 代码实现

既然是无侵入式的，那注解少不了，先定义好注解。

```
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface PassLog {
}
```

操作留痕的表，可自行进行扩展，此处 `browser` 对于app的操作存储手机的唯一标识

```
sql

create table sys_log
(
    id                bigint auto_increment
        primary key,
    operate_user_id   int          not null comment '操作人ID',
    operate_user_name varchar(64)  not null comment '操作人Name',
    operate_module    varchar(64)  null comment '操作模块',
    operate_item      varchar(128) null comment '操作项',
    interface_path    varchar(512) not null comment '接口路径',
    method            varchar(64)  null comment '请求方式（get、post等）',
    ip                varchar(128) not null comment 'ip',
    browser           varchar(512) null comment '浏览器',
    method_name       varchar(512) not null comment '方法名',
    result            varchar(512) not null comment '响应结果',
    result_time       bigint       null comment '响应时间（单位:ms）',
    create_time       datetime     not null comment '创建时间'
)
    comment '系统日志';
```

实体类

```
java

@Data
@Accessors(chain = true)
@TableName("sys_log")
public class SysLog {

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 操作人ID
     */
    @TableField(value = "operate_user_id")
    private Long operateUserId;

    /**
     * 操作人Name
     */
    @TableField(value = "operate_user_name")
    private String operateUserName;

    /**
     * 操作模块
     */
    @TableField(value = "operate_module")
    private String operateModule;

    /**
     * 操作项
     */
    @TableField(value = "operate_item")
    private String operateItem;

    /**
     * 接口路径
     */
    @TableField(value = "interface_path")
    private String interfacePath;

    /**
     * 请求方式
     */
    @TableField(value = "method")
    private String method;

    /**
     * ip
     */
    @TableField(value = "ip")
    private String ip;

    /**
     * 浏览器
     */
    @TableField(value = "browser")
    private String browser;

    /**
     * 方法名
     */
    @TableField(value = "method_name")
    private String methodName;

    /**
     * 响应结果
     */
    @TableField(value = "result")
    private String result;

    /**
     * 响应时间
     */
    @TableField(value = "result_time")
    private Long resultTime;

    /**
     * 创建时间
     */
    @TableField(value = "create_time")
    private LocalDateTime createTime;

}
```

具体的代码实现逻辑如下：

* 将所有controller接口的路径作为切点
* 全局日志记录格式为 **包名.类名#方法名** ,可通过快捷键进行快速定位

![image.png](https://blog.liushigong.cn/static/img/e531f42680fabcf1f4b25b8ea589ca8d.image.webp)

* 实现 `@Around` 与 `AfterThrowing` 方法
* 校验是否存在 `PassLog` 注解，存在则进行操作留痕
* 记录接口执行成功或异常原因
* 从请求头中获取`User-Agent`、`Operate_Module`、`Operate_Item` 记录
* 从当前登录的用户中记录上操作人
* 留痕使用线程池异步处理
* 单例线程池

```
java

@Aspect
@Slf4j
@Component
public class LogAspect implements Ordered, DisposableBean {

    @Resource
    private SysLogService sysLogService;

    /**
     * Get the order value of this object.
     * <p>Higher values are interpreted as lower priority. As a consequence,
     * the object with the lowest value has the highest priority (somewhat
     * analogous to Servlet {@code load-on-startup} values).
     * <p>Same order values will result in arbitrary sort positions for the
     * affected objects.
     *
     * @return the order value
     * @see #HIGHEST_PRECEDENCE
     * @see #LOWEST_PRECEDENCE
     */
    @Override
    public int getOrder() {
        return LOWEST_PRECEDENCE;
    }

    @Pointcut("execution(* cn.liushigong.echoim.controller.*.*(..))")
    private void pointcutToLog() {}

    /**
     * 日志切面
     */
    @Around("pointcutToLog()")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        // 方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        // 类名+方法名
        String methodName = signature.getDeclaringTypeName() + "#" + method.getName();
        log.info("{}, params = {}", methodName, JSONUtil.toJsonStr(joinPoint.getArgs()));

        // 计时器
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object result = joinPoint.proceed();
        stopWatch.stop();

        // 构建日志
        buildLog(method, stopWatch.getTotalTimeMillis(), methodName,  JSONUtil.toJsonStr(result), null);
        return result;
    }

    @AfterThrowing(pointcut="pointcutToLog()", throwing="ex")
    public void doRecoveryActions(JoinPoint joinPoint, Exception ex) throws Throwable {
        // 方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        // 类名+方法名
        String methodName = signature.getDeclaringTypeName() + "#" + method.getName();

        // 构建日志
        buildLog(method, -1, methodName,  null, ex);
    }

    public void buildLog(Method method, long takeTime, String methodName, String result, Throwable ex){
        // 记录系统日志
        boolean hasAnnotation = AnnotationUtil.hasAnnotation(method, PassLog.class);
        if (hasAnnotation) {
            SysLog sysLog = new SysLog();
            sysLog.setResultTime(takeTime);
            sysLog.setResult(ex != null ? ex.getMessage() : "success");
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            sysLog.setInterfacePath(request.getRequestURI());
            sysLog.setMethod(request.getMethod());
            sysLog.setIp(request.getRemoteAddr());
            sysLog.setBrowser(request.getHeader("User-Agent"));
            sysLog.setOperateModule(request.getHeader("Operate_Module"));
            sysLog.setOperateItem(request.getHeader("Operate_Item"));
            sysLog.setMethodName(methodName);
            sysLog.setOperateUserId(0L);
            sysLog.setOperateUserName("");
            sysLog.setCreateTime(LocalDateTime.now());
            // 异步记录日志
            LogThreadPool.execute(() -> {
                sysLogService.save(sysLog);
            });
        }

        // 记录异常日志
        if (ex != null) {
            log.info("{}, error = {}", methodName, ex.getMessage(), ex);
        }
        else {
            log.info("{}, result = {}, takeTime [{}] ms", methodName, result, takeTime);
        }
    }

    @Override
    public void destroy() throws Exception {
        LogThreadPool.shutdown(false);
    }

    /**
     * 日志线程池
     */
    static class LogThreadPool {

        /**
         * 执行器
         */
        private static ThreadPoolExecutor executor;

        /**
         * 私有构造器 拒绝new
         */
        private LogThreadPool() {
        }

        static {
            init();
        }

        /**
         * 初始化
         */
        public static synchronized void init() {
            //线程池已存在则立即关闭
            if (null != executor) {
                executor.shutdown();
            }
            //创建线程池
            executor = createThreadPool();
        }

        /**
         * 初始化线程池
         */
        private static ThreadPoolExecutor createThreadPool() {
            // 原子类
            AtomicInteger threadNumber = new AtomicInteger(1);
            // CPU核心数
            int coreNum = Runtime.getRuntime().availableProcessors();
            // 创建线程池
            return new ThreadPoolExecutor(
                    coreNum + 1,
                    coreNum * 2,
                    60L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(2000),
                    r -> new Thread(r, "Log-thread-" + threadNumber.getAndIncrement()),
                    new ThreadPoolExecutor.CallerRunsPolicy());
        }

        /**
         * 关闭线程池
         *
         * @param isNow 是否立即关闭
         */
        public static synchronized void shutdown(boolean isNow) {
            if (null != executor) {
                if (isNow) {
                    executor.shutdownNow();
                } else {
                    executor.shutdown();
                }
            }

        }

        /**
         * 执行线程
         *
         * @param runnable runnable
         */
        public static void execute(Runnable runnable) {
            executor.execute(runnable);
        }

        /**
         * 执行线程
         *
         * @param task task
         * @param <T>  T
         * @return Future
         */
        public static <T> Future<T> submit(Callable<T> task) {
            return executor.submit(task);
        }

        /**
         * 执行线程
         *
         * @param runnable runnable
         * @return Future
         */
        public static Future<?> submit(Runnable runnable) {
            return executor.submit(runnable);
        }
    }
}
```

全局日志在结合TraceId，可以参考[全链路日志TraceId穿透异步线程与MQ消息](/post/25)，这才是完整的一套高性能日志的解决方案，最终效果如下

![image.png](https://blog.liushigong.cn/static/img/9719e9343d73091bafe20f76a393d0bf.image.webp)

![image.png](https://blog.liushigong.cn/static/img/7ce8225c9f53fe7829f197098b7e3019.image.webp)

集成全局日志进行【高性能】的操作日志留痕

电商业务 - 支付

在 Java 生态中处理下单超时取消问题，分析几种主流解决方案，同时讲述下每种方案的适用场景和优缺点

## 主流的解决方案

主流方案的技术实现

![deepseek_mermaid_20250531_3e879f.png](https://blog.liushigong.cn/static/img/b4a5d42102d8938ed16fdd5f41a5580f.deepseek_mermaid_20250531_3e879f.webp)

### 方案 1：消息队列延迟消息（推荐）

适用场景：高并发、分布式系统

推荐中间件：RocketMQ（支持任意精度延迟消息）

```
java

// 订单创建时发送延迟消息
@Service
public class OrderService {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    private static final String TIMEOUT_TOPIC = "ORDER_TIMEOUT_TOPIC";
    
    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        // 1. 创建订单
        Order order = orderRepository.save(buildOrder(request));
        
        // 2. 发送30分钟超时消息
        Message<String> message = MessageBuilder.withPayload(order.getOrderId())
                .setHeader(MessageConst.PROPERTY_DELAY_TIME_LEVEL, "3") // 延迟级别3=30分钟
                .build();
                
        rocketMQTemplate.syncSend(TIMEOUT_TOPIC, message);
        
        return order;
    }
}

// 消费者处理超时订单
@Component
@RocketMQMessageListener(
    topic = "ORDER_TIMEOUT_TOPIC",
    consumerGroup = "order_timeout_group")
public class OrderTimeoutConsumer implements RocketMQListener<String> {
    
    @Autowired
    private OrderService orderService;

    @Override
    @Transactional
    public void onMessage(String orderId) {
        // 检查并处理超时订单
        orderService.processTimeoutOrder(orderId);
    }
}

// 超时订单处理逻辑
@Service
public class OrderService {
    // 使用乐观锁防止重复处理
    private static final String LOCK_PREFIX = "order_timeout:";
    
    @Autowired
    private RedissonClient redissonClient;
    
    public void processTimeoutOrder(String orderId) {
        RLock lock = redissonClient.getLock(LOCK_PREFIX + orderId);
        try {
            if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                Order order = orderRepository.findById(orderId)
                    .orElseThrow(() -> new OrderNotFoundException(orderId));
                
                if (order.getStatus() == OrderStatus.UNPAID) {
                    // 执行取消逻辑
                    cancelOrder(order);
                    log.info("订单超时取消成功: {}", orderId);
                }
            }
        } finally {
            lock.unlock();
        }
    }
    
    private void cancelOrder(Order order) {
        // 1. 更新订单状态
        order.setStatus(OrderStatus.CANCELLED);
        orderRepository.save(order);
        
        // 2. 释放库存
        inventoryService.releaseStock(order);
        
        // 3. 记录操作日志
        logService.recordCancelLog(order);
    }
}
```

**优点：**

* 高可靠：消息持久化，不丢失
* 高性能：支持高并发
* 分布式友好
* 解耦业务逻辑

**缺点：**

* 依赖消息中间件
* 需要处理消息重复消费

在回头看下，这点缺点也算是问题？

### 方案 2：时间轮算法（高性能内存方案）

适用场景：单机高并发、低延迟要求

```
java

// 基于Netty HashedWheelTimer实现
@Component
public class OrderTimeoutManager {
    private final HashedWheelTimer timer = new HashedWheelTimer(
        new NamedThreadFactory("order-timeout-timer"),
        100, // 100ms一个tick
        TimeUnit.MILLISECONDS,
        512 // 时间轮大小
    );
    
    private final ConcurrentMap<String, Timeout> timeoutTasks = new ConcurrentHashMap<>();
    
    public void scheduleTimeout(String orderId, long delay, TimeUnit unit) {
        TimerTask task = new TimerTask() {
            @Override
            public void run(Timeout timeout) {
                processTimeout(orderId);
            }
        };
        
        Timeout timeout = timer.newTimeout(task, delay, unit);
        timeoutTasks.put(orderId, timeout);
    }
    
    public void cancelTimeout(String orderId) {
        Timeout timeout = timeoutTasks.remove(orderId);
        if (timeout != null) {
            timeout.cancel();
        }
    }
    
    private void processTimeout(String orderId) {
        // 处理超时逻辑（需持久化存储）
        orderService.processTimeoutOrder(orderId);
        timeoutTasks.remove(orderId);
    }
}

// 集成到订单服务
@Service
public class OrderService {
    @Autowired
    private OrderTimeoutManager timeoutManager;
    
    public Order createOrder(CreateOrderRequest request) {
        Order order = orderRepository.save(buildOrder(request));
        
        // 30分钟后超时
        timeoutManager.scheduleTimeout(order.getOrderId(), 30, TimeUnit.MINUTES);
        
        return order;
    }
    
    public void onPaymentSuccess(String orderId) {
        // 支付成功时取消超时任务
        timeoutManager.cancelTimeout(orderId);
    }
}
```

**优点：**

* 毫秒级精度
* 高性能（O(1)时间复杂度）
* 低资源消耗

**缺点：**

* 单机方案，分布式环境下需配合其他方案
* 应用重启导致任务丢失
* 需配合持久化存储

### 方案 3：Redis ZSet 延迟队列

适用场景：轻量级应用、已有Redis基础设施

```
java

@Component
public class RedisOrderTimeoutQueue {
    private static final String KEY = "order:timeout:queue";
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    @Autowired
    private RedissonClient redissonClient;
    
    // 添加订单到延迟队列
    public void addOrder(String orderId, long timeoutMinutes) {
        double score = System.currentTimeMillis() + (timeoutMinutes * 60 * 1000);
        redisTemplate.opsForZSet().add(KEY, orderId, score);
    }
    
    // 取消订单超时
    public void cancelOrder(String orderId) {
        redisTemplate.opsForZSet().remove(KEY, orderId);
    }
    
    // 处理超时订单（定时任务调用）
    public void processExpiredOrders() {
        long now = System.currentTimeMillis();
        // 获取所有已超时的订单
        Set<String> orderIds = redisTemplate.opsForZSet().rangeByScore(KEY, 0, now);
        
        for (String orderId : orderIds) {
            RLock lock = redissonClient.getLock("lock:order_timeout:" + orderId);
            try {
                if (lock.tryLock(3, 30, TimeUnit.SECONDS)) {
                    // 原子移除
                    Long removed = redisTemplate.opsForZSet().remove(KEY, orderId);
                    if (removed != null && removed > 0) {
                        orderService.processTimeoutOrder(orderId);
                    }
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

// 定时任务配置
@Configuration
@EnableScheduling
public class ScheduleConfig {
    
    @Autowired
    private RedisOrderTimeoutQueue timeoutQueue;
    
    @Scheduled(fixedRate = 5000) // 每5秒执行一次
    public void checkOrderTimeout() {
        timeoutQueue.processExpiredOrders();
    }
}
```

**优点：**

* 简单易实现
* 利用Redis持久化
* 分布式友好

**缺点：**

* 轮询机制有延迟
* 需要处理并发竞争
* ZSet可能成为性能瓶颈

### 方案 4：分布式调度框架（XXL-JOB）

适用场景：复杂调度需求、已有调度基础设施

```
java

// XXL-JOB 处理器
@Component
public class OrderTimeoutJobHandler extends IJobHandler {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Override
    public ReturnT<String> execute(String param) {
        // 分片处理
        int shardIndex = getShardIndex();
        int shardTotal = getShardTotal();
        
        // 查询待处理订单（按分片规则）
        List<Order> orders = orderRepository.findTimeoutOrders(
            shardIndex, 
            shardTotal,
            PageRequest.of(0, 100)
        );
        
        for (Order order : orders) {
            processOrder(order);
        }
        
        return SUCCESS;
    }
    
    private void processOrder(Order order) {
        // 使用CAS更新状态
        int updated = orderRepository.updateOrderStatus(
            order.getOrderId(),
            OrderStatus.UNPAID.getValue(),
            OrderStatus.CANCELLED.getValue()
        );
        
        if (updated > 0) {
            // 执行取消逻辑
            inventoryService.releaseStock(order);
        }
    }
}
```

```
sql

SELECT * FROM orders 
WHERE status = 'UNPAID' 
AND created_time < DATE_SUB(NOW(), INTERVAL 30 MINUTE)
AND MOD(order_id % 1024, #{shardTotal}) = #{shardIndex}
LIMIT 100
```

**优点：**

* 可视化调度管理
* 分布式分片处理
* 失败重试机制
* 完善的监控报警

**缺点：**

* 系统复杂度增加
* 需要额外部署调度中心
* 实时性不如消息队列

## 方案对比与选型

| 方案 | 实时性 | 可靠性 | 分布式支持 | 复杂度 | 适用场景 |
| --- | --- | --- | --- | --- | --- |
| 消息队列延迟消息 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | 高并发生产环境（推荐方案） |
| 时间轮算法 | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐ | ⭐ | 单机高性能应用 |
| Redis ZSet 延迟队列 | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | 轻量级应用，已有Redis |
| 分布式调度框架 | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | 复杂调度需求，已有调度中心 |
| 数据库定时扫描 | ⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐ | 小型系统（不推荐生产环境） |

## 生产环境最佳实践

**多层防御机制**

![deepseek_mermaid_20250531_465cbd.png](https://blog.liushigong.cn/static/img/2f7e0c525826abbb771564e6695bd50c.deepseek_mermaid_20250531_465cbd.webp)

* 主要通道：使用 RocketMQ 延迟消息处理实时超时
* 补偿机制：通过 XXL-JOB 每天执行一次对账任务
* 前端辅助：在用户界面显示倒计时提醒
* 监控报警：实现处理延迟、失败率的实时监控

这种组合方案能兼顾实时性、可靠性和可维护性，适合大多数生产环境。具体选型应根据团队技术栈、系统规模和业务需求灵活调整。