spring框架（三）——Spring的核心之AOP

上一节我们了解到spring的一个核心之IOC控制反转（依赖注入），那么 我们接着聊一聊spring的另外一个核心aop（面向切面编程）

1、AOP概念及原理

1.1、什么是AOP

OOP：Object Oriented Programming面向对象编程
AOP：Aspect Oriented Programming面向切面编程

我想直接说可能不懂。我们就从图片中读取信息吧。啥也不说，上图：

AOP：面向切面编程.AOP的出现不是替换OOP.解决OOP开发中一些问题.是OOP一个延伸一个扩展.
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）

AOP的底层原理  底层原理实质就是代理机制.

1.2、代理

充分理解：间接
主要作用：拦截被代理对象执行的方法，同时对方法进行增强。

1.2.1、静态代理

特点：代理类是一个真实存在的类。装饰者模式就是静态代理的一种体现形式。

1.2.2、动态代理

特点：字节码是随用随创建，随用随加载。是在运行期间生成的一个类。
a、基于接口的动态代理
提供者：JDK官方的Proxy类。
要求：被代理类必须实现一个或多个接口。
b、基于子类的动态代理
提供者：第三方的CGLib，如果报asmxxxx异常，需要导入asm.jar。
要求：被代理类必须是一个子类（不能用final修饰的（最终类），其余类都没问题，因为都是Object的子类）。
注意：在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

Spring的AOP的底层采用两种代理机制:

• JDK的动态代理:   只能对实现了接口的类生成代理.
• CGLIB的动态代理:   可以对没有实现接口的类生成代理.(采用的是比较底层的字节码技术,对类生成一个子类对象.)

1.3、代理的总结:

Spring在运行期，生成动态代理对象，不需要特殊的编译器
Spring AOP的底层就是通过JDK动态代理或CGLib动态代理技术 为目标Bean执行横向织入
1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。
程序中应优先对接口创建代理，便于程序解耦维护
标记为final的方法，不能被代理，因为无法进行覆盖
JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰
CGLib 是针对目标类生产子类，因此类或方法 不能使final的
Spring只支持方法连接点，不提供属性连接

2、Spring中的AOP

2.1、基本概念（AOP的术语）

1. Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
2. Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
3. Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
4. Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
5. Target(目标对象):代理的目标对象
6. Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程. spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入
7. Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
8. Aspect(切面): 是切入点和通知（引介）的结合

2.2、具体配置

2.2.1、Spring中的AOP

a、开发阶段（我们做的）

1. 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
2. 把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP编程人员来做。
3. 在配置文件中，声明切入点与通知间的关系，即切面。：AOP编程人员来做。

b、运行阶段（Spring框架完成的）
Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3 基于XML的配置（spring的xml开发）

3.1 AOP的基本配置

a、导入AOP相关的jar包（Spring的AOP是基于IoC的，所以IoC的jar也必须存在）AOP有关的jar包：4个

b、引入aop名称空间

c 编写核心业务代码必须交给spring容器

d 编写一个切面类:(某一个通知类型）也必须交给spring管理

上图的logger类是后期做的。现在是用下面的，bean的配置一样不变

package springAop.aop;public class Logger {//打印日志的公共方法//计划让其在业务核心代码（切入点方法）之前执行。 前置通知public void printLog(){System.out.println("Logger中的printLog方法开始输出日志了。。。。。");}}

注意：通知类型稍后做详解

e 配置切面

注意：切入点表达式以及切入点的配置方式稍后做详解

f 测试：编写测试代码并测试

package springAop.test;import org.springframework.context.support.ClassPathXmlApplicationContext;import springAop.user.UserService;public class Client {public static void main(String[] args) {//Spring容器的初始化ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("springAop/bean.xml");//获取资源//UserServiceImpl userService = (UserServiceImpl) ac.getBean("userServiceImpl");UserService userService = (UserService)ac.getBean("userServiceImpl");userService.save();}}

测试的时候我获取ac.getBean的对象转换为它的接口类型，使用它实际类型抛错，不知道为什么？

结果：

Logger中的printLog方法开始输出日志了。。。。。UserServiceImpl的save方法执行了。。。

注意：到这里一个简单的基于xml的spring的AOP就配置完毕！其它的东西全部都是完善！

4 详解切入点表达式（优化上面的e步骤，配置切面）

execution:匹配方法的执行(常用) execution(public * *(..))
基本语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

• within:匹配包或子包中的方法(了解) within(springAop.aop..*)
• this:匹配实现接口的代理对象中的方法(了解) this(springAop.aop.user.UserDAO)
• target:匹配实现接口的目标对象中的方法(了解) target(springAop.aop.user.UserDAO)
• args:匹配参数格式符合标准的方法(了解) args(int,int)

Spring支持使用如下三个逻辑运算符来组合切入点表达式：

• &&：要求连接点同时匹配两个切点表达式
• ||：要求连接点匹配至少一个切入点表达式
• !：要求连接点不匹配指定的切入点表达式

例子：

方式一：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">      <!-- 1 核心业务代码：service层等一系列 -->   <bean id="userServiceImpl" class="springAop.user.impl.UserServiceImpl"></bean>   <!-- 2 切面类：某一个通知类型的类 -->   <bean id="loggerAdvice" class="springAop.aop.Logger"></bean>      <aop:config>   <aop:aspect ref="loggerAdvice" >      <!--表达式全匹配 <aop:before method="printLog" pointcut="execution(public void springAop.user.impl.UserServiceImpl.save())"/> -->   <!--访问修饰符是可以省略的<aop:before method="printLog" pointcut="execution(void springAop.user.impl.UserServiceImpl.save()"/> -->   <!--使用*来替换返回值类型，表明可以是任意返回值<aop:before method="printLog" pointcut="execution(* springAop.user.impl.UserServiceImpl.save())"/> -->   <!--使用*来通配方法名称。可以直接使用*，也可以使用*+部分方法名称<aop:before method="printLog" pointcut="execution(* springAop.user.impl.UserServiceImpl.*User())"/> -->   <!--使用*来替换包名，表明包的名称可以是任意名称<aop:before method="printLog" pointcut="execution(* springAop.*.*.UserServiceImpl.*())"/> -->   <!--使用..来替换包名，..表明的是在当前包及其子包中 <aop:before method="printLog" pointcut="execution(* springAop.user..UserServiceImpl.*())"/> -->   <!--使用*通配类的名称。 <aop:before method="printLog" pointcut="execution(* springAop.user..*.*())"/>  -->   <!--使用明确数据类型的参数。基本数据类型直接写：int,float等。引用类型：String可以直接写，也可以使用java.lang.String <aop:before method="printLog" pointcut="execution(* springAop.user..*.*(int))"/>  -->   <!--使用*通配任意类型的参数。要求是必须有一个参数 <aop:before method="printLog" pointcut="execution(* springAop.user..*.*(*))"/>  -->   <!--使用..表明有无参数都可以 <aop:before method="printLog" pointcut="execution(* springAop.user..*.*(..))"/>  -->      <aop:before method="printLog" pointcut="execution(* springAop.*.*.UserServiceImpl.*())"/>   </aop:aspect>   </aop:config></beans>

注意：方式一的所有配置中都有一个共同缺点，不能复用
方式二：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">      <!-- 1 核心业务代码：service层等一系列 -->   <bean id="userServiceImpl" class="springAop.user.impl.UserServiceImpl"></bean>   <!-- 2 切面类：某一个通知类型的类 -->   <bean id="loggerAdvice" class="springAop.aop.Logger"></bean>      <aop:config>   <aop:aspect ref="loggerAdvice" >   <!-- 使用 配置切入点的方式，实现复用   aop:pointcut 用于配置切入点，expression是切入点表达式，原来在pointcut属性中怎么写在这还怎么写   使用aop:before（或者其它通知）引入切点id   -->     <aop:pointcut expression="execution(* *..*.*(..))" id="pt1"/>   <aop:before method="printLog" pointcut-ref="pt1" />   </aop:aspect>   </aop:config></beans>

方式二只是将切入点单独提取出来，然后在通知时引入配置切入点的id。但只是提高了一定通用性，只能当前的切面使用。
方式三：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">      <!-- 1 核心业务代码：service层等一系列 -->   <bean id="userServiceImpl" class="springAop.user.impl.UserServiceImpl"></bean>   <!-- 2 切面类：某一个通知类型的类 -->   <bean id="loggerAdvice" class="springAop.aop.Logger"></bean>      <aop:config> <!-- 把切入点声明在外面，使切入点成为全局的，这样其它的切面也可以使用 -->   <aop:pointcut expression="execution(* *..*.*(..))" id="pt1"/>   <aop:aspect ref="loggerAdvice" >   <aop:before method="printLog" pointcut-ref="pt1" />   </aop:aspect>   </aop:config></beans>

方式三只是将切入点表达式提到全局位置中。这样大家都可以引用到了。

OK、切入点表达式、和如何引用。讲完了。

5 通知类型

通知类型有5个如下：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">      <!-- 1 核心业务代码：service层等一系列 -->   <bean id="userServiceImpl" class="springAop.user.impl.UserServiceImpl"></bean>   <!-- 2 切面类：某一个通知类型的类 -->   <bean id="loggerAdvice" class="springAop.aop.Logger"></bean>      <aop:config> <!-- 把切入点声明在外面，使切入点成为全局的，这样其它的切面也可以使用 -->   <aop:pointcut expression="execution(* *..*.*(..))" id="pt1"/>   <aop:aspect ref="loggerAdvice" >   <!-- 配置前置通知 :before是前置通知。永远在切入点方法（核心业务方法）执行之前执行。-->   <!-- <aop:before method="printLog" pointcut-ref="pt1" /> -->   <!-- 配置后置通知：after-retruning。当正常执行完成切入点方法之后执行。 如果切入点方法出现了异常则不会执行 -->   <!-- <aop:after-returning method="printLog" pointcut-ref="pt1" /> -->     <!-- 配置异常通知：after-throwing。当切入点方法出现异常时执行。如果切入点方法正常执行没有异常的话，则不会执行。-->     <!--  <aop:after-throwing method="printLog" pointcut-ref="pt1" /> -->     <!-- 配置最终通知 ：after。无论切入点方法执行成功与否，最终通知都会执行。-->     <!-- <aop:after mmethod="printLog" pointcut-ref="pt1" /> -->     <!-- 配置环绕通知：配置环绕通知时，并没有调用核心业务方法（切入点方法）。-->     <aop:around method="printLog" pointcut-ref="pt1"/>   </aop:aspect>   </aop:config></beans>

6 基于注解的配置

1 使用Spring注解进行AOP配置的前提
a、资源交给Spring管理（核心业务对象，通知对象均在类中添加注解）在此之前要开启扫描包

注意：代码中请使用@Compoment注解。

b、AOP有关的注解配置
开启Spring对@AspectJ注解的支持

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:aop="http://www.springframework.org/schema/aop"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.2.xsd    http://www.springframework.org/schema/context    http://www.springframework.org/schema/context/spring-context-3.2.xsd">      <!-- 指定Spring要扫描的包(同ioc注解一样）      注意：它会扫描当前包和当前包的子包下的所有类(base-package:以点分割包名)       --><context:component-scan base-package="springAop"></context:component-scan><!-- 开启spring对 @Aspectj注解的支持--><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

c、常用的AOP注解
@Aspect 配置切面

@Before：前置通知
@AfterReturning:后置通知
@AfterThrowing：异常通知
@After：最终通知
@Around：环绕通知

d、配置一个前置通知的例子

第一步：编写通知类：并交给spring管理，并配置切面，并指定通知类型

package springAop.aop;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.springframework.stereotype.Component;/** * 注解spring开发 * @author mch * */@Component  //交给spring管理--扫描包的时候就会扫描@Aspect     //配置切面public class Logger {//打印日志的公共方法//计划让其在业务核心代码（切入点方法）之前执行。 前置通知@Before("execution(* springAop.user.impl.UserServiceImpl.save())")public void printLog(){System.out.println("Logger中的printLog方法开始输出日志了。。。。。");}}

第二步：编写核心业务类，并交给spring管理

package springAop.user.impl;import org.springframework.stereotype.Component;/** * 注解spring的核心业务类 * @author mch * */@Component  //交给spring来管理public class UserServiceImpl {public void save(){System.out.println("UserServiceImpl的save方法执行了。。。");}public void update() {System.out.println("UserServiceImpl的update方法执行了。。。");}}

第三步：前提准备的a b 和c

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:aop="http://www.springframework.org/schema/aop"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd       http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.2.xsd    http://www.springframework.org/schema/context    http://www.springframework.org/schema/context/spring-context-3.2.xsd">      <!-- 指定Spring要扫描的包(同ioc注解一样）      注意：它会扫描当前包和当前包的子包下的所有类(base-package:以点分割包名)       --><context:component-scan base-package="springAop"></context:component-scan><!-- 开启spring对 @Aspectj注解的支持--><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

第4步：编写测试类、运行查看结果

package springAop.test;import org.springframework.context.support.ClassPathXmlApplicationContext;import springAop.user.UserService;import springAop.user.impl.UserServiceImpl;public class Client {public static void main(String[] args) {//Spring容器的初始化ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("springAop/bean.xml");//获取资源UserServiceImpl userService = (UserServiceImpl) ac.getBean("userServiceImpl");userService.save();}}

运行结果：

Logger中的printLog方法开始输出日志了。。。。。UserServiceImpl的save方法执行了。。。

OK、到这里基于注解的spring开发就整理完了。其它的详细内容，比如前置通知获取参数、后置通知获取返回值，异常通知获取异常信息等。等到实际项目开发用到的时候，在另行补充。