JAVA动态代理

JAVA动态代理

 

 

在目前的Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的实现。

主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者。

 

Proxy类

 

Proxy类，提供用于创建动态代理类和实例的静态方法。其最重要的两个静态创建方法： 

public static Class getProxyClass (ClassLoader loader, Class[] interfaces)

获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。  

pubic static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

返回代理类的一个实例，返回后的代理类可以当作被代理类使用。

 

下图为API展示：

 

也就是说在方法 newProxyInstance内部，调用了getProxyClass方法。

 

InvocationHandler接口

 

InvocationHandler接口，是代理实例的调用处理程序实现的接口。 

它只有一个方法：

public Object invoke(Object obj, Method method, Object[] args)。

在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的say()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

 

JAVA动态代理

 

 

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。

 

你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

 

 

JAVA动态代理-时序图

 

JAVA动态代理实现过程

 

1. 实现接口InvocationHandler；

2. 实现代理类：被代理对象以构造函数参数的形式传入代理类；

3. 创建代理类实例函数：使用Proxy类的newProxyInstance函数创建动态代理实例；

4. 重写调用处理器（invoke函数）的代码。

 

 

实例如下：

 

public interface HelloWorld {
       void sayHelloWorld() ;
}

 

public class HelloWorldImpl implements HelloWorld {
       public void sayHelloWorld() {
              System.out.println("Hello World!");             
       }
}

 

public class HelloWorldHandler implements InvocationHandler {
    private Object objOriginal;  //要代理的原始对象
    public HelloWorldHandler(Object obj) {this.objOriginal = obj ;}
    public Object invoke(Object proxy, Method method, Object[] args)
                     throws Throwable {          
        Object result ;      
        doBefore();  //方法调用之前
        //调用原始对象的方法
        result = method.invoke(this.objOriginal ,args);
        doAfter();  //方法调用之后 
        return result ;
    }     
    private void doBefore() {  System.out.println("before method invoke!"); }
    private void doAfter() {  System.out.println("after method invoke!");  }
}

 

public class Test {
    public static void main(String[] args) {
        HelloWorld hw = new HelloWorldImpl();
        InvocationHandler handler = new HelloWorldHandler(hw);
        HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(
                            hw.getClass().getClassLoader(),
                            hw.getClass().getInterfaces(),
        handler);
        proxy.sayHelloWorld();
    }
}

 输出：

 

 

before method invoke!

Hello World!

after method invoke!

 

 

例子-时序图

 

$Proxy0的产生

1.  该类通过Proxy中的public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)产生。

2.  $Proxy0这个类重写了equals、hashCode、toString方法，又实现了业务类接口的方法（HelloWorldImpl的sayHelloWorld方法），具体重写和实现都是用到的handler.invoke这个方法。

3.  该类中属性、业务类接口方法等的获取都是通过反射机制获得。

 

public final class $Proxy0 extends Proxy implements HelloWorld{  

private static Method m1;    private static Method m0;  
private static Method m3;    private static Method m2;  
static {  
   try {  
    m1 = Class.forName("java.lang.Object").getMethod("equals",  
      new Class[] { Class.forName("java.lang.Object") });  
    m0 = Class.forName("java.lang.Object").getMethod("hashCode",  
      new Class[0]);  
    m3 = Class.forName("com.java.dao.HelloWorld").
              getMethod("sayHelloWorld",  new Class[0]);  
      m2 = Class.forName("java.lang.Object").getMethod("toString",  
      new Class[0]);  
   } catch (NoSuchMethodException nosuchmethodexception) {  
    throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
   } catch (ClassNotFoundException classnotfoundexception) {  
    throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
   }  
} 

public $Proxy0(InvocationHandler invocationhandler) {  
   super(invocationhandler);  
}     
@Override  
public final boolean equals(Object obj) {  
   try {  
    return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))  
      .booleanValue();  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}  
@Override  
public final int hashCode() {  
   try {  
    return ((Integer) super.h.invoke(this, m0, null)).intValue();  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}

@Override  
public final String toString() {  
   try {  
    return (String) super.h.invoke(this, m2, null);  
   } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
   }  
}
public final void sayHelloWorld() {  
   try {  
    super.h.invoke(this, m3, null);  
    return;  
   } catch (Error e) {  
 } catch (Throwable throwable) {  
    throw new UndeclaredThrowableException(throwable);  
}  
}   
}

 

小结：

1.  动态代理最根本的机制就是反射机制，运行时动态实例化任何一个类，并且调用它的具体细节。 

2.  被代理的对象(真实角色)可以在运行时动态改变，需要控制的接口(抽象)可以在运行时改变，控制的方式(代理角色)也可以动态改变，从而实现了非常灵活的动态代理关系。