MyBatis載入配置檔案

LZC發表於2020-07-24
MyBatis
系列文章：
MyBatis 入門 MyBatis 配置 MyBatis 獲取自增主鍵 MyBatis 引數處理 MyBatis 返回結果 MyBatis 動態 SQL MyBatis 快取 MyBatis載入配置檔案 載入Mapper對映檔案 MyBatis介面繫結原理 MyBatis SQL執行 MyBatis外掛

配置檔案

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>

    <settings>
        <!--設定控制檯列印sql-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <environments default="development">
        <!-- 配置 MyBatis 執行環境 -->
        <environment id="development">
            <!-- 配置 JDBC 事務管理 -->
            <transactionManager type="JDBC"/>
            <!-- POOLED 配置 JDBC 資料來源連線池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/lzc?useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 註冊UserMapper.xml -->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>

</configuration>

Mapper

public interface UserMapper {
    public User getUserByUserName(String userName);
    public List<User> getUserList();
    public int addUser(User user);
    public int deleteUser(Integer id);
    public int updateUser(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">
<!--
namespace: 名稱空間, 如果有對應的介面，需要指定為對應介面的全類名, 如果使用原生介面, 則可以隨便填寫
id: 唯一標識
parameterType: 為引數資料型別,可以省略
resultType: 為返回值資料型別
#{username}是獲取傳遞過來的引數中獲取 username 的值
-->
<mapper namespace="com.example.demo.UserMapper">
    <select id="getUserByUserName"
            parameterType="String"
            resultType="com.example.demo.User">
        select
        id, username, user_email userEmail, user_city userCity, age
        from user
        where username = #{username}
    </select>
    <select id="getUserList"
            resultType="com.example.demo.User">
        select
        id, username, user_email userEmail, user_city userCity, age
        from user
    </select>
    <insert id="addUser"
            parameterType="com.example.demo.User">
        insert into user
        (username, user_email, user_city, age)
        values (#{username}, #{userEmail}, #{userCity}, #{age})
    </insert>
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{id}
    </delete>
    <update id="updateUser" parameterType="com.example.demo.User">
        update user
        set username=#{username}, user_email=#{userEmail}, user_city=#{userCity}, age=#{age}
        where id=#{id}
    </update>
</mapper>

Demo

public class App1 {
    public static void main(String[] args) {
        // 1. 獲取 MyBatis 配置檔案
        InputStream is = App1.class.getClassLoader().getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 2. 載入配置檔案資訊並構造 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        // 獲取 SqlSession, 代表和資料庫的一次會話, 用完需要關閉
        // SqlSession 和 Connection, 都是非執行緒安全的, 每次使用都應該去獲取新的物件
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 獲取實現介面的代理物件
        // UserMapper 並沒有實現類, 但是mybatis會為這個介面生成一個代理物件(將介面和xml繫結)
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        /*-------------------------------------------------------------------*/
        // 查詢
        List<User> userList = userMapper.getUserList();
        userList.stream().forEach(obj -> System.out.println(obj.toString()));
        sqlSession.close();
    }
}

MyBatis 初始化過程中，會載入 mybatis-config.xml 配置檔案、對映配置檔案以及 Mapper介面中的註解資訊，解析後的配置資訊會形成相應的物件並儲存到Configuration物件中。例如：

  • <resultMap>節點(即 ResultSet 的對映規則) 會被解析成 ResultMap 物件。
  • <result> 節點(即屬性對映)會被解析成 ResultMapping 物件。

之後，利用該Configuration物件建立SqlSessionFactory物件。待 MyBatis 初始化之後，開發人員可以透過初始化得到SqlSessionFactory建立SqlSession物件並完成資料庫操作。

// 1. 獲取 MyBatis 配置檔案
InputStream is = App1.class.getClassLoader().getResourceAsStream("mybatis-config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 2. 載入配置檔案資訊並構造 SqlSessionFactory
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
// SqlSessionFactoryBuilder.java
/**
 * 構造 SqlSessionFactory 物件
 * @param inputStream 配置檔案的流資訊
 */
public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
}

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        // 構建 XMLConfigBuilder 物件
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // parser.parse() 會返回一個 Configuration 物件
        // 配置檔案、對映配置檔案以及Mapper介面中的註解資訊都儲存在 Configuration 
        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);
}

主要負責解析mybatis-config.xml 配置檔案、對映配置檔案以及 Mapper介面中的註解資訊

parse

將MyBatis相關的配置檔案解析成Configuration物件

// XMLConfigBuilder.java
public Configuration parse() {`
    // 判斷是否已經解析過了
    // XMLConfigBuilder 只能解析一次
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }

    // 標記已經解析過
    parsed = true;

    // 解析 XML configuration 節點
    // parser.evalNode("/configuration")獲取mybatis-config.xml的<configuration /> 節點
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

parseConfiguration

解析 <configuration /> 節點資訊

// XMLConfigBuilder.java
private void parseConfiguration(XNode root) {
    try {
        // issue #117 read properties first
        // 解析 <properties /> 標籤
        propertiesElement(root.evalNode("properties"));

        // 解析 <settings /> 標籤
        Properties settings = settingsAsProperties(root.evalNode("settings"));

        // 載入自定義 VFS 實現類
        loadCustomVfs(settings);

        // 解析 <typeAliases /> 標籤
        typeAliasesElement(root.evalNode("typeAliases"));

        // 解析 <plugins /> 標籤
        pluginElement(root.evalNode("plugins"));

        // 解析 <objectFactory /> 標籤
        objectFactoryElement(root.evalNode("objectFactory"));

        // 解析 <objectWrapperFactory /> 標籤
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

        // 解析 <reflectorFactory /> 標籤
        reflectorFactoryElement(root.evalNode("reflectorFactory"));

        // 將 <settings /> 中設定的屬性賦值到 Configuration 屬性裡面去
        settingsElement(settings);

        // 解析 <environments /> 標籤
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));

        // 解析 <databaseIdProvider /> 標籤
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));

        // 解析 <typeHandlers /> 標籤
        typeHandlerElement(root.evalNode("typeHandlers"));

        // 解析 <mappers /> 標籤
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

propertiesElement

解析 <properties />標籤，

例如：

<properties resource="dbconfig.properties">
    <property name="username" value="dev_user"/>
    <property name="password" value="F2Fa3!33TYyg"/>
</properties>

dbconfig.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&characterEncoding=UTF-8
username=root
password=root

解析過程如下所示

// XMLConfigBuilder.java
private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
        // 獲取子標籤 <property />
        // 此時這裡的 defaults
        Properties defaults = context.getChildrenAsProperties();

        String resource = context.getStringAttribute("resource");
        String url = context.getStringAttribute("url");

        // resource 和 url 不能同時存在
        if (resource != null && url != null) {
            throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
        }
        // 讀取本地配置檔案到 defaults 中
        if (resource != null) {
            defaults.putAll(Resources.getResourceAsProperties(resource));
        } else if (url != null) {
            // 讀取遠端配置檔案到 defaults 中
            defaults.putAll(Resources.getUrlAsProperties(url));
        }

        // 獲取 configuration 中的 Properties 物件到 defaults
        Properties vars = configuration.getVariables();
        if (vars != null) {
            defaults.putAll(vars);
        }

        // 設定 defaults 到 parser 和 configuration 中
        parser.setVariables(defaults);
        configuration.setVariables(defaults);
    }
}

settingsAsProperties

解析 <settings/>標籤，例如：

<settings>
    <!--設定控制檯列印sql-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

解析過程如下所示

// XMLConfigBuilder.java
private Properties settingsAsProperties(XNode context) {
    if (context == null) {
        return new Properties();
    }
    // 獲取子標籤
    Properties props = context.getChildrenAsProperties();

    // Check that all settings are known to the configuration class
    // 校驗每個屬性在Configuration中都有相應的 setting 方法，否則丟擲 BuilderException 異常
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
    for (Object key : props.keySet()) {
        if (!metaConfig.hasSetter(String.valueOf(key))) {
            throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
        }
    }
    return props;
}

loadCustomVfs

載入自定義 VFS 實現類

// XMLConfigBuilder.java
private void loadCustomVfs(Properties props) throws ClassNotFoundException {
    // 先獲取 vfsImpl 屬性的值
    String value = props.getProperty("vfsImpl");
    if (value != null) {
        // 如果 vfsImpl 屬性的值不為空，則使用逗號進行分割
        String[] clazzes = value.split(",");
        // 遍歷 VFS 類名的陣列
        for (String clazz : clazzes) {
            if (!clazz.isEmpty()) {
                // 獲取例項
                @SuppressWarnings("unchecked")
                Class<? extends VFS> vfsImpl = (Class<? extends VFS>)Resources.classForName(clazz);
                // 儲存到 configuration 中
                configuration.setVfsImpl(vfsImpl);
            }
        }
    }
}

typeAliasesElement

解析<typeAliases />標籤

型別別名可為 Java 型別設定一個縮寫名字。 它僅用於 XML 配置，意在降低冗餘的全限定類名書寫。例如：

<typeAliases>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
</typeAliases>

當這樣配置時，Blog 可以用在任何使用 domain.blog.Blog 的地方。

也可以指定一個包名，MyBatis 會在包名下面搜尋需要的 Java Bean，比如：

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

解析過程如下所示

// XMLConfigBuilder.java
private void typeAliasesElement(XNode parent) {
    if (parent != null) {
        // 遍歷typeAliases子節點
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                // 指定了一個包名，則註冊這個包名下的所有類
                String typeAliasPackage = child.getStringAttribute("name");
                // 註冊到 typeAliasRegistry 中
                configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {
                // 指定了某個類，則註冊類與類對應的別名
                String alias = child.getStringAttribute("alias");
                String type = child.getStringAttribute("type");
                try {
                    Class<?> clazz = Resources.classForName(type);
                    // 註冊到 typeAliasRegistry 中
                    if (alias == null) {
                        // 沒有指定別名，預設為這個類的類名
                        typeAliasRegistry.registerAlias(clazz);
                    } else {
                        typeAliasRegistry.registerAlias(alias, clazz);
                    }
                } catch (ClassNotFoundException e) {
                    throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
                }
            }
        }
    }
}

pluginElement

解析 <plugins /> 標籤，新增到 Configuration中的interceptorChain屬性

// XMLConfigBuilder.java
private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
        // 遍歷 plugins 子節點
        for (XNode child : parent.getChildren()) {
            String interceptor = child.getStringAttribute("interceptor");
            // 建立 Interceptor 物件，並設定屬性
            Properties properties = child.getChildrenAsProperties();
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
            interceptorInstance.setProperties(properties);
            // 新增到 configuration 中
            configuration.addInterceptor(interceptorInstance);
        }
    }
}

objectFactoryElement

解析 <objectFactory /> 節點

<!-- mybatis-config.xml -->
<objectFactory type="org.mybatis.example.ExampleObjectFactory">
  <property name="someProperty" value="100"/>
</objectFactory>

解析流程如下所示

// XMLConfigBuilder.java
private void objectFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 獲得 ObjectFactory 的實現類
        String type = context.getStringAttribute("type");
        // 獲得 Properties 屬性
        Properties properties = context.getChildrenAsProperties();
        // 建立 ObjectFactory 物件，並設定 Properties 屬性
        ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
        factory.setProperties(properties);
        // 設定 Configuration 的 objectFactory 屬性
        configuration.setObjectFactory(factory);
    }
}

每次 MyBatis 建立結果物件的新例項時，它都會使用一個物件工廠（ObjectFactory）例項來完成例項化工作。 預設的物件工廠需要做的僅僅是例項化目標類，要麼透過預設無參構造方法，要麼透過存在的引數對映來呼叫帶有引數的構造方法。 如果想覆蓋物件工廠的預設行為，可以透過建立自己的物件工廠來實現。

objectWrapperFactoryElement

解析 標籤

// XMLConfigBuilder.java
private void objectWrapperFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 拿到 ObjectFactory 的實現類
        String type = context.getStringAttribute("type");
        // 建立 ObjectWrapperFactory 物件
        ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).newInstance();
        // 設定 Configuration 的 objectWrapperFactory 屬性
        configuration.setObjectWrapperFactory(factory);
    }
}

reflectorFactoryElement

解析 標籤

// XMLConfigBuilder.java
private void reflectorFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 獲得 ReflectorFactory 的實現類
        String type = context.getStringAttribute("type");
        // 建立 ReflectorFactory 物件
        ReflectorFactory factory = (ReflectorFactory) resolveClass(type).newInstance();
        // 設定 Configuration 的 reflectorFactory 屬性
        configuration.setReflectorFactory(factory);
    }
}

settingsElement

將 中設定的屬性賦值到 Configuration 屬性裡面去

// XMLConfigBuilder.java
private void settingsElement(Properties props) throws Exception {
    configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
    configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
    configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
    configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
    configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
    configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
    configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
    configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
    configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
    configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
    configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
    configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
    configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
    configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
    configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
    configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
    configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
    configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
    configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
    @SuppressWarnings("unchecked")
    Class<? extends TypeHandler> typeHandler = (Class<? extends TypeHandler>)resolveClass(props.getProperty("defaultEnumTypeHandler"));
    configuration.setDefaultEnumTypeHandler(typeHandler);
    configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
    configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
    configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
    configuration.setLogPrefix(props.getProperty("logPrefix"));
    @SuppressWarnings("unchecked")
    Class<? extends Log> logImpl = (Class<? extends Log>)resolveClass(props.getProperty("logImpl"));
    configuration.setLogImpl(logImpl);
    configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
}

environmentsElement

解析 標籤

<!-- default屬性指定預設的執行環境 -->
<environments default="development">
    <!-- 配置 MyBatis 執行環境 -->
    <environment id="development">
        <!-- 配置 JDBC 事務管理 -->
        <transactionManager type="JDBC"/>
        <!-- POOLED 配置 JDBC 資料來源連線池 -->
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/lzc?useUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="root"/>
        </dataSource>
    </environment>
</environments>

解析流程如下

// XMLConfigBuilder.java
private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
        if (environment == null) {
            // 如果 environment  為空，則從 default 屬性中獲取
            environment = context.getStringAttribute("default");
        }
        // 遍歷 environments 的子節點
        for (XNode child : context.getChildren()) {
            // 獲取 environment 標籤的 id 屬性
            String id = child.getStringAttribute("id");
            // 這裡判斷 environments 標籤的 default 屬性值是否與 
            // environment 標籤的 id 屬性值相等
            if (isSpecifiedEnvironment(id)) {
                // 解析 <transactionManager /> 標籤並返回 TransactionFactory 物件
                TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                // 解析 <dataSource /> 標籤，返回 DataSourceFactory 物件
                DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));

                DataSource dataSource = dsFactory.getDataSource();
                Environment.Builder environmentBuilder = new Environment.Builder(id)
                    .transactionFactory(txFactory)
                    .dataSource(dataSource);

                // 構造 Environment 物件，並設定到 configuration 中
                configuration.setEnvironment(environmentBuilder.build());
            }
        }
    }
}

databaseIdProviderElement

解析 標籤

MyBatis 可以根據不同的資料庫廠商執行不同的語句，這種多廠商的支援是基於對映語句中的 databaseId 屬性。 MyBatis 會載入帶有匹配當前資料庫 databaseId 屬性和所有不帶 databaseId 屬性的語句。 如果同時找到帶有 databaseId 和不帶 databaseId 的相同語句，則後者會被捨棄。 為支援多廠商特性，只要像下面這樣在 mybatis-config.xml 檔案中加入 databaseIdProvider 即可：

<databaseIdProvider type="DB_VENDOR" />

databaseIdProvider 對應的 DB_VENDOR 實現會將 databaseId 設定為 DatabaseMetaData#getDatabaseProductName() 返回的字串。 由於通常情況下這些字串都非常長，而且相同產品的不同版本會返回不同的值，你可能想透過設定屬性別名來使其變短：

<databaseIdProvider type="DB_VENDOR">
  <property name="SQL Server" value="sqlserver"/>
  <property name="DB2" value="db2"/>
  <property name="Oracle" value="oracle" />
</databaseIdProvider>

解析流程如下

// XMLConfigBuilder.java
private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
        String type = context.getStringAttribute("type");
        // awful patch to keep backward compatibility
        if ("VENDOR".equals(type)) {
            type = "DB_VENDOR";
        }
        // 獲得 Properties 物件
        Properties properties = context.getChildrenAsProperties();
        // 建立 DatabaseIdProvider 物件
        databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
        databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
        // 獲得 environment 對應的 databaseId 編號
        String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
        // 將 databaseId 設定到 configuration 中
        configuration.setDatabaseId(databaseId);
    }
}

typeHandlerElement

解析 標籤

MyBatis 在設定預處理語句（PreparedStatement）中的引數或從結果集中取出一個值時， 都會用型別處理器將獲取到的值以合適的方式轉換成 Java 型別。

// XMLConfigBuilder.java
private void typeHandlerElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                // 如果是 package 標籤，則掃描該包
                String typeHandlerPackage = child.getStringAttribute("name");
                typeHandlerRegistry.register(typeHandlerPackage);
            } else {
                // 如果是 typeHandler 標籤，則註冊該 typeHandler 資訊
                String javaTypeName = child.getStringAttribute("javaType");
                String jdbcTypeName = child.getStringAttribute("jdbcType");
                String handlerTypeName = child.getStringAttribute("handler");
                Class<?> javaTypeClass = resolveClass(javaTypeName);
                JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
                Class<?> typeHandlerClass = resolveClass(handlerTypeName);
                if (javaTypeClass != null) {
                    if (jdbcType == null) {
                        typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
                    } else {
                        typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
                    }
                } else {
                    typeHandlerRegistry.register(typeHandlerClass);
                }
            }
        }
    }
}

mapperElement

解析 標籤，即解析我們編寫的Mapper介面或者是Mapper.xml檔案

既然 MyBatis 的行為已經由上述元素配置完了，我們現在就要來定義 SQL 對映語句了。 但首先，我們需要告訴 MyBatis 到哪裡去找到這些語句。 在自動查詢資源方面，Java 並沒有提供一個很好的解決方案，所以最好的辦法是直接告訴 MyBatis 到哪裡去找對映檔案。 你可以使用相對於類路徑的資源引用，或完全限定資源定位符（包括 file:/// 形式的 URL），或類名和包名等。例如：

<!-- 使用相對於類路徑的資源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<!-- 使用完全限定資源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

<!-- 使用對映器介面實現類的完全限定類名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!-- 將包內的對映器介面實現全部註冊為對映器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

解析流程

// XMLConfigBuilder.java
private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        // 遍歷 mappers 的子節點
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                // 如果是 package 標籤，則掃描該包
                String mapperPackage = child.getStringAttribute("name");
                configuration.addMappers(mapperPackage);
            } else {
                // 如果是 mapper 標籤
                 // 獲得 resource、url、class 屬性
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");

                if (resource != null && url == null && mapperClass == null) {
                    // 下一節將會分析如何解析 resource
                    // 解析 resource
                    ErrorContext.instance().resource(resource);
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url != null && mapperClass == null) {
                    // 解析 url
                    ErrorContext.instance().resource(url);
                    InputStream inputStream = Resources.getUrlAsStream(url);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url == null && mapperClass != null) {
                    // 解析 mapperClass
                    Class<?> mapperInterface = Resources.classForName(mapperClass);
                    configuration.addMapper(mapperInterface);
                } else {
                    throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                }
            }
        }
    }
}
本作品採用《CC 協議》，轉載必須註明作者和本文連結

相關文章