Spring 实践指南

格里菲斯~

已于 2023-12-23 11:18:16 修改

阅读量929

点赞数 22

分类专栏： JAVA 文章标签：学习 spring wpf

于 2023-12-08 11:02:56 首次发布

本文链接：https://blog.csdn.net/qq_62368250/article/details/134872525

版权

JAVA 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.Spring简介

「Spring」是指整个 Spring Framework 生态系统，而「Spring Framework」则是指 Spring 框架本身

1.为什么学？学什么？

（1）为什么学？

Spring 技术是 JavaEE 开发必备技能，企业开发技术选型命中率 >90%

简化开发：降低企业级开发的复杂性
框架整合：高效整合其他技术，提高企业级应用开发与运行效率

（2）学什么？

简化开发：
- IOC:控制反转
- AOP:面向切面编程
  - 事务处理
框架整合：MyBatis Junit

2.Spring家族

官网地址：https://spring.io/

Spring 发展到今天已经形成了一种开发的生态圈， Spring 提供了若干个项目，每个项目用于完成特定的功能，例如：web项目，微服务，分布式

在这里插入图片描述

Spring Framework：Spring框架是一个轻量级的框架，其核心原则是面向接口编程和控制反转（IoC），是Spring开发的基础架构，经常简称为Spring。
Spring Boot：Spring Boot 通过简化配置、提供开箱即用的功能和自动化配置，显著简化了基于 Spring 的应用程序的开发和部署流程，作用：简化Spring framework的开发，增加开发速度。
**Spring Cloud：**Spring Cloud 是一个用于构建分布式系统和微服务架构的开源框架集合。它基于Spring Framework，作用：并提供了一套完善的分布式系统解决方案。

总的来说Spring：基础架构，spring Boot：简化开发，spring Cloud 分布式微服务

3.Spring发展史

在这里插入图片描述

2002年：Spring 1.0
Spring Framework 1.0 是Rod Johnson于2002年首次发布的。它引入了依赖注入（DI）和面向切面编程（AOP）的概念，大大简化了企业应用程序的开发。
2004年：Spring 1.2
Spring Framework 1.2 引入了对AspectJ的支持，同时加入了许多新特性，如 JdbcTemplate、JMS、JMX 等。基于配置的开发
2006年：Spring 2.0
Spring Framework 2.0 强化了对依赖注入、AOP和简化了对J2EE的集成。此外，它还引入了**基于注解的配置，简化了配置工作，**并提供了更加方便的开发体验。
2009年：Spring 3.0
Spring Framework 3.0 引入了许多新特性，包括对RESTful的支持、对Java 5的完全支持、IoC容器的改进以及对AspectJ的整合等，不用配置的开发。
2013年：Spring 3.2
进一步加强对Java 7和Java EE 6的支持，优化了对REST的支持以及缓存抽象化等。
2014年：Spring 4.0
Spring Framework 4.0 引入了对Java 8的支持，整合了很多新特性，包括对泛型的支持、条件化的配置、WebSockets、对注解的扩展等。
2018年：Spring 5.0
Spring Framework 5.0 版本引入了对响应式编程的支持，提供了一系列新的特性以支持响应式应用的开发，同时对现有的功能进行了升级和优化。

4.Spring Framework系统架构

在这里插入图片描述
因为4.x已经趋于稳定，所以我们要学习的就是4.x

核心容器（Core Container）：
核心容器是 Spring Framework 的基础，包含了许多核心模块，如控制反转（IoC）和依赖注入（DI），用于管理应用程序中的对象和它们之间的依赖关系。核心容器包括BeanFactory、Application Context和BeanDefinition等组件。
数据访问与集成（Data Access/Integration）：
数据访问与集成模块提供了对数据访问和持久化的支持，包括 JDBC、ORM（如 Hibernate、MyBatis）、事务管理等。此外，Spring Framework 还提供了许多集成模块，用于与其他数据源、消息队列、缓存等进行集成。
Web（Web）：
Spring Framework 提供了一系列Web相关的功能和组件，如Web MVC、WebSocket、RESTful Web Services 等，用于构建可扩展、灵活和高性能的Web应用程序。
AOP（Aspect-Oriented Programming）：
面向切面编程模块提供了将横切关注点（如日志、事务、安全性等）从核心业务逻辑中分离出来的能力。AOP是在不改变旧功能的情况下加入新概念的一种编程思想，Spring的AOP在某些方面可能相对有限。Aspects是实现 AOP (Aspect-Oriented Programming) 的一种方式，它提供了更强大和灵活的功能。
测试（Testing）：
Spring Framework 提供了一套完整的测试支持，包括集成测试、单元测试、模拟对象等。它的测试模块可以帮助开发人员编写可测试、可维护和可扩展的代码。

二.Spring核心容器

1.Spring核心概念

（1）目前代码存在问题

在这里插入图片描述

代码书写现状—耦合度偏高

内聚：是指程序内各个模块之间的紧密程度
耦合：是指各个外部程序之间的紧密程序

在Spring核心容器中的提供了解决方案IOC设计原则（思想）

使用对象时，在程序中不要主动使用new产生对象，转换为由==外部==提供对象

就是在不重新创建另外一个service服务类的情况下,BookDaoImp1与BookDaoImp2，两者的耦合度太高，调这个就不能调那个，所以就出现了控制反转这个东西，不new了直接从外部传过来对象，直接通过声明接口再接收实现类Bean对象就完了。

无论是直接修改代码还是使用依赖注入的方式来替换对象实现，都需要重新编译、打包和部署应用程序才能生效。但是，依赖注入可以让应用程序更加可扩展和易于维护。通过依赖注入，我们可以独立地开发和测试每个组件，而不必把所有代码放在一起进行开发和测试。这使得应用程序更加模块化，并且可以更容易地进行单元测试和集成测试，减少了开发人员的工作量和时间。

（2）什么是IOC，什么是DI？

IOC（Inversion of Control）控制反转
- 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是“将new对象的权利交给Spring，我们从Spring中获取对象使用即可”
Spring技术对IoC思想进行了实现
- Spring提供了一个容器，称为IOC容器，用来充当IoC思想中的“外部”
- IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean
DI（Dependency Injection）依赖注入
- 在容器中可能会有依赖关系，将这些Bean对象导入到容器以后，建立Bean与Bean之间的依赖关系的整个过程，称为依赖注入，它是一种软件设计模式和开发技术。
- 依赖注入（DI）通过构造函数注入、属性注入或接口注入的方式，将对象的依赖关系由外部容器来管理和注入。这种方式实现了控制反转（IoC）的原则，将对象的创建和依赖关系的管理权限交给外部容器，提高了代码的灵活性、可读性和可测试性。

在这里插入图片描述

目标：充分解耦
- 使用IoC容器管理bean（IOC)
- 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
最终效果
- 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

2.IOC入门案例思路分析✨

管理什么？(Service与Dao)
如何将被管理的对象告知IOC容器？(配置文件)
被管理的对象交给IOC容器，如何获取到IoC容器？(接口)
IOC容器得到后，如何从容器中获取bean？(接口方法)
使用Spring导入哪些坐标？(pom.xml)

(1)实现步骤

【第一步】导入Spring坐标
【第二步】定义Spring管理的类（接口）
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象

(2) 实现代码

【第一步】导入Spring坐标

<dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

【第二步】定义Spring管理的类（接口）

BookDao接口和BookDaoImpl实现类

public interface BookDao {
    public void save();
}

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

BookService接口和BookServiceImpl实现类

public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象

定义applicationContext.xml配置文件并配置BookServiceImpl

<?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">

    <!--
		bean标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookDao" class="com.itheima.dao.imp1.BookDaoImp1"></bean>
    <bean id="bookService" class="com.itheima.service.imp1.BookServiceimp1"></bean>

</beans>

注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复

【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class APP {
    public static void main(String[] args) {
        //1.创建IoC容器,加载spring核心配置文件
        ApplicationContext cxt = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        //2.从IOC容器中获取Bean对象(Bookservice对象)
        BookService bookService = (BookService) cxt.getBean("bookService");
        //3.调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}

(3) 运行结果

在这里插入图片描述

最终实现了从Spring（外部）中传入Bookserviceimp1对象，但是没有进行依赖注入，所以仍要在Bookserviceimp1中new BookDaoimp1对象，接下来我们引入DI，去解决这个数据层的问题

3.DI入门

基于IOC管理bean（上文）
Service中使用new形式创建的Dao对象是否保留？(否)
Service中需要的Dao对象如何进入到Service中？(提供方法)
Service与Dao间的关系如何描述？(配置)

（1）实现步骤

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系

（2）代码实现

【第一步】删除使用new的形式创建对象的代码

public class BookServiceimp1 implements BookService {
    private BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
}

【第二步】提供依赖对象对应的setter方法

public class BookServiceimp1 implements BookService {
    private BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

【第三步】配置service与dao之间的关系

在applicationContext.xml中配置

<?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">

    <!--
		bean标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookDao" class="com.itheima.dao.imp1.BookDaoImp1"></bean>
    <bean id="bookService" class="com.itheima.service.imp1.BookServiceimp1">
        <!--配置server与dao的关系
			property标签：表示配置当前bean的属性
        	name属性：表示配置哪一个具体的setter方法 就是去掉set首字母小写后剩下的
        	ref属性：表示参照哪一个bean的id
		-->
        <property name="bookDao" ref="bookDao"></property>
    </bean>

</beans>

执行顺序可以进一步澄清如下：
1. Spring 容器启动时，开始解析配置文件。
2. 当解析到 <bean> 标签定义的 bookDao Bean 时，会创建 bookDao 的实例。
3. 接着解析 <bean> 标签定义的 bookService Bean。在创建 bookService 的实例时，Spring 发现 bookService 类中定义了一个名为 bookDao 的属性，因此会调用 bookService 的 setBookDao() 方法。
4. 在调用 setBookDao() 方法时，Spring 将之前创建的 bookDao 实例作为参数传入，完成属性的注入。
怎么识别的setter方法就是你要的setter呢？

Spring会查找对象中所有公开（public）的方法，作为潜在的setter方法。
对于每个潜在的setter方法，Spring会判断方法名是否以set开头，并且方法名后面跟着与name参数名相匹配的单词，set后面第一个单词得大写然后在name参数中填小写。
如果匹配成功，Spring会将该方法视为属性的setter方法，用于进行依赖注入。

（3）图解演示

在这里插入图片描述

4.Bean对象详解

（1）Bean的配置

A.基础配置

在这里插入图片描述

B.别名配置

在这里插入图片描述

依赖注入也能被别名影响

在依赖注入容器中，别名的作用是指定依赖项的标识符。当需要解析依赖项时，容器可以使用别名来定位并注入正确的依赖项实例。

在底层，依赖注入容器通常会维护一个依赖项注册表，其中包含依赖项类型与实例之间的映射关系。当我们使用别名配置依赖项时，实际上是在注册表中指定了该别名与特定依赖项类型之间的关联。

C.Bean作用范围配置

在这里插入图片描述

默认为单例模式，扩展：scope的取值不仅仅只有singleton和prototype，还有request、session、application、 websocket ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。
在我们的实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性，那为什么绝大多数是单例的呢？

单例模式的作用：

资源节约：单例模式可以确保在系统中只存在一个对象实例，避免了重复创建和销毁对象的开销，节约了系统资源和内存空间。
状态一致性：单例模式能够确保所有的操作都在同一个对象实例上进行，避免了多个对象实例之间状态不一致的可能性，保证了数据的一致性。
交互和共享数据方便：由于单例对象的唯一性，不同模块之间可以方便地共享数据和进行交互，简化了模块之间的调用和通信。
管理和维护简单：由于只有一个实例存在，管理和维护变得更加容易。在整个系统中，只需关注单例对象的创建、初始化和销毁等生命周期管理即可。

（2）Bean实例化

方式一：构造方式实现

Bean的是由默认空参数构造器构造的：

BookDaoImpl实现类

public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}

applicationContext.xml配置

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

AppForInstanceBook测试类

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
    }
}

运行结果

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

另外：在找错误的时候自下而上的

方式二：静态工厂方式

OrderDao接口和OrderDaoImpl实现类

public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}

OrderDaoFatory工厂类

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}

applicationContext.xml配置

<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

在这里插入图片描述

AppForInstanceOrder测试类

public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}

运行结果

方式三：实例工厂方式

UserDao接口和UserDaoImpl实现类

public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}

UserDaoFactory工厂类

//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

applicationContext.xml配置

<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

在这里插入图片描述

AppForInstanceUser测试类

public class AppForInstanceUser {
    public static void main(String[] args) {
        //在没有修改前
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

运行结果

方式四：实例工厂：实现FactoryBean<T>方式【扩展,了解】

定义UserDaoFactoryBean实现FactoryBean<UserDao>

UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    /*
    在 Spring 容器中，保存 Bean 的时候，它会先根据 getObjectType() 方法所返回的类型来先保存 Bean，这样就保证了从容器中根据 Bean 的类型获取对象时不会出错。如果不重写 getObjectType 方法，则Spring将无法确定创建的对象类型，需要通过显式配置Bean的类型来完成。
    就是先创建这种类型预先存在容器中，你看其他的创建方式都是预先创建这种类型的对象的哦~，等要用的时候再再IOC容器中取
    */
    public Class<?> getObjectType() {
        return UserDao.class;
    }
    
    public boolean isSingleton(){
        return false//false 为非单例模式 true 为单例 默认不写就是单例 
    }
    
}

applicationContext.xml配置

<!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复。

如果对象是根据getObject方法去创建的，那么这不就意味着只能创建那个UserDaoImp1对象了吗？

说法错误，getObject()方法内的默认实现返回的是一个UserDaoImpl实例，意味着该工厂默认只能创建UserDaoImpl类型的对象。

但这并不意味着该工厂只能创建这个对象，你可以根据实际需求在getObject()方法内进行逻辑判断和处理，来返回不同的对象实例

*举个例子：*假设你有一个UserDaoFactoryBean工厂类，用于创建UserDao对象，但根据不同的环境（比如开发环境和生产环境），你想要创建不同类型的UserDao实现类。

你可以在getObject()方法内根据环境条件来创建不同的对象，如下所示：

public UserDao getObject() throws Exception {
    if (isDevelopmentEnvironment()) {
        return new UserDaoImplForDevelopment();
    } else {
        return new UserDaoImplForProduction();
    }
}

（3）Bean生命周期控制

3.1.在配置中自定义初始化方法，自定义销毁方法

提供生命周期控制方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}

applicationContext.xml配置

<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

测试类

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        ctx.registerShutdownHook();
        //关闭容器
        //ctx.close();
    }
}

对于主动销毁容器的操作有两种：（容器关闭前触发bean的销毁）

手工关闭容器
ConfigurableApplicationContext接口close()操作
注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机，在任意位置注册
ConfigurableApplicationContext接口registerShutdownHook()操作

3.2.实现接口去定义初始化方法，定义销毁方法

实现InitializingBean, DisposableBean接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
    //这个是初始化的方法，在set之后的意思,确保能调用set后的参数
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

5.注入

（1）依赖注入方式及注入类型

setter注入
- 引用类型
- 简单类型
构造器注入
- 引用类型
- 简单类型

1.1.setter注入

1.1.1.引用类型

在这里插入图片描述

前文用的就是setter注入引用类型,比较常用

applicationContext.xml配置文件

 <bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
            <property name="DaoImp1" ref="DaoImp1"></property>
 </bean>

ServiceImp1

	private dao Dao;
    public void setDaoImp1(dao dao) {
        Dao = dao;
    }

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

1.1.2.简单类型

在这里插入图片描述

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
            <property name="connectionNum" value="3"></property>
</bean>

ServiceImp1

	private int connectionNum;
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

结果：

在这里插入图片描述

1.2.构造器注入

1.2.1.引用类型

在这里插入图片描述

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
            <constructor-arg name="dao" ref="DaoImp1"></constructor-arg>
</bean>
    //在name里面传的是形参名字，有耦合性，那边改这边就得改

ServiceImp1

	private dao dao;
    public ServiceImp1(dao dao) {
        this.dao = dao;
    }

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

1.2.2.简单类型

在这里插入图片描述

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
            <constructor-arg name="connectionNum" value="3"></constructor-arg>   
</bean>
//在name里面传的是形参名字，有耦合性，那边改这边就得改

ServiceImp1

    private int connectionNum;
    public ServiceImp1(int connectionNum) {
        this.connectionNum = connectionNum;
    }

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

针对传递形参名字导致耦合的解决方案

在这里插入图片描述

ServiceImp1

	private dao dao;
    private int connectionNum;
    public ServiceImp1(int connectionNum,dao dao) {
        this.connectionNum = connectionNum;
        this.dao = dao;
    }

1. 使用类型进行传递

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
            <constructor-arg type="int" value="3"></constructor-arg>
            <constructor-arg type="com.itheima.dao.dao" ref="DaoImp1"></constructor-arg>
</bean>

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

缺点：如果参数里有两个类型一样的也难搞

2.使用indx进行传递

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
            <constructor-arg index="0" value="3"></constructor-arg>
            <constructor-arg index="1" ref="DaoImp1"></constructor-arg>
</bean>

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

1.3.依赖注入方式选择

强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
可选依赖使用setter注入进行，灵活性强
Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
自己开发的模块推荐使用setter注入

（2）自动装配

概念：IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配，基本数据类型不可装配

方式：1.按类型（常用），2.按名称，3.按构造方法，4.不启用自动装配

仅介绍按类型与按名称

2.1.按类型

必须要有setter，是在配置文件中找实现类class，不加id也能运行

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1" autowire="byType"/>
<bean id="DaoImp1" class="com.itheima.dao.imp.DaoFactoryBean"></bean>

ServiceImp1

	private dao dao;
    public void setDao(dao dao) {
        this.dao = dao;
    }

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

2.2.按名称

必须要有setter，根据id的名与set方法后面首字母小写一致才可以，有耦合不建议使用

applicationContext.xml配置文件

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1" autowire="byName"/>
<bean id="dao" class="com.itheima.dao.imp.DaoFactoryBean"></bean>
//根据id的名与set方法后面首字母小写一致才可以，有耦合不建议使用

ServiceImp1

	private dao dao;
    public void setDao(dao dao) {
        this.dao = dao;
    }

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();

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

（3）集合注入

3.1 注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

3.2 注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>

3.3 注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

3.4 注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>

3.5 注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签

applicationContext.xml配置文件

<bean id="ServiceImp2" class="com.itheima.service.ServiceImp2">
        <property name="array">
            <array>
                <value>123</value>
                <value>345</value>
                <value>567</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>123</value>
                <value>345</value>
                <value>567</value>
            </list>
        </property>

        <property name="set">
            <set>
                <value>牛</value>
                <value>牛</value>
                <value>牛</value>
            </set>
        </property>

        <property name="mp">
            <map>
                <entry key="牛" value="2"></entry>
                <entry key="牛" value="2"></entry>
                <entry key="牛" value="2"></entry>
            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="牛">2</prop>
                <prop key="牛">2</prop>
                <prop key="牛">2</prop>
            </props>
        </property>
    </bean>

ServiceImp2

public class ServiceImp2 implements service{
    private int[] array;
    private List<Integer> list;
    private Set<String> set;
    private Map<String,Integer> mp;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<Integer> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMp(Map<String, Integer> mp) {
        this.mp = mp;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save(){
        System.out.println("array:"+Arrays.toString(array));
        System.out.println("list:"+list);
        System.out.println("set:"+set);
        System.out.println("mp:"+mp);
        System.out.println("pro:"+properties);
    }
}

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp2 service = (ServiceImp2) cxt.getBean("ServiceImp2");
//3.调用bean
service.save();

结果：

在这里插入图片描述

6.案例-第三方bean

（1）德鲁伊数据库连接池

一开始找DataSource导入类
再通过ctrl+f12看是通过构造器注入还是setter注入

applicationContext.xml配置文件

 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="username" value="root"/>
        <property name="password" value="1234"/>
</bean>

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt =
   new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
DataSource dataSource = (DataSource)cxt.getBean("dataSource");
//3.使用bean
System.out.println(dataSource);

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

（2）c3p0数据库连接池

一开始找DataSource导入类
再通过ctrl+f12看是通过构造器注入还是setter注入

applicationContext.xml配置文件

<bean  class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="user" value="root"/>
        <property name="password" value="1234"/>
</bean>

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt =
   new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
DataSource dataSource = (DataSource)cxt.getBean("dataSource");
//3.使用bean
System.out.println(dataSource);

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

但是一般来说这种外部资源的导入参数都在配置properties文件中：

（3）加载properties文件

在这里插入图片描述

applicationContext.xml配置文件

<?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: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/context
       http://www.springframework.org/schema/context/spring-context.xsd
        ">

    <!--1.开启命名空间-->
    <!--2.加载properties配置文件-->
    <!--3.使用properties中的参数-->
<context:property-placeholder location="jdbc.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

properties配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db
jdbc.username=root
jdbc.password=1234

测试

//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt =
   new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
DataSource dataSource = (DataSource)cxt.getBean("dataSource");
//3.使用bean
System.out.println(dataSource);

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

这里有坑可能会有与系统相同的属性名，而系统的优先级大于配置文件导致出错，

3.1.配置不加载系统文件配置

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

3.2.如果要加载多个呢？

加载多个properties文件

<context:property-placeholder location="jdbc.properties,msg.properties"/>

加载所有properties文件

<context:property-placeholder location="*.properties"/>

加载properties文件**标准格式**

<context:property-placeholder location="classpath:*.properties"/>

加载properties文件标准格式

<context:property-placeholder location="classpath*:*.properties"/>

7.总结

（1）Spring核心容器介绍

问题导入

问题：按照Bean名称获取Bean有什么弊端，按照Bean类型获取Bean有什么弊端？

1.1.创建容器的方法

方式一：类路径加载配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

方式二：文件路径加载配置文件

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");

加载多个配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml", "bean2.xml");

1.2. 获取bean对象的方法

方式一：使用bean名称获取

弊端：需要自己强制类型转换

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

方式二：使用bean名称获取并指定类型

弊端：推荐使用

BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

方式三：使用bean类型获取

弊端：如果IOC容器中同类型的Bean对象有多个，此处获取会报错

BookDao bookDao = ctx.getBean(BookDao.class);

1.3.容器类层次结构

在这里插入图片描述

1.4. BeanFactory

类路径加载配置文件

Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao = bf.getBean("bookDao", BookDao.class);
bookDao.save();

BeanFactory创建完毕后，所有的Bean均为延迟加载，也就是说我们调用getBean()方法获取Bean对象时才创建Bean对象并返回给我们

1.5.相关

BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
ApplicationContext接口常用初始化类
- ClassPathXmlApplicationContext(常用)
- FileSystemXmlApplicationContext

（2）bean相关

在这里插入图片描述

（3）依赖注入相关

在这里插入图片描述

三.Spring注解开发

原因：xml配置Bean对象有些繁琐，使用注解简化Bean对象的定义

总的来说：

bean- --》注解表示
配置文件 —》配置类表示

1.bean-》注解表示

（1）表示方法

原：

<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1"/>

转为：

@Component("ServiceImp1")
public class ServiceImp1 implements service {
    private dao dao;
    public void setDao(dao dao) {
        this.dao = dao;
    }
    
    @Override
    public void save() {
        System.out.println("serviceimp1...");
        //System.out.println("connectionNum=="+connectionNum);
        dao.save();
    }
}

那配置文件怎么访问到呢？通过配置扫描器，扫描某个报下的所有类有没有这个注解

xml:

<?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">
	 <!--扫描com.itheima包及其子包下的类中注解-->
    <context:component-scan base-package="com.itheima"/>
</beans>

（2）增加条理性的注解

Spring提供**@Component**注解的三个衍生注解

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

2.配置文件 -》配置类表示

配置文件也好麻烦呢，去掉变成一个配置类吧

（1）表示方法

原XML文件：

<?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">
	 
</beans>

转为配置类：

@Configuration
public class SpringConfig {
}

加上扫描器注解

@Configuration
@ComponentScan("com.itheima")
//可追加@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}

3.全注解开发全貌

（1）Bean

@Component("ServiceImp1")
public class ServiceImp1 implements service {
    private dao dao;
    public void setDao(dao dao) {
        this.dao = dao;
    }
    
    @Override
    public void save() {
        System.out.println("serviceimp1...");
        //System.out.println("connectionNum=="+connectionNum);
        dao.save();
    }
}

（2）配置文件

@Configuration
@ComponentScan("com.itheima")
//可追加@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}

（3）创建容器

public class App {
    public static void main(String[] args) {
        //1.利用注解类创建ioc容器实现ioc思想
        AnnotationConfigApplicationContext cxt =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //2.创建bean
        ServiceImp1 serviceImp1 = (ServiceImp1)cxt.getBean("ServiceImp1");
        serviceImp1.save();
    }
}

4.作用范围相关注解配置

使用@Scope定义bean作用范围

@Repository
@Scope("singleton")//非单例prototype
public class BookDaoImpl implements BookDao {
}

5.生命周期相关注解配置

（1）生成@PostConstruct

@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 ...");
    }
}

（2）销毁@PreDestroy

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor ...");
    }
    
    @PreDestroy
    public void destroy(){
        System.out.println("book destory ...");
    }
}

注意：@PostConstruct和@PreDestroy注解是jdk中提供的注解，从jdk9开始，jdk中的javax.annotation包被移除了，也就是说这两个注解就用不了了，可以额外导入一下依赖解决这个问题。

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

6.依赖注入相关注解配置🧨

（1）引用类型注入@Autowired

应用 ”自动装配“ 注解去配置依赖**@Autowired注解**默认按类型

不需要构造函数的原因：
自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法。

1.1.按类型@Autowired注解

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    private BookDao bookDao;

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

说明：不管是使用配置文件还是配置类，都必须进行对应的Spring注解包扫描才可以使用。@Autowired默认按照类型自动装配，如果IOC容器中同类的Bean有多个，那么默认按照变量名和Bean的名称匹配，建议使用@Qualifier注解指定要装配的bean名称

1.2.按名称@Qualifier+@Autowired注解

解决：IOC容器中同类型Bean有多个装配哪一个的问题

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    //@Qualifier：自动装配bean时按bean名称装配
    @Qualifier("bookDao")
    private BookDao bookDao;

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

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

（2）简单类型注入@Value

2.1.直接给值

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    //@Value：注入简单类型（无需提供set方法）
    @Value("sunshuo")
    private String name;

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

2.2.配置文件给值

bean

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    //@Value：注入简单类型（无需提供set方法）
    @Value("${name}")
    private String name;

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

SpringConfig

@Configuration
@ComponentScan("com.itheima")
//@PropertySource加载properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //{}可以省略不写
public class SpringConfig {
}

注意：@PropertySource()中加载多文件请使用数组格式配置，不允许使用通配符*

7.注解管理第三方Bean

（1）Bean配置

【第一步】单独定义配置类

public class JdbcConfig {
    //@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @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;
    }
}

【第二步】将独立的配置类加入核心配置

方式1：@Import注解导入式（推荐）

@Configuration
@ComponentScan("com.itheima")
//@Import:导入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {
}

方式2：@ComponentScan扫描式（不推荐）

@Configuration
@ComponentScan({"com.itheima.config","com.itheima.service","com.itheima.dao"})  //只要com.itheima.config包扫到了就行，三个包可以合并写成com.itheima
public class SpringConfig {
}

（2）第三方Bean的依赖注入

2.1.简单类型依赖注入

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("root")
    private String password;
    //2.@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

说明：如果@Value()中使用了EL表达式读取properties属性文件中的内容，那么就需要加载properties属性文件。

2.2.引用类型依赖注入

@Bean 
public DataSource dataSource(BookDao bookDao){
    System.out.println(bookDao);
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(userName);
    ds.setPassword(password);
    return ds;
}

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

为什么第三方导入的形参能识别到该bean，流程是怎样的？

容器加载配置信息，解析并利用构造器创建对应的 Bean 定义。（所有bean都会创建）
在解析DataSource 的 Bean 的时候，发现它依赖于类型为 bookDao
容器会检查已经注册的 Bean 定义，并找到与 bookDao类型匹配的 Bean。
然后，将找到的 bookDao 自动注入到DataSource Bean 的形参中。

Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量，如果没有就会报错。

注解汇总

//@Configuration 配置xml类

//@Component:工具类
//@Controller:用于表现层bean定义
//@Service:用于业务层bean定义
//@Repository:用于数据层bean定义

//@PostConstruct:起始
//@PreDestroy:销毁

//@Scope("singleton")//非单例prototype

//@Autowired:引用类
//@Qualifier:引用id

//@Value:简单类

//@PropertySource({"classpath:jdbc.properties"}):加载prop配置

//@Bean:第三方bean导入到ioc中
//@Import:将含第三方bean的类导入到此类中

四.Spring整合框架

1.整合mybatis

（1）MyBatis程序核心对象分析

在这里插入图片描述

连接对象是由factory得到的紧接着接下来操作，所以核心对象是sqlSessionFactory对象

我们的目标就是通过spring创建此bean

（2）开始整合

前置代码

mapper

public interface BrandMapper {
    //查询所有
    @Select("select * from tb_brand")
    List<Brand> selectAll();

}

service

@Service
public class BrandService implements service{

    @Autowired
    private BrandMapper brandMapper;//(爆红正常,在创建时才能看见bean)
    @Override
    public void save() {

    }

    @Override
    public List<Brand> selectAll() {
        return brandMapper.selectAll();
    }
}

【第一步】导入Spring整合Mybatis依赖

<!--spring使用jdbc所需要的包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<!--整合-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

【第二步】创建JdbcConfig配置DataSource数据源

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

【第三步】创建MybatisConfig整合mybatis

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象，就是Mapper对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

【第四步】创建SpringConfig主配置类进行包扫描和加载其他配置类

@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

测试

public class App {
    public static void main(String[] args) {
        //1.利用注解类创建ioc容器实现ioc思想
        AnnotationConfigApplicationContext cxt =
                new AnnotationConfigApplicationContext(spring_config.class);
        //2.拿出bean
        BrandService bean = cxt.getBean(BrandService.class);
        System.out.println(bean.selectAll());

    }
}

Bean加载配置流程分析

应用启动：当应用启动时，Spring 容器会加载配置类或者配置文件，并开始创建和管理对象。
创建 SqlSessionFactoryBean：Spring 会通过 @Bean 注解标识的方法，创建一个 SqlSessionFactoryBean 对象，并将其添加到Spring容器中。
数据源注入： SqlSessionFactoryBean 需要一个数据源（DataSource）来设置数据库连接。Spring 会根据已有的数据源的配置或者创建新的数据源对象，并将其注入到 SqlSessionFactoryBean 中。
创建 SqlSessionFactory：Spring 容器会调用 SqlSessionFactoryBean 对象的方法，创建一个 SqlSessionFactory 对象。这个对象包含了 MyBatis 的配置信息和对数据库的访问能力。
创建 SqlSession：通过 SqlSessionFactory 创建一个 SqlSession 对象，用于执行数据库操作。这个 SqlSession 包含了与数据库的连接和一个完整的事务上下文。
创建 MapperScannerConfigurer：类似于 SqlSessionFactoryBean 的创建，通过 @Bean 注解创建一个 MapperScannerConfigurer 对象，并将其添加到Spring容器中。
扫描 Mapper 接口：MapperScannerConfigurer 会扫描指定的包路径下的 Mapper 接口，并将其注册为 Spring 的 bean。这样，就可以通过依赖注入的方式，在业务代码中使用 Mapper 接口。
完成初始化：经过以上步骤，Spring 容器中已经创建了 SqlSessionFactory 和 Mapper 对象，可以将其注入到业务代码中进行使用。

什么？你说看不到Sqlssion的创建和不知道mapper怎么与sqlssion产生联系的？

在使用 Spring Boot 集成 MyBatis 时，我们不需要显式地创建 SqlSession 对象，也不需要手动与 Mapper 建立联系。这是因为 Spring Boot 整合 MyBatis 的自动化配置已经帮助我们完成了这些工作。

具体来说，Spring Boot 在创建 SqlSessionFactory 对象时，会自动创建一个由 Spring 管理的 SqlSessionTemplate 对象。SqlSessionTemplate 是 SqlSession 接口的实现类，它封装了对数据库的各种操作方法。

而在 Spring Boot 创建 Mapper 接口时，会使用默认的代理方式将 Mapper 接口与 SqlSessionTemplate 进行关联。这样，当我们注入 Mapper 接口时，实际上注入的是一个代理对象，该代理对象在执行方法时会使用 SqlSessionTemplate 调用相应的数据库操作。

因此，我们不需要手动创建 SqlSession 对象，并且 Mapper 接口与 SqlSession 的关联由 Spring Boot 在背后自动完成。我们只需要在需要使用 Mapper 的地方使用 @Autowired 注解即可，Spring Boot 会负责将 Mapper 对象注入到我们的代码中，使我们可以直接调用 Mapper 的方法进行数据库操作。

（3）步骤汇总

1.导相关包

2.创建数据源，就是数据库连接池对象

返回数据源对象

3.创建MybatisConfig整合mybatis

定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
定义bean，返回MapperScannerConfigurer对象，就是Mapper对象

4.spring扫描其他配置类

@Import({JdbcConfig.class,MybatisConfig.class})
@PropertySource：加载类路径jdbc.properties文件

2.整合junit

（1）开始整合

【第一步】导入整合的依赖坐标spring-test

<!--junit-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<!--spring整合junit-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.1.9.RELEASE</version>
</dependency>

【第二步】使用Spring整合Junit专用的类加载器

【第三步】加载配置文件或者配置类

@RunWith(SpringJUnit4ClassRunner.class)//类加载器
@ContextConfiguration(classes = {spring_config.class}) //加载配置类
public class BrandService {

    @Autowired
    private BrandMapper brandMapper;

    @Test
    public void select(){
        System.out.println(brandMapper.selectAll());
    }
}
}

注意：junit的依赖至少要是4.12版本,可以是4.13等版本,否则出现如下异常：

在这里插入图片描述

实现：

在 UserServiceTest 类上使用 @RunWith(SpringJUnit4ClassRunner.class) 注解，指定使用 Spring 提供的 JUnit 运行器来运行测试类。
在 UserServiceTest 类上使用 @ContextConfiguration(classes = {spring_config.class}) 注解，指定 Spring 配置类的位置，告诉 Spring Test 加载配置类并创建 Spring 应用上下文。

（2）步骤汇总

1.导包

2.在test中新建一个测试类

3.指定使用 Spring 提供的 JUnit 运行器来运行测试类。

@RunWith(SpringJUnit4ClassRunner.class)

4.指定 Spring 配置类的位置

@ContextConfiguration(classes = {spring_config.class})

5.可以注入，然后进行使用

@Test

五.Spring AOP

1.AOP简介

（1）简介

一种编程范式，指导开发者如何组织程序结构

AOP(Aspect Oriented Programming)面向切面编程

OOP(Object Oriented Programming)面向对象编程

（2）作用

在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。

（3）Spring理念

无入侵式/无侵入式

2.AOP核心概念

在这里插入图片描述

**连接点：**正在执行的方法，例如：update()、delete()、select()等都是连接点。
切入点（Pointcut）：进行功能增强了的方法，例如:update()、delete()方法，select()方法没有被增强所以不是切入点，但是是连接点。增强是指用AOP增加了功能。

在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法

（1）一个具体方法：com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法

（2）匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法

**通知（Advice）：**在切入点前后执行的操作，也就是增强的共性功能，在SpringAOP中，功能最终以方法的形式呈现
**通知类：**通知方法所在的类叫做通知类
**切面（Aspect）：**描述通知与切入点的对应关系，也就是指定哪些通知方法对应哪些切入点方法。

3.AOP入门案例

案例设定：在接口执行前输出当前系统时间
开发模式：XML or *注解

（1）思路分析：

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

（2）案例

【第一步】导入aop相关坐标

<dependencies>
    <!--spring核心依赖，会将spring-aop传递进来-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

【第二步】定义dao接口与实现类

public interface dao {
    public void save();
    public void delet();
}

@Repository("DaoImp1")
public class DaoImp1 implements dao{
    @Override
    public void save() {
        System.out.println("DaoImp1...");
    }
    @Override
    public void delet(){
        System.out.println("delet...");
    }
}

【第三步】定义通知类，制作通知方法

//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)

@Component//实例化bean
@Aspect//设置当前类为切面类
public class MyAdvice {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.imp.DaoImp1.delet())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作(前置通知)
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

在这里插入图片描述

【第五步】在配置类中进行Spring注解包扫描和开启AOP功能

@Configuration
@ComponentScan("com.itheima")

//开启注解开发AOP功能
@EnableAspectJAutoProxy

public class SpringConfig {
}

测试类和运行结果

public class App {
    public static void main(String[] args) {
        //1.利用注解类创建ioc容器实现ioc思想
        AnnotationConfigApplicationContext cxt =
                new AnnotationConfigApplicationContext(spring_config.class);
        //2.拿出bean
        dao bean = cxt.getBean(dao.class);
        bean.delet();
        System.out.println(bean.getClass());
    }
}

在这里插入图片描述

（3）步骤汇总

1.开启注解开发AOP功能

@EnableAspectJAutoProxy

2.定义通知类，写通知方法

将此类也加入bean，@Component
告诉spring此类通知类，@Aspect

3.设置切入点

@Pointcut(“execution(void com.itheima.dao.imp.DaoImp1.delet())”)
private void pt(){}

4.绑定切入点和通知（切面）

设置在切入点pt()的前面运行当前操作(前置通知)
@Before(“pt()”)

4.AOP工作流程

（1）流程

Spring容器启动
读取所有切面配置中的切入点
初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
- 匹配失败，创建原始对象
- 匹配成功，创建原始对象（目标对象）的代理对象

在这里插入图片描述

获取bean执行方法
- 获取的bean是原始对象时，调用方法并执行，完成操作
- 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

（2）对象区别

目标对象（Target）：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
代理对象（Proxy）：代理后生成的对象，由Spring帮我们创建代理对象，也就是加上增强后的对象。

5.AOP切入点表达式

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

描述方式一：执行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())

（2）切入点表达式标准格式：

动作关键字(访问修饰符返回值包名.类/接口名.方法名(参数) 异常名）

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

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

（3）通配符

目的：可以使用通配符描述切入点，快速描述。

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

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

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

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

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

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

+：专用于匹配子类类型

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

书写技巧：

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

6.AOP切面分类

（1）AOP通知分类

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
AOP通知共分为5种类型
- 前置通知：在切入点方法执行之前执行
- 后置通知：在切入点方法执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行。
- **环绕通知(重点)：**手动调用切入点方法并对其进行增强的通知方式。
- 返回后通知(了解)：在切入点方法执行之后执行，如果切入点方法内部出现异常将不会执行。
- 抛出异常后通知(了解)：在切入点方法执行之后执行，只有当切入点方法内部出现异常之后才执行。

（2）AOP通知详解

2.1前置通知

名称：@Before
类型：方法注解
位置：通知方法定义上方
作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
范例：

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

2.2.后置通知

名称：@After
类型：方法注解
位置：通知方法定义上方
作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
范例：

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

2.3.返回后通知

名称：@AfterReturning（了解）
类型：方法注解
位置：通知方法定义上方
作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
范例：

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

2.4.抛出异常后通知

名称：@AfterThrowing（了解）
类型：方法注解
位置：通知方法定义上方
作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
范例：

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

2.5.环绕通知

名称：@Around（重点，常用）
类型：方法注解
位置：通知方法定义上方
作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行
范例：：

@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，表示正在执行的连接点，使用该对象的proceed()方法表示对原始对象方法进行调用，返回值为原始对象方法的返回值。
环绕通知方法的返回值建议写成Object类型，用于将原始对象方法的返回值进行返回，哪里使用代理对象就返回到哪里。

7.AOP在通知中获取原方法数据

（1）获取函数签名

  	@Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        //获取接口/类全限定名
        String className = signature.getDeclaringTypeName();
        //获取方法名
        String methodName = signature.getName();
    }

（2）获取参数

说明：在前置通知和环绕通知中都可以获取到连接点方法的参数们

**方法一：**JoinPoint对象

@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}

**方法二：**ProccedJointPoint对象（是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;
}

**注：**另外Object ret = pjp.proceed(arg []);中可以传入一个参数数组，篡改原始方法的参数

（3）获取返回值

可使用：

@AfterReturning
@Around(“pt()”)

方法一：@AfterReturning

@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //变量名要和returning="ret"的属性值一致
    System.out.println("afterReturning advice ..."+ret);
}

==注意：==如果在形参位置ProceedingJoinPoint pjp和String ret同时存在，那么必须先写pjp

方法二：@Around(“pt()”)：环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

（4）获取异常

说明：在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常

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

@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}

方法二：@Around(“pt()”)：抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

8.AOP案例

（1）案例一

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

分析：

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

【第一步】编写通知类

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @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.currentTimeMillis();
        //执行万次操作
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        //打印执行结果
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
}

【第二步】在SpringConfig配置类上开启AOP注解功能

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableAspectJAutoProxy //开启AOP注解功能
public class SpringConfig {
}

【第三步】运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        Account account = accountService.findById(2);
    }
    @Test
    public void testFindAll(){
        List<Account> list = accountService.findAll();
    }
}

在这里插入图片描述

注意点：每一次调用该方法都是一次重新连接重新创建mapper对象所有如果在text输出也就输出一次，注意mybatis配置要配置正确

（2）案例二

需求：因为在百度网盘有的时候，密码可能含有空格导致无法登录

【前置工作】环境准备

//-------------service层代码-----------------------
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}
//-------------dao层代码-----------------------
public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

【第一步】编写通知类

@Component
@Aspect
public class DataAdvice {
    
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}

【第二步】在SpringConfig配置类上开启AOP注解功能

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

【第三步】运行测试类，查看结果

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

六.Spring事务

1.Spring事务简介

（1）简介

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

在这里插入图片描述

（2）什么叫同成功同失败操作

2.1.在没有使用spring事务之前

dao层

    @Update("update tb_brand set ordered = ordered + #{order} where id = #{id}")
    void inMoney(@Param("id") int id,@Param("order") int order);

    @Update("update tb_brand set ordered = ordered - #{order} where id = #{id}")
    void outMoney(@Param("id") int id,@Param("order") int order);

service层：

    @Override
    public void transfer(int inid, int outid, int tranOrder) {
        brandMapper.outMoney(outid,tranOrder);
        int b = 1/0;
        brandMapper.inMoney(inid,tranOrder);
    }

原数据
在这里插入图片描述

调用结果
在这里插入图片描述

只有出没有进~

2.2.使用spring事务之后

在这里插入图片描述

不变，同成功同失败

2.Spring事务操作流程

（1）在业务层==接口==上添加Spring事务管理

public interface service {

    @Transactional
    void transfer(int inid, int outid, int tranOrder);
}

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

（2）设置事务管理器(将事务管理器添加到IOC容器中)

在jdbc中配置

//配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager dtm = new DataSourceTransactionManager();
        dtm.setDataSource(dataSource);
        return dtm;
    }

因为最后每个sql语句都是每个事务，而最终要做到同成功同失败，那么就需要将每个事务融合成一个事务，而这些事务的联系就是通过jdbc的dataSouce

（3）开启注解式事务驱动

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

3.spring角色

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
事务协调员：加入事务方，以下两个都是协调员

在这里插入图片描述

4.Spring事务相关配置

在这里插入图片描述

说明：

对于RuntimeException类型异常或者Error错误，Spring事务能够进行回滚操作

但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。

public interface service {
    @Transactional(rollbackFor = {IOException.class})
    void transfer(int inid, int outid, int tranOrder);
}

5.Spring传播行为

如果有一个需求，无论其他两个事务成功与否，这个事务都要执行，那么就不能将此事务与其他事务进行融合，利用事务传播行为进行分离

**事务传播行为：**事务协调员对事务管理员所携带事务的处理态度
在这里插入图片描述

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}