1. 初始MyBatis ，详细步骤运行第一个MyBatis程序，同时对应步骤MyBatis底层剖析

@

每博一文案

才华果然比金钱更耀眼

2. 前沿知识

2.1 框架（framework）

Java当中常见的框架：

• SSM三大框架：Spring + SpringMVC + MyBatis
• SpringBoot
• SpringCloud
• ......

框架其实就是对通用代码的封装，被提前写好的一大堆接口和类(供你使用)，我们可以在做项目的时候直接引入这些接口和类(引入框架)，基于这些现有的接口和类进行开发，可以大大提高开发效率。

框架一般都是以jar 包的形式存在。(jar 包中有 class 文件以及各种配置文件等。)

SSM三大框架的学习顺序：MyBatis，Spring，SpringMVC 。因为 MyBatis 框架和后面两个 Spring，SpringMVC 比较的独立开来了，可以先学。

关于Spring 框架的内容，大家感兴趣的可以移步至：✏️✏️✏️ Spring_ChinaRainbowSea的博客-CSDN博客

2.2 三层架构

• 表示层（直接跟前端进行交互的，一是接受前端 AJAX 请求，二是返回 JSON 数据给前端）
• 业务逻辑层：一是处理表现层转发过来的前端请求（也就是具体的业务），二是将从持久层获取的数据返回到表示层。
• 数据访问层：直接操作数据库完成CRUD，并获得数据返回到上一层(也就是业务逻辑层)
• Java持久层框架：

关于持久层的框架有如下这些：

• MyBatis
• Hibernate(实现了JPA规范)
• jOOQ
• Guzz
• Spring Data(实现了JPA 规范)
• ActiveJDBC
• ......

更多关于三层架构的内容，大家可以移步至：✏️✏️✏️ MVC 三层架构案例详细讲解_mvc三层架构-CSDN博客

2.3 分析 JDBC 的缺点

我们先观察，分析如下代码的

示例1：

// ......
// sql语句写死在java程序中
String sql = "insert into t_user(id,idCard,username,password,birth,gender,email,city,street,zipcode,phone,grade) values(?,?,?,?,?,?,?,?,?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
// 繁琐的赋值：思考一下，这种有规律的代码能不能通过反射机制来做自动化。
ps.setString(1, "1");
ps.setString(2, "123456789");
ps.setString(3, "zhangsan");
ps.setString(4, "123456");
ps.setString(5, "1980-10-11");
ps.setString(6, "男");
ps.setString(7, "zhangsan@126.com");
ps.setString(8, "北京");
ps.setString(9, "大兴区凉水河二街");
ps.setString(10, "1000000");
ps.setString(11, "16398574152");
ps.setString(12, "A");
// 执行SQL
int count = ps.executeUpdate();
// ......

示例2：

// ......
// sql语句写死在java程序中
String sql = "select id,idCard,username,password,birth,gender,email,city,street,zipcode,phone,grade from t_user";
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
List<User> userList = new ArrayList<>();
// 思考以下循环中的所有代码是否可以使用反射进行自动化封装。
while(rs.next()){
    // 获取数据
    String id = rs.getString("id");
    String idCard = rs.getString("idCard");
    String username = rs.getString("username");
    String password = rs.getString("password");
    String birth = rs.getString("birth");
    String gender = rs.getString("gender");
    String email = rs.getString("email");
    String city = rs.getString("city");
    String street = rs.getString("street");
    String zipcode = rs.getString("zipcode");
    String phone = rs.getString("phone");
    String grade = rs.getString("grade");
    // 创建对象
    User user = new User();
    // 给对象属性赋值
    user.setId(id);
    user.setIdCard(idCard);
    user.setUsername(username);
    user.setPassword(password);
    user.setBirth(birth);
    user.setGender(gender);
    user.setEmail(email);
    user.setCity(city);
    user.setStreet(street);
    user.setZipcode(zipcode);
    user.setPhone(phone);
    user.setGrade(grade);
    // 添加到集合
    userList.add(user);
}
// ......

JDBC的不足点：

SQL语句写牢在了Java程序当中了，不灵活，改SQL的话，就要改Java代码，违背了开闭原则OCP。

给 ? 占位符传值是繁琐的，不能自动化

将结果集封装成Java对象也是比较繁琐的，不能自动化

关于这些自动化的问题，以及OCP开闭原则，运用下面我们正在学习的MyBatis 可以得到一个很好的解决方案。

关于JDBC的更多详细内容，大家可以移步至：✏️✏️✏️ JDBC_ChinaRainbowSea的博客-CSDN博客

3. 初始了解MyBatis

MyBatis 本质上就是对JDBC的封装，通过MyBatis完成CRUD。

MyBatis 在三层架构中负责持久层，属于持久层框架。

MyBatis的发展历程：这里【引用百度百科】

• MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了[google code](https://baike.baidu.com/item/google code/2346604?fromModule=lemma_inlink)，并且改名为MyBatis。2013年11月迁移到Github。
• iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）。
• 当前，最新版本是MyBatis 3.5.13，其发布时间是2023年03月11日。

打开MyBatis 代码可以看到它的包结构中包含：ibatis

ORM ：对象关系映射。

O (object) ：Java虚拟机中的Java对象。

R（Relational）：关系型数据库

M（Mapping）：将Java虚拟机中的Java对象映射到数据库表中一行记录，或是将数据库表中一行记录映射成Java虚拟机中的一个Java对象。

ORM示图：

MyBatis 框架就是一个ORM框架。

MyBatis可以干啥？

java 对象 < ------ > 数据库表中的一条记录

像User 这样在图中，有特殊的称呼：
有的人把它叫做：pojo(普通Java类)
有的叫做: JavaBean (咖啡豆)
有的叫做: domain(领域模型)

MyBatis 是一个半自动化的ORM，因为MyBatis 框架中SQL语句是需要程序员自己写的。

Hibernate 框架是一个全自动化的ORM 使用Hibenrnate 框架的时候，不需要程序员手动编写SQL语句，SQL语句可以自动生成，所以Hibernate 是一个完全的全自动化的ORM框架。

这里我们的主题是 MyBatis 。

MyBatis 框架特点：

1. 支持定制化SQL，存储过程，基本映射以及高级映射
2. 避免了几乎所有的 JDBC代码中手动设置参数以及获取结果集。
3. 支持XML 开发，也支持注解开发。【为了保证 SQL 语句的灵活，所有MyBatis 大部分采用 XML方式开发。】
4. 将接口和 Java 的 POJOs(Plain Ordinary Java Object ，简单普通的Java对象)映射成数据库中的记录
5. 体积小，好学，两个jar 包，两个 XML 配置文件
6. 完全做到 SQL 解耦合
7. 提供了基本映射标签
8. 提供了高级映射标签
9. 提供了XML标签，支持动态SQL的编写。

4. MyBatis第一个入门程序

4.1 MyBatis下载

• 从github上下载，地址：https://github.com/mybatis/mybatis-3

将框架以及框架的源码都下载下来，下载框架后解压，打开mybatis目录

• 通过以上解压可以看到，框架一般都是以jar包的形式存在。我们的mybatis课程使用 maven，所以这个jar我们不需要。

• 官方手册需要。但是，这个官方文档是英文的，对应英文不好的朋友，大家可以来的这个网站：https://mybatis.net.cn/ 是一个 mybatis 的中文网站。

4.2 MyBatis入门程序开发步骤

首先我们先准备好数据库信息

准备数据库表：汽车表t_car，字段包括：

id：主键（自增）【bigint】
car_num：汽车编号【varchar】
brand：品牌【varchar】
guide_price：厂家指导价【decimal类型，专门为财务数据准备的类型】
produce_time：生产时间【char，年月日即可，10个长度，'2022-10-11'】
car_type：汽车类型（燃油车、电车、氢能源）【varchar】

DROP TABLE IF EXISTS `t_car`;
CREATE TABLE `t_car`  (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键，和业务没有关系，自增',
  `car_num` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '汽车编号',
  `brand` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '汽车品牌',
  `guide_price` decimal(10, 2) NULL DEFAULT NULL COMMENT '厂商指导价格',
  `produce_time` char(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '生产日期',
  `car_type` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '汽车类型，燃油车，氢能源',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 33 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;

INSERT INTO `t_car` VALUES (1, '1001', '宝马520Li', 10.00, '2020-10-11', '燃油车');
INSERT INTO `t_car` VALUES (2, '1002', '奔驰E300L', 55.00, '2020-11-11', '新能源');
INSERT INTO `t_car` VALUES (5, '1003', '丰田霸道', 30.00, '2000-10-11', '燃油车');

创建Project：建议创建Empty Project，设置Java版本以及编译版本等。

创建Module：普通的Maven Java模块

第一步：通过maven 在 pom.xml 文件当中引入相关依赖。

mybatis依赖 ，mysql依赖

<!--mybatis核心依赖-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.10</version>
</dependency>

<!--mysql驱动依赖-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.30</version>
</dependency>

<?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>com.ranbowsea</groupId>
    <artifactId>mybatis-001-introduction</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>


    <dependencies>
        <!--mybatis核心依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>
        
        <!--mysql驱动依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
    </dependencies>



</project>

第二步：在 resources 根(类)目录下新建 mybatis-config.xml(文件名随意)配置文件（可以参考mybatis手册拷贝 (https://mybatis.net.cn/getting-started.html)）

注意:

1. 第一，这个文件名不是必须叫 mybatis-config.xml，可以用其他的名字，只是大家都采用这个名字。
2. 这个文件存放的位置也不是固定的，可以随意，但一般情况下，会放到类的根路径下

关于这两点的注意事项，该文章的后面，会详细说明。请继续看下去。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/powernode"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--sql映射文件创建好之后，需要将该文件路径配置到这里-->
        <mapper resource=""/>
    </mappers>
</configuration>

第三步：编写XxxMapper.xml 文件

在这个配置文件当编写SQL语句。

这个文件名也不是固定的，放的位置也不是固定的，我们这里给它起个名字，叫做：CarMapper.xml (mapper 英文单词是“映射”的意思)，把它暂时放到类的根路径下。

在resources根目录下新建CarMapper.xml配置文件（可以参考mybatis手册拷贝）

同时我们在其中编写一条SQL语句，一条insert 插入的SQL语句。

注意编写的是 insert 插入的SQL语句所以，在该 xml 文件中用，<insert> 标签进行定义编写。如下：

而在<insert> 标签当中，需要定义一个 id 属性的值，该

insert语句，id是这个条SQL语句的唯一标识，这个id就代表了这条SQL语句

<!--	insert语句，id是这个条SQL语句的唯一标识，这个id就代表了这条SQL语句 -->
	<insert id="insertCar">
		insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
		values (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车')
	</insert>
// 因为我们的 id 是主键，自增的，所以可以不赋值。为 null ，让其进行一个自增的效果。

因为我们的 id 是主键，自增的，所以可以不赋值。为 null ，让其进行一个自增的效果。

注意1：sql语句最后结尾可以不写“;”

注意2：CarMapper.xml文件的名字不是固定的。可以使用其它名字。

注意3：CarMapper.xml文件的位置也是随意的。这里选择放在resources根下，相当于放到了类的根路径下。

注意4：将CarMapper.xml文件路径配置到mybatis-config.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
		PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
		"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace先随意写一个-->
<mapper namespace="fas">

<!--	insert语句，id是这个条SQL语句的唯一标识，这个id就代表了这条SQL语句 -->
	<insert id="insertCar">
		insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
		values (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车')
	</insert>
</mapper>

第四步： 在mybatis-config.xml 文件中指定XxxMapper.xml 文件的路径

就是将我们上面配置的 XxxMapper.xml(这里是 CarMapper.xml) 的SQL语句的映射文件创建好，将该文件所在位置的路径，填入到 <mapper resource="xxx"> 当中，让MyBatis 框架可以顺利的找到它，并执行其中的SQL语句。注意：resource 属性会自动从类的根路径下开始查找资源。

<mapper resource="CarMapper.xml">

注意：resource 属性会自动从类的根路径下开始查找资源。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
<!--            MANAGED 没有用第三框架管理的话，都是会被提交的，没有事务上的管理了。-->
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="MySQL123"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>

        <!--sql映射文件创建好之后，需要将该文件路径配置到这里-->
<!--        执行XxxMapper.xml 文件的路径-->
<!--        resource 属性自动会从类的根路径下开始查找资源-->
        <mapper resource="CarMapper.xml"/>
    </mappers>

</configuration>

第五步: 编写MyBatis 测试程序(使用MyBatis的类库，编写myBatis 程序，该数据库，做增删改查就行了)

首先我们需要知道，在MyBatis 当中，负责执行SQL语句的是哪个对象，同时又该如何获取到该对象。

负责执行 SQL语句的对象是： SqlSession

SqlSession 是专门来执行 SQL语句的，是一个Java程序和数据库之间的一次会话

想要获取到 SqlSession 对象，就需要先获取SqlSessionFactory 对象，通过SqlSessionFactory 工厂的openSession( ) 方法，来生产 SqlSession 对象。

那怎么湖获取SqlSessionFactory 对象

通过SqlSessionFactoryBuilder 对象的 build( ) 方法，来获取一个SqlSessionFactory 对象。

总结：

MyBatis的核心对象包括：
SqlSessionFactoryBuilder
SqlSessionFactory
SqlSession

SqlSessionFactoryBuilder-->SqlSessionFactory-->SqlSession

注意事项：

int count = sqlSession.insert("insertCar"); // 这个"insertCar"必须是sql的id

该insert(id) 就是，我们上面 CarMapper.xml SQL映射文件当中编写的 SQL 语句(这里是 <insert> 标签当中的 id 的属性值，保持一致)

同时需要：

执行 sqlSession.commit(); 提交数据给数据库(和JDBC是一样的)； 提交（mybatis默认采用的事务管理器是JDBC，默认是不提交的，需要手动提交。）

以及执行: sqlSession.close(); 关闭资源，注意：仅仅是关闭资源，并不会提交数据的。

// 5. 提交（mybatis默认采用的事务管理器是JDBC，默认是不提交的，需要手动提交。）
sqlSession.commit();
// 6. 关闭资源（只关闭是不会提交的）
sqlSession.close();

完整执行代码：

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class MyBatisIntroductionTest {

    public static void main(String[] args) {
        // 1. 创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 2. 创建SqlSessionFactory对象
        InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        // 3. 创建SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4. 执行sql
        int count = sqlSession.insert("insertCar"); // 这个"insertCar"必须是sql的id
        System.out.println("插入几条数据：" + count);
        // 5. 提交（mybatis默认采用的事务管理器是JDBC，默认是不提交的，需要手动提交。）
        sqlSession.commit();
        // 6. 关闭资源（只关闭是不会提交的）
        sqlSession.close();

    }
}

运行结果：

MyBatis 第一个入门程序小总结：

第一： 在MyBatis中一定是有一个很重要的对象，这个对象是：SqlSessionFactory对象

第二： SqlSessionFactory 对象的创建需要 xml
xml 是什么？它是一个配置文件

MyBatis中有两个主要的配置文件：

1. mybatis-config.xml ，这是核心配置文件，主要配置连接数据库的信息等（一般是第一个数据库一个），同样的与之对应的通过mybatis-config.xml 的配置文件创建的对象 SqlSessionFactoryBuilder，SqlSessionFactory 也是一个数据库一个对象 。
2. XxxMapper.xml ，这个是专门用来编写SQL语句的配置文件（一个数据表一个）。

t_user 表，一般会对应一个UserMapper.xml

t_student 表，一般会对应一个StudentMapper.xml

4.3 MyBatis 的第一个入门程序的细节问题

1. 在MyBatis 中的SQ语句的结尾“;” 可以省略的。

2. 在 MyBatis 当中的 SQL语句错误的，异常信息是：java.sql.SQLSyntaxErrorException 该异常表示是你的SQL语句写的不对，SQL语法可能存在问题。

3. 在MyBatis 当中的工具类： Resource.getResourceAsStream( ) 方法。

小技巧：以后凡是遇到 resource 这个单词，大部分情况下，这种加载资源的方式就是从(resource)类路径下开始检索加载的。

例如: 下面三种获取 IO流文件的，检索方式都是从类路径下开始的。

 InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml");
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");  // 使用类加载器

采用从 (resource)类路径 加载文件的优点：

采用这种方式，从类的路径当种加载资源，项目的移植性很强，项目从Windwos移植到Linux，没有路径上的问题

而下面这个是：从系统的绝对路径开始加载的

InputStream stream = new FileInputStream("E:\\mybatis-config.xml");

采用系统的绝对路径加载文件资源的缺点：

可移植性差，程序不够健壮，可能移植到其他的操作系统当中，导致以上路径无效，比如Linux，因为Linux系统是没有所谓的D盘，C盘之类的说法。所以想要移植到Linux当中运行的话，还需要修改Java代码才行。这样就违背了OCP原则了。

5. 关于MyBatis核心配置文件的名字和路径详解

MyBatis 的核心配置文件就是，我们上述的名为 mybatis-config.xml 的配置文件。

已经验证过了，mybatis 核心配置文件的名字，不一定是：mybatis-config.xml 。mybatis 核心配置文件存放的路径，也不一定是类的根路径，可以放到其他的位置，但是为了项目的移植性。健壮性，最好将这个配置文件放到类路径下面。

同理的对应的 SQL 映射文件 XxxMapper.xml 文件的路径也可以不放在根(类)路径下，不过如果 SQL 映射文件 XxxMapper.xml 文件是根据 系统的绝对路径 来的话，需要用 <url> 标签。如下：

重点：注意的是，无论是 MyBatis 的核心配置文件，还是对应的 SQL 映射文件 XxxMapper.xml 文件，如果文件含义目录的话，一定要带上目录才行如下：

源码解析：MyBatis 工具类的：InputStream is = Resources.getResourceAsStream("mybatis-config.xml") 的底层调用的机制。

> InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml")
> ClassLoader.getSystemClassLoader() 获取系统的类加载器。
> 系统类加载器有一个方法叫做：getResourceAsSteam
> 它就是从类路径当中加载资源的
> 通过源代码分析发现：
>   InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
>   底层的源代码其实现就是:
> InputStream is = ClasLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");
> 

6. 关于 mybatis 的事务管理机制（深度剖析）

关于 mybatis 的事务管理机制：

在mybatis-config.xml 文件中，可以通过以下的配置进行 mybatis 的事务处理。

通过：**<transactionManager type="JDBC"> ** 标签进行设置即可。

type 的属性值包括两个：

• JDBC (jdbc)
• MANGED(managed)

type 后面的值，只有以上两个值可以选择，不区分大小写。

在mybatis 中提供了两种事务管理机制。

1. 第一种 JDBC事务管理器

MyBatis 框架自己管理事务，自己采用原生的JDBC 代码去管理事务

> conn.setAutoCommit(false);开启事务,false 是默认的，可以不用写
> ...业务处理...
> conn.commit(); 手动提交事务

使用JDBC事务管理器的话，底层创建的事务管理器对象，jdbcTransaction对象。

如果你编写的代码是下面的代码：
  SqlSession sqlSession = sqlSessionFactory.openSession(true);
  表示没有开启事务，因为这种方式压根不会执行，com.setAutoCommit(false)
  在JDBC事务中，没有执行com.setAutoCommit(false);那么autoCommit就是true.
  如果autoCommit 是 true ，就表示没有开启事务，只要执行任意一条DML语句就提交了一次

我们可以进行一个 Debug 调试，进行一个检查

这里我们用默认的 false ，也可以不填，都是 false

  SqlSession sqlSession = sqlSessionFactory.openSession();
  SqlSession sqlSession = sqlSessionFactory.openSession(false);

下面我们设置为：true

在 JDBC事务管理器 下，SqlSession sqlSession = sqlSessionFactory.openSession( 不填，或者 false); 表示开启事务了(需要自己手动提交，sqlSession.commit()😉，填 true 表示关闭了事务，自动就会提交了

1. 第二种 MANAGED 是事务管理器

在 mybatis 不再负责事务的管理了，事务管理交给其他容器来负责，例如：Spring

<!--            MANAGED 没有用第三框架管理的话，都是会被提交的，没有事务上的管理了。-->
            <transactionManager type="MANAGED"/>

MyBatis 说，我不管事务了(会自动提交数据给数据库)，你来负责吧（Spring）

如果对于我们当前的单纯的只有 MyBatis 的情况下，如果配置为：MANAGED ，那么事务这块是没人管的，没有人管理事务标识，事务压根没有开启，后面我们可以配合使用Spring 进行事务上的管理。

关于 MyBatis 配合Spring 开启事务的详细内容，大家可以移步至：✏️✏️✏️ Spring6 对 集成MyBatis 开发运用(附有详细的操作步骤)-CSDN博客

7. MyBatis第一个比较完整的代码写法

resources 的配置文件下的信息。

CarMapper.xml SQL 语句的映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
		PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
		"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace先随意写一个-->
<mapper namespace="fas">

<!--	insert语句，id是这个条SQL语句的唯一标识，这个id就代表了这条SQL语句 -->
	<insert id="insertCar">
		insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
		values (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车');
	</insert>
</mapper>

mybatis-config.xml 的MyBatis 的核心配置文件。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--    开启mybatis 对标准日志的实现-->
<!--    如果导入的第三方框架的日志，没有下面这个 settings 也是可以的-->
<!--    <settings>-->
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!--    </settings>-->
    <environments default="development">
        <environment id="development">
<!--            MANAGED 没有用第三框架管理的话，都是会被提交的，没有事务上的管理了。-->
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="MySQL123"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>

        <!--sql映射文件创建好之后，需要将该文件路径配置到这里-->
<!--        执行XxxMapper.xml 文件的路径-->
<!--        resource 属性自动会从类的根路径下开始查找资源-->
<!--        <mapper resource="CarMapper.xml"/>-->
        <mapper resource="com/CarMapper2.xml"/>

<!--        url属性: 从绝对路径当中加载资源。-->
<!--        语法格式：file:///绝对路径-->
<!--        <mapper url="file:///e:/CarMapper.xml"></mapper>-->
    </mappers>

</configuration>

运行测试程序：

package com.rainbowsea.mybatis.test;

import com.ranbowsea.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;

public class MyBatisCompleteTest {
    public static void main(String[] args) {
        // 获取到SqlSessionFactoryBuilder 对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSession sqlSession = null;

        try {
            // 获取到SqlSessionFactoryBuilder 一个数据库对应一个 SqlSessionFactoryBuilder
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));

            // 获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession();


            sqlSession.insert("insertCar");// 对应 执行SQL语句对应的数据表的 XxxMapper.xml当中，对应SQL语句的id

            // 执行到这里，提交事务，终止事务
            sqlSession.commit();
        } catch (IOException e) {
            if(sqlSession != null) {  // 上面可能 sqlSession 还是为空
                // 回滚事务
                sqlSession.rollback();
            }
            throw new RuntimeException(e);
        } finally {
            if(sqlSession != null) {

                // 关闭会话
                sqlSession.close();
            }
        }




    }

}

8. MyBatis 引入日志框架

8.1 使用 MyBatis 自带的日志框架

引入日志框架的目的：是为了看清楚MyBatis执行的具体的 SQL语句，以及赋值内容。

启动MyBatis 自带的标准日志组件，只需要在mybatis-config.xml MyBatis 的核心配置文件中添加配置文件【可参考mybatis 手册https://mybatis.net.cn/logging.html】

关于mybatis 集成日志组件，让我们调试起来更加方便。
mybatis常见的集成的日志组件有哪些呢？
SLF4J(沙拉风)
LOG4J
LOG$J2
STDOUT_LOGGING
...
注意：log4j log4j2 logback都是同一个作者开发的。
其中STDOUT_LOGGING 是标准日志，mybatis已经实现了这种标准日志，mybatis框架本身已经实现了这种
标准。只要开启即可，怎么开启呢？在mybatis-config.xml文件中使用settings标签进行配置开启。

<settings>
  <setting name="logImpl" value="STDOUT_LOGGING" />
</settings>

注意：

这个标签在编写的时候要注意，它必须在 environments 标签之前(不然会报错的)，注意顺序，当然，不需要记忆这个顺序。
因为有dtd文件进行约束呢。我们只要参考did约束即可

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--    开启mybatis 对标准日志的实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <environments default="development">
        <environment id="development">
<!--            MANAGED 没有用第三框架管理的话，都是会被提交的，没有事务上的管理了。-->
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="MySQL123"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>

        <!--sql映射文件创建好之后，需要将该文件路径配置到这里-->
<!--        执行XxxMapper.xml 文件的路径-->
<!--        resource 属性自动会从类的根路径下开始查找资源-->
<!--        <mapper resource="CarMapper.xml"/>-->
        <mapper resource="com/CarMapper2.xml"/>

<!--        url属性: 从绝对路径当中加载资源。-->
<!--        语法格式：file:///绝对路径-->
<!--        <mapper url="file:///e:/CarMapper.xml"></mapper>-->
    </mappers>

</configuration>

运行测试：

8.2 引入 logback 日志框架

上述的MyBatis 自带的日志框架，这种实现也是可以的，可以看到一些信息，比如：连接对象什么时候创建，什么时候关闭，sql语句是怎样的
但是没有详细的日期，线程名字，等，如果你想使用更加丰富的配置，可以集成第三方Log组件。

同时配置也不够灵活，我们可以集成其他的日志组件，例如：log4j，logback等。

• logback是目前日志框架中性能较好的，较流行的，所以我们选它。
• 引入logback的步骤：

logback 日志框架实现了slf4j标准(沙拉风，日志门面，日志标准)

第一步： 引入logback的依赖

我们需要在项目的 pom.xml 配置文件当中，引入 logbakc 的依赖，通过 maven 进行导入。

<!--        引入 logback的依赖，这个日志框架实现了slf4j 规范-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>

<?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>com.ranbowsea</groupId>
    <artifactId>mybatis-001-introduction</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>


    <dependencies>
        <!--mybatis核心依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>
        <!--mysql驱动依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>

<!--        junit 依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

<!--        引入 logback的依赖，这个日志框架实现了slf4j 规范-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>
    </dependencies>



</project>

第二步：如logback所必须的 xml 配置文件

注意：这个配置文件的名字必须叫做：logback.xml 或者 logback-test.xml 不能是其他的名字
并且这个配置文件必须放到类的根路径下，不能是其他位置。

<?xml version="1.0" encoding="UTF-8"?>

<configuration debug="false">
    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- 按照每天生成日志文件 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/TestWeb.log.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>100MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

    <!--mybatis log configure-->
    <logger name="com.apache.ibatis" level="TRACE"/>
    <logger name="java.sql.Connection" level="DEBUG"/>
    <logger name="java.sql.Statement" level="DEBUG"/>
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>

    <!-- 日志输出级别,logback日志级别包括五个：TRACE < DEBUG < INFO < WARN < ERROR -->
    <root level="DEBUG">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE"/>
    </root>

</configuration>

<?xml version="1.0" encoding="UTF-8"?>

<configuration debug="false">
    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>

    <!--mybatis log configure-->
    <logger name="com.apache.ibatis" level="TRACE"/>
    <logger name="java.sql.Connection" level="DEBUG"/>
    <logger name="java.sql.Statement" level="DEBUG"/>
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>

    <!-- 日志输出级别,logback日志级别包括五个：TRACE < DEBUG < INFO < WARN < ERROR -->
    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE"/>
    </root>

</configuration>

配置好以后，我们运行看看。

package com.rainbowsea.mybatis.test;

import com.ranbowsea.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;

public class MyBatisCompleteTest {
    public static void main(String[] args) {
        // 获取到SqlSessionFactoryBuilder 对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSession sqlSession = null;

        try {
            // 获取到SqlSessionFactoryBuilder 一个数据库对应一个 SqlSessionFactoryBuilder
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));

            // 获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession();


            sqlSession.insert("insertCar");// 对应 执行SQL语句对应的数据表的 XxxMapper.xml当中，对应SQL语句的id

            // 执行到这里，提交事务，终止事务
            sqlSession.commit();
        } catch (IOException e) {
            if(sqlSession != null) {  // 上面可能 sqlSession 还是为空
                // 回滚事务
                sqlSession.rollback();
            }
            throw new RuntimeException(e);
        } finally {
            if(sqlSession != null) {

                // 关闭会话
                sqlSession.close();
            }
        }




    }

}

9. 总结:

1. MyBatis 本质上就是对JDBC的封装，通过MyBatis完成CRUD。MyBatis 在三层架构中负责持久层，属于持久层框架。

2. MyBatis 的包目录，路径是 ibatis 。不是 mybatis 。这一点需要注意清楚明白。

3. mybatis 核心配置文件的名字，不一定是：mybatis-config.xml 。mybatis 核心配置文件存放的路径，也不一定是类的根路径，可以放到其他的位置，但是为了项目的移植性。健壮性，最好将这个配置文件放到类路径下面。

4. MyBatis 的SQL 映射文件XxxMapper.xml 和MyBatis 的核心配置文件, mybatis-config.xml 都尽量放到类(resources) 根路径下 ，为了项目的移植性。健壮性，最好将这个配置文件放到类路径下面。

5. 小技巧：以后凡是遇到 resource 这个单词，大部分情况下，这种加载资源的方式就是从(resource)类路径下开始检索加载的。

   例如: 下面三种获取 IO流文件的，检索方式都是从类路径下开始的。

   InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
   InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml");
   InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");  // 使用类加载器
   

6. 在mybatis 中提供了两种事务管理机制

   1. 第一种 JDBC事务管理器

      MyBatis 框架自己管理事务，自己采用原生的JDBC 代码去管理事务

      > conn.setAutoCommit(false);开启事务,false 是默认的，可以不用写
      > ...业务处理...
      > conn.commit(); 手动提交事务
      

      使用JDBC事务管理器的话，底层创建的事务管理器对象，jdbcTransaction对象。

      在 JDBC事务管理器 下，SqlSession sqlSession = sqlSessionFactory.openSession( 不填，或者 false); 表示开启事务了(需要自己手动提交，sqlSession.commit()😉，填 true 表示关闭了事务，自动就会提交了

   2. 第二种 MANAGED 是事务管理器

   在 mybatis 不再负责事务的管理了，事务管理交给其他容器来负责，例如：Spring 。

   如果对于我们当前的单纯的只有 MyBatis 的情况下，如果配置为：MANAGED ，那么事务这块是没人管的，没有人管理事务标识，事务压根没有开启，后面我们可以配合使用Spring 进行事务上的管理。

7. 引入日志框架的目的：是为了看清楚MyBatis执行的具体的 SQL语句，以及赋值内容。

   启动MyBatis 自带的标准日志组件，只需要在mybatis-config.xml MyBatis 的核心配置文件中添加配置文件

   <settings>
     <setting name="logImpl" value="STDOUT_LOGGING" />
   </settings>
   

   setting 这个标签在编写的时候要注意，它必须在 environments 标签之前(不然会报错的)，注意顺序，当然，不需要记忆这个顺序。

8. 引入 logback 日志框架。导入的依赖

<!--        引入 logback的依赖，这个日志框架实现了slf4j 规范-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>

如logback所必须的 xml 配置文件**

注意：这个配置文件的名字必须叫做：logback.xml 或者 logback-test.xml 不能是其他的名字
并且这个配置文件必须放到类的根路径下，不能是其他位置。

10. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”

热门相关：从现代飞升以后   农家小地主   满级绿茶穿到八十年代重新做人   官仙   纨绔毒医