标签：配置文件 标签 数据库 mybatis 详解 MyBatis 连接池

1. MyBatis 核心配置文件详细内容详解

@

目录

• 1. MyBatis 核心配置文件详细内容详解
• 2. 测试和学习的准备工作
• 3. environment 标签
• 4. transactionManager 标签
• 5. dataSource 标签
• 6. properties 标签
• 7. mapper 标签
• 8. 总结：
• 9. 最后：

---

关于 MyBatis 这个核心配置文件mybatis-config.xml 文件名，不是固定的，所放的位置也不是固定的。

只是大家都这么命名，而位置，将该配置文件放到 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">
<configuration>
    <environments default="mybatis">
        <environment id="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"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="CarMapper.xml"/>
    </mappers>
</configuration>

mybatis-confg.xml ，也就是MyBatis 的核心配置文件，主要配置连接数据库的信息等(**一般一个数据库，对应一个这个MyBatis 的核心配置文件)，同样的与之对应的通过 mybatis-config.xml 核心配置文件' 所创建的对象：SqlSession FactoryBuilder，SqlSessionFactory 也是一个数据库相对应上一个对象。

MyBatis 核心配置文件的标签，属性的简单说明：如下：

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

• environments : 配置环境（在MyBatis 的核心配置文件当中，可以配置多个），注意：一般s 结尾表示复数，也就是说MyBatis 的环境可以配置多个数据源.

  • default 属性：表示默认使用的是哪个环境，default后面填写的是 environment 的 id，default的值只需要和 environment 的 id 的值保持一致即可 。

• envrionment：具体的环境变量（主要包括：事务管理的配置+数据源的配置信息 ）

  • id：给当前环境一个唯一的标识，该标识用 environments 的default 后面，用来指定默认环境的选择。

• transactionManager：配置事务管理器

  • type属性：指定事务管理器具体使用什么方式，可选值包括两个。

  • JDBC：使用 JDBC 原生的事务管理机制，底层管理：事务开启conn.setAutoCommit(false)；...处理业务，事务提交 conn.commit( )
  • MANAGED：交给其他容器来管理事务，比如：WebLogic，JBOSS，Spring等第三方框架进行事务的管理控制，如果没有设置第三方的框架管理的话，则就没有事务上的控制的了，没有事务（就是只要执行一条DML语句，则提交一次）

• dataSource：指定数据源

  • type 属性：用来指定具体使用的数据库练级池的策略(也就是设置参数)，可选值包括三个：

• UNPOOLED：采用传统的获取连接的方式，虽然也实现了 javax.sql.DataSource 接口，但是并没有使用池的思想。

  • property 属性下可以设置：

  driver 这是JDBC驱动的Java类全限定名
  url 这是数据库的JDBC URL 地址
  usarname 登录数据库的用户名
  password 登录数据库的密码
  defaultTransactionlsolationLevel 默认的连接事务隔离级别
  defaultNetworkTimeout 等待数据库操作完成的默认网络超时实际（单位：毫秒）
  

  • POOLED：采用传统的 javax.sql.DataSource 规范中的连接池，MyBatis 中有针对规范的实现。
  • 在 POOlED 中的设置下的，property 可以是（除了包含 UNPOOLED中之外）：

  poolMazimunmActiveConnections 在任意时间可存在的活动（正在使用）连接数量，默认值 10
  poolMaximumldleConnections 任意时间可能存在的空闲连接数。
  其它...
  
  

  • JNDI：采用服务器提供的JNDI技术实现，来获取DataSource 对象，不同的服务器所能拿到 DataSource 是不一样，如果不是 web 或者 maven 的 war 工程，JNDI 是不能使用的。
  • 在JNDI 下的 property 属性设置，只有两个值：

  initial_context 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。
  data_source 这是引用数据源实例位置的上下文路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。
  

  简单的说就是：就是 Web容器（比如Tomcat）当中上面我们使用了数据库连接池，我们JNDI就只需要获取到Tomcat(这层我们使用的数据库连接池)就可以了，不需要再额外的去，搞个数据库连接池。

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

• mapper：配置某个 SQL 映射文件的路径

  • resource 属性：使用相对于类路径的资源引用方式
  • url 属性：使用完全限定资源定位符（URL）方式

MyBatis 核心配置，可以设置的内容，细节是比较多的，上述只是写明了一些比较常用的，一些设置，更多内容大家可以移步至：✏️✏️✏️https://mybatis.net.cn/configuration.html ，了解更多细节，配置。

2. 测试和学习的准备工作

两个 mybatis，mybatis2 数据库，分别都有t_car 数据表。

t_car 表结构：

对应上的 CarMapper.xml SQL语句的映射文件的编写。

这里因为是测试，所以我们简单点，直接将其写固定好了，测试学习，就添加了一个 insert 插入操作了。

<?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="car">
    <insert id="insertCar">
       insert into t_car values(null,'888','奥迪',30.0,'2000-11-11','燃油车2')
    </insert>
</mapper>

在 pom.xml 文件当中导入相关的依赖 jar 包内容。如下：

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rianbowsea</groupId>
    <artifactId>mybatis-004-configuration-blog</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>


    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>


        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>

        <!--        引入 logback的依赖，这个日志框架实现了slf4j 规范-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>
    </dependencies>

</project>

为了方便看到，相应的变化，这里我们需要导入一个；logback日志框架信息，同时配置该 logback 日志框架的配置，需要注意的是：该文件名，必须为"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>

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

3. environment 标签

<envrioments> 标签表示：配置环境（在MyBatis 的核心配置文件当中，可以配置多个），注意：一般s 结尾表示复数，也就是说MyBatis 的环境可以配置多个数据源.

既然有多个那么就有默认的了，在 <envrioments> 标签 中有一个 defalut 属性值，它是标识默认使用的环境(也就是哪个数据库)。

默认环境是什么意思，当你使用mybatis创建 sqlSessionFactory 对象的时候，没有指定环境的话，默认使用的就是，这里 default 指定的数据库的环境-

其中的一个环境，连接的数据库是 mybatis
一般一个数据库会对应上一个SqlSessionFactory对象
一个环境environment 对对应上一个SqlSessionFactory对象

<?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="mybatis">
        <!--        其中的一个环境，连接的数据库是 mybatis -->
        <!--        一般一个数据库会对应上一个SqlSessionFactory对象-->
        <!--        一个环境environment 对对应上一个SqlSessionFactory对象-->
        <environment id="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"/>
                <property name="username" value="root"/>
                <property name="password" value="MySQL123"/>
            </dataSource>
        </environment>


        <!--这是 mybatis 的另一个环境，也就是连接的数据库是另一个数据库mybatis2-->
        <environment id="mybatis2">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis2"/>
                <property name="username" value="root"/>
                <property name="password" value="MySQL123"/>
            </dataSource>
        </environment>

    </environments>
    <mappers>
        <mapper resource="CarMapper.xml"/>
    </mappers>
</configuration>

在Java当中使用默认的 enviroment 环境(也就是数据库)的编码方式如下：

// 获取SqlSessionFactory 对象（采用默认的方式）
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        // 这种方式就是获取默认的环境，因为你并没有指明其对应的环境
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));

    public void testEnvironment() throws IOException {
        // 获取SqlSessionFactory 对象（采用默认的方式）
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        // 这种方式就是获取默认的环境，因为你并没有指明其对应的环境
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));

        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 执行sql语句
        int count = sqlSession.insert("car.insertCar"); // 完整的 namespace.id
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();



    }

在Java当中使用 指定的 enviroment 环境(也就是数据库)的 编码方式如下：

// 获取SqlSessionFactory 对象（采用默认的方式）
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        // 这种方式就是通过环境id来使用指定的环境
        SqlSessionFactory sqlSessionFactory2 =
                sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"), "mybatis2");

    public void testEnvironment() throws IOException {
        // 获取SqlSessionFactory 对象（采用默认的方式）
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        // 这种方式就是通过环境id来使用指定的环境
        SqlSessionFactory sqlSessionFactory2 =
                sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"), "mybatis2");
        SqlSession sqlSession2 = sqlSessionFactory2.openSession();
        // 执行SQL语句
        int count2 = sqlSession2.insert("car.insertCar");
        sqlSession2.commit();
        sqlSession2.close();


    }

4. transactionManager 标签

transactionManager 我在这篇文章：✏️✏️✏️ 初始MyBatis ，详细步骤运行第一个MyBatis程序，同时对应步骤MyBatis底层剖析-CSDN博客 进行了更加详细的讲解说明，但为了保证文章的完整性，关于 transactionManager 标签的内容，这里稍微简短一些了。

transactionManager标签
作用：配置事务管理器，指定Mybatis具体使用什么方式去管理事务
type属性有两个值：

1. 第一个：JDBC: 使用原生的JDBC代码来管理事务
   conn.seAutoCommit( false )
   ...事务
   conn.commit( );
2. 第二个：MANAGED
   mybatis 不再负责事务的管理，将事务管理交给其它的JEE(JavaEE)容器来管理。 例如：spring

大小写无所谓，不区分大小写，但是不能不写其他值，只能是二选一（ jdbc;managed）

在mybatis中提供了一个事务管理器接口：Transaction；org.apache.ibatis.transaction;

该接口下有两大实现类
JdbcTransaction
ManagedTransaction

• 如果type="JDBC",那么底层会实例化JdbcTransaction对象
• 如果type="MANAGED",那么底层会实例化ManagedTransaction对象

5. dataSource 标签

<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="MySQL123"/>
</dataSource>

dataSource 配置

dataSource 被称之为 数据源

dataSource 作用是什么 ？

为程序员提供Connection对象，（但凡是给程序员提供 Connection连接对象的，都叫做数据源）

我们自己也可以编写数据源组件，只要实现 javax.sql.DataSource接口就行了，

实现接口当中所有的方法，这样就有了自己的数据源了。比如你可以写一个属于自己的数据库连接池（数据库连接池就是提供连接对象（Connection）的，所以数据库连接池就是一个数据源）

<dataSource type="指定数据源的类型其实就是指定使用哪个数据源连接池..."

常见的数据源组件有哪些呢（常见的数据库连接池有哪些呢）
阿里巴巴的德鲁伊数据库连接池（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容器（比如Tomcat）当中上面我们使用了数据库连接池，我们JNDI就只需要
获取到Tomcat(这层我们使用的数据库连接池)就可以了，不需要再额外的去，搞个数据库连接池。

<dataSource type="JNDI">
    <property name="initial_context" value="..."/>
    <property name="data_source" value="..."

当 type 是 UNPOOLED:

 <dataSource type="UNPOOLED">

关于 UNPOOLED 类型，有如下参数设置：

UNPOOLED 不会使用连接池，每一次都会新建JDBC连接对象。

测试程序：我们创建，获取到两个数据库对象，看看是是否是同一个。

当 type 是 POOLED:

<dataSource type="POOLED">

采用传统的 javax.sql.DataSource 规范中的连接池，MyBatis 中有针对规范的实现。

简单的说：就是 POOLED 是采用的数据库连接池的机制的，而这个数据库连接池是MyBatis 自己实现的。因为采用了数据库连接池，所以我们可以对其进行一些 UNPOOLED 没有的，数据库连接池上的参数设置：

注意：正常使用连接池的话，池中有很多的参数需要设置的，设置好参数，可以让连接池发挥的更好，事半功倍的效果，具体连接池当中的参数如何配置呢？需要反复的根据当前业务情况进行测试。

关于 POOLED 类型有如下参数设置：

下面我们简单测试几个比较重要的参数设置。

<!--                PooolMaximumActiveConnections 连接池当中最多的正在使用的连接对象的数量上限，
最多有多少个连接可以活动，默认值是10-->
                <!--最大连接数，默认是10个-->
                <property name="poolMaximumActiveConnections" value="10"/>
<!--                每隔两秒打印日志，并且尝试获取连接对象-->
                <property name="poolTimeToWait" value="2000"/>
<!--                强行让某个连接空间，超时间的设置，等待10，简单的说就是（没有多余连接的时候，等待10秒，就会强制关闭其中的一个连接，给你用）-->
                <property name="poolMaximumCheckoutTime" value="10000"/>
<!--                   假设最多的连接数是10个
                        最多空间的数量是：5个
                        假设目前已经空闲5个，马上第6个要空闲了。
                        假设第6个空闲下来了，此时连接池为了保证最多空闲的数量5个，会真正关闭多余的空闲的连接对象。

-->
<!--                最多的空闲数量-->
                <property name="poolMaximumIdleConnections" value="5"/>

运行测试：

首先我们测试一下：我们创建，获取到两个数据库对象，看看是是否是同一个。从而判断出是否使用了数据库连接池。

二，测试参数当中的配置信息，

    public void testDataSourcePoolMaximumActiveConnections() throws IOException {
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // SqlSessionFactoryBuilder对象，一个数据库一个，不要频繁创建该对象
        SqlSessionFactory sqlSessionFactory =
                sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"),"mybatis");

        // 通过sqlSessionFactory对象可以开启多个会话
        // 会话1
        for (int i = 0; i < 12; i++) {
            SqlSession sqlSession = sqlSessionFactory.openSession();
            sqlSession.insert("car.insertCar");
            // 不要关闭
        }

    }

poolMaximumActiveConnections：最大的活动的连接数量。默认值10

poolMaximumIdleConnections：最大的空闲连接数量。默认值5

poolMaximumCheckoutTime：强行回归池的时间。默认值20秒。

poolTimeToWait：当无法获取到空闲连接时，每隔20秒打印一次日志，避免因代码配置有误，导致傻等。（时长是可以配置的）

当然，还有其他属性。对于连接池来说，以上几个属性比较重要。

最大的活动的连接数量就是连接池连接数量的上限。默认值10，如果有10个请求正在使用这10个连接，第11个请求只能等待空闲连接。

最大的空闲连接数量。默认值5，如何已经有了5个空闲连接，当第6个连接要空闲下来的时候，连接池会选择关闭该连接对象。来减少数据库的开销。

需要根据系统的并发情况，来合理调整连接池最大连接数以及最多空闲数量。充分发挥数据库连接池的性能。【可以根据实际情况进行测试，然后调整一个合理的数量。】

通过测试得出：UNPOOLED不会使用连接池，每一次都会新建JDBC连接对象。POOLED会使用数据库连接池。

当 type 是 JNDI:

<dataSource type="JNDI">

JNDI的方式：表示对接JNDI服务器中的连接池。这种方式给了我们可以使用第三方连接池的接口。如果想使用dbcp、c3p0、druid（德鲁伊）等，需要使用这种方式。并且该连接方式必须在 web 项目 下才有效果。关于这一点，我会在后续的内容补上，并附上相关链接，这里说一声抱歉。

6. properties 标签

MyBatis 提供了更加灵活的配置，连接数据库的信息可以单独写到一个xxx.properties属性资源文件中，假设在类的根路径下创建 jdbc.properties文件，配置如下：

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis2
jdbc.username=root
jdbc.passwords=MySQL123

注意：以properties 后缀的文件，在编写其中的内容的时候：无论是开头，中间，还是结尾

都不要加空格，不然空格会被识别到的，容易出错

我们想要实现的是：

将连接数据库的信息，单独放到 jdbc.properties文件中，然后，在mybatis-config.xml MyBatis 的核心配置文件中，引入 jdbc.properties文件当中的信息。

首先我们需要在：mybatis-config.xml MyBatis 的核心配置文件中，引入 该jdbc.properties文件，使用：<properties> 标签。

<properties> 标签当中有两个属性值：分别是 ：resource ，url

• resource : 表示从类的路径下开始寻找相关的配置文件
• url ： 表示从系统路径下，开始寻找相关的配置文件

    <!--resource , 一定是从类路径下开始查找资源-->
    <properties resource="jdbc.properties"></properties>
    <!--    从绝对路径当中加载资源，绝对路径怎么写？ file:///路径，注意是三个 / -->
    <properties url="file:///d:/jdbc.properties"></properties> 

这里我们用 resource 类路径下寻找，可移植性更好

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

使用 ${对应 jdbc.properties的属性名} 进行赋值，注意是 $，不是 # ，和 MyBatis 当中的 SQL 语句的 #{} 不同。

运行测试：

properties 两个属性：

resource：这个属性从类的根路径下开始加载。【常用的。】

url：从指定的url加载，假设文件放在d:/jdbc.properties，这个url可以写成：file:///d:/jdbc.properties。注意是三个斜杠哦。

注意：如果不知道mybatis-config.xml文件中标签的编写顺序的话，可以有两种方式知道它的顺序：

• 第一种方式：查看dtd约束文件。
• 第二种方式：通过idea的报错提示信息。【一般采用这种方式】

7. mapper 标签

mapper标签用来指定SQL映射文件的路径，包含多种指定方式，这里先主要看其中两种：

第一种：resource，从类的根路径下开始加载【比url常用】

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

如果是这样写的话，必须保证类的根下有CarMapper.xml文件。

如果类的根路径下有一个包叫做test，CarMapper.xml如果放在test包下的话，这个配置应该是这样写：

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

第二种：url，从指定的url位置加载

假设CarMapper.xml文件放在d盘的根下，这个配置就需要这样写：

<mappers>
  <mapper url="file:///d:/CarMapper.xml"/>
</mappers>

mapper还有其他的指定方式，后面再看！！！

8. 总结：

1. mybatis-confg.xml ，也就是MyBatis 的核心配置文件，主要配置连接数据库的信息等(**一般一个数据库，对应一个这个MyBatis 的核心配置文件)，同样的与之对应的通过 mybatis-config.xml 核心配置文件' 所创建的对象：SqlSession FactoryBuilder，SqlSessionFactory 也是一个数据库相对应上一个对象。
2. <envrioments> 标签表示：配置环境（在MyBatis 的核心配置文件当中，可以配置多个），注意：一般s 结尾表示复数，也就是说MyBatis 的环境可以配置多个数据源.
3. transactionManager标签，作用：配置事务管理器，指定Mybatis具体使用什么方式去管理事务，该标签下的属性有两个值：

1. 第一个：JDBC: 使用原生的JDBC代码来管理事务
                conn.seAutoCommit( false )
                ...事务
                conn.commit( );
2. 第二个：MANAGED
 mybatis 不再负责事务的管理，将事务管理交给其它的JEE(JavaEE)容器来管理。 例如：spring

4. dataSource 被称之为 数据源 ,为程序员提供Connection对象，（但凡是给程序员提供 Connection连接对象的，都叫做数据源）,dataSource 标签下的 type="[UNPOOLED|POOLED|JNDI]"）必须三选一

- UNPOOLED: 不能使用数据库连接池技术，每一次请求过来之后，都是创建新的Connection对象。
- POOLED: 使用mybatis 自己实现的数据库连接池。
- JNDI: 集成其他第三方的数据库连接池。

连接池优点：每一次获取连接都从池中拿，效率高。
因为每一次只能从池中拿，所以连接对象的创建数量是可

5. MyBatis 提供了更加灵活的配置，连接数据库的信息可以单独写到一个xxx.properties属性资源文件中
6. mapper标签用来指定SQL映射文件的路径，包含多种指定方式，这里先主要看其中两种：

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

<mappers>
  <mapper url="file:///d:/CarMapper.xml"/>
</mappers>

9. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”

标签：配置文件,标签,数据库,mybatis,详解,MyBatis,连接池
From： https://www.cnblogs.com/TheMagicalRainbowSea/p/18222294