Dynamic Proxy in Java

虽然在一年前就知道了 Proxy 模式，但是基本没有尝试使用过，仅在框架里看到一些例子。昨天翻阅《大型网站系统与 Java 中间件实践》时，偶然发现了 Proxy 模式在 Java 中的应用 —— 动态代理，遂记录下来，顺便复习一下 Proxy 模式。

以下内容参考自

《 Design Patterns》
《大型网站系统与 Java 中间件实践》。
http://www.baeldung.com/java-dynamic-proxies

Proxy 模式图示：

Proxy Pattern

Proxy 模式#

在《 Design Patterns》书中提到了使用 Proxy 模式的四种常见情况：

远程代理 (Remote Proxy) 为一个对象在不同的地址空间提供局部代表。
虚代理 (Virtual Proxy) 根据需要创建开销很大的对象。
保护代理 (Protection Proxy) 控制对原始对象的访问。保护代理用于对象应该有不同的访问权限的时候。
智能指针 (Smart Reference) 引用计数、实现线程安全、延迟创建，熟悉 C++ 的同学应该知道 std::share_ptr、 std::weak_ptr、std::unique_ptr 等。

Java 中的静态代理#

这里借用《大型网站系统与 Java 中间件实践》中的例子：

1
public interface Calculator {
2
    int add(int a, int b);
3
}
4

5
public class CalculatorImpl implements Calculator {
6
    int add(int a, int b) {
7
        return a + b;
8
    }
9
}
10

11
public class CalculatorProxy implements Calculator {
12
    private Calculator calculator;
13

14
    public CalculatorProxy(Calculator calculator) {
15
        this.calculator = calculator;
16
    }
17

18
    int add(int a, int b) {
19
        // We can do anything before and after real add is called,
20
        // such as logging
21
        return calculator.add(a, b);
22
    }
23
}

可以看到，在 CalculatorProxy 中我们可以调用了真正的 add 操作，并可以在 add 前后做很多额外的工作，这种方式看上去十分直接，但是如果我们有一批类需要代理，并且代理类中实现的功能是一致的，那么我们就需要为每一个类都实现一个 XxxProxy 类，这将会十分麻烦。

Java 中的动态代理#

Java 中提供了一种方式使我们能够动态的生成一个类的代理，我们来看一个例子

1
public class DynamicProxyPlayground {
2

3
    public static void main(String[] args) {
4
        Map mapProxyInstance = (Map) Proxy
5
            .newProxyInstance(DynamicProxyPlayground.class.getClassLoader(), new Class[]{Map.class},
6
                new TimingDynamicInvocationHandler(new HashMap<String, String>()));
7

8
        // DynamicProxyPlayground$TimingDynamicInvocationHandler invoke
9
        // INFO: Executing put finished in 74094 ns.
10
        mapProxyInstance.put("hello", "world");
11

12
        CharSequence csProxyInstance = (CharSequence) Proxy.newProxyInstance(
13
            DynamicProxyPlayground.class.getClassLoader(),
14
            new Class[] { CharSequence.class },
15
            new TimingDynamicInvocationHandler("Hello World"));
16

17
        // DynamicProxyPlayground$TimingDynamicInvocationHandler invoke
18
        // INFO: Executing length finished in 11720 ns.
19
        csProxyInstance.length();
20
    }
21

22
    public static class TimingDynamicInvocationHandler implements InvocationHandler {
23
        private static Logger logger =
24
            Logger.getLogger(TimingDynamicInvocationHandler.class.getName());
25

26
        private Object target;
27

28
        private TimingDynamicInvocationHandler(Object target) {
29
            this.target = target;
30
        }
31

32
        @Override
33
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
34
            long start = System.nanoTime();
35
            Object result = method.invoke(target, args);
36
            long elapsed = System.nanoTime() - start;
37

38
            logger.info(String.format("Executing %s finished in %d ns.", method.getName(), elapsed));
39
            return result;
40
        }
41
    }
42
}

在上述例子中，通过实现一个 InvocationHandler，我们就可以使用Proxy.newInstance为一批类创建功能相同的动态代理。