java中设计模式之代理模式（结构型模式）

引言

在Java中，代理模式是一种常见的设计模式，它允许创建一个代理对象来控制对其他对象的访问。代理模式可以用于多种情况，例如远程调用、安全控制、性能优化等。它能够在不修改原始对象的情况下，为其提供额外的功能或控制其访问方式。

代理模式在Java中有两种主要形式：静态代理和动态代理，

静态代理

静态代理是在编译时就已经确定代理类的实现。在静态代理中，代理类持有目标对象的引用，并提供与目标对象相同的接口，以便客户端直接与代理对象进行交互。代理对象在调用目标对象方法的前后可以执行一些附加逻辑，例如日志记录、权限验证等。

// 定义接口
public interface Calculator {
    int add(int a, int b);
}

// 实现目标对象
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

// 实现代理对象
public class CalculatorProxy implements Calculator {
    private Calculator target;

    public CalculatorProxy(Calculator target) {
        this.target = target;
    }

    @Override
    public int add(int a, int b) {
        System.out.println("Before add");
        int result = target.add(a, b);
        System.out.println("After add");
        return result;
    }
}

// 使用代理对象
public class Main {
    public static void main(String[] args) {
        Calculator target = new CalculatorImpl();
        Calculator proxy = new CalculatorProxy(target);

        System.out.println(proxy.add(3, 5));
    }
}

动态代理

动态代理是在运行时动态的生成代理对象，无需编写具体的代理类。Java提供了两种实现动态代理的方式：JDK动态代理和CGLIB动态代理。

JDK动态代理

JDK动态代理只能代理实现了接口的目标对象。它利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来生成代理对象。动态代理对象的方法调用会被重定向到实现InvocationHandler接口的类中的invoke方法，从而实现对目标对象方法的增强。

// 定义接口
public interface Calculator {
    int add(int a, int b);
}

// 实现目标对象
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

// 实现InvocationHandler
public class CalculatorInvocationHandler implements InvocationHandler {
    private Calculator target;

    public CalculatorInvocationHandler(Calculator target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before add");
        Object result = method.invoke(target, args);
        System.out.println("After add");
        return result;
    }
}

// 使用动态代理
public class Main {
    public static void main(String[] args) {
        Calculator target = new CalculatorImpl();
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new CalculatorInvocationHandler(target)
        );

        System.out.println(proxy.add(3, 5));
    }
}

CGLIB动态代理

CGLIB动态代理可以代理没有实现接口的类。它通过生成目标类的子类来实现代理。CGLIB动态代理通过继承目标类并重写其中的方法来实现对目标对象方法的增强。

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

// 目标类
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

// 实现MethodInterceptor
public class CalculatorMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before add");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After add");
        return result;
    }
}

// 使用CGLIB动态代理
public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Calculator.class);
        enhancer.setCallback(new CalculatorMethodInterceptor());

        Calculator proxy = (Calculator) enhancer.create();
        System.out.println(proxy.add(3, 5));
    }
}

代理模式在Java中广泛应用于各种场景，它能够简化和增强对象间的交互，提高代码的可重用性和灵活性。根据具体的需求和场景选择合适的代理方式，可以很好地实现目标对象的功能增强和控制。