Hello World

配置文件

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 初始化过程中，会加载 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);

SqlSessionFactory

// 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);
}

XMLConfigBuilder

主要负责解析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 协议》，转载必须注明作者和本文链接