【Spring的AOP】Spring的简介、案例与工作流程-编程知识

文章目录

1. 什么是AOP
2. AOP的核心概念
3. AOP的入门案例
- 原始代码
- 思路分析
- 第一步：导入坐标
- 第二步：制作连接点（原始操作，Dao接口与实现类）
- 第三步：制作共性功能（通知类与通知）
- 第四步：定义切入点
- 第五步：绑定切入点与通知关系（切面）
- 第六步：让Spring“看到”这个切面
- 第七步：在Spring配置类中加上注解
- 运行主方法
4. AOP工作流程
- 动态代理
- - 为什么需要代理？代理长什么样？Java通过什么来保证代理的样子？
  - 动态代理3问（根据以上内容给出答案）
  - - 1. Java提供了什么API帮我们创建代理？
    - 2. newProxyInstance方法在创建时，需要接几个参数？每个参数的含义是什么？
    - 3. 通过invokehandler的invoke方法指定代理干的事时，这个invoke会被谁调用？需要接哪几个参数？
  - 动态代理实例
- AOP工作流程
5. AOP切入点表达式
- 语法格式
- 通配符
- 书写技巧
6. AOP通知类型
- 前置通知和后置通知
- 环绕通知
- 返回后通知
- 抛出异常后通知
7. AOP案例：测量业务接口执行效率
- 案例代码
- - 整体架构
  - pom.xml
  - config下的包：SpringConfig、JdbcConfig、MyBatisConfig
  - 数据源
  - 实体类
  - 数据层
  - 业务层
  - 测试类
- 进行切面编程
8. AOP通知获取数据
- 获取参数
- 获取返回值
- 获取异常
- 9. AOP总结

1. 什么是AOP

Spring的两大理念：IOC(Inversion of Control)和AOP
AOP是Aspect Oriented Programming，面向切面编程，是一种编程范式，指导开发者如何组织程序结构
（PS：原本的OOP，Object Oriented Programming，面向对象编程，指导我们如何根据对象属性来进行类的开发）
作用： 在不惊动原始设计的基础上为其进行功能增强
举个例子：
在一个类中有四个方法：
在这里插入图片描述
通过测试类分别调用这个四个方法，save会打印出10000次book dao save，若update和delete在代码里没有显示定义这些内容的情况下也分别打印了10000次book dao update和book dao delete，则说明在不惊动原始设计的基础上为其进行功能增强（不对原始方法做修改的情况下加上了打印10000次的功能）
这也符合Spring的理念：无入侵式/无侵入式编程

2. AOP的核心概念

在这里插入图片描述
首先将我们想要实现的共通的功能从代码中抽取出来，写成一个通知类
在通知类中定义一个方法，称为通知，就是把共同的功能抽出来写在其中
不是所有的方法都要执行这个通知，所以要把执行对应通知的方法找出来，定义成切入点（匹配某些方法）
有了切入点和通知，我们将他们绑定起来形成切面，切面就是在哪些切入点上执行哪些通知
在这里插入图片描述

3. AOP的入门案例

案例目标：在接口执行前输出当前系统的时间

原始代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.0</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.example</groupId><artifactId>project3</artifactId><version>0.0.1-SNAPSHOT</version><name>project3</name><description>project3</description><properties><java.version>17</java.version></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.3</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.3.25</version></dependency></dependencies></project>

代码结构：
在这里插入图片描述
SpringConfig.java

package com.example.project3.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@Configuration
@ComponentScan("com.example.project3")
public class SpringConfig {}

BookDao.java

package com.example.project3.dao;import org.springframework.stereotype.Repository;public interface BookDao {void save();void update();
}

BookDaoImpl.java

package com.example.project3.dao.impl;import com.example.project3.dao.BookDao;
import org.springframework.stereotype.Repository;@Repository
public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println(System.currentTimeMillis());System.out.println("book dao save...");}@Overridepublic void update() {System.out.println("book dao update...");}
}

Project3Application.java（主方法）

package com.example.project3;import com.example.project3.config.SpringConfig;
import com.example.project3.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Project3Application {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);bookDao.update();}}

此时执行主方法：
在这里插入图片描述
若将bookDao.update()换成bookDao.save()：

思路分析

导入坐标
制作连接点（原始操作，Dao接口与实现类）
制作共性功能（通知类与通知）
定义切入点
绑定切入点与通知关系（切面）

第一步：导入坐标

实际上，在导入spring-context的时候，相关的aop包已经导入进来了：
在这里插入图片描述

但还需要在pom.xml中进一步导入：

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

第二步：制作连接点（原始操作，Dao接口与实现类）

这个其实已经做好了，就是我们的Dao接口及实现类

第三步：制作共性功能（通知类与通知）

在项目下新建一个aop包，在下面新建一个MyAdvice.java，这个MyAdvice就是通知类，里面写抽取出来的共性方法method就是通知

package com.example.project3.aop;import org.aspectj.lang.annotation.Pointcut;public class MyAdvice {public void method(){System.out.println(System.currentTimeMillis());}
}

第四步：定义切入点

通过@Pointcut定义切入点，里边的内容意思为：执行()内的方法时为切入点
切入点依托一个不具有实际意义的方法进行，即无参数、无返回值，方法体无实际逻辑

package com.example.project3.aop;import org.aspectj.lang.annotation.Pointcut;public class MyAdvice {@Pointcut("execution(void com.example.project3.dao.BookDao.update())")private void pt(){}public void method(){System.out.println(System.currentTimeMillis());}
}

第五步：绑定切入点与通知关系（切面）

通过@Before绑定关系，意为在pt()开始之前执行该通知（方法）

package com.example.project3.aop;import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;public class MyAdvice {@Pointcut("execution(void com.example.project3.dao.BookDao.update())")private void pt(){}@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}
}

第六步：让Spring“看到”这个切面

在该类上加上两个注解，一个是@Component，将其作为一个bean，并告诉Spring，将其作为切面处理，所以加上@Aspect

package com.example.project3.aop;import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;@Component
@Aspect
public class MyAdvice {@Pointcut("execution(void com.example.project3.dao.BookDao.update())")private void pt(){}@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}
}

第七步：在Spring配置类中加上注解

在配置类中加上注解@EnableAspectJAutoProxy，此注解主要用来导入 Spring 切面功能类

package com.example.project3.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;@Configuration
@ComponentScan("com.example.project3")
@EnableAspectJAutoProxy
public class SpringConfig {}

运行主方法

package com.example.project3;import com.example.project3.config.SpringConfig;
import com.example.project3.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Project3Application {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);bookDao.update();}}

结果如下：
在这里插入图片描述

4. AOP工作流程

动态代理

视频：【黑马磊哥】Java动态代理深入剖析，真正搞懂Java核心设计模式：代理设计模式
动态代理（Spring、MyBatis、SpringMVC、Spring Boot）几乎是所有框架的核心原理之一

为什么需要代理？代理长什么样？Java通过什么来保证代理的样子？

举一个最普通的例子，有一位明星，她能够唱歌和跳舞（具备sing()和dance()方法）：

class 明星{void 唱歌(){准备话筒、收钱开始唱歌}void 跳舞(){准备场地、收钱开始跳舞}
}

但是作为一个大明星，她不会自己去做准备话筒、收钱, 准备场地、收钱这件事，所以请了一个中介公司来进行代理（对象如果嫌身上干的事太多的话，可以通过代理来转移职责）
中介公司会派一位代理人，来管理准备场地、话筒, 准备场地、收钱这些事。作为一个代理，它也同样拥有sing()和dance()方法，对象有什么方法想被代理，代理就一定要有对应的方法：

class 代理{void 唱歌(){准备话筒、收钱找明星唱歌}void 跳舞(){准备场地、收钱找明星跳舞}
}

同时这个 “中介” 是通过 “接口” 了解具体需要代理的方法的
明星：

package com.example.demo.agent;public class star implements Istar{String starName;public star(String starName) {this.starName = starName;}@Overridepublic String sing(String name) {System.out.println(this.starName + "正在唱" + name);return "谢谢！谢谢！谢谢！";}@Overridepublic void dance() {System.out.println(this.starName + "正在跳舞");}
}

接口：

package com.example.demo.agent;public interface Istar {String sing(String name);void dance();
}

代理：
首先代理类返回的就是接口的一个对象，其中参数为Star类（代理为明星做代理，需要传入明星类，以获知明星能够做的事情）
通过Proxy.newProxyInstance()获得一个新的代理实例，返回的是一个(Object)类型的对象，将其强转成IStar类型，在该方法中需要传入3个参数：

类加载器，这个一般默认使用当前代理类的类加载器：ProxyUtil.class.getClassLoader()
了解明星能够实现哪一些方法，也就是要知道代理类长什么样子，这里是给了一个数组接口：new Class[]{IStar.class}
InvocationHandler类，定义这个匿名类的方法类写清楚代理对象需要做什么事。其中proxy代表的是代理本身，把代理本身作为一个对象传给invoke方法，method表示当前star调用了哪个方法，args表示调用方法时传入的参数。

package com.example.demo.agent;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class ProxyUtil {public static IStar createProxy(Star star){/** newProxyInstance(ClassLoader loader,* Class<?>[] interfaces,* InvocationHandler h)* 参数1：用于指定一个类加载器* 参数2：指定生成的代理长什么样子，也就是有哪些方法* 参数3：用来指定生成的代理对象要干什么事* */
//        代理干什么事，由invoke决定
//        Star star = new Star("xxx")
//        IStar starProxy = ProxyUtil.createProxy(s)
//        starProxy.sing("xxx"), starProxy.dance()IStar iStar = (IStar) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(), new Class[]{IStar.class},new InvocationHandler() {@Override // 回调方法public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                        代理对象要做的事，在这里写代码if (method.getName().equals("sing")){System.out.println("准备话筒，收钱");} else if (method.getName().equals("dance")) {System.out.println("准备场地，收钱");}return method.invoke(star, args);}});return iStar;}}

测试：

package com.example.demo.agent;public class Test {public static void main(String[] args) {Star star = new Star("大明星");IStar starProxy = ProxyUtil.createProxy(star);String rs = starProxy.sing("一首歌");System.out.println(rs);starProxy.dance();}
}

结果：
在这里插入图片描述
方法调用顺序：

动态代理3问（根据以上内容给出答案）

1. Java提供了什么API帮我们创建代理？

创建代理的API：

Proxy.newProxyInstance(xxxxx)

使用该API并使用强转实现类型转换

2. newProxyInstance方法在创建时，需要接几个参数？每个参数的含义是什么？

3个参数
第一个参数：类加载器，默认使用当前代理类的类加载器：NowClass.class.geetClassLoader()
第二个参数：给出代理类的“模样”，即代理类应该参照的接口，这是一个数组，可以有多个模样：new Class[]{xxx.class}
第三个参数：通过InvocationHandler类写清楚代理对象需要做的事

3. 通过invokehandler的invoke方法指定代理干的事时，这个invoke会被谁调用？需要接哪几个参数？

执行方法之前会被调用，有参数proxy表示代理本身，method表示即将调用的方法，args表示调用方法时传入的参数

动态代理实例

在这里插入图片描述
代码如下：
结构目录如下：

其中，UserService.java

package com.example.project3.aoppractice;
// 用户业务接口
public interface UserService {
//    登录功能void login(String loginName, String password) throws Exception;
//    删除用户void deleteUsers() throws Exception;
//    查询用户，返回数组形式String[] selectUsers() throws Exception;
}

UserServiceImpl.java

package com.example.project3.aoppractice;public class UserServiceImpl implements UserService{@Overridepublic void login(String loginName, String password) throws Exception {long starTime = System.currentTimeMillis();if("admin".equals(loginName) && "123456".equals(password)){System.out.println("登陆成功，欢迎光临");} else {System.out.println("登录失败，用户名/密码错误");}Thread.sleep(1000);long endTime = System.currentTimeMillis();System.out.println("login方法执行耗时：" + (endTime - starTime)/ 1000.0 + "s");}@Overridepublic void deleteUsers() throws Exception {long startTime = System.currentTimeMillis();System.out.println("删除了1万个用户");Thread.sleep(1000);long endTime = System.currentTimeMillis();System.out.println("deleteUsers方法耗时：" + (endTime - startTime)/1000.0 + "s");}@Overridepublic String[] selectUsers() throws Exception {long startTime = System.currentTimeMillis();System.out.println("查询了3个用户");String[] names = {"用户1", "用户2", "用户3"};Thread.sleep(1000);long endTime = System.currentTimeMillis();System.out.println("deleteUsers方法耗时：" + (endTime - startTime)/1000.0 + "s");return names;}
}

这样的程序中存在的问题是：在方法中存在了大量重复的求程序开始时间和程序结束时间的操作，为此，我们可以通过动态代理来简化这些方法

定义动态代理类

package com.example.project3.aoppractice;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class ProxyUtil{public static UserService createProxy(UserServiceImpl impl){UserService userService = (UserService) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(), new Class[]{UserService.class}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {if (method.getName().equals("login") || method.getName().equals("deleteUsers") || method.getName().equals("selectUsers")){long startTime = System.currentTimeMillis();Object rs = method.invoke(impl, args);long endTime = System.currentTimeMillis();System.out.println(method.getName() + "方法执行耗时：" + (endTime - startTime) / 1000.0 + "s");return rs;} else {Object rs = method.invoke(impl, args);return rs;}}});return userService;}
}

这里就是将公共的获取时间的方法从中抽出来，然后再invoke中执行该方法，并返回方法的执行结果

测试

package com.example.project3.aoppractice;public class Test {public static void main(String[] args) throws Exception {UserService userServiceProxy = ProxyUtil.createProxy(new UserServiceImpl());userServiceProxy.login("admin", "12345");System.out.println("--------------------------------");userServiceProxy.deleteUsers();System.out.println("--------------------------------");String[] names = userServiceProxy.selectUsers();System.out.println("查询到的用户是：" + Arrays.toString(names));System.out.println("--------------------------------");}
}

运行结果

AOP工作流程

Spring容器启动
读取所有切面配置中的切入点，如下图，因为只绑定了通知和切入点pt()，所以这里只读取切入点pt()而不读取ptx()
初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
匹配失败，创建对象
匹配成功，创建原始对象（目标对象）的代理对象
获取bean执行方法
获取bean，调用方法并执行，完成操作
获取的是bean的代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

这里第3、第4点可能讲的有点抽象。我理解这几句话的意思如下：
“判定bean对应的类中的方法是否匹配到任意切入点”，这句话的意思判断我们测试时候new的对象：BookDao bookDao = ctx.getBean(BookDao.class);中的方法：
在这里插入图片描述
是否与我们定义的切入点（@Pointcut中指定的具体的方法）匹配上了。
在这里update()方法的实现如下：

现在我们BookDao定义了方法update()、实现类中实现了方法update()。
然后在@Pointcut中又指定了：execution(void com.example.project3.dao.BookDao.update())，也就是指定到了BookDao中的update()方法
这时候说明已经形成了切面，即通知和切入点已经绑定上了，这时候初始化的对象就是代理对象而非原始对象本身，则通过对象名.方法调用就会走代理对象中的内容，先打印当前的时间，再执行对象方法中的内容

1702475078485
book dao update...

如果我们将@Pointcut中的内容改成execution(void com.example.project3.dao.BookDao.update1())，则此时没有办法匹配上，因为在BookDao中没有方法update1()，那么这时候就会初始化原始对象，通过对象名.方法调用不会走代理对象中的内容，只会执行对象本身的内容：

book dao update...

在初始化一个对象时候，我们可以通过对象名.getClass()方法来判断具体产生的是哪个对象，代理对象打印的结果如下：
在这里插入图片描述

5. AOP切入点表达式

切入点：要进行增强的方法
切入点表达式：要进行增强的方法的描述方式
在这里插入图片描述
描述方式一：execution(void com.itheima.dao.BookDao.update())
描述方式二：execution(void com.itheima.dao.impl.BookDaoImpl.update())
描述接口类及其实现皆可

语法格式

在这里插入图片描述

通配符

可以使用通配符描述切入点，快速描述

注意：假如我们要求参数为(*)，则方法中必须有1个或多个参数，若方法没有参数则无法匹配到

书写技巧

在这里插入图片描述

6. AOP通知类型

在这里插入图片描述
代码如下，针对五种类型集中/分别进行说明：
BookDao.java

package com.example.project3.dao;import org.springframework.stereotype.Repository;public interface BookDao {void update();int select();
}

BookDaoImpl.java

package com.example.project3.dao.impl;import com.example.project3.dao.BookDao;
import org.springframework.stereotype.Repository;@Repository
public class BookDaoImpl implements BookDao {@Overridepublic void update() {System.out.println("book dao update is running ...");}@Overridepublic int select() {System.out.println("book dao select is running ...");return 100;}
}

MyAdvice.java

package com.example.project3.aop;import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;@Component
@Aspect
public class MyAdvice {@Pointcut("execution(void com.example.project3.dao.BookDao.update())")private void pt(){}public void before(){System.out.println("Before advice");}public void after(){System.out.println("After advice");}public void around(){System.out.println("around before advice ... ");System.out.println("around after advice ... ");}public void afterReturning(){System.out.println("afterReturning advice ... ");}public void afterThrowing(){System.out.println("afterThrowing advice ... ");}
}

测试方法：

package com.example.project3;import com.example.project3.config.SpringConfig;
import com.example.project3.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Project3Application {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);bookDao.update();}
}

前置通知和后置通知

两种最简单的通知方式：@Before和@After：

	@Before("pt()")public void before(){System.out.println("Before advice");}@After("pt()")public void after(){System.out.println("After advice");}

结果为：
在这里插入图片描述

环绕通知

环绕通知注解：

	@Around("pt()")public void around(){System.out.println("around before advice ... ");System.out.println("around after advice ... ");}

结果为：
在这里插入图片描述
这样会发现对象的方法没有被调用，问题在于当我们使用环绕通知的时候，要在某一个地方进行方法的调用，格式如下：

    @Around("pt()")public void around(ProceedingJoinPoint pjp) throws Throwable{System.out.println("around before advice ... ");
//        表示对原始操作的调用pjp.proceed();System.out.println("around after advice ... ");}

在这里强制地抛出了一个异常，为什么要抛出异常呢？因为它不知道pjp调用的过程中是否有异常抛出，所以它这里就提前抛出，如果有异常要抛出不由此处处理而由pjp本身去处理
运行结果如下：
在这里插入图片描述

如果我们加上一个切入点：

    @Pointcut("execution(int com.example.project3.dao.BookDao.select())")private void pt2(){}

写一个新方法并加上环绕通知：

    @Around("pt2()")public void aroundSelect(ProceedingJoinPoint pjp) throws Throwable{System.out.println("around before advice ... ");
//        表示对原始操作的调用pjp.proceed();System.out.println("around after advice ... ");}

在测试方法中调用bookDao.select()，此时运行结果为：
在这里插入图片描述
这是因为select()方法本身是有返回值的，而我们没有把这个返回值给丢出去。
正确的写法如下：

    @Around("pt2()")public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable{System.out.println("around before advice ... ");
//        表示对原始操作的调用Object result = pjp.proceed();System.out.println("around after advice ... ");return result;}

在这其中将类的返回值改成了Object，这才是标准的写法。如果pjp.proceed()方法本身没有返回值，则返回结果为null。

运行结果为：
在这里插入图片描述

通过这个@Around可以对原始方法做隔离，比如只有经理/会员才能执行该方法，就可以通过@Around在这其中进行处理

返回后通知

这是在方法正常执行完毕后返回的通知
假如目前在这两个方法上加了注解：

    @After("pt2()")public void after(){System.out.println("After advice");}@AfterReturning("pt2()")public void afterReturning(){System.out.println("afterReturning advice ... ");}

测试类改为：

package com.example.project3;import com.example.project3.config.SpringConfig;
import com.example.project3.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Project3Application {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);int result = bookDao.select();System.out.println(result);}}

运行测试类结果为：
在这里插入图片描述
如果在select()方法中加上：

则此时运行会在int a = 1/0处报错，此时返回结果为：

可以看出来只执行了After advice，而没有执行afterReturning advice
这说明 afterReturning advice 是在返回值返回之后才执行的，可以将其视为“最后的通知”

抛出异常后通知

这是在方法抛出异常后返回的通知
保持上面的select()方法不变，测试类不变，只保持以下方法的注解：

    @AfterThrowing("pt2()")public void afterThrowing(){System.out.println("afterThrowing advice ... ");}

此时运行结果为：
在这里插入图片描述
可以发现有异常抛出时候回执行异常抛出的通知类里的代码
若我们将异常注释掉，再次运行结果为：

此时不会执行AfterThrowing内的通知

7. AOP案例：测量业务接口执行效率

需求：任意业务层接口执行均可显示其执行效率（执行时长）
分析：

业务功能：业务层执行接口执行前后分别记录时间，求差值得到执行效率
通知类型：根据业务功能选择环绕通知

PS: 在完成这部分内容的时候，我是重新建立了项目并写了代码，遇到了之前可能没有注意的一些坑，会使用红字进行标注。

案例代码

整体架构

在这里插入图片描述

pom.xml

pom.xml，其中导入的包包含spring-context，以及一些mybatis，JUnit，和AOP相关的aspectj包。
注意，这里Spring版本和MyBatis版本的匹配尤为重要！如果出现版本没办法匹配上，在下面写代码时候会报一些莫名其妙的错误，比如我就是报了：Invalid value type for attribute ‘factoryBeanObjectType’: java.lang.String，一开始觉得莫名其妙，后来发现我是<parent>处的spring版本不对，修改以后就可以运行了

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.1.5</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.example</groupId><artifactId>project4</artifactId><version>0.0.1-SNAPSHOT</version><name>project4</name><description>project4</description><properties><java.version>17</java.version></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.3</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>6.0.3</version></dependency><dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><version>8.0.33</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.11</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>3.0.1</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.13</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.3.25</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.5</version></dependency></dependencies></project>

config下的包：SpringConfig、JdbcConfig、MyBatisConfig

SpringConfig.java，这其中包含的一些配置之前都有介绍过，@Configuration指明这是一个配置类，@ComponentScan指示扫描的范围，@EnableAspectJAutoProxy允许切面编程！我后面就是由于少了这个注解，导致AOP失效，@PropertySource引入外部数据源，@Import表示导入的其他配置类

package com.example.project4.config;import org.springframework.context.annotation.*;@Configuration
@ComponentScan("com.example.project4")
@EnableAspectJAutoProxy
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MyBatisConfig.class})
public class SpringConfig {
}

JdbcConfig.java，配置数据源

package com.example.project4.config;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;import javax.sql.DataSource;public class JdbcConfig {@Value("${jdbc.driver}")String driverClassName;@Value("${jdbc.url}")String url;@Value("${jdbc.password}")String password;@Value("${jdbc.username}")String username;@Beanpublic DataSource dataSource(){DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName(driverClassName);dataSource.setUrl(url);dataSource.setPassword(password);dataSource.setUsername(username);return dataSource;}
}

MyBatis.java，配置工厂方法，及配置MyBatis的扫描范围：

package com.example.project4.config;import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;import javax.sql.DataSource;public class MyBatisConfig {@Beanpublic SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();ssfb.setTypeAliasesPackage("com.example.project4.domain");ssfb.setDataSource(dataSource);return ssfb;}@Beanpublic MapperScannerConfigurer mapperScannerConfigurer(){MapperScannerConfigurer msc = new MapperScannerConfigurer();msc.setBasePackage("com.example.project4.dao");return msc;}
}

数据源

jdbc.properties指定数据库的配置

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456

实体类

Account.java，指定实体的属性

package com.example.project4.domain;import org.springframework.context.annotation.Bean;public class Account {int id;String username;double money;@Overridepublic String toString() {return "Account{" +"id=" + id +", username='" + username + '\'' +", money=" + money +'}';}public Account() {}public Account(int id, String username, double money) {this.id = id;this.username = username;this.money = money;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}
}

数据层

AccountDao.java，使用MyBatis注解进行开发

package com.example.project4.dao;import com.example.project4.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.springframework.stereotype.Repository;import java.util.List;@Repository
public interface AccountDao {@Insert("INSERT INTO account(username, money) VALUES (#{username}, #{money})")void save(Account account);@Delete("DELETE FROM account WHERE id=#{id}")void delete(Integer id);@Update("UPDATE account SET username=#{username}, money=#{money} where id=#{id}")void update(Account account);@Select("SELECT * FROM account")List<Account> findAll();@Select("SELECT * FROM account where id=#{id}")Account findById(Integer id);}

业务层

AccountService.java，业务层接口

package com.example.project4.service;import com.example.project4.domain.Account;import java.util.List;public interface AccountService {void save(Account account);void delete(Integer id);void update(Account account);List<Account> findAll();Account findById(Integer id);
}

AccountServiceImpl.java，业务层实现类，在里面使用自动注解将AccountDao注入进来，并调用具体的方法。

package com.example.project4.service.impl;import com.example.project4.dao.AccountDao;
import com.example.project4.service.AccountService;
import com.example.project4.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.util.List;@Service
public class AccountServiceImpl implements AccountService {@Autowiredprivate AccountDao accountDao;@Overridepublic void save(Account account) {accountDao.save(account);}@Overridepublic void delete(Integer id) {accountDao.delete(id);}@Overridepublic void update(Account account) {accountDao.update(account);}@Overridepublic List<Account> findAll() {return accountDao.findAll();}@Overridepublic Account findById(Integer id) {return accountDao.findById(id);}
}

测试类

Project4ApplicationTest.java

package com.example.project4;import com.example.project4.config.SpringConfig;
import com.example.project4.domain.Account;
import com.example.project4.service.AccountService;
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;import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class Project4ApplicationTests {@Autowiredprivate AccountService accountService;@Testpublic void testFindById(){Account ac = accountService.findById(2);System.out.println(ac);}@Testpublic void testFindAll(){System.out.println(accountService.getClass());List<Account> accountList = accountService.findAll();System.out.println(accountList);}}

进行切面编程

结合4和6进行开发即可。由于这里我们根据需求使用环绕通知，所以注解会使用@Around
在项目下建立一个包aop，在下边建立一个ProjectAdvice.java
第一步：使用@Pointcut定义切入点，运用了通配符进行描述，这里指的是任意返回类型 com.example.project4.service下所有以Service结尾的类下的任意方法

    @Pointcut("execution(* com.example.project4.service.*Service.*(..))")private void servicePt(){}

第二步：定义具体的“通知”，并在通知上加上注解，说明在哪些切入点执行该方法中的内容。方法中的参数ProceedingJointPoint用来进行方法的调用：pjp.proceed()，同时通过pjp.getSignature()可以获得signature参数，并获得执行方法所在的类名getDeclaringTypeName和执行方法的方法名getName

    @Around("servicePt()")public void runSpeed(ProceedingJoinPoint pjp) throws Throwable{Signature signature = pjp.getSignature();String className = signature.getDeclaringTypeName();String methodName = signature.getName();long startTime = System.currentTimeMillis();for (int i = 0; i < 10000; i++){pjp.proceed();}long endTime = System.currentTimeMillis();System.out.println("万次执行：" + className + "." + methodName + "--->" + (endTime-startTime) + "ms");}

使用JUnit得到结果为（由于这里没有返回参数，所以返回值为null）：
在这里插入图片描述

8. AOP通知获取数据

在这里插入图片描述
此处案例使用的是AOP工作流程中的案例，只有以下代码稍有差别：
BookDao.java

package com.example.project4.dao;public interface BookDao {public String findName(int id);
}

BookDaoImpl.java

package com.example.project4.dao.impl;import com.example.project4.dao.BookDao;
import org.springframework.stereotype.Repository;@Repository
public class BookDaoImpl implements BookDao {@Overridepublic String findName(int id) {System.out.println("id:" + id);return "itcast";}
}

MyAdvice.java（这个是切面编程的类）

package com.example.project4.aop;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Component
@Aspect
public class MyAdvice {@Pointcut("execution(* com.example.project4.dao.BookDao.findName(..))")private void pt(){}@Before("pt()")public void before(){System.out.println("before advice ...");}@After("pt()")public void after(){System.out.println("after advice ...");}@Around("pt()")public Object around(ProceedingJoinPoint pjp) throws Throwable{Object ret = pjp.proceed();return ret;}@AfterReturning("pt()")public void afterReturning(){System.out.println("afterReturning advice ...");}@AfterThrowing("pt()")public void afterThrowing(){System.out.println("afterThrowing advice ...");}
}

测试类

package com.example.project4;import com.example.project4.config.SpringConfig;
import com.example.project4.dao.BookDao;
import com.example.project4.dao.impl.BookDaoImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Project4Application {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = (BookDao) ctx.getBean(BookDao.class);String result = bookDao.findName(100);System.out.println(result);}}

AOP相关的类：

package com.example.project4.aop;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Component
@Aspect
public class MyAdvice {@Pointcut("execution(* com.example.project4.dao.BookDao.findName(..))")private void pt(){}@Before("pt()")public void before(){System.out.println("before advice ...");}//    @After("pt()")public void after(){System.out.println("after advice ...");}//    @Around("pt()")public Object around(ProceedingJoinPoint pjp) throws Throwable{Object ret = pjp.proceed();return ret;}//    @AfterReturning("pt()")public void afterReturning(){System.out.println("afterReturning advice ...");}//    @AfterThrowing("pt()")public void afterThrowing(){System.out.println("afterThrowing advice ...");}
}

获取参数

在@Before,@After,@AfterReturning,@AfterThrowing中都可以加入这个参数JoinPoint jp：

	@Before("pt()")public void before(JoinPoint jp){Object[] args = jp.getArgs();System.out.println(Arrays.toString(args));System.out.println("before advice ...");}

通过这个jp可以获取参数，返回值为Object类型的数组。执行一下测试方法：
在这里插入图片描述
对于参数ProceedingJoinPoint pjp，ProceedingJoinPoint作为JoinPoint的子类，同样使用pjp.getArgs()可以获得具体的参数。
有意思的是，我们可以修改参数，并在调用方法时传入我们修改好的参数（注意，这里方法不传入参数也是可以执行的）

    @Around("pt()")public Object around(ProceedingJoinPoint pjp) throws Throwable{Object[] args = pjp.getArgs();System.out.println(Arrays.toString(args));args[0] = 666;Object ret = pjp.proceed(args);return ret;}

结果会变成：
在这里插入图片描述

获取返回值

想要获取方法的返回值，方法如下：

	@AfterReturning(value = "pt()", returning = "ret")public void afterReturning(Object ret){System.out.println("afterReturning advice ..." + ret);}

也就是在注解@AfterReturning中，除了定义value以外，还定义returning，里面的参数写的事括号里的参数，也就是告诉这个注解，将返回值放到参数ret中
执行测试方法，结果：
在这里插入图片描述
注意：如果JointPoint和Object同时作为参数时，必须将JointPoint写在第一个！

获取异常

和获取返回值类似，获取异常的方法：

    @AfterThrowing(value = "pt()", throwing = "t")public void afterThrowing(Throwable t){System.out.println("afterThrowing advice ..." + t);}

修改一下方法并测试：
在这里插入图片描述

9. AOP总结

概念： AOP(Aspect Oriented Programming)面向切面编程，是一种编程范式
作用：在不惊动原始设计的基础上为方法功能进行增强
核心概念：
在这里插入图片描述
切入点表达式：

通知类型：
在这里插入图片描述