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

1 . JDK动态代理美的缺陷

        JDK的Proxy已经设计得很优雅，真正的美始终带有一点缺陷，仅支持对interface代理。那些动态生成的代理类都继承了Proxy类(参考《五》中最后输出结果中通过反射工具反射出的自动生成的代理类$Proxy0的代码)。因为那些生成的代理已经拥有一个父类，而Java的单继承机制使得代理类无法实现对类的动态代理（不能再继承任何一个类，但可以实现接口）。

        所以，JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，这里，将介绍另外一种针对没有实现接口的类的动态代理。原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类或者类里面final修饰的方法进行代理。 

1.1类的动态代理：

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

1．被代理类

2．处理器接口

3．自定义的处理器（实现处理器接口）

4．生成成代理类的类

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

 

1.2 类的动态代理的实现

(1)建一个cglibProxy包，所有程序都放在该包下）。

(2)建一个被代理类（RealSubject.java）。

package cglibProxy;
//被代理类
public class RealSubject {
	public void print() {
		System.out.println("被代理的人郭襄");
	}
}

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

package cglibProxy;
import java.lang.reflect.Method;
public interface InvocationHandler {
	public Object invoke(Object proxy, Method method)throws Exception;
}

(4)建一个用户自定义的处理器，需要实现上面的处理接口，在invoke（）方法里写上被代理类的方法调用前后要进行的动作。这个  invoke （）方法我们不用直接调用，是让将来自动生成的代理类去调用的。

package cglibProxy;
import java.lang.reflect.*;

public class LogHandler implements InvocationHandler{
	private Object delegate;
	//绑定要代理的对象
	public Object bind(Object delegate)throws Exception{
		this.delegate=delegate;
		//这里的传进去的参数相对《二》中已经由Subject.class改成delegate.getClass()
		//传进去是一个类的类对象，不再是接口的类对象
		return Proxy.newProxyInstance(delegate.getClass(),this);
	}
	//invoke()方法是被自动生成的代理类调用，不用我们直接调用
	public Object invoke(Object proxy, Method method) throws Exception {
		
		Object result=null;
		System.out.println("我是代理人郭靖，开始代理");
		//把被代理类对象传进去，通过反射技术调用被代理类的方法，
		result=method.invoke(delegate);
		System.out.println("我是代理人郭靖，代理完毕");
		return result;
	}
}

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

package cglibProxy; 
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; 

//生成代理主题角色的类
public class Proxy {
	/**
	*
	*@paramsubjec传进被代理的类
	*@paramInvocationHandler代理对象的操作接口
	*@return代理类实例
	*/	
public static Object newProxyInstance(Class subjec,InvocationHandler h)
throws Exception{
	Object obj=null;
//换行的转义符
	String br ="\r\n";
	//得到要代理的类里面所有的方法数组
//原来是  Method[] ms=subjec.getMethods();
    Method[] ms=subjec.getDeclaredMethods();  
//存储用反射制造出来的要代理的类里面的方法
    String methodString =""; 

for(Method m:ms){
//如果要代理的接口有多个方法，要把下面的 "methodString=" 改成 "methodString+="
//methodString=只适用于抽象接口只有1个方法，methodString+=适用于抽象接口有1个或1个以上方法
	methodString+= 
	"  public void  "+m.getName()+"(){"+br+
	"     try{ "+ br +
	//不可以去掉这句
	" 	   Method md="+subjec.getSimpleName()+".class.getMethod(\""+m.getName()+"\");"+br+
	"       h.invoke(this,md);"+br+
	"       }catch (Exception e){ "+ br+    
"           e.printStackTrace();" + br +    
"       }" + br +   
"   }";   
}   
	String src="package cglibProxy;"+br+   
			"import java.lang.reflect.Method;"+br+
	"public class $Proxy extends "+subjec.getName()+"{"+br+ //implements变成extends
	" private cglibProxy.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\\cglibProxy\\$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("cglibProxy.$Proxy");
     Constructor ctr=c.getConstructor(InvocationHandler.class);
//生成代理类的实例，传进处理器对象，用于给代理类调用invoke()方法
     obj=(Object) ctr.newInstance(h);
	return obj;//返回代理类实例
}
}

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

(6)编写测试客户端（TestDynamicProxy.java）。

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

输出结果：

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

被代理的人郭襄

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

      从结果可以看出，成功自动生成了代理类$Proxy.java文件，并成功实现了代理的效果。

package cglibProxy;
import java.lang.reflect.Method;
public class $Proxy extends cglibProxy.RealSubject{
private cglibProxy.InvocationHandler h;
public $Proxy(InvocationHandler h) {
super();
this.h = h;
   }

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

(7)以上分析可以看到，类的动态代理的实现和《二》的实现大同小异，只不过代理类由实现抽象接口变成继承了被代理类，成为它的子类覆盖它的方法。这种形式的动态代理不能生成由final修饰的类。如果代理的类的方法有参数可参考《四》中的实现进行改进。

 

 推荐文章：

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

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

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

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

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

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