【SSM】学习笔记（一）—— Spring入门

阅读原文时间：2023年07月09日阅读：3

原视频：https://www.bilibili.com/video/BV1Fi4y1S7ix?p=1 P1~P42

一、Spring 概述
二、Bean 相关知识
三、依赖注入
四、容器
- 4.1、知识点补充
- 4.2、总结
五、注解开发
六、Spring AOP
七、Spring 事务管理
- 7.1、Spring事务介绍
- 7.2、Spring事务属性

建议学习完maven项目结构与设计模式后学习

一、Spring 概述

Spring 技术是JavaEE开发必备技能，企业开发技术选型命中率>90%，从专业角度上来说Spring能够帮我们简化开发，减低企业级开发的复杂度，并且能高效的整合其他技术，提高企业级应用开发与一运行效率。

我们就简化开发和框架整合这两个特点我们进行学习。Spring提供了两个大的核心技术IOC、AOP，正是因为有这两个技术的存在，才能够简易开发。而在AOP思想下又衍生出了事务处理，它是Spring中的一个亮点，能让我们的事务编写更高效、更简单、并且功能更强大。

Spring 框架还整合了市面上主流的几乎所有框架，如MyBatis、MyBatis-plus等等。

Spring 这项技术自诞生就一直爆火的原因不单单是提供了几项功能，而是诞生了非常不错的设计思想，这是我们需要重点去学习的。再去学习基础操作，思考操作与设计思想间的联系。

官网：https://spring.io/

Spring 发展到今天已经形成了一种开发的生态圈，Spring 提供了若干个项目，每个项目用于完成特定的功能

SpringBoot：使用SpringBoot技术可以在Spring技术的简化开发下加速开发，能让原先的Spring开发更加的简单、书写更少的东西

Spring Cloud：分布式开发相关技术

2002年，Rod Jahnson在《Expert One-on-One J2EE Design and Development》书中首次推出了Spring框架雏形interface21框架。

并在2004年时诞生了Spring 的第一个版本，每个版本都有各自的特点

Spring 1.0 使用纯配置的形式开发的

Spring 2.0 引入了注解的功能

Spring 3.0 可以不写配置的功能

Spring 4.0 紧跟JDK的更新，对部分API做了些许调整

Spring 5.0 全面支持JDK8，所有想做Spring开发JDK版本必须得是8或以上

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基。因为5版本最新的架构图官方并没有放出，所以我们主要学的是4版本的架构图。

Spring的架构是上层依赖下层运行的

Data Access：数据访问
Data Integration：数据集成
Web：Web开发
AOP：面向切面编程
Aspects：AOP思想实现
Core Container：核心容器
Test：单元测试与集成测试

IoC（Inversion of Control）控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权转移到外部，此思想称为控制反转

Spring技术对IoC思想进行了实现

Spring 提供了一个容器，称为IoC容器，用来充当IoC思想中的“外部”。IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

DI（Dependency Injection）依赖注入

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

使用IoC容器管理bean（IoC），在IoC容器内将有依赖关系的bean进行关系绑定（DI）。这样在使用对象时不仅可以直接从IoC容器中获取，并且获取的bean已经绑定了所有的依赖关系，从而达到充分解耦的目的。

Ioc 主要是用来管理Service与Dao。通过配置文件通知被Ioc被管理的对象。被管理的对象交给Ioc容器，通过接口就能获取到Ioc容器。IoC容器得到后，再通过接口方法从容器中获取bean。使用Spring导入pox.xml坐标

实现步骤：

①：在pom.xml中导入Spring坐标

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

点击刷新后，Maven项目依赖项中出现了如图依赖性即可进行下一步

②：定义Spring管理的类（接口）

package com.itheima.dao.impl;

public interface BookDao {
    void save();
}


package com.itheima.dao.impl;

public class BookDaoImpl implements BookDao{
    @Override
    public void save() {
        System.out.println("ok,兄弟们全体目光向我看齐");
    }
}


package com.itheima.service.impl;

public interface BookService {
    void save();
}


package com.itheima.service.impl;

import com.itheima.dao.impl.BookDao;

public class BookServiceImpl implements BookService {
    BookDao bookDao = new BookDao();

    public void save() {
        System.out.println("ok，兄弟们全体目光向我看起，看我看我");
        bookDao.save();
    }
}

③：创建名为applicationContext.xml的Spring配置文件，配置对应类作为Spring管理的bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       <!--1.导入spring的坐标spring-context，对应的版本是5.2.10.RELEASE-->

       <!--2.配置bean-->
       <!--bean标签表示配置bean
       id属性表示给bean起名字
       class属性表示给bean定义类型-->
       <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

       <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"/>
</beans>

bean定义时id属性在同一个上下文中不能重复

④：初始化IoC容器（Spring核心容器/Spring容器），通过容器获取bean。创建一个新的App.Java文件

package com.itheima.dao.impl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

class APP {
    public static void main(String[] args) {
        //3.获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        //4.获取bean
        BookService bookService =(BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

单单到这，还不能称为充分解耦了，因为我们还在用new的方式创建对象。

基于IoC管理bean，通过配置的方式描述Service与Dao间的关系。service中不使用new的形式创建Dao对象。Service中需要的Dao对象通过我们提供的方法进入Service中。

实现步骤：

①：删除使用new的形式创建对象的代码，并提供了一个set方法

package com.itheima.service.impl;

import com.itheima.dao.impl.BookDao;

public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    BookDao bookDao;

    public void save() {
        System.out.println("ok，兄弟们全体目光向我看起，看我看我");
        bookDao.save();
    }

    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

②：配置service和dao之间的关系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       <!--1.导入spring的坐标spring-context，对应的版本是5.2.10.RELEASE-->

       <!--2.配置bean-->
       <!--bean标签表示配置bean
       id属性表示给bean起名字
       class属性表示给bean定义类型-->
       <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

       <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
              <!--7.配置server与dao的关系-->
              <!--property标签表示配置当前bean的属性
              name属性表示配置哪一个具体的属性
              ref属性表示参照哪一个bean-->
              <property name="bookDao" ref="bookDao"/>
       </bean>
</beans>

到这我们就完成了IoC与DI的入门，并完成了案例的解耦

二、Bean 相关知识

基础配置

而在工作中，我们常常会跟其他程序员一同完成项目，而每个人的命名习惯不同，所以就有了bean可以起多个名称。也就是bean的别名

别名配置

bean的别名在非常多的地方都可以使用，也可以在ref中充当bean的名称，但一般不建议这么写

作用范围配置

单例与非单例就是说这个对象是一个还是多个，可以看下设计模式中的单例模式的描述了解一下。

bean作用范围说明

Spring容器主要是帮我们管理可以复用的对象，比如：

表现层对象
业务层对象
数据层对象
工具对象

像有状态（记录成员变量属性）的封装实体的域对象就不适合交给容器管理。

所以bean的作用范围实际上就是控制bean创建的实例的数量的。

bean一共有以下三种实例化的方式：

构造方法（常用）
静态工厂（了解）
实例工厂（了解）
- FactoryBean（实用）

2.2.1、构造方法

对于bean来说本质上就是对象，创建bean当然也可以使用构造方法完成

无参构造方法如果不存在，将会抛出异常BeanCreationException

阅读异常小技巧

Spring 的异常报错是非常有规律的，当抛出异常信息后，直接从最下面一行开始阅读，当最下面一行问题解决了，异常也就解决了。如果没有解决就往上看，而上一行的信息其实后面往往会链着下一行的信息。

2.2.2、静态工厂

工厂说的是一种设计模式，能有效解耦。

factory-method：表示创建对象的方法

class：表示工厂类

2.2.3、实例工厂与FactoryBean

通过观察实例工厂的使用方式，我们得知想要使用工厂，必须先创建工厂类的实例化对象。

所以需要先配置工厂对象的bean，再然后配置通过工厂对象创建的对象的bean。

但仔细观察，第一个除了用来被bean指定factory-bean属性外好像并没有任何用处，非常多余。

而且factory-method方法名不同每次需要配置，对此Spring对这两个缺点进行了改良。

Spring 为我们提供了一个 FactoryBean接口，泛型中指定的是工厂创建的对象。实例化接口，getObject返回值为对象实例。getObjectType()返回值为FactoryBean中指定的泛型的字节码。

这样创建出来的对象是一个单例对象，当然我们可以通过重写isSingleton()方法，将返回值改为true就能创建非单例对象。

生命周期表示从创建到消亡的完整过程。bean生命周期指bean从创建到销毁的整体过程。bean生命周期控制指的是在bean创建后到销毁前做一些事情。

而Spring也给我们提供了两种控制生命周期的方案：

1)：配置控制

2）：接口控制（了解即可）

bean的生命周期

初始化容器

1）创建对象（内存分配）

2）执行构造方法

3）执行属性注入（set操作）

4）执行bean初始化方法
使用bean
关闭/销毁容器

三、依赖注入方式

向一个类中传递数据有普通方法（set）与构造方法。依赖注入描述了容器中建立bean与bean之间依赖关系的过程，如果bean运行需要数字或字符串，就需要区分引用类型与简单类型（基本数据类型与String）

依赖注入的方式一共有两种

setter注入
构造器注入

它们之间又有简单类型与引用类型之分

引用类型

简单类型

引用类型（了解即可）

简单类型（了解即可）

参数适配（了解即可）

依赖注入方式选择

Ioc容器根据bean所依赖的资源在容器中自动查找并注入到bean的过程称为自动装配

自动装配的方式

按类型（常用）byType
按名称 byName
按构造方法
不启用自动装配

依赖自动装配特征

自动装配用于引用类型依赖注入，不能对简单类型进行操作
使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
使用按名称装配时（byName）必须保证容器中具有指定名称的 bean，因变量名与配置耦合，不推荐使用
自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

只需要了解注入的格式即可，格式其实还是setter注入的格式

注入数组对象

100 200 300
注入List对象（重点）

a b c
注入List对象（重点）

a b c
注入set对象

a b c
注入Map对象（重点)
注入Properties对象

china henan kaifeng

在开发的过程中，我们并不一定都是管理自己写的bean，有时还要管理同事写的或是第三发引入的bean。我们需要学会如何自行判断使用何种注入方式以及配置bean。

原视频讲解链接：https://www.bilibili.com/video/BV1Fi4y1S7ix?p=17&vd_source=8ae265768486246506e74053a00b60db

我们知道在开发中我们不一定会将对象值写死，尤其是用户名密码，更多的我们会放在properties文件中。spring也提供了我们加载properties文件的方法。

纯记忆，只需要记住是这么写的就行。并且还有一些格式上的去呗

四、容器

创建容器

获取bean

类层次结构

容器每当发现需要增加新的功能时，就会增加一个子接口来丰富容器内容，这样的设计思想也是值得我们学习的

BeanFactory初始化

容器相关

bean相关

依赖注入相关

五、注解开发

为了发挥Spring的强项，简化开发，从Spring 2.0开始，Spring 逐步提供了各种各样的注解

使用 @Component("组件名称") 定义bean

package com.itheima.dao.Impl;

import com.itheima.dao.BookDao;
import org.springframework.stereotype.Component;

@Component("bookDao")
public class BookDaoImpl implements BookDao {

    public void save(){
        System.out.println("book dao save...");
    }
}

核心配置文件中通过<context:component-scan base-package="被扫描类的位置"/>组件扫描加载bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.itheima.dao.Impl"/>

</beans>

为了方便我们开发理解，Spring提供@Component注解的三个衍生注解

@Controller：用于表现层bean定义
@Service：用于业务层bean定义
@Repository：用于数据层bean定义

这些衍生的注解与Component功能性是一样的，只是为了我们方便开发。

Spring3.0升级了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

只需要下面两个注解，java类代替了原来的Spring核心配置文件

@Configuration
@ComponentScan("包名")
public class SpringConfig{
}

@Configuration注解用于设定当前类为配置类
@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

@ComponentScan({"com.service","com.dao"})

读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

//加载配置文件初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

使用@Scope定义bean作用范围，与上面一样singleton为单例（默认），而prototype为非单例

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
}

使用@PostConstruct、@PreDestroy定义bean生命周期

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {

    public BookDaoImpl(){
        System.out.println("book dao constructor ...");
    }

    @PostConstruct
    public void init(){
        System.out.println("book init ...");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("book destroy ...");
    }
}

使用@Autowired注解开启自动装配模式（按类型）

@Service
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bookDao;
```
public void save() {
    System.out.println("book service save ...");
    bookDao.save();
}
```
}

注意：自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法

注意：自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，请提供唯一的构造方法

如果想要指定加载某一个bean，使用@Qualifier注解开启指定名称装配bean

@Service
public class BookService implements BookService {
@Autowired
@Qualifier("bookDao")
private BookDao bookDao;
}

注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用

如果想要加载简单类型的bean，使用@Value注解

@Repositroy("bookDao")
public class BookDaoImpl implements BookDao {
@Value("100")
private String connectionNum;
}
使用@PropertySource 注解加载properties文件

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
public class SpringConfig {
}

注意：路径仅支持单一文件配置，多文件请使用数组格式配置，不允许使用通配符*

使用@Bean配置第三方bean

@Configuration
public class SpringConfig{

    //1.定义一个方法获得要管理的对象
    //2.添加@Bean，表示当前方法的返回值是一个bean
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

使用独立的配置类管理第三方bean，将独立的配置类加入核心配置

@Configuration
public class JdbcConfig{
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

方式一：导入式

public class JdbcConfig {
@bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
//相关配置
return ds;
}
}

使用@Import注解手动加入配置类到核心配置，此注解只能添加一次，多个数据请用数组格式

@Configuration
@Import(JdbcConfig.class)
public class SpringConfig{
}

方式二：扫描式

@Configuration
public class JdbcConfig {
@Bean
public DataSource dataSource() {
DruidDataSource ds = new DruidDataSource();
```
   //相关配置
   return ds;
```
}
}

使用@ComponentScan注解扫描配置类所在的包，加载对应配置类信息

@Configuration
@ComponentScan({"com.itheima.config","com.itheima.service","com.itheima.dao"})
public class SpringConfig{
}

由于第二种方式的隐藏性太强，我们常常找不到哪个用的哪个，所以不推荐使用

假如第三方bean需要依赖其他的bean时

简单类型依赖注入：使用成员变量

引用类型依赖注入：使用方法形参

引用类型注入只需要为bean定义方法去设置形参即可，容器会根据类型自动装配对象

首先需要在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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>//spring核心
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>//数据源
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>//mybatis
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>//mysql
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>//新：spring整合mybatis引入的jdbc包
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>//新：配合spring整合mybatis的包，它是由mybatis提供的
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

    </dependencies>
</project>

将之前mybatis的配置文件替换成spring整合的，其实这个文件就可以删掉了。

但删掉归删掉，文件里面的配置还是需要有相对应的配置来转化

对于原来的映射配置的读取，也转换成一个bean

首先需要引入两个新包，与上面一样，一个是Spring整合Junit的包，一个是配合Spring整合的包

<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
   <scope>test</scope>
</dependency>

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-test</artifactId>
   <version>5.2.10.PELEASE</version>
</dependency>

测试用例一般测试的是业务层，所以代码要写在Service业务层

六、Spring AOP

AOP（Aspect Oriented Programming）面向切面编程，一种编程范式，指导开发者如何组织程序结构。经常被人提起的还有OOP（Object Oriented Programming）面向对象编程，它们都是一种编程思想。

AOP的作用：在不惊动原始设计的基础上为其进行功能增强

在图中蓝色区域是一模一样的，属于共性功能，一般被称为通知，将其包装到新的类中，一般称这个类为通知类。而浅红色区域都可以被追加功能，我们称其为连接点。被追加功能的连接点，需要给它定义一个切入点，切入点说明了哪些连接点需要被添加新的功能。而切面描述的是通知的共性功能与切入点的关系，有了这个关系就知道各个方法追加的功能。

连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
- 在SpringAOP中，理解为方法的执行
切入点(Pointcut)：匹配连接点的式子
- 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
  - 一个具体方法：com.itheima.dao包下的BookDao接口的无形参无返回值的save方法
  - 匹配多个方法：所有的save方法，所有的get开头的方法，所有Dao结尾的接口的任意方法，所有带有一个参数的方法
通知(Advice)：在切入点处执行的操作，也就是共性功能
- 在SpringAOP中，功能最终以方法的形式呈现
通知类：定义通知的类
切面(Aspect)：描述通知与切入点的对应关系

AOP入门案例

案例设计：在接口执行前输出当前系统时间。

开发模式：XML or 注解。

思路分析：

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

首先在BookDaoImpl类中，写好了save和updata两个方法

package com.itheima.dao.Impl;

import com.itheima.dao.BookDao;
import org.springframework.stereotype.Component;

@Component("bookDao")
public class BookDaoImpl implements BookDao {

    public void save(){
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save...");
    }

    public void updata(){
        System.out.println("book dao updata ...");
    }
}

SpringConfig类中简单配置一下

package com.itheima.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}

APP类中加载Bean，运行执行save方法时会输出一次当前系统时间，而执行updata并不会

package com.itheima;

import com.itheima.config.SpringConfig;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args){
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.save();
    }
}

要求在不改变BookDaoImpl中的代码，让我们在执行updata方法时也打印一次当前系统

接着按照上面拟定的顺序来开始编写

1.导入坐标

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

2.定义接口与实现类

public interface BookDao {
    public void save();
    public void updata();
}


@Repository
public class BookDaoImpl implements BookDao {
    public void save(){
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save...");
    }
    public void updata(){
        System.out.println("book dao updata ...");
    }
}

3.定义通知类，制作通知

public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

4.定义切入点

public class MyAdvice {
    @Pointcut("executtion(void com.itheima.dao.BookDao.update()")
    private void pt(){}
}

说明：切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑

5.绑定切入点与通知的关系（切面），并指定通知添加到原始连接点的具体执行位置

public class MyAdvice {
    @Pointcut("executtion(void com.itheima.dao.BookDao.update()")
    private void pt(){}

    @Before("pt()")
    public void defore(){
        System.out.println(System.currentTimeMillis());
    }
}

6.定义通知类受Spring容器管理，并定义当前类为切面类

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

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

7.开启Spring对AOP注解驱动支持

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

AOP 工作流程

Spring容器启动
读取所有切面配置中的切入点
初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
- 匹配失败，创建对象
- 匹配成功，创建原始对象（目标对象）的代理对象
获取bean执行方法
- 获取bean，调用方法并执行，完成操作
- 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

AOP核心概念

目标对象（Target）：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
代理（Proxy）：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

SpringAOP本质就是代理模式

切入点：要进行增强的方法

切入点表达式：要进行增强的方法的描述方式

描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

execution(void com.itheima.dao.BookDao.update())

描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法

execution(void com.itheima.dao.impl.BookDaoImpl.update())

因为是面向接口编程，实际上最后运行的还是实现类，所以这两种描述方式都可以

切入点表达式标准格式：动作关键字（访问修饰符返回值包名.类/接口名.方法名(参数)异常名）

execution(public User com.itheima.service.UserService.findById(int))

动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
访问修饰符：public private等，可以省略
返回值
包名
类/接口名
方法名
参数
异常名：方法定义中抛出指定异常，可以省略

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

*：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

execution (public * com.itheima..UserService.find (*))

匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

..：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

execution (public User com..UserService.findById (..))

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

+：专用于匹配子类类型

execution(* ..Service+.*(..))

书写技巧

所有代码按照标准规范开发，否则以下技巧全部失效
描述切入点通常描述接口，而不描述实现类
访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
返回值类型对于增删改查类使用精准类型加速匹配，对于查询类使用*通配符快速描述
包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
方法名书写以动词进行精准匹配，名词采用匹配，例如getById书写成getBy，selectAll书写成selectAll
参数规则较为复杂，根据业务方法灵活调整
通常不使用异常作为匹配规则

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理位置

AOP通知共分为5种类型，作用都是设置当前通知方法与切入点之间的绑定关系

前置通知：当前通知方法在原始切入点方法前运行

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

运行结果

before advice...
//原始切入点方法

后置通知：当前通知方法在原始切入点方法后运行

@After("pt()")
public void after(){
System.out.println("after adivce…")
}

运行结果

//原始切入点方法
before advice...

环绕通知（重点，常用）：当前通知方法在原始切入点方法前后运行。可以模拟出其他几种通知类型

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("around before advice …");
Object ret = pjp.proceed();
System.out.println("around after advice …");
return ret;
}

注意实现

环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
对原始方法的调用可以不接受返回值，通过方法设置void即可，如果接收返回值，必须设定Object类型
原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object
由于无法预知原始方法运行后是否会抛出异常，因此通知方法必须抛出Throwable对象

返回后通知（了解）：当前通知方法在原始切入点方法正常执行完毕后与运行

@AfterReturning("pt()")
public void afterReturning() {
System.out.println("afterReturning advice …");
}
抛出异常后通知（了解）

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

五种通知类型都有相关属性：value（默认）切入点方法名，格式为类名.方法名()

案例：测量业务层接口万次执行效率

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

分析：

业务功能：业务层接口执行前后分别记录时间，求差值得到执行效率
通知类型选择前后均可以增强的类型————环绕通知

核心代码：

@Around("ProjectAdvice.servicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
    long start = System.currenTimeMillis();
    for (int i = 0; i < 10000; i++) {
       pjp.proceed();
    }
    long end = System.currentTimeMillis();
    System.out.println("业务层接口万次执行时间："+(end-start)+"ms");
}

但我们敲完运行后发现，结果确实可以测得切入点方法执行效率。但并不能区分执行的是哪个方法，需要做些修改

@Around("ProjectAdvice.servicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
    //获取执行签名信息
    Signature signature = pjp.getSignature();
    //通过签名获取执行类型（接口名）
    String className = signature.getDeclaringTypeName();
    //通过签名获取执行操作名称（方法名）
    String methodName = signature.getName();
    long start = System.currenTimeMillis();
    for (int i = 0; i < 10000; i++) {
       pjp.proceed();
    }
    long end = System.currentTimeMillis();
    System.out.println("万次执行时间："+className + "." + methodName + "---->" (end-start)+"ms");
}

获取方法数据的前提是获取的数据存在：如获取切入点方法的返回值，但方法使用的是前置通知，没有返回值，就不能获取。

获取切入点方法的数据有三种：

获取参数

JoinPoint：适用于前置、后置、返回后、抛出异常后通知

JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

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

ProceedJoinPoint：适用于环绕通知

ProceedJoinPoint是JoinPoint的子类

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

获取返回值

返回后通知

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对于的异常对象

@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) {
System.out.println("afterReturning advice …"+ret);
}
环绕通知

环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object ret = pjp.proceed();
return ret;
}

获取异常(了解)

抛出异常后通知

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对于的异常对象

@AfterReturning(value = "pt()",throwing = "t")
public void afterReturning(Throwable t) {
System.out.println("afterReturning advice …"+t);
}
环绕通知

抛出异常通知后可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) {
Object ret = null;
try {
ret = pjp.proceed();
} catch (Throwable t) {
t.printStackTrace();
}
return ret;
}

七、Spring事务管理

事务的作用：在数据层保障一系列的数据库操作同成功同失败

Spring事务的作用：在数据层或业务层保障一系列的数据库操作同成功同失败

案例：银行账户转账

模拟银行账户间转账业务，A账户减钱，B账户加钱

分析：

①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）

②：业务层提供转账操作（transfer），调用减钱与加钱的操作

③：提供2个账号和操作金额执行转账操作

④：基于Spring整合MyBatis环境搭建上述操作

首先数据库中就是Tom和Jerry两个账户的金额

业务层接口

public interface AccountService {
    /**
      * 转账操作
      * @parom out 传出方
      * @parom in 引入方
      * @parom money 金额
      */
    public void transfer(String out,String in,String money);
}

数据层接口

public interface AccountDao {
    //进钱操作
    @Update("updata tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name,@Param("money") Double money);

    //出钱操作
    @Update("updata tbl_account set money = money 1 #{money} where name = #{name}")
    void outMoney(@Param("name") String name,@Param("money") Double money);
}

业务层实现类

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    //调用进钱和出钱的操作
    public void transfer(String out,String in,Double money) {
        accountDao.outMoney(out,money);
        accountDao.inMoney(in,money);
    }
}

测试用例

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D )
    }
}

调用测试用例后查看数据库数据，转账操作完成。

现在在业务层转账功能中间加上一段代码，模拟系统出现异常。

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    //调用进钱和出钱的操作
    public void transfer(String out,String in,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }
}

程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

Spring事务就是为了防止此类事件的发生，成则共成，败则同败。

Spring事务开启方法

①：在业务层接口上添加Spring事务管理

public interface AccountService {
    @Transactional
    public void transfer(String out,String in,Double money);
}

Spring注解式事务通知添加在业务层接口中而不会添加到业务层实现类中，降低耦合。

注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务

②：设定事务管理器

@Bean
Public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSoureTransactionManager ptm = new DataSourceTransactionManager();
    ptm.setDataSource(dataSource);
    return ptm;
}

事务管理器要根据实现技术进行选择

Mybatis框架使用的是JDBC事务

③：开启注解式事务驱动

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

Spring事务角色

在上述案例中的加钱和减钱操作其实也开启了事务

如果发生异常事务T1回滚了，事务T2并不会受到影响。

Spring事务是这样做的，业务层中的transfer开启了事务T，而事务T中又包含了T1、T2的方法，Spring干脆让T1、T2加入到T事务中，这样就只有一个事务了，发生异常后只需回滚T事务就能保证T1、T2同成功同失败。

这里的事务T就是我们的事务管理员，而T1、T2则是事务协调员。

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

事务相关配置

其中rollbackFor比较重要，它是用来设置事务回滚异常的。

在事务回滚异常中，遇到编译时异常就不会回滚，比如IOException。

public interface AccountService {
    @Transactional(rollbackFor = {IOException.class})
    public void transfer(String out,String in,Double money) throws IOException;
}

对事务进行rollbackFor配置后就可以回滚了

接着对上一个案例进行一点扩展

案例：转账业务追加日志

需求：实现任意两个账户转账操作，并对每次转账操作在数据库进行留痕

需求微缩：A账户减钱，B账户加钱，数据库记录日志

分析：

①：基于转账操作案例添加日志模块，实现数据库中记录日志

②：业务层转账操作（transfer），调用减钱、加载与记录日志功能

实现效果预期：

无论转账是否成功，均进行转账操作的日志留痕

在之前的代码中加入了新的事务T3，写完后运行会发现三个事务同成功同失败，因为它们都加入了事务T中

这就是上面说的事务管理员和事务协调员的工作，现在我们想要的是让log留痕操作开启新的事务。

实现：在业务层接口上添加Spring事务，设置事务传播行为REQUIRES_NEW(需要新事务)

@Service
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    @Transactional(propagation = PropagationREQUIRES_NEW)
    public void log(String out,String in,Double money){
        logDao.log("转账操作由"+out+"到"+in+",金额"+money);
    }
}

事务传播行为