动态代理技术

Dynamic Proxy介绍

一、proxy模式简介

GoF介绍了proxy模式。代理对象为其他对象提供一种代理以控制对这个对象的访问。它静态结构如下：

Client需要访问RealSubject时，它实际访问的是Proxy对象，而后Proxy对象将请求委托给RealSubject。RealSubject实现了主要的逻辑，Proxy对象可以在处理请求之前、之后作额外的处理。可以看出，Proxy和RealSubject实现了同样的接口，这样Client才可以调用RealSubject实现的所有Subject的方法。

我们在实现Proxy时，如果使用的是C++语言，我们可以重载操作符->来实现代理。优点是实现简单，缺点是它不能区别对待不同的请求。当然也可以是用普通的形式，创建一个代理类，实现接口，并将调用委托给被代理的对象。

如果使用的是Java语言，我们当然可以使用普通的形式来实现Proxy模式。但是JDK1.3引入了dynamic proxy，它允许我们更容易的实现代理。

二、JDK中的Dynamic Proxy介绍

它由java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler等组成。Proxy类拥有一个protected的InvocationHandler类型的成员变量。它只能代理Interface。

它的基本思想如下：

1.     代理类由Proxy的静态方法getProxyClass来动态的创建出来。该方法所需要的一个参数为它所代理的接口数组。创建出来的代理类实现了所有的接口，并且继承了Proxy。

2.     代理类实现的接口方法的处理逻辑为，调用父类的InvocationHandler类型的成员变量的invoke方法。

由此可以看出，必须让Proxy对象拥有一个正确的InvocationHandler的实现。Proxy对象由Proxy的静态成员函数newProxyInstance来创建，该函数的最后一个参数为InvocationHandler类型。动态生成的代理类实现的所有接口方法都被委托给InvocationHandler接口的invoke方法。

三、例子代码

假如有如下接口：

interface Foo {

 void f(String s);

 void g(int i);

 String h(int i, String s);

}

并且有一个实现

class Implement implements Foo {

   …

}

现在我们想在Foo接口的每个方法调用时，加入日至。一个很简单很直观的方法如下：

class LogProxy implements Foo {

private Foo delegate ;

   public LogProxy( Foo foo ) {

          delegate = foo ;

}

public String h(int i, String s) {

      System.out.println(“call h begin ”) ;

      String result = delegate.h( i , s ) ;

      System.out.println(“call h end ”) ;

      Return result ;

}

…

}

new LogProxy( new Implement()　).h( 10 , “str”);

可以看出这样的实现代码很多，而且几乎都是相同的。当然可以编写程序来写出这样的代码，但是我们如果使用JDK1.3引入的dynamic proxy，那么情况就完全不同了。

四、dynamic proxy实现Log的代码

1.       编写InvocationHandler的子类，来拦截所有的方法调用。

class LogProxy implements InvocationHandler {

      public LogProxy( Object object ) { obj = object ; }

      public Object invoke(Object proxy, Method method, Object[] args)

      throws Throwable {  

String methodName = method.getName() ;

System.out.println("call " + methodName + “ begin “ ) ;       

           Object result = method.invoke( obj , args ) ;

System.out.println("call " + methodName + “ end“ ) ;       

           Return result ;

      }

      public Object obj = null ;

}

2.       使用Proxy的静态方法来创建代理类。 

LogProxy dp = new LogProxy( new Implment() ) ;

Foo proxy = (Foo) Proxy.newProxyInstance(

                    // [1] class loader

                    Foo.class.getClassLoader(),

                   // [2] interface's Class array

                          new Class[]{ Foo.class },

                          // [3] InvocationHandler

                   dp ) ;

3.       客户在代理类上调用方法

proxy.h( 10 , “str”);

可以看出，如果接口中有很多方法，那么使用dynamic proxy是很合适的，但是如果接口只有很少的方法，可能使用普通的方法更直观，也更简单。

五、应用例子

如果我们设计一个数据库连接池，接口如下：

interface DBConnectionPool {

            public java.sql.Connection getConnection() ;

            public void releaseConnection( java.sql.Connection conn ) ;

}

class DBConnectionPoolImpl implements DBConnectionPool {

            …

}

 

那么一个可能的用户调用序列如下：

void getData() {

            DBConnectionPoolImpl cpi = new DBConnectionPoolImpl() ;

            Connection conn = cpi.getConnection() ;

            // use conn to retrieve data from db

            …

            cpi. releaseConnection( conn ) ;

           

}

蓝色的代码表示了将连接还给连接池，因为所有的连接都是由连接池来管理的。但是这样的代码对用户来讲可能不太习惯，而且迫使用户这样编写代码，用户会意识到cpi对连接作了特殊的处理。

            一个更好的方法是调用Connection接口的close方法。这样的代码如下：

void getData() {

            DBConnectionPoolImpl cpi = new DBConnectionPoolImpl() ;

            Connection conn = cpi.getConnection() ;

            // use conn to retrieve data from db

            …

            conn.close() ;

}

这样更符合普通用户的编码习惯。但是可以这么编码的前提是：

1、close函数要将连接对象还给连接池，而不是关闭物理的数据库连接。

2、所有Connection的其他函数必须能够正常工作。

也就是说需要特殊处理close函数，而对其他函数直接进行转发就可以了。

用最直接的方法实现如下：

class ConnectionProxy implements Connection {

            private Connection realConn ;

            private DBConnectionPool dbcp ;

            public ConnectionProxy( Connection conn , DBConnectionPool pool ) {

                        realConn = conn ;

                        dbcp = pool ;

}

 

public void close() throws SQLException {

          dbcp. releaseConnection( realConn ) ;

}

 

public PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException {

         

          return realConn.prepareStatement( sql , columnNames ) ;

}

//        所有的其他Connection接口中的方法转发

…

}

可以看出这样的实现代码很多，而且几乎都是相同的。当然可以编写程序来写出这样的代码，如果使用DynamicProxy，那么整个实现就比较优雅了。

 

Classs ConnectionProxy InvocationHandler {

   Connection conn ;

   DBConnectionPool cp ;

Public ConnectionProxy( Connection conn , DBConnectionPool cp ) {

This.conn = conn ;

This.cp = cp ;
}

public Object invoke(Object proxy, Method method, Object[] args)

      throws Throwable {

             Object result = null ;

             if ( “close”.equals( method.getName() ) {

                   cp. releaseConnection( conn ) ;

} else {

            result = method.invoke( obj , args ) ;

}

           Return result ;

      }

}

有个类ConnectionProxy后，我们只需要让DBConnectionPool的方法getConnection返回动态代理即可。实现如下：

class DBConnectionPoolImpl implements DBConnectionPool {

            public Connection getConnection() {

                        Connection conn ;

                        // 从池中取得连接或建立连接

                        return (Connection)Proxy.newInstance(

                    Connection.class.getClassLoader(),

                          new Class[]{ Connection.class },

                    new ConnectionProxy( conn )  ) ;

 

}

}

这样就实现了连接池。

jdk1.5提供的用于rmi的dynamic stub也使用dynamic proxy技术。只要你认真研究，其实很多问题都可以使用dynamic proxy来解决。