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

最新推荐文章于 2020-11-23 23:12:29 发布

小水滴2014

最新推荐文章于 2020-11-23 23:12:29 发布

阅读量2k

点赞数

分类专栏： JAVA技术

本文链接：https://blog.csdn.net/minidrupal/article/details/24888271

版权

JAVA技术专栏收录该内容

12 篇文章 1 订阅

订阅专栏

1 动态代理

在上一篇文章《浅析JAVA设计模式之代理模式(一)》中，已经简单介绍了代理模式的定义，以及分析和实现了静态代理类，接下来我们分析动态代理。

动态代理类：就是其代理类是在程序运行时，运用反射机制动态创建而成，并不需要像静态代理那样子事先要编写好代理类。如果有多重代理，就要写多个代理类，如果一个类有多个方法都需要代理的话，就更加使得代码臃肿，不易维护，这个时候就需要动态地来生成代理类，这就是动态代理。

1.1 动态代理

动态代理模式至少要有6个角色:

1. 抽象接口

2. 被代理类

3. 处理器接口

4. 自定义的处理器（实现处理器接口）

5．生成成代理类的类

6．代理类（由第5点的类通过反射技术自动生成）

1.2 动态代理的实现

(1) 首先建一个dynamicProxy包，所有程序都放在该包下。

(2) 首先建一个抽象接口（Subject.java）。

package dynamicProxy;

public interface Subject {

    public void print();

}

(3) 建一个被代理类（RealSubject.java），需要实现Subject接口。

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

(4) 建一个处理接口（InvocationHandler.java）。

package dynamicProxy;
public interface InvocationHandler {
	 public Object invoke(Object proxy, Method method)throws Exception;
}

(5) 建一个用户自定义的处理器，需要实现处理接口，在invoke（）方法里写上被代理类的方法调用前后要进行的动作。

这个invoke（）方法我们不用直接调用，是让将来自动生成的代理类去调用的。

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);
	}
 //invoke()方法是被自动生成的代理类调用，不用我们直接调用
	public Object invoke(Object proxy, Method method) throws Exception {
		Object result=null;
		System.out.println("我是代理人郭靖，开始代理");
//把被代理类对象传进去，通过反射技术调用被代理类的方法， 
		method.invoke(delegate); 
		System.out.println("我是代理人郭靖，代理完毕");
		return result;
	}
}

(6) 建生成代理类的类（Proxy.java）。

package dynamicProxy;
import java.io.File;   
import java.io.FileWriter;   
import java.lang.reflect.Constructor;   
import java.lang.reflect.Method;   
import javax.tools.JavaCompiler;   
import javax.tools.StandardJavaFileManager;   
import javax.tools.ToolProvider;   
import javax.tools.JavaCompiler.CompilationTask; 

//生成代理类的类
public class Proxy {
	/**
	 * @param  subjectinterface        传进被代理的类的抽象接口
	 * @param  InvocationHandler       处理器接口实例
	 * @return                            代理类实例
	 */	
public static Object newProxyInstance(
Class subjectinterface,InvocationHandler h)throws Exception{
	Object obj=null;
	String br ="\r\n"; //换行的转义符

	//得到抽象接口里面所有的方法数组
    Method[] ms=subjectinterface.getMethods(); 
    
    //存储用反射制造出来的抽象接口里面的方法
    String methodString =""; 
    
    for(Method m:ms){
    	//如果要代理的接口有多个方法，要把下面的 "methodString=" 改成 "methodString+="
    	methodString=
    	"  public void  "+m.getName()+"(){"+br+
    	"     try{ "+ br +
    	//不可以去掉这句
    	" 	   Method md="+subjectinterface.getSimpleName()+".class.getMethod(\""+
m.getName()+"\");"+br+
    	"       h.invoke(this,md);"+br+
    	 "       }catch (Exception e){ "+ br+    
         "           e.printStackTrace();" + br +    
         "       }" + br +   
     "   }";   
    	
}   
	String src="package dynamicProxy;"+br+
			   "import java.lang.reflect.Method;"+br+
	"public class $Proxy implements "+subjectinterface.getSimpleName()+"{"+br+
	" private dynamicProxy.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\\dynamicProxy\\$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("dynamicProxy.$Proxy");
     Constructor ctr=c.getConstructor(InvocationHandler.class);
     //生成代理类的实例，传进处理器对象，用于给代理类调用invoke()方法
     obj=(Object) ctr.newInstance(h);
	 return obj;  //返回代理类实例
}
}

这个类生成了一个$Proxy.Java

(7)编写测试客户端（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();

    }

}

输出结果：

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

被代理的人郭襄

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

从结果可以看出，成功自动生成了代理类$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  print(){
     try{ 
 	   Method md=Subject.class.getMethod("print");
       h.invoke(this,md);
       }catch (Exception e){ 
           e.printStackTrace();
       }
   }
}

(8)我们看一下以上情形的UML图。

图1.1

（9）为了程序好理解一点，我们可以改进一下LogHandler类（LogHandler.java），去掉里面的bind()方法，改进代码如下：

package dynamicProxy;
import java.lang.reflect.*;
public class LogHandler implements InvocationHandler{
	private Object delegate; //被代理类的对象

	public LogHandler (Object delegate){
		this.delegate=delegate;
	}
 //invoke()方法是被自动生成的代理类调用，不用我们直接调用
	public Object invoke(Object proxy, Method method) throws Exception {
		Object result=null;
		System.out.println("我是代理人郭靖，开始代理");
//把被代理类对象传进去，通过反射技术调用被代理类的方法， 
		method.invoke(delegate); 
		System.out.println("我是代理人郭靖，代理完毕");
		return result;
	}
}

(10) 接着再改一下测试客户端（TestDynamicProxy.java）。

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

输出结果：

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

被代理的人郭襄

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

(11) 结果和没改之前一样，但是它们的UML图发生了改变，比之前简单一点。

（12）如果有多重代理，比如再加多一个代理，只需实现InvocationHandler接口，我们编写LogHandler2.java。

package dynamicProxy;
import java.lang.reflect.*;
public class LogHandler2 implements InvocationHandler{
	private Object delegate;//被代理类的对象
	public LogHandler2(Object delegate){
		this.delegate=delegate;
	}
	
	public Object invoke(Object proxy, Method method) throws Exception {
		Object result=null;
		System.out.println("我是代理人黄蓉，开始代理");
		method.invoke(delegate);
		System.out.println("我是代理人黄蓉，代理完毕");
		return result;
	}
}

（13）接着再改一下测试客户端（TestDynamicProxy.java）。

package dynamicProxy;
public class TestDynamicProxy {
	public static void main(String[] args)throws Exception {
	Subject sub1=new RealSubject();
	
	LogHandler hander=new LogHandler(sub1);
	Subject sub2= (Subject)Proxy.newProxyInstance(Subject.class,hander);

	LogHandler2 hander2=new LogHandler2(sub2);
	Subject sub3=(Subject)Proxy.newProxyInstance(Subject.class,hander2);
sub3.print();
	}
}

输出结果：

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

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

被代理的人郭襄

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

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

从结果可以看出，实现了多重代理。

推荐文章：

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

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

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

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