经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
springboot配置多个数据源两种方式实现
来源：jb51　　时间：2022/3/7 16:37:32　　对本文有异议

在我们的实际业务中可能会遇到；在一个项目里面读取多个数据库的数据来进行展示，spring对同时配置多个数据源是支持的。

本文中将展示两种方法来实现这个功能。

springboot+mybatis

第一种方式：

在配置文件中配置多个数据源，然后通过配置类来获取数据源以及mapper相关的扫描配置

pom.xml

  1. <parent>
  2. 		<groupId>org.springframework.boot</groupId>
  3. 		<artifactId>spring-boot-starter-parent</artifactId>
  4. 		<version>1.5.9.RELEASE</version>
  5. 		<relativePath/>
  6. 	</parent>
  7.   <dependencies>
  8.   			<!-- druid数据源驱动 -->
  9. 			<dependency>
  10. 			   <groupId>com.alibaba</groupId>
  11. 			   <artifactId>druid-spring-boot-starter</artifactId>
  12. 			   <version>1.1.0</version>
  13. 			</dependency>
  14.   			<dependency>
  15. 	            <groupId>mysql</groupId>
  16. 	            <artifactId>mysql-connector-java</artifactId>
  17. 	        </dependency>
  18. 			<!--mybatis SpringBoot依赖 -->
  19. 			<dependency>
  20. 			<groupId>org.springframework.boot</groupId>
  21. 			<artifactId>spring-boot-starter-web</artifactId>
  22. 		</dependency>
  23. 		
  24. 		<dependency>
  25. 		    <groupId>org.springframework.boot</groupId>
  26. 		    <artifactId>spring-boot-starter-tomcat</artifactId>
  27. 		    <scope>compile</scope>
  28. 		</dependency>
  29. 		
  30. 		<dependency>
  31. 			<groupId>org.springframework.boot</groupId>
  32. 			<artifactId>spring-boot-starter-test</artifactId>
  33. 		</dependency>
  34. 		
  35. 		<!-- aop依赖 -->
  36. 		<dependency>
  37. 		    <groupId>org.springframework.boot</groupId>
  38. 		    <artifactId>spring-boot-starter-aop</artifactId>
  39. 		</dependency>
  40. 		
  41. 		<!-- mybatis -->
  42. 		<dependency>
  43. 		    <groupId>org.mybatis.spring.boot</groupId>
  44. 		    <artifactId>mybatis-spring-boot-starter</artifactId>
  45. 		    <version>1.3.1</version>
  46. 		</dependency>
  47. 		
  48. 		<!-- 通用mapper -->
  49. 		<dependency>
  50. 		    <groupId>tk.mybatis</groupId>
  51. 		    <artifactId>mapper-spring-boot-starter</artifactId>
  52. 		    <version>1.1.5</version>
  53. 		</dependency>
  54. 			<!-- druid监控依赖 -->
  55. 			<dependency>
  56. 				<groupId>com.alibaba</groupId>
  57. 				<artifactId>druid</artifactId>
  58. 				<version>1.0.28</version>
  59. 			</dependency>
  60.   </dependencies>

application.yml

  1.  spring:
  2.   datasource:
  3.     type: com.alibaba.druid.pool.DruidDataSource
  4.     driverClassName: com.mysql.jdbc.Driver
  5.     
  6.     url: jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=utf8
  7.     username: root
  8.     password: 123456
  9.     
  10.     url2: jdbc:mysql://127.0.0.1:3306/test1?useUnicode=true&characterEncoding=utf8
  11.     username2: root
  12.     password2: 123456

 DruidDBConfig 连接池相关配置

  1. package com.xbz.common.config;
  2.  
  3. import com.alibaba.druid.support.http.StatViewServlet;
  4. import com.alibaba.druid.support.http.WebStatFilter;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  8. import org.springframework.boot.web.servlet.ServletRegistrationBean;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11.  
  12. /**
  13.  * Druid监控
  14.  */
  15. @SuppressWarnings("AlibabaRemoveCommentedCode")
  16. @Configuration
  17. public class DruidDBConfig {
  18.     private Logger logger = LoggerFactory.getLogger(DruidDBConfig.class);
  19.  
  20.     /**
  21.      * 注册ServletRegistrationBean
  22.      * @return
  23.      */
  24.     @Bean
  25.     public ServletRegistrationBean druidServlet() {
  26.         ServletRegistrationBean reg = new ServletRegistrationBean();
  27.         reg.setServlet(new StatViewServlet());
  28.         reg.addUrlMappings("/druid/*");
  29.         reg.addInitParameter("allow", ""); //白名单
  30.         return reg;
  31.     }
  32.  
  33.     /**
  34.      * 注册FilterRegistrationBean
  35.      * @return
  36.      */
  37.     @Bean
  38.     public FilterRegistrationBean filterRegistrationBean() {
  39.         FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
  40.         filterRegistrationBean.setFilter(new WebStatFilter());
  41.         filterRegistrationBean.addUrlPatterns("/*");
  42.         filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
  43.         filterRegistrationBean.addInitParameter("profileEnable", "true");
  44.         filterRegistrationBean.addInitParameter("principalCookieName", "USER_COOKIE");
  45.         filterRegistrationBean.addInitParameter("principalSessionName", "USER_SESSION");
  46.         filterRegistrationBean.addInitParameter("DruidWebStatFilter", "/*");
  47.         return filterRegistrationBean;
  48.     }
  49. }

MasterDbConfig 注意读取数据库连接相关的键，以及扫描实体、mapper等

  1. package com.xbz.common.config;
  2.  
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.beans.factory.annotation.Qualifier;
  10. import org.springframework.beans.factory.annotation.Value;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.context.annotation.Primary;
  14. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  15. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  16.  
  17. import javax.sql.DataSource;
  18. import java.sql.SQLException;
  19.  
  20.  
  21. @Configuration
  22. @MapperScan(basePackages  = MasterDbConfig.PACKAGE , sqlSessionFactoryRef = "masterSqlSessionFactory")
  23. public class MasterDbConfig {
  24.     private Logger logger = LoggerFactory.getLogger(MasterDbConfig.class);
  25.     // 精确到 master 目录，以便跟其他数据源隔离
  26.     static final String PACKAGE = "com.xbz.**.dao.master";
  27.     private static final String MAPPER_LOCATION = "classpath*:mapper/master/*.xml";
  28.     private static final String DOMAIN_PACKAGE = "com.xbz.**.domain";
  29.  
  30.     @Value("${spring.datasource.url}")
  31.     private String dbUrl;
  32.  
  33.     @Value("${spring.datasource.username}")
  34.     private String username;
  35.  
  36.     @Value("${spring.datasource.password}")
  37.     private String password;
  38.  
  39.     @Value("${spring.datasource.driverClassName}")
  40.     private String driverClassName;
  41.  
  42.  
  43.     @Bean(name="masterDataSource")   //声明其为Bean实例
  44.     @Primary  //在同样的DataSource中，首先使用被标注的DataSource
  45.     public DataSource masterDataSource() {
  46.         DruidDataSource datasource = new DruidDataSource();
  47.  
  48.         datasource.setUrl(this.dbUrl);
  49.         datasource.setUsername(username);
  50.         datasource.setPassword(password);
  51.         datasource.setDriverClassName(driverClassName);
  52.  
  53.         return datasource;
  54.     }
  55.  
  56.     @Bean(name = "masterTransactionManager")
  57.     @Primary
  58.     public DataSourceTransactionManager masterTransactionManager() {
  59.         return new DataSourceTransactionManager(masterDataSource());
  60.     }
  61.  
  62.     @Bean(name = "masterSqlSessionFactory")
  63.     @Primary
  64.     public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource masterDataSource)
  65.             throws Exception {
  66.         final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
  67.         sessionFactory.setDataSource(masterDataSource);
  68.         sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
  69.                 .getResources(MasterDbConfig.MAPPER_LOCATION));
  70.         sessionFactory.setTypeAliasesPackage(DOMAIN_PACKAGE);
  71.         //mybatis 数据库字段与实体类属性驼峰映射配置
  72.         sessionFactory.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
  73.         return sessionFactory.getObject();
  74.     }
  75. }

ClusterDbConfig 

  1. package com.xbz.common.config;
  2.  
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.beans.factory.annotation.Qualifier;
  10. import org.springframework.beans.factory.annotation.Value;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  14. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  15.  
  16. import javax.sql.DataSource;
  17. import java.sql.SQLException;
  18.  
  19. /**
  20.  * 从数据源配置
  21.  * 若需要配置更多数据源 , 直接在yml中添加数据源配置再增加相应的新的数据源配置类即可
  22.  */
  23. @Configuration
  24. @MapperScan(basePackages  = ClusterDbConfig.PACKAGE , sqlSessionFactoryRef = "clusterSqlSessionFactory")
  25. public class ClusterDbConfig {
  26.     private Logger logger = LoggerFactory.getLogger(ClusterDbConfig.class);
  27.     // 精确到 cluster 目录，以便跟其他数据源隔离
  28.     static final String PACKAGE = "com.xbz.**.dao.cluster";
  29.     private static final String MAPPER_LOCATION = "classpath*:mapper/cluster/*.xml";
  30.     private static final String DOMAIN_PACKAGE = "com.xbz.**.domain";
  31.  
  32.     @Value("${spring.datasource.url2}")
  33.     private String dbUrl;
  34.  
  35.     @Value("${spring.datasource.username2}")
  36.     private String username;
  37.  
  38.     @Value("${spring.datasource.password2}")
  39.     private String password;
  40.  
  41.     @Value("${spring.datasource.driverClassName}")
  42.     private String driverClassName;
  43.  
  44.     
  45.  
  46.     @Bean(name="clusterDataSource")   //声明其为Bean实例
  47.     public DataSource clusterDataSource() {
  48.         DruidDataSource datasource = new DruidDataSource();
  49.  
  50.         datasource.setUrl(this.dbUrl);
  51.         datasource.setUsername(username);
  52.         datasource.setPassword(password);
  53.         datasource.setDriverClassName(driverClassName);
  54.         return datasource;
  55.     }
  56.  
  57.     @Bean(name = "clusterTransactionManager")
  58.     public DataSourceTransactionManager clusterTransactionManager() {
  59.         return new DataSourceTransactionManager(clusterDataSource());
  60.     }
  61.  
  62.     @Bean(name = "clusterSqlSessionFactory")
  63.     public SqlSessionFactory clusterSqlSessionFactory(@Qualifier("clusterDataSource") DataSource culsterDataSource)
  64.             throws Exception {
  65.         final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
  66.         sessionFactory.setDataSource(culsterDataSource);
  67.         sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
  68.                 .getResources(ClusterDbConfig.MAPPER_LOCATION));
  69.         sessionFactory.setTypeAliasesPackage(DOMAIN_PACKAGE);
  70.         //mybatis 数据库字段与实体类属性驼峰映射配置
  71.         sessionFactory.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
  72.         return sessionFactory.getObject();
  73.     }
  74. }

不同的数据源配置不佟的mapper扫描位置，然后需要哪一个数据源就注入哪一个mapper接口即可

这样获取的数据就是来自不同的数据源了，这种方法比较简单。

方法二

配置一个默认使用的数据源，然后定义多个其他的数据源，使用aop形成注解式选择数据源

  1. # 默认数据源
  2.  
  3. spring:
  4.   datasource:
  5.     druid:
  6.       # 数据库访问配置, 使用druid数据源 
  7.       type: com.alibaba.druid.pool.DruidDataSource
  8.       driverClassName: com.mysql.jdbc.Driver
  9.       url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
  10.       username: root
  11.       password: 123456
  12.  
  13. # 其他数据源
  14.  
  15. custom:
  16.   datasource:
  17.     druid:
  18.        type: com.alibaba.druid.pool.DruidDataSource
  19.        names: fishlog,fishgame
  20.        fishlog:
  21.          driverClassName: com.mysql.jdbc.Driver
  22.          url: jdbc:mysql://127.0.0.1:3306/test1?useUnicode=true&characterEncoding=utf8
  23.          username: root
  24.          password: 123456
  25.        fishgame:
  26.          driverClassName: com.mysql.jdbc.Driver
  27.          url: jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=utf8
  28.          username: root
  29.          password: 123456

然后启动类中注入注解

注解类及参数value TargetDataSource 

  1. package com.sysmg.common.config.datasoure;
  2.  
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  8.  
  9. @Target({ ElementType.METHOD, ElementType.TYPE })
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented
  12. public @interface TargetDataSource {
  13. 	String value();
  14. }

 DynamicDataSource 

  1. package com.sysmg.common.config.datasoure;
  2.  
  3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
  4.  
  5. public class DynamicDataSource extends AbstractRoutingDataSource {
  6.  
  7. 	@Override
  8. 	protected Object determineCurrentLookupKey() {
  9. 		return DynamicDataSourceContextHolder.getDataSourceType();
  10. 	}
  11.  
  12. }

DynamicDataSourceAspect切面实现

  1. package com.sysmg.common.config.datasoure;
  2.  
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Before;
  7. import org.springframework.core.annotation.Order;
  8. import org.springframework.stereotype.Component;
  9.  
  10. @Aspect
  11. @Order(-10) // 保证该AOP在@Transactional之前执行
  12. @Component
  13. public class DynamicDataSourceAspect {
  14. 	@Before("@annotation(targetDataSource)")
  15. 	public void changeDataSource(JoinPoint point, TargetDataSource targetDataSource) throws Throwable {
  16. 		String dsId = targetDataSource.value();
  17. 		if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {
  18. 			System.err.println("数据源[{}]不存在，使用默认数据源 > {}" + targetDataSource.value() + point.getSignature());
  19. 		} else {
  20. 			System.out.println("UseDataSource : {} > {}" + targetDataSource.value() + point.getSignature());
  21. 			DynamicDataSourceContextHolder.setDataSourceType(targetDataSource.value());
  22. 		}
  23. 	}
  24.  
  25. 	@After("@annotation(targetDataSource)")
  26. 	public void restoreDataSource(JoinPoint point, TargetDataSource targetDataSource) {
  27. 		System.out.println("RevertDataSource : {} > {}"+targetDataSource.value()+point.getSignature());
  28. 		DynamicDataSourceContextHolder.clearDataSourceType();
  29. 	}
  30. }

DynamicDataSourceContextHolder

  1. package com.sysmg.common.config.datasoure;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. import java.util.List;
  6.  
  7. public class DynamicDataSourceContextHolder {
  8. 	private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
  9. 	public static List<String> dataSourceIds = new ArrayList<String>();
  10.  
  11. 	public static void setDataSourceType(String dataSourceType) {
  12. 		contextHolder.set(dataSourceType);
  13. 	}
  14.  
  15. 	public static String getDataSourceType() {
  16. 		return contextHolder.get();
  17. 	}
  18.  
  19. 	public static void clearDataSourceType() {
  20. 		contextHolder.remove();
  21. 	}
  22.  
  23. 	public static boolean containsDataSource(String dataSourceId){
  24. 		return dataSourceIds.contains(dataSourceId);
  25. 	}
  26. }

DynamicDataSourceRegister数据源注册类

  1. package com.sysmg.common.config.datasoure;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import javax.sql.DataSource;
  6. import org.springframework.beans.MutablePropertyValues;
  7. import org.springframework.beans.PropertyValues;
  8. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  9. import org.springframework.beans.factory.support.GenericBeanDefinition;
  10. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
  11. import org.springframework.boot.bind.RelaxedDataBinder;
  12. import org.springframework.boot.bind.RelaxedPropertyResolver;
  13. import org.springframework.context.EnvironmentAware;
  14. import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
  15. import org.springframework.core.convert.ConversionService;
  16. import org.springframework.core.convert.support.DefaultConversionService;
  17. import org.springframework.core.env.Environment;
  18. import org.springframework.core.type.AnnotationMetadata;
  19.  
  20. public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {
  21. 	private static final Object DATASOURCE_TYPE_DEFAULT = "com.alibaba.druid.pool.DruidDataSource";
  22. 	private ConversionService conversionService = new DefaultConversionService();
  23. 	private PropertyValues dataSourcePropertyValues;
  24. 	private DataSource defaultDataSource;
  25. 	private Map<String, DataSource> customDataSources = new HashMap<String, DataSource>();
  26.  
  27. 	@Override
  28. 	public void setEnvironment(Environment environment) {
  29. 		System.out.println("DynamicDataSourceRegister.setEnvironment()");
  30. 		initDefaultDataSource(environment);
  31. 		initCustomDataSources(environment);
  32. 	}
  33.  
  34. 	private void initDefaultDataSource(Environment env) {
  35. 		RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, "spring.datasource.druid.");
  36. 		Map<String, Object> dsMap = new HashMap<String, Object>();
  37. 		dsMap.put("type", propertyResolver.getProperty("type"));
  38. 		dsMap.put("driverClassName", propertyResolver.getProperty("driverClassName"));
  39. 		dsMap.put("url", propertyResolver.getProperty("url"));
  40. 		dsMap.put("username", propertyResolver.getProperty("username"));
  41. 		dsMap.put("password", propertyResolver.getProperty("password"));
  42. 		defaultDataSource = buildDataSource(dsMap);
  43. 		dataBinder(defaultDataSource, env);
  44. 	}
  45.  
  46. 	private void initCustomDataSources(Environment env) {
  47. 		RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, "custom.datasource.druid.");
  48. 		String dsPrefixs = propertyResolver.getProperty("names");
  49. 		for (String dsPrefix : dsPrefixs.split(",")) {// 多个数据源
  50. 			Map<String, Object> dsMap = propertyResolver.getSubProperties(dsPrefix + ".");
  51. 			DataSource ds = buildDataSource(dsMap);
  52. 			customDataSources.put(dsPrefix, ds);
  53. 			dataBinder(ds, env);
  54. 		}
  55. 	}
  56.  
  57. 	@SuppressWarnings("unchecked")
  58. 	public DataSource buildDataSource(Map<String, Object> dsMap) {
  59. 		Object type = dsMap.get("type");
  60. 		if (type == null) {
  61. 			type = DATASOURCE_TYPE_DEFAULT;// 默认DataSource
  62. 		}
  63. 		Class<? extends DataSource> dataSourceType;
  64. 		try {
  65. 			dataSourceType = (Class<? extends DataSource>) Class.forName((String) type);
  66. 			String driverClassName = dsMap.get("driverClassName").toString();
  67. 			String url = dsMap.get("url").toString();
  68. 			String username = dsMap.get("username").toString();
  69. 			String password = dsMap.get("password").toString();
  70. 			DataSourceBuilder factory = DataSourceBuilder.create().driverClassName(driverClassName).url(url)
  71. 					.username(username).password(password).type(dataSourceType);
  72. 			return factory.build();
  73. 		} catch (ClassNotFoundException e) {
  74. 			e.printStackTrace();
  75. 		}
  76. 		return null;
  77. 	}
  78.  
  79. 	private void dataBinder(DataSource dataSource, Environment env) {
  80. 		RelaxedDataBinder dataBinder = new RelaxedDataBinder(dataSource);
  81. 		dataBinder.setConversionService(conversionService);
  82. 		dataBinder.setIgnoreNestedProperties(false);// false
  83. 		dataBinder.setIgnoreInvalidFields(false);// false
  84. 		dataBinder.setIgnoreUnknownFields(true);// true
  85. 		if (dataSourcePropertyValues == null) {
  86. 			Map<String, Object> rpr = new RelaxedPropertyResolver(env, "spring.datasource").getSubProperties(".");
  87. 			Map<String, Object> values = new HashMap<>(rpr);
  88. 			values.remove("type");
  89. 			values.remove("driverClassName");
  90. 			values.remove("url");
  91. 			values.remove("username");
  92. 			values.remove("password");
  93. 			dataSourcePropertyValues = new MutablePropertyValues(values);
  94. 		}
  95. 		dataBinder.bind(dataSourcePropertyValues);
  96. 	}
  97.  
  98. 	@Override
  99. 	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  100. 		System.out.println("DynamicDataSourceRegister.registerBeanDefinitions()");
  101. 		Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
  102. 		targetDataSources.put("dataSource", defaultDataSource);
  103. 		DynamicDataSourceContextHolder.dataSourceIds.add("dataSource");
  104. 		targetDataSources.putAll(customDataSources);
  105. 		for (String key : customDataSources.keySet()) {
  106. 			DynamicDataSourceContextHolder.dataSourceIds.add(key);
  107. 		}
  108. 		GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
  109. 		beanDefinition.setBeanClass(DynamicDataSource.class);
  110. 		beanDefinition.setSynthetic(true);
  111. 		MutablePropertyValues mpv = beanDefinition.getPropertyValues();
  112. 		mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);
  113. 		mpv.addPropertyValue("targetDataSources", targetDataSources);
  114. 		registry.registerBeanDefinition("dataSource", beanDefinition);
  115. 	}
  116. }

这里使用的时候把需要使用的表名注入，如果是默认的数据源，则不需要加这个注解，具体的springboot自定义注解的建立，可参考https://www.jb51.net/article/239952.htm，这里的mapper文件和实体扫描可以跟默认的数据源配置相同即可

到此这篇关于springboot配置多个数据源两种方式实现的文章就介绍到这了,更多相关springboot配置多个数据源内容请搜索w3xue以前的文章或继续浏览下面的相关文章希望大家以后多多支持w3xue！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring热门文章

  • 解决springboot+activemq启动报注解错误的问题
  • Springboot整合Rabbitmq之Confirm和Return机制
  • SpringBoot SpringEL表达式的使用
  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)
  • Spring源码：Bean生命周期（终章）
  • Springboot-Management的项目实践
  • 解决springboot 启动找不到主类的问题
  • Spring5路径匹配器PathPattern解析
  • SpringAOP如何获取方法参数上的注解
  • java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

    • Spring推荐文章

  • SpringBoot Session共享，配置不生效问题排查 → 你竟然在代码里下毒！
  • 【Spring源码分析】Spring Scope功能中的动态代理 - Scoped Proxy
  • Spring AOP概念及原理
  • SpringBoot2.7还是任性的，就是不支持Logback1.3，你能奈他何
  • SpringBoot+ Sharding Sphere 轻松实现数据库字段加解密
  • Spring MVC 中视图的实现原理，在Spring MVC 中实现重定向和转发，以及访问静态资源 - Rainbow-Sea
  • Spring MVC 中 HttpMessageConverter 转换器 - Rainbow-Sea
  • SpringBoot+mail 轻松实现各类邮件自动推送
  • Spring MVC 获取三个域(request请求域，session 会话域，application 应用域)对象的方式 - Rainbow-Sea
  • SpringBoot3整合SpringDoc实现在线接口文档

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号