码迷，mamicode.com
首页 > 编程语言 > 详细

Spring AOP四种实现方式Demo详解与相关知识探究

时间：2018-05-06 21:20:13      阅读：255      评论：0      收藏：0      [点我收藏+]

标签：地址   unit   xmla   实现   默认   htm   正式   detail   逻辑   

一、前言

在网络上看到一篇博客Spring实现AOP的4种方式，博主写的很通俗易懂，但排版实在抓狂，对于我这么一个对排版、代码格式有强迫症的人来说，实在是不能忍受~~~~(>_<)~~~~。

我亲手实现了一遍，重新整理，加上了一些不易关注到的细节、漏掉的知识，以及自己对AOP的一些理解，写成这篇博客。

 

二、AOP相关概念

（1）AOP是什么？AOP与拦截器的区别？

太抽象的不说，如果你知道Struts2的拦截器，拦截器就是应用的AOP的思想，它用于拦截Action以进行一些预处理或结果处理。而Spring的AOP是一种更通用的模式，可以拦截Spring管理的Bean，功能更强大，适用范围也更广，它是通过动态代理与反射机制实现的。（更详细的解释可参看博客 http://blog.csdn.net/zhangliangzi/article/details/51648032 ）

（2）使用AOP需要的一些概念。

1.通知(Advice)

通知定义了在切入点代码执行时间点附近需要做的工作。

Spring支持五种类型的通知：

Before(前)  org.apringframework.aop.MethodBeforeAdvice
After-returning(返回后) org.springframework.aop.AfterReturningAdvice
After-throwing(抛出后) org.springframework.aop.ThrowsAdvice
Arround(周围) org.aopaliance.intercept.MethodInterceptor
Introduction(引入) org.springframework.aop.IntroductionInterceptor

2.连接点(Joinpoint)

程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法调用时、异常抛出时、方法返回后等等。

3.切入点(Pointcut)

通知定义了切面要发生的“故事”，连接点定义了“故事”发生的时机，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正则表达式来指定。

4.切面(Aspect)

通知、连接点、切入点共同组成了切面：时间、地点和要发生的“故事”。

5.引入(Introduction)

引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）。

6.目标(Target)

即被通知的对象，如果没有AOP，那么通知的逻辑就要写在目标对象中，有了AOP之后它可以只关注自己要做的事，解耦合！

7.代理(proxy)

应用通知的对象，详细内容参见设计模式里面的动态代理模式。

8.织入(Weaving)

把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:

(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器；

(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码；

(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术。

 

三、使用AOP的几种方式

1.经典的基于代理的AOP

2.@AspectJ注解驱动的切面

3.纯POJO切面

4.注入式AspectJ切面

 

四、Demo详解

在讲Demo之前，先把项目结构贴一下，我用的的一般的Java Project+Maven进行测试，用Web Project的小区别一会会说到。有一点很重要，jar依赖必须导入正确，我在测试过程中，很多bug都是因为依赖问题引起的，这里也贴一下。

包结构：

技术分享图片

pom.xml：

 

[html] view plain copy
 
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.   
  5.     <groupId>com.springAOP</groupId>  
  6.     <artifactId>springAOP</artifactId>  
  7.     <version>0.0.1-SNAPSHOT</version>  
  8.     <packaging>jar</packaging>  
  9.   
  10.     <name>springAOP</name>  
  11.     <url>http://maven.apache.org</url>  
  12.   
  13.     <properties>  
  14.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  15.         <org.springframework.version>3.0.5.RELEASE</org.springframework.version>  
  16.     </properties>  
  17.   
  18.   
  19.     <dependencies>  
  20.   
  21.         <dependency>  
  22.             <groupId>junit</groupId>  
  23.             <artifactId>junit</artifactId>  
  24.             <version>3.8.1</version>  
  25.             <scope>test</scope>  
  26.         </dependency>  
  27.   
  28.         <!-- Spring -->  
  29.         <dependency>  
  30.             <groupId>org.springframework</groupId>  
  31.             <artifactId>spring-context</artifactId>  
  32.             <version>${org.springframework.version}</version>  
  33.         </dependency>  
  34.   
  35.         <!-- Spring AOP + AspectJ -->  
  36.         <dependency>  
  37.             <groupId>org.springframework</groupId>  
  38.             <artifactId>spring-aop</artifactId>  
  39.             <version>${org.springframework.version}</version>  
  40.         </dependency>  
  41.           
  42.         <dependency>  
  43.             <groupId>org.aspectj</groupId>  
  44.             <artifactId>aspectjrt</artifactId>  
  45.             <version>1.8.9</version>  
  46.         </dependency>  
  47.           
  48.         <dependency>  
  49.             <groupId>org.aspectj</groupId>  
  50.             <artifactId>aspectjweaver</artifactId>  
  51.             <version>1.8.9</version>  
  52.         </dependency>  
  53.       
  54.     </dependencies>  
  55. </project>  


下面开始正式的讲解：

1、经典的基于代理的AOP实现，以一个睡觉的例子实现。

（1）可睡觉的接口，任何可以睡觉的人或机器都可以实现它。

 

[java] view plain copy
 
  1. public interface Sleepable {  
  2.     public void sleep();  
  3. }  

（2）接口实现类，“Me”可以睡觉，“Me”就实现可以睡觉的接口。

 

[java] view plain copy
 
  1. public class Me implements Sleepable{  
  2.     public void sleep() {  
  3.         System.out.println("\n睡觉！不休息哪里有力气学习！\n");  
  4.     }  
  5. }  

（3）Me关注于睡觉的逻辑，但是睡觉需要其他功能辅助，比如睡前脱衣服，起床脱衣服，这里开始就需要AOP替“Me”完成！解耦！首先需要一个SleepHelper类。因为一个是切入点前执行、一个是切入点之后执行，所以实现对应接口。

 

[java] view plain copy
 
  1. public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {  
  2.   
  3.     public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {  
  4.         System.out.println("睡觉前要脱衣服！");  
  5.     }  
  6.   
  7.     public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {  
  8.         System.out.println("起床后要穿衣服！");  
  9.     }  
  10.   
  11. }  

（4）最关键的来了，Spring核心配置文件application.xml配置AOP。

 

[html] view plain copy
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3. <span style="white-space:pre">    </span>xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4. <span style="white-space:pre">    </span>xmlns:aop="http://www.springframework.org/schema/aop"  
  5. <span style="white-space:pre">    </span>xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6. <span style="white-space:pre">    </span>http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7. <span style="white-space:pre">    </span>http://www.springframework.org/schema/aop  
  8. <span style="white-space:pre">    </span>http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">  
  9.      
  10.    <!-- 定义被代理者 -->  
  11.    <bean id="me" class="com.springAOP.bean.Me"></bean>  
  12.      
  13.    <!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->  
  14.    <bean id="sleepHelper" class="com.springAOP.bean.SleepHelper"></bean>  
  15.      
  16.    <!-- 定义切入点位置 -->  
  17.    <bean id="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">  
  18.         <property name="pattern" value=".*sleep"></property>  
  19.    </bean>  
  20.      
  21.    <!-- 使切入点与通知相关联，完成切面配置 -->  
  22.    <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">  
  23.         <property name="advice" ref="sleepHelper"></property>         
  24.         <property name="pointcut" ref="sleepPointcut"></property>  
  25.    </bean>  
  26.      
  27.    <!-- 设置代理 -->  
  28.    <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">  
  29.         <!-- 代理的对象，有睡觉能力 -->  
  30.         <property name="target" ref="me"></property>  
  31.         <!-- 使用切面 -->  
  32.         <property name="interceptorNames" value="sleepHelperAdvisor"></property>  
  33.         <!-- 代理接口，睡觉接口 -->  
  34.         <property name="proxyInterfaces" value="com.springAOP.bean.Sleepable"></property>   
  35.    </bean>  
  36.       
  37. </beans>  

其中：

<beans>是Spring的配置标签，beans里面几个重要的属性：

xmlns：

是默认的xml文档解析格式，即spring的beans。地址是http://www.springframework.org/schema/beans；通过设置这个属性，所有在beans里面声明的属性，可以直接通过<>来使用，比如<bean>等等。一个XML文件，只能声明一个默认的语义解析的规范。例如上面的xml中就只有beans一个是默认的，其他的都需要通过特定的标签来使用，比如aop，它自己有很多的属性，如果要使用，前面就必须加上aop:xxx才可以。类似的，如果默认的xmlns配置的是aop相关的语义解析规范，那么在xml中就可以直接写config这种标签了。

xmlns:xsi：

是xml需要遵守的规范，通过URL可以看到，是w3的统一规范，后面通过xsi:schemaLocation来定位所有的解析文件。

xmlns:aop：

这个是重点，是我们这里需要使用到的一些语义规范，与面向切面AOP相关。

xmlns:tx:

Spring中与事务相关的配置内容。

（5）测试类，Test，其中，通过AOP代理的方式执行Me的sleep()方法，会把执行前、执行后的操作执行，实现了AOP的效果！

 

[java] view plain copy
 
  1. public class Test {  
  2.     public static void main(String[] args){  
  3.         @SuppressWarnings("resource")  
  4.         //如果是web项目，则使用注释的代码加载配置文件，这里是一般的Java项目，所以使用下面的方式  
  5.         //ApplicationContext appCtx = new ClassPathXmlApplicationContext("application.xml");  
  6.         ApplicationContext appCtx = new FileSystemXmlApplicationContext("application.xml");  
  7.         Sleepable me = (Sleepable)appCtx.getBean("proxy");  
  8.         me.sleep();  
  9.     }  
  10. }  

执行结果：

技术分享图片

（6）通过org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator简化配置。

将配置文件中设置代理的代码去掉，加上：

 

[html] view plain copy
 
  1. <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>  

然后，在Test中，直接获取me对象，执行sleep方法，就可以实现同样的功能！

通过自动匹配，切面会自动匹配符合切入点的bean，会被自动代理，实现功能！

2、更简单的方式，通过AspectJ提供的注解实现AOP。

（1）同样的例子，修改后的SleepHelper：

 

[java] view plain copy
 
  1. @Aspect  
  2. public class SleepHelper{  
  3.   
  4.     public SleepHelper(){  
  5.           
  6.     }  
  7.       
  8.     @Pointcut("execution(* *.sleep())")  
  9.     public void sleeppoint(){}  
  10.       
  11.     @Before("sleeppoint()")  
  12.     public void beforeSleep(){  
  13.         System.out.println("睡觉前要脱衣服!");  
  14.     }  
  15.       
  16.     @AfterReturning("sleeppoint()")  
  17.     public void afterSleep(){  
  18.         System.out.println("睡醒了要穿衣服！");  
  19.     }  
  20.       
  21. }  

（2）在方法中，可以加上JoinPoint参数以进行相关操作，如：

 

[java] view plain copy
 
  1. //当抛出异常时被调用  
  2.     public void doThrowing(JoinPoint point, Throwable ex)  
  3.     {  
  4.         System.out.println("doThrowing::method "  
  5.                 + point.getTarget().getClass().getName() + "."  
  6.                 + point.getSignature().getName() + " throw exception");  
  7.         System.out.println(ex.getMessage());  
  8.     }  

（3）然后修改配置为：

 

[html] view plain copy
 
  1.        <aop:aspectj-autoproxy />  
  2. <!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->  
  3. <bean id="sleepHelper" class="com.springAOP.bean.SleepHelper"></bean>  
  4. <!-- 定义被代理者 -->  
  5. <bean id="me" class="com.springAOP.bean.Me"></bean>  


（4）最后测试，一样的结果！

[java] view plain copy
 
  1. public class Test {  
  2.     public static void main(String[] args){  
  3.         @SuppressWarnings("resource")  
  4.         //如果是web项目，则使用注释的代码加载配置文件，这里是一般的Java项目，所以使用下面的方式  
  5.         //ApplicationContext appCtx = new ClassPathXmlApplicationContext("application.xml");  
  6.         ApplicationContext appCtx = new FileSystemXmlApplicationContext("application.xml");  
  7.         Sleepable me = (Sleepable)appCtx.getBean("me");  
  8.         me.sleep();  
  9.     }  
  10. }  


3、使用Spring来定义纯粹的POJO切面（名字很绕口，其实就是纯粹通过<aop:fonfig>标签配置，也是一种比较简单的方式）。

（1）修改后的SleepHelper类，很正常的类，所以这种方式的优点就是在代码中不体现任何AOP相关配置，纯粹使用xml配置。

 

[java] view plain copy
 
  1. public class SleepHelper{  
  2.   
  3.     public void beforeSleep(){  
  4.         System.out.println("睡觉前要脱衣服!");  
  5.     }  
  6.       
  7.     public void afterSleep(){  
  8.         System.out.println("睡醒了要穿衣服！");  
  9.     }  
  10.      
  11. }  

（2）配置文件：

 

[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:aop="http://www.springframework.org/schema/aop"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  6.     http://www.springframework.org/schema/aop  
  7.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">  
  8.   
  9.     <!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->  
  10.     <bean id="sleepHelper" class="com.springAOP.bean.SleepHelper"></bean>  
  11.     <!-- 定义被代理者 -->  
  12.     <bean id="me" class="com.springAOP.bean.Me"></bean>  
  13.   
  14.     <aop:config>  
  15.         <aop:aspect ref="sleepHelper">  
  16.             <aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))" />  
  17.             <aop:after method="afterSleep" pointcut="execution(* *.sleep(..))" />  
  18.         </aop:aspect>  
  19.     </aop:config>  
  20.   
  21. </beans>  

（3）配置的另一种写法

 

[html] view plain copy
 
  1. <aop:config>  
  2.     <aop:aspect ref="sleepHelper">  
  3.            <aop:pointcut id="sleepHelpers" expression="execution(* *.sleep(..))" />  
  4.            <aop:before pointcut-ref="sleepHelpers" method="beforeSleep" />  
  5.            <aop:after pointcut-ref="sleepHelpers" method="afterSleep" />            
  6.        </aop:aspect>  
  7. </aop:config>  

 

五、AOP实现原理

学东西还是要深入进去的，推荐一篇网评还不错的博文，http://www.cnblogs.com/xiaolovewei/p/7919763.html

 

转载：https://blog.csdn.net/zhangliangzi/article/details/52334964

Spring AOP四种实现方式Demo详解与相关知识探究

标签：地址   unit   xmla   实现   默认   htm   正式   detail   逻辑   

原文地址：https://www.cnblogs.com/xiaolovewei/p/8999512.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！