约定编程
本节我们先抛开spring AOP的概念,看一下约定编程的实例。
首先定义一个简单的接口,HelloService
public interface HelloService {
public void sayHello(String name);
}
这个接口定义了一个sayHello方法,参数是name。接着我们写一个实现类,HelloServiceImpl
public class HelloServiceImpl implements HelloService {
@Override
public void sayHello(String name) {
if(name==null || name.trim() ==""){
throw new RuntimeException("name is null");
}
System.out.println("hello "+name);
}
}
这里面代码非常简单,方法sayHello判断name是否为空,为空抛异常告诉调用者参数为空,不为空则对名字说hello。这样一个服务就写好了。接下来我们定义一个拦截器,Interceptor
public interface Interceptor {
//事前方法
public boolean before();
//事后方法
public void after();
/**
* 取代原有事件方法
* invocation --回调参数,通过它的proceed方法,回调原有事件
*/
public Object around(Invocation invocation) throws InvocationTargetException,IllegalAccessException;
//事后返回方法。事件没有发生异常执行
public void afterReturning();
//事后异常方法。当事件发生异常后执行
public void afterThrowing();
//是否使用around方法取代原有方法
boolean useAround();
}
around方法中参数Invocation用于回调原有的方法,代码如下:
public class Invocation {
private Object[] params;
private Method method;
private Object target;
public Invocation(Object target,Method method,Object[] params){
this.target=target;
this.method=method;
this.params=params;
}
//反射方法
public Object proceed()throws InvocationTargetException,IllegalAccessException{
return method.invoke(target,params);
}
****getter and setter*****
}
里面的proceed方法会以反射的形式去调用原有的方法。接着我们实现拦截器接口
public class MyInterceptor implements Interceptor {
@Override
public boolean before() {
System.out.println("before.....");
return true;
}
@Override
public void after() {
System.out.println("after.....");
}
@Override
public Object around(Invocation invocation) throws InvocationTargetException, IllegalAccessException {
System.out.println("around before....");
Object obj=invocation.proceed();
System.out.println("around before....");
return obj;
}
@Override
public void afterReturning() {
System.out.println("afterReturning....");
}
@Override
public void afterThrowing() {
System.out.println("afterThrowing.......");
}
@Override
public boolean useAround() {
return true;
}
}
约定流程
当调用proxy代理对象方法后(后面会讲获取代理对象proxy,这里主要看流程的定义,我们先假设拿到了代理对象,意味者对方法拦截成功),我们定义流程如下。
(1)使用proxy调用方法时会先执行拦截器的before方法。
(2)如果拦截器的useAround方法返回true,则执行拦截器的around方法,而不调用target原对象对应的方法,但around方法的参数invoaiton对象存在一个proceed方法,它可以调用target对象对应的方法;如果useAround方法返回false,则直接调用target对象的事件方法。
(3)无论怎么样,在完成之前的事情后,都会执行拦截器的after方法。
(4)在执行around方法或者回调target的事件方法时,可能发生异常,也可能不发生异常。如果发生异常,就执行拦截器的afterThrowing方法,否则就执行afterReturning方法
ProxyBean的实现
将服务类和拦截方法织入对应的流程,是ProxyBean要实现的功能。首先要理解动态代理模式,例如,当你需要采访一名儿童时,首先需要经过他父母的同意,在一些问题上父母会替他回答,而另外一些问题,父母觉得不太适合这个小孩会替孩子拒绝掉,显然父母就是这名儿童的代理(proxy)。通过代理可以增强或者控制对真实对象(target)的访问。
JDK中提供了类Proxy的静态方法newPorxyInstance来生成一个代理对象。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
它有三个参数:
ClassLoader loader: 类加载器
Class<?>[] interfaces:绑定的接口,也就是把代理对象绑定到哪些接口下,可以时多个。
InvocationHandler h:绑定代理对象逻辑实现
这里InvocationHandler 时一个接口,它定义了一个invoke方法,这个方法就是实现代理对象的逻辑实现的,其源码如下:
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
这里通过目标对象(target)、方法(method)和参数(args)就可以反射方法运行了。为了将服务类和拦截方法织入对应的流程,并且返回代理对象。这里编写了一个ProxyBean类
public class ProxyBean implements InvocationHandler {
private Object target = null;
private Interceptor interceptor = null;
/**
* 绑定代理对象
* @param target 被代理对象
* @param interceptor 拦截器
* @return 代理对象
*/
public static Object getProxyBean(Object target, Interceptor interceptor) {
ProxyBean proxyBean = new ProxyBean();
//保存被代理对象
proxyBean.target = target;
//保存拦截器
proxyBean.interceptor = interceptor;
//生成代理对象
Object proxy =Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),proxyBean);
return proxy;
}
/**
* 处理代理对象方法逻辑
* @param proxy 代理对象
* @param method 当前方法
* @param args 运行参数
* @return 方法调用结果
* @throws Throwable 异常
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//异常标识
boolean exceptionFlag = false;
Invocation invocation = new Invocation(target,method,args);
Object retObj = null;
try {
if(this.interceptor.before()){
retObj = this.interceptor.around(invocation);
}else{
retObj = method.invoke(target,args);
}
} catch (Exception e) {
exceptionFlag =true;
}
this.interceptor.after();
if(exceptionFlag){
this.interceptor.afterThrowing();
}else{
this.interceptor.afterReturning();
return retObj;
}
return null;
}
}
首先,这个ProxyBean实现了接口InvocationHandler,因此就可以定义invoke方法了。在getProxyBean方法中生成一个代理对象,并且创建了一个getProxyBean实例保存目标对象(target)和拦截器(interceptor),为后面的调用做好准备。其次,生成了一个代理对象,而这个代理对象挂在target实现的接口下,所以可以用target对象实现的接口对这个代理对象实现强制类型转换,并且将这个代理对象的逻辑挂在ProxyBean实例下,这样就完成了目标对象target和代理对象proxy的绑定。最后,将代理对象返回给调用者。
约定流程测试
public class TestProxy {
public static void main(String[] args) {
HelloService helloService =new HelloServiceImpl();
//按约定获取proxy
HelloService proxy = (HelloService) ProxyBean.getProxyBean(helloService,new MyInterceptor());
proxy.sayHello("张三");
System.out.println("###########name is null#########");
proxy.sayHello(null);
}
}
按照约定,这段代码打印信息:
before.....
around before....
hello 张三
around before....
after.....
afterReturning....
###########name is null#########
before.....
around before....
after.....
afterThrowing.......
总结
我们自己写了一个约定编程的例子,说明只要提供一定的约定规则,按照约定进行编程后,就可以把自己开发的代码织入约定的流程中。而实际开发中,我们只需要知道框架和你的约定便可以了。Spring Aop就是这么做的。它可以通过与我们约定,把对应的方法通过动态代理技术织入约定的流程中,这就是Spring Aop编程的本质。所以掌握Spring AOP的根据在于掌握其对我们的约定规则。