MyBatis启动：SqlSessionFactory的建立过程

最新推荐文章于 2024-04-18 08:41:55 发布
最新推荐文章于 2024-04-18 08:41:55 发布
阅读量4.8k 收藏 1
点赞数
分类专栏： Mybatis Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xushucan/article/details/38986283
版权

MyBatis的启动，就是建立SqlSessionFactory的过程，读取配置信息，通过会话工程建造者创建会话工厂。SqlSessionFactory接口定义了从数据源、链接中打开会话的方法以及获取配置信息的方法。以DefaultSqlSessionFactory为例，创建过程就是创建Configuration对象，赋值给工程对象。

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }
创建Configuration对象的过程，是解析XML文件的过程，并且在过程中创建对象所依赖的对象。 

XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse());

首先创建XMLConfigBuidler对象用来解析XML配置文件工作，这个对象中持有XPathParser对象，这个才是真正用来解析XML的工具类。底层采用JDK实现的XPath的API来对XML进行解析工作，此处不深入说明。重点关注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创建者将XML文档创建结束后，调用parse()方法进行解析，方法中调用parseConfiguration()方法对configuration节点进行解析。parser.evalNode其实就是解析XML文件返回代表configuration节点的XNode对象，然后再对XNode对象进行粒度更细的解析。 
  private void parseConfiguration(XNode root) {
    try {
      propertiesElement(root.evalNode("properties")); //issue #117 read properties first
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      settingsElement(root.evalNode("settings"));
      environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
      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);
    }
  }

解析configuration节点下的所有可能配置的子节点。首先是Properties，可以从文件中读取，也可以通过URL从网络中获取，还有就是从配置文件中获取。获取到的Properties对象将注入到configuration对象中。

private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
      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) {
        defaults.putAll(Resources.getUrlAsProperties(url));
      }
      Properties vars = configuration.getVariables();
      if (vars != null) {
        defaults.putAll(vars);
      }
      parser.setVariables(defaults);
      configuration.setVariables(defaults);
    }
  }
接下来解析类型的别名，可以配置包名，MyBatis会通过反射获取包下的所有类型，并且通过typeAliasRegistry注册类型的别名。这个TypeAliasRegistry内部持有一个Map，key用来保存别名alias，value用来保存类信息。比如："byte", Byte.class。 
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。 

  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);
      }
    }
  }
  public <T> Class<T> resolveAlias(String string) {
    try {
      if (string == null) return null;
      String key = string.toLowerCase(Locale.ENGLISH); // issue #748
      Class<T> value;
      if (TYPE_ALIASES.containsKey(key)) {
        value = (Class<T>) TYPE_ALIASES.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);
    }
  }
解析配置拦截器的名称，首先别名注册器上寻找，找到直接返回类信息Class对象，找不到则通过类加载器去编译路径找寻找对应的类信息。找到后调用newInstance得到实例对象。然后将拦截器添加到configuration对象的拦截器链上。 

  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);
    }
  }
解析对象工厂，并设置到configuration对象，可以覆盖原来对象工厂的行为。接下来是解析objectWrapperFactory节点，和解析工厂类似。

解析setting节点，这个将会改变configuration对象上的很多默认熟悉，也会改变mybatis的行为。

private void settingsElement(XNode context) throws Exception {
    if (context != null) {
      Properties props = context.getChildrenAsProperties();
      // Check that all settings are known to the configuration class
      MetaClass metaConfig = MetaClass.forClass(Configuration.class);
      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).");
        }
      }
      configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
      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"), true));
      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.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.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
      configuration.setLogPrefix(props.getProperty("logPrefix"));
      configuration.setLogImpl(resolveClass(props.getProperty("logImpl")));
      configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
      configuration.setInjectionFilterEnabled(booleanValueOf(props.getProperty("injectionFilterEnabled"), false));
      configuration.setInjectionFilter(parseExpression(props.getProperty("injectionFilter"), "^[a-zA-Z0-9._]*$"));
    }
  }
接着解析environments这个比较重要，不仅是新建environments对象设置到configuration中，而且还将创建事务工厂对象，以及数据源对象。 
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());
        }
      }
    }
  }
接下来解析databaseIdProvider，通过配置数据库供应商节点，可以在statement语句上标识对应数据库的语句，执行时将根据不同的数据库执行对应的语句。

解析typeHandlers，将处理Java类型和数据库类型的转换关系。解析TyptHandler的同样通过一个注册器来管理信息。

 private void typeHandlerElement(XNode parent) throws Exception {
    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");
          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.");
          }
        }
      }
    }
  }

同样可以通过类路径查找，网络资源查找mapper的信息，然后使用mapper注册器注册。看一下最后一种方式，Class<?> mapperInterface = Resources.classForName(mapperClass);先加载类文件信息，然后调用configuration.addMapper(mapperInterface);来注册。而configuration中mapperRegistry.addMapper(type);通过注册器来注册。

  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);
        }
      }
    }
  }
mapper的注册也是放到一个map中，key是类型名称，value是类型的代理工厂。然后解析mapper的xml文件。关于mapper的创建过程，将在下一篇中分析。





小小小小树
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis的SqlSessionFactory创建配置文件
ICanDoIt
09-28 1019
SqlSessionFactory创建配置文件 1、SqlSessionFactory简介 SqlSessionFactory是MyBatis中的一个重要的对象，它是用来创建SqlSession对象的，而SqlSession用来操作数据库的。 2、SqlSessionFactory生成 SqlSessionFactory对象可以通过SqlSessionFactoryBuilder来获得，而SqlSessionFactoryBuildr则可以从XML配置文件或预先定制的Configuration实例构建出Sq
MyBatis创建SqlSessionFactory遇到问题
qq_19780155的博客
09-01 1183
MyBatis遇到新手问题
MyBatis源码学习（三）——创建SqlSessionFactory实例和Mapper代理工厂
lkforce
06-10 1729
先上小结： 开始调用MybatisAutoConfiguration.sqlSessionFactory()方法。 构建SqlSessionFactoryBean类实例。 把数据源实例DataSource赋值给SqlSessionFactoryBean。 创建Configuration实例，赋值给SqlSessionFactoryBean。 读取mybatis配置文件，把mapperLocations参数赋值给SqlSessionFactoryBean。 SqlSessionFactoryBea
SqlSessionFactory多数据源配置案例（springBoot）
continuce的博客
06-24 4144
SqlSessionFactory多数据源配置案例（springBoot），注解方式在文章下面附带链接
【MyBatis 5】SqlSessionFactory和SqlSession
最新发布
2301_79655496的博客
04-18 1152
看完上述知识点如果你深感Java基础不够扎实，或者刷题刷的不够、知识不全面小编专门为你量身定制了一套针对知识面不够，也莫慌！还有一整套的，可以瞬间查漏补缺全都是一丢一丢的收集整理纯手打出来的。
配置信息的解析以及SqlSessionFactory构建过程
xajh_czbk的博客
03-29 572
一.配置信息解析过程： 调用SqlSessionFactoryBuilder的build（）方法，利用XMLConfiguration方法里的parseConfiguration方法解析相关的配置。inputStream流是mybatis-config.xml配置对应的字节流。 XMLConfigBuilder的parse（）方法解析mybatis-config.xml节点得到Configuration配置类。 简单总结一下这里：parseConfiguration完成是解析configuration
Mybatis系列十：创建SqlSession应用Plugin
lemon
03-12 325
Mybatis系列十：创建SqlSession应用Plugin 一、DefaultSqlSessionFactory SqlSessionFactory默认实现是DefaultSqlSessionFactory，提供了许多openSession重载方法，用于创建SqlSession。 1.1 根据DataSource创建SqlSession private SqlSession op...
Spring Boot 如何给SqlSessionFactoryBean 加插件
热门推荐
每天进步一点点
12-11 1万+
背景：项目中需要对数据库的写操作进行拦截。使用Mybatis的plugins可以完整这个操作 之前使用Spring+mybatis时只需要在xml中SqlSessionFactoryBean中进行配置。其中配置文件信息和插件代码 &lt;property name="plugins"&gt; &lt;array&gt; &lt;bean class="com.meituan.s...
创建springboot + mybatis项目，实现登录、注册功能详细过程
09-10
2. 创建`application.properties`，配置数据源、MyBatis的SqlSessionFactory和Mapper扫描路径。 **步骤三：建立数据库模型** 1. 设计用户表结构，如`users`表，包括`id`、`username`、`password`等字段。 2. 使用...
springboot+mybatis项目demo
03-13
在Spring Boot项目中，我们需要配置MyBatis的相关依赖，并创建`mybatis-config.xml`配置文件，定义数据源和SqlSessionFactory。此外，还需要创建Mapper接口和对应的XML文件，用于定义SQL操作。 3. **数据库连接** ...
mybatis-3.5.7.7z
10-04
7. **SqlSessionFactory**：它是MyBatis的启动入口，负责创建SqlSession对象，而SqlSession则用于执行数据库操作。SqlSessionFactory通常由`SqlSessionFactoryBuilder`构建，配置信息可以来自XML配置文件或Java配置...
mybatis教案
10-20
1. **初始化**：MyBatis 启动时，会读取配置文件，构建 SqlSessionFactory。这一步包括了加载配置文件、解析配置、建立数据源、事务管理器等。 2. **创建SqlSession**：通过 SqlSessionFactory 获取 SqlSession，它...
Mybatis如何配置连接池
08-31
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <!-- 其他配置，如Mapper文件位置等 --> ``` 这样，MyBatis就能利用Druid连接池进行高效的数据库操作。配置合理的连接池参数...
mybatisplus 多数据源，多个sqlSessionFactory 导致 savebatch 执行不正确
张小凡
11-28 5229
记录一下 mybatis-plus + sharding-JDBC 的时候，因为配置多数据源和多个SqlSessionFactory导致 mybatisPlus 执行 saveBatch 异常的问题。
Mybatis 原理之启动阶段
959
01-13 1052
Mybatis 源码之启动阶段解析
MyBatis启动流程
CZengze的专栏
10-31 6128
1.MyBatis简介       MyBatis本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。它支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的
mybatis系列----启动流程
qq_33012981的博客
12-18 814
mybatis系列–1–启动流程 文章目录`mybatis`系列--`1`--启动流程1 前言2 原生`jdbc`3 `mybatis`的简单用法4 启动流程4.1 `SqlSessionFactoryBuilder().build(inputStream)`4.1.1 `configurationElement(parser.evalNode("/mapper"))`4.1.2 `bindMapperForNamespace()`4.2 `sqlSessionFactory.openSession()
什么是SqlSessionFactory
weixin_66107850的博客
11-15 1558
SqlSession是Mybatis最重要的构建之一，可以简单的任务Mybatis一系列的配置目的是生成类似JDBC生成的Connection对象的SqlSession，这样才能和数据库开启“沟通的桥梁”，通过SqlSession可以实现增删改查（当然现在更加推荐是使用Mapper接口的形式），那么它是如何执行实现的呢？SqlSessionFactory是MyBatis框架中十分重要的对象，它是单个数据库映射关系经过编译后的内存镜像，其主要作用是创建SqlSession。
Mybatis源码（三）SqlSeesionFacrory作用及创建过程
雨剑的博客
11-03 476
文章目录1. SqlSessionFactory作用2. SqlSessionFactory创建过程 1. SqlSessionFactory作用 SqlSessionFactory本身是个接口，提供了一些操作Sqlsession对象的方法： 它有个默认实现类DefaultSqlSessionFactory； 所以核心功能点是在SqlSession中；SqlSession是Mybatis的核心接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值