JAVA代理机制初探

今天上午写了一个有关于EJB的拦截例子,其实EJB的拦截用的就是JAVA的代理机制.说广一点,EJB的实现就是利用代理实现的远程方法调用.
EJB会在服务器端生成一个实现了所有的接口的类的代理,然后在里面监听你所做的所有事情,并与之反应,这样就实现了远程调用的效果,你在这边调用,而EJB容器在别的地方也可以知道你调用了什么,并返回与之对应的结果,这一切都是用代理来实现的.

下面我们就来认识一下,代理的主要类:java.lang.reflect.Proxy
它定义了一套静态方法,供我们使用,其中一个最常用的方法就是生成代理对象
public static Object newProxyInstance( ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException

它根据你传入的类加载器和这个代理将会实现的接口,以及一个调用处理器,来生成一个代理对象.说起来比较抽象,还是给点例子吧:
先声明一个接口,用来调用代理的方法

/*
 * MyInterface.java
 *
 * Created on 2007年9月8日, 下午4:38
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
  */

package  test4;

/**
 *
 *  @author  hadeslee
  */
public   interface  MyInterface {
     public   void  sayHello(String s);
     public   void  doSth();
}

然后再写一个类实现此方法

/*
 * Test1.java
 *
 * Created on 2007年9月8日, 下午4:31
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
  */

package  test4;

import  java.lang.reflect.InvocationHandler;
import  java.lang.reflect.Method;
import  java.lang.reflect.Proxy;
import  java.util.ArrayList;
import  java.util.List;


/**
 *
 *  @author  hadeslee
  */
public   class  Test1  implements  MyInterface{
    
     /**  Creates a new instance of Test1  */
     public  Test1() {
        
    }
    
     public   static   void  main(String[] args)  throws  Exception{
        Test1 list = new  Test1();
        MyInterface my = (MyInterface)Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                list.getClass().getInterfaces(),
                 new  MyHandler < MyInterface > (list));
        System.out.println( " my.name= " + my.getClass().getName());
        my.doSth();
        my.sayHello( " 千里冰封 " );
    }
     // 接口中的方法
     public   void  sayHello(String s) {
        System.out.println( " sayHello to: " + s);
    }
     // 接口中的方法
     public   void  doSth() {
        System.out.println( " doSth() " );
    }
     // 一个静态内部类,实现了InvocationHandler的接口,
     // 它也是一个关键的接口,所有代理后的行为都是在这里实现的
     static   class  MyHandler < T >   implements  InvocationHandler{
         private  T t;
         public  MyHandler(T t){
             this .t = t;
        }
         // 实现方法调用
         // 可以自己加上自己的一些调用,此例中只是在加上了一个输出
         public  Object invoke(Object proxy, Method method, Object[] args)  throws  Throwable {
            System.out.println( " 我知道马上要被调用的方法是: " + method.getName());
             return  method.invoke(t,args);
        }
        
    }
}

运行上面的类输出是:

my.name=$Proxy0
我知道马上要被调用的方法是:doSth
doSth()
我知道马上要被调用的方法是:sayHello
sayHello to:千里冰封

从这里可以看出,代理的类的名字换成了$Proxy0,其中$Proxy是所有代理类的类名前缀
我们在调用doSth()和sayHello()的时候,都调用到了我们在代理中设置的输出.如果你想在这里代理别的类,也是可以的,只要你符合以上的调用规律.
最后特别要注意的一点是:

// 实现方法调用
         // 可以自己加上自己的一些调用,此例中只是在加上了一个输出
         public  Object invoke(Object proxy, Method method, Object[] args)  throws  Throwable {
            System.out.println( " 我知道马上要被调用的方法是: " + method.getName());
             return  method.invoke(t,args);
        }

在上面的实现中,千万不能调用method.invoke(proxy,args).因为proxy本身就是一个代理的对象,你如果再在它上面调用一个方法的话,会无限递归的调用这个方法,所以,在InvocationHandler的实现里面,最好是传一个代理对象的真正实现进去,这样就可以还原本来的调用结果,并加上自己的东西在里面.