Java代理模式：动态代理 vs 静态代理

一叶飘零_sweeeet

于 2023-08-15 16:34:14 发布

阅读量175

点赞数

分类专栏：设计模式 java 文章标签：代理模式 java 开发语言

本文链接：https://blog.csdn.net/jam_yin/article/details/132301974

版权

java 同时被 2 个专栏收录

187 篇文章 4 订阅

订阅专栏

设计模式

27 篇文章 0 订阅

订阅专栏

在Java编程中，代理模式是一种非常常用的设计模式，它可以帮助我们在不修改原有代码的情况下，增加额外的功能。代理模式主要有两种实现方式：静态代理和动态代理。本文将详细讨论这两种代理模式的区别，以及如何在Java中实现它们。

1. 静态代理

1.1 静态代理的定义

静态代理是一种设计模式，它通过创建一个新的代理类来实现接口，代理类包含一个对原对象的引用，然后通过代理类来调用原对象的方法，并在调用前后添加额外的操作。

1.2 静态代理的实现

下面是一个简单的静态代理的Java实现：

// 定义一个接口
public interface HelloService {
    void sayHello();
}

// 原始类实现接口
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

// 静态代理类
public class HelloServiceProxy implements HelloService {
    private HelloService target;

    public HelloServiceProxy(HelloService target) {
        this.target = target;
    }

    @Override
    public void sayHello() {
        System.out.println("Before sayHello");
        target.sayHello();
        System.out.println("After sayHello");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        HelloService proxy = new HelloServiceProxy(helloService);
        proxy.sayHello();
    }
}

在这个例子中，HelloServiceProxy就是一个静态代理类，它实现了HelloService接口，并持有一个HelloService的引用。当调用sayHello方法时，它会先调用自己的一些代码（例如，打印"Before sayHello"），然后调用原对象的sayHello方法，再执行一些后续的代码（例如，打印"After sayHello"）。

1.3 静态代理的优缺点

静态代理的优点是实现简单，易于理解。但它的缺点也很明显：每一个被代理的方法都需要在代理类中实现一遍，并且如果接口发生变化，代理类也需要跟着修改。这增加了代码的复杂性和维护成本。

2. 动态代理

2.1 动态代理的定义

动态代理是一种设计模式，它在运行时动态地创建代理对象，并在调用原对象的方法时，可以添加额外的操作。动态代理不需要手动创建代理类，只需要定义一个调用处理器即可。

2.2 动态代理的实现

Java提供了java.lang.reflect.Proxy类来生成动态代理对象。以下是一个简单的动态代理的Java实现：

// 定义一个接口
public interface HelloService {
    void sayHello();
}

// 原始类实现接口
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

// 定义一个调用处理器
public class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

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

// 测试类
public class Test {
    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        InvocationHandler handler = new MyInvocationHandler(helloService);
        HelloService proxy = (HelloService) Proxy.newProxyInstance(
                helloService.getClass().getClassLoader(),
                helloService.getClass().getInterfaces(),
                handler);
        proxy.sayHello();
    }
}

在这个例子中，我们使用Proxy.newProxyInstance方法创建了一个动态代理对象。这个方法需要三个参数：类加载器，一组接口，以及一个调用处理器。调用处理器是一个实现了InvocationHandler接口的对象，它定义了如何处理代理对象的方法调用。