一、Mybatis 简介

---

1. 简介

MyBatis 是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和Java POJO 为数据库中的记录。

2. 持久层框架对比

• JDBC
  • SQL 夹杂在Java 代码中耦合度高，导致硬编码内伤
  • 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
  • 代码冗长，开发效率低
• Hibernate 和 JPA
  • 操作简便，开发效率高
  • 程序中的长难复杂 SQL 需要绕过框架
  • 内部自动生成的 SQL，不容易做特殊优化
  • 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难
  • 反射操作太多，导致数据库性能下降
• MyBatis
  • 轻量级，性能出色
  • SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
  • 开发效率稍逊于 Hibernate，但是完全能够接受

开发效率：Hibernate > Mybatis > JDBC

运行效率：JDBC > Mybatis > Hibernate

3. 快速入门（基于Mybatis3方式）

1）准备数据模型

CREATE DATABASE `mybatis-example`;
USE `mybatis-example`;

CREATE TABLE `t_emp`(
  emp_id INT AUTO_INCREMENT,
  emp_name CHAR(100),
  emp_salary DOUBLE(10,5),
  PRIMARY KEY(emp_id)
);
INSERT INTO `t_emp`(emp_name,emp_salary) VALUES("tom",200.33);
INSERT INTO `t_emp`(emp_name,emp_salary) VALUES("jerry",666.66);
INSERT INTO `t_emp`(emp_name,emp_salary) VALUES("andy",777.77);

2）项目搭建和准备

①项目搭建

②依赖导入 pom.xml

<dependencies>
  <!-- mybatis依赖 -->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.11</version>
  </dependency>

  <!-- MySQL驱动 mybatis底层依赖jdbc驱动实现,本次不需要导入连接池,mybatis自带! -->
  <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.25</version>
  </dependency>

  <!--junit5测试-->
  <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>5.3.1</version>
  </dependency>
</dependencies>

③实体准备

public class Employee {
    private Integer empId;
    private String empName;
    private Double empSalary;    
    //getter | setter
}

 3）准备Mapper接口和MapperXML文件

MyBatis框架下，SQL语句编写位置发生改变，从原来的Java 类，改成XML 或者注解定义。推荐在XML 文件中编写SQL 语句，让用户能更专注于 SQL 代码，不用关注其他的JDBC 代码。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95%的代码！ 一般编写SQL 语句的文件命名：XxxMapper.xml Xxx一般取表名。

Mybatis 中的Mapper 接口相当于以前的 Dao。但是区别在于，Mapper 仅仅只是建接口即可，我们不需要提供实现类，具体SQL 写到对应的 Mapper 文件。

 ① 定义mapper 接口

包：com.atguigui.mapper

/**
 * t_emp表对应数据库SQL语句映射接口!
 *    接口只规定方法,参数和返回值!
 *    mapper.xml中编写具体SQL语句!
 */
public interface EmployeeMapper {
    /**
     * 根据员工id查询员工数据方法
     * @param empId  员工id
     * @return 员工实体对象
     */
    Employee selectEmployee(Integer empId);
    
}

 ② 定义 mapper.xml

位置：resource/mappers/EmployeeMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace等于mapper接口类的全限定名,这样实现对应 -->
<mapper namespace="com.atguigu.mapper.EmployeeMapper">
    
    <!-- 查询使用 select标签
            id = 方法名
            resultType = 返回值类型
            标签内编写SQL语句
     -->
    <select id="selectEmployee" resultType="com.atguigu.pojo.Employee">
        <!-- #{empId}代表动态传入的参数,并且进行赋值!后面详细讲解 -->
        select emp_id empId,emp_name empName, emp_salary empSalary from 
           t_emp where emp_id = #{empId}
    </select>
</mapper>

注意：

• 方法名和SQL的 id 一致
• 方法返回值和 resultType 一致
• 方法的参数和 SQL 的参数一致
• 接口的全类名和映射配置文件的名称空间一致

4）准备MyBatis 配置文件

mybatis框架配置文件：数据连接信息，性能配置，mapper.xml 配置等。

习惯上命名为 mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合 Spring 之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。

<?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表示配置Mybatis的开发环境，可以配置多个环境，在众多具体环境中，使用default属性指定实际运行时使用的环境。default属性的取值是environment标签的id属性的值。 -->
  <environments default="development">
    <!-- environment表示配置Mybatis的一个具体的环境 -->
    <environment id="development">
      <!-- Mybatis的内置的事务管理器 -->
      <transactionManager type="JDBC"/>
      <!-- 配置数据源 -->
      <dataSource type="POOLED">
        <!-- 建立数据库连接的具体信息 -->
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis-example"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <!-- Mapper注册：指定Mybatis映射文件的具体位置 -->
    <!-- mapper标签：配置一个具体的Mapper映射文件 -->
    <!-- resource属性：指定Mapper映射文件的实际存储位置，这里需要使用一个以类路径根目录为基准的相对路径 -->
    <!--    对Maven工程的目录结构来说，resources目录下的内容会直接放入类路径，所以这里我们可以以resources目录为基准 -->
    <mapper resource="mappers/EmployeeMapper.xml"/>
  </mappers>
</configuration>

5）运行和测试

/**
 * projectName: com.atguigu.test
 *
 * description: 测试类
 */
public class MyBatisTest {

    @Test
    public void testSelectEmployee() throws IOException {

        // 1.创建SqlSessionFactory对象
        // ①声明Mybatis全局配置文件的路径
        String mybatisConfigFilePath = "mybatis-config.xml";

        // ②以输入流的形式加载Mybatis配置文件
        InputStream inputStream = Resources.getResourceAsStream(mybatisConfigFilePath);

        // ③基于读取Mybatis配置文件的输入流创建SqlSessionFactory对象
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        // 2.使用SqlSessionFactory对象开启一个会话
        SqlSession session = sessionFactory.openSession();

        // 3.根据EmployeeMapper接口的Class对象获取Mapper接口类型的对象(动态代理技术)
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);

        // 4. 调用代理类方法既可以触发对应的SQL语句
        Employee employee = employeeMapper.selectEmployee(1);

        System.out.println("employee = " + employee);

        // 4.关闭SqlSession
        session.commit(); //提交事务 [DQL不需要,其他需要]
        session.close(); //关闭会话

    }
}

说明：

• SqlSession：代表Java程序和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）
• SqlSessionFactory：是“生产” SqlSession 的“工厂”。
• 工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象。

6）SqlSession 和 HttpSession区别

• HttpSession：工作在Web 服务器上，属于表述层。
  • 代表浏览器和Web服务器之间的会话
• SqlSession：不依赖Web 服务器，属于持久化层。
  • 代表Java 程序和数据库之间的会话。

 

二、日志框架扩展

---

1. 用日志打印替代 sout

1）sout 有什么问题

① 问题1：I/O影响性能        

System.out 对象是一个输出流对象，所以控制台输出信息本质上是 I/O 操作。而 I/O 操作是项目运行过程中两大性能瓶颈之一。

② 问题2：无法统一管理

项目上线时，希望把所有（或一部分）sout 打印关闭，但是只能手动一个一个查找，耗费开发人员的极大精力，因为 sout  的无度使用会使它分散在项目的各个角落。

③ 问题3：显得你很low

想看某个变量的值，只会使用 sout 在控制台打印出来，不会debug，这只能被人鄙视。

2）使用 [ 日志框架 ] 的好处

① 设定级别，统一管理

日志框架会按照事情的严重程度来划分等级，例如：

-   错误（Error）：表示程序运行出错，比如抛异常等情况。
-   警告（Warning）：表示程序运行过程中有潜在风险，但此时并没有报错。
-   信息（Info）：表示程序运行过程中完成了一个关键动作，需要以程序运行信息的形式告知开发者。
-   调试（Debug）：表示程序运行过程中更加细致的信息，协助程序员调试程序。

📌Tips：各种不同的具体日志系统会使用不同的日志级别名称，也可能有更多个级别设定。但是思想是一致的。 通过在配置文件中指定某一个日志级别来控制系统要打印的内容。日志框架会打印当前指定级别的日志和比当前指定级别更严重的级别的日志。 例如在开发阶段，我们指定debug级别，项目上线修改成info级别，那么所有debug级别的日志就都不打印了，不需要到项目代码中一个一个修改，非常方便。

② 灵活指定输出位置

使用日志框架不一定是打印到控制台，也可以保存到文件中或者保存到数据库。这就看具体的项目维护需求。

③ 自定义日志格式

④ 基于日志分析问题

将来我们开发的应用系统中，不仅包含java 代码，还有很多中间件服务器。任何子系统出现故障我们都是通过日志来定位问题，分析故障原因。甚至更复杂的系统还会专门开发日志子系统，在主系统出现问题时抓取日志数据供维护人员参考。而日志数据必须要有确定格式才便于格式化抓取，这肯定不是随意写 sout 就能实现的。

2. 最佳拍档用法

1）以来导入

 <!-- 日志 ， 会自动传递slf4j门面-->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

2）代码测试

代码图解

 测试结果

3）引入配置 

Logback要求配置文件名称必须是logback.xml，存放路径在main/resources目录下。

  

通过配置文件，可以配置输出格式、输出级别、输出位置等！  

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置，ConsoleAppender表示输出到控制台 -->
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- 设置全局日志级别。日志级别按顺序分别是：TRACE、DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>

    <!-- 根据特殊需求指定局部日志级别，可也是包名或全类名。 -->
    <logger name="com.atguigu.mybatis" level="DEBUG" />

</configuration>

3. Lombok插件使用

加入依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

注解功能

注解	作用
@Data	生成getXxx()方法、setXxx()方法、toString()、equals()、canEqual()、hashCode()方法
@AllArgsConstructor	生成全参构造器
@NoArgsConstructor	生成无参构造器
@Slf4j	生成日志对象
@Getter	生成getXxx()方法
@Setter	生成setXxx()方法
@ToString	生成toString()方法

 

三、MyBatis基本使用

---

1. 向SQL语句传参

1.1 mybatis日志输入配置

mybatis配置文件设计标签和顶层结构如下：

•  configuration（配置）
  • properties（属性）
  • settings（设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environments（环境配置）
    • environment（环境变量）
      • transationManager（事务管理器）
      • dataSource（数据源）
  • databaseIdProvider（数据库厂商标识）
  • mappers（映射器）

我们可以在mybatis 的配置文件使用 settings 标签设置，输出运过程 SQL 日志，通过查看日志·，我们可以判定 #{} 和 ${} 的输出结果。

日志配置：

<settings>
  <!-- SLF4J 选择slf4j输出！ -->
  <setting name="logImpl" value="SLF4J"/>
</settings>

1.2 #{}形式

Mybatis 会将SQL语句中的 #{} 转换成问号占位符。

 

1.3 ${}形式

${} 形式传参，底层Mybatis做的是字符串拼接操作。

 

 通常不会采用 ${} 的方式传值。一个特定的适用场景是：通过Java程序动态生成数据表，表名部分需要Java 程序通过参数传入，而 JDBC 对于表名部分是不能使用问好占位符的，此时只能使用

结论：实际开发中，能用 #{} 实现的，肯定不用 ${}.

特殊情况：动态的不是值，是列名或者关键字，需要使用 ${} 拼接

//注解方式传入参数！！
@Select("select * from user where ${column} = #{value}")
User findByColumn(@Param("column") String column, 
                                @Param("value") String value);

 2. 数据输入

2.1 Mybatis总体机制概括

2.2 概念说明

这里数据输入具体是指上层方法（例如Service方法）调用Mapper 接口时，数据传入的形式。

• 简单类型：只包含一个值的数据类型
  • 基本数据类型：int、byte、short、double、...
  • 基本数据类型的包装类型：Integer、Character、Double、...
  • 字符串类型：String
• 复杂类型：包含多个值的数据类型
  • 实体类类型：Employee、Department、...
  • 集合类型：List、Set、Map、...
  • 数组类型：int[] 、String[]、...
  • 复合类型：List<Employee>、实体类型中包含集合.....

 2.3 单个简单类型参数

Mapper 接口中抽象方法的声明

Employee selectEmployee(Integer empId);

SQL 语句 

<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
  select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
</select>

单个简单类型参数，在#{}中可以随意命名，但是没有必要。通常还是使用和接口方法参数同名。

2.4 实体类类型参数

 Mapper 接口中抽象方法的声明

Integer insertEmployee(Employee employee);

SQL 语句

<insert id="insertEmployee">
  insert into t_emp(emp_name,emp_salary) values(#{empName},#{empSalary})
</insert>

结论： Mybatis会根据 #{} 中传入的数据，加工成 getXxx() 方法，通过反射在实体类对象中调用这个方法，从而获取到对应的数据。填充到 #{} 解析后的问号占位符这个位置。

2.5 零散的简单类型数据

零散的多个简单类型参数，如果没有特殊处理，那么Mybatis 无法识别自定义名称：

Mapper 接口中抽象方法的声明

int updateEmployee(@Param("empId") Integer empId,@Param("empSalary") Double empSalary);

SQL 语句 

<update id="updateEmployee">
  update t_emp set emp_salary=#{empSalary} where emp_id=#{empId}
</update>

2.6 Map类型参数

Mapper 接口中抽象方法的声明

int updateEmployeeByMap(Map<String, Object> paramMap);

SQL 语句

<update id="updateEmployeeByMap">
  update t_emp set emp_salary=#{empSalaryKey} where emp_id=#{empIdKey}
</update>

测试 

@Test
public void testUpdateEmpNameByMap() {
  EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
  Map<String, Object> paramMap = new HashMap<>();
  paramMap.put("empSalaryKey", 999.99);
  paramMap.put("empIdKey", 5);
  int result = mapper.updateEmployeeByMap(paramMap);
  log.info("result = " + result);
}

对应关系

#{} 中写 Map 中的 key

使用场景

有很多零散的参数需要传递，但是没有对应的实体类型可以使用。使用 @Param 注解一个一个传入又太麻烦了。所以都封装到 Map中。

3. 数据输出

3.1 输出概括

数据输入总体上有两种形式：

• 增删改操作返回的受影响行数：直接使用  int 或 long  类型接收即可
• 查询操作的查询结果

我们需要做的是，指定查询的输出数据类型即可。并且插入场景下，实现主键数据回显。

3.2 单个简单类型

Mapper 接口中的抽象方法

int selectEmpCount();

SQL 语句

<select id="selectEmpCount" resultType="int">
  select count(*) from t_emp
</select>

测试

@Test
public void testEmpCount() {
  EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
  int count = employeeMapper.selectEmpCount();
  log.info("count = " + count);
}

 细节解释：

select 标签，通过 resultType 指定查询返回值类型

resultType = "全限定符 |  别名 | 如果是返回集合类型，写范型类型即可"

别名问题： 类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
</typeAliases>

当这样配置时，Blog 可以用在任何使用 domain.blog.Blog 的地方，也可以指定一个包名，MyBatis 会在包名下面搜索需要的Java Bean，比如：

<typeAliases> <package name="domain.blog"/> </typeAliases>

每个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。见下面的例子：

@Alias("author")
public class Author {
    ...
}

3.3 返回实体类对象

Mapper 接口的抽象方法

Employee selectEmployee(Integer empId);

SQL 语句

<!-- 编写具体的SQL语句，使用id属性唯一的标记一条SQL语句 -->
<!-- resultType属性：指定封装查询结果的Java实体类的全类名 -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">

  <!-- Mybatis负责把SQL语句中的#{}部分替换成“?”占位符 -->
  <!-- 给每一个字段设置一个别名，让别名和Java实体类中属性名一致 -->
  select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{maomi}

</select>

通过给数据库表字段加别名，让查询结果的每一列都和Java 实体类中属性对应起来。增加全局配置自动识别对应关系，在 Mybatis 全局配置文件中，做了下面的配置，select 语句中可以不给字段设置别名

<!-- 在全局范围内对Mybatis进行配置 -->
<settings>

  <!-- 具体配置 -->
  <!-- 从org.apache.ibatis.session.Configuration类中可以查看能使用的配置项 -->
  <!-- 将mapUnderscoreToCamelCase属性配置为true，表示开启自动映射驼峰式命名规则 -->
  <!-- 规则要求数据库表字段命名方式：单词_单词 -->
  <!-- 规则要求Java实体类属性名命名方式：首字母小写的驼峰式命名 -->
  <setting name="mapUnderscoreToCamelCase" value="true"/>

</settings>

 3.4 返回Map类型

适用于 SQL 查询返回的各个字段综合起来并不和任何一个现有的实体对应，没法封装实体类对象中。能够封装成实体类类型的，就不使用Map类型。

Mapper 接口的抽象方法

Map<String,Object> selectEmpNameAndMaxSalary();

 SQL 语句

<!-- Map<String,Object> selectEmpNameAndMaxSalary(); -->
<!-- 返回工资最高的员工的姓名和他的工资 -->
<select id="selectEmpNameAndMaxSalary" resultType="map">
  SELECT
    emp_name 员工姓名,
    emp_salary 员工工资,
    (SELECT AVG(emp_salary) FROM t_emp) 部门平均工资
  FROM t_emp WHERE emp_salary=(
    SELECT MAX(emp_salary) FROM t_emp
  )
</select>

测试

@Test
public void testQueryEmpNameAndSalary() {
  EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
  Map<String, Object> resultMap = employeeMapper.selectEmpNameAndMaxSalary();
  Set<Map.Entry<String, Object>> entrySet = resultMap.entrySet();
  for (Map.Entry<String, Object> entry : entrySet) {
    String key = entry.getKey();
    Object value = entry.getValue();
    log.info(key + "=" + value);
  }
}

3.5 返回List类型

查询结果返回多个实体类对象，希望把多个实体类对象放在 List 集合中返回。此时不需要任何特殊处理，在 resultType 属性中还是设置实体类类型即可。

Mapper 接口中抽象方法

List<Employee> selectAll();

SQL 语句

<!-- List<Employee> selectAll(); -->
<select id="selectAll" resultType="com.atguigu.mybatis.entity.Employee">
  select emp_id empId,emp_name empName,emp_salary empSalary
  from t_emp
</select>

测试

@Test
public void testSelectAll() {
  EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
  List<Employee> employeeList = employeeMapper.selectAll();
  for (Employee employee : employeeList) {
    log.info("employee = " + employee);
  }
}

 3.6 返回主键值

1）自增长类型主键

Mapper 接口中的抽象方法

int insertEmployee(Employee employee);

SQL 语句

<!-- int insertEmployee(Employee employee); -->
<!-- useGeneratedKeys属性字面意思就是“使用生成的主键” -->
<!-- keyProperty属性可以指定主键在实体类对象中对应的属性名，Mybatis会将拿到的主键值存入这个属性 -->
<insert id="insertEmployee" useGeneratedKeys="true" keyProperty="empId">
  insert into t_emp(emp_name,emp_salary)
  values(#{empName},#{empSalary})
</insert>

 测试

@Test
public void testSaveEmp() {
  EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
  Employee employee = new Employee();
  employee.setEmpName("john");
  employee.setEmpSalary(666.66);
  employeeMapper.insertEmployee(employee);
  log.info("employee.getEmpId() = " + employee.getEmpId());
}

 注意：Mybatis 是将自增主键的值设置到实体类对象中，而不是以 Mapper 接口方法返回值的形式返回。

2）非自增长类型主键

而对于不支持自增型主键的数据库（例如Oracle）或者字符串类型主键，则可以使用 selectKey 子元素：selectKey 元素将会首先运行，id 会被设置，然后插入语句会被调用。

使用 selectKey 帮助插入 UUID 作为字符串类型主键示例：

<insert id="insertUser" parameterType="User">
    <selectKey keyProperty="id" resultType="java.lang.String"
        order="BEFORE">
        SELECT UUID() as id
    </selectKey>
    INSERT INTO user (id, username, password) 
    VALUES (
        #{id},
        #{username},
        #{password}
    )
</insert>

上例中，我们定义了一个 insertUser 的插入语句来将 user 对象插入到 user 表中。我们使用 selectKey 来查询 UUID 并设置到 id 字段中。

通过 keyProperty 属性来指定查询到的  UUID 赋值给对象中的 id 属性，而 resultType 属性指定了 UUID 的类型为 java.lang.String。

需注意的是，我们将 selectKey 放在了插入语句的前面，这是因为 MySQL 在 insert 语句中只支持一个 select 子句，而 selectKey 中查询 UUID 的语句就是一个 select 子句，因此我们需要将其放在前面。

最后，在将User 对象插入到 user 表中时，我们直接使用对象中的 id 属性来插入主键值。

使用这种方式，我们可以方便地插入 UUID 作为字符串类型主键。当然，还有其他插入方式可以使用，如使用 Java 代码生成 UUID 并在类中显式设置值等。需要根据具体应用场景和需求选择合适的插入方式。

3.7 实体类属性和数据库字段对应关系

1）别名对应

将字段的别名设置成和实体类属性一致。

<!-- 编写具体的SQL语句，使用id属性唯一的标记一条SQL语句 -->
<!-- resultType属性：指定封装查询结果的Java实体类的全类名 -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">

  <!-- Mybatis负责把SQL语句中的#{}部分替换成“?”占位符 -->
  <!-- 给每一个字段设置一个别名，让别名和Java实体类中属性名一致 -->
  select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{maomi}

</select>

2）全局配置自动识别驼峰式命名规则

在Mybatis 全局配置文件加入如下配置：

<!-- 使用settings对Mybatis全局进行设置 -->
<settings>

  <!-- 将xxx_xxx这样的列名自动映射到xxXxx这样驼峰式命名的属性名 -->
  <setting name="mapUnderscoreToCamelCase" value="true"/>

</settings>

SQL 语句中可以不使用别名

<!-- Employee selectEmployee(Integer empId); -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">

  select emp_id,emp_name,emp_salary from t_emp where emp_id=#{empId}

</select>

3）使用resultMap

使用  resultMap 标签定义对应关系，再在后面的 SQL 语句中引用这个对应关系

<!-- 专门声明一个resultMap设定column到property之间的对应关系 -->
<resultMap id="selectEmployeeByRMResultMap" type="com.atguigu.mybatis.entity.Employee">

  <!-- 使用id标签设置主键列和主键属性之间的对应关系 -->
  <!-- column属性用于指定字段名；property属性用于指定Java实体类属性名 -->
  <id column="emp_id" property="empId"/>

  <!-- 使用result标签设置普通字段和Java实体类属性之间的关系 -->
  <result column="emp_name" property="empName"/>

  <result column="emp_salary" property="empSalary"/>

</resultMap>

<!-- Employee selectEmployeeByRM(Integer empId); -->
<select id="selectEmployeeByRM" resultMap="selectEmployeeByRMResultMap">

  select emp_id,emp_name,emp_salary from t_emp where emp_id=#{empId}

</select>

4. mapperXML 标签总结

MyBatis 的真正强大在于它的语句映射，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 致力于减少使用成本，让用户能更专注于 SQL 代码。SQL 映射文件只有很少的几个顶级元素：

• insert - 映射插入语句
• update - 映射更新语句
• delete - 映射删除语句
• select - 映射查询语句

select 标签：

MyBatis 在查询和结果映射做了相当多的改进。一个简单查询的 select 元素是非常简单：

<select id="selectPerson" 
resultType="hashmap"> SELECT * FROM PERSON WHERE ID = #{id} </select>

这个语句名为 selectPerson，接受一个 int（或 Integer）类型的参数，并返回一个 HashMap 类型的对象，其中的键是列名，值便是结果行中的对应值。

注意参数符号：#{id}

MyBatis 创建一个预处理语句（PreparedStatement）参数，在 JDBC 中，这样的一个参数在 SQL 中会由一个"?" 来标识，并被传递到一个新的预处理语句中，就像这样：

// 近似的 JDBC 代码，非 MyBatis 代码...
String selectPerson = "SELECT * FROM PERSON WHERE ID=?";
PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);

select 元素允许你配置很多属性来配置每条语句的行为细节：

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
resultType	期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。
resultMap	对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
statementType	可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。

 insert ，update 和 delete 标签：

数据变更语句 insert ，update 和 delete 的实现非常接近：

<insert
  id="insertAuthor"
  statementType="PREPARED"
  keyProperty=""
  keyColumn=""
  useGeneratedKeys=""
  timeout="20">

<update
  id="updateAuthor"
  statementType="PREPARED"
  timeout="20">

<delete
  id="deleteAuthor"
  statementType="PREPARED"
  timeout="20">

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
statementType	可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
useGeneratedKeys	（仅适用于 insert 和 update）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。
keyProperty	（仅适用于 insert 和 update）指定能够唯一识别对象的属性，MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值，默认值：未设置（unset）。如果生成列不止一个，可以用逗号分隔多个属性名称。
keyColumn	（仅适用于 insert 和 update）设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。如果生成列不止一个，可以用逗号分隔多个属性名称。