MyBatis-初始化过程

BoomShell
734 阅读8分钟

1 示例

MyBatis的初始化过程，其实就是创建SqlSessionFactory的过程。

1.1 xml配置

在编译目录下新建一个xml文件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>
    <properties resource="config/jdbc.properties">

    </properties>

    <settings>
        <setting name="logImpl" value="log4j2"/>
    </settings>

    <typeAliases>
        <package name="com.xxx.yyy.model"/>
    </typeAliases>

    <!--自定义TypeHandler, 如enum-->
    <typeHandlers>

    </typeHandlers>

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

    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

1.2 创建SqlSessionFactory

加载mybatis-config.xml，并通过SqlSessionFactoryBuilder.build方法创建：

public static void main(String[] args){
        String resource = "config/mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory =
                new SqlSessionFactoryBuilder().build(inputStream);
                
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);
        List<User> users = userMapper.findList();

        System.out.println(users);
        session.close();
    }

2 XMLConfigBuilder

SqlSessionFactoryBuilder.build中，创建XMLConfigBuilder并执行parse方法：

     XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
     return build(parser.parse());
  • SqlSessionFactory的初始化工作，都在XMLConfigBuilder.parse中完成；
  • XMLConfigBuilder使用XPathParser解析xml配置；
  • XPathParser提供了一系列eval*方法查找xml节点并解析成相应对象。

3 parseConfiguration

XMLConfigBuilder.parseConfiguration是解析过程的核心方法，由parse()中的parseConfiguration(parser.evalNode("/configuration"))开始，即mybatis-config.xml中的顶级节点<configuration>....</configuration>;

  private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties")); // 属性
      Properties settings = settingsAsProperties(root.evalNode("settings")); // settings
      loadCustomVfs(settings);
      typeAliasesElement(root.evalNode("typeAliases")); // 类型别名
      pluginElement(root.evalNode("plugins")); // 拦截器
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings); // 设置Configuration部分属性
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers")); // 类型处理器
      mapperElement(root.evalNode("mappers")); // sql映射文件
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

3.1 属性解析

  • 方法：propertiesElement(root.evalNode("properties"));
  • 解析XML路径：/configuration/properties
  • 解析出的Properties，放入Configuration类的字段：protected Properties variables = new Properties();

解析propertis节点指定的文件或位置，读取属性文件：

<properties resource="config/jdbc.properties">
</properties>
  • 需要指定resource或url，但不能同时指定，会抛出BuilderException;
  • 如果指定resource，就解析resource；没有的话，再解析url。

3.2 解析settings:

  • 方法：settingsAsProperties(root.evalNode("settings"))
  • 解析XML路径：/configuration/settings；
  • settings设置了Configuration类中的部分属性值。
<settings>
    <setting name="logImpl" value="log4j2"/>
</settings>
  • settings的name就是Configuration的属性名，通过settingsAsProperties方法，将settings解析成Properties对象；
  • 如果key在Configuration中没有找到相应的setter方法，则会在解析过程中抛出BuilderException。
  • 解析出的Properties，将在settingsElement方法中设置到Configuration中。

3.3 settingsElement

settingsAsProperties方法将配置文件中的/configuration/settings解析为Properties后，为Configuration中的属性赋值。

setting和Configuration属性对应如下(如示例xml中的logImpl)，没有设置则使用默认值：

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

3.4 settingsElement中类的解决

settingsElement中设置的值，有boolean，有字符串，有枚举等，都可以简单方法设置。

对于对象的解析，需要由Alias查找到对应的类。

这个查找过程，通过BaseBuilder.resolveClass，调用BaseBuilder.typeAliasRegistry.resolveAlias来处理;

默认的alias，在两处初始化：

1) TypeAliasRegistry实例化时

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

2) Configuration实例化时:

public Configuration() {
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
    typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
    typeAliasRegistry.registerAlias("LRU", LruCache.class);
    typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
    typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

    typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

    typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
    typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

    typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
    typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
    typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
    typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
    typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
    typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
    typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

    typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
    typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
    languageRegistry.register(RawLanguageDriver.class);
 }

3.5 TypeAlias(类型别名)注册

  • 方法：typeAliasesElement(root.evalNode("typeAliases"));
  • 对应XML路径：/configuration/typeAliases。
private void typeAliasesElement(XNode parent) {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        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) {
              typeAliasRegistry.registerAlias(clazz);
            } else {
              typeAliasRegistry.registerAlias(alias, clazz);
            }
          } catch (ClassNotFoundException e) {
            throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
          }
        }
      }
    }
  }
  • 如果有package节点，则使用package节点注册；
  • 没有package节点，使用typeAlias的alias和type注册。

3.5.1 注册自定义TypeAlias的两种方式

  • Configuration.getTypeAliasRegistry().registerAlias* : 当没有指定alias时，则使用@Alias标注值，没有的话，则使用类的SimpleName。
  • mybatis-config.xml里配置<typeAliases>....</typeAliases>

如果别名已存在，会抛出TypeException：

public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    TYPE_ALIASES.put(key, value);
 }

3.6 拦截器解析

  • 方法：pluginElement(root.evalNode("plugins"))
  • 对应XML路径：/configuration/plugins。

拦截器类，是实现了org.apache.ibatis.plugin.Interceptor接口的类，通过调用configuration.addInterceptor(interceptorInstance);添加Configuration.interceptorChain中。

自定义拦截器的两种方法：

  • Configuration.addInterceptor；
  • mybatis-config.xml里配置/configuration/plugins。

3.7 TypeHandler解析

  • 方法：typeHandlerElement(root.evalNode("typeHandlers"))
  • 对应XML路径：/configuration/typeHandlers。

功能是设置org.apache.ibatis.type.TypeHandler的实现类，通过Configration.typeHandlerRegistry.register注册。

默认的TypeHandler实现类的注册，在TypeHandlerRegistry的实例化过程中：

  public TypeHandlerRegistry() {
    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());

    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());

    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());

    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());

    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());

    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());

    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());

    register(Reader.class, new ClobReaderTypeHandler());
    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new ClobTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());

    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());

    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());

    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

    register(InputStream.class, new BlobInputStreamTypeHandler());
    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());

    register(Object.class, UNKNOWN_TYPE_HANDLER);
    register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
    register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

    register(Date.class, new DateTypeHandler());
    register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());

    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

    // mybatis-typehandlers-jsr310
    if (Jdk.dateAndTimeApiExists) {
      Java8TypeHandlersRegistrar.registerDateAndTimeHandlers(this);
    }

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }

自定义TypeHandler的两种方法：

  • Configuration.getTypeHandlerRegistry().register()；
  • mybatis-config.xml里配置/configuration/typeHandlers。

3.8 mapper解析

  • 方法：mapperElement(root.evalNode("mappers"));
  • 对应XML路径：/configuration/mappers。
private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          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);
            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) {
            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.");
          }
        }
      }
    }
  }
  • 优先使用package节点解析；
  • 如果没有package节点，则解析mapper节点，并依次判断是否存在resource，url，class三个属性；
  • mapper属性优先级：resource > url > class；三个节点不能同时设置，否则会抛出BuilderException。

3.8.1 几个重要的类

  • XMLMapperBuilder: 解析<mapper></mapper>的属性namespace及相关子节点cache-ref | cache | resultMap | parameterMap | sql | insert | update | delete | select；
  • XMLStatementBuilder: 解析<mapper></mapper>下的select|insert|update|delete四种子节点；
  • LanguageDriver: Configuration中设置的默认实现类是XMLLanguageDriver，根据select|insert|update|delete节点的属性和内容，创建SqlSource对象；
  • MapperBuilderAssistant: 助理类，比如创建MappedStatement对象等；
  • XMLScriptBuilder: xml中动态sql的解析，如 where，foreach，when等，在XMLLanguageDriver中调用，创建SqlSource`对象；
  • SqlSourceBuilder: DynamicSqlSource.getBoundSql获取BoundSql对象时使用，解析动态sql；
  • GenericTokenParser: 工具类，解析sql并处理占位符，比如将#{}替换成?。

3.8.2 XMLMapperBuilder

当mapper节点的属性是resource或url时，mybatis会通过XMLMapperBuilder.parse()方法解析mapper的xml文件。

如xml：

<?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="com.xxx.yyy.UserMapper">
    <select id="selectUser">
        select * from users where id = #{id}
    </select>
</mapper>

XMLMapperBuilder会解析mapper.namespace,/mapper/sql,/mapper/select,/mapper/insert等标签。

  • XMLMapperBuilder.parse()中有两个重要方法：
// 创建MappedStatement对象，并放入Configuration中
configurationElement(parser.evalNode("/mapper"));

// 通过configuration.addMapper，将映射接口类添加到configuration.mapperRegistry中
bindMapperForNamespace();

private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }

在buildStatementFromContext中，会使用XMLStatementBuilder.parseStatementNode()解析select|insert|update|delete四种节点。

3.8.3 XMLStatementBuilder

XMLStatementBuilder.parseStatementNode()方法执行了以下过程：

  • 解析/mapper/select|insert|update|delete中的各种属性；
  • 通过MapperBuilderAssistant.addMappedStatement方法，创建MappedStatement对象；
  • 通过configuration.addMappedStatement将MappedStatement对象添加到Configuration中。
////
MappedStatement statement = MappedStatement.Builder.build();
////
configuration.addMappedStatement(statement);

代码调用路径：

XMLStatementBuilder.parseStatementNode -> XMLLanguageDriver.createSqlSource -> XMLScriptBuilder.parseScriptNode SqlSourceBuilder.parse -> GenericTokenParser.parse

3.9 Configuration.addMapper

MyBatis通过调用Configuration.addMapper将映射类添加到配置中，比如XMLMapperBuilder.bindMapperForNamespace()方法。

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory<T>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }
  • 由此可见，MyBatis的映射类，都有一个与之相关的MapperProxyFactory，最终执行的是代理类MapperProxy:
public class MapperProxy<T> implements InvocationHandler{
    //....
}

 // MapperProxyFactory中创建代理对象
 protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
 }

通过实现InvocationHandler接口，使用JDK代理方式实现。

4 总结

  • 在SqlSessionFactoryBuilder.build()过程中设置Configration;

Configuration属性:

  • Map<String, MappedStatement> mappedStatements : key=com.xxx.yyy.UserMapper.selectUser,value=MappedStatement对象；
  • MapperRegistry mapperRegistry：使用Map<Class, MapperProxyFactory> knownMappers属性，存放Mapper类与其相关的MapperProxyFactory对象；
  • InterceptorChain interceptorChain ： Interceptor列表；
  • TypeAliasRegistry typeAliasRegistry ： 类型别名注册；
  • TypeHandlerRegistry typeHandlerRegistry ： 类型处理器注册；
  • LanguageDriverRegistry languageRegistry ：LanguageDriver实例类注册。
avatar
文章
阅读
粉丝