#代理模式

// 业务接口
public interface UserService {
    void createUser(String name);
    void deleteUser(Long id);
}

// 真实业务实现
public class UserServiceImpl implements UserService {
    @Override
    public void createUser(String name) {
        System.out.println("创建用户: " + name);
    }

    @Override
    public void deleteUser(Long id) {
        System.out.println("删除用户: " + id);
    }
}

// 静态代理类
public class UserServiceProxy implements UserService {
    private final UserService target;

    public UserServiceProxy(UserService target) {
        this.target = target;
    }

    @Override
    public void createUser(String name) {
        long start = System.currentTimeMillis();
        try {
            // 前置增强：参数校验
            if (name == null || name.isEmpty()) {
                throw new IllegalArgumentException("用户名不能为空");
            }
            // 调用真实对象
            target.createUser(name);
            // 后置增强：成功日志
            System.out.println("用户创建成功，耗时: " + (System.currentTimeMillis() - start) + "ms");
        } catch (Exception e) {
            System.out.println("用户创建失败: " + e.getMessage());
            throw e;
        }
    }

    @Override
    public void deleteUser(Long id) {
        long start = System.currentTimeMillis();
        try {
            target.deleteUser(id);
            System.out.println("用户删除成功，耗时: " + (System.currentTimeMillis() - start) + "ms");
        } catch (Exception e) {
            System.out.println("用户删除失败: " + e.getMessage());
            throw e;
        }
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// InvocationHandler：处理方法调用的调用处理器
public class PerformanceHandler implements InvocationHandler {
    private final Object target;

    public PerformanceHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();
        String methodName = method.getName();
        try {
            // 调用真实对象的方法
            Object result = method.invoke(target, args);
            long cost = System.currentTimeMillis() - start;
            System.out.println("[性能监控] " + methodName + " 执行耗时: " + cost + "ms");
            return result;
        } catch (Exception e) {
            long cost = System.currentTimeMillis() - start;
            System.out.println("[性能监控] " + methodName + " 执行异常，耗时: " + cost + "ms");
            throw e;
        }
    }
}

// 创建代理对象
public class JdkProxyDemo {
    public static void main(String[] args) {
        UserService realService = new UserServiceImpl();

        UserService proxy = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),  // 类加载器
            new Class<?>[] { UserService.class }, // 要代理的接口
            new PerformanceHandler(realService)   // 调用处理器
        );

        proxy.createUser("张三");
        proxy.deleteUser(1L);
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        // 设置父类：CGLib 通过继承实现代理
        enhancer.setSuperclass(UserServiceImpl.class);
        // 设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args,
                                    MethodProxy proxy) throws Throwable {
                long start = System.currentTimeMillis();
                try {
                    // 调用父类的方法（CGLib 是继承，所以用 super）
                    Object result = proxy.invokeSuper(obj, args);
                    System.out.println("[CGLib] " + method.getName() + " 耗时: "
                                       + (System.currentTimeMillis() - start) + "ms");
                    return result;
                } catch (Exception e) {
                    System.out.println("[CGLib] " + method.getName() + " 异常");
                    throw e;
                }
            }
        });

        UserServiceImpl proxy = (UserServiceImpl) enhancer.create();
        proxy.createUser("李四");
        proxy.deleteUser(2L);
    }
}

// application.properties
# 强制使用 CGLib（即使有接口也用继承方式）
spring.aop.proxy-target-class=true

# 优先使用 JDK 动态代理（默认）
spring.aop.proxy-target-class=false

public class TransactionInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Connection connection = null;
        try {
            connection = DataSourceUtils.getConnection();
            connection.setAutoCommit(false);

            Object result = invocation.proceed(); // 调用目标方法

            connection.commit();
            return result;
        } catch (Exception e) {
            if (connection != null) {
                connection.rollback();
            }
            throw e;
        } finally {
            if (connection != null) {
                connection.setAutoCommit(true);
                DataSourceUtils.releaseConnection(connection);
            }
        }
    }
}

public class LazyProxy implements Image {
    private RealImage realImage;
    private String filename;

    public LazyProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        // 第一次使用时才加载真实对象
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

public class SecurityProxy<T> implements InvocationHandler {
    private final T target;
    private final Set<String> allowedRoles;

    public SecurityProxy(T target, Set<String> allowedRoles) {
        this.target = target;
        this.allowedRoles = allowedRoles;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        RequiredRole annotation = method.getAnnotation(RequiredRole.class);
        if (annotation != null) {
            String requiredRole = annotation.value();
            if (!allowedRoles.contains(requiredRole)) {
                throw new SecurityException("无权限访问: " + requiredRole);
            }
        }
        return method.invoke(target, args);
    }
}