Spring + Mybatis 项目实现动态切换数据源实例详解

2024-02-25 06:02:03 56

项目背景：项目开发中数据库使用了读写分离，所有查询语句走从库，除此之外走主库。

最简单的办法其实就是建两个包，把之前数据源那一套配置copy一份，指向另外的包，但是这样扩展很有限，所有采用下面的办法。

参考了两篇文章如下：

https://www.nhooo.com/article/111840.htm

https://www.nhooo.com/article/111842.htm

这两篇文章都对原理进行了分析，下面只写自己的实现过程其他不再叙述。

实现思路是：

第一步，实现动态切换数据源：配置两个DataSource，配置两个SqlSessionFactory指向两个不同的DataSource，两个SqlSessionFactory都用一个SqlSessionTemplate，同时重写Mybatis提供的SqlSessionTemplate类，最后配置Mybatis自动扫描。

第二步，利用aop切面，拦截dao层所有方法，因为dao层方法命名的特点，比如所有查询sql都是select开头，或者get开头等等，拦截这些方法，并把当前数据源切换至从库。

spring中配置如下：

主库数据源配置：

从库数据源配置：

主库SqlSessionFactory配置：

从库SqlSessionFactory配置：

两个SqlSessionFactory使用同一个SqlSessionTemplate配置：

配置Mybatis自动扫描dao

自己重写了SqlSessionTemplate代码如下：

packagecom.sincetimes.slg.framework.core;
importstaticjava.lang.reflect.Proxy.newProxyInstance;
importstaticorg.apache.ibatis.reflection.ExceptionUtil.unwrapThrowable;
importstaticorg.mybatis.spring.SqlSessionUtils.closeSqlSession;
importstaticorg.mybatis.spring.SqlSessionUtils.getSqlSession;
importstaticorg.mybatis.spring.SqlSessionUtils.isSqlSessionTransactional;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.sql.Connection;
importjava.util.List;
importjava.util.Map;
importorg.apache.ibatis.exceptions.PersistenceException;
importorg.apache.ibatis.executor.BatchResult;
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.mybatis.spring.MyBatisExceptionTranslator;
importorg.mybatis.spring.SqlSessionTemplate;
importorg.springframework.dao.support.PersistenceExceptionTranslator;
importorg.springframework.util.Assert;
importcom.sincetimes.slg.framework.util.SqlSessionContentHolder;
/**
*
*TODO重写SqlSessionTemplate
*@authorccg
*@version1.0
*Created2017年4月21日下午3:15:15
*/
publicclassDynamicSqlSessionTemplateextendsSqlSessionTemplate{
privatefinalSqlSessionFactorysqlSessionFactory;
privatefinalExecutorTypeexecutorType;
privatefinalSqlSessionsqlSessionProxy;
privatefinalPersistenceExceptionTranslatorexceptionTranslator;
privateMaptargetSqlSessionFactorys;
privateSqlSessionFactorydefaultTargetSqlSessionFactory;
publicvoidsetTargetSqlSessionFactorys(MaptargetSqlSessionFactorys){
this.targetSqlSessionFactorys=targetSqlSessionFactorys;
}
publicMapgetTargetSqlSessionFactorys(){
returntargetSqlSessionFactorys;
}
publicvoidsetDefaultTargetSqlSessionFactory(SqlSessionFactorydefaultTargetSqlSessionFactory){
this.defaultTargetSqlSessionFactory=defaultTargetSqlSessionFactory;
}
publicDynamicSqlSessionTemplate(SqlSessionFactorysqlSessionFactory){
this(sqlSessionFactory,sqlSessionFactory.getConfiguration().getDefaultExecutorType());
}
publicDynamicSqlSessionTemplate(SqlSessionFactorysqlSessionFactory,ExecutorTypeexecutorType){
this(sqlSessionFactory,executorType,newMyBatisExceptionTranslator(sqlSessionFactory.getConfiguration()
.getEnvironment().getDataSource(),true));
}
publicDynamicSqlSessionTemplate(SqlSessionFactorysqlSessionFactory,ExecutorTypeexecutorType,
PersistenceExceptionTranslatorexceptionTranslator){
super(sqlSessionFactory,executorType,exceptionTranslator);
this.sqlSessionFactory=sqlSessionFactory;
this.executorType=executorType;
this.exceptionTranslator=exceptionTranslator;
this.sqlSessionProxy=(SqlSession)newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
newClass[]{SqlSession.class},
newSqlSessionInterceptor());
this.defaultTargetSqlSessionFactory=sqlSessionFactory;
}
@Override
publicSqlSessionFactorygetSqlSessionFactory(){
SqlSessionFactorytargetSqlSessionFactory=targetSqlSessionFactorys.get(SqlSessionContentHolder.getContextType());
if(targetSqlSessionFactory!=null){
returntargetSqlSessionFactory;
}elseif(defaultTargetSqlSessionFactory!=null){
returndefaultTargetSqlSessionFactory;
}else{
Assert.notNull(targetSqlSessionFactorys,"Property'targetSqlSessionFactorys'or'defaultTargetSqlSessionFactory'arerequired");
Assert.notNull(defaultTargetSqlSessionFactory,"Property'defaultTargetSqlSessionFactory'or'targetSqlSessionFactorys'arerequired");
}
returnthis.sqlSessionFactory;
}
@Override
publicConfigurationgetConfiguration(){
returnthis.getSqlSessionFactory().getConfiguration();
}
publicExecutorTypegetExecutorType(){
returnthis.executorType;
}
publicPersistenceExceptionTranslatorgetPersistenceExceptionTranslator(){
returnthis.exceptionTranslator;
}
/**
*{@inheritDoc}
*/
publicTselectOne(Stringstatement){
returnthis.sqlSessionProxy.selectOne(statement);
}
/**
*{@inheritDoc}
*/
publicTselectOne(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.selectOne(statement,parameter);
}
/**
*{@inheritDoc}
*/
publicMapselectMap(Stringstatement,StringmapKey){
returnthis.sqlSessionProxy.selectMap(statement,mapKey);
}
/**
*{@inheritDoc}
*/
publicMapselectMap(Stringstatement,Objectparameter,StringmapKey){
returnthis.sqlSessionProxy.selectMap(statement,parameter,mapKey);
}
/**
*{@inheritDoc}
*/
publicMapselectMap(Stringstatement,Objectparameter,StringmapKey,RowBoundsrowBounds){
returnthis.sqlSessionProxy.selectMap(statement,parameter,mapKey,rowBounds);
}
/**
*{@inheritDoc}
*/
publicListselectList(Stringstatement){
returnthis.sqlSessionProxy.selectList(statement);
}
/**
*{@inheritDoc}
*/
publicListselectList(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.selectList(statement,parameter);
}
/**
*{@inheritDoc}
*/
publicListselectList(Stringstatement,Objectparameter,RowBoundsrowBounds){
returnthis.sqlSessionProxy.selectList(statement,parameter,rowBounds);
}
/**
*{@inheritDoc}
*/
publicvoidselect(Stringstatement,ResultHandlerhandler){
this.sqlSessionProxy.select(statement,handler);
}
/**
*{@inheritDoc}
*/
publicvoidselect(Stringstatement,Objectparameter,ResultHandlerhandler){
this.sqlSessionProxy.select(statement,parameter,handler);
}
/**
*{@inheritDoc}
*/
publicvoidselect(Stringstatement,Objectparameter,RowBoundsrowBounds,ResultHandlerhandler){
this.sqlSessionProxy.select(statement,parameter,rowBounds,handler);
}
/**
*{@inheritDoc}
*/
publicintinsert(Stringstatement){
returnthis.sqlSessionProxy.insert(statement);
}
/**
*{@inheritDoc}
*/
publicintinsert(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.insert(statement,parameter);
}
/**
*{@inheritDoc}
*/
publicintupdate(Stringstatement){
returnthis.sqlSessionProxy.update(statement);
}
/**
*{@inheritDoc}
*/
publicintupdate(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.update(statement,parameter);
}
/**
*{@inheritDoc}
*/
publicintdelete(Stringstatement){
returnthis.sqlSessionProxy.delete(statement);
}
/**
*{@inheritDoc}
*/
publicintdelete(Stringstatement,Objectparameter){
returnthis.sqlSessionProxy.delete(statement,parameter);
}
/**
*{@inheritDoc}
*/
publicTgetMapper(Classtype){
returngetConfiguration().getMapper(type,this);
}
/**
*{@inheritDoc}
*/
publicvoidcommit(){
thrownewUnsupportedOperationException("ManualcommitisnotallowedoveraSpringmanagedSqlSession");
}
/**
*{@inheritDoc}
*/
publicvoidcommit(booleanforce){
thrownewUnsupportedOperationException("ManualcommitisnotallowedoveraSpringmanagedSqlSession");
}
/**
*{@inheritDoc}
*/
publicvoidrollback(){
thrownewUnsupportedOperationException("ManualrollbackisnotallowedoveraSpringmanagedSqlSession");
}
/**
*{@inheritDoc}
*/
publicvoidrollback(booleanforce){
thrownewUnsupportedOperationException("ManualrollbackisnotallowedoveraSpringmanagedSqlSession");
}
/**
*{@inheritDoc}
*/
publicvoidclose(){
thrownewUnsupportedOperationException("ManualcloseisnotallowedoveraSpringmanagedSqlSession");
}
/**
*{@inheritDoc}
*/
publicvoidclearCache(){
this.sqlSessionProxy.clearCache();
}
/**
*{@inheritDoc}
*/
publicConnectiongetConnection(){
returnthis.sqlSessionProxy.getConnection();
}
/**
*{@inheritDoc}
*@since1.0.2
*/
publicListflushStatements(){
returnthis.sqlSessionProxy.flushStatements();
}
/**
*ProxyneededtorouteMyBatismethodcallstotheproperSqlSessiongotfromSpring'sTransactionManagerItalso
*unwrapsexceptionsthrownby{@codeMethod#invoke(Object,Object...)}topassa{@codePersistenceException}to
*the{@codePersistenceExceptionTranslator}.
*/
privateclassSqlSessionInterceptorimplementsInvocationHandler{
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
finalSqlSessionsqlSession=getSqlSession(
DynamicSqlSessionTemplate.this.getSqlSessionFactory(),
DynamicSqlSessionTemplate.this.executorType,
DynamicSqlSessionTemplate.this.exceptionTranslator);
try{
Objectresult=method.invoke(sqlSession,args);
if(!isSqlSessionTransactional(sqlSession,DynamicSqlSessionTemplate.this.getSqlSessionFactory())){
//forcecommitevenonnon-dirtysessionsbecausesomedatabasesrequire
//acommit/rollbackbeforecallingclose()
sqlSession.commit(true);
}
returnresult;
}catch(Throwablet){
Throwableunwrapped=unwrapThrowable(t);
if(DynamicSqlSessionTemplate.this.exceptionTranslator!=null&&unwrappedinstanceofPersistenceException){
Throwabletranslated=DynamicSqlSessionTemplate.this.exceptionTranslator
.translateExceptionIfPossible((PersistenceException)unwrapped);
if(translated!=null){
unwrapped=translated;
}
}
throwunwrapped;
}finally{
closeSqlSession(sqlSession,DynamicSqlSessionTemplate.this.getSqlSessionFactory());
}
}
}
}

SqlSessionContentHolder类代码如下：

packagecom.sincetimes.slg.framework.util;
publicabstractclassSqlSessionContentHolder{
publicfinalstaticStringSESSION_FACTORY_MASTER="master";
publicfinalstaticStringSESSION_FACTORY_SLAVE="slave";
privatestaticfinalThreadLocalcontextHolder=newThreadLocal();
publicstaticvoidsetContextType(StringcontextType){
contextHolder.set(contextType);
}
publicstaticStringgetContextType(){
returncontextHolder.get();
}
publicstaticvoidclearContextType(){
contextHolder.remove();
}
}

最后就是写切面去对dao所有方法进行处理了，代码很简单如下：

packagecom.sincetimes.slg.framework.core;
importorg.aspectj.lang.JoinPoint;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Before;
importorg.aspectj.lang.annotation.Pointcut;
importcom.sincetimes.slg.framework.util.SqlSessionContentHolder;
@Aspect
publicclassDynamicDataSourceAspect{
@Pointcut("execution(*com.sincetimes.slg.dao.*.*(..))")
publicvoidpointCut(){
}
@Before("pointCut()")
publicvoidbefore(JoinPointjp){
StringmethodName=jp.getSignature().getName();
//dao方法查询走从库
if(methodName.startsWith("query")||methodName.startsWith("get")||methodName.startsWith("count")||methodName.startsWith("list")){
SqlSessionContentHolder.setContextType(SqlSessionContentHolder.SESSION_FACTORY_SLAVE);
}else{
SqlSessionContentHolder.setContextType(SqlSessionContentHolder.SESSION_FACTORY_MASTER);
}
}
}

以上所述是小编给大家介绍的Spring+Mybatis项目实现动态切换数据源实例详解，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持！

Spring + Mybatis 项目实现动态切换数据源实例详解

热门推荐

随机推荐