Spring的AOP想必大家都是比较清楚的,从spring 3.x版本出现之后,AOP的概念更加清晰,使用也更加方便。我看过很多书,讲解spring的aop,里面都有太多的概念,看到最后,还是不懂,有些云里雾里的,但是在使用了这么长时间以来,我觉得有些书上讲的太过繁琐了,或者说一下讲的太深入,太抽象让人难以理解。下面我会尽自己的可能让大家弄懂什么是AOP,并解释一个实际当中的应用实例,让大家真正理解AOP的灵活,有什么错误的地方欢迎大家私信(评论)我。
AOP中有几个重要的概念,但是我认为只要弄懂两个概念,就能明白AOP的基本原理。下面我分别阐述一下这两个概念并结合实例。
1.Advice
Advice在国内有很多的翻译,我喜欢把它称作“增强”,顾名思义它的作用,就是把已有代码的功能增强,值得注意的是,增强可以对类增强,可以对方法增强,而spring目前只提供方法级的增强。分别是前置增强,后置增强,环绕增强以及引介增强,除了引介增强(不常用)以外我分别以一个小的实例帮大家理解这些增强。
前置增强:
在spring中提供一个接口MethodBeforeAdive,它继承了Advice,提供前置增强标准,我如果想实现在某个方法前的增强,可以实现该接口,下面我提供一个小的实例帮大家理解。比如我们在开发当中经常要记录接口的调用日志,什么时间哪个接口别调用了,理论上讲这些日志可以用同一段代码实现,我有一个类A,包含两个方法,doValidate和doBusiness,一个为了做校验,一个为了做业务,两个方法都要记录调用日志,我们的代码实现可以如下:
public class TestBoke {
public static class A{
public void doValidate(){
System.out.println("A do validate");
}
public void doBusiness(){
System.out.println("A do business");
}
}
public static class MyBeforeAdvice implements MethodBeforeAdvice{
@Override
public void before(Method method, Object[] args, Object target)
throws Throwable {
String className = target.getClass().getSimpleName();
String methodName = method.getName();
Date date = new Date(System.currentTimeMillis());
System.out.println("类 "+className +" 方法 "+methodName+ " 调用日期:"+date);
}
}
public static void main(String[] args) {
A target = new A();
MyBeforeAdvice beforeAdive = new MyBeforeAdvice();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.setProxyTargetClass(true);
proxyFactory.addAdvice(beforeAdive);
A targetProxy = (A)proxyFactory.getProxy();
targetProxy.doValidate();
targetProxy.doBusiness();
}
}
可以看出,在doValidate,和doBusiness方法调用前,均记录了相应的调用日志,这样前置增强就讲解完了,那有人要问了,如果要将方法的返回值也记录下来,该怎么办,在方法前增强是不能够获取方法的返回值的,是的你猜对了,我们可以使用后置增强。下面继续讲解后置增强。
后置增强:
在spring中提供一个后置增强的接口AfterReturningAdvice,它提供后置增强的标准,如果我们想要实现后置增强,那么需要实现该接口,下面我们就上面的例子做一个修改增加一个后置增强,输出每个方法的返回值。代码如下:
public class TestBoke {
public static class A{
public String doValidate(){
System.out.println("A do validate");
return "doValidateReturnValue";
}
public String doBusiness(){
System.out.println("A do business");
return "doBusinessReturnValue";
}
}
public static class MyBeforeAdvice implements MethodBeforeAdvice{
@Override
public void before(Method method, Object[] args, Object target)
throws Throwable {
String className = target.getClass().getSimpleName();
String methodName = method.getName();
Date date = new Date(System.currentTimeMillis());
System.out.println("类 "+className +" 方法 "+methodName+ " 调用日期:"+date);
}
}
public static class MyAfterAdivce implements AfterReturningAdvice{
@Override
public void afterReturning(Object returnValue, Method method, Object[] args,
Object target) throws Throwable {
System.out.println("方法 "+method.getName() +" 返回值为:"+returnValue);
}
}
public static void main(String[] args) {
A target = new A();
MyBeforeAdvice beforeAdive = new MyBeforeAdvice();
MyAfterAdivce afterAdvice = new MyAfterAdivce();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.setProxyTargetClass(true);
proxyFactory.addAdvice(0,beforeAdive);
proxyFactory.addAdvice(1, afterAdvice);
A targetProxy = (A)proxyFactory.getProxy();
targetProxy.doValidate();
System.out.println();
targetProxy.doBusiness();
}
}
这时有人还有疑问,如果要记录一个方法的运行时间,前置方法与后置方法又不能通信,怎么记录方法的运行时间呢,你可能猜到我的思路了,这时就该用到环绕增强了。
环绕增强:
spring中虽然有环绕增强的概念,但是并没有自己实现环绕增强的接口,而是引用AOP联盟推出的环绕增强接口,一会代码中你会发现,环绕增强的命名,参数列,以及很多地方,都是和spring的advice风格不同的,AOP联盟定义环绕增强的接口是MethodInterceptor,是不是奇怪为什么不叫methedAdvice而叫MethodInterceptor,方法拦截器,这里先卖个关子,下面贴出代码你就全明白了,下面还是在上面的代码基础上,增加统计方法运行时间的环绕增强,代码如下:
public class TestBoke {
public static class A{
public String doValidate() throws InterruptedException{
System.out.println("A do validate");
Thread.sleep(100);
return "doValidateReturnValue";
}
public String doBusiness() throws InterruptedException{
System.out.println("A do business");
Thread.sleep(200);
return "doBusinessReturnValue";
}
}
public static class MyBeforeAdvice implements MethodBeforeAdvice{
@Override
public void before(Method method, Object[] args, Object target)
throws Throwable {
String className = target.getClass().getSimpleName();
String methodName = method.getName();
Date date = new Date(System.currentTimeMillis());
System.out.println("类 "+className +" 方法 "+methodName+ " 调用日期:"+date);
}
}
public static class MyAfterAdivce implements AfterReturningAdvice{
@Override
public void afterReturning(Object returnValue, Method method, Object[] args,
Object target) throws Throwable {
System.out.println("方法 "+method.getName() +" 返回值为:"+returnValue);
}
}
public static class MyMethodInterceptor implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = invocation.proceed();
long endTime = System.currentTimeMillis();
long duringTime = endTime - startTime;
System.out.println("方法 "+invocation.getMethod().getName() + " 运行时间为 "+duringTime +" 毫秒");
return result;
}
}
public static void main(String[] args) throws InterruptedException {
A target = new A();
MyBeforeAdvice beforeAdive = new MyBeforeAdvice();
MyAfterAdivce afterAdvice = new MyAfterAdivce();
MyMethodInterceptor methodInterceptor = new MyMethodInterceptor();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.setProxyTargetClass(true);
proxyFactory.addAdvice(0, methodInterceptor);
proxyFactory.addAdvice(1, afterAdvice);
proxyFactory.addAdvice(2,beforeAdive);
A targetProxy = (A)proxyFactory.getProxy();
targetProxy.doValidate();
System.out.println();
targetProxy.doBusiness();
}
}
如上代码,我增加了环绕增强MyMethodInterceptor,并且为了使结果更加明显,我再A的两个方法中各自sleep了一段时间,为了使方法运行时间变长,通过看代码大家应该知道为什么叫做interceptor了吧,因为该方法想要进行,需要调用invocation的preceed方法才可以执行,所以环绕增强是可以控制目标方法执行与否的,所以将其命名为方法拦截器就更为贴切一些,下面是运行结果:
看到这个运行结果,大家应该彻底理解了增强(advice)到底是干什么的了吧,当然可能有更加细心的人会问,增强是不是和AOP的经典实例声明式事务相比还差些什么啊,因为增强理解后,我们可以认为事务的代码应该是在增强内实现的,但是怎么实现,部分类的部分方法有事务增强,其他则不需要呢,那么这个就是我要讲述的第二个重要的概念,pointCut切入点。
2.pointCut
第二个重要的概念,就是切入点(pointCut),它可以与增强结合,可以定义你的增强,对哪些类的那些方法生效,这样AOP的概念才能完整,实现灵活增强已有代码,当然spring中有很多类型的切入点,但是由于篇幅与时间的原因我不能一一写出实现代码,请大家谅解,下面我仅对增强与切入点的联合使用给出一个实例,该实例不是详尽介绍pointCut,而是帮助大家进一步了解,切入点的重要性与作用。
在给出代码之前,需要补充一点,在AOP中,增强和切入点合并起来称为切面,这虽然是一个新的概念,但是我认为这不应该是理解AOP的障碍,只要理解了增强和切入点的概念,那么切面就是两个概念的联合使用,实例代码还是延续上面的实例,因为dovalidate方法不是那么重要,所以不需要对dovalidate增强,只对doBusiness增强,这里我们用一个增强和切入点结合的实例,NameMatchMethodPointcutAdvisor 这个是spring中提供的切面,该切入点,主要定义匹配方法名的切点,意思就是这个前面可以把增强对应到匹配的所有方法上面,下面给出代码:
Thread.sleep(200);
return "doBusinessReturnValue";
}
}
public static class MyBeforeAdvice implements MethodBeforeAdvice{
@Override
public void before(Method method, Object[] args, Object target)
throws Throwable {
String className = target.getClass().getSimpleName();
String methodName = method.getName();
Date date = new Date(System.currentTimeMillis());
System.out.println("类 "+className +" 方法 "+methodName+ " 调用日期:"+date);
}
}
public static class MyAfterAdivce implements AfterReturningAdvice{
@Override
public void afterReturning(Object returnValue, Method method, Object[] args,
Object target) throws Throwable {
System.out.println("方法 "+method.getName() +" 返回值为:"+returnValue);
}
}
public static class MyMethodInterceptor implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = invocation.proceed();
long endTime = System.currentTimeMillis();
long duringTime = endTime - startTime;
System.out.println("方法 "+invocation.getMethod().getName() + " 运行时间为 "+duringTime +" 毫秒");
return result;
}
}
public static void main(String[] args) throws InterruptedException {
A target = new A();
MyBeforeAdvice beforeAdive = new MyBeforeAdvice();
NameMatchMethodPointcutAdvisor beforeMethodadvisor = new NameMatchMethodPointcutAdvisor();
beforeMethodadvisor.setAdvice(beforeAdive);
beforeMethodadvisor.addMethodName("doBusiness");
MyAfterAdivce afterAdvice = new MyAfterAdivce();
NameMatchMethodPointcutAdvisor afterMethodAdvisor = new NameMatchMethodPointcutAdvisor();
afterMethodAdvisor.setAdvice(afterAdvice);
afterMethodAdvisor.addMethodName("doBusiness");
MyMethodInterceptor methodInterceptor = new MyMethodInterceptor();
NameMatchMethodPointcutAdvisor methodInterceptorAdvisor = new NameMatchMethodPointcutAdvisor();
methodInterceptorAdvisor.setAdvice(methodInterceptor);
methodInterceptorAdvisor.addMethodName("doBusiness");
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.setProxyTargetClass(true);
proxyFactory.addAdvisor(0, methodInterceptorAdvisor);
proxyFactory.addAdvisor(1, afterMethodAdvisor);
proxyFactory.addAdvisor(2, beforeMethodadvisor);
// proxyFactory.addAdvice(0, methodInterceptor);
// proxyFactory.addAdvice(1, afterAdvice);
// proxyFactory.addAdvice(2,beforeAdive);
A targetProxy = (A)proxyFactory.getProxy();
targetProxy.doValidate();
System.out.println();
targetProxy.doBusiness();
}
}
好了,虽然是一个简单的实例,但是却阐明了AOP的概念与作用,希望大家已经理解了AOP,需要补充一点的是,我们使用的ProxyFactory,对应的FactoryBean是ProxyFactoryBean,通过该FactoryBean可以将,生成代理、切面植入、增强植入、植入顺序维护在配置文件当中,为了代码演示简单,我没有使用FactoryBean,如果使用ProxyFactoryBean,对比声明式事务和FactoryBean的配置,你可以发现其实都是一样的,只不过用的切点类型可能不同,增强不同等等,文章就到这里了,祝大家学习愉快!