Mybatis组件之 SqlSessionFactory和SqlSession 对象详解

柔光的暖阳◎ 2022-12-05 13:59 150阅读 0赞

## 一、 SqlSessionFactory ##

SqlSessionFactory是MyBatis的关键对象，它是个单个数据库映射关系经过编译后的内存镜像。SqlSessionFactory对象的实例可以通过SqlSessionFactoryBuilder对象类获得,而SqlSessionFactoryBuilder则可以从XML配置文件或一个预先定制的Configuration的实例构建出SqlSessionFactory的实例。每一个MyBatis的应用程序都以一个SqlSessionFactory对象的实例为核心。同时SqlSessionFactory也是线程安全的，SqlSessionFactory一旦被创建，应该在应用执行期间都存在.在应用运行期间不要重复创建多次，建议使用单例模式。SqlSessionFactory是创建SqlSession的工厂。  
SqlSessionFactory接口源码如下所示:

package org.apache.ibatis.session;
    
    import java.sql.Connection;
    
    /**
     * Creates an {@link SqlSession} out of a connection or a DataSource
     * 
     * @author Clinton Begin
     */
    public interface SqlSessionFactory {
        
    
      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);
    
      Configuration getConfiguration();
    
    }

## 二、SqlSession ##

SqlSession是MyBatis的关键对象，它是应用程序与持久层之间交互操作的一个单线程对象,类似于JDBC中的Connection。SqlSession对象完全包含以数据库为背景的所有执行SQL操作的方法，它的底层封装了JDBC连接，可以用SqlSession实例来直接执行被映射的SQL语句。每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能被共享，同时SqlSession也是线程不安全的，绝对不能讲SqlSeesion实例的引用放在一个类的静态字段甚至是实例字段中。也绝不能将SqlSession实例的引用放在任何类型的管理范围中，比如Servlet当中的HttpSession对象中。使用完SqlSeesion之后关闭Session很重要,应该确保使用finally块来关闭它。  
示例代码有点多就不贴了，可以自己去看源码。

## 三、SqlSessionFactory和SqlSession实现过程 ##

mybatis框架主要是围绕着SqlSessionFactory进行的，创建过程大概如下：  
(1)、定义一个Configuration对象，其中包含数据源、事务、mapper文件资源以及影响数据库行为属性设置settings  
(2)、通过配置对象，则可以创建一个SqlSessionFactoryBuilder对象  
(3)、通过 SqlSessionFactoryBuilder 获得SqlSessionFactory 的实例。  
(4)、SqlSessionFactory 的实例可以获得操作数据的SqlSession实例，通过这个实例对数据库进行操作  
如果是spring+mybaits项目  
application.yml文件数据库配置

spring:
      profiles: devnew
      datasource:
        url: jdbc:mysql://xxx.xxx.xxx.xxx:3306/xxx?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
        driver-class-name: com.mysql.jdbc.Driver
        username: xxxx
        password: xxxxxx
      redis:
        host: xx.xx.xxx.xxx
        port: 7000
        password: xxxxxx
        database: 7
        lettuce:
          pool:
            max-active: 1000
            max-wait: 10000ms
            max-idle: 10
    连接数据库
    
    /**
     * 数据源配置
     */
    @Configuration
    public class DruidConfig {
        
    
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        @Value("${spring.datasource.url}")
        private String dbUrl;
    
        @Value("${spring.datasource.username}")
        private String username;
    
        @Value("${spring.datasource.password}")
        private String password;
    
        @Value("${spring.datasource.driver-class-name}")
        private String driverClassName;
    
        @Bean
        @Primary
        public DataSource druidDataSource() {
        
            DruidDataSource datasource = new DruidDataSource();
            datasource.setUrl(this.dbUrl);
            datasource.setUsername(username);
            datasource.setPassword(password);
            datasource.setDriverClassName(driverClassName);
            datasource.setInitialSize(10);
            datasource.setMinIdle(10);
            datasource.setMaxActive(200);
            datasource.setMaxWait(60000);
            datasource.setTimeBetweenEvictionRunsMillis(45000);
            datasource.setValidationQuery("SELECT 1");
            datasource.setTestWhileIdle(true);
            datasource.setTestOnBorrow(true);
            datasource.setTestOnReturn(false);
            datasource.setRemoveAbandonedTimeout(3600);
            try {
        
                datasource.setFilters("stat");
                datasource.init();
            } catch (SQLException e) {
        
                logger.error("druid configuration initialization filter", e);
            }
            return datasource;
        }
    }

**SqlSessionFactory的创建**

public class SessionFactoryConfig implements TransactionManagementConfigurer {
        
    
        @Autowired
        private DataSource dataSource;
        private String mapper = "classpath:com/xx/xxx/mapper/**/*Mapper.xml";   //xml扫描路径
        @Bean
        public SqlSessionFactory sqlSessionFactory() throws Exception {
        
            final SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    
            MybatisSqlSessionFactoryBean bean  = new MybatisSqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
            sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapper));
            return sqlSessionFactoryBean.getObject();
        }
    
        @Bean
        public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        
            return new SqlSessionTemplate(sqlSessionFactory);
        }
    
        @Bean
        @Override
        public PlatformTransactionManager annotationDrivenTransactionManager() {
        
            return new DataSourceTransactionManager(dataSource);
        }
    }

**加粗样式**具体实现过程  
第一步：  
我们看这个方法sqlSessionFactoryBean.getObject();

/**
       * {@inheritDoc}
       */
      @Override
      public SqlSessionFactory getObject() throws Exception {
        
        if (this.sqlSessionFactory == null) {
        
          afterPropertiesSet();
        }
    
        return this.sqlSessionFactory;
      }

接着我们在看 **afterPropertiesSet()**;

@Override
      public void afterPropertiesSet() throws Exception {
        
        notNull(dataSource, "Property 'dataSource' is required");
        notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
        state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
                  "Property 'configuration' and 'configLocation' can not specified with together");
    
        this.sqlSessionFactory = buildSqlSessionFactory();
      }

接着我们在看看buildSqlSessionFactory()

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
        
    
        Configuration configuration;
    
        XMLConfigBuilder xmlConfigBuilder = null;
        if (this.configuration != null) {
        
          configuration = this.configuration;
          if (configuration.getVariables() == null) {
        
            configuration.setVariables(this.configurationProperties);
          } else if (this.configurationProperties != null) {
        
            configuration.getVariables().putAll(this.configurationProperties);
          }
        } else if (this.configLocation != null) {
        
          xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
          configuration = xmlConfigBuilder.getConfiguration();
        } else {
        
          if (LOGGER.isDebugEnabled()) {
        
            LOGGER.debug("Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
          }
          configuration = new Configuration();
          if (this.configurationProperties != null) {
        
            configuration.setVariables(this.configurationProperties);
          }
        }
    
        if (this.objectFactory != null) {
        
          configuration.setObjectFactory(this.objectFactory);
        }
    
        if (this.objectWrapperFactory != null) {
        
          configuration.setObjectWrapperFactory(this.objectWrapperFactory);
        }
    
        if (this.vfs != null) {
        
          configuration.setVfsImpl(this.vfs);
        }
    
        if (hasLength(this.typeAliasesPackage)) {
        
          String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
              ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
          for (String packageToScan : typeAliasPackageArray) {
        
            configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                    typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
            }
          }
        }
    
        if (!isEmpty(this.typeAliases)) {
        
          for (Class<?> typeAlias : this.typeAliases) {
        
            configuration.getTypeAliasRegistry().registerAlias(typeAlias);
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Registered type alias: '" + typeAlias + "'");
            }
          }
        }
    
        if (!isEmpty(this.plugins)) {
        
          for (Interceptor plugin : this.plugins) {
        
            configuration.addInterceptor(plugin);
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Registered plugin: '" + plugin + "'");
            }
          }
        }
    
        if (hasLength(this.typeHandlersPackage)) {
        
          String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
              ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
          for (String packageToScan : typeHandlersPackageArray) {
        
            configuration.getTypeHandlerRegistry().register(packageToScan);
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
            }
          }
        }
    
        if (!isEmpty(this.typeHandlers)) {
        
          for (TypeHandler<?> typeHandler : this.typeHandlers) {
        
            configuration.getTypeHandlerRegistry().register(typeHandler);
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Registered type handler: '" + typeHandler + "'");
            }
          }
        }
    
        if (this.databaseIdProvider != null) {
        //fix #64 set databaseId before parse mapper xmls
          try {
        
            configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
          } catch (SQLException e) {
        
            throw new NestedIOException("Failed getting a databaseId", e);
          }
        }
    
        if (this.cache != null) {
        
          configuration.addCache(this.cache);
        }
    
        if (xmlConfigBuilder != null) {
        
          try {
        
            xmlConfigBuilder.parse();
    
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");
            }
          } catch (Exception ex) {
        
            throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
          } finally {
        
            ErrorContext.instance().reset();
          }
        }
    
        if (this.transactionFactory == null) {
        
          this.transactionFactory = new SpringManagedTransactionFactory();
        }
    
        configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));
    
        if (!isEmpty(this.mapperLocations)) {
        
          for (Resource mapperLocation : this.mapperLocations) {
        
            if (mapperLocation == null) {
        
              continue;
            }
    
            try {
        
              XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                  configuration, mapperLocation.toString(), configuration.getSqlFragments());
              xmlMapperBuilder.parse();
            } catch (Exception e) {
        
              throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
            } finally {
        
              ErrorContext.instance().reset();
            }
    
            if (LOGGER.isDebugEnabled()) {
        
              LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
            }
          }
        } else {
        
          if (LOGGER.isDebugEnabled()) {
        
            LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
          }
        }
    
        return this.sqlSessionFactoryBuilder.build(configuration);
      }

到此 一个SqlSessionFactory就创建好了。  
**SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession**生命周期  
如果使用依赖注入框架（Spring）可不用在代码中关心作用域问题，因为依赖注入框架会为我们做好几乎一切工作。

**SqlSessionFactoryBuilder**  
这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。因此 SqlSessionFactoryBuilder 实例的最佳范围是方法范围（也就是局部方法变量）。你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但是最好还是不要让其一直存在以保证所有的 XML 解析资源开放给更重要的事情。

**SqlSessionFactory**  
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由对它进行清除或重建。使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种bad smell。因此 　SqlSessionFactory 的最佳范围是应用范围。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

**SqlSession**  
每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的范围是请求或方法范围。绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。也绝不能将 SqlSession 实例的引用放在任何类型的管理范围中，比如 Serlvet 架构中的 HttpSession。如果你现在正在使用一种 Web 框架，要考虑 SqlSession 放在一个和 HTTP 请求对象相似的范围中。换句话说，每次收到的 HTTP 请求，就可以打开一个 SqlSession，返回一个响应，就关闭它。这个关闭操作是很重要的，你应该把这个关闭操作放到 finally 块中以确保每次都能执行关闭。  
![在这里插入图片描述][20200910220659129.gif_pic_center]

[20200910220659129.gif_pic_center]: /images/20221123/3f903b85dfc94e1180cda99fedb96049.png