Mybatis（二）

Mybatis基于代理Dao的CRUD操作
- CRUD中可能遇到的问题：参数的传递以及返回值的封装
介绍Mybatis基于传统dao方式的使用（自己编写dao的实现类）（了解即可）
mybatis主配置文件中的常用配置：
- properties标签
- typeAliases标签
- mappers标签的子标签：package

在之前的笔记中我们已经实现了Mybatis入门，这里回顾一下步骤：

创建 maven 工程并导入坐标（pom.xml）
编写必要代码（实体类和持久层接口）
编写Mybatis的主配置文件（如SqlMapConfig.xml）
编写映射配置文件（如UserDao.xml）
编写测试类（执行代码）

根据上述步骤，我们再创建一个Maven工程，以完成查询user表全部数据的功能（即和笔记中Mybatis入门程序一样）

注意：这里刚开始的时候一直报空指针异常，**InputStream inputStream = Resources.class.getClassLoader().getResourceAsStream("SqlMapConfig.xml");的inputStream 一直为null，是因为自己的SqlMapConfig.xml错写成了SqlMapConifg.xml。**这里以后千万要仔细！不然空指针异常排错起来很浪费时间！

Mybatis基于代理Dao的CRUD操作

使用要求：

持久层接口和持久层接口的映射配置必须在相同的包下
持久层映射配置中mapper标签的namespace属性取值必须是持久层接口的全限定类名
SQL语句的配置标签<select>,<insert>,<delete>,<update>的id属性必须和持久层接口的方法名相同

这里其实就是之前笔记里的**注意事项**

这里我们添加以下几个方法：

保存操作（增）：saveUser
更新操作（改）：updateUser
删除操作（删）：deleteUser
查询一个（查）：findById
模糊查询（查）：findByName
查询user表的总记录数（聚合函数）：findTotal

关于<select>，<insert>，<delete>，<update>这四个标签的具体说明可查看：

官网：XML 映射文件
W3C教程：MybatisXml配置文件

（视频讲解）

保存操作（增）：saveUser

首先在持久层接口（UserDao）中添加saveUser方法，完整代码如下：

package top.qing.dao;

import top.qing.domain.User;

import java.util.List;

public interface UserDao {
    /**
     * 查询所有结果
     * @return
     */
    List<User> findAll();

    /**
     * 保存用户（增）
     * @param user
     */
    void saveUser(User user);
}

然后在映射配置文件中进行补充配置，完整代码如下：

<?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="top.qing.dao.UserDao">

    <!--配置查询所有结果-->
    <select id="findAll" resultType="top.qing.domain.User">
        select * from user
    </select>

    <!--保存用户（增）-->
    <insert id="saveUser" parameterType="top.qing.domain.User" >
        insert into user(username,birthday,sex,address)
                    values(#{username},#{birthday},#{sex},#{address})
    </insert>

</mapper>

parameterType 属性：代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称。

（MybatisXml配置文件）

sql 语句中使用#{}字符：它代表占位符，相当于原来 jdbc 的?，都是用于执行语句时替换实际的数据。具体的数据是由#{}里面的内容决定的。

#{}中内容的写法：由于我们保存方法的参数是一个 User 对象，此处要写 User 对象中的属性名称。它用的是 OGNL表达式。

OGNL表达式：Object Graphic Navigation Language，对象-图导航语言。它是按照一定的语法格式来获取数据的，即： #{对象.对象}的方式，通过对象的取值方法来获取数据。在写法上把get给省略了。比如：我们获取用户的名称类中的写法：user.getUsername()；OGNL表达式写法：user.username。（OGNL表达式基本原理和使用方法）

那么mybatis中为什么能直接写username，而不用user呢？因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名

（OGNL视频讲解）

最后就可以进行测试了（执行代码）。完整代码如下：

package top.qing.test;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import top.qing.dao.UserDao;
import top.qing.domain.User;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

public class MybatisTest {

    private InputStream inputStream;
    private SqlSession session;
    private UserDao userDao;

    @Before
    public void init(){
        // 1.读取配置文件
        inputStream = Resources.class.getClassLoader().getResourceAsStream("SqlMapConfig.xml");
        // 2.创建 SqlSessionFactory 的SqlSessionFactoryBuilder对象builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3.使用builder创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = builder.build(inputStream);
        // 4.使用 SqlSessionFactory对象factory 生产 SqlSession 对象
        session = factory.openSession();
        // 5.使用 SqlSession 创建 dao 接口的代理对象userDao
        userDao = session.getMapper(UserDao.class);
    }

    @After
    public void destroy() throws IOException {
        // 提交事务（不然增删改不会生效）
        session.commit();
        // 7.释放资源
        session.close();
        inputStream.close();
    }

    @Test
    public void test1() throws IOException {
        // 使用刚刚创建的代理对象userDao执行查询所有方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void testSaveUser() throws IOException {
        User user = new User();
        user.setUsername("saveUser");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("中国");

        // 使用useDao代理对象执行saveUser方法
        userDao.saveUser(user);
    }

}

这里为了测试方便，提取出了init()方法和destroy()方法，而关于@Before和@After注解的使用，可以查看Junit笔记

注意：要在destroy()方法中添加session.commit();

这一点和 jdbc 是一样的，我们在实现增删改时一定要去控制事务的提交，在 mybatis中可以使用session.commit();来实现事务提交。

执行结果如下：

问题扩展：返回新增用户 id 的值

视频讲解

新增用户后，往往同时还要返回当前新增用户的 id 值。由于id 是由数据库的自动增长来实现的，所以就相
当于我们要在新增后将自动增长 auto_increment 的值返回。

修改UserDao.xml的saveUser部分代码如下：

<!--保存用户（增）-->
    <insert id="saveUser" parameterType="top.qing.domain.User">
        <!-- 保存时获取插入的 id -->
        <selectKey keyColumn="id" keyProperty="id" resultType="int">
            select last_insert_id();
        </selectKey>
        insert into user(username,birthday,sex,address)
        values(#{username},#{birthday},#{sex},#{address})
    </insert>

selectKey 的属性：

keyColumn：匹配属性的返回结果集中的列名称。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表（在例子中id意思是数据库中的id字段）
keyProperty：selectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表（在例子中我们把获取到的id值赋值给了user对象的id属性）
resultType：**结果的类型。MyBatis 通常可以推算出来，但是为了更加确定写上也不会有什么问题。**MyBatis 允许任何简单类型用作主键的类型，包括字符串。如果希望作用于多个生成的列，则可以使用一个包含期望属性的 Object 或一个 Map。
order：这可以被设置为 BEFORE 或 AFTER。如果设置为 BEFORE，那么它会首先选择主键，设置 keyProperty 然后执行插入语句。如果设置为 AFTER，那么先执行插入语句，然后是 selectKey 元素 （这和像 Oracle 的数据库相似，在插入语句内部可能有嵌入索引调用）

（MybatisXml配置文件）

执行代码如下：

@Test
public void testSaveUser() throws IOException {
    User user = new User();
    user.setUsername("saveUser");
    user.setBirthday(new Date());
    user.setSex("男");
    user.setAddress("中国");

    // 使用useDao代理对象执行saveUser方法
    userDao.saveUser(user);
    System.out.println(user.getId());
}

结果为：

更新操作（改）：updateUser

步骤和上述类似，这里只记录添加部分的代码：

首先在持久层接口（UserDao）添加代码如下：

/**
 * 更新用户（改）
 * @param user
 */
void updateUser(User user);

然后在映射配置文件（UserDao.xml）中添加代码如下：

<!--更新用户（改）-->
<update id="updateUser" parameterType="top.qing.domain.User">
    update user set username = #{username},birthday = #{birthday},sex = #{sex}, address = #{address}
            where id = #{id}
</update>

最后在测试类中（执行代码）：

@Test
public void testUpdateUser() throws IOException {
    User user = new User();
    user.setId(52);
    user.setUsername("updateUser");
    user.setBirthday(new Date());
    user.setSex("女");
    user.setAddress("中国");

    // 使用useDao代理对象执行saveUser方法
    userDao.updateUser(user);
}

结果如下：

删除操作（删）：deleteUser

首先在持久层接口（UserDao）添加代码如下：

/**
 * 根据id删除用户
 * @param userId
 */
void deleteUser(Integer userId);

然后在映射配置文件（UserDao.xml）中添加代码如下：

<!--据id删除用户（parameterType可以不写，Mybatis会自动推出）-->
<delete id="deleteUser" parameterType="java.lang.Integer">    /*注意下这里的parameterType为Integer*/
    delete from user where id = #{uid}  /*这里的uid占位符名称可以随意*/
</delete>

最后在测试类中（执行代码）：

@Test
public void testDeleteUser() throws IOException {
    // 使用useDao代理对象执行saveUser方法
    userDao.deleteUser(53);
}

查询一个（查）：findById

首先在持久层接口（UserDao）添加代码如下：

/**
 * 根据id查询用户信息
 * @param userId
 * @return
 */
User findById(Integer userId);

然后在映射配置文件（UserDao.xml）中添加代码如下：

<!--根据id查询用户信息-->
<select id="findById" resultType="top.qing.domain.User">
    select * from user where id = #{uid}
</select>

resultType 属性：用于指定结果集的类型

parameterType 属性：用于指定传入参数的类型（可以不写，Mybatis会自动判断）

（MybatisXml配置文件）

sql 语句中使用#{}字符：，代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。具体的数据是由#{}里面的内容决定的。

此处#{}中内容的写法：由于数据类型是基本类型，所以此处可以随意写。（这里我们写的是#{uid}）

最后在测试类中（执行代码）：

@Test
public void testFindById() throws IOException {
    // 使用useDao代理对象执行saveUser方法
    User user = userDao.findById(54);
    System.out.println(user);
}

结果如下：

模糊查询（查）：findByName

首先在持久层接口（UserDao）添加代码如下：

/**
 * 根据Name模糊查询名字中带有指定字符串的用户信息
 * @return
 */
List<User> findByName(String UserStr);

然后在映射配置文件（UserDao.xml）中添加代码如下：

<!--根据Name模糊查询名字中带有指定字符串的用户信息-->
<select id="findByName" resultType="top.qing.domain.User">
    select * from user where username like #{uStr}
</select>

最后在测试类中（执行代码）：

@Test
public void testFindByName() throws IOException {
    // 使用useDao代理对象执行saveUser方法
    List<User> users = userDao.findByName("%王%");   // 注意这里要加占位符%以完成模糊查询
    for (User user : users) {
        System.out.println(user);
    }
}

结果如下：

查询user表的总记录数（聚合函数）：findTotal

首先在持久层接口（UserDao）添加代码如下：

/**
 * 查询记录总数
 * @return
 */
Integer findTotal();

然后在映射配置文件（UserDao.xml）中添加代码如下：

<!--查询记录总数-->
<select id="findTotal" resultType="java.lang.Integer">
    select count(id) from user;
</select>

最后在测试类中（执行代码）：

@Test
public void testFindTotal() throws IOException {
    // 使用useDao代理对象执行saveUser方法
    Integer total = userDao.findTotal();
    System.out.println("总记录数为："+total);
}

结果如下：

补充内容

模糊查询的另一种配置方式

模糊查询中，可以在映射配置文件（UserDao.xml）中这么写：

<!--根据Name模糊查询名字中带有指定字符串的用户信息-->
<select id="findByName" resultType="top.qing.domain.User">
    select * from user where username like '%${value}%'
</select>

这样写的话，在测试类中就不用加占位符%了，即这么写：List<User> users = userDao.findByName("王");

执行的结果是和之前一样的。

模糊查询的${value}源码分析：

说明源码中指定了读取的 key 的名字就是value，所以我们在绑定参数时就只能叫 value 的名字，即只能写：${value}

#{}与${}的区别

MyBatis 中#{}和${}区别

Mybatis中#{}与${}的区别（掘金）

#{}表示一个占位符号：通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换，#{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。 如果 parameterType 传输单个简单类型值，#{}括号中可以是 value 或其它名称。

（jdbc preparedStatement笔记）
${}表示拼接 sql字符串：通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${}可以接收简单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。

注意：为了防止 SQL 注入，能用 #{} 的不要去用 ${}。如果非要用 ${} 的话，那要注意防止 SQL 注入问题，可以手动判定传入的变量，进行过滤，一般 SQL 注入会输入很长的一条 SQL 语句

Mybatis 与 JDBC 编程的比较

数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题

解决：在 SqlMapConfig.xml（主配置文件）中配置数据链接池，使用连接池管理数据库链接

Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码

解决：将 Sql 语句配置在 XXXXmapper.xml（映射配置文件）文件中与 java 代码分离

向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数对应

解决：Mybatis 自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的类型

对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对象解析比较方便

解决：Mybatis 自动将 sql 执行结果映射至 java 对象，通过 statement 中的 resultType 定义输出结果的类型

Mybatis 的参数深入

parameterType 配置参数
resultType&resultMap 配置结果类型

**注意，resultType 和 resultMap 之间只能同时使用一个。**resultType和resultMap的区别：

resultType：期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。

resultMap：对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。

（Xml映射配置文件）

parameterType 配置参数

上面我们介绍了 SQL 语句传参，使用标签的 parameterType 属性来设定。该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类），同时也可以使用实体类的包装
类。接下来我们将学习如何使用实体类的包装类作为参数传递。

java对象 POJO和JavaBean的区别

PO、VO、POJO、DTO、DAO、Service包等常见包的理解

传递pojo包装对象：开发中通过 pojo 传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中

首先我们在vo包下创建QueryVo类，代码如下：

package top.qing.vo;

import lombok.Data;
import top.qing.domain.User;

@Data
public class QueryVo {
    private User user;
}

首先在持久层接口（UserDao）添加代码如下：

/**
 * 根据QueryVo中的条件查询用户
 * @param vo
 * @return
 */
List<User> findByVo(QueryVo vo);

然后在映射配置文件（UserDao.xml）中添加代码如下：

<!--根据QueryVo中的条件查询用户-->
<select id="findByVo" parameterType="top.qing.vo.QueryVo" resultType="top.qing.domain.User">
    select * from user where username like #{user.username}
</select>

最后在测试类中（执行代码）：

@Test
public void testFindByVo() throws IOException {
    QueryVo queryVo = new QueryVo();
    User user = new User();
    user.setUsername("%王%");
    queryVo.setUser(user);
    // 使用useDao代理对象执行saveUser方法
    List<User> users = userDao.findByVo(queryVo);
    for (User user1 : users) {
        System.out.println(user1);
    }
}

结果如下：

resultType&resultMap 配置结果类型

resultType 属性可以指定结果集的类型，它支持基本类型和实体类类型。在前面的 CRUD 案例中我们已经用过此属性了。

需要注意的是，resultType 和 parameterType 一样，如果注册过类型别名的，可以直接使用别名。没有注册过的必须使用全限定类名。例如：我们的实体类此时必须是全限定类名（后面会介绍如何配置实体类的别名，官网上也有介绍：类型别名（typeAliases），可以查看官方提供的别名）

同时，当是实体类名称是，还有一个要求，实体类中的属性名称必须和查询语句中的列名（字段名）保持一致，否则无法实现封装。

注意，实体类属性名和数据库字段名不对应的两种解决方式：

在执行的SQL语句上起别名
在Xml映射配置文件中配置resultMap属性

（视频讲解）

比如说，在修改属性名后：

在执行的SQL语句上起别名，在映射配置文件（UserDao.xml）中进行对应修改如下：

<!-- 配置查询所有操作 -->
<select id="findAll" resultType="top.qing.domain.User">
	select id as userId,username as userName,birthday as userBirthday,
	sex as userSex,address as userAddress from user
</select>

如果我们的查询很多，都使用别名的话写起来就会很麻烦，如何解决呢。这就要用到resultMap了：

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系，从而实现封装。在 select 标签中使用 resultMap 属性指定引用即可。同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询。

在Xml映射配置文件中配置resultMap属性，然后在引用它的语句中设置 resultMap 属性就行了（注意我们去掉了 resultType 属性）

在映射配置文件（UserDao.xml）中进行对应修改如下：

<!-- 建立 User 实体和数据库表的对应关系 -->
<resultMap type="top.qing.domain.User" id="userMap"> 
    <!-- 主键字段的对应 -->
    <id column="id" property="userId"/>
    <!-- 非主键字段的对应 -->
	<result column="username" property="userName"/>
	<result column="sex" property="userSex"/>
	<result column="address" property="userAddress"/>
	<result column="birthday" property="userBirthday"/>
</resultMap>
<!-- 查询所有 --> 
<select id="findAll" resultMap="userMap">
	select * from user
</select>

其中，resultMap的两个属性：

type 属性：指定实体类的全限定类名
id 属性：给定一个唯一标识，用于给查询 select 标签引用（即select标签中的resultMap="userMap"）

resultMap下的id和result标签：

id 标签：用于指定主键字段
result 标签：用于指定非主键字段

id和result标签共有的属性：

column 属性：用于指定数据库列名（字段名）
property 属性：用于指定实体类属性名称

ResultMap 的属性列表：

属性描述

id 当前命名空间中的一个唯一标识，用于标识一个结果映射。

type 类的完全限定名（或者一个类型别名）

autoMapping 如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。这个属性会覆盖全局的属性 autoMappingBehavior。默认值：未设置（unset）。

id & result字标签：
1
2
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
这些元素（字标签）是结果映射的基础。id 和 result 元素都将一个列的值映射到一个简单数据类型（String, int, double, Date 等）的属性或字段。这两者之间的唯一不同是，id元素对应的属性会被标记为对象的标识符（主键），在比较对象实例时使用。 这样可以提高整体的性能，尤其是进行缓存和嵌套结果映射（也就是连接映射）的时候。

两个元素都有一些属性：

属性描述

property 映射到列结果的字段或属性。如果 JavaBean 有这个名字的属性（property），会先使用该属性，否则 MyBatis 将会寻找给定名称的字段（field）。无论是哪一种情形，你都可以使用常见的点式分隔形式进行复杂属性导航。比如，你可以这样映射一些简单的东西：“username”，或者映射到一些复杂的东西上：“address.street.number”。

column 数据库中的列名（或者是列的别名）。一般情况下，这和传递给 resultSet.getString(columnName) 方法的参数一样。

javaType 一个 Java 类的全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。

jdbcType JDBC 类型，所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可以为空值的列指定这个类型。

typeHandler 我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。这个属性值是一个类型处理器实现类的全限定名，或者是类型别名。

属性	描述
`id`	当前命名空间中的一个唯一标识，用于标识一个结果映射。
`type`	类的完全限定名（或者一个类型别名）
`autoMapping`	如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。这个属性会覆盖全局的属性 autoMappingBehavior。默认值：未设置（unset）。

属性	描述
`property`	映射到列结果的字段或属性。如果 JavaBean 有这个名字的属性（property），会先使用该属性，否则 MyBatis 将会寻找给定名称的字段（field）。无论是哪一种情形，你都可以使用常见的点式分隔形式进行复杂属性导航。比如，你可以这样映射一些简单的东西：“username”，或者映射到一些复杂的东西上：“address.street.number”。
`column`	数据库中的列名（或者是列的别名）。一般情况下，这和传递给 `resultSet.getString(columnName)` 方法的参数一样。
`javaType`	一个 Java 类的全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。
`jdbcType`	JDBC 类型，所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可以为空值的列指定这个类型。
`typeHandler`	我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。这个属性值是一个类型处理器实现类的全限定名，或者是类型别名。

（视频讲解）

官网：结果映射（resultMap）

W3C教程：Result Maps

Mybatis 传统 DAO 层开发（了解）

使用 Mybatis 开发 Dao，通常有两个方法，即原始 Dao 开发方式（了解）和 Mapper 接口代理开发方式。而现在主流的开发方式是接口代理开发方式，这种方式总体上更加简便。上面已经学习了基于代理方式的 dao 开发，现在可以了解一下基于传统编写 Dao 实现类的开发方式。

大体就是写完UserDao接口后不写UserDao.xml映射配置文件，而是写一个UserDaoImpl接口来实现UserDao接口的相关方发。

这里就不做代码展示了，后续要了解直接去看视频：视频讲解

SqlMapConfig.xml配置文件

Mybatis官网

W3C教程：MyBatis XML配置

视频讲解

SqlMapConfig.xml 中配置的内容和顺序如下：

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

properties（属性）

属性（properties）

在使用 properties 标签配置时，我们有两种方式指定属性配置

第一种指定属性配置方式

先在SqlMaoConfig.xml配置文件中添加：

<!--配置properties-->
<properties>
    <!--配置连接数据库的四个基本信息-->
    <property name="driver" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</properties>

然后在下面的dataSource标签中修改成以下内容：

<dataSource type="POOLED">
    <!--配置连接数据库的四个基本信息-->
    <property name="driver" value="${driver}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>
</dataSource>

完整的SqlMaoConfig.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">
<!--mybatis的主配置文件-->
<configuration>
    <!--配置properties-->
    <properties>
        <!--配置连接数据库的四个基本信息-->
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--配置连接数据库的四个基本信息-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--指定映射配置文件的位置。映射配置文件指的是每个dao独立的配置文件
        如果是有注解来配置的话，此处应该使用class属性指定被注解的dao全限定类型-->
    <mappers>
        <mapper resource="top/qing/dao/UserDao.xml"></mapper>
    </mappers>
</configuration>

第二种指定属性配置方式

首先在 resources目录下定义db.properties文件：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

然后在SqlMaoConfig.xml配置文件中修改对应内容：

<!--配置properties-->
<properties resource="db.properties">
    
</properties>

resource标签有两个属性，用于指定 properties 配置文件的位置，要求配置文件必须在类路径下。

resource 属性：resource="jdbcConfig.properties"

url 属性：要求按照URL的写法来写地址。url=file:///D:/IdeaProjects/day02_eesy_01mybatisCRUD/src/main/resources/jdbcConfig.properties

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

首先读取在 properties 元素体内指定的属性。

然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。

最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。

由于在db.properties文件中我们用的是jdbc.driver=com.mysql.jdbc.Driver之类的，前面命名的是jdbc.driver，所以应该在下面的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>

（视频讲解）

typeAliases（类型别名）

类型别名（typeAliases）

在 SqlMapConfig.xml 中配置：

<typeAliases>
<!-- 单个别名定义 -->
    <typeAlias alias="user" type="top.qing.domain.User"/>
<!-- 批量别名定义，扫描整个包下的类，别名即为类名（首字母大写或小写都可以） --> 
    <package name="top.qing.domain"/>
	<package name="其它包"/>
</typeAliases>

<typeAliases>下的两个标签：

typeAlias

package

typeAlias标签的两个属性：

alias：指定别名

type：指定实体类的全限定类名

package标签的属性：

name：指定批量定义别名的包的路径

（视频讲解）

mappers（映射器）

映射器（mappers）

<mapper resource=" " />：使用相对于类路径的资源如：<mapper resource="com/itheima/dao/IUserDao.xml" />
<mapper class=" " />：使用 mapper 接口类路径。如：<mapper class="com.itheima.dao.UserDao"/>。注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。
<package name=""/>：注册指定包下的所有 mapper 接口。如：<package name="cn.itcast.mybatis.mapper"/>。注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。