引言
Java代理模式是一种常见的设计模式，它允许我们在不修改已有代码的情况下，通过引入一个代理类来对其进行包装，并在其基础上添加额外的逻辑。Java中有两种代理模式：静态代理和动态代理。
本文将深入探讨Java代理模式的概念和使用方法，并演示实战中的动态代理的应用。
Java代理模式
在Java代理模式中，我们定义一个接口，然后有一个实现该接口的类，我们希望对该类进行包装以添加额外的逻辑。这时，我们可以创建一个代理类，它也实现同样的接口，并将原始对象作为其成员变量，同时在方法调用时，可以在调用前后附加自定义的逻辑。
代理模式可以用于以下场景：
- 访问控制：代理类可以添加额外的访问控制逻辑，例如权限验证等。
- 日志记录：代理类可以记录方法调用的日志，用于调试和分析。
- 缓存：代理类可以在调用方法之前检查缓存，以避免重复计算。
- 延迟加载：代理类可以在真正需要对象时才进行加载，以提高性能。
静态代理
静态代理是最简单的一种代理模式。在静态代理中，我们直接编写一个代理类来对原始对象进行包装，代理类需要手动维护原始对象，并将方法调用转发给原始对象。
以下是一个示例：
public interface Printer {
void print();
}
public class RealPrinter implements Printer {
@Override
public void print() {
System.out.println("Printing...");
}
}
public class PrinterProxy implements Printer {
private RealPrinter printer;
public PrinterProxy() {
this.printer = new RealPrinter();
}
@Override
public void print() {
System.out.println("Before Printing...");
printer.print();
System.out.println("After Printing...");
}
}
在上面的例子中，PrinterProxy是一个代理类，它实现了Printer接口，并在print方法中添加了前置和后置逻辑。RealPrinter是一个原始对象，它实现了相同的接口。
通过使用静态代理，我们可以在调用PrinterProxy的print方法时，先执行"Before Printing..."，然后调用RealPrinter的print方法，最后再执行"After Printing..."。
动态代理
动态代理是指在运行时通过反射机制动态生成代理类。相比于静态代理，动态代理更加灵活，因为它在运行时才决定生成代理类。
在Java中，我们可以使用java.lang.reflect包中的Proxy类和InvocationHandler接口来实现动态代理。
以下是一个示例：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public interface Printer {
void print();
}
public class RealPrinter implements Printer {
@Override
public void print() {
System.out.println("Printing...");
}
}
public class DynamicProxy implements InvocationHandler {
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
public Object getProxy() {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this
);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before Printing...");
Object result = method.invoke(target, args);
System.out.println("After Printing...");
return result;
}
}
在上面的例子中，DynamicProxy是一个实现了InvocationHandler接口的代理类，它包装了一个实际对象RealPrinter。getProxy方法使用Proxy.newProxyInstance生成一个代理对象，并将代理对象返回。
通过使用动态代理，我们可以在调用代理对象的方法时，在方法调用前后执行自定义的逻辑，而无需手动编写静态代理类。
动态代理实战
以下是一个使用动态代理的实际应用场景：
public interface Image {
void display();
}
public class RealImage implements Image {
private String filename;
public RealImage(String filename) {
this.filename = filename;
loadFromDisk();
}
private void loadFromDisk() {
System.out.println("Loading image from disk: " + filename);
}
@Override
public void display() {
System.out.println("Displaying image: " + filename);
}
}
public class ImageProxy implements Image {
private String filename;
private Image realImage;
public ImageProxy(String filename) {
this.filename = filename;
}
@Override
public void display() {
if (realImage == null) {
realImage = new RealImage(filename);
}
System.out.println("Before displaying image...");
realImage.display();
System.out.println("After displaying image...");
}
}
在上述场景中，ImageProxy是一个代理类，它实现了Image接口，并在display方法中添加了前置和后置逻辑。RealImage是一个实际对象，它实现了相同的接口。
在调用ImageProxy的display方法时，如果realImage为空，则先创建一个RealImage对象，并将其保存在realImage成员变量中。然后，执行前置逻辑，调用realImage的display方法，最后执行后置逻辑。
这样，我们可以在显示图像之前和之后添加自定义的逻辑，例如加载图像等。
结论
Java代理模式允许我们通过引入一个代理类来对原始对象进行包装，并在其基础上添加额外的逻辑。静态代理是最简单的代理模式，而动态代理则更加灵活。
通过本文的分析和示例代码，我们深入理解了Java中的代理模式和动态代理，并演示了动态代理的实际应用场景。希望读者可以在实际开发中充分利用代理模式，提高代码的可维护性和可扩展性。
参考资料：
本文来自极简博客，作者：柠檬微凉，转载请注明原文链接：深入理解Java中的Java代理模式与动态代理实战
