@Service
public class OrderServiceImpl implements OrderService {
    public void createOrder(OrderCreateDTO dto) {
        // --- 非核心逻辑：性能监控 ---
        long start = System.currentTimeMillis();
        
        // --- 非核心逻辑：简陋的权限校验 ---
        if (!"admin".equals(UserContext.getCurrentUser().getRole())) {
             throw new RuntimeException("无权操作");
        }
        
        // --- 非核心逻辑：日志记录 ---
        log.info("开始创建订单，操作人: {}", UserContext.getCurrentUser().getName());
        
        // --- 核心业务逻辑（真正的价值所在） ---
        log.info("1. 校验库存...");
        productService.decreaseStock(dto.getProductId(), dto.getQuantity());
        log.info("2. 创建订单记录...");
        Order order = convertToPO(dto);
        orderMapper.insert(order);
        
        // --- 非核心逻辑：收尾工作 ---
        log.info("订单创建成功，ID: {}", order.getId());
        long duration = System.currentTimeMillis() - start;
        log.info("耗时: {}ms", duration);
    }
}

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("sys_user") // 使用 @TableName 注解将实体类与数据库表 sys_user 关联
public class User {
    private Long id;
    private String username;
    private String role;
}

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper // 标记为 MyBatis 的 Mapper 接口，Spring 会为它创建实现类
public interface UserMapper extends BaseMapper<User> {
    // 继承了 BaseMapper 后，就自动拥有了强大的 CRUD 能力，无需手写任何 SQL 和 XML
}

package com.example.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.demo.mapper") // 扫描 Mapper 接口所在的包
public class DemoApplication {

    public static void main(String [] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

package com.example.demo.aspect;

import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 java.util.Arrays;

@Aspect      // 声明这是一个切面类
@Component   // 将其作为 Bean 交给 Spring 容器管理
@Slf4j       // 使用 Lombok 提供的日志功能
public class WebLogAspect {

    /**
     * 定义切点。
     * 匹配 com.example.demo.controller 包及其子包下的所有类的所有公共方法。
     */
    @Pointcut(" execution(public * com.example.demo.controller..*.*(..))")
    public void webLogPointcut() {}

    /**
     * @Around 是最强大的通知类型，它能完全控制目标方法的执行。
     * ProceedingJoinPoint 参数是 JoinPoint 的子类，只能在 @Around 通知中使用，
     * 它提供了一个 proceed() 方法来执行原始的目标方法。
     */
    @Around("webLogPointcut()")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        // 1. 获取当前 HTTP 请求信息
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = (attributes != null) ? attributes.getRequest() : null;

        Object result;
        // 必须用 try-finally 来确保无论方法成功还是异常，日志都能被记录
        try {
            // 2. 执行目标方法
            // pjp.proceed() 的返回值就是目标方法的返回值
            result = pjp.proceed();
            return result;
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            
            // 3. 记录完整的请求日志
            if (request != null) {
                Signature signature = pjp.getSignature();
                log.info("------------------- Request Log Start -------------------");
                log.info("请求 URL      : {}", request.getRequestURL());
                log.info("HTTP Method  : {}", request.getMethod());
                log.info("来源 IP        : {}", request.getRemoteAddr());
                log.info("执行的类.方法 : {}.{}", signature.getDeclaringTypeName(), signature.getName());
                log.info("请求参数      : {}", Arrays.toString(pjp.getArgs()));
                log.info("执行耗时      : {} ms", duration);
                log.info("------------------- Request Log End ---------------------");
            }
        }
    }
}

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @GetMapping("/hello")
    public String sayHello(@RequestParam("name") String name) throws InterruptedException {
        // 模拟业务耗时
        Thread.sleep(100); 
        return "Hello, " + name;
    }
}

package com.example.demo.annotation;

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;

@Target(ElementType.METHOD) // 此注解只能用于方法上
@Retention(RetentionPolicy.RUNTIME) // 注解在运行时可见，AOP 才能读取到
@Documented
public @interface Log {
    /**
     * 操作的业务描述, e.g., "创建用户", "更新订单状态"
     */
    String description();
}

package com.example.demo.aspect;

import com.example.demo.annotation.Log;
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.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
@Slf4j
public class OperationLogAspect {

    /**
     * 定义切点，匹配所有被 @Log 注解标记的方法。
     */
    @Pointcut("@annotation(com.example.demo.annotation.Log)")
    public void operationLogPointcut() {}
    
    @Around("operationLogPointcut()")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        Object result;
        String status = "成功";
        
        try {
            result = pjp.proceed();
            return result;
        } catch (Throwable e) {
            status = "失败";
            // 异常需要继续向上抛出，以便全局异常处理器能够捕获并处理
            throw e; 
        } finally {
            // 通过反射获取方法上的注解信息
            MethodSignature signature = (MethodSignature) pjp.getSignature();
            Method method = signature.getMethod();
            Log logAnnotation = method.getAnnotation(Log.class);
            String description = logAnnotation.description();
            
            // 模拟记录操作日志到数据库或日志文件
            log.info("==== ==== ==== = Operation Log ==== ==== ==== =");
            log.info("业务操作: {}", description);
            // 在真实项目中，操作人应从 SecurityContext 或 Token 中获取
            log.info("操作人: {}", "Admin"); 
            log.info("执行状态: {}", status);
            log.info("==== ==== ==== ==== ==== ==== ==== ==== ==== ====");
        }
    }
}

// ... 已有代码

import com.example.demo.annotation.Log;
// ...

@GetMapping("/deleteUser")
@Log(description = "删除用户操作") // 添加我们的自定义注解
public String deleteUser(@RequestParam("userId") Long userId) {
    if (userId < 0) {
        // 模拟一个失败场景
        throw new IllegalArgumentException("用户 ID 不能为负数");
    }
    log.info("正在执行删除用户 {} 的业务逻辑...", userId);
    return "用户 " + userId + " 删除成功";
}

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private UserRoleService userRoleService; // 假设用于查询用户角色

    @DeleteMapping("/delete/{id}")
    public String deleteUser(@PathVariable Long id, @RequestHeader("X-User-Id") Long currentUserId) {
        // 1. 手动获取当前用户角色
        String userRole = userRoleService.getRoleByUserId(currentUserId);
        
        // 2. 硬编码进行权限判断
        if (! "ADMIN".equals(userRole)) {
            // 3. 手动返回错误信息
            return "权限不足！"; 
        }

        // --- 真正的业务逻辑 ---
        userService.deleteById(id);
        return "用户删除成功";
    }
    
    // 其他几十个需要 ADMIN 权限的接口...
    // @PostMapping("/resetPassword")
    // @PostMapping("/publishNotice")
    // ... 每个方法里都有一段几乎一模一样的 if-else ...
}