Spring 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