Mybatis初始化流程源码解析

最新推荐文章于 2022-08-19 09:48:34 发布
最新推荐文章于 2022-08-19 09:48:34 发布
阅读量252 收藏
点赞数
分类专栏： Mybatis 文章标签： Mybatis 初始化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22866497/article/details/103342479
版权

Mybatis初始化流程源码解析

代码中如何使用Mybatis

  1. java代码中用编程的方式使用Mybatis框架。
    InputStream inputStream = Resources.getResourceAsStream("MapperConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    CachedAuthorMapper cachedAuthorMapper = sqlSession.getMapper(CachedAuthorMapper.class);
    cachedAuthorMapper.selectAuthorWithInlineParams(1);

其中Resources.getResourceAsStream的入参是一个相对于classpath的Mybatis主配置文件，这是Mybatis启动时要加载的配置文件，它包含了Mybatis的核心组件的配置信息。示例如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!--

       Copyright 2009-2016 the original author or authors.

       Licensed under the Apache License, Version 2.0 (the "License");
       you may not use this file except in compliance with the License.
       You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

       Unless required by applicable law or agreed to in writing, software
       distributed under the License is distributed on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
       See the License for the specific language governing permissions and
       limitations under the License.

-->
<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

  <properties resource="org/apache/ibatis/databases/blog/blog-derby.properties"/>

  <settings>
    <setting name="logImpl" value="LOG4J"/>
    <setting name="cacheEnabled" value="true"/>
    <setting name="lazyLoadingEnabled" value="false"/>
    <setting name="multipleResultSetsEnabled" value="true"/>
    <setting name="useColumnLabel" value="true"/>
    <setting name="useGeneratedKeys" value="false"/>
    <setting name="defaultExecutorType" value="SIMPLE"/>
    <setting name="defaultStatementTimeout" value="25"/>
  </settings>

  <typeAliases>
    <typeAlias alias="Author" type="org.apache.ibatis.domain.blog.Author"/>
    <typeAlias alias="Blog" type="org.apache.ibatis.domain.blog.Blog"/>
    <typeAlias alias="Comment" type="org.apache.ibatis.domain.blog.Comment"/>
    <typeAlias alias="Post" type="org.apache.ibatis.domain.blog.Post"/>
    <typeAlias alias="Section" type="org.apache.ibatis.domain.blog.Section"/>
    <typeAlias alias="Tag" type="org.apache.ibatis.domain.blog.Tag"/>
  </typeAliases>

  <typeHandlers>
    <typeHandler javaType="String" jdbcType="VARCHAR" handler="org.apache.ibatis.builder.CustomStringTypeHandler"/>
  </typeHandlers>

  <objectFactory type="org.apache.ibatis.builder.ExampleObjectFactory">
    <property name="objectFactoryProperty" value="100"/>
  </objectFactory>

  <plugins>
    <plugin interceptor="org.apache.ibatis.builder.ExamplePlugin">
      <property name="pluginProperty" value="100"/>
    </plugin>
  </plugins>

  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC">
        <property name="" value=""/>
      </transactionManager>
      <dataSource type="UNPOOLED">
        <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="org/apache/ibatis/builder/AuthorMapper.xml"/>
    <mapper resource="org/apache/ibatis/builder/BlogMapper.xml"/>
    <mapper resource="org/apache/ibatis/builder/CachedAuthorMapper.xml"/>
    <mapper resource="org/apache/ibatis/builder/PostMapper.xml"/>
    <mapper resource="org/apache/ibatis/builder/NestedBlogMapper.xml"/>
  </mappers>

</configuration>

整个流程的执行时序图

在这里插入图片描述

详细源码解析

资源文件的读取

Mybatis为我们提供一个Resources类可以很方便的从classpath下读取一个资源文件。它返回一个该资源文件的InputStream对象。

InputStream inputStream = Resources.getResourceAsStream("MapperConfig.xml");
实例化SqlSessionFactoryBuilder对象

通过其build(Inputstream)方法返回一个SqlSessionFactory对象。我们通过SqlSessionFactory对象可以得到一个代表和数据库交互的SqlSession对象。

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSessionFactoryBuilder.build方法
public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }

  public SqlSessionFactory build(InputStream inputStream, String environment) {
    return build(inputStream, environment, null);
  }

  public SqlSessionFactory build(InputStream inputStream, Properties properties) {
    return build(inputStream, null, properties);
  }

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

实际上最后都是调用了最后的build方法返回了一个SqlSessionFactory实例。

XMLConfigBuilder的parse方法

在这个build方法中首先new了一个XMLConfigBuilder对象，然后调用了其的parse()方法返回了一个Configuration对象，Configuration对象是Mybatis中主配置文件信息的内存数据结构。

public Configuration parse() {
    // 每个XMLConfigBuilder只能使用一次，不过我感觉这里有线程安全问题
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

先调用Mybatis为我们提供的使用XPath语法解析Dom的工具类XPathParser.evalNode的到configuration节点以及其子节点的XNode表示。然后调用parseConfiguration(XNode)方法，依次解析configuration下的节点。

private void parseConfiguration(XNode root) {
  try {
    //issue #117 read properties first
    propertiesElement(root.evalNode("properties"));
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    loadCustomVfs(settings);
    loadCustomLogImpl(settings);
    typeAliasesElement(root.evalNode("typeAliases"));
    pluginElement(root.evalNode("plugins"));
    objectFactoryElement(root.evalNode("objectFactory"));
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    reflectorFactoryElement(root.evalNode("reflectorFactory"));
    settingsElement(settings);
    // read it after objectFactory and objectWrapperFactory issue #631
    environmentsElement(root.evalNode("environments"));
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    typeHandlerElement(root.evalNode("typeHandlers"));
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}
解析properties节点
private void propertiesElement(XNode context) throws Exception {
  if (context != null) {
    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.");
    }
    if (resource != null) {
      defaults.putAll(Resources.getResourceAsProperties(resource));
    } else if (url != null) {
      defaults.putAll(Resources.getUrlAsProperties(url));
    }
    // 合并属性信息
    Properties vars = configuration.getVariables();
    if (vars != null) {
      defaults.putAll(vars);
    }
    parser.setVariables(defaults);
    configuration.setVariables(defaults);
  }
}
解析settings节点
private Properties settingsAsProperties(XNode context) {
  if (context == null) {
    return new Properties();
  }
  Properties props = context.getChildrenAsProperties();
  // 检查settings节点下的配置的name值在Configuration类中都有属性与之对应
  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;
}
加载CustomVfs
private void loadCustomVfs(Properties props) throws ClassNotFoundException {
  String value = props.getProperty("vfsImpl");
  if (value != null) {
    String[] clazzes = value.split(",");
    for (String clazz : clazzes) {
      if (!clazz.isEmpty()) {
        @SuppressWarnings("unchecked")
        Class<? extends VFS> vfsImpl = (Class<? extends VFS>)Resources.classForName(clazz);
        configuration.setVfsImpl(vfsImpl);
      }
    }
  }
}
加载日志配置
private void loadCustomLogImpl(Properties props) {
  // 调用基类BaseBuilder的resolveClass方法
  Class<? extends Log> logImpl = resolveClass(props.getProperty("logImpl"));
  configuration.setLogImpl(logImpl);
}
protected <T> Class<? extends T> resolveClass(String alias) {
  if (alias == null) {
    return null;
  }
  try {
    return resolveAlias(alias);
  } catch (Exception e) {
    throw new BuilderException("Error resolving class. Cause: " + e, e);
  }
}
protected <T> Class<? extends T> resolveAlias(String alias) {
  // 委托TypeAliasRegistr类根据类别名找到一个实现
  return typeAliasRegistry.resolveAlias(alias);
}

TypeAliasRegistry类中维护了一个typeAliases的Map结构，key是类的别名，而value是对应的class信息。在TypeAliasRegistry类的构造方法中默认注册了一些类。

public class TypeAliasRegistry {

private final Map<String, Class<?>> typeAliases = new HashMap<>();

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

TypeAliasRegistry的resolveAilas方法根据别名先在这个map种查找是否有类的信息，如果有直接返回，如果没有调用Resources.classForName加载这个类。

public <T> Class<T> resolveAlias(String string) {
  try {
    if (string == null) {
      return null;
    }
    // issue #748
    String key = string.toLowerCase(Locale.ENGLISH);
    Class<T> value;
    if (typeAliases.containsKey(key)) {
      value = (Class<T>) typeAliases.get(key);
    } else {
      value = (Class<T>) Resources.classForName(string);
    }
    return value;
  } catch (ClassNotFoundException e) {
    throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
  }
}

看到这，可能有读者会有疑问，怎么看默认构造的是否没有看到log4j这个key呢？其实是我们在new XMLConfigBuilder对象调用基类BaseBuilder的构造方法时，会new一个Configuration实例，在Configuration的构造函数里会调用TypeAliasRegistry的registerAlias方法，默认注册一些类。在此处可以看见常见的日志实现类。

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  super(new Configuration());
  ErrorContext.instance().resource("SQL Mapper Configuration");
  this.configuration.setVariables(props);
  this.parsed = false;
  this.environment = environment;
  this.parser = parser;
}
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);
}
解析typeAliases节点下的配置

以别名为key，其Class为value调用typeAliasRegistry的registerAlias方法注册到map中。

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);
        }
      }
    }
  }
}
解析plugins节点下的配置

resolveClass方法委托TypeAliasRegistr类根据类别名找到一个实现类，然后通过反射构建出plugin实例，设置到configuration中的属性中。

 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).getDeclaredConstructor().newInstance();
      interceptorInstance.setProperties(properties);
      configuration.addInterceptor(interceptorInstance);
    }
  }
}
解析objectFactory节点下的配置

和解析流程和plugins类似。但具体ObjectFactory的用法等理解深刻了再写分享出来，目前自己也还不太很清楚。

private void objectFactoryElement(XNode context) throws Exception {
  if (context != null) {
    String type = context.getStringAttribute("type");
    Properties properties = context.getChildrenAsProperties();
    ObjectFactory factory = (ObjectFactory) resolveClass(type).getDeclaredConstructor().newInstance();
    factory.setProperties(properties);
    configuration.setObjectFactory(factory);
  }
}
解析objectWrapperFactory节点下的配置

同理。

 private void objectWrapperFactoryElement(XNode context) throws Exception {
  if (context != null) {
    String type = context.getStringAttribute("type");
    ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).getDeclaredConstructor().newInstance();
    configuration.setObjectWrapperFactory(factory);
  }
}
解析reflectorFactory节点下的配置

Mybatis中的反射工厂类。

 private void reflectorFactoryElement(XNode context) throws Exception {
  if (context != null) {
    String type = context.getStringAttribute("type");
    ReflectorFactory factory = (ReflectorFactory) resolveClass(type).getDeclaredConstructor().newInstance();
    configuration.setReflectorFactory(factory);
  }
}
设置Mybatis的一些基础配置，并赋予默认值
private void settingsElement(Properties props) {
  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.setDefaultResultSetType(resolveResultSetType(props.getProperty("defaultResultSetType")));
  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")));
  configuration.setDefaultEnumTypeHandler(resolveClass(props.getProperty("defaultEnumTypeHandler")));
  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"));
  configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
}
解析environment节点下的配置

解析transactionManager和dataSource节点后，根据数据源和事务工厂构建Environment对象。

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");
      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());
      }
    }
  }
}
private TransactionFactory transactionManagerElement(XNode context) throws Exception {
  if (context != null) {
    String type = context.getStringAttribute("type");
    Properties props = context.getChildrenAsProperties();
    TransactionFactory factory = (TransactionFactory) resolveClass(type).getDeclaredConstructor().newInstance();
    factory.setProperties(props);
    return factory;
  }
  throw new BuilderException("Environment declaration requires a TransactionFactory.");
}
解析databaseIdProvider节点

根据databaseId在不同的数据库执行sql语句。

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 = context.getChildrenAsProperties();
    databaseIdProvider = (DatabaseIdProvider) resolveClass(type).getDeclaredConstructor().newInstance();
    databaseIdProvider.setProperties(properties);
  }
  Environment environment = configuration.getEnvironment();
  if (environment != null && databaseIdProvider != null) {
    String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
    configuration.setDatabaseId(databaseId);
  }
}
解析typeHandlers节点

实例化TypeHandler并注册。

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 {
        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);
        }
      }
    }
  }
}
解析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");
        // 读取classpath下的mapper文件
        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) { // 读取远程url的mapper文件
          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.");
        }
      }
    }
  }
}
javazcw
关注
专栏目录
mybatis-spring 框架原理与源码解析--初始化过程
yange1025的博客
07-28 315
mybatis-spring将mybatis无缝集成到spring框架中，使得mybatis能够参与spring的事务，将mybatis mapper和sqlsession注入到其它bean中，将mybatis的异常转换成spring的DataAccessException等。本文将在代码层面，从spring容器启动到一次数据库访问结束期间，mybatis-spring的运行流程，来解析mybat...
【源码解析】MyBatis 整体架构与源码解析
wadfdhsajd的博客
08-21 241
简述下 MyBatis 的三层架构以及其中各个模块的核心功能，从基础支撑层到核心处理层，再到暴露给调用的接口层。然后再深入剖析，MyBatis 中 n 种设计模式的使用；MyBatis 工作原理和运行流程；动态 SQL 语句解析；映射机制；一二级缓存；我有一些面试题、架构、设计类资料可以说是程序员面试必备！所有资料都整理到网盘了，需要的话欢迎下载！私信我回复【07】即可免费获取原文出处：xie.infoq.cn/article/e8a121e18519e24e952b36066。
mybatis 源码解析之初始化流程
qq_31514235的博客
01-17 288
一、本文介绍  本文只专注于mybaits初始化流程，旨在帮助各位弄清楚mybatis初始化过程中都进行那些工作，这些初始化工作在那些类中。并没有对每项初始化工作进行详细的介绍，如果有这方面的需求请移步别处，避免耽误您的时间。只要各位学会了怎么去看mybatis源码，那我相信如果以后想要深入的学习细节的实现会变得非常简单。好了，话不多说，下面进入正题。 二、简单介绍一下mybatis基础配置 ...
mybatis 源码系列(一) 初始化
八一菜刀的专栏
05-15 408
mybatis 源码系列(一) 初始化 通过阅读mybatis的官方文档,我们知道了初始化mybatis的方法有以下两种方法: 通过XML文件构建SqlSessionFactory对象,最终创建SqlSession使用对象实例 通过Java创建Configuration对象来构建SqlSessionFactory对象 类图 我们先来看mybatis的初始化相关的几个基础类图 几个关键类说明：...
Mybatis的初始化和结合Spring Framework后初始化的源码探究
weixin_45032957的博客
05-08 83
带着下面的问题进行学习： （1）Mybatis 框架或 Spring Framework 框架对数据层 Mapper 接口做了代理，那是做了 JDK 动态代理还是 CGLIB 代理？ （2）Mapper 接口使用和不使用 @Mapper 注解有什么区别？ （3）Spring Framework 框架引入 Mybatis 的 jar 包后，Spring Framework 是怎么管理的？ （4）@MapperScan注解的作用是什么？ 在探究上面的问题前，先了解什么是 FactoryBean，FactoryB
Mybatis spring 结合初始化流程
laomei
07-08 352
本文主要介绍Mybatis配合Spring使用，spring如何发现家在mybatis接口，同时将这些接口注册为bean。 mybatis配合spring一般会使用MapperScannerConfigurer类，创建对应的bean，这个类实现了BeanDefinitionRegistryPostProcessor接口实现postProcessBeanDefinitionRegistry 方法，这个方法会在bean，此接口会在bean都被定义完成之后调用，用户可以自定义修改bean definition。
Mybatis源码解析之流程解析：初始化阶段
12-22
源码解析地址 https://github.com/erlieStar/mybatis-3 debug源码用项目 https://github.com/erlieStar/mybatis-examples 介绍 Mybatis的核心流程主要分为两大阶段 初始化阶段：读取XML配置文件和注解中的配置信息，...
mybatis3.x源码深度解析与最佳实践.pdf
最新发布
09-12
本系列源码解析的方式将从 MyBatis 的源码入手，深入分析 MyBatis 的设计思路和实现机制。 2. 容器的加载与初始化 2.1 config 文件解析 XMLConfigBuilder.parseConfiguration 方法是 MyBatis 中的核心方法之一，...
【源码解析】MyBatis 工作原理源码深度解析
Chenhui98的博客
08-19 1092
本文解析 MyBatis 工作流程源码，MyBatis 的运行流程分为三大阶段 1. 初始化阶段；2. 代理封装阶段；3. 数据访问阶段。
从Mybatis源码到Spring动态数据源底层原理分析系列一、Mybatis初始化源码浅析
m0_70109670的博客
05-10 308
private Environment environment; private Map<String, MappedStatement> mappedStatements; } class Environment { private TransactionFactory transactionFactory; private DataSource dataSource; } 复制代码 非常清晰的映射关系, 一个环境里面包含了数据源以及事务工厂, 如果不是很理解事务工厂的用处, 可以先不用着急,
Spring自动注入源码分析
xianmingsu的博客
07-27 393
autowireByName @Configuration @ComponentScan("com.su.spring.common") public class CommonConfig { } @Service public class UserService { UserDao userDao; public void query(){ System.out.println("UserService query() -----------");
mybatis-spring源码分析（有图解）
qq1805696978的博客
07-24 610
springboot所有的中间件配置都是从 xxxAutoConfiguration开始的。mybatis也不例外。MybatisAutoConfiguration最重要的3个方法 接下来按照执行顺序，逐一讲解 一、MapperScannerRegistrarNotFoundConfiguration 这个类不一定会执行，主要取决于 1、那么这个bean什么时候会有，什么时候会没有呢？这取决于你用什么方式扫描方式。我们通常有2种方式声明mapper： ①在启动类添加@Mappe..
spring 整合mybatis 源码解析
xjk201的博客
11-26 436
uuserMapper 是个接口 如下所示 spring怎么注入 那就要解决: 把userMapper对象当成bean放入 spring容器中 因为是factoryBean 所以 调用getObject方法创建代理对象后就 不用走spring自有的创建bean的生命周期了 多个mapeer的思路 使用LubanBeanDefinitionRegistar 扫描的逻辑： 注册bd @Mapper 注解 在m...
Spring源码解析之整合Mybatis
0xZzzz的博客
01-25 6518
阅读须知 整合包版本：1.3.1 注释规则： //单行注释做普通注释 /**/多行注释做深入分析 建议配合源码阅读 正文首先我们来看Spring整合Mybatis的配置：&lt;bean id=&quot;sqlSessionFactory&quot; class=&quot;org.mybatis.spring.SqlSessionFactoryBean&quot;&gt; &lt;property name=&quot;conf
SpringBoot-Mybatis框架使用与源码解析
恐龙弟旺仔的博客
08-03 5414
前言： 在上两篇文章Spring-Mybatis框架使用与源码解析 原生Mybatis框架源码解析中，我们说了使用mybatis有三种方式， 这两篇文章已经分析了原生Mybatis、Spring-Mybatis的使用及源码分析。 现在微服务架构基本已经成为一种架构正确了，而SpringBoot技术也已经被应用在各个项目中。 SpringBoot不仅仅那些传统...
Spring和Mybatis的整合使用及源码解析
lgq2626的博客
12-25 1633
之前分析过Spring的源码，里面涉及到很多Spring的拓展接口，具体的介绍文字在http://blog.csdn.net/lgq2626/article/details/78729368 文章中，文章中介绍了InitializingBean这个接口的是在依赖注入完成之后调用了此接口中的afterPropertiesSet()方法,具体的几个重要的接口方法的执行简单总结下： 首先大致看代码：p
spring-整合mybatis源码注解的方式--简单解析
chijianwei的博客
01-11 672
现在主流的spring整合mybatis用注解@MapperScan("com.cat.mapper") 这个注解里包含了注解@Import(MapperScannerRegistrar.class) 在spring源码那篇讲到.扫描到注解@import的时候.会处理里面的class 这里的MapperScannerRegistrar implements ImportBeanDefinit...
SpringBoot与Mybatis整合实践及源码解析
源码分析主要涉及Mybatis的整体架构、核心组件及其工作流程等。了解Mybatis的工作原理可以帮助开发者更好地使用该框架，解决实际开发中遇到的问题。在本资源中，通过源码分析记录，可以了解到Mybatis是如何通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值