Spring AOP之增强介绍

最新推荐文章于 2023-11-27 14:24:50 发布
最新推荐文章于 2023-11-27 14:24:50 发布
阅读量1k 收藏 5
点赞数 1
分类专栏： Java 文章标签： aop aspectj 增强
课程概要：
  • Spring AOP的基本概念
  • Spring AOP的增强类型
  • Spring AOP的前置增强
  • Spring AOP的后置增强
  • Spring AOP的环绕增强
  • Spring AOP的异常抛出增强
  • Spring AOP的引介增强
一.Spring AOP 增强 的基本概念
Spring当中的专业术语-advice，翻译成中文就是增强的意思。
所谓增强，其实就是向各个程序内部注入一些逻辑代码从而增强原有程序的功能。
二.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类型的实现类，如下图所示：



其中：
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接口， ThrowsAdvic e接口并没有定义任何的方法，他只是一个标志接口。
在运行期，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配置文件方式，建议在以后开发中使用后者，这样可以避免代码的耦合度，方便后期维护。

注意需要使用AspectJ需要引入一些jar包:

aopalliance.jar

aspectjrt.jar

aspectjtools.jar

aspectjweaver.jar

org.aspectj.matcher.jar

可以根据需要引入上面的部分包，不一定全部需要引入，然后就可以编译通过了，

如果还缺其他的包，可以百度查，然后下载下来就可以了。

资源下载地址:http://download.csdn.net/download/a1317338022/10130277


a1317338022
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习（二十五）Spring AOP之增强介绍
wangxin1248的博客
06-22 1万+
课程概要： Spring AOP的基本概念Spring AOP的增强类型Spring AOP的前置增强Spring AOP的后置增强Spring AOP的环绕增强Spring AOP的异常抛出增强Spring AOP的引介增强 一.Spring AOP增强的基本概念 Spring当中的专业术语-advice，翻译成中文就是增强的意思。 所谓增强，其实就是向各个程序内部注入一些逻辑代
Spring AOP之3种增强方式简单示例
wl_Honest的博客
07-03 679
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。从《Spring实战（第4版）》图书中扒了一张图：从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。想象下面的场景，开发中在多个模块间有某段重复的代码，我们通常是怎么处理的？显然，没有人会靠“复制粘贴”吧。在传统的面向过程编程中，我们也会
Spring AOP五种增强
qq_43234235的博客
07-01 1089
概念： AOP，面向切面编程，就是当你已经完成，或者更加注意一些核心功能的时候。需要使用的编程过程，这个使用，你会发现，一个核心的业务，是由一个核心功能，和若干个额外服务类型的功能，统一组成的，比如数据验证，再比如日志的记录。 其实在场景中，我们的核心功能是针对数据库的操作，可能是增删过程。而服务类功能，比如记录日志，或者输入内容的验证过程。其实不是非有不可。没有这个功能，核心功能也能正常执行。 这个时候，我们就要考虑一个问题，这些必要或者非必要的额外功能，是不是要写在你的核心代码过程当中啊? 我们现在，将
AOP增强详解
u012068294的专栏
09-21 583
增强是AOP的核心部分之一，它包含逻辑代码和方位，增强就是一重最简单的切面。 增强的类型： 前置增强 后置增强 环绕增强 异常抛出增强 引介增强 package com.smart.advice; public interface Waiter { //接口 void greetTo(String name); void serveTo(String name); }...
Spring AOP的五种增强处理
qq_51649461的博客
08-22 3807
一、基于注解的Spring AOP的五种增强处理 1. 前置增强处 //定义增强处理 /** * 1、定义前置增强处理 * @Before注解表示该方法是一个前置增强处理 在目标方法执行之前调用 * 属性value：定义该增强处理切入的位置（切入点） * execution(* com.cxsw.spring.service.impl.UserServiceImpl.*(..)) * UserServiceImpl实现类下的所有方法 * execution(* c
Spring学习日记：Aop五种增强+注解开发Ioc/Aop
m0_74777020的博客
08-22 1984
自述：此篇文章主要记录了本人学习Spring的日常，在CSDN上发表，一是为了方便今后回顾，二也是想分享给有需要的人。
线程池中使用spring aop事务增强
08-25
主要介绍了线程池中使用spring aop事务增强,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring AOP之增强
03-01
NULL 博文链接：https://lucky520.iteye.com/blog/258107
spring AOP的Around增强实现方法分析
08-25
主要介绍了spring AOP的Around增强实现方法,结合实例形式分析了spring面向切面AOP的Around增强具体步骤与相关操作方法,需要的朋友可以参考下
SpringAOP使用介绍，从前世到今生
02-24
SpringAOP发展到现在出现的全部3种配置方式。由于Spring强大的向后兼容性，实际代码中往往会出现很多配置混杂的情况，而且居然还能工作，本文希望帮助大家理清楚这些知识。我们先来把它们的概念和关系说说清楚。AOP...
spring AOP的After增强实现方法实例分析
08-25
主要介绍了spring AOP的After增强实现方法,结合实例形式分析了spring面向切面AOP的After增强实现步骤与相关操作技巧,需要的朋友可以参考下
SpringAOP的5种增强类型应用讲解
m0_73875939的博客
01-03 449
spring框架中为我们提供的增强包括针对切面的增强和针对切入点的增强，对一个方法的增强底层使用的是动态代理，所以在学习springAop增强之前大家有必要先了解一下动态代理相关内容； 本文分别采用继承接口和使用配置文件来实现增强。 1.前置增强：org.springframework.aop.BeforeAdvice是前置增强顶层接口，因为Spring只持方法的增强，其子接口MethodBeforeAdvice是目前可用的前置增强。表示在目标方法执行前实施增强。 2.后置增强：org.springfr
spring增强
最新发布
weixin_52030010的博客
11-27 364
After在目标方法执行结束后执行的逻辑，无论是否发生异常都会执行。
AOP常用的增强方式
m0_73804996的博客
01-04 296
AOP常用的增强方式
Spring 之Aop增强
m0_73889578的博客
02-22 180
遍历后置处理器，并应用postProcessBeforeInstantiation()，其中与Aop相关的核心处理器是AnnotationAwareAspectJAutoProxyCreator 这个类实现了SmartInstantiationAwareBeanPostProcessor，他会找到所有Bean中那些事切面类，原理就是判断Bean上面是否带有@Aspect注解，而Aspect本身并不能由Spring容器管理，所以还需要给切面类接上@Component注解。2.创建Aop增强类。
AOP常用的几种增强方式，各自的特点
Pursuit_li的博客
12-06 1312
1. 前置增强，在核心功能之前执行的额外功能 2. 后置增强，在核心功能之后执行的额外功能 3.异常增强，在核心功能发生异常时执行的额外功能，先捕获，后抛出 4. 环绕增强，在核心功能之前以及之后执行的额外功能
Spring AOP 增强介绍
实践是最好的方法
08-22 3187
目录 一、前置增强 二、ProxyFactory介绍 三、后置增强和异常增强 四、环绕增强 五、引介增强 advance，通知，在Spring中叫增强也许更加合理。所谓增强，其实就是向各个程序内部注入一些代码从而增强原有程序的功能。 Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强还包括在方法的哪一点加入横切代码的方位信息，所以增强即包括横切逻辑，又包含部...
AOP常用的几种增强方式
lC518800的博客
02-23 861
AOP常用的几种增强方式
AOP常用的几种增强方式和各自特点
m0_73878473的博客
12-11 766
AOP常用的几种增强方式和各自特点
spring aop注解增强
10-17
Spring AOP注解增强可以通过在方法上添加注解来实现，常用的注解有： 1. @Before：在目标方法执行前执行增强逻辑。 2. @After：在目标方法执行后执行增强逻辑。 3. @AfterReturning：在目标方法返回结果后执行增强...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值