Spring核心AOP（面向切面编程）

1、AOP概念：

面向切面编程，指扩展功能不修改源代码，将功能代码从业务逻辑代码中分离出来。

       主要功能：日志记录，性能统计，安全控制，事务处理，异常处理等等。

       主要意图：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

2、AOP特点：

采用横向抽取机制，取代了传统纵向继承体系重复性代码。

3、AOP底层实现：

AOP底层使用动态代理实现。包括两种方式：

      （1）使用JDK动态代理实现。

      （2）使用cglib来实现

JDK动态代理实现：

只能对实现了接口的类生成代理，而不是针对类，该目标类型实现的接口都将被代理。原理是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。步骤如下：

1. 定义一个实现接口InvocationHandler的类
2. 通过构造函数，注入被代理类
3. 实现invoke（ Object proxy, Method method, Object[] args）方法
4. 在主函数中获得被代理类的类加载器
5. 使用Proxy.newProxyInstance( )产生一个代理对象
6. 通过代理对象调用各种方法

cglib动态代理实现：

针对类实现代理，对是否实现接口无要求。原理是对指定的类生成一个子类，覆盖其中的方法，因为是继承，所以被代理的类或方法最好不要声明为final类型。
1. 定义一个实现了MethodInterceptor接口的类
2. 实现其intercept（）方法，在其中调用proxy.invokeSuper( )

代理方式的选择：

  1. 如果目标对象实现了接口，默认情况下回采用JDK的动态代理实现AOP，也可以强制使用cglib实现AOP
2. 如果目标对象没有实现接口，必须采用cglib库，Spring会自动在JDK动态代理和cglib之间转换

静态代理和动态代理的区别：

静态代理：自己编写创建代理类，然后再进行编译，在程序运行前，代理类的.class文件就已经存在了。
动态代理：在实现阶段不用关心代理谁，而在运行阶段（通过反射机制）才指定代理哪一个对象。

4、AOP原理

5、AOP操作术语：

Joinpoint(连接点): 类里面可以被增强的方法，这些方法称为连接点
Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Aspect(切面): 是切入点和通知（引介）的结合
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
Target(目标对象):代理的目标对象(要增强的类)
Weaving(织入):是把增强应用到目标的过程，把advice 应用到 target的过程
Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类   

其实我们只需要这么记忆即可：

切入点：在类里边可以有很多方法被增强，比如实际操作中，只是增强了个别方法，则定义实际被增强的某个方法为切入点。

通知/增强：增强的逻辑，称为增强，比如扩展日志功能，这个日志功能称为增强。包括：

前置通知：在方法之前执行

后置通知：在方法之后执行

异常通知：方法出现异常执行

最终通知：在后置之后执行

环绕通知：在方法之前和之后执行

切面：把增强应用到具体方法上面的过程称为切面。

6、AOP操作案例：

导入和aop相关的jar包

创建spring核心配置文件，导入aop约束

[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"  
4.     xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="  
5.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
6.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  

使用表达式配置切入点：

常用的表达式
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
（1）execution(* cn.itcast.aop.Book.add(..))
（2）execution(* cn.itcast.aop.Book.*(..))
（3）execution(* *.*(..))
（4） 匹配所有save开头的方法 execution(* save*(..))

举例：

1、首先定义一个Book类，里边有方法add（），也就是切入点（被增强的方法）

[java]  view plain  copy

1. package cn.ywq.aop;  
2.   
3. public class Book {  
4.   
5.     public void add() {  
6.         System.out.println("add...........");  
7.     }  
8. }  

2、定义一个MyBook类，里边有可以用来增强的方法，即某些功能方法代码。我们要实现的就是将某些功能方法加入切入点。

[java]  view plain  copy

1. package cn.ywq.aop;  
2.   
3. import org.aspectj.lang.ProceedingJoinPoint;  
4.   
5. public class MyBook {  
6.   
7.     public void before1() {  
8.         System.out.println("前置增强......");  
9.     }  
10.       
11.     public void after1() {  
12.         System.out.println("后置增强......");  
13.     }  
14.       
15.     //环绕通知  
16.     public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
17.         //方法之前  
18.         System.out.println("方法之前.....");  
19.           
20.         //执行被增强的方法  
21.         proceedingJoinPoint.proceed();  
22.           
23.         //方法之后  
24.         System.out.println("方法之后.....");  
25.     }  
26. }  

3、核心配置文件：

[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"  
4.     xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="  
5.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
6.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  
7.       
8.     <!-- 1  配置对象 -->  
9.     <bean id="book" class="cn.ywq.aop.Book"></bean>  
10.     <bean id="myBook" class="cn.ywq.aop.MyBook"></bean>  
11.       
12.     <!-- 2 配置aop操作 -->  
13.     <aop:config>  
14.         <!-- 2.1 配置切入点 -->  
15.         <aop:pointcut expression="execution(* cn.ywq.aop.Book.*(..))" id="pointcut1"/>  
16.           
17.         <!-- 2.2 配置切面   
18.             把增强用到方法上面  
19.         -->  
20.         <aop:aspect ref="myBook">  
21.             <!-- 配置增强类型   
22.                 method： 增强类里面使用哪个方法作为前置  
23.             -->  
24.             <aop:before method="before1" pointcut-ref="pointcut1"/>  
25.               
26.             <aop:after-returning method="after1" pointcut-ref="pointcut1"/>  
27.               
28.             <aop:around method="around1" pointcut-ref="pointcut1"/>  
29.         </aop:aspect>  
30.     </aop:config>  
31.       
32. </beans>  

4、测试类如下：

[java]  view plain  copy

1. package cn.ywq.aop;  
2.   
3. import org.junit.Test;  
4. import org.springframework.context.ApplicationContext;  
5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
6.   
7. public class TestAnno {  
8.       
9.     @Test  
10.     public void testService() {  
11.         ApplicationContext context =   
12.                 new ClassPathXmlApplicationContext("bean3.xml");  
13.         Book book = (Book) context.getBean("book");  
14.         book.add();  
15.     }  
16. }  

5、结果如下：

以上就是我们使用aop的一个基本简单介绍，这样我们便可以在业务逻辑代码前后加一些功能性代码了，比如日志记录，性能统计，安全控制，事务处理，异常处理。