devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring boot 多数据源配置(分配置文件和数据库表两种情况)_springboot多数据源配置保存在主数据库

作者：我家小花儿 | 2024-06-25 18:06:38

赞

踩

springboot多数据源配置保存在主数据库
由于项目有很多数据源需要配置，所以参考网上的资料研究了下。现在有2种实现方案，一种是数据源信息在项目中不会很多就2-3个那种，那就直接读取配置文件就行了，还有一种是有很多数据源的那种成百上千的可以考虑写到数据表中。
一、配置在配置文件中使用方法
1、配置文件application.properties( 需要注意所有数据源共享主数据源的其它属性配置，如果需要不同的数据源配置不同的数据源配置，需要修改代码) 
# 数据库访问配置
# 主数据源，默认的
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url= jdbc:mysql://127.0.0.1:3306/test0?useUnicode=true&characterEncoding=UTF-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root1234

# 更多数据源
com.pgl.edi.datasource.names=test1,test2 

com.pgl.edi.datasource.test1.type=com.alibaba.druid.pool.DruidDataSource
com.pgl.edi.datasource.test1.driver-class-name=com.mysql.jdbc.Driver
com.pgl.edi.datasource.test1.url=jdbc:mysql://127.0.0.1:3306/test1?useUnicode=true&characterEncoding=UTF-8
com.pgl.edi.datasource.test1.username=root
com.pgl.edi.datasource.test1.password=root1234

com.pgl.edi.datasource.test2.type=com.alibaba.druid.pool.DruidDataSource
com.pgl.edi.datasource.test2.driver-class-name=com.mysql.jdbc.Driver
com.pgl.edi.datasource.test2.url= jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=UTF-8
com.pgl.edi.datasource.test2.username=root
com.pgl.edi.datasource.test2.password=root1234
# 下面为连接池的补充设置，应用到上面所有数据源中
# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM t_user
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=true
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,log4j
2、然后是注册数据源类DynamicDataSourceRegister 如下 
  1. import java.util.HashMap;
  2. import java.util.Map;
  3.  
  4. import javax.sql.DataSource;
  5.  
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.MutablePropertyValues;
  9. import org.springframework.beans.PropertyValues;
  10. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  11. import org.springframework.beans.factory.support.GenericBeanDefinition;
  12. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
  13. import org.springframework.boot.bind.RelaxedDataBinder;
  14. import org.springframework.boot.bind.RelaxedPropertyResolver;
  15. import org.springframework.context.EnvironmentAware;
  16. import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
  17. import org.springframework.core.convert.ConversionService;
  18. import org.springframework.core.convert.support.DefaultConversionService;
  19. import org.springframework.core.env.Environment;
  20. import org.springframework.core.type.AnnotationMetadata;
  21.  
  22. /**
  23.  * 
  24.  * 功能描述：动态数据源注册 
  25.  * 启动动态数据源请在启动类中（如Start）
  26.  * 添加 @Import(DynamicDataSourceRegister.class)
  27.  */
  28. public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {
  29.  
  30. 	private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);
  31.  
  32. 	private ConversionService conversionService = new DefaultConversionService();
  33. 	private PropertyValues dataSourcePropertyValues;
  34.  
  35. 	// 如配置文件中未指定数据源类型，使用该默认值
  36. 	private static final Object DATASOURCE_TYPE_DEFAULT = "org.apache.tomcat.jdbc.pool.DataSource";
  37. 	 
  38.  
  39. 	// 数据源
  40. 	private DataSource defaultDataSource;
  41. 	private Map<String, DataSource> customDataSources = new HashMap<>();
  42.  
  43. 	@Override
  44. 	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  45. 		Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
  46. 		// 将主数据源添加到更多数据源中
  47. 		targetDataSources.put("dataSource", defaultDataSource);
  48. 		DynamicDataSourceContextHolder.dataSourceIds.add("dataSource");
  49. 		// 添加更多数据源
  50. 		targetDataSources.putAll(customDataSources);
  51. 		for (String key : customDataSources.keySet()) {
  52. 			DynamicDataSourceContextHolder.dataSourceIds.add(key);
  53. 		}
  54.  
  55. 		// 创建DynamicDataSource
  56. 		GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
  57. 		beanDefinition.setBeanClass(DynamicDataSource.class);
  58. 		beanDefinition.setSynthetic(true);
  59. 		MutablePropertyValues mpv = beanDefinition.getPropertyValues();
  60. 		mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);
  61. 		mpv.addPropertyValue("targetDataSources", targetDataSources);
  62. 		registry.registerBeanDefinition("dataSource", beanDefinition);
  63.  
  64. 		logger.info("Dynamic DataSource Registry");
  65. 	}
  66.  
  67. 	/**
  68. 	 * 创建DataSource
  69. 	 *
  70. 	 * @param type
  71. 	 * @param driverClassName
  72. 	 * @param url
  73. 	 * @param username
  74. 	 * @param password
  75. 	 * @return
  76. 	 */
  77. 	@SuppressWarnings("unchecked")
  78. 	public DataSource buildDataSource(Map<String, Object> dsMap) {
  79. 		try {
  80. 			Object type = dsMap.get("type");
  81. 			if (type == null)
  82. 				type = DATASOURCE_TYPE_DEFAULT;// 默认DataSource
  83.  
  84. 			Class<? extends DataSource> dataSourceType;
  85. 			dataSourceType = (Class<? extends DataSource>) Class.forName((String) type);
  86.  
  87. 			String driverClassName = dsMap.get("driver-class-name").toString();
  88. 			String url = dsMap.get("url").toString();
  89. 			String username = dsMap.get("username").toString();
  90. 			String password = dsMap.get("password").toString();
  91.  
  92. 			DataSourceBuilder factory = DataSourceBuilder.create().driverClassName(driverClassName).url(url)
  93. 					.username(username).password(password).type(dataSourceType);
  94. 			return factory.build();
  95. 		} catch (ClassNotFoundException e) {
  96. 			e.printStackTrace();
  97. 		}
  98. 		return null;
  99. 	}
  100.  
  101. 	/**
  102. 	 * 加载多数据源配置
  103. 	 */
  104. 	@Override
  105. 	public void setEnvironment(Environment env) {
  106. 		initDefaultDataSource(env);
  107. 		initCustomDataSources(env);
  108. 	}
  109.  
  110. 	/**
  111. 	 * 初始化主数据源
  112. 	 *
  113. 	 */
  114. 	private void initDefaultDataSource(Environment env) {
  115. 		// 读取主数据源
  116. 		RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, "spring.datasource.");
  117. 		Map<String, Object> dsMap = new HashMap<>();
  118. 		dsMap.put("type", propertyResolver.getProperty("type"));
  119. 		dsMap.put("driver-class-name", propertyResolver.getProperty("driver-class-name"));
  120. 		dsMap.put("url", propertyResolver.getProperty("url"));
  121. 		dsMap.put("username", propertyResolver.getProperty("username"));
  122. 		dsMap.put("password", propertyResolver.getProperty("password"));
  123.  
  124. 		defaultDataSource = buildDataSource(dsMap);
  125.  
  126. 		dataBinder(defaultDataSource, env);
  127. 	}
  128.  
  129. 	/**
  130. 	 * 为DataSource绑定更多数据
  131. 	 *
  132. 	 * @param dataSource
  133. 	 * @param env
  134. 	 */
  135. 	private void dataBinder(DataSource dataSource, Environment env) {
  136. 		RelaxedDataBinder dataBinder = new RelaxedDataBinder(dataSource);
  137. 		// dataBinder.setValidator(new
  138. 		// LocalValidatorFactory().run(this.applicationContext));
  139. 		dataBinder.setConversionService(conversionService);
  140. 		dataBinder.setIgnoreNestedProperties(false);// false
  141. 		dataBinder.setIgnoreInvalidFields(false);// false
  142. 		dataBinder.setIgnoreUnknownFields(true);// true
  143. 		if (dataSourcePropertyValues == null) {
  144. 			Map<String, Object> rpr = new RelaxedPropertyResolver(env, "spring.datasource").getSubProperties(".");
  145. 			Map<String, Object> values = new HashMap<>(rpr);
  146. 			// 排除已经设置的属性
  147. 			values.remove("type");
  148. 			values.remove("driver-class-name");
  149. 			values.remove("url");
  150. 			values.remove("username");
  151. 			values.remove("password");
  152. 			dataSourcePropertyValues = new MutablePropertyValues(values);
  153. 		}
  154. 		dataBinder.bind(dataSourcePropertyValues);
  155. 	}
  156.  
  157. 	/**
  158. 	 * 初始化更多数据源
  159. 	 *
  160. 	 */
  161. 	private void initCustomDataSources(Environment env) {
  162. 		// 读取配置文件获取更多数据源，也可以通过defaultDataSource读取数据库获取更多数据源
  163. 		RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, "com.pgl.edi.datasource.");//这里写自己的配置的数据源前缀
  164. 		String dsPrefixs = propertyResolver.getProperty("names");//根据自己定义的获取数据源key
  165. 		for (String dsPrefix : dsPrefixs.split(",")) {// 多个数据源
  166. 			Map<String, Object> dsMap = propertyResolver.getSubProperties(dsPrefix + ".");
  167. 			DataSource ds = buildDataSource(dsMap);
  168. 			customDataSources.put(dsPrefix, ds);
  169. 			dataBinder(ds, env);
  170. 		}
  171. 	}
  172.  
  173. }
上面是注册多数据源代码，下面是如何使用数据源需要以下几个类DynamicDataSourceContextHolder、DynamicDataSourceAspect、DynamicDataSource、DataSource。 
  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4.  
  5. public class DynamicDataSourceContextHolder {
  6. 	private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
  7. 	public static List<String> dataSourceIds = new ArrayList<>();
  8.  
  9. 	public static void setDataSourceType(String dataSourceType) {
  10. 		contextHolder.set(dataSourceType);
  11. 	}
  12.  
  13. 	public static String getDataSourceType() {
  14. 		return contextHolder.get();
  15. 	}
  16.  
  17. 	public static void clearDataSourceType() {
  18. 		contextHolder.remove();
  19. 	}
  20.  
  21. 	/**
  22. 	 * 判断指定DataSrouce当前是否存在
  23. 	 *
  24. 	 * @param dataSourceId
  25. 	 * @return	
  26. 	 */
  27. 	public static boolean containsDataSource(String dataSourceId) {
  28. 		return dataSourceIds.contains(dataSourceId);
  29. 	}
  30. }
  1. import org.aspectj.lang.JoinPoint;
  2. import org.aspectj.lang.annotation.After;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.annotation.Before;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.core.annotation.Order;
  8. import org.springframework.stereotype.Component;
  9.  
  10. @Aspect
  11. @Order(-1)// 保证该AOP在@Transactional之前执行
  12. @Component
  13. public class DynamicDataSourceAspect {
  14. 	private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
  15.  
  16.     @Before("@annotation(ds)")
  17.     public void changeDataSource(JoinPoint point, DataSource ds) throws Throwable {
  18.         String dsId = ds.name();
  19.         if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {
  20.             logger.error("数据源[{}]不存在，使用默认数据源 > {}", ds.name(), point.getSignature());
  21.         } else {
  22.             logger.debug("Use DataSource : {} > {}", ds.name(), point.getSignature());
  23.             DynamicDataSourceContextHolder.setDataSourceType(ds.name());
  24.         }
  25.     }
  26.  
  27.     @After("@annotation(ds)")
  28.     public void restoreDataSource(JoinPoint point, DataSource ds) {
  29.         logger.debug("Revert DataSource : {} > {}", ds.name(), point.getSignature());
  30.         DynamicDataSourceContextHolder.clearDataSourceType();
  31.     }
  32. }
  1. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
  2.  
  3.  
  4. public class DynamicDataSource extends AbstractRoutingDataSource {
  5.  
  6. 	@Override
  7. 	protected Object determineCurrentLookupKey() {
  8. 		  return DynamicDataSourceContextHolder.getDataSourceType();
  9. 	}
  10.  
  11. }
  1. mport java.lang.annotation.Documented;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6.  
  7. @Target({ ElementType.METHOD, ElementType.TYPE })
  8. @Retention(RetentionPolicy.RUNTIME)
  9. @Documented
  10. public @interface DataSource {
  11. 	String name();
  12. }
以上就是这四个类的代码。使用的时候需要注意在启动类上使用@Import(DynamicDataSourceRegister.class)，在要使用方法用注解的方式@DataSource(name="test1")，这样就可以使用了。如果没有指定数据源则使用默认数据源。还有一点配置文件中的names就是我们所使用数据源的key。
二、数据源信息配置在数据库中
1、配置主数据源，主数据源主要是访问存储其他数据源信息的。 
# 主数据源，默认的
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url= jdbc:mysql://127.0.0.1:3306/test0?useUnicode=true&characterEncoding=UTF-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root1234
然后建立数据库dataource表如下 
  1. CREATE TABLE `datasource` (
  2.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  3.   `type` varchar(255) COLLATE utf8_bin NOT NULL COMMENT '数据源类型',
  4.   `driver_class_name` varchar(255) COLLATE utf8_bin NOT NULL COMMENT '数据库驱动类',
  5.   `url` varchar(255) COLLATE utf8_bin NOT NULL COMMENT '连接url',
  6.   `username` varchar(255) COLLATE utf8_bin NOT NULL COMMENT '用户名',
  7.   `password` varchar(255) COLLATE utf8_bin NOT NULL COMMENT '密码',
  8.   `rmark` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '备注',
  9.   `dsname` varchar(255) COLLATE utf8_bin NOT NULL COMMENT '数据源名称',
  10.   `status` varchar(255) COLLATE utf8_bin NOT NULL DEFAULT '1' COMMENT '状态',
  11.   PRIMARY KEY (`id`)
  12. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
在项目配置文件配置datasource表所在数据库信息，在这里也可以配置数据源的其他信息，比如初始化大小、最大连接大小等信息。( 需要注意所有数据源共享主数据源的其它属性配置，如果需要不同的数据源配置不同的数据源配置，需要修改代码)。需要修改的地方就一个DynamicDataSourceRegister类中initCustomDataSources方法需要修改为如下 
  1. private void initCustomDataSources(Environment env) {
  2. 		// 读取库表中datasource获取更多数据源
  3. 		Map<String, Map<String, Object>> customInfo=getCustomDataSourceInfo();
  4. 		for (String key : customInfo.keySet()) {  
  5. 		    Map<String, Object> dsMap = customInfo.get(key);  
  6. 		    DataSource ds = buildDataSource(dsMap);
  7. 			customDataSources.put(key, ds);
  8. 			dataBinder(ds, env); 
  9. 		}  
  10. 	}
  11.  
  12. 	private Map<String, Map<String, Object>> getCustomDataSourceInfo() {
  13. 		Map<String, Map<String, Object>> customMap = new HashMap<>();
  14. 		String sql = "select type,`driver_class_name`,url,username,`password`,`dsname` from datasource where status=1";
  15. 		JdbcTemplate jdbcTemplate=new JdbcTemplate(defaultDataSource);
  16. 		List<DataSourceInfo> infos=jdbcTemplate.query(sql, new RowMapper<DataSourceInfo>() {
  17. 			@Override
  18. 			public DataSourceInfo mapRow(ResultSet rs, int rowNum) throws SQLException {
  19. 				DataSourceInfo info=new DataSourceInfo();
  20. 				info.setType(rs.getString("type"));
  21. 				info.setDriverClassName(rs.getString("driver_class_name"));
  22. 				info.setUrl(rs.getString("url"));
  23. 				info.setPassword(rs.getString("password"));
  24. 				info.setUsername(rs.getString("username"));
  25. 				info.setDsName(rs.getString("dsname"));
  26. 				return info;
  27. 			}
  28. 		});
  29. 		for(DataSourceInfo info:infos) {
  30. 			Map<String, Object> dsMap = new HashMap<>();
  31. 			dsMap.put("type", info.getType());
  32. 			dsMap.put("driver-class-name", info.getDriverClassName());
  33. 			dsMap.put("url", info.getUrl());
  34. 			dsMap.put("username", info.getUsername());
  35. 			dsMap.put("password", info.getPassword());
  36. 			customMap.put(info.getDsName(), dsMap);
  37. 		}
  38. 		return customMap;
  39. 	}
使用方式和第一种一样。
在很多时候我们可能不喜欢用注解的方式指定使用的数据源，我们可以修改DynamicDataSourceAspect类可以使用如下配置 
  1. @Aspect
  2. @Order(-10) // 保证该AOP在@Transactional之前执行
  3. @Component
  4. public class DynamicDataSourceAspect {
  5. 	private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
  6.         //由于我项目中使用方法名后缀是FromDB进入AOP处理且默认第一个参数为使用数据源的key
  7.   	//这里可以自己修改想要以什么方式匹配使用数据源
  8. 	@Pointcut("execution(* com.pgl.demo.service.impl..*.*FromDB(..))")
  9. 	public void excude() {
  10. 	}
  11.  
  12. 	@Before("excude()")
  13. 	public void changeDataSource(JoinPoint point) throws Throwable {
  14. 	
  15. 		Object obj = point.getArgs()[0];
  16. 		if(obj instanceof String) {
  17. 			String dsName=obj.toString();
  18. 			if (!DynamicDataSourceContextHolder.containsDataSource(dsName)) {
  19. 				logger.error("数据源[{}]不存在，使用默认数据源 > {}", obj, point.getSignature());
  20. 				throw new Throwable("数据源["+dsName+"]不存在");
  21. 			} else {
  22. 				logger.info("Use DataSource : {} > {}", dsName, point.getSignature());
  23. 				DynamicDataSourceContextHolder.setDataSourceType(dsName);
  24. 			}
  25. 			logger.info("-----------args DataSource : {} > {}", dsName, point.getSignature());
  26. 		}else {
  27. 			logger.error("数据源[{}]不存在", obj);
  28. 			 throw new Throwable("数据源["+obj+"]不存在");
  29. 		}
  30. 		
  31. 	}
  32.  
  33. 	
  34. 	@After("excude()")
  35. 	public void restoreDataSource(JoinPoint point) {
  36. 		Object obj = point.getArgs()[0];
  37. 		 logger.info("Revert DataSource : {} > {}", obj.toString(), point.getSignature());
  38. 		 DynamicDataSourceContextHolder.clearDataSourceType();
  39. 	}
  40. }
使用这种方式的话要拦截的方法必须不能private的。













声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/756999
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号