Java动态代理

Java提供了动态代理，可以完成AOP和装饰模式的功能，主要的Proxy类和InvocationHandler接口：
1、Proxy类
[code]
public class Proxy implements java.io.Serializable {
//...
public static Class getProxyClass( ClassLoader loader,
Class[] interfaces )throws IllegalArgumentException;

public static Object newProxyInstance( ClassLoader loader,
Class[] interfaces,InvocationHandler h )throws IllegalArgumentException;
public static boolean isProxyClass( Class cl );
public static InvocationHandler getInvocationHandler( Object proxy )
throws IllegalArgumentException;
}
[/code]
Proxy类提供了一些工具方法：
getProxyClass得到代理类，如果不存在则动态创建。
newProxyInstance创建一个代理实例。
isProxyClass判断是否是一个代理类。
getInvocationHandler得到InvocationHandler。
一般先调用isProxyClass,判断是，然后再使用getInvocationHandler
参数：loader，创建对象需要classLoader，创建proxy也需要，一般被代理
真实对象得到：realObj.getClass().getClassLoader();
interfaces，代理和真实对象实现的接口。
创建一个代理一般使用以下两种方式：
方法一：
[code]
Proxy cl = getProxyClass( SomeInterface.getClassLoader(),
Class[]{SomeInterface.class} );
Constructor cons = cl.getConstructor( new Class[]{InvocationHandler.class} );
Object proxy = cons.newInstance( new Object[] { new SomeIH( obj ) } );
[/code]
方法二：
[code]
Object proxy = Proxy.newProxyInstance( SomeInterface.getClassLoader(),
Class[]{SomeInterface.class},
new SomeIH( obj ) );
[/code]
2、InvocationHandler接口：
[code]
public interface InvocationHandler {
public Object invoke( Object proxy, Method method, Object[] args )
throws Throwable;
}
[/code]
代理对象通过这个接口来将真实的对象联系起来。过程是：
代理对象直接调用InvocationHandler 的invoke方法，把自己作为proxy参数，调用的函数
作为method参数，调用函数的参数作为args传递过来，我们只需要在invoke方法中做一些事情，然后再调用被代理对象的方法就可以了。
我们以一个例子说明：
跟踪函数的调用过程：
函数执行之前和之后打印出跟踪信息：
实现InvocationHandler接口：
[code]
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class MethodTracker implements InvocationHandler{;
private Object target;
private PrintWriter out;

private MethodTracker(Object obj, PrintWriter out){
this.target = obj;
this.out = out;
}

public static Object createProxy(Object obj, PrintWriter out){
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new MethodTracker(obj,out));
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try{
out.println(method.getName() + "(...) called");
result = method.invoke(target, args);
}catch(InvocationTargetException e){
out.println(method.getName() + " throws " + e.getCause());
throw e.getCause();
}
out.println(method.getName() + " returns");
return result;
}

}
[/code]
我们测试一下：
[code]
import java.io.PrintWriter;

interface IHelloWorld{
void hello();
}

class HelloWorld implements IHelloWorld{
private String name = "world";

public void hello(){
System.out.println("Hello," + name);
}

public void setName(String name){
this.name = name;
}
}

public class TestTracker {
public static void main(String[] args) {
IHelloWorld tc = (IHelloWorld) MethodTracker.createProxy(new HelloWorld(),new PrintWriter(System.out,true));
tc.hello();
}
}
[/code]
Java动态代理的缺点是只能对接口进行代理，无法代理class。
3.高级进阶：
如果我们想象拦截器那样一层一层的拦截，也就是形成一个代理链，上面的实现可能会出现问题，比如我们想有个同步调用方法的代理，如果按照上面的实现
IHelloWorld tc = (IHelloWorld) MethodSynchronizer.createProxy(
MethodTracker.createProxy(new HelloWorld(),new PrintWriter(System.out,true))
);
将是错误的，因为他使用的同步对象是内层代理，而不是真实要被代理的对象。
要完成上面的功能，我们可以通过下面实现来达到：
[code]
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public abstract class InvocationHandlerBase implements InvocationHandler{
protected Object nextTarget;
protected Object realTarget = null;

public InvocationHandlerBase(Object target){
nextTarget = target;
if(nextTarget != null){
realTarget = findRealTarget(nextTarget);
if(realTarget == null){
throw new RuntimeException("findRealTarget failure");
}
}
}

protected final Object getRealTarget(){
return realTarget;
}

protected static final Object findRealTarget(Object t){
if(! Proxy.isProxyClass(t.getClass()))
return t;
InvocationHandler ih = Proxy.getInvocationHandler(t);
if(InvocationHandlerBase.class.isInstance(ih)){
return ((InvocationHandlerBase)ih).getRealTarget();
}else{
try{
Field f = findField(ih.getClass(), "target");
if(Object.class.isAssignableFrom(f.getType())&&
! f.getType().isArray()){
f.setAccessible(true);
Object innerTarget = f.get(ih);
return findRealTarget(innerTarget);
}
return null;
}catch(Exception e){
return null;
}
}
}

public static Field findField(Class<?> cls, String name) throws NoSuchFieldException{
if(cls != null){
try{
return cls.getDeclaredField(name);
}catch(NoSuchFieldException e){
return findField(cls.getSuperclass(),name);
}
}else{
throw new NoSuchFieldException();
}
}
}

[/code]
注意，这里我们约定了实现InvocationHandler接口的类使用target字段来保存被代理的对象，通过继承InvocationHandlerBase便可以达到所说的效果：
[code]
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class MethodSynchronizer extends InvocationHandlerBase{
public static Object createProxy(Object obj){
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), new MethodSynchronizer(obj));
}
private MethodSynchronizer(Object obj){
super(obj);
}

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

Object result = null;
synchronized( this.getRealTarget() ){
result = method.invoke(nextTarget, args);
}
return result;
}
}
[/code]
测试代码：
[code]
import java.io.PrintWriter;

interface IHelloWorld{
void hello();
}

class HelloWorld implements IHelloWorld{
private String name = "world";

public void hello(){
System.out.println("Hello," + name);
}

public void setName(String name){
this.name = name;
}
}

public class TestTracker {
public static void main(String[] args) {
IHelloWorld tc = (IHelloWorld) MethodSynchronizer.createProxy(
MethodTracker.createProxy(new HelloWorld(),new PrintWriter(System.out,true))
);
tc.hello();
}
}
[/code]