SqlSessionFactoryBean

最新推荐文章于 2024-05-22 19:32:24 发布
最新推荐文章于 2024-05-22 19:32:24 发布
阅读量138 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/lavedream/blog/1819049
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

package org.mybatis.spring;

import java.io.IOException;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.DatabaseIdProvider;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.type.TypeAliasRegistry;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.core.NestedIOException;
import org.springframework.core.io.Resource;
import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

public class SqlSessionFactoryBean
  implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent>
{
  private static final Log logger = LogFactory.getLog(SqlSessionFactoryBean.class);
  private Resource configLocation;
  private Resource[] mapperLocations;
  private DataSource dataSource;
  private TransactionFactory transactionFactory;
  private Properties configurationProperties;
  private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
  private SqlSessionFactory sqlSessionFactory;
  private String environment = SqlSessionFactoryBean.class.getSimpleName();
  private boolean failFast;
  private Interceptor[] plugins;
  private TypeHandler<?>[] typeHandlers;
  private String typeHandlersPackage;
  private Class<?>[] typeAliases;
  private String typeAliasesPackage;
  private Class<?> typeAliasesSuperType;
  private DatabaseIdProvider databaseIdProvider;
  private ObjectFactory objectFactory;
  private ObjectWrapperFactory objectWrapperFactory;
  
  public void setObjectFactory(ObjectFactory objectFactory)
  {
    this.objectFactory = objectFactory;
  }
  
  public void setObjectWrapperFactory(ObjectWrapperFactory objectWrapperFactory)
  {
    this.objectWrapperFactory = objectWrapperFactory;
  }
  
  public DatabaseIdProvider getDatabaseIdProvider()
  {
    return this.databaseIdProvider;
  }
  
  public void setDatabaseIdProvider(DatabaseIdProvider databaseIdProvider)
  {
    this.databaseIdProvider = databaseIdProvider;
  }
  
  public void setPlugins(Interceptor[] plugins)
  {
    this.plugins = plugins;
  }
  
  public void setTypeAliasesPackage(String typeAliasesPackage)
  {
    this.typeAliasesPackage = typeAliasesPackage;
  }
  
  public void setTypeAliasesSuperType(Class<?> typeAliasesSuperType)
  {
    this.typeAliasesSuperType = typeAliasesSuperType;
  }
  
  public void setTypeHandlersPackage(String typeHandlersPackage)
  {
    this.typeHandlersPackage = typeHandlersPackage;
  }
  
  public void setTypeHandlers(TypeHandler<?>[] typeHandlers)
  {
    this.typeHandlers = typeHandlers;
  }
  
  public void setTypeAliases(Class<?>[] typeAliases)
  {
    this.typeAliases = typeAliases;
  }
  
  public void setFailFast(boolean failFast)
  {
    this.failFast = failFast;
  }
  //设置mybatis 配置
  public void setConfigLocation(Resource configLocation)
  {
    this.configLocation = configLocation;
  }
  
  //设置mapper配置 
  public void setMapperLocations(Resource[] mapperLocations)
  {
    this.mapperLocations = mapperLocations;
  }
  
  public void setConfigurationProperties(Properties sqlSessionFactoryProperties)
  {
    this.configurationProperties = sqlSessionFactoryProperties;
  }
  //在spring配置时，添加数据源
  public void setDataSource(DataSource dataSource)
  {
    if ((dataSource instanceof TransactionAwareDataSourceProxy)) {
      this.dataSource = ((TransactionAwareDataSourceProxy)dataSource).getTargetDataSource();
    } else {
      this.dataSource = dataSource;
    }
  }
  
  public void setSqlSessionFactoryBuilder(SqlSessionFactoryBuilder sqlSessionFactoryBuilder)
  {
    this.sqlSessionFactoryBuilder = sqlSessionFactoryBuilder;
  }
  
  public void setTransactionFactory(TransactionFactory transactionFactory)
  {
    this.transactionFactory = transactionFactory;
  }
  
  public void setEnvironment(String environment)
  {
    this.environment = environment;
  }
  // 实现了  InitializingBean 这个类 ，在类初始化完成后，调用 buildSqlSessionFactory 方法 。 
  public void afterPropertiesSet()
    throws Exception
  {
    Assert.notNull(this.dataSource, "Property 'dataSource' is required");
    Assert.notNull(this.sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
    
    this.sqlSessionFactory = buildSqlSessionFactory();
  }
  
  protected SqlSessionFactory buildSqlSessionFactory()
    throws IOException
  {
    XMLConfigBuilder xmlConfigBuilder = null;
    Configuration configuration;
    Configuration configuration;
    if (this.configLocation != null)
    {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      configuration = xmlConfigBuilder.getConfiguration();
    }
    else
    {
      if (logger.isDebugEnabled()) {
        logger.debug("Property 'configLocation' not specified, using default MyBatis Configuration");
      }
      configuration = new Configuration();
      configuration.setVariables(this.configurationProperties);
    }
    if (this.objectFactory != null) {
      configuration.setObjectFactory(this.objectFactory);
    }
    if (this.objectWrapperFactory != null) {
      configuration.setObjectWrapperFactory(this.objectWrapperFactory);
    }
    if (StringUtils.hasLength(this.typeAliasesPackage))
    {
      String[] typeAliasPackageArray = StringUtils.tokenizeToStringArray(this.typeAliasesPackage, ",; \t\n");
      for (String packageToScan : typeAliasPackageArray)
      {
        configuration.getTypeAliasRegistry().registerAliases(packageToScan, this.typeAliasesSuperType == null ? Object.class : this.typeAliasesSuperType);
        if (logger.isDebugEnabled()) {
          logger.debug("Scanned package: '" + packageToScan + "' for aliases");
        }
      }
    }
    if (!ObjectUtils.isEmpty(this.typeAliases)) {
      for (Class<?> typeAlias : this.typeAliases)
      {
        configuration.getTypeAliasRegistry().registerAlias(typeAlias);
        if (logger.isDebugEnabled()) {
          logger.debug("Registered type alias: '" + typeAlias + "'");
        }
      }
    }
    if (!ObjectUtils.isEmpty(this.plugins)) {
      for (Interceptor plugin : this.plugins)
      {
        configuration.addInterceptor(plugin);
        if (logger.isDebugEnabled()) {
          logger.debug("Registered plugin: '" + plugin + "'");
        }
      }
    }
    if (StringUtils.hasLength(this.typeHandlersPackage))
    {
      String[] typeHandlersPackageArray = StringUtils.tokenizeToStringArray(this.typeHandlersPackage, ",; \t\n");
      for (String packageToScan : typeHandlersPackageArray)
      {
        configuration.getTypeHandlerRegistry().register(packageToScan);
        if (logger.isDebugEnabled()) {
          logger.debug("Scanned package: '" + packageToScan + "' for type handlers");
        }
      }
    }
    if (!ObjectUtils.isEmpty(this.typeHandlers)) {
      for (TypeHandler<?> typeHandler : this.typeHandlers)
      {
        configuration.getTypeHandlerRegistry().register(typeHandler);
        if (logger.isDebugEnabled()) {
          logger.debug("Registered type handler: '" + typeHandler + "'");
        }
      }
    }
    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();
    }
    //初始化环境信息  ，事物管理 ，数据源 
    Environment environment = new Environment(this.environment, this.transactionFactory, this.dataSource);
    configuration.setEnvironment(environment);
    if (this.databaseIdProvider != null) {
      try
      {
        configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
      }
      catch (SQLException e)
      {
        throw new NestedIOException("Failed getting a databaseId", e);
      }
    }
    if (!ObjectUtils.isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation != null)
        {
          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);
  }
  
  public SqlSessionFactory getObject()
    throws Exception
  {
    if (this.sqlSessionFactory == null) {
      afterPropertiesSet();
    }
    return this.sqlSessionFactory;
  }
  
  public Class<? extends SqlSessionFactory> getObjectType()
  {
    return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
  }
  
  public boolean isSingleton()
  {
    return true;
  }
  
  public void onApplicationEvent(ApplicationEvent event)
  {
    if ((this.failFast) && ((event instanceof ContextRefreshedEvent))) {
      this.sqlSessionFactory.getConfiguration().getMappedStatementNames();
    }
  }
}

1：实现了 InitializingBean类  ，在初始化完成后，会调用 ：afterPropertiesSet()完成sessionFactory 的 创建

转载于:https://my.oschina.net/lavedream/blog/1819049

weixin_34380296
关注
mybatis 与 spring框架整合 之 SqlSessionFactoryBean 和 事务管理
TyuIn的博客
12-23 2031
接上一篇博客：https://blog.csdn.net/qq_43605444/article/details/122104494?spm=1001.2014.3001.5502 二、SqlSessionFactoryBean 在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。 1、设置 要创建工厂 bean，将下面的
MyBatis-Spring (二) SqlSessionFactoryBean
S2020chenxin的博客
03-14 2902
设置 要创建工厂 bean，将下面的代码放到 Spring 的 XML 配置文件中： <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> </bean> 需要注意的是 SqlSessionFactoryBean 实现了 Spring 的 FactoryBean 接口（
mybatis-spring学习笔记之SqlSessionFactoryBean
纸上得来终觉浅，绝知此事要躬行
11-18 1万+
在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。     原文地址：http://mybatis.github.io/spring/factorybean.html 1、创建SqlSessionFactory 创建工
深入浅出重构Mybatis与Spring集成的SqlSessionFactoryBean（上）
09-01
【深入浅出重构Mybatis与Spring集成的SqlSessionFactoryBean（上）】 在软件开发中，重构是一项关键的技术，旨在改善代码结构，提高可读性，同时保持原有功能不变。然而，这里的“重构”不仅限于优化，还包括了针对...
关于SqlSessionFactoryBean
qq_40492885的博客
04-20 2013
在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的，而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。要创建工厂 bean，将下面的代码放到 Spring 的 XML 配置文件中： <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <prope
mybatis-spring：SqlSessionFactoryBean
程序猿的樊笼
08-23 2615
引言 在demo: springboot+mybatis的MybatisConfig中有这样两个bean配置（事务此时不看）： // 数据源配置 @Bean public DataSource dataSource() { // mybatis自带的一个简易数据库连接池，只是为了debug代码，这个就不关心了 PooledDataSou...
[mybatis-spring]sqlSessionFactoryBean
weixin_30432179的博客
05-30 155
在mybatis中,SqlSessionFactory由SqlSessionFactoryBuilder创建. 在mybatis-spring中,是由SqlSessionFactoryBean创建的. 1.创建 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> &...
Spring-MyBatis 之 SqlSessionFactoryBean
zsg88的专栏
09-09 1773
在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。 Spring 的 XML 配置文件：       SqlSessionFactoryBean这个类实现了三个接口，一个是InitializingBean，
spring-mybatis 之SqlSessionFactoryBean
热门推荐
赶路人儿
09-03 5万+
在 MyBatis 中，使用 SqlSessionFactoryBuilder创建SqlSessionFactory ，进而来创建 SqlSession。一旦你获得一个 session 之后,你可以使用它来执行映射语句,提交或回滚连接,最后,当不再需要它的时候, 你可以关闭 session。  Mybatis社区自己开发了一个Mybatis-Spring用来满足Mybatis用户整合Spring
SqlSessionFactoryBean简单分析
luzhensmart的专栏
07-22 5935
package sqlsessionfactory; import java.io.IOException; import java.sql.SQLException; import java.util.Properties; import javax.sql.DataSource; import org.apache.ibatis.builder.xml.XMLConfigBuild...
【第14章】MyBatis-Spring之SqlSessionFactoryBean
最新发布
zjg
05-22 876
在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。SqlSessionFactory 有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。属性描述dataSource。
MyBatis入门系列(22) -MyBatis-Spring核心源码解析之SqlSessionFactoryBean
记录知识、锤炼自我
11-01 5115
前言 在之前使用了mybatis的文档中，我们需要手动创建SqlSessionFactory对象来获取SqlSession，然后通过SqlSession获取mapper代理对象，进行数据库操作。 // 根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); Sql
Mybatis-Spring 的高级配置 （SqlSessionFactoryBean）
bingguang1993的博客
08-30 3838
一、SqlSessionFactoryBean mybatis-spring 官网 在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-spring 中,则使用SqlSessionFactoryBean 来替代：   &lt;bean id="sqlSessionFactory" class="...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值