AOP技术是spring框架的一个重要特征。通过该特性能够在函数运行之前,之后,或者异常处理的时候执行我们需要的一些操作。
下面我们就是需要抛开AOP,Spring这样成型的框架不用,而仅仅使用java反射机制中的Proxy,InvocationHandler来实现类似Spring框架的拦截器的效果。
动态代理DynamicProxy
首先,在设计这个拦截器框架之前,我们需要明白java中动态代理是什么?我想如果早就清楚请直接跳过,如果需要了解,那我想你手边最好有一个javadoc的电子书。
Java.lang.reflect.Proxy是反射包的成员之一。具体说明请查javadoc。
用法就是比如有一个对象,我们需要在调用它提供的方法之前,干点别的什么,就不能直接调用它,而是生成一个它的代理,这个代理有这个对象所提供的所有接口方法,我们通过直接调用代理的这些方法,来实现:函数既能像原来对象的那样工作,又能在函数运行过程前后加入我们自己的处理。
这个类有个非常重要的函数用来实现某个类的代理:
1
Objectjava.lang.reflect.Proxy.newProxyInstance(ClassLoaderloader,
2Class<?>
[]interfaces,
3InvocationHandlerh)throwsIllegalArgumentException
参数有点迷惑人,解释下:
ClassLoader 是类加载器,这个参数用来定义代理类,一般使用原对象的即可,也可以为null用上下文解决。
Class<?>[] 接口数组,就是我们需要这个代理能够提供原来的类的什么函数。如果全部则直接class.getInterfaces()来解决.
InvocationHandler 调用处理器,这个就是如果你调用代理的方法,那么这个处理器就会被关联过来,处理调用这个函数的整个过程。这个接口只定义了一个方法:
1public
Objectinvoke(Objectproxy,Methodmethod,
2Object[]args)throwsThrowable;
参数中proxy就是你调用的代理,method指的是你调用的代理的那个方法,args是传给该方法的参数。
我们生成某个类的代理步骤,一般需要先考虑我们在调用这个类的函数的时候(之前,或者之后)如何处理某些事情,因此我们首先考虑的就是如何实现InvocationHandler这个接口。
让我们做一个实践,做这么一个调用处理器:任何使用此处理器的代理在调用它的任何方法的时候,都打印被代理的类的类名+“.”+方法名+”(“+参数+”,”+参数+...+”)”。
步骤1: 定义接口IUser
1package
com.cyh.proxy.sample;
2
3publicinterfaceIUser
{
4publicStringgetName();
5
6publicvoidsetName(Stringname);
7}
步骤2: 写IUser接口的实现类User
1package
com.cyh.proxy.sample.impl;
2
3import
com.cyh.proxy.sample.IUser;
4
5publicclassUserimplements
IUser{
6
Stringname;
7
8public
User(Stringname){
9this.name=
name;
10
}
11
12public
StringgetName(){
13return
name;
14
}
15
16publicvoid
setName(Stringname){
17this.name=
name;
18
}
19}
步骤3: 写TraceHandler实现调用处理器InvocationHandler,即在invoke()方法里我们要打印被代理的类的类名+“.”+方法名+”(“+参数+”,”+参数+...+”)”。
1package
com.cyh.proxy.sample.impl;
2
3import
java.lang.reflect.InvocationHandler;
4import
java.lang.reflect.Method;
5
6publicclassTraceHandlerimplements
InvocationHandler{
7private
Objecttarget;
8
9public
TraceHandler(Objecttarget){
10this.target=
target;
11
}
12
13public
Objectinvoke(Objectproxy,Methodmethod,Object[]args)
14throws
Throwable{
15
16//printimplicitargument
17
System.out.print(target.getClass().getName());
18//printmethodname
19System.out.print("."+method.getName()+"("
);
20//printexplicitarguments
21if(args!=null
){
22for(inti=0;i<args.length;i++
){
23
System.out.print(args[i]);
24if(i<args.length-1
){
25System.out.print(","
);
26
}
27
}
28
}
29System.out.println(")"
);
30
31returnmethod.invoke(this
.target,args);
32
}
33}
步骤4: 最后,让我们写测试类ProxyTest
1package
com.cyh.proxy.sample.test;
2
3import
java.lang.reflect.InvocationHandler;
4import
java.lang.reflect.Proxy;
5
6import
com.cyh.proxy.sample.IUser;
7import
com.cyh.proxy.sample.impl.TraceHandler;
8import
com.cyh.proxy.sample.impl.User;
9
10publicclass
ProxyTest{
11
Useruser;
12
13public
ProxyTest(){
14user=newUser("LaraCroft"
);
15
16ClassLoaderclassLoader=
user.getClass().getClassLoader();
17Class[]interfaces=
user.getClass().getInterfaces();
18InvocationHandlerhandler=new
TraceHandler(user);
19IUserproxy=
(IUser)Proxy.newProxyInstance(classLoader,interfaces,
20
handler);
21
22proxy.setName("DavidBeckham"
);
23
}
24
25publicstaticvoid
main(String[]args){
26new
ProxyTest();
27
}
28
29}
好了,所有代码写好了,运行一下,测试结果是:
com.cyh.proxy.impl.User.setName(David Beckham)
讲一下运行原理:
首先我们初始化了user对象,user.name = = “LaraCroft”;
然后创建了user对象的代理proxy。
注意这里:
Proxy.newProxyInstance()函数的返回值使用接口IUser转型的,你或许会想到
用User来做强制类型转换,但是会抛出下面的异常
Exception in thread "main" java.lang.ClassCastException: $Proxy0 cannot be cast to com.cyh.proxy.impl.User
因为:代理类是实现了User类的所有接口,但是它的类型是$Proxy0,不是User。
最后,我们调用代理的setName()方法:
proxy.setName("David Beckham");
代理在执行此方法的时候,就好触发调用处理器 TraceHandler,并执行 TraceHandler的invoke()方法,然后就会打印:
com.cyh.proxy.impl.User.setName(David Beckham)
拦截器框架的实现
好了,关于代理的知识我们讲完了,我们可以考虑如何实现这个拦截器的框架,所谓拦截器就是在函数的运行前后定制自己的处理行为,也就是通过实现InvocationHandler达到的。
设计思路
我们来理清一下思路,在使用一个拦截器的时候?什么是不变的,什么是变化的?
不变的:
每次都要创建代理
拦截的时间:函数执行之前,之后,异常处理的时候
变化的:
每次代理的对象不同
拦截器每次拦截到执行时的操作不同
好了,废话少说,看类图:
图中:
DynamicProxyFactory 和它的实现类,是一个工厂,用来创建代理
Interceptor 这个接口用来定义拦截器的拦截处理行为配合DynamicProxyInvocationHandler达到拦截效果
DynamicProxyInvocationHandler 调用处理器的实现,它有两个成员,一个是Object target指的是被代理的类,另一个是Interceptor interceptor就是在invoke()方法执行target的函数之前后,异常处理时,调用interceptor的实现来达到拦截,并处理的效果。
代码实现
步骤1: 定义接口DynamicProxyFactory
1package
com.cyh.proxy.interceptor;
2
3publicinterface
DynamicProxyFactory{
4/**
5
*生成动态代理,并且在调用代理执行函数的时候使用拦截器
6
*
7*@param
clazz
8
*需要实现的接口
9*@param
target
10
*实现此接口的类
11*@param
interceptor
12
*拦截器
13*@return
14*/
15public<T>
TcreateProxy(Ttarget,Interceptorinterceptor);
16}
步骤2: 定义接口Interceptor
1package
com.cyh.proxy.interceptor;
2
3import
java.lang.reflect.Method;
4
5publicinterface
Interceptor{
6publicvoid
before(Methodmethod,Object[]args);
7
8publicvoid
after(Methodmethod,Object[]args);
9
10publicvoid
afterThrowing(Methodmethod,Object[]args,Throwablethrowable);
11
12publicvoid
afterFinally(Methodmethod,Object[]args);
13
}
14
步骤3: 实现接口DynamicProxyFactory
1package
com.cyh.proxy.interceptor.impl;
2
3import
java.lang.reflect.InvocationHandler;
4import
java.lang.reflect.Proxy;
5
6import
com.cyh.proxy.interceptor.DynamicProxyFactory;
7import
com.cyh.proxy.interceptor.Interceptor;
8
9publicclassDynamicProxyFactoryImplimplements
DynamicProxyFactory{
10/**
11
*生成动态代理,并且在调用代理执行函数的时候使用拦截器
12
*
13*@param
target
14
*需要代理的实例
15*@param
interceptor
16
*拦截器实现,就是我们希望代理类执行函数的前后,
17
*抛出异常,finally的时候去做写什么
18*/
19
@Override
20@SuppressWarnings("unchecked"
)
21public<T>
TcreateProxy(Ttarget,Interceptorinterceptor){
22//当前对象的类加载器
23ClassLoaderclassLoader=
target.getClass().getClassLoader();
24//获取此对象实现的所有接口
25Class<?>[]interfaces=
target.getClass().getInterfaces();
26//利用DynamicProxyInvocationHandler类来实现InvocationHandler
27InvocationHandlerhandler=new
DynamicProxyInvocationHandler(target,
28
interceptor);
29
30return
(T)Proxy.newProxyInstance(classLoader,interfaces,handler);
31
}
32}
步骤4: 实现调用处理器
1package
com.cyh.proxy.interceptor.impl;
2
3import
java.lang.reflect.InvocationHandler;
4import
java.lang.reflect.Method;
5
6import
com.cyh.proxy.interceptor.Interceptor;
7
8/**
9
*动态代理的调用处理器
10
*
11*@author
chen.yinghua
12*/
13publicclassDynamicProxyInvocationHandlerimplements
InvocationHandler{
14private
Objecttarget;
15private
Interceptorinterceptor;
16
17/**
18*@param
target
19
*需要代理的实例
20*@param
interceptor
21
*拦截器
22*/
23public
DynamicProxyInvocationHandler(Objecttarget,
24
Interceptorinterceptor){
25this.target=
target;
26this.interceptor=
interceptor;
27
}
28
29/**
30*@param
proxy
31
*所生成的代理对象
32*@param
method
33
*调用的方法示例
34
*@argsargs参数数组
35
*@Override
36*/
37public
Objectinvoke(Objectproxy,Methodmethod,Object[]args)
38throws
Throwable{
39Objectresult=null
;
40
41try
{
42//在执行method之前调用interceptor去做什么事
43this
.interceptor.before(method,args);
44//在这里我们调用原始实例的method
45result=method.invoke(this
.target,args);
46//在执行method之后调用interceptor去做什么事
47this
.interceptor.after(method,args);
48}catch
(Throwablethrowable){
49//在发生异常之后调用interceptor去做什么事
50this
.interceptor.afterThrowing(method,args,throwable);
51throw
throwable;
52}finally
{
53//在finally之后调用interceptor去做什么事
54
interceptor.afterFinally(method,args);
55
}
56
57return
result;
58
}
59
60}
好了,目前为止,这个框架算完成了,怎么用呢?
接下来我们完成测试包。
完成测试
步骤1: 首先,给需要代理的类定义一个接口Service
1package
com.cyh.proxy.interceptor.test;
2
3publicinterface
Service{
4public
Stringgreet(Stringname);
5}
步骤2: 实现这个接口,编写类ServiceImpl
1package
com.cyh.proxy.interceptor.test;
2
3publicclassServiceImplimplements
Service{
4
@Override
5public
Stringgreet(Stringname){
6Stringresult="Hello,"+
name;
7
System.out.println(result);
8return
result;
9
}
10}
步骤3: 实现拦截器接口Interceptor,编写类InterceptorImpl
1package
com.cyh.proxy.interceptor.test;
2
3import
java.lang.reflect.Method;
4
5import
com.cyh.proxy.interceptor.Interceptor;
6
7publicclassInterceptorImplimplementsInterceptor
{
8@Override
9publicvoidafter(Methodmethod,Object[]args){
10System.out.println("afterinvokingmethod:"+method.getName());
11}
12
13@Override
14publicvoidafterFinally(Methodmethod,Object[]args){
15System.out.println("afterFinallyinvokingmethod:"+method.getName());
16}
17
18@Override
19publicvoidafterThrowing(Methodmethod,Object[]args,
20Throwablethrowable){
21System.out.println("afterThrowinginvokingmethod:"
22+method.getName());
23}
24
25@Override
26publicvoidbefore(Methodmethod,Object[]args){
27System.out.println("beforeinvokingmethod:"+method.getName());
28}
29}
步骤4:编写测试类TestDynamicProxy
1package
com.cyh.proxy.interceptor.test;
2
3import
com.cyh.proxy.interceptor.DynamicProxyFactory;
4import
com.cyh.proxy.interceptor.Interceptor;
5import
com.cyh.proxy.interceptor.impl.DynamicProxyFactoryImpl;
6
7publicclass
TestDynamicProxy{
8public
TestDynamicProxy(){
9DynamicProxyFactorydynamicProxyFactory=new
DynamicProxyFactoryImpl();
10Interceptorinterceptor=new
InterceptorImpl();
11Serviceservice=new
ServiceImpl();
12
13Serviceproxy=
dynamicProxyFactory.createProxy(service,interceptor);
14//
Serviceproxy=DefaultProxyFactory.createProxy(service,
15//interceptor);
16proxy.greet("iwindyforest"
);
17
}
18
19publicstaticvoid
main(String[]args){
20new
TestDynamicProxy();
21
}
22}
好了,整个测试包完成了,让我们运行下看看运行结果:
before invoking method: greet
Hello, iwindyforest
after invoking method: greet
afterFinally invoking method: greet
完善设计
现在,让我们回顾一下:接口DynamicProxyFactory,真的需要么?
它只是一个工厂,负责生产代理的,但是我们并没有过多的要求,因此可以说它的实现基本上是不变的。鉴于此,我们在使用createProxy()函数的时候,只需要一个静态方法就可以了,没有必要再初始化整个类,这样才比较方便么。
因此,我在com.cyh.proxy.interceptor.impl包里加了一个默认的工厂DefaultProxyFactory:
1package
com.cyh.proxy.interceptor.impl;
2
3import
java.lang.reflect.InvocationHandler;
4import
java.lang.reflect.Proxy;
5
6import
com.cyh.proxy.interceptor.Interceptor;
7
8publicclass
DefaultProxyFactory{
9@SuppressWarnings("unchecked"
)
10publicstatic<T>
TcreateProxy(Ttarget,Interceptorinterceptor){
11//当前对象的类加载器
12ClassLoaderclassLoader=
target.getClass().getClassLoader();
13//获取此对象实现的所有接口
14Class<?>[]interfaces=
target.getClass().getInterfaces();
15//利用DynamicProxyInvocationHandler类来实现InvocationHandler
16InvocationHandlerhandler=new
DynamicProxyInvocationHandler(target,
17
interceptor);
18
19return
(T)Proxy.newProxyInstance(classLoader,interfaces,handler);
20
}
21}