java的静态与动态代理

采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。

按照代理类的创建时期，可以分为：静态代理和动态代理。

所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。

所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。

 

package www.ibm.delegate;

/*
 * 定义一个服务接口
 */
public interface Service 
{
	/** 
     * 查询日期 
     */  
    public String queryDate();  
    /** 
     * 计算两个整数之差 
     */  
    public int sub(int a, int b);  
}

package www.ibm.delegate;

import java.util.Date;  

/** 
 * 委托类需要实现服务接口（必须) 
 * @author IBM 
 */  
public class CountImpl implements Service {  
  
    @Override  
    public String queryDate() {  
        return new Date().toString();  
    }  
  
    @Override  
    public int sub(int a, int b) {  
        return a-b;  
    }  
      
    public void ownMethod(){  
        System.out.println("It's the delegate method");  
    }  
}  


package www.ibm.delegate;

public class StaticProxy implements Service{
	 private CountImpl countImpl;  
     
	    public StaticProxy(CountImpl countImpl){  
	        this.countImpl = countImpl;  
	    }  
	      
	    @Override  
	    public String queryDate() {  
	        return countImpl.queryDate();  
	    }  
	  
	    @Override  
	    public int sub(int a, int b) {  
	        return countImpl.sub(a, b);  
	    }  
	      
	    public void ownMethod(){  
	        System.out.println("It's the static method");  
	    }  

}


package www.ibm.delegate;

public class StaticProxyTest 
{
	public static void main(String [] args)
	{
		 //创建委托类实例，即被代理的类对象
		CountImpl taget= new CountImpl();
		//创建静态代理类  
		StaticProxy staticproxy = new StaticProxy(taget);
		String data = staticproxy.queryDate();
		System.out.println(data);
	}
}

/*output:
 * Wed Jun 27 09:43:38 CST 2012
 */

 静态代理类的特点： 代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。而且代理类只能为特定的接口(Service)服务。

 

以下：是动态代理类

 

package www.ibm.delegate;

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

public class DynamicProxy implements InvocationHandler
{

	private Object target;
	

	public DynamicProxy() {
		super();
	}


	public DynamicProxy(Object target) {
		super();
		this.target = target;
	}

	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;  
        result = method.invoke(target, args);  
        return result; 
	}

	/** 
     * @param target 
     * @return 返回委托类接口的实例对象 
     * 把这个方法包装了一下Proxy.newProxyInstance
     */  
    public Object getProxyInstance(){  
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),   
                target.getClass().getInterfaces(), this);  
    }  
    
    
}


package www.ibm.delegate;

public class StaticProxyTest 
{
	public static void main(String [] args)
	{
		 //创建委托类实例，即被代理的类对象
		CountImpl target= new CountImpl();
		//创建静态代理类  
		StaticProxy staticproxy = new StaticProxy(target);
		String data = staticproxy.queryDate();
		System.out.println(data);
		
		//创建动态代理类型
		DynamicProxy dynamicproxy=new DynamicProxy(target);
		Service service =(Service)dynamicproxy.getProxyInstance();
		String dydata =service.queryDate();
		System.out.println(dydata);
	}
}

/*output:
 * Wed Jun 27 10:10:19 CST 2012
 *Wed Jun 27 10:10:19 CST 2012
 */

  动态代理： 代理类需要实现 InvocationHandler接口。

使用场合举例： 如果需要委托类处理某一业务，那么我们就可以先在代理类中，对客户的权限、各类信息先做判断，如果不满足某一特定条件，则将其拦截下来，不让其代理。