Java动态代理

代理是一种常用的程序设计模式，如同网络代理一样，代理是介于调用者和真正调用目标对象之间的中间对象，代理在调用真正目标对象时提供一些额外或者不同的操作，真正的对目标对象的操作还是通过代理调用目标对象来完成。

简单的代理例子如下：

[java] view
plaincopy

//接口

interface Interface{

void doSomething();

void somethingElse(String arg);

}

//目标对象

class RealObject implement Interface{

public void doSomething(){

System.out.println(“RealObject doSomething”);

}

public void somethingElse(String arg){

System.out.println(“RealObject somethingElse ” + arg);

}

}

//简单代理对象

class SimpleProxy implements Interface(

private Interface proxied;

public SimpleProxy(Interface proxied){

this.proxied = proxied;

}

public void doSomething(){

System.out.println(“SimpleProxy doSomething”);

proxied.doSomething();

}

public void somethingElse(String arg){

System.out.println(“SimpleProxy somethingElse ” + arg);

proxied.somethingElse(arg);

}

)

Class SimpleProxyDemo{

public static void consumer(Interface iface){

iface.doSomething();

iface.somethingElse(“TestProxy”);

}

public static void main(String[] args){

//不是用代理

cosumer(new RealObject());

//使用代理

cosumer(new SimpleProxy(new RealObject()));

}

}

输出结果为：

RealObject doSomething

RealObjectsomethingElse TestProxy

SimpleProxy doSomething

RealObject doSomething

SimpleProxy somethingElse TestProxy

RealObject somethingElse TestProxy

上面例子可以看出代理SimpleProxy在调用目标对象目标方法之前做了一些额外的操作。

Java中的代理是针对接口的动态代理，当然java也可以使用第三方的CGLIB实现针对类的代理，但是JDK中只支持针对接口的动态代理，我们只分析JDK的动态代理。

JDK动态代理的要素：

(1).实现了InvocationHandler的代理处理类，实现其invoke方法，该方法是代理调用目标对象方法以及提供额外操作的方法。

(2).使用Proxy.newProxyInstance(类加载器, 代理接口列表,InvocationHandler对象);方法创建实现了指定接口的动态代理。

JDK的代理例子如下：

[java] view
plaincopy

//接口

interface Interface{

void doSomething();

void somethingElse(String arg);

}

//目标对象

class RealObject implement Interface{

public void doSomething(){

System.out.println(“RealObject doSomething”);

}

public void somethingElse(String arg){

System.out.println(“RealObject somethingElse ” + arg);

}

}

//代理处理类

class DynamicProxyHandler implements InvocationHandler{

provate Object proxied;

public DynamicProxyHandler(Object proxied){

this.proxied = proxied;

}

//动态代理调用目标对象的方法

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

System.out.println(“Dynamic proxy invoke”);

return method.invoke(proxied, args);

}

}

class SimpleDynamicProxy{

public static void consumer(Interface iface){

iface.doSomething();

iface.somethingElse(“DynamicProxy”);

}

public static void main(String[] args){

RealObject real = new RealObject();

//不是用代理

consumer(real);

//创建动态代理

Interface proxy = (Interface) Proxy.newProxyInstance(

Interface.class.getClassLoader(),

new Class[]{Interface.class},

new DynamicProxyHandler(real)

);

cosumer(proxy);

}

}

输出结果为：

RealObject doSomething

RealObject somethingElse DynamicProxy

Dynamic proxy invoke

RealObject doSomething

Dynamic proxyinvoke

RealObject somethingElse DynamicProxy

InvocationHandler 用于实现代理。

如果不用InvocationHandler接口实现代理的话，我们写代码是这样的：

定义一个接口：

Java code

interface Greet
{
void sayHello(String name);

void goodBye();
}

实现这个接口：

Java code

class GreetImpl implements Greet
{
public void sayHello(String name)
{
System.out.println("Hello " + name);
}

public void goodBye()
{
System.out.println("Good bye.");
}
}

实现一个代理类

Java code

public class SimpleProxy implements Greet
{
private Greet greet = null;

SimpleProxy(Greet greet)
{
this.greet = greet;
}

public void sayHello(String name)
{
System.out.println("--before method sayHello");
greet.sayHello(name);
System.out.println("--after method sayHello");
}

public void goodBye()
{
System.out.println("--before method goodBye");
greet.goodBye();
System.out.println("--after method goodBye");
}

/**
* @param args
*/
public static void main(String[] args)
{
Greet greet = new SimpleProxy(new GreetImpl());//生成代理
greet.sayHello("walter");
greet.goodBye();

}
}

代理其实没什么的，再看看如果实现了InvocationHandler接口，

我们怎样实现代理。

还是要实现原来的Greet接口。

接口的实现还是GreetImpl。

Java code

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class DebugProxy implements java.lang.reflect.InvocationHandler
{
private Object obj;

public static Object newInstance(Object obj)
{
return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), new DebugProxy(obj));
}

private DebugProxy(Object obj)
{
//Greet接口的實現：GreetImpl
this.obj = obj;
}

//Method m：調用的方法
//Object[] args：方法要傳入的參數
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object result;
try
{
//自定義的處理
System.out.println("--before method " + m.getName());
//調用GreetImpl中方法
result = m.invoke(obj, args);
}
catch(InvocationTargetException e)
{
throw e.getTargetException();
}
catch(Exception e)
{
throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
}
finally
{
System.out.println("--after method " + m.getName());
}
return result;
}

/**
* @param args
*/
public static void main(String[] args)
{
Greet tmp = new GreetImpl();

Greet greet = (Greet) DebugProxy.newInstance(tmp);
//生成的greet和tmp有相同的hashCode

greet.sayHello("walter");
greet.goodBye();
}
}

实现了InvocationHandler接口的

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

Proxy 代理类

Method 调用的方法

Args  调用方法的参数

的方法的类可以作为InvocationHandler类的参数来构建Proxy类的实例

当调用被代理的类（Connection）的实例的方法时系统将转到包含代理类（Proxy）的InvocationHandler的

invoke

方法中去执行相应代码。

这样就可以在不修改代码的前提下为已经存在的类来添加新的功能。

如：

public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
Object obj = null;
if (CLOSE_METHOD_NAME.equals(m.getName())) {
DBConnectionPool.pushConnectionBackToPool(this);
}
else {
obj = m.invoke(m_originConnection, args);
}
if (DEBUG) {
System.out.println(m.getName()+"is invoke!");
}
lastAccessTime = System.currentTimeMillis();
return obj;
}