用get ai助手辅助搜索资料，代理模式从入门到面试通关（2026-04-08）

public interface SmsService {
    void send(String message);
}

public class SmsServiceImpl implements SmsService {
    @Override
    public void send(String message) {
        System.out.println("发送消息：" + message);
    }
}

// 代理类：实现同一接口，持有真实对象引用
public class SmsProxy implements SmsService {
    private final SmsService smsService;
    
    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }
    
    @Override
    public void send(String message) {
        // 前置增强：日志记录
        System.out.println("【前置】发送消息开始：" + message);
        
        // 调用真实对象的核心方法
        smsService.send(message);
        
        // 后置增强：日志记录
        System.out.println("【后置】消息发送成功");
    }
}

// 使用方式
SmsService realService = new SmsServiceImpl();
SmsService proxy = new SmsProxy(realService);
proxy.send("Hello");  // 调用代理对象，代理内部调用真实对象

public class LogInvocationHandler implements InvocationHandler {
    private final Object target;  // 真实对象
    
    public LogInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        System.out.println("【前置】调用方法：" + method.getName());
        // 反射调用真实对象的方法
        Object result = method.invoke(target, args);
        // 后置增强
        System.out.println("【后置】方法执行完成");
        return result;
    }
}

// 使用方式
SmsService realService = new SmsServiceImpl();
InvocationHandler handler = new LogInvocationHandler(realService);
SmsService proxy = (SmsService) Proxy.newProxyInstance(
    realService.getClass().getClassLoader(),
    realService.getClass().getInterfaces(),
    handler
);
proxy.send("Hello");

public class LogMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, 
                           MethodProxy proxy) throws Throwable {
        System.out.println("【前置】调用方法：" + method.getName());
        Object result = proxy.invokeSuper(obj, args);  // 调用父类原始方法
        System.out.println("【后置】方法执行完成");
        return result;
    }
}

// 使用方式（需引入cglib依赖）
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(SmsServiceImpl.class);
enhancer.setCallback(new LogMethodInterceptor());
SmsServiceImpl proxy = (SmsServiceImpl) enhancer.create();
proxy.send("Hello");

// 抽象主题：订单服务接口
public interface OrderService {
    void placeOrder(String userId, String productId);
}

// 真实主题：核心业务实现
public class OrderServiceImpl implements OrderService {
    @Override
    public void placeOrder(String userId, String productId) {
        System.out.println("核心业务：用户 " + userId + " 下单商品 " + productId);
    }
}

public class OrderServiceStaticProxy implements OrderService {
    private final OrderService target;
    
    public OrderServiceStaticProxy(OrderService target) {
        this.target = target;
    }
    
    @Override
    public void placeOrder(String userId, String productId) {
        // 前置增强：权限校验 + 日志记录
        System.out.println("【静态代理前置】校验用户权限：" + userId);
        System.out.println("【静态代理前置】记录请求日志");
        
        target.placeOrder(userId, productId);  // 调用真实业务
        
        // 后置增强：发送通知
        System.out.println("【静态代理后置】发送下单成功通知");
    }
}

// 统一的增强处理器
public class LogAndAuthInvocationHandler implements InvocationHandler {
    private final Object target;
    
    public LogAndAuthInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【动态代理前置】方法：" + method.getName());
        System.out.println("【动态代理前置】参数：" + Arrays.toString(args));
        
        Object result = method.invoke(target, args);
        
        System.out.println("【动态代理后置】执行完成");
        return result;
    }
}

// 使用方式
OrderService realService = new OrderServiceImpl();
OrderService proxy = (OrderService) Proxy.newProxyInstance(
    realService.getClass().getClassLoader(),
    realService.getClass().getInterfaces(),
    new LogAndAuthInvocationHandler(realService)
);
proxy.placeOrder("user001", "productA");

【动态代理前置】方法：placeOrder
【动态代理前置】参数：[user001, productA]
核心业务：用户 user001 下单商品 productA
【动态代理后置】执行完成