Spring动态注册多数据源的实现方法

上一篇 / 下一篇  2018-03-14 14:01:18 / 个人分类：软件开发

查看( 1575 ) / 评论( 0 ) / 评分( 0 / 0 )

最近在做SaaS应用，数据库采用了单实例多schema的架构（详见参考资料1），每个租户有一个独立的schema，同时整个数据源有一个共享的schema，因此需要解决动态增删、切换数据源的问题。

在网上搜了很多文章后，很多都是讲主从数据源配置，或都是在应用启动前已经确定好数据源配置的，甚少讲在不停机的情况如何动态加载数据源，所以写下这篇文章，以供参考。

使用到的技术

  • Java8
  • Spring + SpringMVC + MyBatis
  • Druid连接池
  • Lombok
  • （以上技术并不影响思路实现，只是为了方便浏览以下代码片段）

思路

当一个请求进来的时候，判断当前用户所属租户，并根据租户信息切换至相应数据源，然后进行后续的业务操作。

代码实现

  2. TenantConfigEntity（租户信息）
  3. @EqualsAndHashCode(callSuper = false)
  4. @Data
  5. @FieldDefaults(level = AccessLevel.PRIVATE)
  6. public class TenantConfigEntity {
  7. /**
  8. * 租户id
  9. **/
  10. Integer tenantId;
  11. /**
  12. * 租户名称
  13. **/
  14. String tenantName;
  15. /**
  16. * 租户名称key
  17. **/
  18. String tenantKey;
  19. /**
  20. * 数据库url
  21. **/
  22. String dbUrl;
  23. /**
  24. * 数据库用户名
  25. **/
  26. String dbUser;
  27. /**
  28. * 数据库密码
  29. **/
  30. String dbPassword;
  31. /**
  32. * 数据库public_key
  33. **/
  34. String dbPublicKey;
  35. }
  36. DataSourceUtil（辅助工具类，非必要）
  37. public class DataSourceUtil {
  38. private static final String DATA_SOURCE_BEAN_KEY_SUFFIX = "_data_source";
  39. private static final String JDBC_URL_ARGS = "?useUnicode=true&characterEncoding=UTF-8&useOldAliasMetadataBehavior=true&zeroDateTimeBehavior=convertToNull";
  40. private static final String CONNECTION_PROPERTIES = "config.decrypt=true;config.decrypt.key=";
  41. /**
  42. * 拼接数据源的spring bean key
  43. */
  44. public static String getDataSourceBeanKey(String tenantKey) {
  45. if (!StringUtils.hasText(tenantKey)) {
  46. return null;
  47. }
  48. return tenantKey + DATA_SOURCE_BEAN_KEY_SUFFIX;
  49. }
  50. /**
  51. * 拼接完整的JDBC URL
  52. */
  53. public static String getJDBCUrl(String baseUrl) {
  54. if (!StringUtils.hasText(baseUrl)) {
  55. return null;
  56. }
  57. return baseUrl + JDBC_URL_ARGS;
  58. }
  59. /**
  60. * 拼接完整的Druid连接属性
  61. */
  62. public static String getConnectionProperties(String publicKey) {
  63. if (!StringUtils.hasText(publicKey)) {
  64. return null;
  65. }
  66. return CONNECTION_PROPERTIES + publicKey;
  67. }
  68. }
复制代码

DataSourceContextHolder

使用 ThreadLocal 保存当前线程的数据源key name，并实现set、get、clear方法；

  2. public class DataSourceContextHolder {
  3. private static final ThreadLocal<String> dataSourceKey = new InheritableThreadLocal<>();
  4. public static void setDataSourceKey(String tenantKey) {
  5. dataSourceKey.set(tenantKey);
  6. }
  7. public static String getDataSourceKey() {
  8. return dataSourceKey.get();
  9. }
  10. public static void clearDataSourceKey() {
  11. dataSourceKey.remove();
  12. }
  13. }
复制代码

DynamicDataSource（重点）

继承 AbstractRoutingDataSource （建议阅读其源码，了解动态切换数据源的过程），实现动态选择数据源；

  2. public class DynamicDataSource extends AbstractRoutingDataSource {
  3. @Autowired
  4. private ApplicationContext applicationContext;
  5. @Lazy
  6. @Autowired
  7. private DynamicDataSourceSummoner summoner;
  8. @Lazy
  9. @Autowired
  10. private TenantConfigDAO tenantConfigDAO;
  11. @Override
  12. protected String determineCurrentLookupKey() {
  13. String tenantKey = DataSourceContextHolder.getDataSourceKey();
  14. return DataSourceUtil.getDataSourceBeanKey(tenantKey);
  15. }
  16. @Override
  17. protected DataSource determineTargetDataSource() {
  18. String tenantKey = DataSourceContextHolder.getDataSourceKey();
  19. String beanKey = DataSourceUtil.getDataSourceBeanKey(tenantKey);
  20. if (!StringUtils.hasText(tenantKey) || applicationContext.containsBean(beanKey)) {
  21. return super.determineTargetDataSource();
  22. }
  23. if (tenantConfigDAO.exist(tenantKey)) {
  24. summoner.registerDynamicDataSources();
  25. }
  26. return super.determineTargetDataSource();
  27. }
  28. }
复制代码

DynamicDataSourceSummoner（重点中的重点）

从数据库加载数据源信息，并动态组装和注册spring bean，

  2. @Slf4j
  3. @Component
  4. public class DynamicDataSourceSummoner implements ApplicationListener<ContextRefreshedEvent> {
  5. // 跟spring-data-source.xml的默认数据源id保持一致
  6. private static final String DEFAULT_DATA_SOURCE_BEAN_KEY = "defaultDataSource";
  7. @Autowired
  8. private ConfigurableApplicationContext applicationContext;
  9. @Autowired
  10. private DynamicDataSource dynamicDataSource;
  11. @Autowired
  12. private TenantConfigDAO tenantConfigDAO;
  13. private static boolean loaded = false;
  14. /**
  15. * Spring加载完成后执行
  16. */
  17. @Override
  18. public void onApplicationEvent(ContextRefreshedEvent event) {
  19. // 防止重复执行
  20. if (!loaded) {
  21. loaded = true;
  22. try {
  23. registerDynamicDataSources();
  24. } catch (Exception e) {
  25. log.error("数据源初始化失败, Exception:", e);
  26. }
  27. }
  28. }
  29. /**
  30. * 从数据库读取租户的DB配置,并动态注入Spring容器
  31. */
  32. public void registerDynamicDataSources() {
  33. // 获取所有租户的DB配置
  34. List<TenantConfigEntity> tenantConfigEntities = tenantConfigDAO.listAll();
  35. if (CollectionUtils.isEmpty(tenantConfigEntities)) {
  36. throw new IllegalStateException("应用程序初始化失败,请先配置数据源");
  37. }
  38. // 把数据源bean注册到容器中
  39. addDataSourceBeans(tenantConfigEntities);
  40. }
  41. /**
  42. * 根据DataSource创建bean并注册到容器中
  43. */
  44. private void addDataSourceBeans(List<TenantConfigEntity> tenantConfigEntities) {
  45. Map<Object, Object> targetDataSources = Maps.newLinkedHashMap();
  46. DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
  47. for (TenantConfigEntity entity : tenantConfigEntities) {
  48. String beanKey = DataSourceUtil.getDataSourceBeanKey(entity.getTenantKey());
  49. // 如果该数据源已经在spring里面注册过,则不重新注册
  50. if (applicationContext.containsBean(beanKey)) {
  51. DruidDataSource existsDataSource = applicationContext.getBean(beanKey, DruidDataSource.class);
  52. if (isSameDataSource(existsDataSource, entity)) {
  53. continue;
  54. }
  55. }
  56. // 组装bean
  57. AbstractBeanDefinition beanDefinition = getBeanDefinition(entity, beanKey);
  58. // 注册bean
  59. beanFactory.registerBeanDefinition(beanKey, beanDefinition);
  60. // 放入map中，注意一定是刚才创建bean对象
  61. targetDataSources.put(beanKey, applicationContext.getBean(beanKey));
  62. }
  63. // 将创建的map对象set到 targetDataSources；
  64. dynamicDataSource.setTargetDataSources(targetDataSources);
  65. // 必须执行此操作，才会重新初始化AbstractRoutingDataSource 中的 resolvedDataSources，也只有这样，动态切换才会起效
  66. dynamicDataSource.afterPropertiesSet();
  67. }
  68. /**
  69. * 组装数据源spring bean
  70. */
  71. private AbstractBeanDefinition getBeanDefinition(TenantConfigEntity entity, String beanKey) {
  72. BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(DruidDataSource.class);
  73. builder.getBeanDefinition().setAttribute("id", beanKey);
  74. // 其他配置继承defaultDataSource
  75. builder.setParentName(DEFAULT_DATA_SOURCE_BEAN_KEY);
  76. builder.setInitMethodName("init");
  77. builder.setDestroyMethodName("close");
  78. builder.addPropertyValue("name", beanKey);
  79. builder.addPropertyValue("url", DataSourceUtil.getJDBCUrl(entity.getDbUrl()));
  80. builder.addPropertyValue("username", entity.getDbUser());
  81. builder.addPropertyValue("password", entity.getDbPassword());
  82. builder.addPropertyValue("connectionProperties", DataSourceUtil.getConnectionProperties(entity.getDbPublicKey()));
  83. return builder.getBeanDefinition();
  84. }
  85. /**
  86. * 判断Spring容器里面的DataSource与数据库的DataSource信息是否一致
  87. * 备注:这里没有判断public_key,因为另外三个信息基本可以确定唯一了
  88. */
  89. private boolean isSameDataSource(DruidDataSource existsDataSource, TenantConfigEntity entity) {
  90. boolean sameUrl = Objects.equals(existsDataSource.getUrl(), DataSourceUtil.getJDBCUrl(entity.getDbUrl()));
  91. if (!sameUrl) {
  92. return false;
  93. }
  94. boolean sameUser = Objects.equals(existsDataSource.getUsername(), entity.getDbUser());
  95. if (!sameUser) {
  96. return false;

收藏 举报

TAG:

 

评分：0

我来说两句