Java的动态代理

电玩女神 2022-07-11 01:53 173阅读 0赞

# 1、代理 #

代理是基本的设计模式，有一些操作你不想整合到逻辑代码里面，因此需要代理来做这个事情。例如：日志、监控等

下面将演示一个简单的代理：

package test;
    
    interface Interface {
        void doSomething();
        void somethingElse(String arg);
    }
    
    class RealObject implements Interface {
        public void doSomething() {
            System.out.println("doSomething");
        }
    
        public void somethingElse(String arg) {
            System.out.println("somethingElse " + arg);
        }
    }   
    
    class SimpleProxy implements Interface {
        private Interface proxied;
    
        public SimpleProxy(Interface proxied) {
            this.proxied = proxied;
        }
        public void doSomething() {
            System.out.println("SimpleProxy doSomething");
            proxied.doSomething();
        }
        public void somethingElse(String arg) {
            System.out.println("SimpleProxy somethingElse " + arg);
            proxied.somethingElse(arg);
        }
    }   
    
    class SimpleProxyDemo {
        public static void consumer(Interface iface) {
            iface.doSomething();
            iface.somethingElse("bonobo");
        }
        public static void main(String[] args) {
            consumer(new RealObject());
    
            System.out.println("=========================");
    
            consumer(new SimpleProxy(new RealObject()));
        }
    } /* Output: doSomething somethingElse bonobo ========================= SimpleProxy doSomething doSomething SimpleProxy somethingElse bonobo somethingElse bonobo *///:~

consumer()函数接收的是Interface，所以它无法知道正在获取的是RealObject还是SimpleProxy,因为这两个类都实现了Interface，但是SimpleProxy里面构造器可以传递进去Interface，实现代理其余的Interface实现类。

关于[代理模式][Link 1]可以看另外一篇blog

上面代码[github][]

# Java的动态代理 #

Java的动态代理比代理的思想更加迈进了一步，不单是存在代理这个模式，而且还可以动态的创建代理并动态的处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的 调用处理器 上，它的工作是揭示调用的类型并确定相应的对策。下面是使用动态代理重写上面的代理：

package test;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    
    class DynamicProxyHandler implements InvocationHandler {
        private Object proxied;
        public DynamicProxyHandler(Object proxied) {
            this.proxied = proxied;
        }
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("**** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args);
            if(args != null)
                for(Object arg : args)
                    System.out.println(" " + arg);
    
            return method.invoke(proxied, args);
        }
    }   
    
    class SimpleDynamicProxy {
        public static void consumer(Interface iface) {
            iface.doSomething();
            iface.somethingElse("bonobo");
        }
    
        public static void main(String[] args) {
            RealObject real = new RealObject();
            consumer(real);
    
            System.out.println("====Insert a proxy and call again====");
            /** 静态方法创建动态代理 */
            Interface proxy = (Interface)Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class[]{ Interface.class },
                new DynamicProxyHandler(real));
            //
            consumer(proxy);
        }
    }
    
    /* Output: (95% match) doSomething somethingElse bonobo ====Insert a proxy and call again==== **** proxy: class test.$Proxy0, method: public abstract void test.Interface.doSomething(), args: null doSomething **** proxy: class test.$Proxy0, method: public abstract void test.Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@3fe329eb bonobo somethingElse bonobo *///:~

静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法有三个参数：  
1、类加载器，我们可以从已被加载的类中获取其加载器；  
2、该代理实现的接口列表；  
3、InvocationHandler接口的一个实现类。

动态代理将所有调用重定向到调用处理器。常规套路是向调用处理器的构造器传递一个“实际”对象的引用，从而使得调用处理器在执行其中介任务时，可以将请求转发。

在调用处理器中的invoke()方法中，传递进来代理的对象。在invoke()内部，在代理上调用方法需要格外当心，因为对接口的调用将被重定向为对代理的调用。

在DynamicProxyHandler的实现里面的proxy其实是代理，而不是实际的类。通过method.invoke(interFace, args)方法执行真实类的方法。甚至我们可以通过方法名来控制执行的方法。

上面代码[github][github 1]

[Link 1]: http://blog.csdn.net/u010853261/article/details/51746947
[github]: https://github.com/leetcode-hust/leetcode/blob/master/louyuting/src/test/SimpleProxyDemo.java
[github 1]: https://github.com/leetcode-hust/leetcode/blob/master/louyuting/src/test/SimpleDynamicProxy.java