java 代理机制实现

[b]
Proxy 模式
[/b]

代理的主要类:java.lang.reflect.Proxy
它定义了一套静态方法,供我们使用,其中一个最常用的方法就是生成代理对象，动态代理机制的核心是 InvocationHandler 接口
[b]代理对象[/b]

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException

它根据你传入的类加载器和这个代理将会实现的接口,以及一个调用处理器,来生成一个代理对象.
[b]核心接口[/b]

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

请看例子：
接口1：

package com.ben.proxy;

/**
 * <pre>
 * </pre>
 * @author ben.liu
 * @version 1.0, 2008-9-23
 */
public interface Talk
{
	public void talk(String someone);
}

实现类1：

package com.ben.proxy;

/**
 * <pre>
 * </pre>
 * @author ben.liu
 * @version 1.0, 2008-9-23
 */
public class MyTalk implements Talk
{

	public void talk(String someone)
	{
		System.out.println("talk to "+someone);
	}

}

接口2：

package com.ben.proxy;

/**
 * <pre>
 * </pre>
 * @author ben.liu
 * @version 1.0, 2008-9-23
 */
public interface Write
{
	public void hello(String name);

	public void doAction();
}

实现类2：

package com.ben.proxy;

/**
 * <pre>
 * </pre>
 * @author ben.liu
 * @version 1.0, 2008-9-23
 */
public class MyWrite implements Write
{

	public void doAction()
	{
		System.out.println("doAction is done");
	}

	public void hello(String name)
	{
		System.out.println("hello !"+name);
	}

}

动态代理:

package com.ben.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * <pre>
 * 动态代理对象
 * </pre>
 * @author ben.liu
 * @version 1.0, 2008-9-23
 */
public class MyProxy<T> implements InvocationHandler
{
	private T t;

	public MyProxy(T t)
	{
		this.t = t;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
	{
		System.out.println("--------proxy:----" + proxy.getClass());
		System.out.println("--------Method:---" + method);
		System.out.println("--------args:-----" + args);
		if (args != null)
		{
			for (Object o : args)
				System.out.println("---------" + o);
		}

		return method.invoke(t, args);
	}

}

将两个接口绑定到代理来调用，实现不同的事情。示例如下：

package com.ben.proxy;

import java.lang.reflect.Proxy;

/**
 * <pre>
 * 代理机制示例
 * </pre>
 * @author ben.liu
 * @version 1.0, 2008-9-23
 */
public class MyProxyFactory
{
	private Object o;

	public void bond(Object o)
	{
		this.o = o;
		doSth();
	}

	public void doSth()
	{
		if (o instanceof Talk)
		{
			Talk t = (Talk) Proxy.newProxyInstance(Talk.class.getClassLoader(), new Class[] { Talk.class },
					new MyProxy(o));
			t.talk("ben");
		}
		if (o instanceof Write)
		{
			Write w = (Write) Proxy.newProxyInstance(Write.class.getClassLoader(), new Class[] { Write.class },
					new MyProxy(o));
			w.doAction();
			w.hello("bensoft");
		}
	}

	public static void main(String[] args)
	{
		Talk t = new MyTalk();
		Write w = new MyWrite();
		MyProxyFactory ft = new MyProxyFactory();
		ft.bond(t);
		ft.bond(w);
	}
}

通过以上MyProxyFactory类的绑定，将多个接口要做的事情在一个类中即可实现。