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

1. 抽象接口的方法有参数的情况

        在《浅析JAVA设计模式之代理模式(二)》（简称《二》）中,抽象方法里面的方法是没有参数的，如果方法里面有参数的，我们的代码又该如何写？

1.1 静态代理的处理

         在《浅析JAVA设计模式之代理模式(一)》（简称《一》）中,实现的静态代理本来就是有参数的,也非常容易实现,可参考回《一》，这里不再详细分析。

1.2 动态代理的处理

（1）新建一个包argDynamicProxy。

（2）如果抽象接口中的方法带有参数，现在改动一下《二》中的Subject.Java文件，增加一个参数。

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

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

package argDynamicProxy;
public  class  RealSubject implements Subject{
	public  void  print(String words) {
		System.out.println("被代理的人郭襄说:\""+words+"!\"");
	}
}

（4）相应的《二》中的处理器类（LogHandler.java）进行改动,在invoke()方法中参数列表中，增加了一个参数Object[] args，在method.invoke(delegate,args);这句代码中，也增加了一个参数 args。

package argDynamicProxy;
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 , Object[] args) throws Exception{
		Object result=null;
		System.out.println("我是代理人郭靖，开始代理");
		result=method.invoke(delegate,args);
		System.out.println("我是代理人郭靖，代理完毕");
		return result;
	}
}

（5）相应的《二》中Proxy.java进行较大的改动，请认真看注释，可对比《二》中的Proxy.java。

package argDynamicProxy;
import java.io.File;   
import java.io.FileWriter;   
import java.lang.reflect.Constructor;   
import java.lang.reflect.Method;   
import java.net.URL;   
import java.net.URLClassLoader;   
  
import javax.tools.JavaCompiler;   
import javax.tools.StandardJavaFileManager;   
import javax.tools.ToolProvider;   
import javax.tools.JavaCompiler.CompilationTask; 
  /** 
     * @param  subjectinterface        传进被代理的类的抽象接口 
     * @param  InvocationHandler       处理器接口实例 
     * @return                         代理类实例 
     */ 
//生成代理主题角色的类
public  class  Proxy {
public  static  Object newProxyInstance(Class subjectinterface ,InvocationHandler h)
throws  Exception{
	Object obj=null;
    //换行的转义符
	String br ="\r\n";
	//得到抽象主题接口里面所有的方法数组
    Method[] ms=subjectinterface.getMethods(); 
    //存储用反射制造出来的抽象主题接口里面的方法
    String methodString =""; 
    //存储反射出接口方法的参数
    String methodArgs="";       //改动增加这句
    //存储参数数组里面的参数
    String objectArrayArgs="";  //改动增加这句
    //存储参数类型 
    String typesclass="";       //改动增加这句
    for(Method m:ms){
    	// 改动 增加（38到54行）这段代码，写进接口的方法参数列表
      	//获取方法参数类型数组
        Class [] mc=m.getParameterTypes();
        for(int i=0;i<mc.length;i++){
        	//存进方法参数类型
        	methodArgs+=mc[i].getSimpleName();
        	//存进方法参数名 args是自己随便弄个名字
        	methodArgs+=(" args"+i);
        	//存进方法类型的类
        	typesclass+=(mc[i].getSimpleName()+".class");
        	//存进参数数组里面的参数
        	objectArrayArgs+=("args"+i);
        	//如果不是到最后一个参数就存进一个逗号分隔
        	if(i<mc.length-1){
        		methodArgs+=",";
        		objectArrayArgs+=",";
        		typesclass+=",";
        	}
        }
     
    	//如果要代理的接口有多个方法，要把下面的 "methodString=" 改成 "methodString+="
//methodString=只适用于抽象接口只有1个方法，methodString+=适用于抽象接口有1个或1个以上方法
methodString+= 
    	"  public void  "+m.getName()+"("+methodArgs+")"+"{"+br+
    	"     try{ "+ br +
    	"     Object[] args={"+objectArrayArgs+"};"+ br + //改动增加这句
    	"     Class[]types=new Class[]{"+typesclass+"};"+ br + //改动增加这句
    	//不可以去掉这句 //改动增加了“,types”
    	" 	   Method md="+subjectinterface.getSimpleName()+".class.getMethod(\""+m.getName()+"\""+",types);"+br+
    	"       h.invoke(this,md,args);"+br+
    	 "       }catch (Exception e){ "+ br+    
         "           e.printStackTrace();" + br +    
         "       }" + br +   
     "   }";   
   }//foreach循环结尾 
	String src="package argDynamicProxy;"+br+ //改动
			   "import java.lang.reflect.Method;"+br+
	"public class $Proxy implements "+subjectinterface.getSimpleName()+"{"+br+
	" private argDynamicProxy.InvocationHandler h;"+br+  //改动
	"   public $Proxy(InvocationHandler h) {" + br +   
    "       super();" + br +   
    "       this.h = h;" + br +   
    "   }" + br + br +
    methodString+br+
    "}";

   //生成java文件    
	 String fileName ="F:\\G\\servlet\\Design\\argDynamicProxy\\$Proxy.java";  //改动包名
	 
	 File file = new File(fileName);   
     FileWriter fWriter = new FileWriter(file);   
     fWriter.write(src);   
     fWriter.flush();   
     fWriter.close();   
	
     //jdk6工具类生成class文件   
     JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();   
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);   
     Iterable units = fileManager.getJavaFileObjects(fileName);   
     CompilationTask task = compiler.getTask(null, fileManager, null, null, null, units);   
     task.call();   
     fileManager.close();   

     //生成代理类的类对象                   
     Class c=Class.forName("argDynamicProxy.$Proxy");  //改动包名
     Constructor ctr=c.getConstructor(InvocationHandler.class);
//生成代理类的实例，传进处理器对象，用于给代理类调用invoke()方法
obj=(Object) ctr.newInstance(h);
	return obj;//返回代理类实例
}
}

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

package argDynamicProxy;
public class TestargDynamicDynamicProxy {  
    public static void main(String[] args)throws Exception {  
       Subject sub1=new RealSubject();  
       LogHandler hander=new LogHandler();  
       Subject sub2=(Subject)hander.bind(sub1);  
       sub2.print("你好");  
    }  
}  

输出结果：

我是代理人郭靖，开始代理

被代理的人郭襄说:"你好!"

我是代理人郭靖，代理完毕

结果可以看出，成功实现了有参数的方法的代理。生成了代理类$Proxy，生成后的代码如下：

package argDynamicProxy;
import java.lang.reflect.Method;
public class $Proxy implements Subject{
 private argDynamicProxy.InvocationHandler h;
   public $Proxy(InvocationHandler h) {
       super();
       this.h = h;
   }
  public void  print(String args0){
     try{ 
     Object[] args={args0};//增加的代码
     Class[]types=new Class[]{String.class};//增加的代码
 	   Method md=Subject.class.getMethod("print",types); //增加一个参数types
       h.invoke(this,md,args);
       }catch (Exception e){ 
           e.printStackTrace();
       }
   }
} 

        从上面的代码中看出$Proxy比《二》的$Proxy多了两行代码，增加了一个参数types，而相对应的Proxy类的修改的关键就是运用反射技术，把$Proxy类增加的两行代码生成。

 

推荐文章：

浅析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/24985737

浅析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: 读书得可道之道，实践悟不可道之道