Spring的AOP

一，Spring的AOP简洁

1.简介

AOP:面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架重要组成部分，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
的各个部分进行解耦合，从而使得业务逻辑个部分之间降低耦合度，提高程序的可重用性，同时提高了开发效率

2.AOP作用和优势

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

3. AOP的底层实现

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

4.AOP动态代理技术

常用的动态代理技术：
jdk代理：基于接口的动态代理技术
cglib代理：基于父类的动态代理技术

jdk
cglib

5.AOP相关概述

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

AOP相关术语

• Target（目标对象）：代理的目标对象
• Proxy（代理）：一个类被AOP织入增强后，就产生一个代理结果类
• Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在Spring中，这些点指的是方法。因为Spring只支持方法类型的连接点（可以被增强的方法叫做连接点）------公民
• Pointcut（切入点）：指的是对那些Jointpoint进行拦截的定义 -----人大代表
• Advice（通知/增强）：指的是拦截到Jointpoint之后所要做的事就是通知
• Aspect（切面）：是切入点和通知的结合
• Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的流程。Spring采用动态代理织入，而Aspect采用编译期织入和类装载期织入（通俗的说就是切点和通知结合的过程就是织入）

AOP开发事项
1.编写内容

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

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

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

二，基于XML的AOP开发

1.入门

• 1.导入AOP相关坐标

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.4</version>
    </dependency>

• 2.创建目标接口和目标类（内部有切点）

目标类
public class Target implements TargetInterface {

    public void save() {
        System.out.println("saverun ......");
    }
}
目标接口
public interface TargetInterface {
    public void save();
}

• 3.创建切面类（内部有增强方法）

public class MyAspect {
    public void before(){
        System.out.println("前值增强");
    }
}

• 4.将目标类和切面类的对象创建权交给Spring（在application.xml中）

		<!--配置目标对象-->
        <bean id="target" class="cn.ycu.aop.Target"/>

        <!--配置切面对象-->
        <bean id="myAspect" class="cn.ycu.aop.MyAspect"/>

• 5.在applicationContext.xml中配置织入关系

 <!--配置织入：告诉Spring哪些方法（切点）需要哪些增强（前值增强/后置增强）-->
        <aop:config>
                <!--声明切面-->
                <aop:aspect ref="myAspect">
                        <!--切面=切点+通知-->
                        <aop:before method="before" pointcut="execution(public void cn.ycu.aop.Target.save())"></aop:before>
                </aop:aspect>
        </aop:config>

• 6.测试代码

package cn.ycu.test;

import cn.ycu.aop.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;

    @Test
    public void test1(){
        target.save();
    }
}

2.切点表达式的写法

表达式语句：execution（[修饰符] 返回值类型 包名.类名.方法名（参数））

• 访问修饰符可省略
• 返回值类型，包名，类名，方法名可以使用*代替
• 包名与类名之间一个点 . 代表当前包下的类,两点…表示当前包及其子包下的类
• 参数列表可以使用两个点…表示任意个数，任意类型的参数列表
  

3.通知的类型

 <aop:config>
       <!--声明切面-->
       <aop:aspect ref="myAspect">
      	<!--切面=切点+通知-->
        <aop:before method="before" pointcut="execution(* cn.ycu.aop.*.*(..))"></aop:before>
        <aop:after-returning method="afterReturn" pointcut="execution(* cn.ycu.aop.*.*(..))"></aop:after-returning>
        <aop:around method="around" pointcut="execution(* cn.ycu.aop.*.*(..))"/>
        <aop:after-throwing method="afterThrowing" pointcut="execution(* cn.ycu.aop.*.*(..))"/>
        <aop:after method="after" pointcut="execution(* cn.ycu.aop.*.*(..))"/>
       </aop:aspect>
</aop:config>

public class MyAspect {
    public void before(){
        System.out.println("前值增强");
    }

    public void afterReturn(){
        System.out.println("后值增强");
    }
    //ProceedingJoinPoint:正在执行的连接点===切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强");
        Object proceed = pjp.proceed();//切点方法
        System.out.println("环绕后增强");
        return proceed;
    }

    public void afterThrowing(){
        System.out.println("异常抛出");
    }
    public void after(){
        System.out.println("最终增强");
    }
}

4.切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcun属性来引用抽取后的切点表达式

三，基于注解的AOP开发

1 .入门

• 1.创建目标接口和目标类（内部有切点）

目标类
public class Target implements TargetInterface {

    public void save() {

        System.out.println("saverun ......");
    }
}
目标接口
public interface TargetInterface {
    public void save();
}

• 2.创建切面类（内部有增强方法）

public class MyAspect {
    public void before(){
        System.out.println("前值增强");
    }

    public void afterReturn(){
        System.out.println("后值增强");
    }
    //ProceedingJoinPoint:正在执行的连接点===切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强");
        Object proceed = pjp.proceed();//切点方法
        System.out.println("环绕后增强");
        return proceed;
    }

    public void afterThrowing(){
        System.out.println("异常抛出");
    }
    public void after(){
        System.out.println("最终增强");
    }
}

• 3.将目标类和切面类的对象创建权交给Spring

目标类
@Component("target")
切面类
@Component("MyAspect")
@Aspect //标注当前MyAspect是一个切面类

• 4.在切面类中使用注解配置织入关系

@Before(value = "execution(* cn.ycu.anno.*.*(..))")
@AfterReturning("execution(* cn.ycu.anno.*.*(..))")
@Around("execution(* cn.ycu.anno.*.*(..))")
@AfterThrowing("execution(* cn.ycu.anno.*.*(..))")
@After("execution(* cn.ycu.anno.*.*(..))")

• 5.在配置文件中开启组件扫描和AOP自动代理

		<!--组件扫描-->
       <context:component-scan base-package="cn.ycu.anno"></context:component-scan>

       <!--aop自动代理-->
        <aop:aspectj-autoproxy/>

• 6.测试

2.通知的类型

@Before(value = "execution(* cn.ycu.anno.*.*(..))")
@AfterReturning("execution(* cn.ycu.anno.*.*(..))")
@Around("execution(* cn.ycu.anno.*.*(..))")
@AfterThrowing("execution(* cn.ycu.anno.*.*(..))")
@After("execution(* cn.ycu.anno.*.*(..))")

3.切点表达式的抽取

和xml配置aop一样，我们可以将切点表达式抽取。抽取方式是在切面内定方法，在该方法上使用@Pointcut注解自定义切点表达式，然后在增强注解中引用：