public class UserService {
    public void register(String username, String password) {
        // 日志记录——重复
        System.out.println("【日志】开始执行register方法，参数：" + username);
        // 事务开启——重复
        System.out.println("【事务】开启事务");
        try {
            // 核心业务逻辑
            System.out.println("执行用户注册，用户名：" + username);
            // 事务提交——重复
            System.out.println("【事务】提交事务");
            // 日志记录——重复
            System.out.println("【日志】register方法执行完成");
        } catch (Exception e) {
            // 事务回滚——重复
            System.out.println("【事务】回滚事务");
            // 日志记录异常——重复
            System.out.println("【日志】register方法执行异常：" + e.getMessage());
        }
    }
    
    public void updateProfile(Long userId, String nickname) {
        // 同样的日志、事务代码重复出现...
    }
}

@Pointcut("execution( com.example.service..(..))")
public void serviceLayer() {} // 匹配service包下所有类的所有方法

@Pointcut("@annotation(com.example.Log)")
public void logAnnotation() {} // 匹配被@Log注解标记的方法

import java.lang.annotation.;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequirePermission {
    String value();  // 需要的权限标识
}

import org.springframework.stereotype.Service;

@Service
public class OrderService {
    
    @RequirePermission("ORDER_CREATE")
    public void createOrder(String productId, int quantity) {
        System.out.println("执行创建订单业务逻辑");
    }
    
    @RequirePermission("ORDER_VIEW")
    public String getOrderDetail(Long orderId) {
        System.out.println("执行查询订单详情业务逻辑");
        return "订单详情";
    }
    
    // 普通方法，无权限校验
    public void testMethod() {
        System.out.println("这是一个不需要权限校验的方法");
    }
}

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

@Aspect          // 标记为切面类
@Component       // 交由Spring容器管理
public class PermissionAspect {
    
    // 定义切点：匹配所有被@RequirePermission注解标记的方法
    @Pointcut("@annotation(requirePermission)")
    public void permissionPointcut(RequirePermission requirePermission) {}
    
    // 环绕通知：实现权限校验逻辑
    @Around("permissionPointcut(requirePermission)")
    public Object checkPermission(ProceedingJoinPoint joinPoint, 
                                   RequirePermission requirePermission) throws Throwable {
        String requiredPermission = requirePermission.value();
        System.out.println("【权限校验】需要权限：" + requiredPermission);
        
        // 模拟获取当前用户的权限列表
        String currentUserPermission = "ORDER_CREATE";
        
        if (currentUserPermission.equals(requiredPermission)) {
            System.out.println("【权限校验】校验通过，执行目标方法");
            // 执行目标方法
            Object result = joinPoint.proceed();
            System.out.println("【权限校验】目标方法执行完成");
            return result;
        } else {
            System.out.println("【权限校验】校验失败，无权执行该方法");
            throw new SecurityException("权限不足，需要：" + requiredPermission);
        }
    }
}

@SpringBootApplication
@EnableAspectJAutoProxy  // 启用AOP代理
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = 
            SpringApplication.run(Application.class, args);
        
        OrderService orderService = context.getBean(OrderService.class);
        
        // 调用需要权限校验的方法
        orderService.createOrder("P10001", 2);
        // 调用不需要权限校验的方法
        orderService.testMethod();
    }
}

import java.lang.reflect.;

public class JdkAopDemo {
    // 目标接口
    public interface UserService {
        void register();
    }
    // 目标实现类
    public static class UserServiceImpl implements UserService {
        @Override
        public void register() {
            System.out.println("执行注册业务逻辑");
        }
    }
    
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        
        // 创建JDK动态代理
        UserService proxy = (UserService) 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("【代理前置增强】方法执行前");
                    Object result = method.invoke(target, args);
                    System.out.println("【代理后置增强】方法执行后");
                    return result;
                }
            }
        );
        
        proxy.register();
    }
}

【代理前置增强】方法执行前
执行注册业务逻辑
【代理后置增强】方法执行后

如果目标类实现了接口 且 未强制使用CGLIB → 使用 JDK 动态代理
否则 → 使用 CGLIB 动态代理