Spring+Mybatis多数据源的实现

最新推荐文章于 2024-08-19 11:44:41 发布
最新推荐文章于 2024-08-19 11:44:41 发布
阅读量1.5k 收藏
点赞数
文章标签： springmvc security lucene hibernate datagrid
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwwp22233/article/details/52619290
版权
第一种方法：创建两个会话工厂  
配置如下 
Java代码   
  1. <beans>  
  2.     <!-- 数据源1 -->  
  3.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">    
  4.          <!-- 数据库基本信息配置 -->  
  5.          <property name="url" value="${url}" />    
  6.          <property name="username" value="${username}" />    
  7.          <property name="password" value="${password}" />    
  8.          <property name="driverClassName" value="${driverClassName}" />    
  9.          <property name="filters" value="${filters}" />    
  10.         <!-- 最大并发连接数 -->  
  11.          <property name="maxActive" value="${maxActive}" />  
  12.          <!-- 初始化连接数量 -->  
  13.          <property name="initialSize" value="${initialSize}" />  
  14.          <!-- 配置获取连接等待超时的时间 -->  
  15.          <property name="maxWait" value="${maxWait}" />  
  16.          <!-- 最小空闲连接数 -->  
  17.          <property name="minIdle" value="${minIdle}" />    
  18.     </bean>    
  19.     <!-- 数据源2 -->  
  20.     <bean id="syncDataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">    
  21.          <property name="url" value="${sync.url}" />    
  22.          <property name="username" value="${sync.username}" />    
  23.          <property name="password" value="${sync.password}" />    
  24.          <property name="driverClassName" value="${sync.driverClassName}" />    
  25.          <property name="filters" value="${filters}" />    
  26.          <property name="maxActive" value="${maxActive}" />  
  27.          <property name="initialSize" value="${initialSize}" />>  
  28.          <property name="maxWait" value="${maxWait}" />  
  29.          <property name="minIdle" value="${minIdle}" />    
  30.     </bean>    
  31.     <!-- 第一个sqlSessionFactory -->  
  32.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
  33.         <property name="dataSource" ref="dataSource" />  
  34.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>  
  35.         <!-- mapper扫描 -->  
  36.         <property name="mapperLocations" value="classpath:mybatis/*/*.xml"></property>  
  37.     </bean>  
  38.       
  39.     <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">  
  40.         <constructor-arg ref="sqlSessionFactory" />  
  41.     </bean>  
  42.     <!-- 第二个sqlSessionFactory -->  
  43.     <bean id="syncSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
  44.         <property name="dataSource" ref="syncDataSource" />  
  45.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>  
  46.         <property name="mapperLocations" value="classpath:mybatis/sync/*.xml"></property>  
  47.     </bean>         
  48.     <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">     
  49.             <property name="dataSource" ref="dataSource"></property>  
  50.     </bean>  
  51.     <bean id="syncSqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">  
  52.         <constructor-arg ref="syncSqlSessionFactory" />  
  53.     </bean>  
  54.     <!-- <aop:aspectj-autoproxy proxy-target-class="true" />  -->  
  55. </beans>  

这种方法，在程序中只需要切换sqlSessionTemplate即可，但是这样第二数据源无事务， 
容易抛出TransactionSynchronizationManager.unbindResourceIfPossible异常，这也是其缺点 
是否可以再添加一个事务管理器？ 下载

Java代码   
  1. <bean name="syncTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">     
  2.             <property name="dataSource" ref="syncDataSource"></property>  
  3. </bean>  

你可以试试，我测试没问题。 
jdbc.properties配置文件 
Java代码   
  1. url=jdbc\:mysql\://localhost\:3306/test?useUnicode\=true&characterEncoding\=utf8&characterSetResults\=utf8   
  2. driverClassName=com.mysql.jdbc.Driver  
  3. username=donald  
  4. password=123456  
  5.   
  6. #sync datasource  
  7. sync.url=jdbc\:mysql\://192.168.32.128\:3306/test?useUnicode\=true&characterEncoding\=utf8&characterSetResults\=utf8   
  8. sync.driverClassName=com.mysql.jdbc.Driver  
  9. sync.username=donald  
  10. sync.password=123456  


第二种方法：扩展数据源路由  下载
查看AbstractRoutingDataSource 
//抽象数据源路由 
Java代码   
  1. public abstract class AbstractRoutingDataSource extends AbstractDataSource  
  2.     implements InitializingBean  
  3. {  
  4.   
  5. public void afterPropertiesSet()  
  6.     {  
  7.         if(targetDataSources == null)  
  8.             throw new IllegalArgumentException("Property 'targetDataSources' is required");  
  9.         resolvedDataSources = new HashMap(targetDataSources.size());  
  10.         Object lookupKey;  
  11.         DataSource dataSource;  
  12.     //将配置的多数据源添加到resolvedDataSources中  
  13.         for(Iterator iterator = targetDataSources.entrySet().iterator(); iterator.hasNext(); resolvedDataSources.put(lookupKey, dataSource))  
  14.         {  
  15.             java.util.Map.Entry entry = (java.util.Map.Entry)iterator.next();  
  16.             lookupKey = resolveSpecifiedLookupKey(entry.getKey());  
  17.             dataSource = resolveSpecifiedDataSource(entry.getValue());  
  18.         }  
  19.   
  20.         if(defaultTargetDataSource != null)  
  21.         //默认数据源  
  22.             resolvedDefaultDataSource = resolveSpecifiedDataSource(defaultTargetDataSource);  
  23.     }  
  24.     //数据源key  
  25.     protected Object resolveSpecifiedLookupKey(Object lookupKey)  
  26.     {  
  27.         return lookupKey;  
  28.     }  
  29.     //获取数据源根据dataSource  
  30.     protected DataSource resolveSpecifiedDataSource(Object dataSource)  
  31.         throws IllegalArgumentException  
  32.     {  
  33.         if(dataSource instanceof DataSource)  
  34.             return (DataSource)dataSource;  
  35.         if(dataSource instanceof String)  
  36.        //从bean容器中获取对应的数据源，(DataSource)beanFactory.getBean(dataSourceName, javax/sql/DataSource);  
  37.        // in BeanFactoryDataSourceLookup.getDataSource(String dataSourceName)  
  38.             return dataSourceLookup.getDataSource((String)dataSource);  
  39.         else  
  40.             throw new IllegalArgumentException((new StringBuilder()).append("Illegal data source value - only [javax.sql.DataSource] and String supported: ").append(dataSource).toString());  
  41.     }  
  42.     //获取连接  
  43.      public Connection getConnection()  
  44.         throws SQLException  
  45.     {  
  46.        //再看determineTargetDataSource  
  47.         return determineTargetDataSource().getConnection();  
  48.     }  
  49.     protected DataSource determineTargetDataSource()  
  50.     {  
  51.         //获取当前数据源名，这里是关键  
  52.         Object lookupKey = determineCurrentLookupKey();  
  53.     //获取当前数据源  
  54.         DataSource dataSource = (DataSource)resolvedDataSources.get(lookupKey);  
  55.         if(dataSource == null && (lenientFallback || lookupKey == null))  
  56.         //如果dataSource为空，则dataSource为默认的数据源resolvedDataSources  
  57.             dataSource = resolvedDefaultDataSource;  
  58.         if(dataSource == null)  
  59.             throw new IllegalStateException((new StringBuilder()).append("Cannot determine target DataSource for lookup key [").append(lookupKey).append("]").toString());  
  60.         else  
  61.             return dataSource;  
  62.     }  
  63.     //determineCurrentLookupKey方法，为抽象方法，待子类扩展，这是不是给了我们一种思路  
  64.     protected abstract Object determineCurrentLookupKey();  
  65.     private Map targetDataSources;//Map<String,DataSource>,key为数据源名，value为DataSource  
  66.     private Object defaultTargetDataSource;  
  67.     private boolean lenientFallback;  
  68.     private DataSourceLookup dataSourceLookup;  
  69.     private Map resolvedDataSources;//Map<String,DataSource>,key为数据源名，value为DataSource  
  70.     private DataSource resolvedDefaultDataSource;  
  71. }  

从分析AbstractRoutingDataSource获取数据源得出，想要实现多数据源，只需要扩展AbstractRoutingDataSource,并实现determineCurrentLookupKey方法即可，并在determineCurrentLookupKey方法中切换数据源名即可。 
下面实验： 下载
//数据源路由 
Java代码   
  1. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;  
  2. /** 
  3.  * 动态切换数据源 
  4.  * @author donald 
  5.  * 
  6.  */  
  7. public class MultipleRoutingDataSource extends AbstractRoutingDataSource{  
  8.     @Override  
  9.     protected Object determineCurrentLookupKey() {  
  10.         return DataSourceContextHolder.getDataSourceType();  
  11.     }  

} 
//这里我们创建一个数据源上下文句柄，以便切换数据源 下载
Java代码   
  1. /** 
  2.  * 数据源上下文 
  3.  * @author donald 
  4.  * 
  5.  */  
  6. public  class DataSourceContextHolder {  
  7.     public final static String DATA_SOURCE_LOCAL = "dataSource";  
  8.     public final static String DATA_SOURCE_SYNC = "syncDataSource";  
  9.     //对数据源名，线程隔离  
  10.     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();  
  11.       
  12.     public static void setDataSourceType(String dataSource) {    
  13.         contextHolder.set(dataSource);    
  14.     }        
  15.     public static String getDataSourceType() {    
  16.         return contextHolder.get();    
  17.     }     
  18.     public static void clearDataSourceType() {    
  19.         contextHolder.remove();    
  20.     }    
  21. }  

//配置如下 下载
Java代码   
  1. <beans>  
  2.         <!-- 数据源1 -->  
  3.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">    
  4.          <!-- 数据库基本信息配置 -->  
  5.          <property name="url" value="${url}" />    
  6.          <property name="username" value="${username}" />    
  7.          <property name="password" value="${password}" />    
  8.          <property name="driverClassName" value="${driverClassName}" />    
  9.          <property name="filters" value="${filters}" />    
  10.         <!-- 最大并发连接数 -->  
  11.          <property name="maxActive" value="${maxActive}" />  
  12.          <!-- 初始化连接数量 -->  
  13.          <property name="initialSize" value="${initialSize}" />  
  14.          <!-- 配置获取连接等待超时的时间 -->  
  15.          <property name="maxWait" value="${maxWait}" />  
  16.          <!-- 最小空闲连接数 -->  
  17.          <property name="minIdle" value="${minIdle}" />    
  18.     </bean>    
  19.     <!-- 数据源2 -->  
  20.     <bean id="syncDataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">    
  21.          <property name="url" value="${sync.url}" />    
  22.          <property name="username" value="${sync.username}" />    
  23.          <property name="password" value="${sync.password}" />    
  24.          <property name="driverClassName" value="${sync.driverClassName}" />    
  25.          <property name="filters" value="${filters}" />    
  26.          <property name="maxActive" value="${maxActive}" />  
  27.          <property name="initialSize" value="${initialSize}" />>  
  28.          <property name="maxWait" value="${maxWait}" />  
  29.          <property name="minIdle" value="${minIdle}" />    
  30.     </bean>    
  31.     <!-- 数据源路由 -->  
  32.     <bean id="multipleDataSource" class="com.dataSource.MultipleRoutingDataSource">  
  33.             <!-- 默认数据源 -->  
  34.         <property name="defaultTargetDataSource" ref="dataSource"/>  
  35.                  <!-- 目标数据源 -->  
  36.         <property name="targetDataSources">  
  37.             <map>       
  38.             <!-- 注意这里的value是和上面的DataSource的id对应，key要和  
  39.                            下面的DataSourceContextHolder中的常量对应 -->  
  40.             <entry value-ref="dataSource" key="dataSource"/>  
  41.             <entry value-ref="syncDataSource" key="syncDataSource"/>  
  42.             </map>     
  43.         </property>  
  44.     </bean>  
  45.     <!-- 配置mybatis -->  
  46.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
  47.              <!-- 这里为multipleDataSource，可以统一管理事务 -->  
  48.         <property name="dataSource" ref="multipleDataSource" />  
  49.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>  
  50.         <!-- mapper扫描 -->  
  51.         <property name="mapperLocations" value="classpath:mybatis/*/*.xml"></property>  
  52.         </bean>  
  53.     <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">  
  54.         <constructor-arg ref="sqlSessionFactory" />  
  55.     </bean>  
  56.     <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">     
  57.             <property name="dataSource" ref="multipleDataSource"></property>  
  58.     </bean>  
  59.     <!-- <aop:aspectj-autoproxy proxy-target-class="true" />  -->  
  60. </beans>  

手动测试 下载
Java代码   
  1. @Controller  
  2. @RequestMapping(value="/test")  
  3. public class TestController extends BaseController{  
  4.     private static Logger log = LoggerFactory.getLogger(TestController.class);  
  5.     @Resource(name = "daoSupport")  
  6.     private DaoSupport dao;  
  7.       
  8.     @SuppressWarnings("unchecked")  
  9.     @RequestMapping("/db")  
  10.     public void testDbSource(HttpServletResponse response) throws IOException {  
  11.         log.debug("=======Into testDbSource==============");  
  12.         PageData pd = this.getPageData();  
  13.         try {  
  14.             DataSourceContextHolder.setDataSourceType(DataSourceContextHolder.DATA_SOURCE_LOCAL);  
  15.             List<PageData> lpd = (List<PageData>) dao.findForList("test.list", pd);  
  16.             log.info("=============localDao size:"+lpd.size()+","+DataSourceContextHolder.getDataSourceType());  
  17.             DataSourceContextHolder.clearDataSourceType();  
  18.         } catch (Exception e) {  
  19.             log.error(e.getMessage());  
  20.             e.printStackTrace();  
  21.         }  
  22.         try {  
  23.             DataSourceContextHolder.setDataSourceType(DataSourceContextHolder.DATA_SOURCE_SYNC);  
  24.             List<PageData> lpdTest = (List<PageData>) dao.findForList("test.list", pd);  
  25.             log.info("=============syncDao size:"+lpdTest.size()+","+DataSourceContextHolder.getDataSourceType());  
  26.             DataSourceContextHolder.clearDataSourceType();  
  27.         } catch (Exception e) {  
  28.             log.error(e.getMessage());  
  29.             e.printStackTrace();  
  30.         }  
  31.         response.getWriter().write("test");  
  32.     }  
  33. }  

访问http：//localhost:8080/r/test/db.do控制台输出 
2016-09-21 17:57:13 -40921 [com.controller.test.TestController] INFO    - =============localDao size:5,dataSource 
2016-09-21 17:57:13 -40941 [com.controller.test.TestController] INFO    - =============syncDao size:4,syncDataSource 
上面的方式是手动切换数据源，下面我们通过Spring AOP实现动态切换数据源： 
定义注解 下载
Java代码   
  1. @Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})  
  2. @Retention(RetentionPolicy.RUNTIME)  
  3. @Documented  
  4. public @interface DbSource {  
  5.   
  6.     String value() default "";  
  7.   
  8. }  

定义AOP 
Java代码   
  1. /** 
  2.  * 根据DAO的DbSource的值，动态切换数据源 
  3.  * @author donald 
  4.  * 
  5.  */  
  6. @Aspect  
  7. @Component  
  8. public class DataSourceAspect {  
  9.   
  10.     private static final Logger log = LoggerFactory.getLogger(DataSourceAspect.class);  
  11.         //定义切点  
  12.     @Pointcut("@annotation(com.fh.dataSource.DbSource)")  
  13.     public void dbSourceAspect() {}  
  14.       
  15. /*  @Before("dbSourceAspect()") 
  16.     public void doBefore(JoinPoint joinPoint) { 
  17.         try { 
  18.             System.out.println("Dao-class:" + (joinPoint.getTarget().getClass().getName())); 
  19.             System.out.println("DataSource:" + getDbSourceValue(joinPoint)); 
  20.         } catch (Exception e) { 
  21.             // 记录本地异常日志 
  22.             logger.error("exception", e.getMessage()); 
  23.         } 
  24.     }*/  
  25.         /** 
  26.      * 切换数据源 
  27.      * @param joinPoint 
  28.      */  
  29.     @Around("dbSourceAspect()")  
  30.     public void doAround(ProceedingJoinPoint  joinPoint)  {  
  31.         try {  
  32.             log.info("=============Dao-class:" + (joinPoint.getTarget().getClass().getName()));  
  33.             log.info("=============DataSource:" + getDbSourceValue(joinPoint));  
  34.             joinPoint.proceed();  
  35.             DataSourceContextHolder.clearDataSourceType();  
  36.         }   
  37.         catch(Throwable e){  
  38.             log.error("=============Throwable:", e.getMessage());  
  39.         }  
  40.     }  
  41.  /** 
  42.   * 获取数据源id 
  43.   * @param joinPoint 
  44.   * @return 
  45.   * @throws Exception 
  46.   */  
  47.     @SuppressWarnings({ "rawtypes", "unchecked" })  
  48.     public static String getDbSourceValue(JoinPoint joinPoint) throws Exception {  
  49.         //根据连接点获取class  
  50.         String targetName = joinPoint.getTarget().getClass().getName();  
  51.         Class targetClass = Class.forName(targetName);  
  52. //      DbSource dbSource = (DbSource) targetClass.getAnnotation(DbSource.class);  
  53.         //根据连接点获取method  
  54.         String methodName = joinPoint.getSignature().getName();  
  55.         //根据连接点获取args  
  56.         Object[] arguments = joinPoint.getArgs();  
  57.         Method[] methods = targetClass.getMethods();  
  58.         String dbId ="";  
  59.         //获取注解连接点的值  
  60.         for (Method method : methods) {  
  61.             if (method.getName().equals(methodName)) {  
  62.                 Class[] clazzs = method.getParameterTypes();  
  63.                 if (clazzs.length == arguments.length) {  
  64.                 dbId = method.getAnnotation(DbSource.class).value();  
  65.                 if(!StringUtils.isBlank(dbId)){  
  66.                     DataSourceContextHolder.setDataSourceType(dbId);  
  67.                 }  
  68.                 else{  
  69.                     dbId = DataSourceContextHolder.DATA_SOURCE_LOCAL;  
  70.                     DataSourceContextHolder.setDataSourceType(DataSourceContextHolder.DATA_SOURCE_LOCAL);  
  71.                 }  
  72.                 break;  
  73.              }  
  74.           }  
  75.         }  
  76.         return dbId;  
  77.     }  
  78. }  

wwwp22233
关注
Spring+SpringMVC+Mybatis多数据源
12-15
Spring+SpringMVC+Mybatis多数据源整合。基于spring3.0和mybatis3.2的
Spring+MyBatis多数据源配置实现
weixin_34342578的博客
06-23 108
为什么80%的码农都做不了架构师？>>> ...
DataSource 数据源
最新发布
m0_64473295的博客
08-19 1209
DataSource是 Java 中用于获取数据库连接的标准接口，定义在包中。它的主要职责是创建和管理数据库连接，提供了一种统一的方式去获取连接，同时还可以实现连接池功能以提高性能。创建 DataSource 对象是与数据库交互的基础，它可以帮助我们更高效地管理数据库连接，提高应用程序的性能。通过上述示例，你应该能够理解如何创建 DataSource 并将其用于实际的 Java 应用程序中。如果你还有其他具体的需求或问题，请随时提出。
Spring+MyBatis多数据源配置实现（实操型）
qq_39736103的博客
08-16 290
最近用到了MyBatis配置多数据源，原以为简单配置下就行了，实际操作后发现还是要费些事的，这里记录下，以作备忘 不多废话，直接上代码，后面会有简单的实现介绍 jdbc和log4j的配置 #定义输出格式 ConversionPattern=%d %-5p [%t] %c - %m%n log4j.rootLogger=DEBUG,Console log4j.logger.com.cnbl...
Spring+SpringMVC+Mybatis 多数据源整合
热门推荐
Townkoim的专栏
12-15 4万+
此篇文章是基于Spring3.0和mybatis3.2的 总体大概流程： 1. 拷贝所需jar 2.写一个数据库切换的工具类：DataSourceContextHolder，用来切换数据库 3.写一个DynamicDataSource类来继承AbstractRoutingDataSource，并重写determineCurrentLookupKey（）方法，来达到动态切换数据库 4.
spring+mybatis多数据源
weixin_45059961的博客
10-30 1875
1.使用spring+mybatis构建多数据源 1.1项目环境：spring+mybatis+mysql 依赖如下 依赖注释部分开启后 可以作为SSM项目使用，下图只为测试多数据源 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.7</maven.comp
spring+spring mvc+mybatis框架整合实现超市货物管理系统
01-08
对于MyBatis，我们需要创建`mybatis-config.xml`配置文件，配置数据源、事务管理器以及映射文件的位置。 数据库方面，本系统使用了MySQL，通过MyBatis的SqlSessionFactory和SqlSession对象，我们可以执行SQL语句。`...
详解springboot+mybatis多数据源最简解决方案
08-30
SpringBoot框架中实现多数据源解决方案的常见方法有两种：一种是使用JPA来实现多数据源解决方案，另一种是使用Spring框架自带的多数据源解决方案。然而，这两种方法都有其缺陷，例如JPA需要使用复杂的配置文件，而...
SSM（Spring+SpringMVC+MyBatis）多数据源配置框架
12-05
在多数据源配置中，Spring能够帮助管理不同的数据源，通过配置bean来切换和控制数据源的使用。 **SpringMVC** 是Spring框架的一部分，专为Web开发设计。它简化了模型-视图-控制器（Model-View-Controller，MVC）的...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
4. 配置Mybatis：创建mybatis的全局配置文件，mybatis-config.xml，配置数据源、SqlSessionFactory等，以及Mapper的XML配置文件。 5. 编写DAO层：定义Mapper接口，编写对应的Mapper XML文件，实现SQL语句。 6. 业务...
SpringMVC+Spring+Mybatis集成开发环境
04-28
3. 配置Mybatis，包括数据源、SqlSessionFactory和Mapper接口。 4. 创建Service层，使用Spring的依赖注入获取DAO层对象，实现业务逻辑。 5. 编写Controller层，处理HTTP请求，调用Service层方法，返回响应结果。 ...
Spring+Mybatis实现多数据源
技术人集结地
03-16 923
在我们的项目开发过程中，经常需要在同一个项目中运用多个数据库中的数据资源，所以我们经常会在同一个项目连接多个数据库进行开发，今天我们来实现一下在Spring+Mybatis框架下实现多数据源的配置： 1、项目准备： a、项目中所使用的jar包，该项目通过maven进行jar包的引用 4.0.0.RELEASE 2.5 0.2.15 1.2.2
spring+mybatis整合多数据源
幸运小男神的博客
06-25 1061
本例 SpringBoot 版本：2.3.0.RELEASE，开发工具：IDEA 源码下载地址： 一、创建数据库与表结构数据 CREATE DATABASE `test1` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; USE `test1`; DROP TABLE IF EXISTS `student`; CREATE TABLE `student` ( `id` int(5) NOT NULL AUTO_INCREMENT, `
Spring基于MyBatis实现多数据源
尽力而为！
01-25 1040
理论上来讲，通过mybatis实现多数据源，就是创建出多套mybatis的数据库配置，上述通过两个文件配置了两个不同的数据源。通过新增注解的方式，在业务方法上将相关事务管理器写入，在执行方法时通过aop扫描出相关的事务管理器，然后代理执行具体业务方法，当出现异常时，通过循环事务管理器来回滚事务。对于多数据源情况，单一的事务管理器是无法切换的，@Transactionnal是无法管理多个数据源的，需要配置多个事务管理器TransactionManager。先清空数据库，然后执行save方法后，报错如下。
Spring集成Mybatis多数据源配置
qq_40874285的博客
06-28 1742
既然在整理Mybatis那就把经常用的这个多数据源的笔记也整一下吧。 Spring集成Mybatis在之前就已经提到了。Spring集成Mybatis 集成Mybatis多数据源有两种方式： 1、创建多个SqlSessionFactory，扫描每个SqlSessionFactoryBean对应的包，形成了每个Factory对应一个数据源。 2、创建一个SqlSessionFactory，通过动态切换数据源对象，达到多数据源操作功能。 第一种方式 通过在Spring的配置文件中配置多个SqlSes
dataSource
weixin_30553777的博客
12-05 111
jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql:///db_shiro?serverTimezone=UTC jdbc.username=root jdbc.password=123456 转载于:https://juejin.im/post/5c07be63e51d45561d3c9cc3
DataSource
better_zhang的博客
01-12 1600
1、基础概念 1.1、DriverManager DriverManager（驱动管理器）是由SUN公司实现的，提供了基本的获取连接方式。主要作用是管理注册到DriverManager中的JDBC驱动程序，并根据需要使用JDBC驱动程序建立与数据服务器的连接网络。频繁的进行数据库连接会产生很大的开销。 1.2、DataSource DataSouce（数据源）指定的用于获取数据库连接的规范接口。它存在于javax.sql包中，用来替代DriverManager的方式来...
DataSource数据源
ShaneHolmes
04-29 5325
MySQL专栏 上一篇 主目录 下一篇 目录1 基本概念1.1 数据源DataSource、连接池1.2 连接池思想2 数连接池分类2.1 Hikari连接池2.2 阿里druid 【前言】 我们在进行数据访问都需要配置数据源用来连接数据库。数据源又可以分为两大类：直连的数据源 ...
Spring+MyBatis多数据源配置实战与代码详解
本文将详细介绍如何在Spring+MyBatis的环境中实现多数据源的配置，以提高系统的灵活性和扩展性。 首先，理解Spring和MyBatis之间的关系是关键。Spring是一个强大的轻量级Java IoC（Inversion of Control）和AOP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值