1. Mybatis 入门程序开发步骤

1.1 数据库表的创建

• 准备数据库表：数据库：north_mybatis , 汽车表 t_car，字段包括：
  • id：主键（自增）【bigint】
  • car_num：汽车编号【varchar】
  • brand：品牌【varchar】
  • guide_price：厂家指导价【decimal类型，专门为财务数据准备的类型】
  • produce_time：生产时间【char，年月日即可，10个长度，'2022-10-11'】
  • car_type：汽车类型（燃油车、电车、氢能源）【varchar】、
• 使用navicat for mysql工具建表
• 使用navicat for mysql工具向t_car表中插入两条数据，如下：

1.2 创建入门程序

创建Maven项目并配置Maven ， 根据以下步骤开始创建入门程序
其中 ，resource目录：放在这个目录当中的，一般都是资源文件，配置文件。直接放到resources目录下的资源，等同于放到了类的根路径下。

‍

• 第一步：打包方式：jar包 (这里说一下：不需要war: 因为mybatis封装的是jdbc)

<groupId>com.north</groupId>
    <artifactId>mybatis-001-introduction</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包方式-->
    <packaging>jar</packaging>

• 第二步：引入依赖
  • 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.26</version>
</dependency>

• 第三步：编写mybatis核心配置文件：mybatis-config.xml ，并放在resources根目录下, 这里注意一下：
  • 第一：这个文件名不是必须叫做mybatis-config.xml，可以用其他的名字。只是大家都采用这个名字。
  • 第二：这个文件存放的位置也不是固定的，可以随意，但一般情况下，会放到类的根路径下。

<?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/north_mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--sql映射文件创建好之后，需要将该文件路径配置到这里-->
        <!--这里存放的是执行XxxMapper.xml文件的路径-->
        <!--resource 属性自动会从类的根路径下开始查找资源-->
        <mapper resource="CarMapper.xml"/>
    </mappers>
</configuration>

• 第四步：在resources根目录下新建CarMapper.xml配置文件（可以参考mybatis手册拷贝）
  • 在这个配置文件当中编写SQL语句。
  • 这个文件名也不是固定的，放的位置也不是固定，我们这里给它起个名字，叫做：CarMapper.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="car">
    <!--insert 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>
</mapper>

• 第五步：在mybatis-config.xml文件中指定XxxxMapper.xml文件的路径：
  • 注意：resource属性会自动从类的根路径下开始查找资源
• 第六步：编写MyBatis程序。(使用mybatis的类库，编写mybatis程序，连接数据库，做增删改查就行了。)
  • 在MyBatis当中，负责执行SQL语句的那个对象叫做什么呢？ SqlSession
  • SqlSession是专门用来执行SQL语句的，是一个Java程序和数据库之间的一次会话。
  • 要想获取SqlSession对象，需要先获取SqlSessionFactory对象，通过SqlSessionFactory工厂来生产SqlSession对象。
  • 怎么获取SqlSessionFactory对象呢？
    • 需要首先获取SqlSessionFactoryBuilder对象。
    • 通过SqlSessionFactoryBuilder对象的build方法，来获取一个SqlSessionFactory对象。
  • mybatis的核心对象包括：SqlSessionFactoryBuilder , SqlSessionFactory , SqlSession
  • SqlSessionFactoryBuilder --> SqlSessionFactory --> SqlSession

package com.north.mybatis.test;

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.InputStream;

/**
 * @Author North
 * @Date 2024/4/4
 * 学习目标：Mybatis 的入门程序
 */
public class MybatisIntroductionTest {
    public static void main(String[] args) throws Exception {
        // 获取 SqlSessionFactoryBuilder 对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 获取 SqlSessionFactory 对象
		// Resources.getResourceAsStream默认就是从类的根路径下开始查找资源。
        InputStream resource = Resources.getResourceAsStream("mybatis-config.xml"); 
        SqlSessionFactory build = sqlSessionFactoryBuilder.build(resource); // 一般情况下都是一个数据库对应一个SqlSessionFactory对象。
        // 获取 SqlSession 对象
        SqlSession sqlSession = build.openSession();
        // 执行SQL语句
        int rows = sqlSession.insert("insertCar"); // 返回值是影响数据库表当中的记录条数。
        System.out.println("插入了几条记录 ：" + rows);
        // 手动提交
        // 如果使用的事务管理器是JDBC的话，底层实际上还是会执行conn.commit();
        sqlSession.commit();
    }
}

• 通过以上六步 ，得出一个完整的mybatis的入门程序 ， 运行结果如下：

1.3 Mybatis入门程序的小细节

从 XML 中构建 SqlSessionFactory
通过官方的这句话，你能想到什么呢？

• 第一：在MyBatis中一定是有一个很重要的对象，这个对象是：SqlSessionFactory对象。
• 第二：SqlSessionFactory对象的创建需要XML。

XML是什么？

• 它一定是一个配置文件。

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

• 其中一个是：mybatis-config.xml，这是核心配置文件，主要配置连接数据库的信息等。（一个）
• 另一个是：XxxxMapper.xml，这个文件是专门用来编写SQL语句的配置文件。（一个表一个）
  • t_user表，一般会对应一个UserMapper.xml
  • t_student表，一般会对应一个StudentMapper.xml

‍
关于第一个程序的小细节

• mybatis中sql语句的结尾";"可以省略。
• Resources.getResourceAsStream
  • 小技巧：以后凡是遇到resource这个单词，大部分情况下，这种加载资源的方式就是从类的根路径下开始加载。（开始查找）
  • 优点：采用这种方式，从类路径当中加载资源，项目的移植性很强。项目从windows移植到linux，代码不需要修改，因为这个资源文件一直都在类路径当中。
• InputStream is = new FileInputStream("d:\mybatis-config.xml"); 采用这种方式也可以。
  • 缺点：可移植性太差，程序不够健壮。可能会移植到其他的操作系统当中。导致以上路径无效，还需要修改java代码中的路径。这样违背了OCP原则。
• 已经验证了：
  • mybatis核心配置文件的名字，不一定是：mybatis-config.xml。可以是其它名字。
  • mybatis核心配置文件存放的路径，也不一定是在类的根路径下。可以放到其它位置。但为了项目的移植性，健壮性，最好将这个配置文件放到类路径下面。
• InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");
  • ClassLoader.getSystemClassLoader() 获取系统的类加载器。
  • 系统类加载器有一个方法叫做：getResourceAsStream
  • 它就是从类路径当中加载资源的。
  • 通过源代码分析发现：
    • InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    • 底层的源代码其实就是：InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");
• CarMapper.xml文件的名字是固定的吗？CarMapper.xml文件的路径是固定的吗？
  • 都不是固定的。
  • resource属性：这种方式是从类路径当中加载资源。
  • url属性：这种方式是从绝对路径当中加载资源。

2. Mybatis 的事务管理机制深度剖析

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

其中：type属性的值包括两个：type后面的值，只有以上两个值可选，不区分大小写。

1. JDBC(jdbc)
2. MANAGED(managed)

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

• 第一种：JDBC事务管理器
• 第二种：MANAGED事务管理器

‍
JDBC事务管理器：
mybatis框架自己管理事务，自己采用原生的JDBC代码去管理事务：

• conn.setAutoCommit(false); 开启事务。
• ....业务处理...
• conn.commit(); 手动提交事务

使用JDBC事务管理器的话，底层创建的事务管理器对象：JdbcTransaction对象。
‍
如果你编写的代码是下面的代码：

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

‍
MANAGED事务管理器：
mybatis不再负责事务的管理了。事务管理交给其它容器来负责。例如：spring。
我不管事务了，你来负责吧。
对于我们当前的单纯的只有mybatis的情况下，如果配置为：MANAGED
那么事务这块是没人管的。没有人管理事务表示事务压根没有开启。
没有人管理事务就是没有事务。
‍
JDBC中的事务：

• 如果你没有在JDBC代码中执行：conn.setAutoCommit(false);的话，默认的autoCommit是true。

‍
重点：
以后注意了，只要你的autoCommit是true，就表示没有开启事务。
只有你的autoCommit是false的时候，就表示开启了事务。

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

代码演示：

package com.north.mybatis.test;

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

/**
 * @Author North
 * @Date 2024/4/4
 * 学习目标：写一个比较完整的Mybatis入门程序
 */
public class MybatisCompleteTest {
    public static void main(String[] args) {
        SqlSession sqlSession = null;
        try {
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));
            // 开启会话（底层会开启事务）
            sqlSession = sqlSessionFactory.openSession();
            // 执行sql语句
            int rows = sqlSession.insert("insertCar");
            System.out.println("插入了几条记录：" + rows);
            // 执行到这里，没有发生任何异常，提交事务。终止事务。
            sqlSession.commit();
        } catch (Exception e) {
            if (sqlSession != null) {
                sqlSession.rollback();
            }
            e.printStackTrace();
        } finally {
            // 关闭会话(释放资源)
            if (sqlSession != null) {
                sqlSession.close();
            }
        }
    }
}

自我感觉良好 ， 哈哈哈~~~

4. 引入Junit

• JUnit是专门做单元测试的组件。
  • 在实际开发中，单元测试一般是由我们Java程序员来完成的。
  • 我们要对我们自己写的每一个业务方法负责任，要保证每个业务方法在进行测试的时候都能通过。
  • 测试的过程中涉及到两个概念：
    • 期望值
    • 实际值
  • 期望值和实际值相同表示测试通过，期望值和实际值不同则单元测试执行时会报错。
• 这里引入JUnit是为了代替main方法。

‍
使用Junit的步骤：
第一步：引入依赖
第二步：编写单元测试类【测试用例】，测试用例中每一个测试方法上使用@Test注解进行标注。
第三步：可以在类上执行，也可以在方法上执行

• 在类上执行时，该类中所有的测试方法都会执行。
• 在方法上执行时，只执行当前的测试方法。

junit依赖：

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

junit测试程序代码演示：

@Test
    public void testInsert() {
        SqlSession sqlSession = null;
        try {
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));
            sqlSession = sqlSessionFactory.openSession();
            int rows = sqlSession.insert("insertCar");
            System.out.println("影响的行数：" + rows);
            sqlSession.commit();
        } catch (Exception e) {
            if (sqlSession != null) {
                sqlSession.rollback();
            }
            e.printStackTrace();
        } finally {
            if (sqlSession != null) {
                sqlSession.close();
            }
        }
    }

5. Mybatis 集成日志框架logback

mybatis常见的集成的日志组件有哪些呢？

• SLF4J（沙拉风）：沙拉风是一个日志标准，其中有一个框架叫做logback，它实现了沙拉风规范。
• LOG4J
• LOG4J2
• STDOUT_LOGGING
• .......

注意：log4j log4j2 logback都是同一个作者开发的。
‍
其中STDOUT_LOGGING是标准日志，mybatis已经实现了这种标准日志。mybatis框架本身已经实现了这种标准。
只要开启即可。怎么开启呢？在mybatis-config.xml文件中使用settings标签进行配置开启。

这个标签在编写的时候要注意，它应该出现在environments标签之前。注意顺序。当然，不需要记忆这个顺序。
因为有dtd文件进行约束呢。我们只要参考dtd约束即可。
这种实现也是可以的，可以看到一些信息，比如：连接对象什么时候创建，什么时候关闭，sql语句是怎样的。
但是没有详细的日期，线程名字，等。如果你想使用更加丰富的配置，可以集成第三方的log组件。
集成logback日志框架。logback日志框架实现了slf4j标准。(沙拉风：日志门面。日志标准。)
第一步：引入logback的依赖。
第二步：引入logback所必须的xml配置文件。

• 这个配置文件的名字必须叫做：logback.xml或者logback-test.xml，不能是其它的名字。
• 这个配置文件必须放到类的根路径下。不能是其他位置。
• 主要配置日志输出相关的级别以及日志具体的格式。

logback依赖：

<!--引入logback依赖-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
            <!--<scope>test</scope>-->
        </dependency>

logback.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>

使用logback后 ，控制台打印的信息：

6. Mybatis 工具类的编写

public class SqlSessionUtil {

    // 工具类的构造方法一般都是私有化的。
    // 工具类中所有的方法都是静态的，直接采用类名即可调用。不需要new对象。
    // 为了防止new对象，构造方法私有化。
    private SqlSessionUtil(){}

    private static SqlSessionFactory sqlSessionFactory;

    // 类加载时执行
    // SqlSessionUtil工具类在进行第一次加载的时候，解析mybatis-config.xml文件。创建SqlSessionFactory对象。
    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /*public static SqlSession openSession(){
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // SqlSessionFactory对象：一个SqlSessionFactory对应一个environment，一个environment通常是一个数据库。
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }*/

    /**
     * 获取会话对象。
     * @return 会话对象
     */
    public static SqlSession openSession(){
        return sqlSessionFactory.openSession();
    }

}

‍