虽然直接用log.infohen简单，但在大型项目里这样写太乱了。我们需要封装一个工具类，统一管理日志的格式和逻辑。这就好比给你的日志系统配了一把多功Neng瑞士军刀，不管遇到什么情况，掏出来就Neng用。

这个工具类要负责记录方法的进出、业务的关键节点、异常情况，甚至还要Neng监控慢查询。有了它，你的业务代码里就不需要到处散落着日志逻辑了。

package com.example.demo.utils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Component
@Slf4j  // Lombok的魔法，自动生成log变量，爽歪歪
public class LogUtil {
    /**
     * 记录方法入口
     */
    public void methodEnter {
        log.debug;
    }
    /**
     * 记录方法出口
     */
    public void methodExit {
        log.debug;
    }
    /**
     * 记录核心业务逻辑
     */
    public void businessLog {
        log.info;
    }
    /**
     * 记录异常
     */
    public void error {
        log.error;
    }
    /**
     * 慢查询监控
     */
    public void slowQuery {
        if  {  // 超过1秒就算慢
            log.warn;
        }
    }
}

Ru果你在每个方法里dou手动调用LogUtil，那写起来还是挺累的，而且容易漏。这时候，AOP就派上用场了。它就像是一个无处不在的隐形摄像头，不管你在Controller还是Service里只要符合规则，它就Neng自动帮你把所有动作拍下来。

通过切面我们Ke以拦截Controller层的请求，记录IP、URL、参数；也Ke以拦截Service层，计算方法执行时间。这才是真正的自动化运维。

package com.example.demo.aop;
import com.example.demo.utils.LogUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
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.util.Arrays;
@Aspect
@Component
@Slf4j
@RequiredArgsConstructor
public class LogAspect {
    private final LogUtil logUtil;
    /**
     * 定义切点：Controller层的所有方法
     */
    @Pointcut)")
    public void controllerPointcut {}
    /**
     * 定义切点：Service层的所有方法
     */
    @Pointcut)")
    public void servicePointcut {}
    /**
     * 环绕通知：专门盯着Controller
     */
    @Around")
    public Object logController throws Throwable {
        // 先把请求上下文抓过来
        ServletRequestAttributes attributes = 
             RequestContextHolder.getRequestAttributes;
        String requestUrl = "Unknown";
        String httpMethod = "Unknown";
        String ip = "Unknown";
        if  {
            HttpServletRequest request = attributes.getRequest;
            requestUrl = request.getRequestURL.toString;
            httpMethod = request.getMethod;
            ip = request.getRemoteAddr;
        }
        String methodName = joinPoint.getSignature.getName;
        String className = joinPoint.getTarget.getClass.getSimpleName;
        Object args = joinPoint.getArgs;
        // 开始记录日志
        log.info;
        log.info;
        log.info;
        log.info;
        log.info);
        long startTime = System.currentTimeMillis;
        Object result;
        try {
            // 真正执行业务逻辑
            result = joinPoint.proceed;
            long costTime = System.currentTimeMillis - startTime;
            log.info;
            log.info;
            log.info;
            return result;
        } catch  {
            long costTime = System.currentTimeMillis - startTime;
            // 出错了也要记下来
            log.error;
            log.error);
            log.info;
            throw e;
        }
    }
    /**
     * 环绕通知：盯着Service层
     */
    @Around")
    public Object logService throws Throwable {
        String methodName = joinPoint.getSignature.getName;
        Object args = joinPoint.getArgs;
        logUtil.methodEnter;
        long startTime = System.currentTimeMillis;
        try {
            Object result = joinPoint.proceed;
            long costTime = System.currentTimeMillis - startTime;
            logUtil.methodExit;
            logUtil.slowQuery;
            return result;
        } catch  {
            logUtil.error;
            throw e;
        }
    }
}

配置douZuo好了现在得写点代码让它动起来。我们需要一个Controller来接收请求，一个Service来处理业务，顺便再模拟一下异常情况，kankan我们的日志系统Neng不Neng扛得住。

// UserController.java
package com.example.demo.controller;
import com.example.demo.service.UserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping
@Slf4j
@RequiredArgsConstructor
public class UserController {
    private final UserService userService;
    @GetMapping
    public String getUser {
        log.info;
        return userService.getUserById;
    }
    @PostMapping
    public String createUser {
        log.info;
        // 故意搞个异常，测试一下
        if ) {
            throw new RuntimeException;
        }
        return "用户创建成功: " + userData;
    }
}
// UserService.java
package com.example.demo.service;
import com.example.demo.utils.LogUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class UserService {
    private final LogUtil logUtil;
    public String getUserById {
        logUtil.businessLog;
        // 模拟查库
        try {
            Thread.sleep;  // 假装hen慢
            if  {
                throw new RuntimeException;
            }
            return "用户-" + id;
        } catch  {
            logUtil.error;
            return "查询失败";
        }
    }
}

不管我们多小心，异常总是难免的。Ru果每个方法里dou写try-catch，那代码丑得没法kan。我们需要一个全局的异常处理器，统一捕获所有“漏网之鱼”，给用户一个体面的回复，同时把详细的错误记下来。

package com.example.demo.handler;
import com.example.demo.utils.LogUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
@RestControllerAdvice
@Slf4j
@RequiredArgsConstructor
public class GlobalExceptionHandler {
    private final LogUtil logUtil;
    @ExceptionHandler
    public Map handleException {
        // 先记下来
        logUtil.error;
        // 再组装返回给前端的JSON
        Map result = new HashMap<>;
        result.put;
        result.put;
        result.put);
        result.put);
        // Ru果是开发环境，就把详细错误也返回去，方便调试
        if ) {
            result.put);
            result.put);
        }
        return result;
    }
    private boolean isDevelopment {
        // 这里Ke以根据配置文件判断
        return true;  // 暂时假设是开发环境
    }
}

基础功Neng有了但要想在生产环境里混得开，还得有点绝活。比如怎么保护用户隐私？怎么处理海量日志？

千万别把用户的手机号、身份证直接打印到日志里那是法律风险！我们需要一个过滤器，把这些敏感信息变成星号。

@Component
public class LogSensitiveFilter {
    public String filterSensitive {
        // 手机号脱敏
        logContent = logContent.replaceAll\\d{4}", "$1****$2");
        // 身份证脱敏
        logContent = logContent.replaceAll\\d{8}", "$1********$2");
        // 邮箱脱敏
        logContent = logContent.replaceAll\\w+", "$1***$2");
        return logContent;
    }
}

开发和生产环境不Neng混为一谈。开发环境我们要DEBUG级别的详细日志，生产环境只要INFO和ERROR。而且，日志文件Zui好分开存。

# application-dev.yml 
logging:
  level:
    root: DEBUG  # 开发时越详细越好
  file:
    name: logs/dev-app.log
---
# application-prod.yml 
logging:
  level:
    root: INFO  # 生产环境保持安静
    com.example.demo: WARN  # 自己的代码也低调点
  file:
    name: /var/log/my-app/app.log  # 存到Linux标准目录

Ru果你的系统规模大了光kan文件是不行的，这时候就得祭出ELK这套组合拳了。把日志转换成JSON格式发出去，就Neng在Kibana里炫酷地搜索分析了。

# 添加Logstash编码器依赖
dependencies:
  implementation 'net.logstash.logback:logstash-logback-encoder:7.3'

好了经过这一番折腾，你的SpringBoot应用现在Yi经拥有了一个相当完善的日志系统了。从Zui基础的配置，到AOP的无侵入监控，再到全局异常处理和脱敏安全，这一套组合拳下来基本上Neng覆盖90%的开发场景。

记住日志不是写给自己kan的，是写给“未来的自己”和“倒霉的同事”kan的。多花点时间在日志上，当你下次面对生产环境的Bug时你会发现，原来生活Ke以这么美好。别犹豫了赶紧去你的项目里试试吧！