您的位置: 首页  >  文章  >  Spring学习----------Spring AOP之增强介绍

Spring学习----------Spring AOP之增强介绍

分类: 文章 • 2024-04-15 08:43:11
一.Spring AOP增强的基本概念
Spring当中的专业术语-advice，翻译成中文就是增强的意思。
所谓增强，其实就是向各个程序内部注入一些逻辑代码从而增强原有程序的功能。
二.Spring AOP的增强类型
首先先了解一下增强接口的继承关系
Spring学习----------Spring AOP之增强介绍
如上图所示：
其中带Spring标志的是Spring定义的扩展增强接口
其中带aopalliance标志的是AOP联盟所定义的接口

按照增加在目标类方法连接点的位置可以将增强划分为以下五类：
  • 前置增强   (org.springframework.aop.BeforeAdvice)   表示在目标方法执行前来实施增强
  • 后置增强   (org.springframework.aop.AfterReturningAdvice)   表示在目标方法执行后来实施增强
  • 环绕增强   (org.aopalliance.intercept.MethodInterceptor)   表示在目标方法执行前后同时实施增强
  • 异常抛出增强   (org.springframework.aop.ThrowsAdvice)   表示在目标方法抛出异常后来实施增强
  • 引介增强   (org.springframework.aop.introductioninterceptor)   表示在目标类中添加一些新的方法和属性
其中，引介增强是一种特殊的增强。他可以在目标类中添加属性和方法，通过拦截定义一个接口，让目标代理实现这个接口。他的连接点是类级别的，而前面的几种则是方法级别的。
其中，环绕增强是AOP联盟定义的接口，其他四种增强接口则是Spring定义的接口。

其实，AOP增强很简单：
通过实现这些增强接口，在实现这些接口的方法当中定义横切逻辑，然后通过配置Spring的配置文件就可以完成将增强织入到目标方法当中了。

补充：增强既包含了横切逻辑同时又包含了部分连接点信息。

三.Spring AOP的前置增强

1.通过代码实现增强
在Spring当中，仅支持方法级别的增强，利用MethodBeforeAdvice实现，表示在目标方法执行前实施增强。
示例演示：
对服务生的服务用语进行强制规范。我们假设服务生只需要干两件事情：1.欢迎顾客 2.对顾客提供服务
那么我们创建的示例代码的主要步骤如下：
  1. 创建业务接口类：Waiter.java
  2. 创建业务实现类：NativeWaiter.java
  3. 创建业务增强类：GreetingBeforeAdvice.java
  4. 创建增强测试类：TestAdvice.java
接下来我们分别在IDEA中创建相应的类。
服务生接口Waiter.java
[java] view plain copy
  1. public interface Waiter {  
  2.     void greetTo(String name);  
  3.     void serverTo(String name);  
  4. }  
服务生实现类NativeWaiter.java
[java] view plain copy
  1. public class NativeWaiter implements Waiter{  
  2.     public void greetTo(String name) {  
  3.         System.out.println("greet to"+name+"...");  
  4.     }  
  5.   
  6.     public void serverTo(String name) {  
  7.         System.out.println("serving"+name+"...");  
  8.     }  
  9. }  
服务生业务增强类GreetingBeforeAdvice.java
[java] view plain copy
  1. public class GreetingBeforeAdvice implements MethodBeforeAdvice{  
  2.     /** 
  3.     * 前置增强方法 
  4.     * 当该方法发生异常时，将阻止目标方法的执行 
  5.     * @param method 目标类方法 
  6.     * @param objects 目标类方法入参 
  7.     * @param o 目标类对象实例 
  8.     * @throws Throwable 
  9.     */  
  10.     public void before(Method method, Object[] objects, Object o) throws Throwable {  
  11.         String clientName=(String)objects[0];  
  12.         System.out.println("How Are You! mr."+clientName);  
  13.     }  
  14. }  

增强测试类TestBeforeAdvice.java
[java] view plain copy
  1. public class TestBeforeAdvice {  
  2.     public static void main(String[] args){  
  3.         //创建目标对象  
  4.         Waiter target=new NativeWaiter();  
  5.         //创建增强类对象  
  6.         BeforeAdvice advice=new GreetingBeforeAdvice();  
  7.         //创建代理工厂对象  
  8.         ProxyFactory factory=new ProxyFactory();  
  9.         //设置代理类  
  10.         factory.setTarget(target);  
  11.         //添加增强类  
  12.         factory.addAdvice(advice);  
  13.         //获取代理类  
  14.         Waiter proxy=(Waiter)factory.getProxy();  
  15.         //调用目标类方法  
  16.         proxy.greetTo("icarus");  
  17.         proxy.serverTo("icarus");  
  18.   
  19.     }  
  20. }  
程序运行结果：
How Are You! mr.icarus
greet toicarus...
How Are You! mr.icarus
servingicarus...

2.ProxyFactory介绍
其实ProxyFactory代理技术就是利用jdk代理或者cglib代理的技术，将增强应用到目标类当中。
Spring定义的AOP Proxy类具有两个final类型的实现类，如下图所示：

Spring学习----------Spring AOP之增强介绍

其中：
Cglib2AopProxy是使用cglib代理技术来创建代理
JdkDynamicAopProxy是使用jdk代理技术来创建代理
那么使用JDK代理来实现上面的代码则为：
[java] view plain copy
  1. //创建代理工厂对象  
  2. ProxyFactory factory=new ProxyFactory();  
  3. //设置代理接口  
  4. factory.setInterfaces(target.getClass().getInterfaces());  
  5. //设置代理类  
  6. factory.setTarget(target);  
  7. //设置增强类  
  8. factory.addAdvice(advice);  

使用CGLib代理则为：
[java] view plain copy
  1. ProxyFactory factory=new ProxyFactory();  
  2. //设置代理接口  
  3. factory.setInterfaces(target.getClass().getInterfaces());  
  4. //启用cglib代理方式  
  5. factory.setOptimize(true);  
  6. //设置代理类  
  7. factory.setTarget(target);  
  8. //添加增强类  
  9. factory.addAdvice(advice);  

可以观察到，ProxyFactory通过addAdvice来增加一个增强。
用户可以使用该方法增加多个增强，通过增强形成一个增强链，他们的调用顺序和添加顺序是一致的
3.通过配置文件实现增强
我们也可以通过配置文件来实现Spring的前置增强，并且大多数情况下都是使用配置文件方式。
首先我们介绍下ProxyFactory Bean配置文件当中常用的属性：
  • target：我们需要代理的目标对象
  • proxyInterfaces：代理所要实现的接口，可以是多个接口
  • interceptorNames：需要织入的目标对象的Bean的列表（增强类的Bean列表），使用Bean的名称来指定。
  • singleton：确定返回的代理是不是单实例的，系统默认返回的是单实例的。
  • optimize：当值为true时，强制使用cglib代理。当是singleton的实例时我们推荐使用cglib代理，当是其他作用域的时候，推荐使用JDK的代理。原因是cglib创建代理速度比较慢，但是运行效率高。JDK代理则刚好相反。
  • proxyTargetClass：是否对类进行代理而不是对接口进行代理，当值为true的时候使用cglib代理

接下来我们使用配置文件对上面的示例代码进行配置：
[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.     <bean id="gerrtingBefore" class="cn.lovepi.chapter07.aop.advice.GreetingBeforeAdvice"/>  
  6.     <bean id="target" class="cn.lovepi.chapter07.aop.advice.NativeWaiter"/>  
  7.     <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"  
  8.           p:proxyInterfaces="cn.lovepi.chapter07.aop.advice.Waiter"  
  9.           p:interceptorNames="gerrtingBefore"  
  10.           p:target-ref="target"  
  11.           />  
  12.   
  13. </beans>  

接下来我们创建对应的测试文件
[java] view plain copy
  1. public class TestBeforeAdviceByXml {  
  2.     public static void main(String[] args){  
  3.         String path="src/conf/conf-advice.xml";  
  4.         ApplicationContext context=new FileSystemXmlApplicationContext(path);  
  5.         Waiter waiter=context.getBean("waiter",Waiter.class);  
  6.         waiter.greetTo("icarus");  
  7.         waiter.serverTo("icarus");  
  8.   
  9.     }  
  10. }  

可以看到输出结果为：
How Are You! mr.icarus
greet toicarus...
How Are You! mr.icarus
servingicarus...

和我们通过代码实现增强的结果相同

四.Spring AOP的后置增强
后置增强在目标方法调用后执行，例如上面的例子中，在服务生每次服务后，也需要向客人问候，可以通过后置增强来实施这一要求，步骤如下：
  1. 创建业务接口类：Waiter.java
  2. 创建业务实现类：NativeWaiter.java
  3. 创建业务增强类：GreetingAfterAdvice.java
  4. 创建配置文件：conf-advice.xml
  5. 创建增强测试类：TestAdvice.java
接下来我们在IDEA中创建相应的代码：
我们继续使用上面的例子，由于Waiter.java和NativeWaiter.java已经创建好了
我们只需创建GreetingAfterAdvice.java
[java] view plain copy
  1. public class GreetingAfterAdvice  implements AfterReturningAdvice{  
  2.     /** 
  3.     * 后置增强代码实现 
  4.     * @param o 代理返回对象 
  5.     * @param method 目标对象方法 
  6.     * @param objects 目标对象方法参数 
  7.     * @param o1 目标对象 
  8.     * @throws Throwable 
  9.     */  
  10.     public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {  
  11.         System.out.println("please enjoy youself!");  
  12.     }  
  13. }  

接下来我们修改对应的配置文件
首先得将后者增强类作为bean配置到文件当中
<bean id="gerrtingAfter" class="cn.lovepi.chapter07.aop.advice.GreetingAfterAdvice"/>
接下来得在ProxyFactory Bean当中添加织入的bean
p:interceptorNames="gerrtingBefore,gerrtingAfter"
完整的配置文件如下：
[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.     <bean id="gerrtingBefore" class="cn.lovepi.chapter07.aop.advice.GreetingBeforeAdvice"/>  
  6.     <bean id="gerrtingAfter" class="cn.lovepi.chapter07.aop.advice.GreetingAfterAdvice"/>  
  7.     <bean id="target" class="cn.lovepi.chapter07.aop.advice.NativeWaiter"/>  
  8.     <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"  
  9.           p:proxyInterfaces="cn.lovepi.chapter07.aop.advice.Waiter"  
  10.           p:interceptorNames="gerrtingBefore,gerrtingAfter"  
  11.           p:target-ref="target"  
  12.           />  
  13.   
  14. </beans>  

测试文件和上面的保持不变，运行测试类，测试结果为：
How Are You! mr.icarus
greet toicarus...
please enjoy youself!
How Are You! mr.icarus
servingicarus...
please enjoy youself!

五.Spring AOP的环绕增强
环绕增强允许在目标类方法调用前后织入横切逻辑，它综合实现了前置，后置增强两者的功能，下面是我们用环绕增强同时实现上面的我们的示例。步骤如下：
  1. 创建业务接口类：Waiter.java
  2. 创建业务实现类：NativeWaiter.java
  3. 创建业务增强类：GreetingInterceptor.java
  4. 创建配置文件：conf-advice.xml
  5. 创建增强测试类：TestAdvice.java
接下来我们在IDEA中来实现。
首先创建GreetingInterceptor.java
[java] view plain copy
  1. public class GreetingInterceptor implements MethodInterceptor{  
  2.     /** 
  3.     * 业务逻辑实现类 
  4.     * @param methodInvocation 封装了目标方法和入参数组以及目标方法所带的实例对象 
  5.     * @return 代理对象 
  6.     * @throws Throwable 
  7.     */  
  8.     public Object invoke(MethodInvocation methodInvocation) throws Throwable {  
  9.         //获取目标方法的入参  
  10.         Object[] args=methodInvocation.getArguments();  
  11.         //获取方法名称  
  12.         String clickName= (String) args[0];  
  13.         System.out.println("GreetingInterceptor：How are you!");  
  14.         //利用反射机制来调用目标方法  
  15.         Object object=methodInvocation.proceed();  
  16.         System.out.println("GreetingInterceptor: please enjoy youself!");  
  17.         return object;  
  18.     }  
  19. }  

接下来在配置文件中对其进行配置：
[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.     <bean id="gerrtingBefore" class="cn.lovepi.chapter07.aop.advice.GreetingBeforeAdvice"/>  
  6.     <bean id="gerrtingAfter" class="cn.lovepi.chapter07.aop.advice.GreetingAfterAdvice"/>  
  7.     <bean id="gerrtingAround" class="cn.lovepi.chapter07.aop.advice.GreetingInterceptor"/>  
  8.     <bean id="target" class="cn.lovepi.chapter07.aop.advice.NativeWaiter"/>  
  9.     <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"  
  10.           p:proxyInterfaces="cn.lovepi.chapter07.aop.advice.Waiter"  
  11.           p:interceptorNames="gerrtingBefore,gerrtingAfter,gerrtingAround"  
  12.           p:target-ref="target"  
  13.           />  
  14.   
  15. </beans>  


启动测试类，观察打印结果：
How Are You! mr.icarus
GreetingInterceptor：How are you!
greet toicarus...
GreetingInterceptor: please enjoy youself!
please enjoy youself!
How Are You! mr.icarus
GreetingInterceptor：How are you!
servingicarus...
GreetingInterceptor: please enjoy youself!
please enjoy youself!

可以看到，我们成功在示例中实现了前置增强，后者增强以及环绕增强。

六.Spring AOP的异常抛出增强
异常抛出增强表示在目标方法抛出异常后实施增强，最适合的场景是事务管理，比如当参与事事务的方法抛出异常后需要回滚事务。
异常抛出增强类需要实现ThrowsAdvice接口，ThrowsAdvice接口并没有定义任何的方法，他只是一个标志接口。
在运行期，Spring采用反射的机制来进行判断。我们必须采用以下的形式来定义异常抛出的方法
public void afterThrowing(Method method,Object[] args,Object target,Throwable t)
其中：
方法名必须为afterThrowing，方法入参中前三个入参是可选的，即要么同时存在，要么都没有
最后一个入参是Throwable及其子类，必须得有。
也可以在异常增强类中定义多个方法，Spring会自动选择匹配的方法来进行调用。
在类的继承树上，两个类的距离越近，则两个类的相似度越高
那么当方法抛出异常时，会优先选取异常入参和抛出的异常相似度最高的afterThrowing方法。

接下来我们创建示例来演示一下，步骤如下：
  1. 创建业务实现类：ForumService.java
  2. 创建业务增强类：TransactionManager.java
  3. 创建配置文件：conf-advice.xml
  4. 创建增强测试类：TestAdvice.java
接下来我们在IDEA上分别创建对应的代码：
首先，我们创建业务逻辑类ForumService
[java] view plain copy
  1. public class ForumService {  
  2.     public void removeForum(){  
  3.         //进行相应的数据库操作，但这里只为演示抛出异常  
  4.         throw new RuntimeException("removeForum:Exception...");  
  5.     }  
  6.     public void updateForum(){  
  7.         //进行相应的数据库操作，但这里只为演示抛出异常  
  8.         throw new RuntimeException("updateForum:Exception...");  
  9.     }  
  10. }  

接下来我们创建增强类TransactionManager
[java] view plain copy
  1. public class TransactionManager implements ThrowsAdvice{  
  2.     /** 
  3.     * 捕获异常并打印异常名称 
  4.     * @param method 目标对象对应方法 
  5.     * @param args 方法入参 
  6.     * @param target 目标对象 
  7.     * @param ex 运行方法所捕获的异常 
  8.     * @throws Throwable 
  9.     */  
  10.     public void afterThrowing(Method method,Object[] args,Object target,Exception ex)throws Throwable{  
  11.         System.out.println("method:"+method.getName());  
  12.         System.out.println("抛出异常："+ex.getMessage());  
  13.         System.out.println("成功回滚事务");  
  14.     }  
  15. }  
接下来我们编写对应的配置文件
[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.     <bean id="forumServiceTarget" class="cn.lovepi.chapter07.aop.advice.ForumService"/>  
  6.     <bean id="transactionManager" class="cn.lovepi.chapter07.aop.advice.TransactionManager"/>  
  7.     <bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean"  
  8.           p:proxyTargetClass="true"  
  9.           p:target-ref="forumServiceTarget"  
  10.           p:interceptorNames="transactionManager"  
  11.           />  
  12. </beans>  
创建相应的测试类进行测试
[java] view plain copy
  1. public static void testThrowAdvice(){  
  2.     String path="src/conf/conf-advice.xml";  
  3.     ApplicationContext context=new FileSystemXmlApplicationContext(path);  
  4.     ForumService forumService=context.getBean("forumService",ForumService.class);  
  5.     try {  
  6.         forumService.removeForum();  
  7.     }catch (Exception e){}  
  8.     try {  
  9.         forumService.updateForum();  
  10.     }catch (Exception e){}  
  11. }  
运行结果为：
method:removeForum
抛出异常：removeForum:Exception...
成功回滚事务
method:updateForum
抛出异常：updateForum:Exception...
成功回滚事务


七.Spring AOP的引介增强
引介增强是一种比较特殊的增强类型，他不是在目标方法周围织入增强，而是为目标创建新的方法和属性，所以他的连接点是类级别的而非方法级别的。通过引介增强我们可以为目标类添加一个接口的实现即原来目标类未实现某个接口,那么通过引介增强可以为目标类创建实现某接口的代理。

接下来我们创建一个示例来演示下，步骤如下：
  • 创建接口类：Monitorable.java
  • 创建业务类：PerformanceMonitor.java
  • 创建增强类：ControllablePerformanceMonitor.java
  • 创建配置文件：conf-advice-introduce.xml
  • 创建增强测试类：TestIntroduce.java

接下来我们在IDEA上分别创建对应的代码：
首先创建性能监视接口Monitorable

[java] view plain copy
  1. public interface Monitorable {  
  2.     void setMonitorActive(boolean active);  
  3. }  
创建测试接口Testable
[java] view plain copy
  1. public interface Testable {  
  2.   void test();  
  3. }  
接下来创建业务类
[java] view plain copy
  1. public class PerformanceMonitor {  
  2.   private static ThreadLocal<MethodPerformace> performaceRecord = new ThreadLocal<MethodPerformace>();  
  3.   public static void begin(String method) {  
  4.       System.out.println("begin monitor...");  
  5.       MethodPerformace mp = performaceRecord.get();  
  6.       if(mp == null){  
  7.         mp = new MethodPerformace(method);  
  8.         performaceRecord.set(mp);  
  9.       }else{  
  10.           mp.reset(method);  
  11.       }  
  12.   }  
  13.   public static void end() {  
  14.       System.out.println("end monitor...");  
  15.       MethodPerformace mp = performaceRecord.get();  
  16.       mp.printPerformace();  
  17.   }  
  18. }  

接下来创建增强类ControllablePerformanceMonitor
[java] view plain copy
  1. public class ControllablePerformaceMonitor  
  2.       extends  
  3.         DelegatingIntroductionInterceptor implements Monitorable, Testable {  
  4.   private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>();  
  5.   public void setMonitorActive(boolean active) {  
  6.       MonitorStatusMap.set(active);  
  7.   }  
  8.   public Object invoke(MethodInvocation mi) throws Throwable {  
  9.       Object obj = null;  
  10.       if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) {  
  11.         PerformanceMonitor.begin(mi.getClass().getName() + "."  
  12.               + mi.getMethod().getName());  
  13.         obj = super.invoke(mi);  
  14.         PerformanceMonitor.end();  
  15.       } else {  
  16.         obj = super.invoke(mi);  
  17.       }  
  18.       return obj;  
  19.   }  
  20.   public void test() {  
  21.       // TODO Auto-generated method stub  
  22.       System.out.println("dd");  
  23.   }  
  24. }  
接下来创建所要增强的方法类
[java] view plain copy
  1. public class ForumService {  
  2.   
  3.   public void removeTopic(int topicId) {  
  4.       System.out.println("模拟删除Topic记录:"+topicId);  
  5.       try {  
  6.         Thread.currentThread().sleep(20);  
  7.       } catch (Exception e) {  
  8.         throw new RuntimeException(e);  
  9.       }  
  10.   
  11.   }  
  12.   
  13.   public void removeForum(int forumId) {  
  14.       System.out.println("模拟删除Forum记录:"+forumId);  
  15.       try {  
  16.         Thread.currentThread().sleep(40);  
  17.       } catch (Exception e) {  
  18.         throw new RuntimeException(e);  
  19.       }  
  20.   }  
  21. }  
  22.   
  23. public class MethodPerformace {  
  24.   private long begin;  
  25.   private long end;  
  26.   private String serviceMethod;  
  27.     public MethodPerformace(String serviceMethod){  
  28.       reset(serviceMethod);  
  29.     }  
  30.     public void printPerformace(){  
  31.         end = System.currentTimeMillis();  
  32.         long elapse = end - begin;  
  33.         System.out.println(serviceMethod+"花费"+elapse+"毫秒。");  
  34.     }  
  35.     public void reset(String serviceMethod){  
  36.       this.serviceMethod = serviceMethod;  
  37.       this.begin = System.currentTimeMillis();  
  38.     }  
  39. }  
创建配置文件来将所设置的代码组合起来：
[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.   xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
  6.   
  7.   <bean id="pmonitor" class="cn.lovepi.chapter07.aop.intorduce.ControllablePerformaceMonitor" />  
  8.   <bean id="forumServiceTarget" class="cn.lovepi.chapter07.aop.intorduce.ForumService" />  
  9.   <bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean"  
  10.       p:interfaces="cn.lovepi.chapter07.aop.intorduce.Monitorable"  
  11.       p:target-ref="forumServiceTarget"  
  12.       p:interceptorNames="pmonitor" p:proxyTargetClass="true" />  
  13.   
  14. </beans>  
创建对应的测试类
[java] view plain copy
  1. public class TestIntroduce {  
  2.   public static void main(String[] args) {  
  3.       testBeforeAdviceByCode();  
  4.   }  
  5.   
  6.   private static void testBeforeAdviceByCode() {  
  7.       String configPath = "src/conf/conf-advice-introduce.xml";  
  8.       ApplicationContext ctx = new FileSystemXmlApplicationContext(configPath);  
  9.         ForumService forumService = (ForumService)ctx.getBean("forumService");  
  10.         forumService.removeForum(10);  
  11.         forumService.removeTopic(1022);  
  12.         Monitorable moniterable = (Monitorable)forumService;  
  13.         moniterable.setMonitorActive(true);  
  14.         forumService.removeForum(10);  
  15.         forumService.removeTopic(1022);  
  16.   }  
  17.   
  18. }  
程序运行结果为：

模拟删除Forum记录:10
模拟删除Topic记录:1022
begin monitor...
模拟删除Forum记录:10
end monitor...
org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.removeForum花费40毫秒。
begin monitor...
模拟删除Topic记录:1022
end monitor...
org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.removeTopic花费20毫秒。


总结：
增强其实就是对原有的方法或类动态增加功能，可为方法执行前后以及所抛出的异常进行逻辑处理。实现增强的方式有两种：代码方式和XML配置文件方式，建议在以后开发中使用后者，这样可以避免代码的耦合度，方便后期维护。

相关推荐