Java实现动态代理
Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：
（1）InvocationHandler：该接口中仅定义了一个方法
publicobjectinvoke(Objectobj,Methodmethod,Object[]args)
在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
（2）Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容protectedProxy(InvocationHandlerh)：构造函数，用于给内部的h赋值。
staticClassgetProxyClass(ClassLoaderloader,Class[]interfaces)
获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
staticObjectnewProxyInstance(ClassLoaderloader,Class[]interfaces,InvocationHandlerh)
返回代理类的一个实例，返回后的代理类可以当作被代理类使 用(可使用被代理类的在Subject接口中声明过的方法)
所谓DynamicProxy是这样一种class：它是在运行时生成的class，在生成它时你必须 提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把 该class的实例当作这些interface中的任何一个来用。当然，这个DynamicProxy其实 就是一个 Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它 接管实际的工作。
在使用动态代理类时，我们必须实现InvocationHandler接口：
参见程序Subject.java
参见程序RealSubject.java
参见程序DynamicSubject.java
参见程序Client.java
packagecom.langsin.dynamicproxy;
//抽象角色(之前是抽象类，此处应改为接口)：
publicinterfaceSubject
{
abstractpublicvoidrequest();
}
packagecom.langsin.dynamicproxy;
//具体角色
publicclassRealSubjectimplementsSubject
{
publicRealSubject()
{
}
publicvoidrequest()
{
System.out.println("Fromrealsubject.");
}
}
packagecom.langsin.dynamicproxy;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
//代理处理器
/**
*该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Objectobj)对其赋值；
*此外，在该类还实现了invoke方法，该方法中的method.invoke(sub,args);
*其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，
*args为执行被代理对象相应操作所需的参数。
*通过动态代理类，我们可以在调用之前或之后执行一些相关操作
*/
publicclassDynamicSubjectimplementsInvocationHandler
{
privateObjectsub;
publicDynamicSubject()
{
}
publicDynamicSubject(Objectobj)
{
sub=obj;
}
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable
{
System.out.println("beforecalling"+method);
method.invoke(sub,args);
System.out.println("aftercalling"+method);
returnnull;
}
}
packagecom.langsin.dynamicproxy;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Proxy;
//客户端
publicclassClient
{
staticpublicvoidmain(String[]args)throwsThrowable
{
RealSubjectrs=newRealSubject();//在这里指定被代理类
InvocationHandlerds=newDynamicSubject(rs);
Class<?>cls=rs.getClass();
//以下是一次性生成代理
Subjectsubject=(Subject)Proxy.newProxyInstance(
cls.getClassLoader(),cls.getInterfaces(),ds);
subject.request();
}
}
实例2：
packagecom.langsin.dynamicproxy;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
importjava.util.List;
importjava.util.Vector;
publicclassVectorProxyimplementsInvocationHandler
{
privateObjectproxyobj;
publicVectorProxy(Objectobj){
proxyobj=obj;
}
publicstaticObjectfactory(Objectobj){
Class<?>cls=obj.getClass();
returnProxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),newVectorProxy(obj));
}
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
System.out.println("beforecalling"+method);
if(args!=null){
for(inti=0;i<args.length;i++){
System.out.println(args[i]+"");
}
}
Objectobject=method.invoke(proxyobj,args);
System.out.println("aftercalling"+method);
returnobject;
}
@SuppressWarnings("unchecked")
publicstaticvoidmain(String[]args){
List<String>v=(List<String>)factory(newVector<String>(10));
v.add("New");
v.add("York");
System.out.println(v);
v.remove(0);
System.out.println(v);
}
}
实例3、
packagecom.langsin.dynamicproxy;
publicinterfaceFoo{
voiddoAction();
}
packagecom.langsin.dynamicproxy;
publicclassFooImplimplementsFoo{
publicFooImpl(){
}
publicvoiddoAction(){
System.out.println("inFooImp1.doAction()");
}
}
packagecom.langsin.dynamicproxy;
publicclassFooImpl2implementsFoo{
publicFooImpl2(){
}
publicvoiddoAction(){
System.out.println("inFooImp2.doAction()");
}
}
packagecom.langsin.dynamicproxy;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
publicclassCommonInvocationHandlerimplementsInvocationHandler{
//动态执行对象，需要回调的对象
privateObjecttarget;
//支持构造子注射
publicCommonInvocationHandler(){
}
//支持构造子注射
publicCommonInvocationHandler(Objecttarget){
setTarget(target);
}
/**
*
*采用setter方法注射
*
*@paramtarget
*
*/
publicvoidsetTarget(Objecttarget){
this.target=target;
}
/**
*
*调用proxy中指定的方法method，并传入参数列表args
*
*@paramproxy
* 代理类的类型，例如定义对应method的代理接口
*
*@parammethod
* 被代理的方法
*
*@paramargs
* 调用被代理方法的参数
*
*@return
*
*@throwsjava.lang.Throwable
*
*/
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
returnmethod.invoke(target,args);
}
}
packagecom.langsin.dynamicproxy;
importjava.lang.reflect.Proxy;
publicclassDemo{
publicstaticvoidmain(String[]args){
//1.通用的动态代理实现
CommonInvocationHandlerhandler=newCommonInvocationHandler();
Foof;
//2.接口实现1
handler.setTarget(newFooImpl());
//方法参数说明：代理类、代理类实现的接口列表、代理类的处理器
//关联代理类、代理类中接口方法、处理器，当代理类中接口方法被调用时，会自动分发到处理器的invoke方法
//如果代理类没有实现指定接口列表，会抛出非法参数异常
f=(Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(),
newClass[]{Foo.class},
handler);
f.doAction();
//3.接口实现2
handler.setTarget(newFooImpl2());
f=(Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(),
newClass[]{Foo.class},
handler);
f.doAction();
}
}
由于本人文采有限，所以大部分内容都是代码，还请大家谅解^_^