Mybatis源码分析:SqlSessionFactory

SqlSessionFactory讲解

  SqlSessionFactory通过类名可以看出其作用是通过工厂模式创建SqlSession,那么如何通过工厂模式创建Sqlsession呢?抛开Sqlsession,先看看SqlSessionFactory的类结构和相关的方法。SqlSessionFactory实现了有两个子类分别是DefaultSqlSessionFactory和SqlSessionManager。其中DefaultSqlSessionFactory是构建Sqlsession最常用的一个类,可以直接通过构造器方式进行实例化,也可以使用mybatis提供的SqlSessionFactoryBuilder来构建一个SqlSessionFactory。SqlSessionManager更像是一个组合体,不仅仅实现了SqlSessionFactory,同时实现了SqlSession接口,其包含了三个属性sqlSessionFactory,sqlSessionProxy,localSqlSession,在完成SqlSession的构建后,可以完成SqlSession的CURD功能,说白了,SqlsessionManager集合了SqlSessionFactory和SqlSession的功能。
   SqlSessionFactory重载了多个openSession()方法,其目的就是希望实例化出一个Sqlsession,并且通过不同的参数形式构建出不同功能的Sqlsession,从下面的方法可以看出,可以为即将实例化出的SqlSession设置事务隔离等级,执行器类型,是否自动提交。

• SqlSession openSession();
• SqlSession openSession(boolean autoCommit);
• SqlSession openSession(Connection connection);
• SqlSession openSession(TransactionIsolationLevel level);
• SqlSession openSession(ExecutorType execType);
• SqlSession openSession(ExecutorType execType, boolean autoCommit);
• SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
• SqlSession openSession(ExecutorType execType, Connection connection);

构建一个SqlSessionFactory

这里采用两种方式进行构建,SqlSessionFactoryBuilder和SqlsessionManager

SqlSessionFactoryBuilder

   SqlSessionFactoryBuilder采用建造者模式进行构建,观察实现方法,可以看到重载了多个build()方法,通过不同的入参方式或者参数组合方式实现。大体上可以看到三种方式进行build。通过输入流InputStream，读入器Reader,配置类 Configuration。除了这三种入参,还提供了环境参数environment用于选择当前的后端存储环境和额外的资源属性properties,资源属性会防止在Configuration类中的variables属性中,用于为SqlSession和mybatis其他类提供相关的资源值。
   通过reader和inputStream方式构建SqlSessionFactory比较类似,都是先解析mybatis配置文件和Mapper配置文件。如果在解析期间出错,则抛出"Error building SqlSession."异常提示,在解析完成之后,会调用build(Configuration config)返回一个DefaultSqlSessionFactory实例。值得注意的是,一个SqlSessionFactoryBuilder实例只能加载一次配置,这是因为将配置文件以流的形式读入后,XMLConfigBuilder的parse()方法会进行打标,如果发现已经加载过了,则抛出BuilderException("Each XMLConfigBuilder can only be used once.")异常信息。其源码如下:

• 源码1

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

• 源码2

  public SqlSessionFactory build(Configuration config) {
     //获取默认的DefaultSqlSessionFactory
   return new DefaultSqlSessionFactory(config);
  }

• 实例1

package com.zzz.mybatis.service;

import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Map.Entry;
import java.util.Properties;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
public class SqlSessionFactoryTest {
@Test
public void SqlSessionFactoryBuilderTest() {
    SqlSessionFactory sessionFactory;
    //通过InputStream方式构建
    InputStream inputStream=getClass().getResourceAsStream("/mybatis-config.xml");
    SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
    //buil完成之后会将inputStream进行关闭,所以下述方式必须重新读取配置文件
    sessionFactory=builder.build(inputStream,new Properties() 
                                                {
                                                    {put("name", "zhangsan");}
                                                }
                                );
    //通过reader进行builder
    sessionFactory=builder.build(new InputStreamReader(getClass().getResourceAsStream("/mybatis-config.xml")),new Properties() 
                                {
                                    {put("name", "zhangsan");}
                                }
                                );
    //获取外部的资源
    Properties properties=sessionFactory.getConfiguration().getVariables();
    for(Entry<Object, Object> entry:properties.entrySet()) {
        System.out.println("key:"+entry.getKey()+"--->"+"value:"+entry.getValue());
    }
    //通过configuration方式进行build
    Configuration configuration = new Configuration();
    sessionFactory=builder.build(configuration);
}
}

SqlSessionFactoryBuilder

除了使用Builder方式,还可以通过SqlSessionManager的形式构建,其内部包含三个属性sqlSessionFactory,sqlSessionProxy,localSqlSession。其中sqlSessionProxy采用了JDK自身的代理机制,使用代理进行方法调用,而localSqlSession则使用了LocalThread对SqlSession进行纳管。SqlSessionManager中构造方法是私有的,只能通过其提供的newInstance()方法进行实例化,传参形式跟SqlSessionFactoryBuilder.builder()方式没有任何区别,事实上,newInstance()内部就是通过实例化了一个SqlSessionFactoryBuilder来获取DefaultSqlSessionFactory实例，再调用自身的私有构造器进行实例化。

@Test
    public void SqlSessionManagerTest() throws SQLException {
        //通过InputStream方式构建
        InputStream inputStream=getClass().getResourceAsStream("/mybatis-config.xml");
        SqlSessionManager sessionManager=SqlSessionManager.newInstance(inputStream);
        //该方式调用了openSession()方法,向localSqlSession写入一个SqlSession,后续可以直接进行CURD操作,其原理是通过动态代理进行调用
        sessionManager.startManagedSession();
        //调用DefaultSqlSessionFactory中的方法
        SqlSession session=sessionManager.openSession();
        sessionManager.close();
        System.out.println(sessionManager.isManagedSessionStarted());
    }

DefaultSqlSessionFactory

DefaultSqlSessionFactory用于创建一个SqlSession，在实例化的时候必须传入Confugration类,openSession()方法返回一个DefaultSqlSession实例,该方法实际上调用了openSessionFromDataSource()或者openSessionFromConnection().这两个方法的执行顺序如下步骤。

1. 获取configuration类中的运行环境信息,通过环境信息获取一个事务工厂,如果未设置环境信息,则使用默认的受管事务工厂(ManagedTransactionFactory),否则使用指定的事务工厂
2. 从事务工厂(TransactionFactory)实例化出一个事务对象Transaction
3. 根据指定的执行器类型实例化对应的执行器,如果未指定,则使用默认的Simple执行器
4. 实例化一个DefaultSqlSession,该实例需要Configuration,Executor,autoCommit作为入参。

使用DefaultSqlSessionFactory构造一个DefaultSqlSession实例核心代码如下

 private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

DefaultSqlSessionFactory 创建SqlSession的流程图

测试代码如下

mybatis-config.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "./mybatis-3-config.dtd">
  <configuration>
      <!--引入外部资源  -->
      <properties resource="./mybatis-mysql.properties"> 
      </properties>
      <settings>
          <setting name="cacheEnabled" value="true"/>
      </settings>
      <objectFactory type="com.zzz.mybatis.object.MyObjectFacotry">
          <property name="env" value="test"/>
      </objectFactory>
      <!--设置默认的环境为开发环境  -->
        <environments default="test">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="UNPOOLED">
        <property name="driver" value="${dev.driver}"/>
        <property name="url" value="${dev.url}"/>
        <property name="username" value="${dev.username}"/>
        <property name="password" value="${dev.password}"/>
      </dataSource>
    </environment>
    <!--测试环境用  -->
    <environment id="test">
        <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${test.driver}"/>
        <property name="url" value="${test.url}"/>
        <property name="username" value="${test.username}"/>
        <property name="password" value="${test.password}"/>
      </dataSource>
    </environment>
    <!--生产环境用  -->
    <environment id="prod">
        <transactionManager type="MANAGED"/>
      <dataSource type="JDBC">
        <property name="driver" value="${prod.driver}"/>
        <property name="url" value="${prod.url}"/>
        <property name="username" value="${prod.username}"/>
        <property name="password" value="${prod.password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
      <package name="com.zzz.mybatis.mapper"/>
  </mappers>
  </configuration>

Mapper接口

package com.zzz.mybatis.mapper;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.Flush;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Select;

public interface SqlMapper {
    @Select("select id,name,age from student")
    public List<Map<String, Object>> list();

    @Flush
    public void flush();

    @MapKey(value="id")
    @Select("select id,name,age from student")
    public Map<String,Map<String,String>> listByMapkey();
}

测试代码

@Test
public void DefaultSqlSessionFacotryTest() {
//通过InputStream方式构建
    InputStream inputStream=getClass().getResourceAsStream("/mybatis-config.xml");
    SqlSessionManager sessionManager=SqlSessionManager.newInstance(inputStream);
    //该方式调用了openSession()方法,向localSqlSession写入一个SqlSession,后续可以直接进行CURD操作,其原理是通过动态代理进行调用
    sessionManager.startManagedSession();
    //调用DefaultSqlSessionFactory中的方法
    SqlSession session=sessionManager.openSession();
    SqlMapper mapper=session.getMapper(SqlMapper.class);
    List<Map<String,Object>> rs=mapper.list();
    for(Map<String, Object> map:rs) {
        System.out.println(map.toString());
    }
}

测试结果

{name=zhangsan, id=1, age=20}
{name=lisi, id=2, age=30}
{name=wangwu, id=3, age=40}