java 代理(proxy)模式

   代理模式是常用的Java 设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

  例如：

 

package proxy;
interface Dao{
  public void insert();
}
class JdbcDao implements Dao{
public void insert(){
System.out.println("in jdbc insert");
}
}
class HibernateDao implements Dao{
public void insert(){
System.out.println("in hibernate insert");
}
}
class ProxyDao implements Dao{
private Dao dao;
public ProxyDao(Dao dao){
this.dao=dao;
}
public void insert() {
System.out.println("write log before invoke");
dao.insert();
System.out.println("write log after invoke");
}
}
public class Test {
public static void main(String[] args) {
Dao jdbcDao =new JdbcDao();
Dao proxydao = new ProxyDao(jdbcDao);
proxydao.insert();
}
}

 

   以上例子中使用了静态代理，而动态代理与静态代理的区别在于，动态代理中的代理类是由java.lang.reflect.Proxy类在运行期间根据接口定义，

和 java.lang.reflect.InvocationHandler结合，可以加强现有类的方法实现。如图2：

  

 

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

你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，

在生成它的实例时你必须提供一个handler，由它接管实际的工作。

例子

声明业务接口HelloWorld:

interface HelloWorld{
	public void sayHello();
	public String sayHelloWithReturnValue();
}

 声明业务接口的实现类：

class HelloWorldImple implements HelloWorld{

	public void sayHello() {
		System.out.println("执行了sayHello()");
	}

	public String sayHelloWithReturnValue() {
		String str = "HelloWorld";
		System.out.println("执行了 sayHelloWithReturnValue()");
		return str;
	}
	
} 

 

声明自定义handler类：

class HelloWorldHandler implements InvocationHandler{
	private Object target;//要代理的目标对象
	public HelloWorldHandler(){
	}
	public HelloWorldHandler(Object obj){
		this.target = obj;
	}
	public Object newProxy(Object obj){
		this.target = obj;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result;
		doBefore();
		result = method.invoke(target, args);
		doAfter();
		return result;
	}
	private void doBefore(){
		System.out.println("before method invoke!");
	}
	private void doAfter(){
		System.out.println("after method invoke!");
	}
	
}

 

编写测试代码：

public static void main(String[] args) {
		HelloWorldHandler handler = new HelloWorldHandler();
		HelloWorld proxy = (HelloWorld)handler.newProxy(new HelloWorldImple());
		proxy.sayHello();
		String str = proxy.sayHelloWithReturnValue();
		System.out.println(str);
	}