MyBatis简介和全局配置文件

MyBatis简介

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

其他持久层工具或者框架：

DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能

JdbcTemplate是Spring对JDBC的封装，目的是使JDBC更加易于使用。JdbcTemplate是Spring的一部分。JdbcTemplate处理了资源的建立和释放。他帮助我们避免一些常见的错误，比如忘了总要关闭连接。他运行核心的JDBC工作流，如Statement的建立和执行，而我们只需要提供SQL语句和提取结果。

以上两个工具都类似于洗衣服的搓衣板一样，简化了洗衣服的过程。但是不能像持久层框架（像洗衣机一样）一样有完整的解决洗衣服的方案。

MyBatis持久层框架:

MyBatis相当于半自动洗衣机，而Hibernate相当于全自动洗衣机，当我们一些衣服需要完全按照我们制定的洗衣流程来的话，只能使用半自动的。

为什么使用MyBatis:

MyBatis的下载安装

要使用MyBatis就需要下载一个唯一的jar包：mybatis.jar;

mybatis官网进行下载：

https://github.com/mybatis/mybatis-3
在此页面的最下方可以选择最新版jar包下载；

MyBatis的安装：
要使用 MyBatis， 只需将 mybatis-x.x.x.jar 文件置于类路径（classpath）中即可。

如果使用 Maven 来构建项目，则需将下面的依赖代码置于 pom.xml 文件中：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>
</dependency>

MyBatis核心：从 XML 中构建 SqlSessionFactory

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流（InputStream）实例，比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）。后面会再探讨 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="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

不使用接口使用MyBatis的案例：

代码演示：

第一步，创建一个普通的javaEE项目，项目结构如下：创建放jar包的lib文件夹（导入两个需要的jar包，然后build path/add 到库中），和放配置文件的conf文件夹，并将conf文件夹右键标记为Resources Root。

第二步，创建数据表和对应的java实体类：

User实体类:

package com.fan.pojo;

import java.util.Date;

public class User {
    private Integer id;
    private String username;
    private String addr;
    private Integer age;
    private Date birthday;
    //省略set,get，toString方法，有参和无参构造等
}

第三步，编写sql映射文件,UserMapper.xml(放到conf文件夹下)：

<?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:名称空间，自定义一个名字
id="selectUser"：此sql语句的唯一标识
resultType="com.fan.pojo.User"：此sql查询后对应的结果集对象的类，全路径名
#{id}：从传递的参数中取出id值
-->
<mapper namespace="com.fan.mybatisxxx.UserMapper">
    <select id="selectUser" resultType="com.fan.pojo.User">
    select * from user where id = #{id}
  </select>
</mapper>

第四步，编写mybatis核心配置文件,mybatis-config.xml(放到conf文件夹下)：

<?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/test"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--sql映射文件的位置,将sql映射文件绑定到核心配置文件中-->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

第五步，在com.fan包下创建一个测试包test,写一个测试类(测试使用mybatis)：

package com.fan.test;

import com.fan.pojo.User;
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;

public class MyBatisTest {
    @org.junit.Test
    public void test01() throws IOException {
        //1.根据全局配置文件创建一个SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //SqlSessionFactoryBuilder基建.build(流材料)，创建出来一个SqlSessionFactory工厂。
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        
        //2.工厂创建sqlSession实例，能直接执行已经映射的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //第一个参数是一个sql映射的标志，为了唯一性，我们选择使用名称空间.id的形式，
        //第二个参数是sql查询需要的的参数
        User user = sqlSession.selectOne("com.fan.mybatisxxx.UserMapper.selectUser", 1);
        System.out.println(user);

        sqlSession.close();//关闭sqlSession资源

    }
}

测试结果：

注意，当数据路字段和实体类属性不一致的时候，我们可以给数据库字段起别名进行处理：

总结不使用接口使用mybatis的过程：

MyBatis接口式编程(开发中推荐)：

参照官方文档：https://mybatis.org/mybatis-3.

我们可以提供一个接口（java中Dao层接口一般是需要一个实现类来实现数据库的增删改查，刚好我们的sql映射文件就是实现数据库的增删改查的。）所以，mybatis提供了接口和配置文件的动态绑定(这里的接口相当于原先的Dao层接口，sql映射文件相当于Dao层的实现类)。有了接口后，将接口的规范和实现方式分开了，达到解耦，方便我们的开发。

mapper接口和sql配置文件绑定之后，以后则sql映射文件中的namespace中指定的是接口的全类名，不能乱写其他的了。

接口开发中核心代码的更改：
将原先的sqlSession下调用的增删改查方法（如sqlSession.selectOne()）换成了sqlSession.getMapper（）；

//.通过getMapper获取接口的实现类对象，此时的mapper相当于dao
UserMapper mapper = sqlSession.getMapper(UserMapper.class);

以下使用maven工程构建一个mybatis的测试：

代码演示：

第一步，导入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springboot-web-admin01</artifactId>
        <groupId>com.fan</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>mybatis-mappertest</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

第二步，数据库的表的准备和实体类的编写：
User 类：

package com.fan.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String addr;
    private Integer age;
    private Date birthday;

}

第三步，创建接口方法（相当于原先的dao层接口）

mapper包下的UserMapper 接口：

package com.fan.mapper;

import com.fan.domain.User;

public interface UserMapper {
    public User getUserById(Integer id);//接口提供一个规范
}

第四步，mybatis的核心配置文件和sql映射文件的准备：

mybatis的核心配置mybatis-config.xml:
注意：此核心配置文件至少需要数据库环境environment 标签和sql映射文件的绑定配置mapper标签

<?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/test"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--sql映射文件的位置,将sql映射文件绑定到核心配置文件中-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

sql映射文件的准备:资源路径下的mapper文件夹下的UserMapper.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--
namespace:名称空间，有接口后要写接口的全路径名
id="selectUser"：此sql语句的唯一标识,有接口后写接口中关联sql语句的接口方法的方法名
resultType="com.fan.pojo.User"：此sql查询后对应的结果集对象的类，全路径名
#{id}：从传递的参数中取出id值
-->
<mapper namespace="com.fan.mapper.UserMapper">
    <!--User getUserById(Integer id)-->
    <select id="getUserById" resultType="com.fan.domain.User">
    select * from user where id = #{id}
  </select>
</mapper>

第五步，mybatis测试类的编写：

import com.fan.domain.User;
import com.fan.mapper.UserMapper;
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.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;

public class MapperMybatisTest {
    @Test//这里我使用的是junit5的jupiter单元测试
    public void test01() throws IOException {
        //1.加载mybatis核心配置文件创建sqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.sqlSessionFactory创建一个sqlSession会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //3.获取接口的实现类对象，此时的mapper相当于dao
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        System.out.println("打印mapper实例的类型："+mapper.getClass());//打印mapper实例的类型：class com.sun.proxy.$Proxy10
        User user = mapper.getUserById(2);
        System.out.println(user);
    }
}

测试结果：
打印mapper实例的类型：class com.sun.proxy.$Proxy10
User(id=2, username=李四, addr=咸阳, age=30, birthday=Tue Apr 10 00:00:00 GMT+08:00 2018)

总结：

有接口后，我么就把dao层的规范和实现分离开来了。达到了解耦的目的。

MyBatis全局配置文件/核心配置文件的编写：

参照官方文档：https://mybatis.org/mybatis-3.

全局配置文件引入约束：

参考：
https://blog.csdn.net/m0_38001814/article/details/88359797
idea手动导入dtd：


Apply后xml中即有自动提示功能了。

或者自动导入：
idea自动导入dtd
这里就是依赖ide工具自己下载dtd文件，把鼠标放到飘红的url上即有左上角的感叹号提示，点击第一个

如果红色没散去的话重复上面操作出现感叹号，此时会有个绿色的标识fetch一下，一般来说点第一次就生效了，因为需要时间下载，红色散去之后即已完成，此时你的配置中即有dtd约束文件了

引入外部properties配置文件：

properties标签的作用是引入外部的数据库连接信息
db.properties文件：（properties标签的作用是引入外部的数据库连接信息）将数据库的信息抽取出来

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

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="db.properties"></properties>
    
    <environments default="development">
        <environment id="development">
            <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>
    <!--sql映射文件的位置,将sql映射文件绑定到核心配置文件中-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

当使用spring和springboot的时候，可能properties标签用的很少，因为配置文件都交给spring管理了。

Settings设置项：

当数据库字段使用下划线命名如user_name,而javabean使用驼峰命名的时候，
不能封装到实体类中，这时候开启settings中的mapUnderscoreToCamelCase为true就可以解决此问题。

<!--设置项settings-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

返回值类型的别名处理器：

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 resource="db.properties"></properties>
    <!--设置项settings-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!--返回值的别名处理器-->
    <typeAliases>
        <!--1.批量处理实体类的别名-->
        <!--<package name="com.fan.domain"/>-->
        <!--单独的为每个类，起别名，默认是类名小写，也可以头通过alias显式的指定别名是什么-->
        <typeAlias type="com.fan.domain.User" alias="user"></typeAlias>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <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>
    <!--sql映射文件的位置,将sql映射文件绑定到核心配置文件中-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>

</configuration>

在使用批量起别名的时候：
当实体类所在的包下有子包也有相同的实体类名的时候，就会出现别名冲突。
解决方案：

2.系统帮非自定义类已经起好了别名：

typeHandlers类型处理器：

注意：mybatis3.4以后的版本已经不需要们手动的注册这些处理器插件了。全部自动注册。

环境配置（environments）

mybatis中事务管理器和数据源的配置：

数据库环境的切换：

从外部属性配置文件中取出oracle数据库的连接信息值：

数据库厂商标识（databaseIdProvide标签）

MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。 MyBatis 会加载带有匹配当前数据库 databaseId 属性和所有不带 databaseId 属性的语句。 如果同时找到带有 databaseId 和不带 databaseId 的相同语句，则后者会被舍弃。

mybatis就能根据数据库厂商标识来执行不同的sql；

全局配置文件中声明不同的数据库供应商的别名(value的值就是数据库厂商的别名)：

<databaseIdProvider type="DB_VENDOR"><!--DB_VENDOR数据库的供应商，vendor-->
        <!--为不同的数据库供应商起别名-->
        <property name="MySQL" value="mysql"/>
        <property name="DB2" value="db2"/>
        <property name="Oracle" value="oracle"/>
        <property name="SQL Server" value="sqlserver"/>
    </databaseIdProvider>

databaseId指明我们当前sql语句是针对哪个数据库厂商下的（如mysql），然后动态的根据数据库厂商的标识来发送不同的sql语句：
databaseId:数据库标识符 的意思

<select id="getUserById" resultType="U" databaseId="mysql">
    select * from user where id = #{id}
  </select>

数据库环境的切换结合使用数据库厂商的支持：

从外部属性配置文件中取出oracle数据库的连接信息值：
注意这里的数据库环境的切换只在environments标签下自己用。默认的环境是引用environment 标签下的的id的。

sql映射文件中，我们写两个不同的sql语句，通过数据库标识来区分底层使用哪个数据库来执行。
注意这里的databaseId的值是引用databaseIdProvider标签下的property name=“MySQL” value=“mysql” 的数据库厂商的别名(即value值)。

Mapper标签：

1.总结：

作用：将sql映射注册绑定到全局配置中

mappers
	mapper 注册一个sql映射
		resource 引用类路径下的sql映射文件
		url 引用网络路径或者磁盘路径下的sql映射文件
			file:///liao/mappers/UserMapper.xml
		class 使用注解开发时指定持久化层接口的全限定类名，没有映射文件
			还有一种情况，你的映射文件和你的接口同名而且在同一包下，也可以
	package
		name ：包名 -批量注册
			接口与映射文件必须同名且在同一个包内，才可生效，不满足的将绑定失败

全局配置文件的对应做法：

<mappers>
        <!--绑定注册类路径（Resources文件夹下）单个sql映射文件,-->
        <!--<mapper resource="mapper/EmpMapper.xml"/>-->

        <!--批量绑定接口下的多个sql映射文件，需要sql文件名和对应接口名字一样-->
        <!--<package name="com.fan.mapper"/>-->

        <!--绑定接口下的sql单个映射文件，需要sql文件名和对应接口名字一样-->
        <mapper class="com.fan.mapper.EmpMapper"></mapper>
</mappers>

我们写好的sql映射文件一定要通过mappers标签 -->注册/绑定到全局配置文件中

2.有两种方式绑定注册sql配置文件：

方式一：绑定一个sql配置文件

方式二：绑定一个接口：
需要三步：

第一步，
注意：当绑定一个接口的时候，或者接口下的多个xml的时候，因为是maven项目，所以需要在pom文件中添加以下代码，才能成功注册。

<!--    扫描处了resources之外的其他xml包-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

第二步，
此外，还需要将sql映射文件文件的名字和对应的接口的名字写成一样的，且必须放到接口所在的包下。
如下所示：

第三步，
在mybatis的全局配置文件中绑定那一个接口。

<mapper class="com.fan.mapper.UserMapper"></mapper>

---

3.其他扩展（不需要sql映射文件的注解开发）：

所以我们可以混合编程：重要的复杂的dao接口我们来写sql映射文件
不重要的dao接口我们使用注解快速开发。

UserMapper 接口中的方法：

package com.fan.mapper;

import com.fan.domain.User;
import org.apache.ibatis.annotations.Select;

public interface UserMapper {
    public User getUserById(Integer id);//接口提供一个规范

    @Select("select count(*) from user")
    public Integer getCount();
}

代码演示：

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

    <!--标签顺序：The content of element type "configuration" must match "
    (properties?,settings?,typeAliases?,typeHandlers?,
    objectFactory?,objectWrapperFactory?,reflectorFactory?,
    plugins?,environments?,databaseIdProvider?,mappers?)".-->
    <!--外部属性配置文件-->
    <properties resource="db.properties"></properties>
    <!--设置项settings-->
    <settings>
        <!--开启驼峰命名-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!--返回值的别名处理器-->
    <typeAliases>
        <!--批量处理实体类的别名-->
        <package name="com.fan.domain"/>
        <!--单独的为每个类，起别名，默认是类名小写，也可以头通过alias显式的指定别名是什么-->
        <!--<typeAlias type="com.fan.domain.User" alias="user"></typeAlias>-->
    </typeAliases>



    <environments default="mysql">
        <!--测试的数据源-->
        <environment id="mysql">
            <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>

        <environment id="oracle">
            <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>
    <databaseIdProvider type="DB_VENDOR"><!--DB_VENDOR数据库的供应商-->
        <!--为不同的数据库供应商起别名-->
        <property name="Mysql" value="mysql"/>
        <property name="Oracle" value="oracle"/>
        <property name="SQL Server" value="sqlserver"/>
    </databaseIdProvider>
    <!--sql映射文件的位置,将sql映射文件绑定到核心配置文件中-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"></mapper><!--和resources文件夹下的sql映射文件绑定-->

        <!--和com.fan.mapper文件夹下的xxxmapper接口进行绑定,注意当我们使用mybatis-springboot-starter的时候，能自动关联mapper接口-->
        <!--<mapper class="com.fan.mapper.UserMapper"></mapper>-->
        <!--<package name="com.fan.mapper"/>-->
    </mappers>
</configuration>

测试注解版的sql的方法：

 @Test//这里我使用的是junit5的jupiter单元测试
    public void test02() throws IOException {
        //1.加载mybatis核心配置文件创建sqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.sqlSessionFactory创建一个sqlSession会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //3.获取接口的实现类对象，此时的mapper相当于dao
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        System.out.println("打印mapper实例的类型："+mapper.getClass());//打印mapper实例的类型：class com.sun.proxy.$Proxy10
        Integer count = mapper.getCount();
        System.out.println("user数据库中的记录数："+count);
    }

注意，当我们使用maven或者springboot开发的时候（使用了mybatis-plus时），可能报错：org.apache.ibatis.binding.BindingException: Type interface com.fan.mapper.UserMapper is already known to the MapperRegistry.
就只当前能自动扫描并绑定到我们写的接口，所以需要注释掉mapper class="com.fan.mapper.UserMapper即可。

4.批量绑定注册指定包下的所有mapper接口

<mappers>
        <!--绑定接口所在的包下的多个sql映射文件-->  
        <package name="com.fan.mapper"/>
</mappers>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

注意：当绑定接口的时候，因为是maven项目，所以需要在pom文件中添加以下代码，才能成功注册。

<!--    扫描处了resources之外的其他xml包-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>