1.SPring的AOP简介

1.1什么是AOP

面向切面编程,运行期间执行的,动态代理
动态代理优点:不动用源码情况下,对目标方法进行相应的增强(修改)
作用:程序功能之间松耦合

OOP面向对象编程

两个核心：IOC和AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序
的可重用性，同时提高了开发的效率。

1.2AOP的优势

将功能方法加在目标方法上就是一个切面

  • 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
  • 优势：减少重复代码，提高开发效率。并且便于维护

1.3AOP的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强

1.4AOP的动态代理技术

常用的动态代理技术

  • JDK代理：基于接口的动态代理技术
  • cglib代理：基于父类的动态代理技术

09_AOP - 图1

1.5JDK动态代理

  1. 目标接口
  1. public interface TargetInterface {
  2.     public void save();
  3. }
  1. 目标类
  1. public class Target implements TargetInterface {
  2.     public void save() {
  3.         System.out.println("save running...");
  4.     }
  5. }
  1. 目标增强
  1. public class Advice {
  2.     public void before(){
  3.         System.out.println("前置增强");
  4.     }
  6.     public void afterReturning(){
  7.         System.out.println("后置增强");
  8.     }
  9. }
  1. 动态代理代码

ProxyTest.java

  1. // 目标对象
  2. final Target target = new Target();
  3. // 增强对象
  4. final Advice advice = new Advice();
  5. // 返回值 就是动态生产的代理对象
  6. TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
  7.         target.getClass().getClassLoader(), // 目标对象类加载器
  8.         target.getClass().getInterfaces(),// 目标对象相同的接口字节码对象数组
  9.         new InvocationHandler() {
  10.             // 调用代理对象的任何方法,实质执行的都是invoke方法
  11.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  12.                 // 前置增强
  13.                 advice.before();
  14.                 Object invoke = method.invoke(target, args);// 执行目标方法
  15.                 // 后置增强
  16.                 advice.afterReturning();
  17.                 return invoke;
  18.             }
  19.         }
  20. );
  21. // 调用代理对象的方法
  22. proxy.save();

输出

  1. 前置增强
  2. save running...
  3. 后置增强

1.6cglib动态代理

  1. 目标类
  1. public class Target {
  2.     public void save() {
  3.         System.out.println("save running...");
  4.     }
  5. }
  1. 目标增强
  1. public class Advice {
  2.     public void before(){
  3.         System.out.println("前置增强");
  4.     }
  6.     public void afterReturning(){
  7.         System.out.println("后置增强");
  8.     }
  9. }
  1. 动态代理
  1. public class ProxyTest {
  2.     public static void main(String[] args) {
  4.         // 目标对象
  5.         final Target target = new Target();
  6.         // 增强对象
  7.         final Advice advice = new Advice();
  9.         // 返回值 就是动态生产的代理对象
  10.         // 1.创建增强器
  11.         Enhancer enhancer = new Enhancer();
  12.         // 2.设置父类(目标)
  13.         enhancer.setSuperclass(Target.class);
  14.         // 3.设置回调
  15.         enhancer.setCallback(new MethodInterceptor() {
  16.             public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  17.                 advice.before();// 执行前置
  18.                 Object invoke = method.invoke(target, args);// 执行目标
  19.                 advice.afterReturning();// 执行后置
  20.                 return invoke;
  21.             }
  22.         });
  23.         // 4.创建代理对象
  24.         Target proxy = (Target) enhancer.create();
  25.         proxy.save();
  26.     }
  27. }

1.7AOP相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

连接点：可以被增强的方法
切入点：被增强了的方法

  • Target（目标对象）：代理的目标对象
  • Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
  • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
  • Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
  • Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
  • Aspect（切面）：是切入点和通知（引介）的结合
  • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

1.8AOP开发明确的事项

1.需要编写的内容

  • 编写核心业务代码（目标类的目标方法）
  • 编写切面类，切面类中有通知(增强功能方法)
  • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2.AOP技术实现的内容
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3. AOP 底层使用哪种代理方式
在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

1.9知识要点

  • aop：面向切面编程
  • aop底层实现：基于JDK的动态代理和基于Cglib的动态代理

  • aop的重点概念

    • Pointcut（切入点）：被增强的方法
    • Advice（通知/ 增强）：封装增强业务逻辑的方法
    • Aspect（切面）：切点+通知
    • Weaving（织入）：将切点与通知结合的过程

  • 开发明确事项：

    • 谁是切点（切点表达式配置）
    • 谁是通知（切面类中的增强方法）
    • 将切点和通知进行织入配置

2.基于XML 的 AOP 开发

2.1 快速入门

① 导入 AOP 相关坐标
② 创建目标接口和目标类（内部有切点）
③ 创建切面类（内部有增强方法）
④ 将目标类和切面类的对象创建权交给 spring
⑤ 在 applicationContext.xml 中配置织入关系
⑥ 测试代码

  1. 导入AOP相关坐标
  1. <!--导入spring的context坐标，context依赖aop-->
  2. <dependency>
  3.     <groupId>org.springframework</groupId>
  4.     <artifactId>spring-context</artifactId>
  5.     <version>5.0.5.RELEASE</version>
  6. </dependency>
  7. <!-- aspectj的织入 -->
  8. <dependency>
  9.     <groupId>org.aspectj</groupId>
  10.     <artifactId>aspectjweaver</artifactId>
  11.     <version>1.8.4</version>
  12. </dependency>
  1. 创建目标接口和目标类(内部有切点)

切点:被增强的方法

  1. public interface TargetInterface {
  2.     public void method();
  3. }
  1. public class Target implements TargetInterface {
  2.     // 切点:被增强的方法
  3.     @Override
  4.     public void method() {
  5.         System.out.println("Target running....");
  6.     }
  7. }
  1. 创建切面类(内含增强方法)
  1. public class MyAspect {
  2.     //前置增强方法
  3.     public void before(){
  4.         System.out.println("前置代码增强.....");
  5.     }
  6. }
  1. 将目标类和切面类的对象创建权交给 spring
  1. <!--配置目标类-->
  2. <bean id="target" class="com.itheima.aop.Target"></bean>
  3. <!--配置切面类-->
  4. <bean id="myAspect" class="com.itheima.aop.MyAspect"></bean>
  1. 在 applicationContext.xml 中配置织入关系
  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"
  5.        xsi:schemaLocation="
  6.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  8. ">

配置切点表达式和前置增强的织入关系

  1. <!--配置织入:告诉spring框架 哪些方法(切点)需要进行哪些增强(前置/后置...)-->
  2. <aop:config>
  3.     <aop:aspect ref="myAspect">
  4.         <!--切面:切点+通知-->
  5.     <aop:before method="before" pointcut="execution(* com.itheima.aop.*.*(..))"></aop>
  6.     </aop:aspect>
  7. </aop:config>
  1. 测试代码
  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class AopTest {
  4.     @Autowired
  5.     private TargetInterface target;
  6.         @Test
  7.         public void test1(){
  8.             target.method();
  9.     }    
  10. }

2.2 XML 配置 AOP 详解

  1. 切点表达式的写法

表达式语法

  1. execution([修饰符] 返回值类型 包名.类名.方法名(参数))
  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用星号* 代表任意
  • 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
  • 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

例如

  1. execution(public void com.itheima.aop.Target.method())
  2. execution(void com.itheima.aop.Target.*(..))
  3. execution(* com.itheima.aop.*.*(..))
  4. execution(* com.itheima.aop..*.*(..))
  5. execution(* *..*.*(..))
  1. 通知的类型

通知配置语法:

  1. <aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

09_AOP - 图2

2.3 知识要点

  • aop织入的配置
  1. <aop:config>
  2.     <aop:aspect ref=“切面类”>
  3.         <aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
  4.     </aop:aspect>
  5. </aop:config>
  • 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知
  • 切点表达式的写法：
  1. execution([修饰符] 返回值类型 包名.类名.方法名(参数))

3. 基于注解的 AOP 开发

3.1 快速入门

基于注解的aop开发步骤：
① 创建目标接口和目标类（内部有切点）
② 创建切面类（内部有增强方法）
③ 将目标类和切面类的对象创建权交给 spring
④ 在切面类中使用注解配置织入关系
⑤ 在配置文件中开启组件扫描和 AOP 的自动代理
⑥ 测试

  1. 创建目标接口和目标类（内部有切点）
  1. public interface TargetInterface {
  2.     public void method();
  3. }
  1. public class Target implements TargetInterface {
  2.     @Override
  3.     public void method() {
  4.         System.out.println("Target running....");
  5.     }
  6. }
  1. 创建切面类（内部有增强方法）
  1. public class MyAspect {
  2.     //前置增强方法
  3.     public void before(){
  4.         System.out.println("前置代码增强.....");
  5.     }
  6. }
  1. 将目标类和切面类的对象创建权交给 spring
  1. @Component("target")
  2. public class Target implements TargetInterface {
  3.     @Override
  4.     public void method() {
  5.         System.out.println("Target running....");
  6.     }
  7. }
  8. ===================================================
  9. @Component("myAspect")
  10. public class MyAspect {
  11.     public void before(){
  12.         System.out.println("前置代码增强.....");
  13.     }
  14. }
  1. 在切面类中使用注解配置织入关系
  1. @Component("myAspect")
  2. @Aspect
  3. public class MyAspect {
  4.     @Before("execution(* com.itheima.aop.*.*(..))")
  5.     public void before(){
  6.         System.out.println("前置代码增强.....");
  7.     }
  8. }
  1. 在配置文件中开启组件扫描和 AOP 的自动代理
  1. <!--组件扫描-->
  2. <context:component-scan base-package="com.itheima.anno"/>
  3. <!--aop的自动代理-->
  4. <aop:aspectj-autoproxy/>
  1. 测试代码
  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext-anno.xml")
  3. public class AnnoTest {
  4.     @Autowired
  5.     private TargetInterface target;
  7.     @Test
  8.     public void test1(){
  9.         target.save();
  10.     }
  11. }

3.2 注解配置 AOP 详解

  1. 注解通知的类型

通知的配置语法：@通知注解(“切点表达式”)

09_AOP - 图3

  1. 切点表达式的抽取
    同 xml 配置 aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut
    注解定义切点表达式，然后在在增强注解中进行引用。具体如下：
  1. @@Component("myAspect")
  2. @Aspect
  3. public class MyAspect {
  4.     @Before("MyAspect.myPoint()")
  5.     public void before(){
  6.         System.out.println("前置代码增强.....");
  7.     }
  9.     @Pointcut("execution(* com.itheima.aop.*.*(..))")
  10.     public void myPoint(){}
  11. }

3.3 知识要点

注解aop开发步骤

  • 使用@Aspect标注切面类
  • 使用@通知注解标注通知方法
  • 在配置文件中配置aop自动代理aop:aspectj-autoproxy/

通知注解类型.
09_AOP - 图4