Java 知识库

# MyBatis源码-配置文件解析

这一节我们来看看 MyBatis 如何把xml文件解析为配置文件

下面结合 xml 配置文件对 MyBatis 配置解析进行分析，为了更加直观的了解有哪些配置项，所以在下方列出来了一个尽量配置比较全的配置文件内容。

# 配置文件

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

	<!--  This file is for a reference purpose for various configuration options -->
	<properties resource="application.properties">
		<property name="username" value="db_user"/>
  		<property name="password" value="verysecurepwd"/>	
	</properties>
	
	<settings>
		  <setting name="cacheEnabled" value="true"/>
		  <setting name="lazyLoadingEnabled" value="true"/>
		  <setting name="multipleResultSetsEnabled" value="true"/>
		  <setting name="useColumnLabel" value="true"/>
		  <setting name="useGeneratedKeys" value="false"/>
		  <setting name="autoMappingBehavior" value="PARTIAL"/>
		  <setting name="defaultExecutorType" value="SIMPLE"/>
		  <setting name="defaultStatementTimeout" value="25000"/>
		  <setting name="safeRowBoundsEnabled" value="false"/>
		  <setting name="mapUnderscoreToCamelCase" value="false"/>
		  <setting name="localCacheScope" value="SESSION"/>
		  <setting name="jdbcTypeForNull" value="OTHER"/>
		  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
	</settings>
	
	  <typeAliases>
	  	<typeAlias alias="Tutor" type="com.mybatis3.domain.Tutor"/>
	  	<package name="com.mybatis3.domain"/>
	  </typeAliases>
	  
		<typeHandlers>
		  <typeHandler handler="com.mybatis3.typehandlers.PhoneTypeHandler"/>
		  <package name="com.mybatis3.typehandlers"/>
		</typeHandlers>

	 <environments default="development">
	    <environment id="development">
	      <transactionManager type="JDBC"/>
	      <dataSource type="POOLED">
	        <property name="driver" value="${jdbc.driverClassName}"/>
	        <property name="url" value="${jdbc.url}"/>
	        <property name="username" value="${jdbc.username}"/>
	        <property name="password" value="${jdbc.password}"/>
	      </dataSource>
	    </environment>
	    
	    <environment id="production">
	      <transactionManager type="JDBC"/>
	      <dataSource type="JNDI">
	        <property name="data_source" value="java:comp/jdbc/MyBatisDemoDS"/>
	      </dataSource>
	    </environment>
	    
	  </environments>
    
     <!-- 插件 -->
      <plugins>
        <plugin interceptor="com.example.plugin.MyPlugin">
          <property name="someProperty" value="someValue"/>
        </plugin>
      </plugins>
	    <!-- 对象工厂 -->
      <objectFactory type="com.example.factory.CustomObjectFactory"/>

      <!-- 对象包装工厂 -->
      <objectWrapperFactory type="com.example.wrapper.CustomObjectWrapperFactory"/>

      <!-- 反射工厂 -->
      <reflectorFactory type="com.example.reflector.CustomReflectorFactory"/>
    
	  <mappers>
	    <mapper resource="com/mybatis3/mappers/StudentMapper.xml"/>
	    <mapper url="file:///var/mappers/StudentMapper.xml"/>
	    <mapper class="com.mybatis3.mappers.TutorMapper"/>
	  </mappers>
  	
  	
</configuration>

# 解析配置文件入口

  public Configuration parse() {
    // 不允许重复解析
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    // 从根节点开展解析
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

//解析xml文件的各个节点
private void parseConfiguration(XNode root) {
    try {
      //解析properties 节点主要是自定义配置项
      propertiesElement(root.evalNode("properties"));
      //解析 settings 节点，并将其转换为 Properties 对象
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      //加载自定义的虚拟文件系统和日志实现，通常用于扩展 MyBatis 的功能
      loadCustomVfs(settings);
      loadCustomLogImpl(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"));
      //将解析的设置应用于当前环境
      settingsElement(settings);
      //解析 environments 节点，处理不同的环境配置
      environmentsElement(root.evalNode("environments"));
      //解析 databaseIdProvider 节点，用于设置数据库 ID 提供者
      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);
    }
  }

# properties 节点

<properties resource="application.properties">
    <property name="username" value="db_user"/>
    <property name="password" value="verysecurepwd"/>	
</properties>

properties 节点主要是自定义配置项，也就是传统的 key value 键值形式配置。但需要注意的是，该节点配置是支持多种形式的设置。

  1. 可以直接在 xml 文件 如 <property name="username" value="db_user"/> 形式配置。

  2. 还支持指定 resource 和 url 形式配置，比如： <properties resource="application.properties" url="http://www.xx.com/con.properties">。 resource 和 url 参数只能指定其一。

  private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
      //读取xml properties 配置
      Properties defaults = context.getChildrenAsProperties();
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("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.");
      }
      //读取本能资源路径获取配置内容
      if (resource != null) {
        defaults.putAll(Resources.getResourceAsProperties(resource));
      } else if (url != null) {
        //根据http地址加载配置内容
        defaults.putAll(Resources.getUrlAsProperties(url));
      }
      //获取系统已经设置的其它配置内容
      Properties vars = configuration.getVariables();
      if (vars != null) {
        defaults.putAll(vars);
      }
      //XPathParser 解析器也设置下配置项
      parser.setVariables(defaults);
      configuration.setVariables(defaults);
    }
  }

# settings 节点

<settings>
      <setting name="cacheEnabled" value="true"/>
      <setting name="lazyLoadingEnabled" value="true"/>
      <setting name="multipleResultSetsEnabled" value="true"/>
      <setting name="useColumnLabel" value="true"/>
      <setting name="useGeneratedKeys" value="false"/>
      <setting name="autoMappingBehavior" value="PARTIAL"/>
      <setting name="defaultExecutorType" value="SIMPLE"/>
      <setting name="defaultStatementTimeout" value="25000"/>
      <setting name="safeRowBoundsEnabled" value="false"/>
      <setting name="mapUnderscoreToCamelCase" value="false"/>
      <setting name="localCacheScope" value="SESSION"/>
      <setting name="jdbcTypeForNull" value="OTHER"/>
      <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

settings 节点，主要是对 MyBatis 相关设置比如：缓存、字段驼峰处理、超时时间等等设置。

  private Properties settingsAsProperties(XNode context) {
    //读取不到settings 返回空对象
    if (context == null) {
      return new Properties();
    }
    Properties props = context.getChildrenAsProperties();
    // 通过反射获取 Configuration 类的各个属性
    //localReflectorFactory 工厂主要提供对象反射的过程中是否使用缓存
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
    for (Object key : props.keySet()) {
       //把配置文件中设置的配置项 添加到 Configuration 对象，如果设置的配置项在 Configuration 里边没有对应属性就抛出异常
      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;
  }

MetaClass 类主要提供反射相关操作，它可以拿出来单独使用。在平时的开发中，没有过多其它的依赖。

# typeAliases 节点

  <typeAliases>
    <typeAlias alias="Tutor" type="com.mybatis3.domain.Tutor"/>
    <package name="com.mybatis3.domain"/>
  </typeAliases>

该节点主要解析类型别名，可以用两种方式进行配置分别为 typeAlias 和 package ， package 配置必须放在最后。如果配置了类型别名，类型直接指定别名就行了。

	<select id="queryUserBySchoolName" resultType="Tutor">
        SELECT * FROM `user`
    </select>

  private void typeAliasesElement(XNode parent) {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
         //获取 package 节点
        if ("package".equals(child.getName())) {
            //拿到需要扫描包路径
          String typeAliasPackage = child.getStringAttribute("name");
            //根据路径地址扫描路径下的所有类文件
          configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
        } else {
            //获取配置的别名
          String alias = child.getStringAttribute("alias");
            //别名对应的类路径
          String type = child.getStringAttribute("type");
          try {
            //通过类路径 反射创建对象
            Class<?> clazz = Resources.classForName(type);
            if (alias == null) {
                //如果 xml 文件没配置别名名称 ，继续查找是否配置 Alias 注解
              typeAliasRegistry.registerAlias(clazz);
            } else {
              typeAliasRegistry.registerAlias(alias, clazz);
            }
          } catch (ClassNotFoundException e) {
            throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
          }
        }
      }
    }
  }

	//根据包路径注册别名
  public void registerAliases(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
      //扫描包路径下所有类文件
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for (Class<?> type : typeSet) {
      // Ignore inner classes and interfaces (including package-info.java)
      // Skip also inner classes. See issue #6
      	//isAnonymousClass是否是匿名类
        //isInterface是否是接口
        //isMemberClass是否是成员类（非静态内部类）
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(type);
      }
    }
  }

通过上面的源码可以知道，MyBatis 支持别名的形式配置，简单点来说就是通过维护一个映射表，通过名称直接可以找到名称对应的类文件路径。

MyBatis 默认注册了一批别名数据

public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
  }

# plugins 节点

  <plugins>
    <plugin interceptor="com.example.plugin.MyPlugin">
      <property name="someProperty" value="someValue"/>
    </plugin>
  </plugins>

MyBatis 通过拦截器的形式来实现插件，可以对整个数据库操作过程当中进行拓展。

  private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
          //获取拦截器实现类
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();
          //创建拦截器对象
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
          //设置定义的属性
        interceptorInstance.setProperties(properties);
          //添加到配置拦截器中
        configuration.addInterceptor(interceptorInstance);
      }
    }
  }

MyBatis plugins 机制，后边会单独详细解析

# objectFactory 节点

<objectFactory type="com.example.factory.CustomObjectFactory">
	<property name="someProperty" value="100"/>
</objectFactory>

这个节点主要配置对象工厂，MyBatis 默认提供了对象工厂的实现 DefaultObjectFactory 实现比较简单，基本上是根据类来创建一个对象，但在平时的开发过程当中，有可能需要在对象创建的时候进行一些操作，在这种情况下就需要自定义对象工厂来实现。

比如：

public class CustomObjectFactory extends DefaultObjectFactory {

    @Override
    public Object create(Class type) {
        if (type.equals(People.class)){
            People p = (People)super.create(type);
            p.setAge(22);
            return p;
        }
        return super.create(type);
    }

    @Override
    public void setProperties(Properties properties) {
        Iterator iterator = properties.keySet().iterator();
        while (iterator.hasNext()){
            String keyValue = String.valueOf(iterator.next());
        }
        super.setProperties(properties);
    }

    @Override
    public <T> boolean isCollection(Class<T> type) {
        return Collection.class.isAssignableFrom(type);
    }

}

  private void objectFactoryElement(XNode context) throws Exception {
    if (context != null) {
        //获取自定义对象工厂类路径
      String type = context.getStringAttribute("type");
      Properties properties = context.getChildrenAsProperties();
        //通过反射创建一个对象
      ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
      factory.setProperties(properties);
        //添加到配置对象中
      configuration.setObjectFactory(factory);
    }
  }

# objectWrapperFactory 节点

 <objectWrapperFactory type="com.example.wrapper.CustomObjectWrapperFactory"/>

ObjectWrapperFactory 在 MyBatis 中用于自定义对象的封装方式。当 MyBatis 从数据库中查询结果时，它会将结果映射到 Java 对象。通过实现 ObjectWrapperFactory 接口，可以自定义如何将查询结果封装到 Java 对象中。

比如：

import org.apache.ibatis.reflection.wrapper.ObjectWrapper;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;

public class CustomObjectWrapperFactory implements ObjectWrapperFactory {

    @Override
    public boolean hasWrapperFor(Object obj) {
        return User.class.isAssignableFrom(obj.getClass());
    }

    @Override
    public ObjectWrapper getWrapperFor(Object obj) {
        return new CustomObjectWrapper(obj);
    }
}
import org.apache.ibatis.reflection.wrapper.ObjectWrapper;

public class CustomObjectWrapper implements ObjectWrapper {
    private final Object object;

    public CustomObjectWrapper(Object object) {
        this.object = object;
    }

    @Override
    public void set(String propertyName, Object value) {
        if ("user".equals(propertyName) && value instanceof String) {
            // 将 JSON 字符串转换为 User 对象
            User user = convertJsonToUser((String) value);
            // 设定转换后的对象
            // 这里需要用到反射或其他方法将 user 设置到 object 中
        } else {
            // 其他属性设置
        }
    }

    // 实现其他方法...
    
    private User convertJsonToUser(String json) {
        // 使用 JSON 库将字符串转换为 User 对象
    }
}


//这块源码比较简单，获取类路径通过反射加载  
private void objectWrapperFactoryElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type");
      ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).newInstance();
      configuration.setObjectWrapperFactory(factory);
    }
  }

# reflectorFactory 节点

<reflectorFactory type="com.example.reflector.CustomReflectorFactory"/>

ReflectorFactory 在 MyBatis 中用于自定义反射行为。MyBatis 使用反射来访问 Java 对象的属性和方法，通过实现 ReflectorFactory 接口，可以定制如何创建和管理 Reflector 对象，以便更灵活地处理属性访问和方法调用。

自定义情况下，使用自定义的 ReflectorFactory 可以确保 MyBatis 能够正确处理带有自定义注解的属性。例如，如果你有一个实体类，某些字段使用了注解来指定数据库列名或其他元数据，通过自定义的 ReflectorFactory 可以解析这些注解并在进行数据库操作时使用它们。

//获取类路径通过反射加载    
private void reflectorFactoryElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type");
      ReflectorFactory factory = (ReflectorFactory) resolveClass(type).newInstance();
      configuration.setReflectorFactory(factory);
    }
  }

# environments 节点

 <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>

    <environment id="production">
      <transactionManager type="JDBC"/>
      <dataSource type="JNDI">
        <property name="data_source" value="java:comp/jdbc/MyBatisDemoDS"/>
      </dataSource>
    </environment>

  </environments>

environment 主要是对环境进行配置，比如：开发环境、生产环境。需要注意的是 type 支持3种配置 UNPOOLED、POOLED、JNDI

UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。

POOLED– 这个是使用数据库连接池，提前创建一批连接提供了效率。

JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。

private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
      if (environment == null) {
          //获取默认数据源
        environment = context.getStringAttribute("default");
      }
      for (XNode child : context.getChildren()) {
        String id = child.getStringAttribute("id");
          //默认数据源id与配置的id是否一致
        if (isSpecifiedEnvironment(id)) {
            //事务工厂
          TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
            //数据源连接工厂
          DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
          DataSource dataSource = dsFactory.getDataSource();
          Environment.Builder environmentBuilder = new Environment.Builder(id)
              .transactionFactory(txFactory)
              .dataSource(dataSource);
          configuration.setEnvironment(environmentBuilder.build());
        }
      }
    }
  }
	//根据 type 创建数据源工厂
  private DataSourceFactory dataSourceElement(XNode context) throws Exception {
    if (context != null) {
        //获取type对应的值 比如 POOLED
      String type = context.getStringAttribute("type");
      Properties props = context.getChildrenAsProperties();
        //resolveClass 会根据别名先查找对象是否注册
      DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
      factory.setProperties(props);
      return factory;
    }
    throw new BuilderException("Environment declaration requires a DataSourceFactory.");
  }

# databaseIdProvider 节点

<!--数据库厂商标示 -->
<databaseIdProvider type="DB_VENDOR">
    <property name="Oracle" value="oracle"/>
    <property name="MySQL" value="mysql"/>
</databaseIdProvider>

<mapper namespace="cn.mybatis.mapper.TimeMapper" >
  <select id="getTime"  resultType="string" databaseId="mysql">
   select  now() from dual 
  </select>

  <select id="getTime"   resultType="string" databaseId="oracle">
   select  'oralce'||to_char(sysdate,'yyyy-mm-dd hh24:mi:ss')  from dual 
  </select>
</mapper>

MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。

  private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
        //获取数据库表示类型
      String type = context.getStringAttribute("type");
      // awful patch to keep backward compatibility
      //如果配置 VENDOR 转为  DB_VENDOR
      if ("VENDOR".equals(type)) {
        type = "DB_VENDOR";
      }
      Properties properties = context.getChildrenAsProperties();
        //获取 VendorDatabaseIdProvider 对象，在 Configuration 配置里边，已经通过别名的方式创建了对象，typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
      databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
      databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
        //获取数据库表示 如： MySql
        //这里根据 <dataSource type="POOLED">  type 获取 DataSource对象
      String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
      configuration.setDatabaseId(databaseId);
    }
  }

# typeHandlers 节点

<typeHandlers>
  <typeHandler handler="com.example.typeHandle.MobileTypeHandler"/>
  <package name="com.example.typeHandle"/>
</typeHandlers>

<update id="updateMobile">
    update users
    set mobile = #{mobile, typeHandler=com.example.typeHandle.MobileTypeHandler}
    where id = #{id}
</update>

typeHandlers 节点主要处理 java 与 jdbc 类型之间的类型转换。通过 typeHandlers 节点可以自定义类型处理。

private void typeHandlerElement(XNode parent) {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
          //指定处理器的包路径，下面的类都会被扫描加载
        if ("package".equals(child.getName())) {
          String typeHandlerPackage = child.getStringAttribute("name");
          typeHandlerRegistry.register(typeHandlerPackage);
        } else {
            //获取Java类型
          String javaTypeName = child.getStringAttribute("javaType");
            //获取对应jdbc 类型
          String jdbcTypeName = child.getStringAttribute("jdbcType");
            //自定义处理类路径
          String handlerTypeName = child.getStringAttribute("handler");
          Class<?> javaTypeClass = resolveClass(javaTypeName);
          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
          Class<?> typeHandlerClass = resolveClass(handlerTypeName);
            //查看类型处理器是否加载过，没加载添加到 typeHandlerRegistry
          if (javaTypeClass != null) {
            if (jdbcType == null) {
              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
            } else {
              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
            }
          } else {
            typeHandlerRegistry.register(typeHandlerClass);
          }
        }
      }
    }
  }
//自定义类型处理器需要实现这个接口 或者继承 BaseTypeHandler
public interface TypeHandler<T> {
	//用于设置PreparedStatement对象的指定参数
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * @param columnName Colunm name, when configuration <code>useColumnLabel</code> is <code>false</code>
   */
    //从结果集中根据列名获取数据
  T getResult(ResultSet rs, String columnName) throws SQLException;
	//从结果集中根据列索引获取数据
  T getResult(ResultSet rs, int columnIndex) throws SQLException;
	//从存储过程的结果集中根据列索引获取数据
  T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}

# mappers 节点

  <mappers>
    <mapper resource="com/mybatis3/mappers/StudentMapper.xml"/>
    <mapper url="file:///var/mappers/StudentMapper.xml"/>
    <mapper class="com.mybatis3.mappers.TutorMapper"/>
    <package name="com.mybatis3"/>
  </mappers>

mappers 一共支持4种方式的配置，mapper 可以配置接口和 xml 。

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
          //扫描指定包下面的所有mapper接口
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
            // 扫描指定的包，并向mapperRegistry注册mapper接口
          configuration.addMappers(mapperPackage);
        } else {
            //获取 resource url mapperClass 值，这3者只能指定其一
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
              //获取resource或url不为空，使用XMLMapperBuilder形式构建mapper配置
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            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) {
              //反射创建mapper对象
            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.");
          }
        }
      }
    }
  }

具体整个 mapper 解析过程，后边会详细介绍

上次更新: 2024/11/5

← MyBatis源码-mapper解析 →