浅析JAVA设计模式之代理模式(三)

1. 抽象接口有多个方法的情况

        在《浅析JAVA设计模式之代理模式(一)》（简称《一》）和《浅析JAVA设计模式之代理模式(二)》（简称《二》）中,抽象方法里面只有一个方法，如果有一个以上的方法需要代理，我们的代码又该如何写？

1.1 静态代理的处理

（1）现在改动一下《一》中的Subject.Java文件，增加一个方法。

package StaticProxy;
public interface Subject {
	public void print(String words);
	public void print2(String words);
}

（2）相应的《一》中的被代理类（RealSubject.java）进行改动。

package StaticProxy;

    publicclass RealSubject implements Subject{

    publicvoid print(String words) {

       System.out.println("被代理的人郭襄说："+words);

    }

    publicvoid print2(String words) {

       System.out.println("被代理的人郭襄2说："+words);

    }

}

（3）相应的《一》中的代理类（ProxySubject.java）进行改动。

package StaticProxy;
public class ProxySubject implements Subject{
    private Subject s;
    public ProxySubject(Subject s){
    	this.s=s;
    }
	public void print(String words) {
		System.out.println("我是代理,我的名字叫黄蓉！");
		   //调用实际的被代理的方法print()
		s.print(words);
		System.out.println("黄蓉代理完毕！");
	}
	public void print2(String words) {
		System.out.println("我是代理,我的名字叫黄蓉！");
		   //调用实际的被代理的方法print2()
		s.print2(words);
		System.out.println("黄蓉代理完毕！");
	}
}

（4）再修改一下客户端程序（TestSubject.java）。

package StaticProxy;
public class TestSubject {  
	 public static void main(String []args){  
	  Subject sub1=new RealSubject();//创建真实对象（被代理对象）   
	  Subject sub2=new ProxySubject(sub1);//创建代理对象，把被代理对象传进去   
	   sub2.print("你好!"); //调用代理方法print()   
	   System.out.println();
	   sub2.print2("你坏!"); //调用代理方法print2()   
	 }  
}

输出结果：

我是代理,我的名字叫黄蓉！

被代理的人郭襄说：你好!

黄蓉代理完毕！

 

我是代理,我的名字叫黄蓉！

被代理的人郭襄2说：你坏!

黄蓉代理完毕！

      从结果可以看出，当有多个方法需要代理的时候，静态代理还是很好实现的，当不同的方法被调用时，相应的处理也会被调用。

       但是，如果一个被代理类有多个方法，而这些方法调用前后都有着相同的处理方式，那么静态代理中的代理类就要在不同的方法里面写着相同的代码，如果某一天改动了一下，所有的代码都要全部改动一次，这样非常不好，这种情况使用《二》的动态代理只需要在LogHandler.java中的invoke( )方法中写一次即可。

1.2 动态代理的处理

   （1）如果是对抽象接口中不同的方法都有相同的处理逻辑，只需要把《二》的Proxy.java改动一小下，把里面的newProxyInstance()方法下的methodString=改成methodString+=即可，其中methodString=只适用于抽象接口只有1个方法，methodString+=适用于抽象接口有1个或1个以上方法。

   （2）如果对抽象接口中不同的方法有不相同的处理逻辑，情况就有点变化。现在改动一下《二》中的Subject.Java文件，增加一个方法。

package dynamicProxy;
public interface Subject {
	public void print();
	public void print2();
}

（3）相应的《二》中的被代理类（RealSubject.java）进行改动。

package dynamicProxy;
public class RealSubject implements Subject{
	public void print() {
		System.out.println("被代理的人郭襄");
	}
	public void print2() {
		System.out.println("被代理的人郭襄2");
	}
}

（4）相应的《二》中的处理器类（LogHandler.java）进行改动。

package dynamicProxy;  
import java.lang.reflect.*;
public class LogHandler implements InvocationHandler{  
private Object delegate; //被代理类的对象   
	//绑定被代理类的对象
	public Object bind(Object delegate)throws Exception{
		this.delegate=delegate;
		//Proxy就是要生成代理类的类，Subject.class 是要被代理的类所实现的接口
		return Proxy.newProxyInstance(Subject.class,this);
	}  
 
   public Object invoke(Object proxy, Method method) throws Exception {
		String name=method.getName();
		Object result=null;
		if(name.equals("print")){
			System.out.println("我是代理人黄蓉，开始代理");
			result=method.invoke(delegate);
			System.out.println("我是代理人黄蓉，代理完毕");
		} if(name.equals("print2")) {
			System.out.println("我是代理人黄蓉2，开始代理");
			result=method.invoke(delegate);
			System.out.println("我是代理人黄蓉2，代理完毕");
		}
		return result;
	}
}

（5）相应的《二》中的测试客户端（TestDynamicProxy.java）进行改动。

package dynamicProxy;  
public class TestDynamicProxy {  
    public static void main(String[] args)throws Exception {  
       Subject sub1=new RealSubject();  
       LogHandler hander=new LogHandler();  
       Subject sub2=(Subject)hander.bind(sub1);  
       sub2.print();  
       sub2.print2();
    }  
}  

输出结果：

我是代理人黄蓉，开始代理

被代理的人郭襄

我是代理人黄蓉，代理完毕

我是代理人黄蓉2，开始代理

被代理的人郭襄2

我是代理人黄蓉2，代理完毕

 （6）生成的$Proxy.java文件如下，可看出抽象接口的每个方法都已经被代理。

package dynamicProxy;
import java.lang.reflect.Method;
public class $Proxy implements Subject{
 private dynamicProxy.InvocationHandler h;
   public $Proxy(InvocationHandler h) {
       super();
       this.h = h;
   }

  public void  print2(){
     try{ 
 	   Method md=Subject.class.getMethod("print2");
       h.invoke(this,md);
       }catch (Exception e){ 
           e.printStackTrace();
       }
   }  public void  print(){
     try{ 
 	   Method md=Subject.class.getMethod("print");
       h.invoke(this,md);
       }catch (Exception e){ 
           e.printStackTrace();
       }
   }
}

       结果可以看出，对不同的方法实现了不同的处理逻辑，而且还可以把处理逻辑写成配置式的，这里就不详细说明。

动态代理的明显好处这里就体现出来了：

1．对于同一个对象的所有方法，如果对所有方法都是相同的处理逻辑，只需要写一次处理逻辑就行。

2．对于同一个抽象接口，不同的对象，如果对所有对象的相同名字的方法具有相同的处理逻辑（同一个对象，不同方法的处理逻辑可以不同），也只需要写一次处理逻辑就行，只需要写一次处理器类即可。

3．如果某一天，那个方法的处理逻辑被改变了，只需要改动一次即可，如果是静态代理，每个代理类下的相对应的方法的处理逻辑都要改动一次，维护非常困难。

 

 

推荐文章：

浅析JAVA设计模式之代理模式(一)

http://blog.csdn.net/minidrupal/article/details/24807835

浅析JAVA设计模式之代理模式(二)

http://blog.csdn.net/minidrupal/article/details/24888271

浅析JAVA设计模式之代理模式(四)

http://blog.csdn.net/minidrupal/article/details/25058433

浅析JAVA设计模式之代理模式(五)

http://blog.csdn.net/minidrupal/article/details/25093563

浅析JAVA设计模式之代理模式(六)

http://blog.csdn.net/minidrupal/article/details/27948355

浅析JAVA设计模式之代理模式(七)

http://blog.csdn.net/minidrupal/article/details/28588507

Author: Piano
Introduction: 师者
Sign: 读书得可道之道，实践悟不可道之道