黑马程序员技术交流社区

标题: 对动态代理的理解 [打印本页]
作者: 熊永标    时间: 2013-1-24 16:46
标题: 对动态代理的理解
  1. package cn.javastudy.p16.proxy.demo;

  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;

  11. public class ProxyDemo {

  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.                 {

  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(){

  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. }

复制代码
动态代理的应用,Proxy的newProxyInstance的原理:
此方法接收三个参数,第一个参数为被代理的类的类加载器,第二个为被代理的类实现的接口的字节码数列表(字节码数组),第三个为InvocationHandler的实现类.
通过调用调用这方不就可以产生一个代理对象,这个代里对像实现了被代理类的所有接口.
当调用这个代里对象时,就会调用InvocaionHandler中的Invoke方法,然后再通过个方法根据目标对象调用被代理的相应方法.返回来的值再传递给代理相应方法.
作者: 黑马-小龙    时间: 2013-1-25 23:06
个人理解java的动态代理具体实现分三步:
1.首先告诉它类需要使用哪些接口？然后告诉它该类的加载器是谁？
2.然后实例化InvocationHandler对象，由于InvocationHandler是一个接口，所以必须先实现它，这里最好用匿名内部类
3.让系统功能的代码以参数形式传递进来，让它在运行的时候传递进来，这样以后方便修改。(使用切面编程)

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

对动态代理技术原理的理解:
动态生成类的原理:
          客户端调用代理，代理的构造方法接受一个Invocationhandler对象，接受进去了，然后客户端调用代理的各个方法，
      代理的各个方法会把请求转发给Invocationhandler对象，Invocationhandler对象又会把各个请求分发给目标的相应方法。
作者: 黑马张旭    时间: 2013-1-25 23:06
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 中的应用》



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2