@Service
public class BillService {

    private static final Logger logger = LoggerFactory.getLogger(BillService.class);

    public void saveBill(Bill bill) {
        // 日志记录 - 重复代码
        logger.info("开始保存账单：" + bill.getAmount());
        long startTime = System.currentTimeMillis();

        try {
            // 核心业务逻辑
            System.out.println("执行保存账单业务逻辑");
        } catch (Exception e) {
            logger.error("保存失败：" + e.getMessage());
            throw e;
        } finally {
            // 性能监控 - 重复代码
            long endTime = System.currentTimeMillis();
            logger.info("保存账单耗时：" + (endTime - startTime) + "ms");
        }
    }

    public void updateBill(Bill bill) {
        // 同样的日志、监控代码再次出现——严重冗余！
    }
}

@Aspect
@Component
public class BillLoggingAspect {

    // 定义可复用的切点：匹配com.example.bill.service包下所有类的所有方法
    @Pointcut("execution( com.example.bill.service..(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("【前置】方法执行前，目标方法：" + joinPoint.getSignature().getName());
    }

    @After("serviceMethods()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("【后置】方法执行后");
    }

    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【返回】方法正常返回，返回值：" + result);
    }

    @AfterThrowing(pointcut = "serviceMethods()", throwing = "error")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {
        System.out.println("【异常】方法抛出异常：" + error.getMessage());
    }

    @Around("serviceMethods()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【环绕前】开始执行：" + joinPoint.getSignature().toShortString());
        
        Object result = joinPoint.proceed(); // 执行目标方法
        
        long end = System.currentTimeMillis();
        System.out.println("【环绕后】执行完成，耗时：" + (end - start) + "ms");
        return result;
    }
}

// 匹配指定包下所有类的所有方法
@Pointcut("execution( com.example.bill.service..(..))")

// 匹配被指定注解标记的方法
@Pointcut("@annotation(com.example.anno.BillLog)")

// 匹配指定类中的所有方法
@Pointcut("within(com.example.bill.service.BillService)")

// 匹配参数类型为String的方法
@Pointcut("args(java.lang.String)")

// Step 1：定义接口（JDK代理要求）
public interface UserService {
    void register();
}

// Step 2：实现类
public class UserServiceImpl implements UserService {
    @Override
    public void register() {
        System.out.println("执行注册业务逻辑");
    }
}

// Step 3：AOP代理核心实现
import java.lang.reflect.;
public class AOPProxy {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // 前置增强：方法执行前
                    System.out.println("【Before】方法执行前：记录日志");
                    Object result = method.invoke(target, args);  // 执行目标方法
                    // 后置增强：方法执行后
                    System.out.println("【After】方法执行后：记录日志");
                    return result;
                }
            }
        );
    }
}

// Step 4：测试
public class Main {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) AOPProxy.getProxy(target);
        proxy.register();
    }
}

【Before】方法执行前：记录日志
执行注册业务逻辑
【After】方法执行后：记录日志

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Configuration
@EnableAspectJAutoProxy  // 启用AspectJ自动代理，告诉Spring扫描@Aspect切面并生成代理对象
public class AopConfig {
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MethodExecutionTimeAspect {

    private static final Logger logger = LoggerFactory.getLogger(MethodExecutionTimeAspect.class);

    // 定义切点：匹配controller包下的所有方法
    @Pointcut("execution( com.example.demo.controller..(..))")
    public void controllerMethods() {}

    // 环绕通知：记录方法执行时间
    @Around("controllerMethods()")
    public Object recordExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        try {
            Object result = joinPoint.proceed();  // 执行目标方法
            long endTime = System.currentTimeMillis();
            logger.info("方法 [{}] 执行时间: {} ms", 
                joinPoint.getSignature().toShortString(), endTime - startTime);
            return result;
        } catch (Exception e) {
            logger.error("方法 [{}] 执行异常: {}", joinPoint.getSignature().toShortString(), e.getMessage());
            throw e;
        }
    }
}

方法 [UserController.getUserById] 执行时间: 2 ms