动态代理-一个简单例子

参考——java编程思想，动态代理

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy:　　指代我们所代理的那个真实对象
method:　　指代的是我们所要调用真实对象的某个方法的Method对象
args:　　指代的是调用真实对象某个方法时接受的参数

Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法

public static Object newProxyInstance(ClassLoader loader,
 Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
 
loader:　　一个ClassLoader对象，
        定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:　　一个Interface对象的数组，
表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，
那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:　　一个InvocationHandler对象，
表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

例子

package type_information.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Interface {
    void doSomething();

    void somethingElse(String arg);
}
//具体实现类
class RealObject implements Interface {
    @Override
    public void doSomething() {
        System.out.println("doSomething");
    }

    @Override
    public void somethingElse(String arg) {
        System.out.println("somethingElse " + arg);
    }
}
//动态代理类 
class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }
    @Override
    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);
    }
}
public class SDP {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }
    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),   //定义了由哪个ClassLoader对象来对生成的代理对象进行加载
                // new Class[]{Interface.class}
                  real.getClass().getInterfaces()   //提供接口,意思是我提供了什么接口，这个代理类就会实现什么接口，并调用接口里的方法
                ,
                new DynamicProxyHandler(real));


        consumer(proxy);
    }
}

通过动态代理 不用再像静态代理一样，需要为每一个具体实现类都单独创建一个代理类