SqlSessionFactoryBean简单分析

最新推荐文章于 2021-04-20 22:39:25 发布
原创 最新推荐文章于 2021-04-20 22:39:25 发布 · 6k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了MyBatis配置项的使用方法，包括如何通过Spring配置数据源、读取配置文件、注册映射器等关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >





package sqlsessionfactory;

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.cache.Cache;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.io.VFS;
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.TypeHandler;
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 Configuration configuration;
    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 Class<? extends VFS> vfs;
    private Cache cache;
    private ObjectFactory objectFactory;
    private ObjectWrapperFactory objectWrapperFactory;

    public SqlSessionFactoryBean() {
    }

    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 Class<? extends VFS> getVfs() {
        return this.vfs;
    }

    public void setVfs(Class<? extends VFS> vfs) {
        this.vfs = vfs;
    }

    public Cache getCache() {
        return this.cache;
    }

    public void setCache(Cache cache) {
        this.cache = cache;
    }

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

    /**
     * 将resource注入到bean中的方式获取资源
     * 会将<property name="configLocation" value="classpath:mybatis-config.xml" /> 以一个Resource类里面的一个属性注入
     Resource依赖:

     如果一个类的某依赖属性类型为Resource,如下配置

     Spring提供了对路径解析为Resource的转换器

     只要在在注入类内添加Resource field 如: private Resource configLocation;

     同时在配置文件内写入
     <property name="configLocation" value="classpath:mybatis-config.xml" />
     这样就会自动解析为Resource
     * @param configLocation
     */
    public void setConfigLocation(Resource configLocation) {
        this.configLocation = configLocation;
    }

    public void setConfiguration(Configuration configuration) {
        this.configuration = configuration;
    }

    public void setMapperLocations(Resource[] mapperLocations) {
        this.mapperLocations = mapperLocations;
    }

    public void setConfigurationProperties(Properties sqlSessionFactoryProperties) {
        this.configurationProperties = sqlSessionFactoryProperties;
    }

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

    public void afterPropertiesSet() throws Exception {
        //实例化SqlSessionFactoryBean前，必须确保dataSource属性已经得到配置。
        Assert.notNull(this.dataSource, "Property 'dataSource' is required");
        Assert.notNull(this.sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
        Assert.state(this.configuration == null && this.configLocation == null || this.configuration == null || this.configLocation == null, "Property 'configuration' and 'configLocation' can not specified with together");
        //调用方法创建sqlSessionFactory
        this.sqlSessionFactory = this.buildSqlSessionFactory();
    }

    /**
     生产sqlSessionFacoty 使用了建设者模式（Builder）。其构造过程主要注入了Configuration的实例对象，
     sqlSessionFactoryBuilder 扮演具体的建造者，
     configuration类主要负责建造细节的工作，sqlSessionFactory则是建造出来的产品
     */
    //创建sqlSessionFactory的方法体
    protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
        XMLConfigBuilder xmlConfigBuilder = null;
        Configuration configuration;
        //初始化的时候configuration=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) {
            //注意：初始化走这 configLocation因为含有类路径 所以在Spring注入该属性的时候
            // 被自动解析成了Resource对象 其中的Resource对象的path属性=classpath:mybatis-config.xml
            // 如果传入了MyBatis Config文件的路径,初始化xmlConfigBuilder 并获得里面的配置信息
            xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), (String)null, this.configurationProperties);
            //这步只是拿到初始化 super(new Configuration()); Configuration这个对象  并没有用到解析classpath:mybatis-config.xml得到的Document对象
            configuration = xmlConfigBuilder.getConfiguration();
        } else {
            //否则则采用默认的Mybatis配置，@see Configuration
            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);
        }

        String[] typeHandlersPackageArray;
        String[] var4;
        int var5;
        int var6;
        String packageToScan;
        // 如果在Spring的配置文件中,配置类实体类包的别名typeAliasesPackage
        //截取typeAliasesPackage属性的包，支持,或;
        if (StringUtils.hasLength(this.typeAliasesPackage)) {
            typeHandlersPackageArray = StringUtils.tokenizeToStringArray(this.typeAliasesPackage, ",; \t\n");
            var4 = typeHandlersPackageArray;
            var5 = typeHandlersPackageArray.length;

            for(var6 = 0; var6 < var5; ++var6) {
                packageToScan = var4[var6];
                //对应方法的目的是通过扫描包得到其包以及子包目录下的所有Class，然后为每个class注册别名
                //TypeAliasRegistry 负责管理别名， 这儿就是通过TypeAliasRegistry 进行别名注册
                configuration.getTypeAliasRegistry().registerAliases(packageToScan, this.typeAliasesSuperType == null ? Object.class : this.typeAliasesSuperType);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
                }
            }
        }

        /**
         * typeAliases是单独一个个的指定实例类别名，上面的typeAliasesPackage 是批量扫描包下面的实体类 批量指定别名
         */
        int var27;
        if (!ObjectUtils.isEmpty(this.typeAliases)) {
            Class[] var25 = this.typeAliases;
            var27 = var25.length;

            for(var5 = 0; var5 < var27; ++var5) {
                Class<?> typeAlias = var25[var5];
                configuration.getTypeAliasRegistry().registerAlias(typeAlias);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Registered type alias: '" + typeAlias + "'");
                }
            }
        }

        //如果配置类插件,注册插件,从这我们可以看到,插件类是实现Interceptor, 配置文件里可以传入数组
        if (!ObjectUtils.isEmpty(this.plugins)) {
            Interceptor[] var26 = this.plugins;
            var27 = var26.length;

            for(var5 = 0; var5 < var27; ++var5) {
                Interceptor plugin = var26[var5];
                configuration.addInterceptor(plugin);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Registered plugin: '" + plugin + "'");
                }
            }
        }

        /**
         Mybatis中的TypeHandler是什么？

         无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，
         都会用类型处理器将获取的值以合适的方式转换成 Java 类型。Mybatis默认为我们实现了许多TypeHandler,
         当我们没有配置指定TypeHandler时，Mybatis会根据参数或者返回结果的不同，默认为我们选择合适的TypeHandler处理。
         TypeHandler package配置方式:
         <configuration>
            <typeHandlers>
             <!--当配置package的时候，mybatis会去配置的package扫描TypeHandler -->
             <package name="mybatis.typeHandler"/>

             </typeHandlers>
         </configuration>
         */
        if (StringUtils.hasLength(this.typeHandlersPackage)) {
            typeHandlersPackageArray = StringUtils.tokenizeToStringArray(this.typeHandlersPackage, ",; \t\n");
            var4 = typeHandlersPackageArray;
            var5 = typeHandlersPackageArray.length;

            for(var6 = 0; var6 < var5; ++var6) {
                packageToScan = var4[var6];
                configuration.getTypeHandlerRegistry().register(packageToScan);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
                }
            }
        }

        /**
         TypeHandler 非package配置方式:
         <configuration>
             <typeHandlers>

                 <!-- handler属性直接配置我们要指定的TypeHandler -->
                 <typeHandler handler=""/>

                 <!-- javaType 配置java类型，例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->
                 <typeHandler javaType="" handler=""/>

                 <!-- jdbcType 配置数据库基本数据类型，例如varchar, 如果配上jdbcType, 那么指定的typeHandler就只作用于指定的类型  -->
                 <typeHandler jdbcType="" handler=""/>

                 <!-- 也可两者都配置 -->
                 <typeHandler javaType="" jdbcType="" handler=""/>

             </typeHandlers>
         </configuration>
         */
        if (!ObjectUtils.isEmpty(this.typeHandlers)) {
            TypeHandler[] var28 = this.typeHandlers;
            var27 = var28.length;

            for(var5 = 0; var5 < var27; ++var5) {
                TypeHandler<?> typeHandler = var28[var5];
                configuration.getTypeHandlerRegistry().register(typeHandler);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Registered type handler: '" + typeHandler + "'");
                }
            }
        }

        //databaseIdProvider 多数据库支持 在编写Mapper的时候 指定databaseId
        if (this.databaseIdProvider != null) {
            try {
                configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
            } catch (SQLException var24) {
                throw new NestedIOException("Failed getting a databaseId", var24);
            }
        }

        //缓存配置
        if (this.cache != null) {
            configuration.addCache(this.cache);
        }

        //如果xmlConfigBuilder存在则开始分析创建Configuration对象
        if (xmlConfigBuilder != null) {
            try {
                //这步才开始利用到 上面解析mybatis-config.xml得到的Document对象
                xmlConfigBuilder.parse();
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");
                }
            } catch (Exception var22) {
                throw new NestedIOException("Failed to parse config resource: " + this.configLocation, var22);
            } finally {
                ErrorContext.instance().reset();
            }
        }

        //事务工厂配置
        if (this.transactionFactory == null) {
            this.transactionFactory = new SpringManagedTransactionFactory();
        }

        configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

        //如果指定了mapper文件的路径
        if (!ObjectUtils.isEmpty(this.mapperLocations)) {
            Resource[] var29 = this.mapperLocations;
            var27 = var29.length;

            for(var5 = 0; var5 < var27; ++var5) {
                Resource mapperLocation = var29[var5];
                if (mapperLocation != null) {
                    try {
                        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(), configuration, mapperLocation.toString(), configuration.getSqlFragments());
                        xmlMapperBuilder.parse();
                    } catch (Exception var20) {
                        throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", var20);
                    } 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");
        }

        //创建SqlSessionFactory
        return this.sqlSessionFactoryBuilder.build(configuration);
    }

    public SqlSessionFactory getObject() throws Exception {
        if (this.sqlSessionFactory == null) {
            this.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();
        }

    }
}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
	default-lazy-init="false" default-autowire="byName">

	<!--数据源配置 start -->
	<!--  务必不能改成sqlSessionFactory-->
	<bean id="projectSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="mysqlDynamicDataSource" />
		<property name="configLocation" value="classpath:mybatis-config.xml" />
		<property name="mapperLocations">
			<array>
				<value>classpath:com/jd/account/mapper/*Mapper.xml</value>
			</array>
		</property>
	</bean>
	<bean id="projectSqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="projectSqlSessionFactory" />
	</bean>
	<bean id="projectSqlSessionTemplateBatch" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="projectSqlSessionFactory" />
		<constructor-arg index="1" value="BATCH" /> 
	</bean>
	<!--数据源配置 end -->
	
	<!-- 自动扫描 mapper 接口 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="${mapper.scan.package.name}" />
		<property name="processPropertyPlaceHolders" value="true"/>
		<property name="sqlSessionTemplateBeanName" value="projectSqlSessionTemplate" />
	</bean>
</beans>

 

Mybatis 自定义SqlSessionFactoryBean扫描通配符typeAliasesPackage
hgffhh的博客
02-22 476
Mybatis 自定义SqlSessionFactoryBean扫描通配符typeAliasesPackage
Spring:FactoryBean<T>接口+SqlSessionFactoryBean创建会话工厂
Oxygen的博客
05-16 1346
问题 Spring项目整合MyBatis时使用MyBatis-Spring，配置回话工厂时使用如下代码。 分析：在基础的MyBatis用法中是通过SqlSessionFactoryBuilder来创建SqlSessionFactory的。而在MyBatis-Spring中，则使用SqlSessionFactoryBean创建SqlSessionFactory。 <!-- MyBatis会话工...
mybatis-spring学习笔记之SqlSessionFactoryBean
纸上得来终觉浅，绝知此事要躬行
11-18 1万+
在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。     原文地址：http://mybatis.github.io/spring/factorybean.html 1、创建SqlSessionFactory 创建工
SqlSessionFactoryBean
weixin_34380296的博客
05-26 171
2019独角兽企业重金招聘Python工程师标准>>> ...
注意：为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的是同一个数据源，否则事务管理器就无法工作了。 why?
weixin_42448375的博客
01-13 2076
一 、mybatis单独使用 构建SqlSessionFactory String resource = "org/mybatis/example/mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFact...
SSM项目中Spring与Mybatis整合的原理与实践分析
通过XML或注解的方式将对象与数据库表进行映射，从而可以使用简单的Java对象（POJO）来进行数据库操作。 3. Spring整合Mybatis的过程： - 首先需要在项目中加入Mybatis和数据库驱动的依赖。 - 配置Mybatis的...
Mybatis 源码项目搭建以及主流程分析
06-12
5. **装饰器模式**：Mybatis的Executor执行器，通过装饰器模式扩展其功能，如SimpleExecutor、ReuseExecutor和BatchExecutor分别代表简单执行、复用Statement和批处理执行。 通过对Mybatis源码的阅读和项目实践，...
Mybatis源码分析（二）:源码分析入口引导
公众号-老炮说Java
05-03 2867
如果没看Mybatis源码分析(一):源码准备工作，再看本节1. 引导进入spring的源码首先是mybatis对  xml文件 进行解析，那么这个解析的关键配置就是&lt;bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"&gt;&lt;property name="dataSource" re...
关于SqlSessionFactoryBean
qq_40492885的博客
04-20 2099
在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的，而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。要创建工厂 bean，将下面的代码放到 Spring 的 XML 配置文件中： <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <prope
mybatis-spring：SqlSessionFactoryBean
程序猿的樊笼
08-23 2763
引言 在demo: springboot+mybatis的MybatisConfig中有这样两个bean配置（事务此时不看）： // 数据源配置 @Bean public DataSource dataSource() { // mybatis自带的一个简易数据库连接池，只是为了debug代码，这个就不关心了 PooledDataSou...
[mybatis-spring]sqlSessionFactoryBean
weixin_30432179的博客
05-30 201
在mybatis中,SqlSessionFactory由SqlSessionFactoryBuilder创建. 在mybatis-spring中,是由SqlSessionFactoryBean创建的. 1.创建 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> &...
Spring-MyBatis 之 SqlSessionFactoryBean
zsg88的专栏
09-09 1873
在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。 Spring 的 XML 配置文件：       SqlSessionFactoryBean这个类实现了三个接口，一个是InitializingBean，
MyBatis-spring之SqlSessionFactoryBean
ystyaoshengting的专栏
12-08 684
在基础的 MyBatis 用法中，是通过SqlSessionFactoryBuilder来创建SqlSessionFactory的。 而在 MyBatis-Spring 中，则使用SqlSessionFactoryBean来创建。 常用属性 DataSource SqlSessionFactory有一个唯一的必要属性：用于 JDBC 的DataSource。这可以是任意的Da...
spring-mybatis 之SqlSessionFactoryBean
热门推荐
赶路人儿
09-03 5万+
在 MyBatis 中，使用 SqlSessionFactoryBuilder创建SqlSessionFactory ，进而来创建 SqlSession。一旦你获得一个 session 之后,你可以使用它来执行映射语句,提交或回滚连接,最后,当不再需要它的时候, 你可以关闭 session。  Mybatis社区自己开发了一个Mybatis-Spring用来满足Mybatis用户整合Spring
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值