[Java]Mybatis学习笔记(动力节点老杜)

文章修改记录：
2023-02-01 第一版：https://www.yuque.com/u27599042/un32ge/mfpui3w5mgiugbhp
2023-06-04 完成重构 第二版：https://www.yuque.com/u27599042/un32ge/kggx3zvyg7mztgvd
手写 MyBatis 框架[GodBatis]第五章节单独抽取了出来：https://www.yuque.com/u27599042/un32ge/ru8czamo6trse3rl
文章汇总归纳于：https://www.yuque.com/u27599042/un32ge

老杜MyBatis原版笔记：https://www.yuque.com/zuihoudewu/java_note/mt2812
资料
1、javaWeb 链接：https://pan.baidu.com/s/1T3ouoZuZCMCAwPRv1Tahdg?pwd=5u25 提取码：5u25
2、主流框架 链接：https://pan.baidu.com/s/10HGe7wP1aed2HUCihc3-yQ?pwd=afjd 提取码：afjd
3、微服务架构 链接：https://pan.baidu.com/s/14RCkZXWyRP5hlOpDpp_ESQ?pwd=g0at 提取码：g0at
4、互联网生态 链接：https://pan.baidu.com/s/1IlM4LAU2gQqUMeN_B48t8w?pwd=egl7 提取码：egl7
6、架构师必会 链接：https://pan.baidu.com/s/10fPzIzSskuecnSxs4F4FRQ?pwd=s8tg 提取码：s8tg

MyBatis下载

• MyBatis GitHub 网址：https://github.com/mybatis/mybatis-3

• 

• 

• 

• 

MyBatis 文档

• MyBatis 官方文档：https://mybatis.org/mybatis-3/
• MyBatis 中文文档：https://mybatis.net.cn/
  

MyBatis 概述

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

ORM思想

• ORM：对象关系映射
  • O（Object）：Java虚拟机中的Java对象
  • R（Relational）：关系型数据库
  • M（Mapping）：映射，将Java虚拟机中的Java对象映射到数据库表中⼀⾏记录，或是将数据库表中⼀⾏记录映射成Java虚拟机中的⼀个Java对象。
• 在ORM思想中，一个Java类对应数据库中一个表，Java类中的属性对应数据库表中的字段，该Java类实例化出来的对象对应数据库表中的一条记录，Java对象的属性对应数据库表中相应记录的字段值，其中Java对象到数据库表中每条记录的对应关系为映射。
• 在ORM中，数据库表对应的Java类被称为pojo(普通Java类)、javabean(咖啡豆)或domain(邻域模型)。
  
  

Mybatis 与 ORM

• Mybatis可以实现Java对象与数据库表中一条记录的映射。
• MyBatis属于半⾃动化ORM框架。MyBatis中SQL语句需要我们自己编写。
• Hibernate属于全⾃动化的ORM框架。Hibernate中SQL语句不需要我们自己编写，SQL语句可以自动生成。

MyBatis框架特点

• ⽀持定制化 SQL、存储过程、基本映射以及⾼级映射
• 避免了⼏乎所有的 JDBC 代码中⼿动设置参数以及获取结果集
• ⽀持XML开发，也⽀持注解式开发。【为了保证sql语句的灵活，所以mybatis⼤部分是采⽤XML⽅式开发。】
• 将接⼝和 Java 的 POJOs(Plain Ordinary Java Object，简单普通的Java对象)映射成数据库中的记录
• 体积⼩好学：两个jar包，两个XML配置⽂件。
• 完全做到sql解耦合。
• 提供了基本映射标签。
• 提供了⾼级映射标签。
• 提供了XML标签，⽀持动态SQL的编写。
• …
  

MyBatis 入门程序

数据库表的准备

• 汽⻋表 t_car
  • id：主键（⾃增）【bigint】
  • car_num：汽⻋编号【varchar】
  • brand：品牌【varchar】
  • guide_price：⼚家指导价【decimal类型，专⻔为财务数据准备的类型】
  • produce_time：⽣产时间【char，年⽉⽇即可，10个⻓度，‘2022-10-11’】
  • car_type：汽⻋类型（燃油⻋、电⻋、氢能源）【varchar】
• 补充：数据库中的命名规范，数据库中字段名全部字母采用小写，如果字段名由多个单词组成，单词之间使用下划线进行分割

# 创建数据库
CREATE DATABASE mybatis_study;
# 使用数据库
USE mybatis_study;
# 创建表 汽⻋表t_car
CREATE TABLE t_car(
    id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '自然主键',
    car_num VARCHAR(255) COMMENT '汽车编号',
    brand VARCHAR(255) COMMENT '汽车品牌',
    guide_price DECIMAL(10, 2) COMMENT '厂家指导价',
    produce_time CHAR(10) COMMENT '生产时间 如：2022-10-11',
    car_type VARCHAR(255) COMMENT '汽车类型'
);
# 添加数据
INSERT INTO t_car(car_num, brand, guide_price, produce_time, car_type)
VALUES ('1001', '宝马520Li', 10.00, '2022-10-11', '燃油车'),
       ('1002', '奔驰E300L', 55.00, '2022-11-11', '新能源');

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eR8ThlDz-1685870936754)(https://www.yuque.com/api/filetransfer/images?url=https%3A%2F%2Fimg-blog.csdnimg.cn%2Fd860610f0184434e9077fb5027e9e597.png&sign=98ee78e42953c41fb0b78df7a3357393b05f83cceb62b7a4aa71fc680c7a3509#from=url&id=CPSPR&originHeight=179&originWidth=1135&originalType=binary&ratio=1.25&rotation=0&showTitle=false&status=done&style=none&title=)]

创建空项目

• 这里采用在工程 project 中创建模块 model 的形式

设置项目采用的编码

设置项目的Maven

设置项目使用的JDK

创建第一个 MyBatis 模块

• 快捷键：（选中要新建模块的项目）ALT + Ins

项目模块目录分析

• src目录下存放源程序
• main目录下存放源程序的主程序
• test目录下存放源程序的测试程序
• main/java目录下编写主程序的Java代码
• test/java目录下编写测试程序的Java代码
• resources目录用于存放配置文件或资源文件
  • 放在该目录下的文件，相当于放到了类的根路径下。
    

类根路径

• 不管是 maven 还是普通的 java 模块，只要是 idea 文件夹中变成蓝色的部分，就是可以理解为类路径的起始地点，之后的编译就是由蓝色文件夹开始算类路径，自定义文件夹后用 idea 标记为 resource 后的文件夹也会被最终打包到类路径下
• 图中的蓝色Java目录和resource目录都相当于类的根路径，就是打包后，包的根路径
  • 
  • 
  • 
• 由于test目录中的文件主要是测试程序，测试程序一般不会被打包到JAR包，test目录下的子目录和文件会被单独打包到另外的文件夹下
  • 
  • 
  • 
    

设置模块的打包方式

<groupId>cw</groupId>
<artifactId>mybatis-study-001</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 
  设置打包方式为 jar, 
  MyBatis 是封装 JDBC 的框架
  不创建web项目所以不需要使用war的打包方式 
-->
<packaging>jar</packaging>

引入依赖

• 由于MyBatis是封装JDBC的框架，用于操作数据库，且这里使用的数据库为MySQL
• 因此我们需要引入的依赖有：MyBatis依赖、MySQL驱动依赖

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

编写mybatis核心配置文件：mybatis-config.xml

• 
• 每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
• 通过官方文档中的这句话，我们可以得到：
  • 第一：在MyBatis中一定是有一个很重要的对象，SqlSessionFactory对象。
  • 第二：SqlSessionFactory对象需要通过SqlSessionFactoryBuilder实例加载读取XML配置文件来进行创建。
  • 第三：MyBatis 需要一个配置文件，这个配置文件的文件格式为XML。
• 由于 SqlSessionFactory 的实例是 MyBatis 的核心，所以与其创建相关的 xml 配置文件即为 MyBatis 的核心配置文件
• 在类根路径下创建 MyBatis 的核心配置文件：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/mybatis_study"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--sql映射⽂件创建好之后，需要将该⽂件路径配置到这⾥-->
        <mapper resource=""/>
    </mappers>
</configuration>

• 注意：
  • 第一：这个文件名不是必须叫做mybatis-config.xml，可以用其他的名字。只是大家都采用这个名字。
  • 第二：这个文件存放的位置也不是固定的，可以随意，但一般情况下，会放到类的根路径下。(打包后在jar包的根目录下)
    • MyBatis 包含一个名叫 Resources 的工具类，该工具类中有静态方法，可以从类路径加载资源文件。
• mybatis-config.xml 文件中的配置信息不理解没关系，先把连接数据库的信息修改以下即可。
  

编写 XxxxMapper.xml 文件

• MyBatis 是封装 JDBC 的框架，并且MyBatis是一个半自动化ORM框架，也就是需要我们自己编写SQL语句，在MyBatis中我们主要在 XxxxMapper.xml 文件中进行SQL语句的编写。所以我们还需要一个 XxxxMapper.xml 配置文件
• 在类根路径下，新建 CarMapper.xml 文件
  • 因为在该配置文件中，我们主要写操作t_car这个数据库表的SQL语句，所以文件名为 XxxxMapper.xml
  • 与t_car数据库表相关的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="car">
    <!--insert sql：保存⼀个汽⻋信息-->
    <!-- id 是这条SQL语句的唯一标识，这个id就代表了这条SQL语句 -->
    <insert id="insertCar">
        insert into t_car
            (id,car_num,brand,guide_price,produce_time,car_type)
        values
            (null,'102','丰⽥mirai',40.30,'2014-10-05','氢能源')
    </insert>
</mapper>

• 注意：
  • sql语句最后结尾可以不写“;”
  • CarMapper.xml文件的名字不是固定的。可以使用其它名字。
  • CarMapper.xml文件的位置也是随意的。
• 这里选择放在resources根下，相当于放到了类的根路径下。便于未来程序进行移植，同时也便于对该配置文件进行配置
  

在 mybatis-config.xml 文件中指定 XxxxMapper.xml 文件的路径

• 由于SQL语句，是我们自己在自己创建的配置文件中编写的，MyBatis并没有强制规定配置文件的存放路径和位置，也没有强制规定配置文件的文件名，所以我们需要通过配置告诉MyBatis框架我们编写SQL语句的配置文件存放的位置，以及配置文件的文件名
• 在前面，我们已经确定了MyBatis核心配置文件的配置，可以将其配置进MyBatis程序，所以我们可以通过将编写SQL的配置文件的路径和文件配置在核心配置文件中来告知MyBatis
• 修改MyBatis核心配置文件的 mapper 标签：

<mappers>
  <!-- sql映射⽂件创建好之后，需要将该⽂件路径配置到这⾥ -->
  <!-- 和 resource 相关的路径配置，默认都是从类根路径开始 -->
  <mapper resource="CarMapper.xml"/>
</mappers>

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

mybatis 中的两个主要配置文件

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

编写MyBatis程序

• 接下来，我们使用mybatis的类库，编写mybatis程序，连接数据库，做增删改查就行了。
• 在MyBatis当中，负责执行SQL语句的那个对象叫做什么呢？
  • SqlSession
  • SqlSession是专门用来执行SQL语句的，是一个Java程序和数据库之间的一次会话。
  • 要想获取SqlSession对象，我们就需要先获取SqlSessionFactory对象，通过SqlSessionFactory工厂对象来生产SqlSession对象。
• 怎么获取SqlSessionFactory对象呢？
  • 需要首先获取SqlSessionFactoryBuilder对象。
  • 通过SqlSessionFactoryBuilder对象的build方法，来获取一个SqlSessionFactory对象。
• mybatis的核心对象包括：
  • SqlSessionFactoryBuilder：用于创建SqlSessionFactory对象
  • SqlSessionFactory：用于创建SqlSession对象
  • SqlSession：Java程序和数据库之间进行会话的对象
• SqlSessionFactoryBuilder --> SqlSessionFactory --> SqlSession

/**
 * ClassName: Main
 * Package: cw.mybatis.study.main
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-25 23:55
 * @Version 1.0
 */
public class Main {
    public static void main(String[] args) throws IOException {
        // 获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    
        // 获取 SqlSessionFactory 对象
        // 获取 SqlSessionFactory 对象，需要读取配置文件，根据配置文件中的信息创建 SqlSessionFactory 对象
        // Resources.getResourceAsStream 默认就是从类的根路径下开始查找资源。
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); 
        // 以流的形式加载资源的方式二
        //InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");
        // 需要传入核心配置文件对应的输入流，一般情况下都是一个数据库对应一个 SqlSessionFactory 对象。
        // 根据配置文件中的信息创建 SqlSessionFactory 对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    
        // 通过 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession sqlSession = sqlSessionFactory.openSession(); // 开启与数据库之间的会话
    
        // 执行 SQL 语句
        // 传入SQL语句对应的id，执行配置文件中id对应的SQL语句，
        // 返回值是影响数据库表当中的记录条数。
        int count = sqlSession.insert("insertCar");
        System.out.println("插入了几条记录：" + count);
    
        // 手动提交事务
        // 注意：默认采用的事务管理器是：JDBC。
        // JDBC事务默认是不提交的，需要手动提交。
        sqlSession.commit();
        // 关闭本次与数据库的会话
        sqlSession.close();
    }
}

关于第一个程序的小细节

• mybatis中sql语句的结尾 “;” 可以省略。
• Resources.getResourceAsStream
  • 小技巧：以后凡是遇到resource这个单词，大部分情况下，这种加载资源的方式就是从类的根路径下开始加载（开始查找）
  • 优点：采用这种方式，从类路径当中加载资源，项目的移植性很强。项目从windows移植到linux，代码不需要修改，因为这个资源文件一直都在类路径当中。
• InputStream is = new FileInputStream("d:\\mybatis-config.xml");采用这种方式也可以。
  • 缺点：可移植性太差，程序不够健壮。可能会移植到其他的操作系统当中。导致以上路径无效，还需要修改java代码中的路径。这样违背了OCP原则。
• 已经验证了：
  • mybatis核心配置文件的名字，不一定是：mybatis-config.xml。可以是其它名字。
  • mybatis核心配置文件存放的路径，也不一定是在类的根路径下。可以放到其它位置。但为了项目的移植性，健壮性，最好将这个配置文件放到类路径下面。
  • 因为我们在通过核心配置文件mybatis-config.xml创建SqlSessionFactory对象时，配置文件的路径和文件名都是我们自己在程序中指定的
• 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文件的路径是固定的吗？
  • 都不是固定的。
  • <mapper resource="CarMapper.xml"/> resource属性：这种方式是从类路径当中加载资源。
  • <mapper url="file:///d:/CarMapper.xml"/> url属性：这种方式是从绝对路径当中加载资源。（绝对路径前需要加上file:///）
  • 由于CarMapper.xml文件的文件路径和文件名都是我们指定的，所以都不是固定的
    

关于 mybatis 的事务管理机制（剖析）

• 在mybatis-config.xml文件中，可以通过以下的配置进行mybatis的事务管理
  • <transactionManager type="JDBC"/>
  • type属性的值包括两个：
    • JDBC(jdbc)
    • MANAGED(managed)
    • type后面的值，只有以上两个值可选，不区分大小写。
• 在mybatis中提供了两种事务管理机制：
  • 第一种：JDBC事务管理器
  • 第二种：MANAGED事务管理器
    

JDBC事务管理器

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

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

// 获取SqlSession对象
// 如果使用的事务管理器是JDBC的话，底层实际上会执行：conn.setAutoCommit(false);
SqlSession sqlSession = sqlSessionFactory.openSession(); 

// 执行SQL语句
// 返回值是影响数据库表当中的记录条数。
int count = sqlSession.insert("insertCar"); 

System.out.println("插入了几条记录：" + count);

// 手动提交
// 如果使用的事务管理器是JDBC的话，底层实际上还是会执行conn.commit();
sqlSession.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，那么事务这块是没人管的。没有人管理事务表示事务压根没有开启。
• 没有人管理事务就是没有事务。不开启事务，autoCommit是true，就表示没有事务。只要执行任意一条DML语句就提交一次。
• JDBC中的事务：
  • 如果你没有在JDBC代码中执行：conn.setAutoCommit(false);的话，默认的autoCommit是true。
• 重点：
  • 以后注意了，只要你的autoCommit是true，就表示没有开启事务(事务自动提交)。
  • 只有你的autoCommit是false的时候，就表示开启了事务。
    

MyBatis第一个程序比较完整的代码写法

package cw.mybatis.study.main;

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.IOException;
import java.io.InputStream;

/**
 * ClassName: Main
 * Package: cw.mybatis.study.main
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-25 23:55
 * @Version 1.0
 */
public class Main {
    public static void main(String[] args){
        SqlSession sqlSession = null; // 与数据库会话的对象
        try {
            // 获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        
            // 获取 SqlSessionFactory 对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        
            // 通过 SqlSessionFactory 对象获取 SqlSession 对象
            // 开启与数据库之间的会话
            sqlSession = sqlSessionFactory.openSession();
        
            // 执行 SQL 语句
            int count = sqlSession.insert("insertCar");
            System.out.println("插入了几条记录：" + count);
    
            // 到这里没有报错，说明执行成功，可以提交本次事务
            // 手动提交事务
            sqlSession.commit();
        } catch (Exception e) {
            e.printStackTrace();
            // 由异常说明事务执行过程中出现错误
            // 回滚事务
            if (sqlSession != null) sqlSession.rollback();
        } finally {
            // 关闭本次与数据库的会话（释放资源）
            if (sqlSession != null) sqlSession.close();
        }
    }
}

引入 Junit

• Junit 是专⻔做单元测试的组件。
• 在实际开发中，单元测试⼀般是由我们 Java 程序员来完成的。我们要对我们⾃⼰写的每⼀个业务⽅法负责任，要保证每个业务⽅法在进⾏测试的时候都能通过。
• 测试的过程中涉及到两个概念：
  • 期望值：执行了这个业务方法之后，你期望的执行结果是什么
  • 实际值：被测试的业务方法的真正执行结果
  • 期望值和实际值相同表示测试通过，期望值和实际值不同则单元测试执⾏时会报错。
• 这里引⼊ Junit 是为了代替 main ⽅法
  

第一步：引入依赖

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

第二步：使用 Junit 进行测试

• 编写单元测试类，对我们的代码进行测试，测试类中的每⼀个测试⽅法上使用@Test注解进⾏标注
• 关于测试类的一写规范：
  • 测试类的类名：要进行测试的类 + Test
  • 测试类中的测试方法：一般是一个业务方法对应一个测试方式，测试方法的命名为test + 要测试方法的方法名，public void testXxxx() {}，每个测试方法需要使用@Test注解进行标注，表示该方法是一个单元测试方法

package com.powernode.junit.service;

import org.junit.Assert;
import org.junit.Test;

// 测试类的类名：要进行测试的类 + Test
public class MathServiceTest {

    @Test
    public void testSum(){
        // 单元测试中有两个重要的概念：
        // 一个是：实际值（被测试的业务方法的真正执行结果）
        // 一个是：期望值（执行了这个业务方法之后，你期望的执行结果是多少）
        MathService mathService = new MathService();
        // 获取实际值
        int actual = mathService.sum(1, 2);
        // 期望值
        //int expected = 3;
        int expected = 30;
        // 加断言进行测试，期望值与实际值不一致会报错
        Assert.assertEquals(expected, actual);
    }

    @Test
    public void testSub(){
        MathService mathService = new MathService();
        // 实际值
        int actual = mathService.sub(10, 5);
        // 期望值
        int expected = 5;
        // 添加断言机制，期望值与实际值一致则不会报错
        Assert.assertEquals(expected, actual);
    }

}

关于 MyBatis 集成日志组件

日志组件简述

• mybatis 常见的集成的日志组件有哪些呢？
  • SLF4J（沙拉风）：沙拉风是一个日志标准，其中有一个日志框架叫做logback，它实现了沙拉风规范。
  • LOG4J
  • LOG4J2
  • STDOUT_LOGGING
  • …
• log4j、log4j2、logback都是同一个作者开发的。
• STDOUT_LOGGING 是标准日志，mybatis 已经实现了这种标准日志，mybatis 框架本身已经实现了这种标准，只要开启即可。
  

开启 MyBatis 本身的日志功能

• 在 mybatis-config.xml 文件中使用settings标签进行配置开启。
  • 可参考mybatis⼿册：https://mybatis.net.cn/configuration.html#settings

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

• 这个标签在编写的时候要注意，它应该出现在 environments 标签之前，注意顺序。
  • 当然，不需要记忆这个顺序，因为有dtd文件进行约束，我们只要参考dtd约束即可，标签的顺序不正确会报错
• MyBatis 本身自己实现的日志框架也是可以的，可以看到一些信息，比如：连接对象什么时候创建，什么时候关闭，sql语句是怎样的。但是没有详细的日期，线程名字等。
  • 
• 如果想可以看到更加丰富的日志信息，可以集成第三方的log组件。
  

集成 logback 日志框架。

• logback日志框架实现了slf4j标准。(沙拉风：日志门面、日志标准)
• 在MyBatis使用标准日志 STDOUT_LOGGING 之外的其他日志框架，可以不在mybatis的配置文件中指定 MyBatis 所用日志的具体实现，未指定时将会自动查找，只需要引入相应日志框架的依赖以及日志框架的配置文件即可。
• 第一步：引入logback的依赖。

<!-- 引入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，不能是其它的名字。
  • 这个配置文件必须放到类的根路径下，不能是其他位置。

<?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>[%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="DEBUG">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE"/>
    </root>

</configuration>

MyBatis 工具类 SqlSessionUtil 的封装

package cw.mybatis.utils;

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

/**
 * Mybatis工具类
 */
public class SqlSessionUtils {
    // 工具类的构造方法一般为私有，防止实例化对象
    // 工具类中的方法都是静态的，可以直接采用类名进行调用，不需要new对象，方便调用
    private SqlSessionUtils() {}
    
    private static SqlSessionFactory sqlSessionFactory;
    
    // 类加载时执行
    // SqlSessionUtil工具类在进行第一次加载的时候，解析mybatis-config.xml文件。创建SqlSessionFactory对象。
    // SqlSessionFactory对象：一个SqlSessionFactory对应一个environment，一个environment通常是一个数据库。
    static {
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        try {
            sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 获取数据库会话对象
     * @return 数据库会话对象
     */
    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;
    }
}

• 测试：

package cw.mybatis.test;

import cw.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class SqlSessionUtilsTest {
    @Test
    public void testOpenSession() {
        SqlSession sqlSession = SqlSessionUtils.openSession();
        int count = sqlSession.insert("insertCar");
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();
    }
}

使用 MyBatis 完成 CRUD

• CRUD
  • C: Create 增
  • R: Retrieve 查（检索）
  • U: Update 改
  • D: Delete 删
    

insert

MyBatis 中 SQL 的编写

<!--namespace先随便写-->
<mapper namespace="car">
		<!-- 在insert标签中写向数据库中插入数据的SQL -->
    <insert id="insertCar">
        insert into t_car(car_num,brand,guide_price,produce_time,car_type) 
      	values('103', '奔驰E300L', 50.3, '2022-01-01', '燃油车')
    </insert>
</mapper>

• 这样写的问题是：插入数据库的值写死到配置文件中的。这个在实际开发中是不存在的。一定是前端的form表单提交过来数据。然后将值传给sql语句。
• JDBC 的代码的写法

String sql = "insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values(null,?,?,?,?,?)";
ps.setString(1, xxx);
ps.setString(2, yyy);
....

• 在JDBC当中占位符采用的是?，在mybatis当中是什么呢？
  • 和?等效的写法是：#{}
• 在mybatis当中不能使用?占位符，必须使用 #{} 来代替JDBC当中的 ?
• #{} 和 JDBC当中的 ? 是等效的。

<!--namespace先随便写-->
<mapper namespace="car">
    <insert id="insertCar">
        insert into t_car(car_num,brand,guide_price,produce_time,car_type) 
      	values(#{}, #{}, #{}, #{}, #{})
    </insert>
</mapper>

使用Map集合传参

• java程序中使用Map可以给SQL语句的占位符传值，占位符中写map集合的key，如果key不存在，获取的是null，一般map集合的key起名的时候要见名知意。

<mapper namespace="car">
    <!--insert sql：保存⼀个汽⻋信息-->
    <insert id="insertCar">
        insert into t_car
            (id,car_num,brand,guide_price,produce_time,car_type)
        values
            (null, #{k1}, #{k2}, #{k3}, #{k4}, #{k5})
    </insert>
</mapper>

package cw.mybatis;

import cw.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.HashMap;
import java.util.Map;

public class CarMapperTest {
	
	@Test
    public void testInsertCar() {
        // 使用map集合进行数据的封装。
        Map<String, Object> map = new HashMap<>();
        map.put("k1", "1111");
        map.put("k2", "比亚迪汉");
        map.put("k3", 10.0);
        map.put("k4", "2020-11-11");
        map.put("k5", "电车");
        
        // 获取与数据库的会话对象
        SqlSession sqlSession = SqlSessionUtils.openSession();
    
        // 执行SQL语句
        // insert SQL 使用 insert方法
        // insert方法的参数：
        // 第一个参数：sqlId，从CarMapper.xml文件中复制。
        // 第二个参数：封装数据的对象。
        sqlSession.insert("insertCar", map);
        
        sqlSession.commit();
        sqlSession.close();
    }
}

使用POJO(简单普通的java对象)传参

• 第一步：定义一个pojo类Car，提供相关属性

package cw.mybatis.pojo;

/**
 * 封装汽车相关信息的pojo类。普通的java类。
 */
public class Car {
    // 数据库表当中的字段应该和pojo类的属性一一对应。
    // 建议使用包装类，这样可以防止null的问题。
    private Long id;
    private String carNum;
    private String brand;
    private Double guidePrice;
    private String produceTime;
    private String carType;
    
    public Car() {
    }
    
    public Car(Long id, String carNum, String brand, Double guidePrice, String produceTime, String carType) {
        this.id = id;
        this.carNum = carNum;
        this.brand = brand;
        this.guidePrice = guidePrice;
        this.produceTime = produceTime;
        this.carType = carType;
    }
    
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public String getCarNum() {
        return carNum;
    }
    
    public void setCarNum(String carNum) {
        this.carNum = carNum;
    }
    
    public String getBrand() {
        return brand;
    }
    
    public void setBrand(String brand) {
        this.brand = brand;
    }
    
    public Double getGuidePrice() {
        return guidePrice;
    }
    
    public void setGuidePrice(Double guidePrice) {
        this.guidePrice = guidePrice;
    }
    
    public String getProduceTime() {
        return produceTime;
    }
    
    public void setProduceTime(String produceTime) {
        this.produceTime = produceTime;
    }
    
    public String getCarType() {
        return carType;
    }
    
    public void setCarType(String carType) {
        this.carType = carType;
    }
    
    @Override
    public String toString() {
        return "Car{" + "id=" + id + ", carNum='" + carNum + '\'' + ", brand='" + brand + '\'' + ", guidePrice=" + guidePrice + ", produceTime='" + produceTime + '\'' + ", carType='" + carType + '\'' + '}';
    }
}

• 第二步：Java程序

@Test
public void testInsertCarPOJO() {
    // 封装数据
    Car car = new Car(null, "3333", "比亚迪", 30.0, "2020-11-11", "新能源");

    SqlSession sqlSession = SqlSessionUtils.openSession();
    
    // 执行sql
    sqlSession.insert("insertCar", car);
    
    sqlSession.commit();
    sqlSession.close();
}

• 第三步：SQL语句

<mapper namespace="car">
    <!--insert sql：保存⼀个汽⻋信息-->
    <!-- 占位符 #{} 中写POJO的属性名 -->
    <insert id="insertCar">
        insert into t_car
            (id,car_num,brand,guide_price,produce_time,car_type)
        values
            (null, #{carNum}, #{brand}, #{guidePrice}, #{produceTime}, #{carType})
    </insert>
</mapper>

MyBatis 如何获取 POJO 属性值分析

• 如果把SQL语句写成如下这个德行：

insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
values(null,#{xyz},#{brand},#{guidePrice},#{produceTime},#{carType})

• 出现了什么问题呢？
  • There is no getter for property named 'xyz' in 'class com.powernode.mybatis.pojo.Car'
  • mybatis去找：Car类中的getXyz()方法去了。没找到。报错了。
• 怎么解决的？
  • 可以在Car类中提供一个getXyz()方法。这样问题就解决了。
• 通过这个测试，得出一个结论：
  • 严格意义上来说：如果使用POJO对象传递值的话，#{}这个大括号中到底写什么？
  • 写的是get方法的方法名去掉get，然后将剩下的单词首字母小写，然后放进去。
    • 例如：getUsername() --> #{username}
    • 例如：getEmail() --> #{email}
    • …
• 也就是说mybatis在底层给?传值的时候，先要获取值，怎么获取的？
  • 调用了pojo对象的get方法。例如：car.getCarNum()，car.getCarType()，car.getBrand()
    

SQL 语句标签的 parameterType 属性

• 其实传参数的时候有一个属性parameterType，这个属性用来指定传参的数据类型，不过这个属性是可以省略的

<insert id="insertCar" parameterType="java.util.Map">
  insert into t_car(car_num,brand,guide_price,produce_time,car_type) values(#{carNum},#{brand},#{guidePrice},#{produceTime},#{carType})
</insert>

<insert id="insertCarByPOJO" parameterType="com.powernode.mybatis.pojo.Car">
  insert into t_car(car_num,brand,guide_price,produce_time,car_type) values(#{carNum},#{brand},#{guidePrice},#{produceTime},#{carType})
</insert>

delete

• 需求：根据id删除数据
• SQL语句

<!-- 当sql语句中的占位符只有一个时，占位符中的内容可以任意写，但是不能不写，一般采用见名知意的命名 -->
<!-- 只有一个占位符时，mybatis可以知道数据填放的位置 -->
<delete id="deleteById">
    delete from t_car where id = #{id}
</delete>

• java程序

@Test
public void testDeleteById() {
    SqlSession sqlSession = SqlSessionUtils.openSession();

	// 第二个参数会被自动装箱成相应的类型
    sqlSession.delete("deleteById", 10);
    
    sqlSession.commit();
    sqlSession.close();
}

• 注意：如果占位符只有一个，那么#{}的大括号里可以随意。但是最好见名知意。
  

update

• 需求：根据id修改某条记录。

<update id="updateById">
    update t_car set
        car_num = #{carNum}, brand = #{brand},
        guide_price = #{guidePrice}, produce_time = #{produceTime},
        car_type = #{carType}
    where id = #{id}
</update>

@Test
public void testUpdateById() {
    SqlSession sqlSession = SqlSessionUtils.openSession();

    // 封装数据
    Car car = new Car(4L, "9999", "凯美瑞", 30.3, "1999-11-10", "燃油车");

    int count = sqlSession.update("updateById", car);
    System.out.println(count);
    
    sqlSession.commit();
    sqlSession.close();
}

select

• select语句查询会有一个结果集
  

查一条数据

• 需求：根据id查询。
• 查询时需要告诉mybatis查询结果集封装成的java对象类型，select标签中resultType属性，这个属性用来告诉mybatis，查询结果集封装成什么类型的java对象。
• select标签中resultType通常写的是：全限定类名。
• 如果表的字段名与相应的java类的属性名不一致可以使用别名为查询语句的字段指定别名，来解决不能为java对象属性赋值的问题

<!-- 
	sql语句中如果表的字段名与相应的java类的属性名不一致需要使用别名为查询语句的字段指定别名，
	否则对应字段的查询为null 
-->
<select id="selectById" resultType="cw.mybatis.pojo.Car">
    select
        id,car_num as carNum,brand,guide_price as guidePrice,
        produce_time as produceTime,
        car_type as carType
    from
        t_car
    where
        id = #{id}
</select>

@Test
public void testSelectById() {
    SqlSession sqlSession = SqlSessionUtils.openSession();

    // 执行DQL语句。查询。根据id查询。返回结果一定是一条。
    // mybatis底层执行了select语句之后，一定会返回一个结果集对象：ResultSet
    // JDBC中叫做ResultSet，接下来就是mybatis应该从ResultSet中取出数据，封装java对象。
    Object car = sqlSession.selectOne("selectById", 1);
    System.out.println(car);

    sqlSession.close();
}

查多条数据

<!-- 
resultType还是指定要封装的结果集的类型。
不是指定List类型，是指定List集合中元素的类型。 
-->
<select id="selectAll" resultType="cw.mybatis.pojo.Car">
    select
        id,car_num as carNum,brand,guide_price as guidePrice,
        produce_time as produceTime,
        car_type as carType
    from
        t_car
</select>

@Test
public void testSelectAll() {
    SqlSession sqlSession = SqlSessionUtils.openSession();

    // selectList方法：mybatis通过这个方法就可以得知你需要一个List集合。
    // 它会自动给你返回一个List集合。
    List<Car> cars = sqlSession.selectList("selectAll");
    cars.forEach(System.out::println);

    sqlSession.close();
}

SQL Mapper 的 namespace

• 在sql mapper.xml文件当中有一个namespace,这个属性是用来指定命名空间的。用来防止id重复。
• 当不同的 SQLMapper 映射文件中，存在 sqlId 相同的两个SQL语句，若使用SQL语句时不使用命名空间，则会报错
• 命名空间的使用 namespace.sqlId （MyBatis中sqlId的完整写法）
• 实际上，本质上，mybatis中的sqlId的完整写法：namespace.id
• 创建CarMapper2.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">

<mapper namespace="car2">
    <select id="selectCarAll" resultType="com.powernode.mybatis.pojo.Car">
        select
            id, car_num as carNum, brand, guide_price as guidePrice, produce_time as produceTime, car_type as carType
        from
            t_car
    </select>
</mapper>

• CarMapper.xml和CarMapper2.xml文件中都有 id=“selectCarAll”
• 将CarMapper2.xml配置到mybatis-config.xml文件中。

<mappers>
  <mapper resource="CarMapper.xml"/>
  <mapper resource="CarMapper2.xml"/>
</mappers>

• Java代码

@Test
public void testSelectAll() {
    SqlSession sqlSession = SqlSessionUtils.openSession();

    List<Car> cars = sqlSession.selectList("selectAll");
    cars.forEach(System.out::println);

    sqlSession.close();
}

org.apache.ibatis.exceptions.PersistenceException: 
### Error querying database.  Cause: java.lang.IllegalArgumentException: 
  selectCarAll is ambiguous in Mapped Statements collection (try using the full name including the namespace, or rename one of the entries) 
【翻译】selectCarAll在Mapped Statements集合中不明确（请尝试使用包含名称空间的全名，或重命名其中一个条目）
【大致意思是】selectCarAll重名了，你要么在selectCarAll前添加一个名称空间，要有你改个其它名字。

• Java代码修改如下：

@Test
public void testSelectAll() {
    SqlSession sqlSession = SqlSessionUtils.openSession();

    // SQL id：namespace.id
    List<Car> cars = sqlSession.selectList("car.selectAll");
    cars.forEach(System.out::println);

    sqlSession.close();
}

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>
    <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>
        <mapper resource="CarMapper.xml"/>
        <mapper resource="CarMapper2.xml"/>
    </mappers>
</configuration>

• configuration：根标签，表示配置信息。
• environments：环境（多个），以“s”结尾表示复数，也就是说mybatis的环境可以配置多个数据源。
  • default属性：表示默认使用的是哪个环境，default后面填写的是environment的id。default的值只需要和environment的id值一致即可。
• environment：具体的环境配置（主要包括：事务管理器的配置 + 数据源的配置）
  • id：给当前环境一个唯一标识，该标识用在environments的default后面，用来指定默认环境的选择。
• transactionManager：配置事务管理器
  • type属性：指定事务管理器具体使用什么方式，可选值包括两个
    • JDBC：使用JDBC原生的事务管理机制。底层原理：事务开启conn.setAutoCommit(false); …处理业务…事务提交conn.commit();
    • MANAGED：交给其它容器来管理事务，比如WebLogic、JBOSS等。如果没有管理事务的容器，则没有事务。没有事务的含义：只要执行一条DML语句，则提交一次。
• dataSource：指定数据源
  • type属性：用来指定具体使用的数据库连接池的策略，可选值包括三个
    • UNPOOLED：采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。
      • property可以是：
        • driver 这是 JDBC 驱动的 Java 类全限定名。
        • url 这是数据库的 JDBC URL 地址。
        • username 登录数据库的用户名。
        • password 登录数据库的密码。
        • defaultTransactionIsolationLevel 默认的连接事务隔离级别。
        • defaultNetworkTimeout 等待数据库操作完成的默认网络超时时间（单位：毫秒）
    • POOLED：采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现。
      • property可以是（除了包含UNPOOLED中之外）：
        • poolMaximumActiveConnections 在任意时间可存在的活动（正在使用）连接数量，默认值：10
        • poolMaximumIdleConnections 任意时间可能存在的空闲连接数。
        • 其它…
    • JNDI：采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。如果不是web或者maven的war工程，JNDI是不能使用的。
      • property可以是（最多只包含以下两个属性）：
        • initial_context 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。
        • data_source 这是引用数据源实例位置的上下文路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。
• mappers：在mappers标签中可以配置多个sql映射文件的路径。
• mapper：配置某个sql映射文件的路径
  • resource属性：使用相对于类路径的资源引用方式
  • url属性：使用完全限定资源定位符（URL）方式
    

各标签拆分解释说明版

文档类型说明

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

• 文档类型说明中的 configuration，是根标签的名称，一个文档只有一个根标签
• http://mybatis.org/dtd/mybatis-3-config.dtd 是xml文档的dtd约束，约束文档中可以出现什么标签、标签能有什么子标签、标签中可以有什么属性、标签属性可以具有的值以及标签出现的顺序
  

根标签

<configuration>
  ...
</configuration>

• configuration：根标签，表示配置信息
  

properties

• java.util.Properties类，是一个Map集合，key和value都是String类型
• property标签中的name属性为key，value属性为value
• 在properties标签中可以配置很多属性
• 在properties下面的标签中可以使用property配置的属性值，使用 ${property的name属性} 取出相应的值

<properties>
		<!-- <property name="属性名" value="属性值"/> -->
    <property name="jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
    <property name="jdbc.url" value="jdbc:mysql://localhost:3306/powernode"/>
    <property name="jdbc.username" value="root"/>
    <property name="jdbc.password" value="root"/>
</properties>

<dataSource type="POOLED">
    <property name="driver" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</dataSource>

从指定路径下开始查找配置文件

• properties中的property可以配置到配置文件中

<!-- resource，从类路径下开始查找资源 -->
<properties resource="jdbc.properties" />

<!-- 从绝对路径当中加载资源 -->
<!-- 绝对路径怎么写？file:///路径 -->
<properties url="file:///d:/jdbc.properties" />

environments

<environments default="powernodeDB">
  ...
</environments>

• 在 environments 标签中配置数据库环境，可以配置多个数据库环境
• default 表示默认使用的数据库环境
  • 当你使用mybatis创建SqlSessionFactory对象的时候，没有指定数据库环境的话，默认使用 default 属性指定的数据库环境
    

environment

• environments 的子标签，在 environment 标签中配置每一个数据库环境
• 一般一个数据库会对应一个SqlSessionFactory对象，一个环境environment会对应一个SqlSessionFactory对象，所以一个数据库一般对应一个环境

<!-- 第一个数据库环境 -->
<environment id="powernodeDB">
    <transactionManager type="JDBC"/>
    <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="poolMaximumActiveConnections" value="10"/>
        <property name="poolTimeToWait" value="2000"/>
        <property name="poolMaximumCheckoutTime" value="10000"/>
        <property name="poolMaximumIdleConnections" value="5"/>
    </dataSource>
</environment>

<!-- 第二个数据库环境 -->
<environment id="mybatisDB">
    <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="root"/>
    </dataSource>
</environment>

默认方式获取 SqlSessionFactory 对象

SqlSessionFactory sqlSessionFactory = 
	sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));

• 这种方式就是获取默认数据库环境
• 该 SqlSessionFactory 对象对应在 environments 标签的 default 属性中指定的数据库环境
  

通过数据库环境id获取 SqlSessionFactory 对象

SqlSessionFactory sqlSessionFactory1 =
	sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"), "powernodeDB");

• 第二个参数为数据库环境id
• 这种方式就是通过数据库环境id来使用指定的数据库环境
• 通过该方式获取的 SqlSessionFactory 对象对应 id 相应的数据库环境
  

transactionManager

<transactionManager type="JDBC"/>

• 作用：配置事务管理器，指定mybatis具体使用什么方式去管理事务。
• type属性有两个值：
  • 第一个：JDBC: 使用原生的JDBC代码来管理事务。
  • conn.setAutoCommit(false);
  • ...
  • conn.commit();
  • 第二个：MANAGED：mybatis不再负责事务的管理，将事务管理交给其它的JEE(JavaEE)容器来管理。
    • 例如：spring
  • 大小写无所谓。不缺分大小写。但是不能写其他值。只能是二选一： jdbc、managed
• 在mybatis中提供了一个事务管理器接口：Transaction
  • 该接口下有两个实现类：
    • JdbcTransaction
    • ManagedTransaction
• 如果type=“JDBC”，那么底层会实例化JdbcTransaction对象。
• 如果type=“MANAGED”，那么底层会实例化ManagedTransaction
  

dataSource

<dataSource type="POOLED">
    <property name="driver" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</dataSource>

• dataSource被称为数据源。
• dataSource的作用：为程序提供Connection对象。
  • 凡是给程序提供Connection对象的，都叫做数据源。
• 数据源实际上是一套规范。
  • JDK中有这套规范：javax.sql.DataSource，这个数据源的规范，这套接口是JDK规定的。
  • 我们自己也可以编写数据源组件，只要实现javax.sql.DataSource接口就行，实现接口当中所有的方法。
• 常见的数据源组件有哪些呢【常见的数据库连接池有哪些呢】？
  • 阿里巴巴的德鲁伊连接池：druid
  • c3p0
  • dbcp
  • …
• type属性用来指定数据源的类型，就是指定具体使用什么方式来获取Connection对象：
  • type属性有三个值：必须是三选一。
  • type=“[UNPOOLED|POOLED|JNDI]”
  • UNPOOLED：不使用数据库连接池技术。每一次请求过来之后，都是创建新的Connection对象。
  • POOLED：使用mybatis自己实现的数据库连接池。
  • JNDI：集成其它第三方的数据库连接池。
    • JNDI是一套规范，大部分的web容器都实现了JNDI规范，例如：Tomcat、Jetty、WebLogic、WebSphere，这些服务器(容器)都实现了JNDI规范。
    • JNDI是：java命名目录接口。Tomcat服务器实现了这个规范。
    • 就好比，WEB容器实现了这个规范，为第三方数据库连接池提供了一个接入到web项目的“接口”，第三方数据库连接池可以通过该“接口”接入web项目，web项目中可以直接通过JNDI来使用第三方数据库连接池
  • 数据源的type属性指定不同的值，可以配置不同的属性 https://mybatis.net.cn/configuration.html#environments

<dataSource type="POOLED">
    <property name="driver" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <!-- 以下配置数据库连接池的参数 -->
    <!--提醒：正常使用连接池的话，池中有很多参数是需要设置的。设置好参数，可以让连接池发挥的更好。事半功倍的效果。-->
    <!--具体连接池当中的参数如何配置呢？需要反复的根据当前业务情况进行测试。-->
    <!--poolMaximumActiveConnections：连接池当中最多的正在使用的连接对象的数量上限。最多有多少个连接可以活动。默认值10-->
    <property name="poolMaximumActiveConnections" value="10"/>
    <!--每隔2秒打印日志，并且尝试获取连接对象-->
    <property name="poolTimeToWait" value="2000"/>
    <!--强行让某个连接空闲，超时时间的设置-->
    <property name="poolMaximumCheckoutTime" value="10000"/>
    <!--最多的空闲数量-->
    <!--
        假设最多的连接数量为10个，最多空闲数量为5个，现在已经空闲5个了，马上第六个也要空闲了
        如果第六个空闲下来，连接池为了保证空闲的数量最多5个，会真正关闭多余的空闲连接对象
        可以节省系统资源
    -->
    <property name="poolMaximumIdleConnections" value="5"/>
</dataSource>

mappers

• 在mappers标签中可以配置多个sql映射文件的路径

<mappers>
    <!-- mapper：配置某个sql映射文件的路径 -->
    <!-- resource属性：使用相对于类路径的资源引用方式 -->
    <!-- url属性：使用完全限定资源定位符（URL）方式 -->
    <mapper resource="CarMapper.xml"/>
</mappers>

代码文档注释版

<?xml version="1.0" encoding="UTF-8" ?>
<!-- 文档类型说明中的 configuration，是根标签的名称，一个文档一个根标签 -->
<!--
    http://mybatis.org/dtd/mybatis-3-config.dtd
    xml文档的dtd约束，约束文档中可以出现什么标签、标签能有什么子标签、标签中可以有什么属性以及标签出现的顺序
-->
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!-- configuration：根标签，表示配置信息。 -->
<configuration>

    <!--java.util.Properties类。是一个Map集合。key和value都是String类型-->
    <!-- property标签中的name属性为key，value属性为value -->
    <!--在properties标签中可以配置很多属性-->
    <!-- 在下面的标签中可以使用property配置的属性值，使用 ${property的name属性} 取出相应的值 -->
    <!--<properties>-->
        <!--这是其中的一个属性-->
        <!--<property name="属性名" value="属性值"/>-->
        <!--<property name="jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbc.url" value="jdbc:mysql://localhost:3306/powernode"/>
        <property name="jdbc.username" value="root"/>
        <property name="jdbc.password" value="root"/>-->
    <!--</properties>-->

    <!-- properties中的property可以配置到配置文件中 -->
    <!--resource,一定是从类路径下开始查找资源-->
    <properties resource="jdbc.properties" />

    <!--从绝对路径当中加载资源。绝对路径怎么写？file:///路径-->
    <!--<properties url="file:///d:/jdbc.properties" />-->


    <!-- environments：环境（多个），以“s”结尾表示复数，也就是说mybatis的环境可以配置多个数据源。 -->
    <!--default表示默认使用的环境。-->
    <!--默认环境什么意思？当你使用mybatis创建SqlSessionFactory对象的时候，没有指定环境的话，默认使用哪个环境。-->
    <environments default="powernodeDB">

        <!--其中的一个环境。连接的数据库是powernode-->
        <!--一般一个数据库会对应一个SqlSessionFactory对象。-->
        <!--一个环境environment会对应一个SqlSessionFactory对象-->
        <!-- 一个数据库对应一个环境 -->
        <!--
            // 这种方式就是获取的默认环境
            SqlSessionFactory sqlSessionFactory =
                   sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
            // 这种方式就是通过环境id来使用指定的环境，第二个参数为环境id
            SqlSessionFactory sqlSessionFactory1 =
                sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"), "powernodeDB");
        -->
        <environment id="powernodeDB">
            <!--
                transactionManager标签：
                    1.作用：配置事务管理器。指定mybatis具体使用什么方式去管理事务。
                    2.type属性有两个值：
                        第一个：JDBC: 使用原生的JDBC代码来管理事务。
                            conn.setAutoCommit(false);
                            ....
                            conn.commit();
                        第二个：MANAGED：mybatis不再负责事务的管理，将事务管理交给其它的JEE(JavaEE)容器来管理。例如：spring
                    3. 大小写无所谓。不缺分大小写。但是不能写其他值。只能是二选一：
                        jdbc、managed
                    4. 在mybatis中提供了一个事务管理器接口：Transaction
                        该接口下有两个实现类：
                            JdbcTransaction
                            ManagedTransaction
                        如果type="JDBC"，那么底层会实例化JdbcTransaction对象。
                        如果type="MANAGED"，那么底层会实例化ManagedTransaction
            -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource配置：
                    1.dataSource被称为数据源。
                    2.dataSource作用是什么？为程序提供Connection对象。（但凡是给程序提供Connection对象的，都叫做数据源。）
                    3.数据源实际上是一套规范。JDK中有这套规范：javax.sql.DataSource（这个数据源的规范，这套接口实际上是JDK规定的。）
                    4.我们自己也可以编写数据源组件，只要实现javax.sql.DataSource接口就行了。实现接口当中所有的方法。这样就有了自己的数据源。
                    比如你可以写一个属于自己的数据库连接池（数据库连接池是提供连接对象的，所以数据库连接池就是一个数据源）。
                    5.常见的数据源组件有哪些呢【常见的数据库连接池有哪些呢】？
                        阿里巴巴的德鲁伊连接池：druid
                        c3p0
                        dbcp
                        ....
                    6. type属性用来指定数据源的类型，就是指定具体使用什么方式来获取Connection对象：
                        type属性有三个值：必须是三选一。
                        type="[UNPOOLED|POOLED|JNDI]"
                        UNPOOLED：不使用数据库连接池技术。每一次请求过来之后，都是创建新的Connection对象。
                        POOLED：使用mybatis自己实现的数据库连接池。
                        JNDI：集成其它第三方的数据库连接池。

                        JNDI是一套规范。谁实现了这套规范呢？大部分的web容器都实现了JNDI规范：
                            例如：Tomcat、Jetty、WebLogic、WebSphere，这些服务器(容器)都实现了JNDI规范。
                        JNDI是：java命名目录接口。Tomcat服务器实现了这个规范。
            -->
            <!-- 数据源的type属性指定不同的值，需要配置不太的属性 https://mybatis.net.cn/configuration.html#environments -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
                <!-- 以下配置数据库连接池的参数 -->
                <!--提醒：正常使用连接池的话，池中有很多参数是需要设置的。设置好参数，可以让连接池发挥的更好。事半功倍的效果。-->
                <!--具体连接池当中的参数如何配置呢？需要反复的根据当前业务情况进行测试。-->
                <!--poolMaximumActiveConnections：连接池当中最多的正在使用的连接对象的数量上限。最多有多少个连接可以活动。默认值10-->
                <property name="poolMaximumActiveConnections" value="10"/>
                <!--每隔2秒打印日志，并且尝试获取连接对象-->
                <property name="poolTimeToWait" value="2000"/>
                <!--强行让某个连接空闲，超时时间的设置-->
                <property name="poolMaximumCheckoutTime" value="10000"/>
                <!--最多的空闲数量-->
                <!--
                    假设最多的连接数量为10个，最多空闲数量为5个，现在已经空闲5个了，马上第六个也要空闲了
                    如果第六个空闲下来，连接池为了保证空闲的数量最多5个，会真正关闭多余的空闲连接对象
                    可以节省系统资源
                -->
                <property name="poolMaximumIdleConnections" value="5"/>
            </dataSource>

        </environment>

        <!--这是mybatis的另一个环境，也就是连接的数据库是另一个数据库mybatis-->
        <environment id="mybatisDB">
            <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="root"/>
            </dataSource>
        </environment>

    </environments>

    <!-- mappers：在mappers标签中可以配置多个sql映射文件的路径。 -->
    <mappers>
        <!-- mapper：配置某个sql映射文件的路径 -->
        <!-- resource属性：使用相对于类路径的资源引用方式 -->
        <!-- url属性：使用完全限定资源定位符（URL）方式 -->
        <mapper resource="CarMapper.xml"/>
    </mappers>
</configuration>

手写MyBatis框架

• 手写 MyBatis 框架[GodBatis]：https://www.yuque.com/u27599042/un32ge/ru8czamo6trse3rl
  

在 WEB 中应用 MyBatis（MVC架构模式）

• 实现功能：银行账户转账
• 使用技术：HTML + Servlet + MyBatis
• WEB应用的名称：bank
  

需求描述

数据库表的设计和准备数据

USE dbtest;

DROP TABLE IF EXISTS t_act;

CREATE TABLE t_act (
    id int PRIMARY KEY AUTO_INCREMENT,
    actno VARCHAR(255),
    balance DECIMAL(10, 2)
);

INSERT INTO t_act(actno, balance) VALUES ('act001', 50000);
INSERT INTO t_act(actno, balance) VALUES ('act002', 0);

环境搭建

• IDEA中使用Maven原型创建WEB应用
• 
• 
• 使用Maven原型创建的web应用默认没有java和resources目录，包括两种解决方案
  • 
  • 第一种：自己手动加上。
    • 
  • 第二种：找到原型jar包所在的位置，修改maven-archetype-webapp-1.4.jar中的配置文件
    
    
• web.xml文件的版本较低，可以从tomcat的样例文件中复制，然后修改

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
</web-app>

• 删除index.jsp文件，因为我们这个项目不使用JSP，使用html。
  • 
• 确定pom.xml文件中的打包方式是war包。

<packaging>war</packaging>

• 引入相关依赖

<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>
  <!-- servlet依赖 -->
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
  </dependency>
  <!-- logback依赖 -->
  <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.5</version>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
  </dependency>
</dependencies>

• 编译器版本修改为17

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>17</maven.compiler.source>
		<maven.compiler.target>17</maven.compiler.target>
	</properties>

• IDEA配置Tomcat，并部署应用到tomcat，应用名 bank
• 准备相关配置文件，放到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>

    <properties resource="jdbc.properties"/>

    <environments default="dev">
        <environment id="dev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="AccountMapper.xml"/>
    </mappers>
</configuration>

• AccountMapper.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">

<mapper namespace="account">

</mapper>

• 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>

• jdbc.properties

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

前端页面 index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>银行账户转账</title>
</head>
<body>
<!--/bank是应用的根，部署web应用到tomcat的时候一定要注意这个名字-->
<form action="/bank/transfer" method="post">
    转出账户：<input type="text" name="fromActno"/><br>
    转入账户：<input type="text" name="toActno"/><br>
    转账金额：<input type="text" name="money"/><br>
    <input type="submit" value="转账"/>
</form>
</body>
</html>

创建软件包（MVC架构模式）

工具类 SqlSessionUtil

package cw.study.mybatis.utils;

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

/**
 * ClassName: SqlSessionUtil
 * Package: cw.study.mybatis.utils
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-28 14:32
 * @Version 1.0
 */
public class SqlSessionUtil {
    
    private SqlSessionUtil(){}
    
    private static SqlSessionFactory sqlSessionFactory;
    
    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 获取会话对象。
     * @return 会话对象
     */
    public static SqlSession openSession(){
        return sqlSessionFactory.openSession();
    }
    
}

定义实体类 Account

public class Account {
    private Long id;
    private String actno;
    private Double balance;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", actno='" + actno + '\'' +
                ", balance=" + balance +
                '}';
    }

    public Account() {
    }

    public Account(Long id, String actno, Double balance) {
        this.id = id;
        this.actno = actno;
        this.balance = balance;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public Double getBalance() {
        return balance;
    }

    public void setBalance(Double balance) {
        this.balance = balance;
    }
}

后端代码实现

@WebServlet({"/transfer"})
public class AccountServlet extends HttpServlet {
    
    // 为了让这个对象在其他方法中也可以用。声明为实例变量。
    private AccountService accountService = new AccountServiceImpl();
    
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获取数据
        String fromActno = request.getParameter("fromActno");
        String toActno = request.getParameter("toActno");
        double money = Double.parseDouble(request.getParameter("money"));
        // 调用业务层
        try {
            accountService.transfer(fromActno, toActno, money);
            // 到这转账成功
            // 调用视图完成结果展示
            response.sendRedirect(request.getContextPath() + "/success.html");
        } catch (MoneyNotEnoughException e) {
            response.sendRedirect(request.getContextPath() + "/error1.html");
        } catch (TransferException e) {
            response.sendRedirect(request.getContextPath() + "/error2.html");
        } catch (Exception e) {
            response.sendRedirect(request.getContextPath() + "/error2.html");
        }
        
    }
}

/**
 * 注意：业务类当中的业务方法的名字在起名的时候，最好见名知意，能够体现出具体的业务是做什么的。
 * 账户业务类
 */
public interface AccountService {
    
    /**
     * 转账业务
     * @param fromActno 转出账户
     * @param toActno 转入账户
     * @param money 转账金额
     */
    void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException, TransferException;
    
}

public class AccountServiceImpl implements AccountService {
    
    private AccountDao accountDao = new AccountDaoImpl();
    
    @Override
    public void transfer(String fromActno, String toActno, double money)
            throws MoneyNotEnoughException, TransferException {
        // 1. 判断转出账户的余额是否充足(select)
        Account fromAct = accountDao.selectByActno(fromActno);
        // 2. 如果转出账户余额不足，提示用户
        if (fromAct.getBalance() < money) { // 转出账户余额不足
            throw new MoneyNotEnoughException("余额不足");
        }
        // 3. 如果转出账户余额充足，更新转出账户余额(update)
        // 先更新java内存中对象的余额再更新数据库
        Account toAct = accountDao.selectByActno(toActno);
        fromAct.setBalance(fromAct.getBalance() - money);
        toAct.setBalance(toAct.getBalance() + money);
        int count = accountDao.updateByAccount(fromAct);
        // 4. 更新转入账户余额(update)
        count += accountDao.updateByAccount(toAct);
        if (count != 2) {
            throw new TransferException("转账失败");
        }
    }
}

/**
 * 账户的DAO对象。负责t_act表中数据的CRUD.
 * 强调一下：DAO对象中的任何一个方法和业务不挂钩。没有任何业务逻辑在里面。
 * DAO中的方法就是做CRUD的。所以方法名大部分是：insertXXX deleteXXX updateXXX selectXXX
 */
public interface AccountDao {
    
    /**
     * 根据账号查询账户信息。
     * @param actno 账号
     * @return 账户信息
     */
    Account selectByActno(String actno);
    
    /**
     * 更新账户信息
     * @param act  被更新的账户对象
     * @return 1表示更新成功，其他值表示失败。
     */
    int updateByAccount(Account act);
}

public class AccountDaoImpl implements AccountDao {
    
    @Override
    public Account selectByActno(String actno) {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        Account account = (Account) sqlSession.selectOne("account.selectByActno", actno);
        sqlSession.close();
        return account;
    }
    
    @Override
    public int updateByAccount(Account act) {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        int count = sqlSession.update("account.updateByAccount", act);
        sqlSession.commit();
        sqlSession.close();
        return count;
    }
}

public class MoneyNotEnoughException extends Exception{
    public MoneyNotEnoughException() {
    }
    
    public MoneyNotEnoughException(String message) {
        super(message);
    }
}

public class TransferException extends Exception{
    public TransferException() {
    }
    
    public TransferException(String message) {
        super(message);
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>转账报告</title>
</head>
<body>
<h1>转账成功！</h1>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>转账报告</title>
</head>
<body>
<h1>余额不足！！！</h1>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>转账报告</title>
</head>
<body>
<h1>转账失败，未知原因！！！</h1>
</body>
</html>

使用 ThreadLocal 进行事务控制

• 在之前的转账业务中，更新了两个账户，我们需要保证它们的同时成功或同时失败，这个时候就需要使用事务机制，在transfer方法开始执行时开启事务，直到两个更新都成功之后，再提交事务
• 如果在转账业务中，更新两个账户的操作在两个事务之中，如果中间出现异常，可能会导致钱丢失，只更新了一个账户的数据，另一个账户的数据未进行更新。
• 前面代码的实现，可能会存在上述的问题，**主要是因为service和dao中使用的SqlSession对象不是同一个，**不能将更新两个账户的操作控制在一个事务之内
• 为了解决可能存在的事务问题，为了保证service和dao中使用的SqlSession对象是同一个，将更新两个账户的操作控制在一个事务之内，我们可以将SqlSession对象存放到ThreadLocal当中，保证一个线程都使用同一个SqlSession对象，把更新两个账户的操作控制在一个事务之内
  • tomcat服务器是支持多线程的，对应不同的来自客户端的请求，tomcat会使用线程池中的一个线程来处理该请求，将SqlSession对象存放到ThreadLocal当中，为当前线程绑定一个属于该线程的SqlSession对象，可以实现只要是同一个线程中的操作，使用的就是同一个SqlSession对象
• 修改SqlSessionUtil工具类：

public class SqlSessionUtil {
    
    private SqlSessionUtil(){}
    
    private static SqlSessionFactory sqlSessionFactory;
    
    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    
    // 全局的，服务器级别的，一个服务器当中定义一个即可。
    // 为什么把SqlSession对象放到ThreadLocal当中呢？
    // 为了保证一个线程对应一个SqlSession。可以把更新两个账户的操作控制在一个事务内
    private static ThreadLocal<SqlSession> local = new ThreadLocal<>();
    
    /**
     * 获取会话对象。
     * @return 会话对象
     */
    public static SqlSession openSession(){
        SqlSession sqlSession = local.get();
        if (sqlSession == null) {
            sqlSession = sqlSessionFactory.openSession();
            // 将sqlSession对象绑定到当前线程上。
            local.set(sqlSession);
        }
        return sqlSession;
    }
    
    /**
     * 关闭SqlSession对象(从当前线程中移除SqlSession对象。)
     * @param sqlSession
     */
    public static void close(SqlSession sqlSession) {
        if (sqlSession != null) {
            sqlSession.close();
            // 注意移除SqlSession对象和当前线程的绑定关系。
            // 因为Tomcat服务器支持线程池。也就是说：用过的线程对象t1，可能下一次还会使用这个t1线程。
            local.remove();
        }
    }
    
}

• 修改service中的方法：

public class AccountServiceImpl implements AccountService {
    
    private AccountDao accountDao = new AccountDaoImpl();
    
    @Override
    public void transfer(String fromActno, String toActno, double money)
            throws MoneyNotEnoughException, TransferException {
        // 添加事务控制代码
        SqlSession sqlSession = SqlSessionUtil.openSession();
        
        // 1. 判断转出账户的余额是否充足(select)
        Account fromAct = accountDao.selectByActno(fromActno);
        // 2. 如果转出账户余额不足，提示用户
        if (fromAct.getBalance() < money) { // 转出账户余额不足
            throw new MoneyNotEnoughException("余额不足");
        }
        // 3. 如果转出账户余额充足，更新转出账户余额(update)
        // 先更新java内存中对象的余额再更新数据库
        Account toAct = accountDao.selectByActno(toActno);
        fromAct.setBalance(fromAct.getBalance() - money);
        toAct.setBalance(toAct.getBalance() + money);
        int count = accountDao.updateByAccount(fromAct);
        
        String s = null;
        s.toUpperCase();
        
        // 4. 更新转入账户余额(update)
        count += accountDao.updateByAccount(toAct);
        if (count != 2) {
            throw new TransferException("转账失败");
        }
        
        // 提交事务
        sqlSession.commit();
        // 关闭事务
        SqlSessionUtil.close(sqlSession);
    }
}

• 修改dao中的方法：AccountDaoImpl中所有方法中的提交commit和关闭close代码全部删除。

public class AccountDaoImpl implements AccountDao {
    
    @Override
    public Account selectByActno(String actno) {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        Account account = (Account) sqlSession.selectOne("account.selectByActno", actno);
        // sqlSession.close();
        return account;
    }
    
    @Override
    public int updateByAccount(Account act) {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        int count = sqlSession.update("account.updateByAccount", act);
        // sqlSession.commit();
        // sqlSession.close();
        return count;
    }
}

MyBatis 三大核心对象的作用域

SqlSessionFactoryBuilder

• 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。
  • SqlSessionFactoryBuilder 对象的作用就是创建 SqlSessionFactory 对象，只要有了 SqlSessionFactory 对象就不在需要 SqlSessionFactoryBuilder 对象，其就可以被垃圾回收器回收了
• 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。

static {
    try {
        // 获取默认数据库环境对应的SqlSessionFactory对象
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

• 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。
  

SqlSessionFactory

• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
• 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。
• 因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

// 默认数据库环境对应的SqlSessionFactory
private static SqlSessionFactory sqlSessionFactory = null;

static {
    try {
        // 获取默认数据库环境对应的SqlSessionFactory对象
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

SqlSession

• 每个线程都应该有它自己的 SqlSession 实例。
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
• 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。
• 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。
• 下面的示例就是一个确保 SqlSession 关闭的标准模式：

try (SqlSession session = sqlSessionFactory.openSession()) {
  // 你的应用逻辑代码
}

使用 javassist 生成类

依赖

<dependencies>
  <!-- javassist -->
  <dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.29.1-GA</version>
  </dependency>
  <!-- junit -->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
  </dependency>
</dependencies>

运行参数配置

• 出现下列报错，需要进行运行参数的配置，JDK高版本的问题，低版本没有java.base这个模块，但是高版本添加了这个模块

java.lang.reflect.InaccessibleObjectException: 
Unable to make protected final java.lang.Class 
java.lang.ClassLoader.defineClass(java.lang.String,byte[],int,int,java.security.ProtectionDomain) 
throws java.lang.ClassFormatError accessible: 
module java.base does not "opens java.lang" to unnamed module @28c97a5

• –add-opens java.base/java.lang=ALL-UNNAMED
• –add-opens java.base/sun.net.util=ALL-UNNAMED
• 
• 
  

Javassist的使用

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;

import java.lang.reflect.Method;

/**
 * ClassName: Test
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-31 15:54
 * @Version 1.0
 */
public class Test {
    
    @org.junit.Test
    public void tset01() throws Exception {
        // 获取类池，用于生成class
        ClassPool pool = ClassPool.getDefault();
        // 使用类池制造类
        // 方法参数为类的全类名
        CtClass ctClass = pool.makeClass("cw.mybatis.bank.dao.impl.AccountDaoImpl");
        // 类中方法的代码
        String methodCode = "public void insert() { System.out.println(\"数据库正在新增信息...\");}";
        // 制造类中的方法
        // 参数一：类中方法的代码；参数二：为哪个类创建方法
        CtMethod ctMethod = CtMethod.make(methodCode, ctClass);
        // 将创建的方法添加到类中
        ctClass.addMethod(ctMethod);
        // 在内存中动态生成class，将类加载到JVM中
        // 得到类对应的Class对象
        // Class<?> aClass = ctClass.toClass();
        ctClass.toClass();
        
        // 加载类到JVM中
        Class<?> aClass = Class.forName("cw.mybatis.bank.dao.impl.AccountDaoImpl");
        // 利用动态生成的类进行对象的创建(使用无参构造方法)
        Object o = aClass.getDeclaredConstructor().newInstance();
        // 获取类中的方法
        Method insertMethod = aClass.getDeclaredMethod("insert");
        // 调用新创建的对象的insert方法
        insertMethod.invoke(o);
    }
    
}

使用 javassist 动态生成类并实现接口

public interface AccountDao {
    
    void delete();
    
}

@org.junit.Test
public void testGenerateImpl() throws Exception {
    // 获取类型用于类的制造
    ClassPool pool = ClassPool.getDefault();
    // 制造类
    CtClass AccountDaoImpl = pool.makeClass("cw.study.mybatis.dao.impl.AccountDaoImpl");
    // 制造接口
    CtClass AccountDao = pool.makeInterface("cw.study.mybatis.dao.AccountDao");
    // 添加接口到类中
    AccountDaoImpl.addInterface(AccountDao);
    // 实现接口中的方法
    // 方法的代码
    String methodCode = "public void delete() {System.out.println(\"数据库正在删除信息...\");}";
    // 制造AccountDaoImpl类的方法
    CtMethod method = CtMethod.make(methodCode, AccountDaoImpl);
    // 将方法添加到类中
    AccountDaoImpl.addMethod(method);
    // 在内存中生成类，并将类加载到JVM中
    Class<?> AccountDaoImplClass = AccountDaoImpl.toClass();
    // 创建对象
    AccountDao accountDao = (AccountDao) AccountDaoImplClass.getDeclaredConstructor().newInstance();
    // 调用方法
    accountDao.delete();
}

使用 javassist 动态生成类并实现接口中所有方法

public interface AccountDao {
    
    void delete();
    
    int insert(String actno);
    
    int update(String actno, Double balance);
    
    String selectByActno(String actno);
    
}

@org.junit.Test
public void testGenerateAccountDaoImpl() throws Exception {
    // 获取类池
    ClassPool pool = ClassPool.getDefault();
    // 制造类
    CtClass ctClass = pool.makeClass("cw.study.mybatis.dao.impl.AccountDaoImpl");
    // 制造接口
    CtClass ctInterface = pool.makeInterface("cw.study.mybatis.dao.AccountDao");
    // 类实现接口
    ctClass.addInterface(ctInterface);
    // 获取接口中的所有方法
    Method[] methods = AccountDao.class.getDeclaredMethods();
    // 遍历接口中的每个方法实现接口方法
    Arrays.stream(methods).forEach(method -> {
        // 实现接口方法
        // public void update(String actno, Double balance) {}
        StringBuilder builder = new StringBuilder();
        // 添加访问权限修饰符
        builder.append("public ");
        // 添加返回值类型
        builder.append(method.getReturnType().getName());
        builder.append(" ");
        // 追加方法名
        builder.append(method.getName());
        builder.append("(");
        // 获取方法的形参列表
        Parameter[] parameters = method.getParameters();
        // 遍历追加形参列表
        for (int i = 0; i < parameters.length; i++) {
            // 追加形参列表中形参的类型
            builder.append(parameters[i].getType().getName());
            builder.append(" ");
            // 追加形参名 parameters[i].getName() 获取的形参名为 arg0 arg1 ...
            builder.append(parameters[i].getName());
            if (i != parameters.length - 1) {
                builder.append(", ");
            }
        }
        builder.append(") {");
        // 添加方法体的方法
        builder.append("System.out.println(\"" + method.getName() + "\");");
        // 动态添加return语句
        // 获取返回类型的简类名
        String returnTypeSimpleName = method.getReturnType().getSimpleName();
        if ("void".equals(returnTypeSimpleName)) {
        
        } else if ("int".equals(returnTypeSimpleName)) {
            builder.append("return 111;");
        } else if ("String".equals(returnTypeSimpleName)) {
            builder.append("return \"method return string\";");
        }
        builder.append("}");
        // System.out.println(builder);
        try {
            // 制造ctClass的方法
            CtMethod method1 = CtMethod.make(builder.toString(), ctClass);
            // 将方法添加到类中
            ctClass.addMethod(method1);
        } catch (CannotCompileException e) {
            e.printStackTrace();
        }
    });
    // 在内存中生成类并将类加载到JVM
    Class<?> aClass = ctClass.toClass();
    // 创建对象（接口的实现类可以进行强转）
    AccountDao accountDao = (AccountDao) aClass.getDeclaredConstructor().newInstance();
    // 调用方法
    accountDao.delete();
    accountDao.insert("");
    accountDao.selectByActno("");
    accountDao.update("", 12.0);
}

工具类 GenerateDaoProxy 的实现

• 工具类 GenerateDaoProxy 可以动态生成接口的实现类
• 在MyBatis中对javassist进行了二次包装，所以可以在MyBatis中直接使用javassist
• 由于SQL语句的id是框架的使用者提供的，所以框架的开发者不可能知道SQL语句的id，因此框架的开发者就规定SQL语句的id必须时dao接口中的方法名，namespace必须是dao接口的全限定类名，否则不能使用框架提供的动态代理生成接口的实现类的功能

package cw.study.mybatis.utils;

import org.apache.ibatis.javassist.CannotCompileException;
import org.apache.ibatis.javassist.ClassPool;
import org.apache.ibatis.javassist.CtClass;
import org.apache.ibatis.javassist.CtMethod;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.session.SqlSession;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.Arrays;

/**
 * ClassName: GenerateDaoProxy
 * Package: cw.study.mybatis.utils
 * Description:
 * 该工具类用于动态生成实现Dao接口的代理类
 * GenerateDaoProxy 这个工具类是MyBatis框架提供的
 *
 * @Author tcw
 * @Create 2023-05-31 17:42
 * @Version 1.0
 */
public class GenerateDaoProxy {
    
    /**
     * 工具类的构造方法私有化，防止创建对象
     */
    private GenerateDaoProxy() {}
    
    /**
     * 动态生成Dao接口的代理类对象
     *
     * @param sqlSession 与数据库的会话对象，由工具类的使用这传递
     * @param daoInterfaceClass Dao接口
     * @return Dao接口的代理类对象
     */
    public static Object generate(SqlSession sqlSession, Class daoInterfaceClass) {
        // 获取类池
        ClassPool pool = ClassPool.getDefault();
        // 制造接口的代理类
        CtClass daoInterfaceImpl = pool.makeClass(daoInterfaceClass.getName() + "Impl");
        // 制造接口
        CtClass daoInterface = pool.makeInterface(daoInterfaceClass.getName());
        // 接口的代理类实现接口
        daoInterfaceImpl.addInterface(daoInterface);
        // 接口的代理类实现接口中的方法
        // 获取接口中所有的方法
        Method[] daoInterfaceClassDeclaredMethods = daoInterfaceClass.getDeclaredMethods();
        // 遍历接口中的所有的方法，逐个进行实现，并添加到接口的代理类中
        Arrays.stream(daoInterfaceClassDeclaredMethods).forEach(method -> {
            // 实现接口中的方法
            try {
                // 接口方法的实现方法的代码
                StringBuilder methodCode = new StringBuilder();
                // public int update(String actno, Double balance) {代码;}
                methodCode.append("public ");
                // 获取接口方法的返回值类型，添加到实现方法中
                methodCode.append(method.getReturnType().getName());
                methodCode.append(" ");
                // 获取接口方法的方法名，添加到实现方法中
                methodCode.append(method.getName());
                methodCode.append("(");
                // 获取接口方法的形参列表，添加到实现方法中
                Parameter[] methodParameters = method.getParameters();
                for (int i = 0; i < methodParameters.length; i++) {
                    // 获取形参的类型
                    methodCode.append(methodParameters[i].getType().getName());
                    methodCode.append(" ");
                    // 获取形参的名 arg0 arg1 arg2 ...
                    methodCode.append(methodParameters[i].getName());
                    // 如果不是最后一个形参需要在后面添加逗号
                    if (i != methodParameters.length - 1) {
                        methodCode.append(", ");
                    }
                }
                methodCode.append(")");
                methodCode.append("{\n");
                // 接口方法的具体实现
                // 获取与数据库的会话对象
                // javassist 需要知道类是哪个包下的所以要使用全限定包名
                methodCode.append("\torg.apache.ibatis.session.SqlSession sqlSession = cw.study.mybatis.utils" +
                                ".SqlSessionUtil.openSession();\n");
                // 执行SQL语句，我们需要知道SQL语句的类型才可以调用相应的方法执行SQL
                // getConfiguration() 获取MyBatis核心配置文件中根标签configuration中的内容
                // getMappedStatement(SQL语句的Id) 根据SQL语句的id获取相应的SQL语句
                // getSqlCommandType() 获取SQL语句的类型，获取到SQL语句的类型是一个枚举值
                // 由于SQL语句的id是框架的使用者提供的，所以框架的开发者不可能知道SQL语句的id
                // 因此框架的开发者就规定SQL语句的id必须时dao接口中的方法名，namespace必须是dao接口的全限定类名
                // 否则不能使用框架提供的动态代理生成接口的实现类的功能
                // SQL id = namespace + . +SQL id
                String SqlId = daoInterfaceClass.getName() + "." + method.getName();
                SqlCommandType sqlCommandType = sqlSession.getConfiguration().getMappedStatement(SqlId).getSqlCommandType();
                // 根据SQL语句的类型的不同调用相应的方法
                if (sqlCommandType == SqlCommandType.INSERT) {

                } else if (sqlCommandType == SqlCommandType.DELETE) {

                } else if (sqlCommandType == SqlCommandType.UPDATE) {
                    methodCode.append("\treturn sqlSession.update(\"" + SqlId + "\", arg0);\n");
                } else if (sqlCommandType == SqlCommandType.SELECT) {
                    // by java.lang.reflect.InvocationTargetException
                    methodCode.append("\treturn (" + method.getReturnType().getName() + ") sqlSession.selectOne(\"" + SqlId +
                            "\", arg0);\n");
                }
                methodCode.append("}");
                // System.out.println(methodCode);
                // 制造接口方法对应的实现方法
                CtMethod ctMethod = CtMethod.make(methodCode.toString(), daoInterfaceImpl);
                // 将制造的实现方法添加到动态生成的代理类中
                daoInterfaceImpl.addMethod(ctMethod);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        // 接口动态代理类的对象
        Object daoInterfaceProxyObj = null;
        try {
            // 在内存中动态生成类，并且将动态生成的类添加到JVM中
            Class<?> daoInterfaceImplClass = daoInterfaceImpl.toClass();
            // 创建接口代理类的对象
            daoInterfaceProxyObj = daoInterfaceImplClass.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 返回接口动态代理类的对象
        return daoInterfaceProxyObj;
    }
}

工具类 GenerateDaoProxy 测试

• 要想使用工具类GenerateDaoProxy这种自动生成Dao接口实现类的机制： namespace必须是dao接口的全限定名称，id必须是dao接口的方法名。

<!-- 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>

package cw.study.mybatis.pojo;

/**
 * ClassName: Account
 * Package: cw.study.mybatis.pojo
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-28 14:33
 * @Version 1.0
 */
public class Account {
    private Long id;
    private String actno;
    private Double balance;
    
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", actno='" + actno + '\'' +
                ", balance=" + balance +
                '}';
    }
    
    public Account() {
    }
    
    public Account(Long id, String actno, Double balance) {
        this.id = id;
        this.actno = actno;
        this.balance = balance;
    }
    
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public String getActno() {
        return actno;
    }
    
    public void setActno(String actno) {
        this.actno = actno;
    }
    
    public Double getBalance() {
        return balance;
    }
    
    public void setBalance(Double balance) {
        this.balance = balance;
    }
}