spring 整合 mybatis 中数据源的几种配置方式(总结篇)

2023-09-13 06:09:04 259

因为spring整合mybatis的过程中，有好几种整合方式，尤其是数据源那块，经常看到不一样的配置方式，总感觉有点乱，所以今天有空总结下。

一、采用org.mybatis.spring.mapper.MapperScannerConfigurer

其实逆向工程也是这种方式

1、数据源配配置文件

2、DAO文件

packagecom.jdd.mapper;
importcom.jdd.pojo.Employee;
importjava.util.List;
publicinterfaceEmployeeMapper{
publicEmployeegetEmployeeById(intid);
publicListfindAllEmployees();
}

3、Mapper.xml文件

这样在service类里就可以直接注入dao接口了

packagecom.jdd.service.impl;
importcom.jdd.mapper.EmployeeMapper;
importcom.jdd.pojo.Employee;
importcom.jdd.service.EmployeeService;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Service;
importjava.util.List;
@Service("employeeService")
publicclassEmployeeServiceImplimplementsEmployeeService{
@Autowired
privateEmployeeMapperemployeeMapper;
@Override
publicEmployeegetEmployeeById(intid){
returnemployeeMapper.getEmployeeById(id);
}
@Override
publicListfindAllEmployees(){
returnemployeeMapper.findAllEmployees();
}
}

二、采用抽象类org.mybatis.spring.support.SqlSessionDaoSupport，给它注入sqlSessionFactory的方式

1、数据源配置文件

2、baseDao类

packagecom.jdd.dao;
importorg.apache.ibatis.session.SqlSessionFactory;
importorg.mybatis.spring.support.SqlSessionDaoSupport;
importjavax.annotation.Resource;
publicabstractclassBaseDaoextendsSqlSessionDaoSupport{
@Resource
publicvoidsetSqlSessionFactory(SqlSessionFactorysqlSessionFactory){
super.setSqlSessionFactory(sqlSessionFactory);
}
}

3、接口EmployeeDao.java类

packagecom.jdd.dao;
importcom.jdd.pojo.Employee;
importjava.util.List;
publicinterfaceEmployeeDao{
EmployeegetEmployeeById(intid);
ListfindAllEmployees();
}

4、dao实现类EmployeeDaoImpl

packagecom.jdd.dao.impl;
importcom.jdd.dao.BaseDao;
importcom.jdd.dao.EmployeeDao;
importcom.jdd.pojo.Employee;
importorg.springframework.stereotype.Repository;
importjava.util.List;
@Repository("employeeDao")
publicclassEmployeeDaoImplextendsBaseDaoimplementsEmployeeDao{
@Override
publicEmployeegetEmployeeById(intid){
returnthis.getSqlSession().selectOne("com.jdd.dao.EmployeeDao.getEmployeeById",id);
}
@Override
publicListfindAllEmployees(){
returnthis.getSqlSession().selectList("com.jdd.dao.EmployeeDao.findAllEmployees");
}
}

5、这样就可以在service类里注入employeeDao了

三、采用org.mybatis.spring.SqlSessionTemplate模板类

1、数据源文件

2、basedao.java类

packagecom.jdd.dao;
importorg.mybatis.spring.SqlSessionTemplate;
importjavax.annotation.Resource;
publicabstractclassBaseDao{
publicSqlSessionTemplatesqlSessionTemplate;
@Resource
publicvoidsetSqlSessionTemplate(SqlSessionTemplatesqlSessionTemplate){
this.sqlSessionTemplate=sqlSessionTemplate;
}
}

3、接口EmployeeDao.java类

packagecom.jdd.dao;
importcom.jdd.pojo.Employee;
importjava.util.List;
publicinterfaceEmployeeDao{
EmployeegetEmployeeById(intid);
ListfindAllEmployees();
}

4、dao实现类EmployeeDaoImpl

packagecom.jdd.dao.impl;
importcom.jdd.dao.BaseDao;
importcom.jdd.dao.EmployeeDao;
importcom.jdd.pojo.Employee;
importorg.springframework.stereotype.Repository;
importjava.util.List;
@Repository("employeeDao")
publicclassEmployeeDaoImplextendsBaseDaoimplementsEmployeeDao{
@Override
publicEmployeegetEmployeeById(intid){
returnsqlSessionTemplate.selectOne("com.jdd.dao.EmployeeDao.getEmployeeById",id);
}
@Override
publicListfindAllEmployees(){
returnsqlSessionTemplate.selectList("com.jdd.dao.EmployeeDao.findAllEmployees");
}
}

5、同样现在也可以在service类里直接注入employeeDao使用了。

注：这里basedao的注入比较灵活，也可以注入SqlSessionFactory，然后再setter方法里创建SqlSessionTemplate，如下：

packagecom.jdd.dao;
importorg.apache.ibatis.session.SqlSessionFactory;
importorg.mybatis.spring.SqlSessionTemplate;
importjavax.annotation.Resource;
publicabstractclassBaseDao{
publicSqlSessionTemplatesqlSessionTemplate;
@Resource
publicvoidsetSqlSessionFactory(SqlSessionFactorysqlSessionFactory){
sqlSessionTemplate=newSqlSessionTemplate(sqlSessionFactory);
}
}

其实不管是采用继承SqlSessionDaoSupport类，注入sqlSessionFactory的方式，还是直接注入SqlSessionTemplate的方式，本质上是一样的。

如果你采用注入sqlSessionFactory的方式，它在底层也是通过sqlSessionFactory来创建SqlSessionTemplate，然后通过其api来操作。

不信给你们看下SqlSessionDaoSupport的源码：

//
//Sourcecoderecreatedfroma.classfilebyIntelliJIDEA
//(poweredbyFernflowerdecompiler)
//
packageorg.mybatis.spring.support;
importorg.apache.ibatis.session.SqlSession;
importorg.apache.ibatis.session.SqlSessionFactory;
importorg.mybatis.spring.SqlSessionTemplate;
importorg.springframework.dao.support.DaoSupport;
importorg.springframework.util.Assert;
publicabstractclassSqlSessionDaoSupportextendsDaoSupport{
privateSqlSessionsqlSession;
privatebooleanexternalSqlSession;
publicSqlSessionDaoSupport(){
}
publicvoidsetSqlSessionFactory(SqlSessionFactorysqlSessionFactory){
if(!this.externalSqlSession){
this.sqlSession=newSqlSessionTemplate(sqlSessionFactory);
}
}
publicvoidsetSqlSessionTemplate(SqlSessionTemplatesqlSessionTemplate){
this.sqlSession=sqlSessionTemplate;
this.externalSqlSession=true;
}
publicSqlSessiongetSqlSession(){
returnthis.sqlSession;
}
protectedvoidcheckDaoConfig(){
Assert.notNull(this.sqlSession,"Property'sqlSessionFactory'or'sqlSessionTemplate'arerequired");
}
}

同样SqlSessionTemplate继承了SqlSession接口，因此不管操作哪个效果都一样

//
//Sourcecoderecreatedfroma.classfilebyIntelliJIDEA
//(poweredbyFernflowerdecompiler)
//
packageorg.mybatis.spring;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
importjava.sql.Connection;
importjava.util.List;
importjava.util.Map;
importorg.apache.ibatis.exceptions.PersistenceException;
importorg.apache.ibatis.executor.BatchResult;
importorg.apache.ibatis.reflection.ExceptionUtil;
importorg.apache.ibatis.session.Configuration;
importorg.apache.ibatis.session.ExecutorType;
importorg.apache.ibatis.session.ResultHandler;
importorg.apache.ibatis.session.RowBounds;
importorg.apache.ibatis.session.SqlSession;
importorg.apache.ibatis.session.SqlSessionFactory;
importorg.springframework.dao.support.PersistenceExceptionTranslator;
importorg.springframework.util.Assert;
publicclassSqlSessionTemplateimplementsSqlSession{
privatefinalSqlSessionFactorysqlSessionFactory;
privatefinalExecutorTypeexecutorType;
privatefinalSqlSessionsqlSessionProxy;
privatefinalPersistenceExceptionTranslatorexceptionTranslator;
publicSqlSessionTemplate(SqlSessionFactorysqlSessionFactory){
this(sqlSessionFactory,sqlSessionFactory.getConfiguration().getDefaultExecutorType());
}
publicSqlSessionTemplate(SqlSessionFactorysqlSessionFactory,ExecutorTypeexecutorType){
this(sqlSessionFactory,executorType,newMyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(),true));
}
publicSqlSessionTemplate(SqlSessionFactorysqlSessionFactory,ExecutorTypeexecutorType,PersistenceExceptionTranslatorexceptionTranslator){
Assert.notNull(sqlSessionFactory,"Property'sqlSessionFactory'isrequired");
Assert.notNull(executorType,"Property'executorType'isrequired");
this.sqlSessionFactory=sqlSessionFactory;
this.executorType=executorType;
this.exceptionTranslator=exceptionTranslator;
this.sqlSessionProxy=(SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(),newClass[]{SqlSession.class},newSqlSessionTemplate.SqlSessionInterceptor());
}
publicSqlSessionFactorygetSqlSessionFactory(){
returnthis.sqlSessionFactory;
}
publicExecutorTypegetExecutorType(){
returnthis.executorType;
}
publicPersistenceExceptionTranslatorgetPersistenceExceptionTranslator(){
returnthis.exceptionTranslator;
}
publicTselectOne(Stringstatement){
returnthis.sqlSessionProxy.selectOne(statement);
}
publicTselectOne(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.selectOne(statement,parameter);
}
publicMapselectMap(Stringstatement,StringmapKey){
returnthis.sqlSessionProxy.selectMap(statement,mapKey);
}
publicMapselectMap(Stringstatement,Objectparameter,StringmapKey){
returnthis.sqlSessionProxy.selectMap(statement,parameter,mapKey);
}
publicMapselectMap(Stringstatement,Objectparameter,StringmapKey,RowBoundsrowBounds){
returnthis.sqlSessionProxy.selectMap(statement,parameter,mapKey,rowBounds);
}
publicListselectList(Stringstatement){
returnthis.sqlSessionProxy.selectList(statement);
}
publicListselectList(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.selectList(statement,parameter);
}
publicListselectList(Stringstatement,Objectparameter,RowBoundsrowBounds){
returnthis.sqlSessionProxy.selectList(statement,parameter,rowBounds);
}
publicvoidselect(Stringstatement,ResultHandlerhandler){
this.sqlSessionProxy.select(statement,handler);
}
publicvoidselect(Stringstatement,Objectparameter,ResultHandlerhandler){
this.sqlSessionProxy.select(statement,parameter,handler);
}
publicvoidselect(Stringstatement,Objectparameter,RowBoundsrowBounds,ResultHandlerhandler){
this.sqlSessionProxy.select(statement,parameter,rowBounds,handler);
}
publicintinsert(Stringstatement){
returnthis.sqlSessionProxy.insert(statement);
}
publicintinsert(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.insert(statement,parameter);
}
publicintupdate(Stringstatement){
returnthis.sqlSessionProxy.update(statement);
}
publicintupdate(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.update(statement,parameter);
}
publicintdelete(Stringstatement){
returnthis.sqlSessionProxy.delete(statement);
}
publicintdelete(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.delete(statement,parameter);
}
publicTgetMapper(Classtype){
returnthis.getConfiguration().getMapper(type,this);
}
publicvoidcommit(){
thrownewUnsupportedOperationException("ManualcommitisnotallowedoveraSpringmanagedSqlSession");
}
publicvoidcommit(booleanforce){
thrownewUnsupportedOperationException("ManualcommitisnotallowedoveraSpringmanagedSqlSession");
}
publicvoidrollback(){
thrownewUnsupportedOperationException("ManualrollbackisnotallowedoveraSpringmanagedSqlSession");
}
publicvoidrollback(booleanforce){
thrownewUnsupportedOperationException("ManualrollbackisnotallowedoveraSpringmanagedSqlSession");
}
publicvoidclose(){
thrownewUnsupportedOperationException("ManualcloseisnotallowedoveraSpringmanagedSqlSession");
}
publicvoidclearCache(){
this.sqlSessionProxy.clearCache();
}
publicConfigurationgetConfiguration(){
returnthis.sqlSessionFactory.getConfiguration();
}
publicConnectiongetConnection(){
returnthis.sqlSessionProxy.getConnection();
}
publicListflushStatements(){
returnthis.sqlSessionProxy.flushStatements();
}
privateclassSqlSessionInterceptorimplementsInvocationHandler{
privateSqlSessionInterceptor(){
}
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
SqlSessionsqlSession=SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,SqlSessionTemplate.this.executorType,SqlSessionTemplate.this.exceptionTranslator);
Objectunwrapped;
try{
Objectresult=method.invoke(sqlSession,args);
if(!SqlSessionUtils.isSqlSessionTransactional(sqlSession,SqlSessionTemplate.this.sqlSessionFactory)){
sqlSession.commit(true);
}
unwrapped=result;
}catch(Throwablevar){
unwrapped=ExceptionUtil.unwrapThrowable(var);
if(SqlSessionTemplate.this.exceptionTranslator!=null&&unwrappedinstanceofPersistenceException){
SqlSessionUtils.closeSqlSession(sqlSession,SqlSessionTemplate.this.sqlSessionFactory);
sqlSession=null;
Throwabletranslated=SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
if(translated!=null){
unwrapped=translated;
}
}
throw(Throwable)unwrapped;
}finally{
if(sqlSession!=null){
SqlSessionUtils.closeSqlSession(sqlSession,SqlSessionTemplate.this.sqlSessionFactory);
}
}
returnunwrapped;
}
}
}

总结

以上所述是小编给大家介绍的spring整合mybatis中数据源的几种配置方式，希望对大家有所帮助，如果大家有任何疑问欢迎给我留言，小编会及时回复大家的！

spring 整合 mybatis 中数据源的几种配置方式(总结篇)

热门推荐

随机推荐