在Java编程中，代理设计模式是一种非常实用的设计原则，它允许我们为对象提供一个替代者，以控制对原始对象的访问。Java提供了三种主要的代理实现方式：静态代理、JDK动态代理和CGLIB动态代理。本文将详细介绍这三种代理机制及其应用场景。

1. 静态代理

定义：静态代理是在编译期间就创建好的代理类，其代理逻辑是硬编码在代理类中的。代理类通常会实现与目标类相同的接口，并通过持有目标类的实例，在方法调用时进行前置或后置处理。

public interface Service {
    void doSomething();
}

// 目标类
public class RealService implements Service {
    @Override
    public void doSomething() {
        System.out.println("Real service doing something...");
    }
}

// 静态代理类
public class StaticProxy implements Service {
    private final Service realService;

    public StaticProxy(Service realService) {
        this.realService = realService;
    }

    @Override
    public void doSomething() {
        before();
        realService.doSomething();
        after();
    }

    private void before() {
        System.out.println("Static proxy: Preprocessing...");
    }

    private void after() {
        System.out.println("Static proxy: Postprocessing...");
    }
}

优缺点

• 优点：逻辑清晰，易于理解。
• 缺点：每增加一个新的业务接口都需要编写新的代理类，扩展性差。

2. JDK动态代理

定义：JDK动态代理是Java SE自带的动态代理机制，它利用反射机制生成代理类。代理类无需事先写好，而是根据给定的目标类接口在运行时动态生成。

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

public class JdkDynamicProxy implements InvocationHandler {

    private Object target;

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

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }

    private void before() {
        System.out.println("JDK dynamic proxy: Preprocessing...");
    }

    private void after() {
        System.out.println("JDK dynamic proxy: Postprocessing...");
    }
}

优缺点

• 优点：动态生成代理类，不需要预先编译，适用于需要灵活代理多种类型的场景。
• 缺点：要求目标类必须实现至少一个接口。

3. CGLIB动态代理

定义：CGLIB（Code Generation Library）是一个强大的高性能代码生成库，它可以在运行期扩展Java类与实现Java接口。CGLIB动态代理不依赖于接口，可以为没有实现接口的类创建代理。

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

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

    public Object getInstance(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        // 设置回调方法
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        before();
        Object result = proxy.invokeSuper(obj, args);
        after();
        return result;
    }

    private void before() {
        System.out.println("CGLIB dynamic proxy: Preprocessing...");
    }

    private void after() {
        System.out.println("CGLIB dynamic proxy: Postprocessing...");
    }
}

优缺点

• 优点：适用于无法修改源码且未实现接口的类，灵活性更强。
• 缺点：由于采用字节码技术，比JDK动态代理更复杂，对性能有一定影响。

4.小结

总结来说，选择哪种代理模式取决于具体的应用场景。静态代理适合结构稳定、扩展需求较少的情况；而动态代理则更适合频繁变动、需要灵活控制代理行为的场景，其中JDK动态代理适用于基于接口的代理，CGLIB动态代理适用于无接口或者不能修改源码的类的代理。