1. package cn.javastudy.p16.proxy.demo;
   
2. 
   
3. import java.lang.reflect.Constructor;
   
4. import java.lang.reflect.InvocationHandler;
   
5. import java.lang.reflect.InvocationTargetException;
   
6. import java.lang.reflect.Method;
   
7. import java.lang.reflect.Proxy;
   
8. import java.util.ArrayList;
   
9. import java.util.Collection;
   
10. 
    
11. public class ProxyDemo {
    
12. 
    
13.         /**
    
14.          * @param args
    
15.          * @throws NoSuchMethodException
    
16.          * @throws SecurityException
    
17.          * @throws InvocationTargetException
    
18.          * @throws IllegalAccessException
    
19.          * @throws InstantiationException
    
20.          * @throws IllegalArgumentException
    
21.          */
    
22.         public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException{
    
23.                 // TODO Auto-generated method stub
    
24.                 Class<?> clazzProxy=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
    
25.                 /*Method[] m=clazzProxy.getMethods();
    
26.                 for(Method mm:m)
    
27.                         System.out.println(mm.toString());*/
    
28.                 Constructor<?> constructor=clazzProxy.getConstructor(InvocationHandler.class);
    
29.                 //第一种方法
    
30.                 /*class MyInvocationHandler implements InvocationHandler
    
31.                 {
    
32. 
    
33.                         @Override
    
34.                         public Object invoke(Object proxy, Method method, Object[] args)
    
35.                                         throws Throwable {
    
36.                                 ArrayList<?> list=new ArrayList<Object>();
    
37.                                 Object o = method.invoke(list, args);
    
38.                                 return o;
    
39.                         }
    
40.                        
    
41.                 }
    
42.                 MyInvocationHandler handler=new MyInvocationHandler();
    
43.                 Collection<String> c=(Collection<String>)constructor.newInstance(new MyInvocationHandler());*/
    
44.                 //第二种方法
    
45.                 /*Collection c=(Collection)constructor.newInstance(new InvocationHandler(){
    
46. 
    
47.                         @Override
    
48.                         public Object invoke(Object proxy, Method method, Object[] args)
    
49.                                         throws Throwable {
    
50.                                 ArrayList<?> list=new ArrayList<Object>();
    
51.                                 Object o = method.invoke(list, args);
    
52.                                 return o;
    
53.                         }});
    
54.                
    
55.                 c.add("a");
    
56.                 c.add("b");
    
57.                 c.add("c");
    
58.                 c.add("d");*/
    
59.                 //第三种方法
    
60.                 Collection c=(Collection)Proxy.newProxyInstance(
    
61.                                 Collection.class.getClassLoader(),
    
62.                                 new Class[]{Collection.class},
    
63.                                 new InvocationHandler(){
    
64.                                 @Override
    
65.                                 public Object invoke(Object proxy, Method method, Object[] args)
    
66.                                                 throws Throwable {
    
67.                                         ArrayList<?> list=new ArrayList<Object>();Thread a=null;a.start();
    
68.                                         Object o = method.invoke(list, args);
    
69.                                         return o;
    
70.                                 }} );
    
71.                 c.add("a");
    
72.                 c.add("b");
    
73.                 c.add("c");
    
74.                 c.add("d");
    
75.         }
    
76.        
    
77. }
    
78. 
    

复制代码

动态代理的应用,Proxy的newProxyInstance的原理:
此方法接收三个参数,第一个参数为被代理的类的类加载器,第二个为被代理的类实现的接口的字节码数列表(字节码数组),第三个为InvocationHandler的实现类.
通过调用调用这方不就可以产生一个代理对象,这个代里对像实现了被代理类的所有接口.
当调用这个代里对象时,就会调用InvocaionHandler中的Invoke方法,然后再通过个方法根据目标对象调用被代理的相应方法.返回来的值再传递给代理相应方法.

个人理解java的动态代理具体实现分三步:
1.首先告诉它类需要使用哪些接口？然后告诉它该类的加载器是谁？
2.然后实例化InvocationHandler对象，由于InvocationHandler是一个接口，所以必须先实现它，这里最好用匿名内部类
3.让系统功能的代码以参数形式传递进来，让它在运行的时候传递进来，这样以后方便修改。(使用切面编程)

我个人觉得关键理解在于InvocationHandler接口的invoke方法。
invoke方法是每调用一次对象的方法时，它都执行一次，这个方法不是代理对象的方法，而是目标taget对象的方法

对动态代理技术原理的理解:
动态生成类的原理:
          客户端调用代理，代理的构造方法接受一个Invocationhandler对象，接受进去了，然后客户端调用代理的各个方法，
      代理的各个方法会把请求转发给Invocationhandler对象，Invocationhandler对象又会把各个请求分发给目标的相应方法。

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, J2EEjava语言JDK1.4APIjavalangObject.html">Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：
Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

       所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。(参见文献3)
    在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：
抽象角色(之前是抽象类，此处应改为接口)：
public interface Subject
{
    abstract public void request();
}
具体角色RealSubject：同上；

代理角色：
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;

public class DynamicSubject implements InvocationHandler {
private Object sub;

public DynamicSubject() {
}

public DynamicSubject(Object obj) {
    sub = obj;
}


public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("before calling " + method);

    method.invoke(sub,args);

    System.out.println("after calling " + method);
    return null;
}

}

       该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的
method.invoke(sub,args);
其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。
客户端：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Client
{

    static public void main(String[] args) throws Throwable
       {
      RealSubject rs = new RealSubject(); //在这里指定被代理类
      InvocationHandler ds = new DynamicSubject(rs); //初始化代理类
        Class cls = rs.getClass();
      //以下是分解步骤
      /*
      Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;
      Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});
      Subject subject =(Subject) ct.newInstance(new Object[]{ds});
     */
     //以下是一次性生成
      Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),
                                 cls.getInterfaces(),ds );

      subject.request();
}
       通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系(参见文献2)。


参考文献：
1.      阎宏，《Java 与模式》
2.          透明,《动态代理的前世今生》
3.   Forest Hou，《Dynamic Proxy 在 Java RMI 中的应用》