关于代理模式的一些小的例子

代理的方法是有两种
一种是静态的代理方法
还有一种是动态的代理方法
首先研究的是静态的代理的方法 它主要体现的是代理模式的思想
首先是定义一个实现业务的接口

public interface UserManager {
     public void setUserName();
     public void setUserPassword();
     public void setAddress();
} 

然后是定义一个类去实现这些接口

public class UserManagerImpl implements UserManager {

	@Override
	public void setAddress() {
      System.out.println("-----setAddress Successfully!-------");
	}

	@Override
	public void setUserName() {
	  System.out.println("-----setUserName Successfully!-------");

	}

	@Override
	public void setUserPassword() {
	  System.out.println("-----setUserPassword Successfully!-------");

	}

}

然后是一个代理的实现类 既然是代理类当然是要也实现这些业务否者就不能实现代理功能了

public class UserManagerProxy implements UserManager {
        private UserManager  manager; 
        public UserMnaagerProxy(UserManager  manager){
              this.manager = manager 
}
	@Override
	public void setAddress() {
         check();
         manager.setAddress();
	}

	@Override
	public void setUserName() {
	 check();
          this.manager.setUserName();

	}

	@Override
	public void setUserPassword() {
	  check();
          this.manager.setUserPassword();

	}
        public void check(){
            System.out.println("-----check Successfully!-------");
}

}

客户端的代码就是

import org.util.Impl.UserManagerImpl;

import org.util.interfaces.UserManager;

public class UserManagerClient {


	public static void main(String[] args) {

		UserManager proxy = new UserManagerProxy(new UserManagerImpl()); 
	       proxy.setAddress();
               proxy.setUserPassword();
	       proxy.setUserName();
	}

}

这就是静态代理方法了 他不适合适用于大的代码量就是说很多的业务方法都必须的进行check();这就比较麻烦了 但是java 的包里给我们实现了一个动态的实现代理的模式体现了aop的思想
首先是他的接口的代码是 实现接口的业务类相同的就不写了都是相同的 就不再写代码了
就在上面
然后就是他的一个包含在动态代理类里的一个实现 （调用处理程序 接口）的实现类并且我们可以将这个代理类的实例化在这个类中完成 其实这都是一步一步的走的

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

public class UserManagerInvoke implements InvocationHandler {
    public Object targetObj ;

    public Object newProxy(Object targetObj){
    	this.targetObj = targetObj;
    	/**
    	 *  创建一个目标类的Proxy实例
    	 *  并且将一个实现InvocationHandler类的实例的参数
    	 *  传进对这个Proxy对象将成员进行初始化
    	 *  从下面的例子中可以看出这个类主要的思想就是AOP思想
    	 *  就是为第三个参数（实现InvocationHandler类的实例的参数）
    	 *  是最重要的  这个参数类的实例会实现在invoke()中整个的方法
    	 *  约定的是当你在使用这个代理类的时候会自东进行jinvoke()的方法
    	 */
    	return Proxy.newProxyInstance(targetObj.getClass().getClassLoader(),
    			                      targetObj.getClass().getInterfaces(),
    			                      this);
    }
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		checkSecurity();
		Object result = null;
		try{
			result = method.invoke(this.targetObj, args);
		}catch(Exception e ){
		  e.printStackTrace();	
		}
		return result;
	}
	public void checkSecurity(){
		System.out.println("-------checkSecurity Successfully!!!--------");
	}

}

关于java.lang.reflect.Proxy 的介绍你可以看看jdk的api文档这里不再细说了
然后是client的代码

import org.util.Impl.UserManagerImpl;
import org.util.aop.UserManagerInvoke;
import org.util.interfaces.UserManager;

public class UserManagerClient {


	public static void main(String[] args) {
		UserManagerInvoke hander = new UserManagerInvoke();
		UserManager proxy = (UserManager) hander.newProxy(new UserManagerImpl());
           //由proxy的实现机制可以看出 这个代理类每一次调用代理的方法就会自动转到
          //实现InvocationHandler接口的类中的invoke();方法中运行
	    proxy.setAddress();
	    proxy.setUserPassword();
	    proxy.setUserName();
	}

}

运行的结果就是
-------checkSecurity Successfully!!!--------
-----setAddress Successfully!-------
-------checkSecurity Successfully!!!--------
-----setUserPassword Successfully!-------
-------checkSecurity Successfully!!!--------
-----setUserName Successfully!-------
相比较而言第二种方式就有更灵活的代理机制了 也体现了aop的切面的思想