java 代理模式怎么实现

代理模式（Proxy Pattern）在Java中是一种结构型设计模式，可以在不改变其原有类的代码的情况下对某个对象提供一个替代品或占位符，以控制对这个对象的访问。代理模式有三种类型：静态代理、动态代理（分为JDK动态代理和CGLIB动态代理）和Java字节码实现的代理（如使用ASM）。在静态代理中，我们会自己定义一个代理类，这个代理类会实现和原始对象相同的接口，并在内部持有一个对真实对象的引用，通过重写接口中定义的方法来扩展或者控制对被代理对象的访问。

一、代理模式的概念

代理模式通过创建一个代理对象，用这个代理对象来代表真实对象。客户端不直接与真实对象交互，而是通过代理对象来进行间接交云。代理对象控制了对真实对象的访问，并可以在此过程中添加一些特定的操作。

二、代理模式的优势

降低系统的耦合度

通过使用代理模式，可以分离真实对象的实现和客户端的使用，从而降低系统的耦合度，提高系统的灵活性。

增强安全性和功能

代理可以在执行真实对象的操作前后，添加安全检查或其他功能增强，例如延迟初始化、日志记录、访问控制等。

三、静态代理的实现

定义接口

首先定义一个接口，它声明了你想代理的类的方法。

public interface Subject {
    void request();
}

实现真实对象

然后有一个真实对象类，实现了这个接口。

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("真实对象的请求处理。");
    }
}

创建代理类

接着定义一个代理类，同样实现Subject接口，并持有一个对真实对象的引用。

public class Proxy implements Subject {
    private Subject realSubject;
    public Proxy(Subject realSubject) {
        this.realSubject = realSubject;
    }
    @Override
    public void request() {
        preRequest();
        realSubject.request();
        postRequest();
    }
    private void preRequest() {
        System.out.println("调用前的处理。");
    }
    private void postRequest() {
        System.out.println("调用后的处理。");
    }
}

客户端调用

最后，在客户端中使用代理对象完成工作。

public class Client {
    public static void mAIn(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = new Proxy(realSubject);
        proxy.request();
    }
}

四、JDK动态代理的实现

JDK提供的动态代理主要涉及两个类：Proxy和InvocationHandler。

定义InvocationHandler

需要定义一个InvocationHandler，在这个InvocationHandler实现类中指明代理的逻辑。

public class DynamicProxyHandler implements InvocationHandler {
    private Object subject;
    public DynamicProxyHandler(Object subject) {
        this.subject = subject;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        preRequest();
        Object result = method.invoke(subject, args);
        postRequest();
        return result;
    }
    private void preRequest() {
        System.out.println("调用前的处理。");
    }
    private void postRequest() {
        System.out.println("调用后的处理。");
    }
}

创建动态代理对象

使用Proxy.newProxyInstance方法创建代理对象。

public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        InvocationHandler handler = new DynamicProxyHandler(realSubject);
        Subject proxyInstance = (Subject) Proxy.newProxyInstance(
            realSubject.getClass().getClassLoader(),
            realSubject.getClass().getInterfaces(),
            handler
        );
        proxyInstance.request();
    }
}

五、CGLIB动态代理的实现

当无法使用JDK动态代理（例如被代理类没有实现接口）时，可以使用CGLIB库来实现动态代理。CGLIB是一个强大的高性能代码生成库，用于在运行时扩展Java类和实现指定接口。

定义CGLIB代理工厂

创建一个代理工厂来生成代理对象。

public class CglibProxyFactory implements MethodInterceptor {
    private Object target;
    public CglibProxyFactory(Object target) {
        this.target = target;
    }
    public Object getProxyInstance() {
        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 {
        preRequest();
        Object returnValue = method.invoke(target, args);
        postRequest();
        return returnValue;
    }
    private void preRequest() {
        System.out.println("CGLIB代理前的处理。");
    }
    private void postRequest() {
        System.out.println("CGLIB代理后的处理。");
    }
}

使用代理对象

使用代理工厂生成一个代理对象，并执行方法。

public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        CglibProxyFactory proxyFactory = new CglibProxyFactory(realSubject);
        RealSubject proxy = (RealSubject) proxyFactory.getProxyInstance();
        proxy.request();
    }
}

六、Java字节码实现的代理

使用如ASM这类字节码操作库，可以在运行时动态生成类或者增强已有类的功能。这种方法相对复杂，需要深入了解Java字节码技术。

创建字节码代理

首先需要了解Java字节码的结构和指令，然后通过ASM的API来动态构造和修改类。

// ASM的使用过程较为复杂，这里仅作简单说明，不提供具体的代码示例。

实现功能增强

通过字节码操作，可以在不修改原有代码的情况下，增加方法的调用前后逻辑，实现功能的增强。

七、小结

代理模式是一种非常有用的设计模式，其在Java中的实现主要有静态代理和两种动态代理方式。静态代理一般适用于代理类相对固定且数量不大的场景。动态代理则更加灵活，可以在运行时创建代理类，而且不需要为真实对象和代理对象提供共同的接口。CGLIB动态代理更适用于对类代理的场景，特别是当被代理对象没有实现任何接口时。这些代理模式的使用，可以帮助我们构建更加灵活和强大的系统。