MyBatis 源码阅读之旅一

最新推荐文章于 2024-06-12 21:52:13 发布

Rickesy

最新推荐文章于 2024-06-12 21:52:13 发布

阅读量1w

点赞数 3

分类专栏： MyBatis源码阅读之旅文章标签： mybatis 源码

本文链接：https://blog.csdn.net/Rickesy/article/details/52075410

版权

MyBatis源码阅读之旅专栏收录该内容

1 篇文章 0 订阅

订阅专栏

参考官方入门文档：
英文：http://www.mybatis.org/mybatis-3/getting-started.html
中文：http://www.mybatis.org/mybatis-3/zh/getting-started.html

MyBatis 作为一个框架，通过框架配置文件configuration.xml为框架的运行设置相关参数。
正如入门文档中开篇所说：Building SqlSessionFactory from XML ，源码阅读也从实际使用出发，即构建SqlSessionFactory并读取XML中的配置参数

官方入门文档又给出使用示例：

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

可以看出SqlSessionFactory对象是有SqlSessionFactoryBuilder构建出来的

SqlSessionFactoryBuilder源码如下：

package org.apache.ibatis.session;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Properties;
import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.exceptions.ExceptionFactory;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;

public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(Reader reader) {
        return build(reader, null, null);
    }
    public SqlSessionFactory build(Reader reader, String environment) {
        return build(reader, environment, null);
    }
    public SqlSessionFactory build(Reader reader, Properties properties) {
        return build(reader, null, properties);
    }
    public SqlSessionFactory build(Reader reader, String environment,
            Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment,
                    properties);
            return build(parser.parse());
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building SqlSession.",
                    e);
        } finally {
            ErrorContext.instance().reset();
            try {
                reader.close();
            } catch (IOException e) {
                // Intentionally ignore. Prefer previous error.
            }
        }
    }

    public SqlSessionFactory build(InputStream inputStream) {
        return build(inputStream, null, null);
    }
    public SqlSessionFactory build(InputStream inputStream, String environment) {
        return build(inputStream, environment, null);
    }
    public SqlSessionFactory build(InputStream inputStream,
            Properties properties) {
        return build(inputStream, null, properties);
    }
    public SqlSessionFactory build(InputStream inputStream, String environment,
            Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream,
                    environment, properties);
            return build(parser.parse());
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building SqlSession.",
                    e);
        } finally {
            ErrorContext.instance().reset();
            try {
                inputStream.close();
            } catch (IOException e) {
                // Intentionally ignore. Prefer previous error.
            }
        }
    }
    public SqlSessionFactory build(Configuration config) {
        return new DefaultSqlSessionFactory(config);
    }
}

其结构：
这里写图片描述

通过类源码的阅读，可以发现：
1. 通过IO流读取XML文件：Reader和InputStream，既支持字符流也支持字节流
2. 每种IO流读取XML文件方法均有不同参数列表的重载方法，以支持多种参数组合
3. 无论何种IO流读取，最终均调用build(Configuration)方法，返回一个官方默认实现的SqlSessionFactory实例

以字符流为例：

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
            return build(parser.parse());
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
            ErrorContext.instance().reset();
            try {
                reader.close();
            } catch (IOException e) {
                // Intentionally ignore. Prefer previous error.
            }
        }
    }

Reader均能理解，用于读取指定路径的XML文件，但environment参数和properties参数又有什么用？又为何需要传递这两个参数？

先说说properties参数：
官方其实在XML文件properties标签示例中也已做说明：http://www.mybatis.org/mybatis-3/zh/configuration.html#properties

这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过 properties 元素的子元素来传递。
例如：

<properties resource="org/mybatis/example/config.properties">
    <property name="username" value="dev_user"/>
    <property name="password" value="F2Fa3!33TYyg"/>
</properties>

其中的属性就可以在整个配置文件中使用来替换需要动态配置的属性值。比如:

<dataSource type="POOLED">
    <property name="driver" value="${driver}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>
</dataSource>

这个例子中的 username 和 password 将会由 properties 元素中设置的相应值来替换。

driver 和 url 属性将会由 config.properties 文件中对应的值来替换。这样就为配置提供了诸多灵活选择。

属性也可以被传递到 SqlSessionBuilder.build()方法中。例如：

SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, props);
// ... or ...
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment, props);

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

在 properties 元素体内指定的属性首先被读取。
然后根据 properties 元素中的 resource 属性读取类路径下属性文件或根据 url 属性指定的路径读取属性文件，并覆盖已读取的同名属性。
最后读取作为方法参数传递的属性，并覆盖已读取的同名属性。
因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的是 properties 属性中指定的属性。

再来说说environment参数：
官方其实在XML文件environment标签示例中也做了说明：http://www.mybatis.org/mybatis-3/zh/configuration.html#environments
MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中，现实情况下有多种理由需要这么做。
例如，开发、测试和生产环境需要有不同的配置；或者共享相同 Schema 的多个生产数据库，想使用相同的 SQL 映射。许多类似的用例。

不过要记住：尽管可以配置多个环境，每个 SqlSessionFactory 实例只能选择其一。

所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。而如果是三个数据库，就需要三个实例，依此类推，记起来很简单：
每个数据库对应一个 SqlSessionFactory 实例

为了指定创建哪种环境，只要将它作为可选的参数传递给 SqlSessionFactoryBuilder 即可。

可以接受环境配置的两个方法签名是：

SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment);
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment,properties);

如果忽略了环境参数，那么默认环境将会被加载，如下所示：

SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader);
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader,properties);

环境元素定义了如何配置环境。

<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC">
           <property name="..." value="..."/>
        </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>

注意这里的关键点:
默认的环境 ID（比如:default=”development”）。
每个 environment 元素定义的环境 ID（比如:id=”development”）。
事务管理器的配置（比如:type=”JDBC”）。
数据源的配置（比如:type=”POOLED”）。
默认的环境和环境 ID 是一目了然的。随你怎么命名，只要保证默认环境要匹配其中一个环境ID。

实际可如下使用：

<environments default="development">
    <environment id="write">
        <transactionManager type="JDBC">
           <property name="..." value="..."/>
        </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>
     <environment id="read">
        <transactionManager type="JDBC">
           <property name="..." value="..."/>
        </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>

SqlSessionFactory writeSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream,"write");
SqlSessionFactory readSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream,"read");

而构造方法体内的语句：

try {
    XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
    return build(parser.parse());
} catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
} finally {
    ErrorContext.instance().reset();
    try {
        reader.close();
    } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
    }
}