saas 多租户技术 springboot 基于域名动态切换数据库

Myth丶恋晨 2023-01-08 05:26 397阅读 0赞

# #

## 前言 ##

saas  软件即服务   现在的软件服务提供商提供一套页面给各个租户，通过一个申请页面

填写租户的租户信息，点击生成，租户就可以有一套自己的系统，可以自己去新建用户，角色，授权等操作。

其实这就是所谓的多租户技术。

多租户，通俗点说，多个租户共用同一套服务提供商提供系统资源，即跟现在流行的共享单车，充电宝差不多。

多租户更多跟云计算在一起，因为你有的客户需求大，付费多，那它分配的计算资源和功能更多，比如有自己独立的应用实例，数据库，硬盘空间等。

这个跟云计算的概念就差不多，云计算就是计算资源，理论上云上的资源的无限大的。

## 多租户隔离级别 ##

多租户主要就是数据隔离，具体来说有三种：

1. 独立数据库      
2. 共享数据库，独立 Schema  
3. 共享数据库，共享 Schema，共享数据表

第一种消耗资源最多，就是租户有独立的数据库实例。

第二种在一个数据库实例中每一个租户建立一个Schema数据库，这个也有个问题，当你租户很多的话，对应的表也更多，堆数据库性能也有影响

第三种实例，数据库，表都共享，基于一个租户字段进行隔离，这种成本最低，隔离性也最差。

## 架构图 ##

第三种网上有很多demo，大部分都是通过mybatis plus 在数据库操作时增加一个租户字段。

第一和第二种差不多，都可以通过动态切换数据源的方法来达到。下面我就只要来讲第二种

下面是一个架构图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70][]

如上图所示：租户可以通过多租户系统申请应用和资源，审核通过后，租户信息同步到redis当中，同时根据的租户类型在对应的数据库实例中初始化库和表，

你也可以自己手动在mysql库中自己增加几个一样的数据库，数据初始脚本在项目里。

ps 我的应用系统项目来自 [https://github.com/Heeexy/SpringBoot-Shiro-Vue][https_github.com_Heeexy_SpringBoot-Shiro-Vue]  这是一个简单的springboot +vue的项目，为了增加动态数据源，我讲spring-boot-starter-parent版本升级为2.3.4.RELAERS版本。

![2021011911455596.png][]

可以导入我修改后的代码，[下载地址][Link 1]

1，增加了 shrek-tanent模块，改模块是spring-boot-starter模块，通过启动类加入注解@EnableTenant启动租户模式，

主要代码shrek-tanent代码如下：

DynamicRoutingDataSourceHolder.java  动态数据源持有类

public class DynamicRoutingDataSourceHolder {
    
        public static final String PRIMARY_DATASOURCE = "primaryDatasource";
    
    
        private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();
    
        public static void putKey(String name) {
            THREAD_LOCAL.set(name);
        }
    
        public static String getKey() {
            String key = THREAD_LOCAL.get();
            if (key == null) {
                key = PRIMARY_DATASOURCE;
                putKey(key);
            }
            return key;
        }
    
        public static void removeKey() {
            THREAD_LOCAL.remove();
        }
    }

DynamicRoutingDataSource.java  动态数据源类

public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
    
    //获取当前请求线程的数据源持有
        @Override
        protected Object determineCurrentLookupKey() {
            return DynamicRoutingDataSourceHolder.getKey();
        }
    //设置多数据源map
        @Override
        public void setTargetDataSources(Map<Object, Object> targetDataSources) {
            super.setTargetDataSources(targetDataSources);
            super.afterPropertiesSet();
        }
    }

@Configuration
    public class DatasourceConfig {
        @Value("${spring.datasource.url}")
        private String url;
        @Value("${spring.datasource.username}")
        private String username;
        @Value("${spring.datasource.password}")
        private String password;
        @Value("${spring.datasource.driver-class-name}")
        private String driverClassName;
    
        /**
         * 设置默认数据源
         * @return
         */
        @Primary
        @Bean(name = "datasource")
        public DynamicRoutingDataSource dynamicRoutingDataSource() {
            DynamicRoutingDataSource dataSource = new DynamicRoutingDataSource();
            Map<Object, Object> targetDataSources = new HashMap<>(16);
            HikariDataSource hikariDataSource = new HikariDataSource();
            hikariDataSource.setJdbcUrl(url);
            hikariDataSource.setUsername(username);
            hikariDataSource.setPassword(password);
            hikariDataSource.setDriverClassName(driverClassName);
            targetDataSources.put(DynamicRoutingDataSourceHolder.PRIMARY_DATASOURCE, hikariDataSource);
            dataSource.setTargetDataSources(targetDataSources);
            //设置动态数据源的默认数据源，也就是配置文件里的数据源
            dataSource.setDefaultTargetDataSource(hikariDataSource);
            return dataSource;
        }
    
        /**
         * 加入事务管理？ 没试过
         * @return
         */
        @Bean
        public PlatformTransactionManager transactionManager() {
            return new DataSourceTransactionManager(dynamicRoutingDataSource());
        }
    }

@Configuration
    @Slf4j
    public class DynamicSourceConfig implements ApplicationContextAware {
    
    
        @Autowired
        private DynamicRoutingDataSource dynamicRoutingDataSource;
        public static ApplicationContext applicationContext;
        public static List<TenantUser> tenantUsers = new ArrayList();
    
        //演示用  静态初始化,  可以考虑一个定时任务从redis通过，跟我上面的图形一样
        static {
            tenantUsers.add(new TenantUser(1,"aaa","jdbc:mysql://127.0.0.1:3306/shrek_example_1348915432900841474?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai","root","root"));
            tenantUsers.add(new TenantUser(2,"bbb","jdbc:mysql://127.0.0.1:3306/shrek_example_1349659685910249474?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai","root","root"));
        }
    
        @PostConstruct
        public void init() {
            List<TenantUser> list = tenantUsers;
    
            ConfigurableApplicationContext applicationContext = (ConfigurableApplicationContext) DynamicSourceConfig.applicationContext;
            DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getBeanFactory();
            Map<Object, DataSource> dataSourceMap = dynamicRoutingDataSource.getResolvedDataSources();
            Map<Object, Object> map = new HashMap<>(dataSourceMap);
            for (TenantUser user : list) {
                BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(HikariDataSource.class);
                beanDefinitionBuilder.addPropertyValue("username", user.getDatasourceUsername());
                beanDefinitionBuilder.addPropertyValue("password", user.getDatasourcePassword());
                beanDefinitionBuilder.addPropertyValue("jdbcUrl", user.getDatasourceUrl());
                beanDefinitionBuilder.addPropertyValue("driverClassName", "com.mysql.cj.jdbc.Driver");
                String beanName = user.getPrefix();
                beanFactory.registerBeanDefinition(beanName, beanDefinitionBuilder.getRawBeanDefinition());
                DataSource dataSource = DynamicSourceConfig.applicationContext.getBean(beanName, DataSource.class);
                map.put(beanName, dataSource);
            }
            dynamicRoutingDataSource.setTargetDataSources(Collections.unmodifiableMap(map));
            log.info("dynamic datasource init success");
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            DynamicSourceConfig.applicationContext = applicationContext;
        }
    }

还有一个拦截类，就是拦截前端的请求，获取分域名，存入的ThredLocal中，这里可以做个判断，可以判断为空，直接返回租户未注册，再根据租户类型是基于字段还是库的，这里我没判断

@Component
    public class RequestHander implements HandlerInterceptor {
        //请求前
        @Override
        public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
    
            //获取域名，从本地缓存对象（从redis同步过来）判断是否过期，租户ID和多租户类型，存入ThreadLocal
            URL url = new URL(httpServletRequest.getRequestURL().toString());
            DynamicRoutingDataSourceHolder.putKey(url.getHost().split("\\.")[0]);
    
            return true;
        }
    
    }

修改你的host文件。

127.0.0.1  aaa.shrek.com
    127.0.0.1  bbb.shrek.com
    127.0.0.1  ccc.shrek.com

启动项目后，不同的域名就会操作不同的数据库了，这样就差不多是可以实现多租户了，一套应用，多个租户共用，可以基于多种数据隔离模式。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NocmVrMTE_size_16_color_FFFFFF_t_70]: /images/20221119/e2899ca08d504fd9ba6421c4d64687a7.png
[https_github.com_Heeexy_SpringBoot-Shiro-Vue]: https://github.com/Heeexy/SpringBoot-Shiro-Vue
[2021011911455596.png]: /images/20221119/178bb44932b34920ba42cc9a4048d9e8.png
[Link 1]: https://download.csdn.net/download/shrek11/14801173