如何理解Mybatis初始化

这篇文章主要讲解了“如何理解Mybatis初始化”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“如何理解Mybatis初始化”吧！

成都创新互联公司长期为1000+客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为云安企业提供专业的成都网站制作、成都做网站、外贸营销网站建设，云安网站改版等技术服务。拥有10多年丰富建站经验和众多成功案例,为您定制开发。

Mybatis 初始化是由SqlSessionFactoryBuilder来完成的，主要的工作解析XML文件，并将解析的类容封装到Configuration类中，最后将Configuration类封装到SqlSessionFactory中并返回，自此初始化完成。

完成对XML文件解析的是XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder三个类来完成：

• XMLConfigBuilder：负责全局配置文件（mybatis-config.xml）中除了mappers节点的解析。

• XMLMapperBuilder：负责解析xxxMapper.xml映射文件中cache-ref、cache、parameterMap、resultMap、sql节点；根据 namespace 将Mapper接口的动态代理工厂注册到 MapperRegistry 中。

• XMLStatementBuilder：负责解析xxxMapper.xml映射文件中SQL语句节点，如：select、insert、update、delete。

• XMLScriptBuilder：负责解析SQL脚本，然后封装成SqlSource。

Mybatis 初始化流程

SqlSessionFactoryBuilder

SqlSessionFactoryBuilder会将解析任务托给XMLConfigBuilder类，源码如下：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    // 委托给XMLConfigBuilder去解析配置文件
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    // 开始解析
    return build(parser.parse());
  } 
  ...
}

public SqlSessionFactory build(Configuration config) {
  return new DefaultSqlSessionFactory(config);
}

XMLConfigBuilder

负责全局配置文件（mybatis-config.xml）中除了mappers节点的解析。解析节点委托给XMLMapperBuilder解析器。

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

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来解析映射文件
          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来解析映射文件
          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.");
        }
      }
    }
  }
}

XMLMapperBuilder

负责解析xxxMapper.xml映射文件中cache-ref、cache、parameterMap、resultMap、sql节点；根据 namespace 将Mapper接口的动态代理工厂（MapperProxyFactory）注册到 MapperRegistry 中。

public void parse() {
  // 防止重复解析
  if (!configuration.isResourceLoaded(resource)) {
    // 解析xxxMapper.xml 映射文件中的 mapper节点
    configurationElement(parser.evalNode("/mapper"));
    // 标记为已经加载过
    configuration.addLoadedResource(resource);
    // 根据 namespace 将Mapper接口的动态代理工厂注册到 MapperRegistry 中
    bindMapperForNamespace();
  }
  // 兜底
  parsePendingResultMaps();
  parsePendingCacheRefs();
  parsePendingStatements();
}

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. The XML location is '" + resource + "'. Cause: " + e, e);
  }
}

private void buildStatementFromContext(List list) {
  if (configuration.getDatabaseId() != null) {
    buildStatementFromContext(list, configuration.getDatabaseId());
  }
  buildStatementFromContext(list, null);
}

private void buildStatementFromContext(List list, String requiredDatabaseId) {
  for (XNode context : list) {
    // 解析节点委托给 XMLStatementBuilder
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      configuration.addIncompleteStatement(statementParser);
    }
  }
}

XMLStatementBuilder

负责解析xxxMapper.xml映射文件中SQL语句节点，如：select、insert、update、delete。解析节点委托给XMLStatementBuilder解析器。

public void parseStatementNode() {
  String id = context.getStringAttribute("id");
  String databaseId = context.getStringAttribute("databaseId");

  if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
    return;
  }

  // 根据节点的名称来判断SQL语句的类型（select|insert|update|delete）
  String nodeName = context.getNode().getNodeName();
  SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
  boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
  boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
  boolean useCache = context.getBooleanAttribute("useCache", isSelect);
  boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

  // Include Fragments before parsing
  // 解析节点
  XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
  includeParser.applyIncludes(context.getNode());

  String parameterType = context.getStringAttribute("parameterType");
  Class parameterTypeClass = resolveClass(parameterType);

  String lang = context.getStringAttribute("lang");
  LanguageDriver langDriver = getLanguageDriver(lang);

  // Parse selectKey after includes and remove them.
  // 解析节点，并在XML中删除节点
  processSelectKeyNodes(id, parameterTypeClass, langDriver);

  // Parse the SQL (pre:  and  were parsed and removed)
  KeyGenerator keyGenerator;
  String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
  keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
  if (configuration.hasKeyGenerator(keyStatementId)) {
    keyGenerator = configuration.getKeyGenerator(keyStatementId);
  } else {
    keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
        configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
        ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
  }

  // 解析SQL语句，然后封装成SqlSource
  SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
  StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
  Integer fetchSize = context.getIntAttribute("fetchSize");
  Integer timeout = context.getIntAttribute("timeout");
  String parameterMap = context.getStringAttribute("parameterMap");
  String resultType = context.getStringAttribute("resultType");
  Class resultTypeClass = resolveClass(resultType);
  String resultMap = context.getStringAttribute("resultMap");
  String resultSetType = context.getStringAttribute("resultSetType");
  ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
  if (resultSetTypeEnum == null) {
    resultSetTypeEnum = configuration.getDefaultResultSetType();
  }
  String keyProperty = context.getStringAttribute("keyProperty");
  String keyColumn = context.getStringAttribute("keyColumn");
  String resultSets = context.getStringAttribute("resultSets");

  // 使用建造者模式构建MappedStatement对象
  builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
      fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
      resultSetTypeEnum, flushCache, useCache, resultOrdered,
      keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}

Mybatis 初始化流程图

核心数据结构类

Configuration

Configuration其实就是XML配置文件的Java形态，Configuration是单例的，生命周期是应用级的；

ResultMap

对应xxxMapper.xml映射文件中的resultMap节点。节点中的子节点使用ResultMapping来封装，如：、等节点。

MappedStatement

对应xxxMapper.xml映射文件中的、、和节点。

SqlSource

对应xxxMapper.xml映射文件中的sql语句，经过解析SqlSource包含的语句最终仅仅包含？占位符，可以直接提交给数据库执行；

MapperRegistry

它是Mapper接口动态代理工厂类的注册中心。在MyBatis中，通过MapperProxy实现InvocationHandler接口，通过MapperProxyFactory生成动态代理的实例对象；

MyBatis建造者类图

Mybatis的整个初始化过程使用了建造者模式。建造者模式比较适合生成复杂对象，主要关注对象的实例化具体细节。

Mybatis 源码中文注释

https://github.com/xiaolyuh/mybatis

感谢各位的阅读，以上就是“如何理解Mybatis初始化”的内容了，经过本文的学习后，相信大家对如何理解Mybatis初始化这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！

新闻名称：如何理解Mybatis初始化
文章出自：http://cdkjz.cn/article/pijeps.html

返回首页 了解更多建站资讯

相关资讯

• javaweb应用代码 javaweb应用开发教程

• 路由器桥接后无法上网 路由器桥接后都无法上网

• 阿里云配置神经网络服务器 阿里云服务器跑神经网络

• api怎么找域名 api的域名

• linux执行几行命令行 linux执行命令在哪

• java运行程序源代码 java软件源代码

• 关于sap系统的pr在哪看的信息

• 关于SAP300系统的信息

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线   成都：13518219792   座机：028-86922220

在线咨询 提交需求

友情链接 交换友情链接

深圳纱窗安装大英网站建设设计网站网络营销推广微信公众号开发内江智速网站建设软文推广眉山发电机维修成都移动托管成都网站建设

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图