一. AOP概述

1. 什么是AOP

AOP（Aspect Oriented Programming），即面向切面编程。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件系统开发中的一个热点，也是spring框架的一个重点。利用AOP可以实现业务逻辑各个部分的隔离，从而使得业务逻辑各个部分的耦合性降低，提高程序的可重用性，同时提高开发效率。

2. 传统开发模型: 纵向的编程

在这里插入图片描述

3. 面向切面编程:纵横配合的编程

在这里插入图片描述

AOP原理：

在这里插入图片描述

4. AOP的作用及优势

作用：在程序运行期间，不修改源码对已有方法进行增强，扩展功能。

优势：减少重复代码、提高开发效率、维护方便

5. AOP的实现原理

原理： 动态代理技术

说明：在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

如果目标对象实现接口，使用JDK代理。

目标对象没有实现接口使用CGLIB代理。

JDK动态代理

动态代理：代理类在程序运行时创建的代理方式被成为动态代理。

JDK动态代理有以下特点:

代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们提供目标对象所实现的接口的字节码对象)
动态代理要求目标对象一定要实现接口，所以也叫做接口代理！

回顾JDK动态代理

Proxy类

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 作用：生成一个代理对象
loader	和目标对象一类的类加载器
interfaces	真实对象所有实现的接口
h	是一个接口，传一个匿名内部类做为实现类，并且重写其中的方法来实现代理的功能
返回值	返回代理对象

InvocationHandler接口

Object invoke(Object proxy, Method method, Object[] args) 作用：这个接口中的方法会调用多次，每个方法都会调用一次，用来实现代理方法的功能
proxy	代表生成的代理对象，不建议在方法中直接调用，不然会出现递归调用。
method	代理的方法对象
args	调用方法时传递的参数数组
返回	返回当前这个方法调用的返回值

动态代理模式的开发步骤

首先需要存在抽象角色，定义所有的功能
真实对象实现抽象角色所有的功能
通过Proxy类，创建代理对象，调用代理方法
在InvocationHandler的invoke对代理的方法有选择的修改或不修改。

动态代理模式应用案例：

租房案例：

在这里插入图片描述

接口：

interface Service{                          //接口
    void save();
    void update();
    void delete();
}

目标对象：

class ServiceImpl implements Service{           //目标对象(被代理对象)

    @Override
    public void save() {
        System.out.println("保存数据");
    }

    @Override
    public void update() {
        System.out.println("修改数据");
    }

    @Override
    public void delete() {
        System.out.println("删除数据");
    }
}

测试类：

public class Demo {
    public static void main(String[] args) throws Exception {
        /*
        最终返回一个代理对象,此代理对象对目标对象的所有方法都进行了代理
        最终执行代理对象的任何方法都会执行InvocationHandler中的invoke方法
         */
        Service o = (Service) Proxy.newProxyInstance(
                /*
               传入目标对象的类加载器
                 */
                ServiceImpl.class.getClassLoader(),
                /*
             传入目标对象的所有实现接口的字节码对象
             代理对象就是根据此接口字节码对象来指定代理方法,实现动态方法代理
               要不然目标对象增加一个方法,动态代理需要手动添加一个代理方法
                 */
                ServiceImpl.class.getInterfaces(),
                new InvocationHandler() {
                    @Override
                    //proxy是代理对象
                    //method是目标对象的方法
                    //args是目标对象方法的参数
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("增强的代码");
                        /*
                        因为method.invoke执行的是目标对象的具体方法,因此必须传入目标对象
                         */
                        Object invoke = method.invoke(new ServiceImpl());
                        System.out.println("增强的代码");
                        return invoke;
                    }
                }
        );
        //代理对象执行save方法,最终会执行InvocationHandler中的invoke方法
        o.save();

    }
}

小结：JDK提供的动态代理是基于接口的，把目标对象所实现的所有接口的字节码对象传入方法中，JDK能在内存中动态的帮我们创建一个对象，该对象实现的目标对象实现的所有方法。即保证目标对象的所有方法代理对象都能代理到

JDK动态代理，要求目标对象一定要实现接口,否则不能用动态代理。

如果目标对象就是没有实现接口，还想对目标对象某个方法进行扩展，怎么办？看CGLIB代理！

CGLIB代理

动态代理模式要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)

Spring-Core核心已经包含CGLIB功能。

代码：

Service类：

package com.dfbz.entity;

public class Service {
    public void save(){
        System.out.println("保存");
    }
    
    public void update(){
        System.out.println("修改");
    }
    
    public void delete(){
        System.out.println("删除");
    }
}

package com.itdfbz.spring;

import com.dfbz.entity.Service;
import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Demo1 {

    @Test
    public void test1() {
        //返回一个service的子类
        Service serviceProxy = (Service) Enhancer.create(Service.class, new MethodInterceptor() {
            /*
            *
            *   proxy:代理对象
            *   method:要执行的方法对象
            *   args:要执行的方法的参数
            *   methodProxy:代理对象的方法对象
            * */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("增强的代码");
//                Object invoke = method.invoke(new Service());
                 /*
                methodProxy:
                    代理对象的方法类,因为cglib代理对目标对象进行继承派生出子类,因此代理对象是目标对象的子类
                    此代理对象方法类可以执行本代理对象方法,也可以执行
                 */
                Object invoke = methodProxy.invoke(new Service(), args);
                System.out.println("增强的代码");
                return invoke;
            }
        });

        serviceProxy.save();
    }

}

使用CGLIB子类代理：

需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,
引入功能包后,就可以在内存中动态构建子类
代理的类不能为final,否则报错
目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

二. Spring中的AOP

通过动态代理模式的实现后，我们可以定义AOP其实就是用于通过规则设置来拦截方法，加入可以统一处理的代码。

1. AOP实现原理

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

AOP配置后 Spring容器返回的目标对象,实质上是 Spring利用动态代理技术生成一个代理类型。代理类重写了原目标组件方法的功能,在代理类中调用方面对象功能和目标对象功能

Spring框架采用了两种动态代理实现:

利用cglib工具包目标没有接口时采用CGLIB代理,代理类是利用继承方法生成一个目标子类
利用 JDK Proxy API目标有接口时采用JDK动态代理,代理类是用实现目标接口方法生成一个类

2. AOP相关名词(了解)

Joinpoint(连接点):

在程序执行过程中，需要拦截的方法
根据规则，可以指定拦截的方法，我们将每一个被拦截的方法称为连接点。如：UserService中的save()方法就是连接点

Pointcut(切入点):

切入点，就是拦截方法设置的规则，连接点的一系列集合
所谓切入点是指我们要对哪些Joinpoint进行拦截的定义

Advice(通知/增强):

增强连接点的实现代码(也就是需要为连接点绑定的方法)
所谓通知是指拦截到Joinpoint之后所要做的事情就是通知

通知的类型：

前置通知(Before)：执行连接点方法之前执行
后置通知(After)：目标方法
环绕通知(Around)
最终通知(After)
异常通知(AfterThrowing)

target(目标对象)：

被代理对象，连接点的所属方法，也就是需要增强的方法

Weaving(织入)：

将通知应用到连接点形成切点的过程

Proxy(代理)：

一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面):

我们的拦截处理类，切入点+通知

3. 基于XML配置AOP

使用spring的aop，需要加入IOC基础框架包和spring的AOP支持包。

aspectj 开源的面向切面编程的组织，SpringAop在此基础上实现的切面编程。

3.1. 搭建环境

搭建Maven项目

需求：编写一个切面类，在执行save,delete,update方法，分别在方法执行前、方法之后、异常出现后、分别方法执行前后调用编写统一处理的代码，

引入依赖（context依赖中依赖有aop包，所有我们只要引入context依赖就ok）：

<!--context中有依赖于aop包所有导入context依赖就行-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<!--导入spring整合的aspects依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

<!--spring整合junit依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

<!--junit依赖-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

编写业务层类和接口

StudentService接口

package com.dfbz.service;

public class UserService  {

    public void save(){
        System.out.println("保存");
    }

}

编写切面类：

package com.dfbz.aspect;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {
    
    public void before(){
        System.out.println("前置通知");
    }

    public void afterReturning(){
        System.out.println("后置通知");
    }

    public Object around(ProceedingJoinPoint around) throws Throwable {         //环绕通知

        System.out.println("环绕通知之前");
        Object proceed = around.proceed();          //执行目标方法
        System.out.println("环绕通知之后");
        return proceed;                             //将目标方法的返回值返回
    }

    public void after(){
        System.out.println("最终通知");
    }

    public void afterThrowing(){
        System.out.println("异常抛出通知");
    }

}

编写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.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">


    <bean id="userService" class="com.dfbz.service.UserService"></bean>
    <bean id="myAspect" class="com.dfbz.aspect.MyAspect"></bean>
    <!--aop核心配置-->
    <aop:config>
        <!--
            配置切点
                id:切点名称
                expression:切点表达式
        -->
        <aop:pointcut id="myPoint" expression="execution(public void com.dfbz.service.UserService.save(..))"/>

        <!--
            配置切面
            before:前置通知
            after-returning:后置通知
            around:环绕通知
            after:最终通知
            after-throwing:异常通知
        -->
        <aop:aspect ref="myAspect">
            <!--【前置通知】-->
            <aop:before method="before" pointcut-ref="myPoint"/>
            <!--【环绕通知】-->
            <aop:around method="around" pointcut-ref="myPoint"/>
            <!--【后置通知(后置返回通知)】-->
            <aop:after-returning method="afterReturning" pointcut-ref="myPoint"/>
            <!--【异常通知】-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="myPoint"/>
            <!--【最终通知】-->
            <aop:after method="after" pointcut-ref="myPoint"/>
        </aop:aspect>
    </aop:config>
</beans>

编写测试代码

package com.dfbz.spring;

import com.dfbz.service.UserService;
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:application.xml")
public class Demo1 {

    @Autowired
    private UserService userService;

    @Test
    public void test1(){

        userService.save();

    }
}

测试结果：

在这里插入图片描述

aop配置注意事项

在我们开发中通知顺序应该为：

前置通知
环绕通知之前
目标方法执行
环绕通知之后
后置通知
最终通知

但是如果在application.xml配置顺序如果不一样则会导致不同的情况，因此必须严格控制在spring配置文件中配置的通知顺序

在这里插入图片描述

3.2. 切入点表达式说明

3.2.1 execution

匹配方法的执行(常用)

execution(表达式)表达式语法：

execution([修饰符] 返回值类型包名.类名.方法名(参数))

全匹配方式：

public void com.dfbz.service.UserService.save(..)

访问修饰符可以省略

void com.dfbz.service.UserService.save()

返回值可以使用**号，表示任意返回值*

* com.dfbz.service.UserService.save()

包名可以使用*号，表示任意包，但是有几级包，需要写几个

* *.*.*.*.UserService.save()

使用…来表示当前包，及其子包

* com..UserService.save()

方法名匹配UserService的所有方法都能找到(但是方法必须无参)

* com..UserService.*();

方法参数匹配，Userservice所有方法都能找到，不管方法是否有参

* com..UserService.*(..)

类名可以使用 * 号，表示任意类*

* com..*.save()

3.2.2within

按类匹配：

被匹配的类中的所有方法作为目标方法，使用within来实现

语法within(包名.类名)

匹配到具体类

<aop:pointcut id="myPoint" expression="within(com.dfbz.service.UserService)"/>

匹配到包下的类(不包含子包)

com.dfbz.service.*

找所有的service包下的类匹配到包和子包下的类

within(com..*)

注意所有的该包和子包的类都会切入切面

*:通配的是任何的字符串

… :如果通配包的时候，就是匹配包以及它子包的类，如果通配是方法参数，就是不限定任何参数

3.4. 常用标签

aop:config

作用：aop的核心配置标签

aop:aspect

作用：用于配置切面。

属性：

id：给切面提供一个唯一标识。

ref：引用配置好的通知类bean的id。

aop:pointcut

作用：

用于配置切入点表达式

属性：

expression：用于定义切入点表达式。

id：用于给切入点表达式提供一个唯一标识。

aop:before

作用：用于配置前置通知

属性：

method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

aop:after-returning

作用：用于配置后置通知，如果出了异常就一定不会调用切面的方法

属性：

method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

aop:after-throwing

作用：用于配置异常通知，只有出了异常才会调用切面对应的方法

属性：

method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

aop:after

作用：用于配置最终通知，不管出不出异常，调用的切面的方法

属性：

method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

aop:around

作用：用于配置环绕通知

属性：

method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

4. 基于注解配置AOP

4.1. 搭建环境

4.1.1. 第一步：创建一个Maven项目

引入依赖

<!--context中有依赖于aop包所有导入context依赖就行-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<!--导入spring整合的aspects依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

<!--spring整合junit依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

<!--junit依赖-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

4.1.2. 第二步：编写业务层类

UserService

package com.dfbz.service;

public class UserService  {

    public void save(){
        System.out.println("保存");
    }

}

编写切面类：

package com.dfbz.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect     //标注此类是个注解类
@Component
public class AnnoMyAspect {

    @Pointcut("execution(* com.dfbz.service.UserService.save())")
    public void pt(){}

//    @Before("execution(* com.dfbz.service.UserService.save())")     //单独定义切点
    @Before("pt()")             //引用切点
    public void before(){
        System.out.println("前置通知");
    }

    @AfterReturning("pt()")
    public void afterReturning(){
        System.out.println("后置通知");
    }

    @Around("pt()")
    public Object around(ProceedingJoinPoint around) throws Throwable {         //环绕通知

        System.out.println("环绕通知之前");
        Object proceed = around.proceed();          //执行目标方法
        System.out.println("环绕通知之后");
        return proceed;                             //将目标方法的返回值返回
    }

    @After("pt()")
    public void after(){
        System.out.println("最终通知");
    }

    @AfterThrowing("pt()")
    public void afterThrowing(){
        System.out.println("异常抛出通知");
    }
}

4.1.3. 第三步：编写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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd 	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


    <context:component-scan base-package="com.dfbz" />
    <bean id="userService" class="com.dfbz.service.UserService" />
    <!--开启aop注解支持-->
    <aop:aspectj-autoproxy />

</beans>

4.1.4. 第四步：编写测试代码

package com.dfbz.spring;

import com.dfbz.service.UserService;
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:application.xml")
public class Demo1 {

    @Autowired
    private UserService userService;

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

4.3. 常用注解

@Aspect

作用：把当前类声明为切面类。

@Before

作用：把当前方法看成是前置通知。

属性：