jdk动态代理

以下的内容是从 http://www.blogjava.net/DoubleJ/archive/2008/03/04/183796.html 引用而来 谢谢

 

基于接口的jdk动态代理编程

1，先定义一个接口，把我们要做的事情写成接口方法

public interface IOstocy{
   void sayHello(String name);

   void sayGoodBye(String name);

}

 2,我们给与IOstocy一个实现类

public class Ostocy implements IOstocy{
  public void sayHello(String name){
      System.out.println("hello"+name);
  }
  
  public void sayGoodBye(String name){
      System.out.println(name+"goodsBye!");
  }
}

  一个很简单的实现类

3，我们写一个代理类，来实现java.lang.reflect.InvocationHandler接口，目的是希望jvm在处理Ostocy这个类的时候可以通过代理类能够对ostocy类中的方法做另行的控制

public class DynaProxyOstocy implements InvocationHandler{
  
   private Object delegate;//会存在需要处理对象的引用

   public Object bind(Object delegate){
    
      this.delegate=delegate;
      return Proxy.newProxyInstance(this.delegate.getClass().getClassLoader(),this.delegate.getClass().getInterfaces(),this);//一个代理的工厂方法去得到一个类加载器然后得到接口部分，这时上下文中就有了ostocy接口的引用了吧

   }

   public Object invoke(Object proxy,Method method,Object[]args)throws Throwable{
    Object result=null;
    try{
           Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
           //JVM通过这条语句执行原来的方法(反射机制)
           result = method.invoke(this.delegate, args);

           //执行原来的方法之后记录日志
           Logger.logging(Level.INFO, method.getName() + " Method Start!");
        }catch(Exception e){
          e.printStackTrace();
        }
        return result;

   }

}

 当类进入这个代理类的时候，每一个在实现类中的方法都会被invoke到，也就是方法都会被invoke处理一次，但其是基于接口中定义的方法扫面的吧。

 

4，写一个测试类

 public class Test {
     public static void main(String[] args) {
         IOstocy ostocy = (IOstocy )new DynaProxyOstocy().bind(new Ostocy());
         ostocy.sayGoogBye("Double J");
         ostocy.sayHello("Double J");
         
    }
}

 代理类去bind了ostocy()这个类，bind方法在通过类加载器获取其内部内容。然后在调用sayGoodBye和sayHello的时候，都会被invoke一次。所以日志都被记录了。这就是jdk的动态代理。实质还是基于反射，获取类内部的内容。