{"path":"1930202","ref":"动态代理.md","title":"动态代理","content":"## [动态代理](https:\/\/lingcoder.gitee.io\/onjava8\/#\/book\/19-Type-Information?id=%e5%8a%a8%e6%80%81%e4%bb%a3%e7%90%86)\n\n*代理*是基本的设计模式之一。一个对象封装真实对象，代替其提供其他或不同的操作---这些操作通常涉及到与“真实”对象的通信，因此代理通常充当中间对象。这是一个简单的示例，显示代理的结构：\n\n~~~\n\/\/ typeinfo\/SimpleProxyDemo.java\n\ninterface Interface {\n    void doSomething();\n\n    void somethingElse(String arg);\n}\n\nclass RealObject implements Interface {\n    @Override\n    public void doSomething() {\n        System.out.println(\"doSomething\");\n    }\n\n    @Override\n    public void somethingElse(String arg) {\n        System.out.println(\"somethingElse \" + arg);\n    }\n}\n\nclass SimpleProxy implements Interface {\n    private Interface proxied;\n\n    SimpleProxy(Interface proxied) {\n        this.proxied = proxied;\n    }\n\n    @Override\n    public void doSomething() {\n        System.out.println(\"SimpleProxy doSomething\");\n        proxied.doSomething();\n    }\n\n    @Override\n    public void somethingElse(String arg) {\n        System.out.println(\n                \"SimpleProxy somethingElse \" + arg);\n        proxied.somethingElse(arg);\n    }\n}\n\nclass SimpleProxyDemo {\n    public static void consumer(Interface iface) {\n        iface.doSomething();\n        iface.somethingElse(\"bonobo\");\n    }\n\n    public static void main(String[] args) {\n        consumer(new RealObject());\n        consumer(new SimpleProxy(new RealObject()));\n    }\n}\n~~~\n\n输出结果：\n\n~~~\ndoSomething\nsomethingElse bonobo\nSimpleProxy doSomething\ndoSomething\nSimpleProxy somethingElse bonobo\nsomethingElse bonobo\n~~~\n\n因为`consumer()`接受`Interface`，所以它不知道获得的是`RealObject`还是`SimpleProxy`，因为两者都实现了`Interface`。 但是，在客户端和`RealObject`之间插入的`SimpleProxy`执行操作，然后在`RealObject`上调用相同的方法。\n\n当你希望将额外的操作与“真实对象”做分离时，代理可能会有所帮助，尤其是当你想要轻松地启用额外的操作时，反之亦然（设计模式就是封装变更---所以你必须改变一些东西以证明模式的合理性）。例如，如果你想跟踪对`RealObject`中方法的调用，或衡量此类调用的开销，该怎么办？你不想这部分代码耦合到你的程序中，而代理能使你可以很轻松地添加或删除它。\n\nJava 的*动态代理*更进一步，不仅动态创建代理对象而且动态处理对代理方法的调用。在动态代理上进行的所有调用都被重定向到单个*调用处理程序*，该处理程序负责发现调用的内容并决定如何处理。这是`SimpleProxyDemo.java`使用动态代理重写的例子：\n\n~~~\n\/\/ typeinfo\/SimpleDynamicProxy.java\n\nimport java.lang.reflect.*;\n\nclass DynamicProxyHandler implements InvocationHandler {\n    private Object proxied;\n\n    DynamicProxyHandler(Object proxied) {\n        this.proxied = proxied;\n    }\n\n    @Override\n    public Object\n    invoke(Object proxy, Method method, Object[] args)\n            throws Throwable {\n        System.out.println(\n                \"**** proxy: \" + proxy.getClass() +\n                        \", method: \" + method + \", args: \" + args);\n        if (args != null)\n            for (Object arg : args)\n                System.out.println(\"  \" + arg);\n        return method.invoke(proxied, args);\n    }\n}\n\nclass SimpleDynamicProxy {\n    public static void consumer(Interface iface) {\n        iface.doSomething();\n        iface.somethingElse(\"bonobo\");\n    }\n\n    public static void main(String[] args) {\n        RealObject real = new RealObject();\n        consumer(real);\n        \/\/ Insert a proxy and call again:\n        Interface proxy = (Interface) Proxy.newProxyInstance(\n                Interface.class.getClassLoader(),\n                new Class[]{Interface.class},\n                new DynamicProxyHandler(real));\n        consumer(proxy);\n    }\n}\n~~~\n\n输出结果：\n\n~~~\ndoSomething\nsomethingElse bonobo\n**** proxy: class $Proxy0, method: public abstract void\nInterface.doSomething(), args: null\ndoSomething\n**** proxy: class $Proxy0, method: public abstract void\nInterface.somethingElse(java.lang.String), args:\n[Ljava.lang.Object;@6bc7c054\n  bonobo\nsomethingElse bonobo\n~~~\n\n可以通过调用静态方法`Proxy.newProxyInstance()`来创建动态代理，该方法需要一个类加载器（通常可以从已加载的对象中获取），希望代理实现的接口列表（不是类或抽象类），以及接口`InvocationHandler`的一个实现。动态代理会将所有调用重定向到调用处理程序，因此通常为调用处理程序的构造函数提供对“真实”对象的引用，以便一旦执行中介任务便可以转发请求。\n\n`invoke()`方法被传递给代理对象，以防万一你必须区分请求的来源---但是在很多情况下都无需关心。但是，在`invoke()`内的代理上调用方法时要小心，因为接口的调用是通过代理重定向的。\n\n通常执行代理操作，然后使用`Method.invoke()`将请求转发给被代理对象，并携带必要的参数。这在一开始看起来是有限制的，好像你只能执行一般的操作。但是，可以过滤某些方法调用，同时传递其他方法调用：\n\n~~~\n\/\/ typeinfo\/SelectingMethods.java\n\/\/ Looking for particular methods in a dynamic proxy\n\nimport java.lang.reflect.*;\n\nclass MethodSelector implements InvocationHandler {\n    private Object proxied;\n\n    MethodSelector(Object proxied) {\n        this.proxied = proxied;\n    }\n\n    @Override\n    public Object\n    invoke(Object proxy, Method method, Object[] args)\n            throws Throwable {\n        if (method.getName().equals(\"interesting\"))\n            System.out.println(\n                    \"Proxy detected the interesting method\");\n        return method.invoke(proxied, args);\n    }\n}\n\ninterface SomeMethods {\n    void boring1();\n\n    void boring2();\n\n    void interesting(String arg);\n\n    void boring3();\n}\n\nclass Implementation implements SomeMethods {\n    @Override\n    public void boring1() {\n        System.out.println(\"boring1\");\n    }\n\n    @Override\n    public void boring2() {\n        System.out.println(\"boring2\");\n    }\n\n    @Override\n    public void interesting(String arg) {\n        System.out.println(\"interesting \" + arg);\n    }\n\n    @Override\n    public void boring3() {\n        System.out.println(\"boring3\");\n    }\n}\n\nclass SelectingMethods {\n    public static void main(String[] args) {\n        SomeMethods proxy =\n                (SomeMethods) Proxy.newProxyInstance(\n                        SomeMethods.class.getClassLoader(),\n                        new Class[]{ SomeMethods.class },\n                        new MethodSelector(new Implementation()));\n        proxy.boring1();\n        proxy.boring2();\n        proxy.interesting(\"bonobo\");\n        proxy.boring3();\n    }\n}\n~~~\n\n输出结果：\n\n~~~\nboring1\nboring2\nProxy detected the interesting method\ninteresting bonobo\nboring3\n~~~\n\n在这个示例里，我们只是在寻找方法名，但是你也可以寻找方法签名的其他方面，甚至可以搜索特定的参数值。\n\n动态代理不是你每天都会使用的工具，但是它可以很好地解决某些类型的问题。你可以在 Erich Gamma 等人的*设计模式*中了解有关*代理*和其他设计模式的更多信息。 （Addison-Wesley，1995年），以及[设计模式](https:\/\/lingcoder.gitee.io\/onjava8\/#\/.\/25-Patterns)一章。"}