使用切面在controller层记录操作日志

日志切面

package com.feedback.service.common.aop.log;

import cn.hutool.core.exceptions.ExceptionUtil;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * 日志aop
 */
@Slf4j
@Aspect
@Component
public class LogAop {

    @Resource
    private OperationLogClient operationLogClient;

    @Value("${spring.application.name}")
    private String applicationName;


    @Pointcut(value = "@annotation(com.haier.hopm.feedback.api.common.annotations.Log)")
    public void cutService() {
    }

    @Around("cutService()")
    public Object recordSysLog(ProceedingJoinPoint point) throws Throwable {
        long startTime = System.currentTimeMillis();
        //先执行业务
        Object result = point.proceed();
        long endTime = System.currentTimeMillis();
        try {
            handle(point, endTime - startTime, UserUtil.getUserInfo(), JSONUtil.toJsonStr(result), null);
        } catch (Exception e) {
            log.error("日志记录出错!", e);
        }
        return result;
    }

    @AfterThrowing(pointcut = "cutService()", throwing = "e")
    public void doAfterThrowing(JoinPoint point, Throwable e) {
        try {
            handle(point, null, UserUtil.getUserInfo(), null, e);
        } catch (Exception ex) {
            log.error("日志记录出错!", ex);
        }
    }

    private void handle(JoinPoint point, Long methodProcessTime, SysUserDTO sysUserDTO, String outParamStr, Throwable e) throws Exception {
        //获取拦截的方法名
        Signature sig = point.getSignature();
        MethodSignature msig = null;
        if (!(sig instanceof MethodSignature)) {
            throw new IllegalArgumentException("该注解只能用于方法");
        }
        msig = (MethodSignature) sig;
        Object target = point.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        String methodName = currentMethod.getName();
        //获取拦截方法的参数
        Object[] params = point.getArgs();
        //获取操作名称
        Log annotation = currentMethod.getAnnotation(Log.class);
        String moduleName = annotation.moduleName();
        String operationName = annotation.value();
        OperationLogDTO operationLog = new OperationLogDTO();
        operationLog.setModuleName(applicationName);
        operationLog.setOperationName(operationName);
        operationLog.setMethodName(methodName);
        //sysLog.setParams(Arrays.toString(params));
        operationLog.setParamJson(JSONUtil.toJsonStr(params));
        operationLog.setResultJson(outParamStr);
        operationLog.setTime(methodProcessTime);
        operationLog.setRequestUrl(RequestContextHolderUtil.requestUrl());
        operationLog.setRequestMethod(RequestContextHolderUtil.requestMethod());
        operationLog.setUserAgent(RequestContextHolderUtil.getUserAgent());
        operationLog.setIp(RequestContextHolderUtil.getRemoteAddr());
        operationLog.setSuccess(Boolean.TRUE);
        operationLog.setCreateTime(new Date());
        if (sysUserDTO != null) {
            operationLog.setCreateBy(sysUserDTO.getUserAccount());
            operationLog.setCreateByName(sysUserDTO.getUserName());
        }
        if (e != null) {
            operationLog.setSuccess(Boolean.FALSE);
            operationLog.setErrorMsg(ExceptionUtil.getMessage(e));
        }
        operationLogClient.save(operationLog);
    }

}

日志注解

package com.feedback.api.common.annotations;

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

/**
 * 系统日志注解
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Log {
    String value() default "";

    String moduleName() default "";

}

保存日志实体类

package com.feedback.api.dto;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value = "OperationLogDTO", description = "系统操作日志表")
public class OperationLogDTO extends BaseDTO {

    @ApiModelProperty(value = "操作名称")
    private String operationName;

    @ApiModelProperty(value = "方法名称")
    private String methodName;

    @ApiModelProperty(value = "微服务名称")
    private String moduleName;

    @ApiModelProperty(value = "成功失败标记:0-失败;1-成功")
    private Boolean success;

    @ApiModelProperty(value = "请求参数")
    private String paramJson;

    @ApiModelProperty(value = "返回参数")
    private String resultJson;


    @ApiModelProperty(value = "异常信息")
    private String errorMsg;


    @ApiModelProperty(value = "执行时长(毫秒)")
    private Long time;


    @ApiModelProperty(value = "IP地址")
    private String ip;

    @ApiModelProperty(value = "请求地址")
    private String requestUrl;


    @ApiModelProperty(value = "请求方法")
    private String requestMethod;


    @ApiModelProperty(value = "浏览器信息")
    private String userAgent;


    @ApiModelProperty(value = "创建人姓名")
    protected String createByName;


}

<think>首先,用户的问题是:在Java中使用切面记录Controller层请求Body日志时,如果记录失败,如何实现日志回滚。具体来说,是关于AOP(面向切面编程)在记录请求Body日志时失败的回滚机制。 关键点: - 使用Java AOP(可能使用Spring AOP或AspectJ)。 - 记录Controller层的请求Body日志。 - 当记录失败时(例如,日志写入失败),如何回滚日志操作。 回滚在日志上下文中可能不是直接的,因为日志通常是异步的或非事务性的。但用户可能指的是确保日志失败不影响主业务逻辑,或者如何优雅处理日志失败。 从引用中: - 引用[1]:解释了AOP的核心概念,如切面、连接点、切入点、通知。 - 引用[2]:提供了一些关于Spring Boot AOP实现日志的参考文章。 - 引用[3]:展示了一个Controller方法,带有@LogInfo注解,用于记录日志。 - 引用[4]:描述了AOP的基本概念,并提到日志记录是横切关注点。 用户的问题焦点是:当记录日志失败时,如何回滚。在AOP中,日志记录通常是在通知(Advice)中实现的,比如在方法执行前后记录日志。 回滚通常与事务管理相关,但日志记录本身不是事务性的。日志失败可能意味着写入日志文件或数据库失败。因此,回滚可能指的是: - 确保日志失败不导致整个请求失败(即不影响业务逻辑)。 - 或者,在日志失败时,尝试回滚日志操作(如删除部分日志),但这可能不实际。 在Spring AOP中,通知的类型包括: - Before advice: 在方法执行前执行。 - After returning advice: 方法成功执行后执行。 - After throwing advice: 方法抛出异常后执行。 - After (finally) advice: 无论方法如何结束都执行。 - Around advice: 包围方法执行,可以在执行前后添加逻辑。 对于日志记录,常见做法是使用Around advice或After advice。如果日志记录失败,我们可能希望: 1. 捕获异常,避免传播到主业务逻辑。 2. 记录错误,但不回滚业务事务(因为日志是辅助操作)。 3. 如果日志是事务性的(如写入数据库),可以结合事务管理回滚。 但在标准日志记录中,日志通常是写入文件或外部系统,不是事务性的。所以,回滚可能不直接适用。 可能的解决方案: - **使用异常处理**:在通知中捕获日志记录异常,记录错误但不传播异常,这样主业务逻辑不受影响。 - **事务性日志**:如果日志存储在数据库中,可以使用Spring的事务管理。例如,在同一个事务中,如果日志写入失败,可以回滚整个事务(包括业务操作)。但这可能不理想,因为日志失败不应导致业务回滚。 - **异步日志**:使用异步方式记录日志,这样日志失败不影响主线程。 - **错误处理机制**:在切面中实现重试或回退逻辑。 用户提到“日志回滚”,可能意味着在日志失败时,撤销或忽略日志记录,而不影响请求处理。 结构回答: 1. **理解问题**:解释AOP日志记录的基本原理。 2. **分析失败场景**:当记录日志失败时(如IO异常),如何避免影响Controller方法。 3. **解决方案**: - 使用try-catch在通知中捕获异常。 - 确保日志操作是独立的,不参与业务事务。 - 如果使用数据库日志,配置事务传播。 4. **代码示例**:提供简单的代码示例。 5. **生成相关问题**:根据指令,生成相关问题。 系统指令: - 所有行内数学表达式用$...$。 - 独立公式用$$...$$(但这里可能不涉及)。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 引用的段落末尾添加引用标识,如[^1]。 用户可见层:回答结构清晰,逐步解决问题。 参考引用: - [^1] 解释了AOP核心概念。 - [^2] 提供了相关文章。 - [^3] 展示了Controller方法。 - [^4] 描述了AOP基础。 在回答中,自然地引用这些。 最终回答结构: 1. 介绍AOP日志记录。 2. 解释日志失败的可能原因。 3. 提出回滚策略。 4. 代码示例。 5. 生成相关问题。</think>### Java AOP 切面记录Controller请求Body日志失败时的回滚实现 在Java中使用AOP(面向切面编程)记录Controller层请求Body日志时,如果日志记录失败(例如,IO异常、数据库写入失败等),实现“日志回滚”的核心思路是:**确保日志操作不影响主业务逻辑,并通过异常处理机制隔离错误**。日志记录本质上是非事务性的辅助操作,因此“回滚”并非传统数据库事务的回滚,而是指在日志失败时避免传播异常、保证请求正常处理,并可选地记录错误信息。以下是逐步解决方案: --- #### 步骤1: 理解AOP日志记录的基本原理 在Spring AOP中,日志记录通常通过**切面(Aspect)** 实现: - **切入点(Pointcut)**:定义拦截目标(如所有Controller方法)。 - **通知(Advice)**:在方法执行前后添加日志逻辑(常用`@Around`或`@AfterReturning`通知)。 - 当记录日志失败时(如请求Body解析错误或日志写入异常),通知需捕获异常并处理,防止影响Controller的业务逻辑[^4]。 关键点:日志操作应独立于业务事务。如果日志失败导致异常传播,可能中断请求处理,这不是“回滚”而是错误处理。 --- #### 步骤2: 日志失败的回滚策略 “回滚”在此上下文的实现方式: 1. **隔离日志操作**:使用`try-catch`块包裹日志代码,捕获所有异常,确保错误不传播到Controller。 2. **错误降级处理**:日志失败时,记录错误到备用系统(如控制台或简单文件),或忽略日志但不影响业务。 3. **事务性日志(可选)**:如果日志存储到数据库,可结合Spring事务管理: - 为日志操作添加`@Transactional(propagation = Propagation.REQUIRES_NEW)`,使其独立事务。 - 日志失败时,事务自动回滚,但业务事务不受影响。 - 注意:这仅适用于数据库日志;文件日志或外部系统日志无法直接回滚。 --- #### 步骤3: 代码实现示例 以下是一个Spring Boot切面示例,使用`@Around`通知记录请求Body日志,并在失败时实现“回滚”(异常隔离): ```java import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.ServletRequestAttributes; import javax.servlet.http.HttpServletRequest; import java.io.BufferedReader; import java.util.stream.Collectors; @Aspect @Component public class RequestLoggingAspect { private static final Logger logger = LoggerFactory.getLogger(RequestLoggingAspect.class); // 切入点:拦截所有Controller方法 @Around("execution(* com.example.controller.*.*(..))") public Object logRequest(ProceedingJoinPoint joinPoint) throws Throwable { HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest(); String requestBody = null; // 1. 尝试读取请求Body try { if ("POST".equalsIgnoreCase(request.getMethod()) || "PUT".equalsIgnoreCase(request.getMethod())) { BufferedReader reader = request.getReader(); requestBody = reader.lines().collect(Collectors.joining()); } } catch (Exception e) { // 日志失败时:捕获异常,不传播错误 logger.error("日志记录失败(请求Body解析错误)", e); // 可选:记录到备用系统或忽略 } // 2. 执行业务逻辑(Controller方法) Object result = joinPoint.proceed(); // 3. 记录日志(示例:简单打印) try { if (requestBody != null) { logger.info("请求Body: {}", requestBody); // 实际中可写入文件/数据库 } } catch (Exception e) { // 日志失败回滚:捕获异常,保证业务正常 logger.error("日志写入失败", e); } return result; // 正常返回结果,请求不受影响 } } ``` **代码解释**: - **隔离日志操作**:所有日志代码包裹在`try-catch`中。如果日志失败(如`IOException`),异常被捕获并记录错误,但`joinPoint.proceed()`执行业务逻辑不受影响。 - **回滚效果**:日志失败不会中断Controller请求,实现“逻辑回滚”。 - **事务性扩展**:如果日志写入数据库,在`try`块中添加数据库操作,并用`@Transactional(rollbackFor = Exception.class)`管理独立事务。 --- #### 步骤4: 最佳实践与注意事项 1. **异步日志**:使用`@Async`或消息队列(如Kafka)异步处理日志,避免阻塞主线程。失败时可重试或丢弃。 - 示例:将日志发送到队列,后台线程消费。失败时,队列自动重试或记录死信。 2. **错误监控**:集成Sentry或ELK栈,集中处理日志失败事件。 3. **性能考虑**:读取请求Body可能影响性能,建议在切面中缓存或使用过滤器预处理。 4. **事务边界**:业务事务(如DB操作)和日志事务必须分离。使用`Propagation.REQUIRES_NEW`确保日志失败不污染业务数据[^1]。 > **关键公式**:在错误处理中,日志失败的概率$P_{\text{fail}}$不应影响请求成功率$R_{\text{success}}$。即: > $$R_{\text{success}} = 1 - P_{\text{biz\_fail}}$$ > 其中$P_{\text{biz\_fail}}$是业务失败概率,通过隔离日志错误,确保$P_{\text{biz\_fail}}$与日志无关[^4]。 --- #### 相关问题 1. 如何优化AOP切面以避免日志记录Controller性能的影响? 2. 在Spring Boot中,如何实现异步日志记录以提高系统吞吐量? 3. 如果使用数据库存储日志,如何配置事务回滚机制确保数据一致性? 4. AOP切面中,如何处理文件日志写入失败的重试策略? [^1]: AOP的核心概念包括切面、连接点、切入点等,用于分离公共逻辑如日志记录。 [^2]: Spring Boot AOP实现日志的参考文章包括统一请求响应日志操作日志记录等。 [^3]: Controller方法可通过注解如@LogInfo标记日志点,结合AOP拦截请求Body。 [^4]: AOP通过切面模块化横切关注点如日志,使业务代码保持干净。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值