java动态代理之我的理解

    在java的动态代理机制中，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java动态代理的结构图

每一个非动态代理类（我将中间过程理解成非动态代理类）都必须要实现InvocationHandler这个接口，每个动态代理类的实例都关联到一个费动态代理类的对象handler，当我们通过动态代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：（）

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我们看到这个方法一共接受三个参数，那么这三个参数分别代表什么呢？

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

这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载。代理那个类就用那个类的加载器

interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象实现了一组什么接口，如果我实现了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了。即结构图中最开始的接口，因为我的例子只有一个接口。

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

我们来通过一个实例来看看我们的动态代理模式是什么样的：

首先定义了一个IIIt类型的接口，为其声明了一个个方法

package Dynamic;

public interface III {
  public void say();
}

接着，定义了一个类来实现这个接口，这个类就是我们的真实对象，SbuClass类

package Dynamic;

public class SbuClass implements III {
public void say() {
	// TODO Auto-generated method stub
	System.out.println("just say something");
}
}

下一步，我们就要定义一个非动态代理类了，前面说个，每一个中间过程（非动态代理类）都必须要实现 InvocationHandler 这个接口，因此我们这个非动态代理类也不例外：

package Dynamic;

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

public class DynamicProxy  implements InvocationHandler {
	private Object obj;
	public DynamicProxy(Object obj){
		this.obj=obj;
	}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	
	// TODO Auto-generated method stub
	System.out.println("before say ");
    
    System.out.println("Method:" + method);
    
    method.invoke(obj, args); //通过method的invoke方法，把需要被代理的类即SbuClass的方法传进来
    
    System.out.println("after  say ");
    
	
	return null;
}
}

最后，来看看我们的Client类：

package Dynamic;

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

public class Client  {
	 public static void main(String[] args){
       	III sbu =new SbuClass();
	 
	      InvocationHandler handler =new DynamicProxy(sbu);
 
	        III ii =(III) Proxy.newProxyInstance(sbu.getClass().getClassLoader(), sbu.getClass().getInterfaces(), handler);
        //上面这个方法的前两个参数，是看你要被代理的类是哪一个。这里我们要代理的就是SubClass类 所以就用它的实例来调用加载器等    
		System.out.println("before say");
		  
		ii.say();
	 }
}

我们先来看看控制台的输出

before say
before say 
Method:public abstract void Dynamic.III.say()
just say something
after  say 

 

通过代理对象来调用实现类的接口中的方法，这个时候程序就会跳转到由这个代理对象关联到的handler（费动态代理类对象） 中的invoke方法去执行，而我们的这个 handler 对象又接受了一个SubClass类型的参数，表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行。我们看到，在真正通过动态代理对象来调用真实被代理对象的方法的时候，我们可以在该方法前后添加自己的一些操作，同时我们看到我们的这个 method 对象是这样的：method.invoke(obj, args)。正式这句代码来调用被代理类的say()方法。我认为method应该是Proxy底层实现传递参数的。 输出结构：  Method:public abstract void Dynamic.III.say()。

这就是我在别人基础上理解的java动态代理机制

欢迎指正讨论。。。