MyBatis全总结（入门与实践）

MyBatis官方文档网址：

中文文档：

{\color{red}{}} {\color{red}{具体编程，可以详见文档！}}

MyBatis 是 Maven 项目：

点击上图中的， Download Latest 下载最新版本的MyBatis：此时的最新版本是3.5.9，点击 mybatis-3.5.9.zip 即可下载 MyBatis

mybatis-3.5.9.zip是jar包
Source code （zip）和 Source code （tar.gz）是不同格式的MyBatis源码 (tar.gz是linux系统下的压缩文件格式)

1.4 持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 瞬时状态：内存 断电即失
• 持久状态：数据库（jdbc）、IO文件持久化（相比较数据库浪费资源）
• 生活中持久化例子：冷藏、罐头

为什么需要持久化？

• 有一些对象，不能让它丢掉
• 内存太贵了（外在原因）

1.5 持久层

Dao , Service , Controller 层

• 完成持久化工作的代码块 Dao 层
• 层界限十分明显

1.6 为什么需要Mybatis

• 帮助程序员将数据存入到数据库
• 方便
• 传统的JDBC代码太复杂，简化、框架、自动化
• 不用mybatis也可以，更容易上手。 技术没有高低之分

优点

1. 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件。易于学习，易于使用。通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
2. 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
3. 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。 sql和代码的分离 ， 提高了可维护性 。
4. 提供映射标签，支持对象与数据库的orm字段关系映射。
5. 提供对象关系映射标签，支持对象关系组建维护。
6. 提供xml标签，支持编写动态sql。
7. 最重要的一点：使用的人多!

未来： mybatis => spring | spring mvc | sring boot

1.7 和其它持久化层技术对比

• JDBC

1. SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
2. 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
3. 代码冗长，开发效率低

• Hibernate 和 JPA

1. 操作简便，开发效率高
2. 程序中的长难复杂 SQL 需要绕过框架
3. 内部自动生产的 SQL，不容易做特殊优化
4. 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
5. 反射操作太多，导致数据库性能下降

• MyBatis

1. 轻量级，性能出色
2. SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
3. 开发效率稍逊于HIbernate，但是完全能够接受

二、搭建MyBatis

开发环境

IDE：idea 2021.3
JDK：1.8
构建工具：maven 3.6.1
MySQL版本：MySQL 8.0.3
MyBatis版本：MyBatis 3.5.9

2. 第一个 mybatis 程序

思路： 搭建环境 -> 导入MyBatis -> 编写代码 -> 测试

2.1 搭建环境

2.1.1 创建数据库

CREATE DATABASE `mybatis`
USE `mybatis`
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(20) NOT NULL,
`name` varchar(30) DEFAULT NULL,
`pwd` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `user`(`id`,`name`,`pwd`) VALUES 
(1,'张三','123456'),
(2,'李四','123456'),
(3,'王五','123890')

2.1.2 新建一个普通的maven项目

重新配置一下 Maven ：

Windows系统： File -> Setting -> Build,Execution,Deployment -> Build Tool -> Maven

macOS: IntelliJ IDEA -> Preferences... -> Build,Execution,Deployment -> Build Tool -> Maven

应该是自己的 路径 ，不是 Bundled(Maven 3)

2.1.3 删除 src文件 : 目的是创建一个项目是父项目，以后直接创建各个模块子项目

2.2 导入Maven依赖（MyBatis）

 <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!--mybatis-->
        <!--https://mvnreposiyory.com/artifact/org.mybatis/mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

确保依赖都导入成功：

2.3 编写代码

2.3.1 创建一个模块 new module

2.3.2 编写mybatis的核心配置文件

连接数据库：

填写必要的信息：

核心配置文件： mybatis-config.cml 放到 resources 文件中

<?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">  <!--约束，用的是.dtd文件-->
<!--!DOCTYPE后的configuration是下面的根标签-->
<!--核心配置文件-->
<configuration><!--根标签-->
  <!--配置连接数据库的环境-->
  <!--环境 environments下可以配置多个environment环境 环境名称是id="" environments default=使用哪个环境就写哪个环境的id-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>    <!--事务管理的类型-->
            <dataSource type="POOLED"> <!--数据源：连接数据的信息--> 
                <property name="driver" value="com.mysql.jdbc.Driver"/> 
              <!--驱动 /mybatis 是数据库名--> <!--编码--> <!--&amp;就是and  serverTimezone时区-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
             <property name="username" value="root"/><!--用户名 写自己的-->
             <property name="password" value="*****"/><!--密码 写自己的-->
            </dataSource>
        </environment>
    </environments>
</configuration>

2.3.3 编写mybatis工具类

编写工具类： MybatisUtils.java

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

package com.guo.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;
import java.io.InputStream;
//sqlSessionFactory --> sqlSession   加载资源  创建对象
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //使用mybatis第一步获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";  //初始就加载 指定配置文件加载
            //读取配置文件 字节输出流
            InputStream inputStream = Resources.getResourceAsStream(resource); 
        //获取 sqlSessionFactoryBuilder
        // SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //获取 sqlSessionFactory 
        // sqlSessionFactoryBuilder可以传入字节输入流或者字符输入流
//相当于SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 
        // sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
            //以上注释相当于下面
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //创建流
        }catch (IOException e){
            e.printStackTrace();
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例了。
    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
}

2.3.4 编写代码

1. 实体类

package com.guo.pojo;
//实体类
public class User {
    private int id;
    private String name;
    private String pwd;
    //构造函数快捷键：command + N
    public User(){
    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    public int getId() {
        return id;
    public void setId(int id) {
        this.id = id;
    public String getName() {
        return name;
    public void setName(String name) {
        this.name = name;
    public String getPwd() {
        return pwd;
    public void setPwd(String pwd) {
        this.pwd = pwd;
    @Override
    public String toString() {
        return "User{"+
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
}

2. Mapper接口，相当于DAO

package com.guo.dao;
import com.guo.pojo.User;
import java.util.List;
public interface UserMapper {
   //获取全部用户
   List<User> getUserList();
}

3. 接口实现类

• 相关概念：ORM （Object Relations Mapping）对象关系映射。
• 对象：Java的实体类对象
• 关系：关系型数据库
• 映射：二者之间的对应关系

1. 映射文件的命名

• 表所对应的实体类的类名+Mapper.xml
• 例如：表 user ，映射的实体类为 User ，所对应的映射文件为 UserMapper.xml
• 因此，一个映射文件对应一个实体类 ，对应一张表操作
• Mybatis映射文件用于编写SQL，访问以及操作表中的数据。
• Mybatis映射文件存放的位置是 src/main/mappers 目录下 ( mapper 就是原来的 dao )

2. Mybatis中可以面向接口操作数据，要保证两个一致：

• a. mapper接口的全类名和映射文件的命名空间（ namespace ）保持一致
• b. mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

3. 对应：表-实体类-mapper接口-映射文件

• 由原来的 UserDaoImpl.java 转换为一个 Mapper配置文件 ： UserMapper.xml 满足SqlSession的调用

<?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"><!--约束，用的是.dtd文件-->
<!--!DOCTYPE后的mapper是下面的根标签-->
<!--引入映射文件-->
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.guo.dao.UserMapper"> <!--绑定mapper接口-->
    <!--权限定名就是把类及类所在的包都写上-->
<!--select查询语句-->  
<!--重写方法，id对应方法名是getUserList,resultType返回一个结果（LIST结果集）,resultMap是多个结果集合-->
    <select id="getUserList" resultType="com.guo.pojo.User" > 
    <!--这必须是 com.guo.pojo.User,因为是包名需要用.而不是路径不能用/-->
        <!--执行SQL-->
        select * from mybatis.user where name like #{value};
    </select>
</mapper>

需要在 配置 里是设置一下 SQL Dialects 保证下面使用 Sql语句 时可以出现表名

• Windows： File -> Setting -> Languages & Frameworks -> SQL Dialects
• macOS: IntelliJ IDEA -> Preferences... -> Languages & Frameworks -> SQL Dialects

2.4 测试 （junit测试）

2.4.1 建立对应的包

package com.guo.dao;
import com.guo.pojo.User;
import com.guo.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class UserMapperTest {
    @Test
    public void test(){
        //第一步，获得SQLSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 执行SQL 获取mapper接口对象 
   //当我们传给getMapper()一个类型的class对象，该方法会获取一个这个类型的实例化对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //每当调用mapper接口中的方法，该方法会找到接口，接口找到相对应的映射文件，根据当前调用的方法找到当前映射文件里对应的SQL语句
        List<User> userList =  userMapper.getUserList(); //代理模式
        for (User user : userList){
            System.out.println(user);
        //关闭sqlSession
        sqlSession.close();
    }

注意点：

2.4.2 可能报错，需要注意：

报错1：

org.apache.ibatis.binding.BindingException: Type interface com.guo.dao.UserMapper is not known to the MapperRegistry.

核心配置文件 mybatis-config.xml 中注册mapper.

    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/guo/dao/UserMapper.xml"/> <!--写自己的-->
    </mappers>

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"> <!--约束，用的是.dtd文件-->
<!--核心配置文件-->
<configuration><!--根标签-->
  <!--配置连接数据库的环境-->
  环境 environments下可以配置多个environment环境,环境名称是id="" environments 
   default=使用哪个环境就写哪个环境的id
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>    <!--事务管理的类型-->
            <dataSource type="POOLED"> <!--数据源：连接数据的信息-->  
                <property name="driver" value="com.mysql.jdbc.Driver"/> 
              <!--驱动 /mybatis 是数据库名--> <!--编码--> <!--&amp;就是and  serverTimezone时区-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
             <property name="username" value="root"/><!--用户名 写自己的-->
             <property name="password" value="*****"/><!--密码 写自己的-->
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/> <!--写自己的-->
    </mappers>
</configuration>

报错2： 初始化异常

The error may exist in com/guo/dao/UserMapper.xml

注意在主项目和子模块的 pom.xml 加代码，并重新刷新一遍maven

<!--maven由于它的约定大于配置，我们以后可能遇到我们自己写的配置文件，无法被导出或者生效的问题，解决方法：-->
    <!--在build中配置resources，来防止我们资源导出失败的问题！-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource> <!--重点在这里！-->
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

{\color{red}{当然你可以通过创建相同的包解决此类问题！}}

例如：接口 SelectMapper.java 对应实现类 SelectMapper.xml ，存放的包名相同：

接口 SelectMapper.java 存放在 ./src/main/java/com/**/mappers 中

对应实现类 SelectMapper.xml 存放在 ./src/main/resources/com/**/mappers 中如：接口

如果不是第一次运行，需要 clean 一下 target 文件

2.5 运行

2.5.1 结果显示

2.5.2 文件结构

2.5.3 可能遇到的问题：

1. 配置文件没有注册
2. 绑定接口错误
3. 方法名不对
4. 返回类型不对
5. Maven导出资源问题

三、 特别注意（核心接口）

SqlSessionFactoryBuilder ：这个类可以被实例化、使用和丢弃， 一旦创建了 SqlSessionFactory，就不再需要它了 。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。
SqlSessionFactory ： SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在 ，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到， 最简单的就是使用单例模式或者静态单例模式 。
SqlSession ：每个线程都应该有它自己的 SqlSession 实例。 SqlSession 的实例不是线程安全的，因此是不能被共享的 ，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。

四、总结流程

五、加入log4j 日志功能

5.1 加入依赖 pom.xml （ 导入后注意更新！ ）

     <!--log4j日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

5.2 编写 log4j.xml 配置文件，在 /src/main/resources/ 下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"><!--爆红没事-->
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql"> <!--logger 输出日志的范围-->
        <level value="debug" /> <!--level 级别-->
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

5.3 日志的级别

1. FATA（致命）
2. ERROR（错误）
3. WARN（警告）
4. INFO（信息）
5. DEBUG（测试）

• 从上到下级别越来越低，但级别越高输出信息越少
• 从上到下打印出来的内容越来越详细

六、MyBatis核心配置文件

6.1 environmen t

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下可以配置多个environment环境 环境名称是id="" environments
    default: 设置默认使用的环境的id
    <environments default="development">
        environment:配置某个具体的环境
           id：表示连接数据库环境的唯一标识，不能重复
        <environment id="development">
                transactionManager: 设置事务管理方式
                type："JDBC/MANAGED"
                JDBC:当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动来处理。
                MANAGED:表示被管理，隶属Spring
            <transactionManager type="JDBC"/>  <!--事务管理的类型-->
            dataSource: 配置数据源
                type：设置数据源的类型
                type："POOLED/UNPOOLED/JNDI"
                POOLED：表示使用数据库的连接池，缓存数据库连接
                UNPOOLED：表示不使用数据库的连接池
                JNDI：表示使用上下文中的数据源
                Spring管理数据源，SSM整合后，不需要再设置数据源了！！！
            <dataSource type="POOLED"><!--数据源：连接数据的信息-->
                <!--设置连接数据库的驱动--> <!--编码-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--设置连接数据库的连接地址-->
                <!-- /mybatis 是数据库名  &amp;就是and   serverTimezone时区-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="******"/><!--自定义-->
                <!--设置连接数据库的密码-->
                <property name="password" value="******"/><!--自定义-->
            </dataSource>
        </environment>
    </environments>
</configuration>

6.2 properties

这里我们的数据源：连接数据的信息可以是写死的，我们还可以把数据源信息单拿出来放到 db.properties 文件中：

6.2.1 创建 db.properties 文件

6.2.2 编写 db.properties 文件

配置文件有很多且是键值对应的，为了防止重名，加一个跟文件名同名的前缀，例如文件名是 db.properties ，因此前缀就是 db.

db.properties 文件：

db.driver = com.mysql.jdbc.Driver
db.url =jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT
db.username = ******
db.password = ******

mybatis-config.xml 文件中添加信息

<!--引入外部properties配置文件-->
    <properties resource="db.properties"/>

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配置文件-->
    <properties resource="db.properties"/>
    <!--环境 environments下可以配置多个environment环境  环境名称是id="" environments default=使用哪个个环境就写哪个环境的id-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>    <!--事物管理-->
            <dataSource type="POOLED">
                <property name="driver" value="${db.driver}"/> <!--驱动--><!--编码--> <!--&amp;就是and  serverTimezone时区-->
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

6.3 typeAliases

在接口实现类 Mapper.xml 中，我们需要写 resultType="com.guo.pojo.***" 包名，比如 UserMapper.xml ，每次写一个 SQL 语句都要重新写一个 resuktType ：

<select id="getUserList" resultType="com.guo.pojo.User" > 
    <!--这必须是 com.guo.pojo.User,因为是包名需要用.而不是路径不能用/-->
        <!--执行SQL-->
        select * from mybatis.user where name like #{value};
    </select>

MyBatis提供了类型别名的功能，解决了问题： mybatis-config.xml 核心配置文件中引入标签

<!--设置类型别名-->
<typeAliases>
        typeAlias：设置某个具体的类型的别名
        type：需要设置别名的类型的全类名
        alias：设置此类型的别名，且别名不区分大小写。若不设置此属性，该类型拥有默认的别名，即类名
        <!--<typeAlias type="com.atguigu.mybatis.bean.User"></typeAlias>-->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User" alias="user">
        </typeAlias>-->
        <!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="com.guo.pojo"/>
    </typeAliases>

{\color{red}{但是 mybatis-config.xml 核心配置文件中引入标签需要符合顺序！}}

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配置文件-->
    <properties resource="db.properties"/>
    <!--以包为单位，将包下所有类型设置默认的类型别名，即类名且不区分大小写-->
    <typeAliases>
        <package name="com.guo.pojo"/>
    </typeAliases>
    <!--环境 environments下可以配置多个environment环境  环境名称是id="" environments default=使用哪个个环境就写哪个环境的id-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>    <!--事物管理-->
            <dataSource type="POOLED">
                <property name="driver" value="${db.driver}"/> <!--驱动--><!--编码--> <!--&amp;就是and  serverTimezone时区-->
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

6.4 mappers

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>

但是每次写一个 接口文件 ，就需要引用一个 mappper 标签，因此可以以 包 为单位改量一下：

6.4.1 新建一个包

映射文件放在 resources 里，这里不能直接创建包，只能创建 Directory ：

{\color{red}{`resources`文件下是一个个目录，因此里写的是路径，创建 `Directory`时不能写`com.guo.mappers`要写`com/guo/mappers`}}

6.4.2 修改核心配置文件 mybatis-configxml

核心配置文件 mybatis-config.xml :

    <!--引入映射文件-->
    <mappers>
        <!--<mapper resource="mappers/UserMapper.xml"/>-->
           以包为单位应如映射文件
           1. mapper接口所在的包要和映射文件所在的包一致
           2. mapper接口要和映射文件的名字一样
        <package name="com.guo.mappers"/>
    </mappers>

6.5 总结

6.5.1 核心配置文件 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文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"/>
    <typeAliases>
        typeAlias：设置某个具体的类型的别名
        type：需要设置别名的类型的全类名
        alias：设置此类型的别名，且别名不区分大小写。若不设置此属性，该类型拥有默认的别名，即类名
        <!--<typeAlias type="com.guo.pojo.User"></typeAlias>-->
        <!--<typeAlias type="com.guo.pojo.User" alias="user">
        </typeAlias>-->
        <!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="com.guo.pojo"/>
    </typeAliases>
    environments：设置多个连接数据库的环境
	    default：设置默认使用的环境的id
    <environments default="development">
        environment：设置具体的连接数据库的环境信息
	        id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
        <environment id="development">
            transactionManager：设置事务管理方式
	            type：设置事务管理方式，type="JDBC|MANAGED"
	            type="JDBC"：设置当前环境的事务管理都必须手动处理
	            type="MANAGED"：设置事务被管理，例如spring中的AOP
            <transactionManager type="JDBC"/>
            dataSource：设置数据源
	            type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
	            type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
	            type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
	            type="JNDI"：调用上下文中的数据源
            <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="UserMapper.xml"/> -->
        以包为单位，将包下所有的映射文件引入核心配置文件