<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

@Slf4j
@Component
public class TenantInterceptor implements WebRequestInterceptor {
    private static final String TENANT_HEADER = "X-Tenant";
    @Override
    public void preHandle(WebRequest request) {
        String tenantId = request.getHeader(TENANT_HEADER);
        if (tenantId != null && !tenantId.isEmpty()) {
            TenantContext.setTenantId(tenantId);
            log.info("Tenant header get: {}", tenantId);
        } else {
            log.error("Tenant header not found.");
            throw new TenantAliasNotFoundException("Tenant header not found.");
        }
    }
    @Override
    public void postHandle(WebRequest webRequest, ModelMap modelMap) {
        TenantContext.clear();
    }
    @Override
    public void afterCompletion(WebRequest webRequest, Exception e) {
    }
}

@Slf4j
public class TenantContext {
    private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();
    public static void setTenantId(String tenantId) {
        log.debug("Setting tenantId to " + tenantId);
        CONTEXT.set(tenantId);
    }
    public static String getTenantId() {
        return CONTEXT.get();
    }
    public static void clear() {
        CONTEXT.remove();
    }
}

@Service
public class RedisDatasourceService {
    private final RedisTemplate redisTemplate;
    private final ApplicationProperties applicationProperties;
    private final DataSourceProperties dataSourceProperties;
    public RedisDatasourceService(RedisTemplate redisTemplate, ApplicationProperties applicationProperties, DataSourceProperties dataSourceProperties) {
        this.redisTemplate = redisTemplate;
        this.applicationProperties = applicationProperties;
        this.dataSourceProperties = dataSourceProperties;
    }
    /**
     * Save tenant datasource infos
     *
     * @param tenantDatasource data of datasource
     * @return status if true save successfully , false error
     */
    public boolean save(TenantDatasource tenantDatasource) {
        try {
            Map ruleHash = new ObjectMapper().convertValue(tenantDatasource, Map.class);
            redisTemplate.opsForHash().put(applicationProperties.getServiceKey(), String.format("%s_%s", applicationProperties.getTenantKey(), tenantDatasource.getAlias()), ruleHash);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * Get all of keys
     *
     * @return list of datasource
     */
    public List findAll() {
        return redisTemplate.opsForHash().values(applicationProperties.getServiceKey());
    }
    /**
     * Get datasource
     *
     * @return map key and datasource infos
     */
    public Map<String, TenantDatasource> loadServiceDatasources() {
        List<Map<String, Object>> datasourceConfigList = findAll();
        // Save datasource credentials first time
        // In production mode, this part can be skip
        if (datasourceConfigList.isEmpty()) {
            List<DataSourceProperties.Tenant> tenants = dataSourceProperties.getDatasources();
            tenants.forEach(d -> {
                TenantDatasource tenant = TenantDatasource.builder()
                        .alias(d.getAlias())
                        .database(d.getDatabase())
                        .host(d.getHost())
                        .port(d.getPort())
                        .username(d.getUsername())
                        .password(d.getPassword())
                        .build();
                save(tenant);
            });
        }
        return getDataSourceHashMap();
    }
    /**
     * Get all tenant alias
     *
     * @return list of alias
     */
    public List<String> getTenantsAlias() {
        // get list all datasource for this microservice
        List<Map<String, Object>> datasourceConfigList = findAll();
        return datasourceConfigList.stream().map(data -> (String) data.get("alias")).collect(Collectors.toList());
    }
    /**
     * Fill the data sources list.
     *
     * @return Map<String, TenantDatasource>
     */
    private Map<String, TenantDatasource> getDataSourceHashMap() {
        Map<String, TenantDatasource> datasourceMap = new HashMap<>();
        // get list all datasource for this microservice
        List<Map<String, Object>> datasourceConfigList = findAll();
        datasourceConfigList.forEach(data -> datasourceMap.put(String.format("%s_%s", applicationProperties.getTenantKey(), (String) data.get("alias")), new TenantDatasource((String) data.get("alias"), (String) data.get("host"), (int) data.get("port"), (String) data.get("database"), (String) data.get("username"), (String) data.get("password"))));
        return datasourceMap;
    }
}

@Configuration
public class MultiTenantMongoDBFactory extends SimpleMongoClientDatabaseFactory {
    @Autowired
    MongoDataSources mongoDataSources;
    public MultiTenantMongoDBFactory(@Qualifier("getMongoClient") MongoClient mongoClient, String databaseName) {
        super(mongoClient, databaseName);
    }
    @Override
    protected MongoDatabase doGetMongoDatabase(String dbName) {
        return mongoDataSources.mongoDatabaseCurrentTenantResolver();
    }
}

@Component
@Slf4j
public class MongoDataSources {
    /**
     * Key: String tenant alias
     * Value: TenantDatasource
     */
    private Map<String, TenantDatasource> tenantClients;
    private final ApplicationProperties applicationProperties;
    private final RedisDatasourceService redisDatasourceService;
    public MongoDataSources(ApplicationProperties applicationProperties, RedisDatasourceService redisDatasourceService) {
        this.applicationProperties = applicationProperties;
        this.redisDatasourceService = redisDatasourceService;
    }
    /**
     * Initialize all mongo datasource
     */
    @PostConstruct
    @Lazy
    public void initTenant() {
        tenantClients = new HashMap<>();
        tenantClients = redisDatasourceService.loadServiceDatasources();
    }
    /**
     * Default Database name for spring initialization. It is used to be injected into the constructor of MultiTenantMongoDBFactory.
     *
     * @return String of default database.
     */
    @Bean
    public String databaseName() {
        return applicationProperties.getDatasourceDefault().getDatabase();
    }
    /**
     * Default Mongo Connection for spring initialization.
     * It is used to be injected into the constructor of MultiTenantMongoDBFactory.
     */
    @Bean
    public MongoClient getMongoClient() {
        MongoCredential credential = MongoCredential.createCredential(applicationProperties.getDatasourceDefault().getUsername(), applicationProperties.getDatasourceDefault().getDatabase(), applicationProperties.getDatasourceDefault().getPassword().toCharArray());
        return MongoClients.create(MongoClientSettings.builder()
                .applyToClusterSettings(builder ->
                        builder.hosts(Collections.singletonList(new ServerAddress(applicationProperties.getDatasourceDefault().getHost(), Integer.parseInt(applicationProperties.getDatasourceDefault().getPort())))))
                .credential(credential)
                .build());
    }
    /**
     * This will get called for each DB operations
     *
     * @return MongoDatabase
     */
    public MongoDatabase mongoDatabaseCurrentTenantResolver() {
        try {
            final String tenantId = TenantContext.getTenantId();
            // Compose tenant alias. (tenantAlias = key + tenantId)
            String tenantAlias = String.format("%s_%s", applicationProperties.getTenantKey(), tenantId);
            return tenantClients.get(tenantAlias).getClient().
                    getDatabase(tenantClients.get(tenantAlias).getDatabase());
        } catch (NullPointerException exception) {
            throw new TenantAliasNotFoundException("Tenant Datasource alias not found.");
        }
    }
73
}

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@Document(collection = "employee")
public class Employee  {
    @Id
    private String id;
    private String firstName;
    private String lastName;
    private String email;
}

@Override
public void run(String... args) throws Exception {
    List<String> aliasList = redisDatasourceService.getTenantsAlias();
    if (!aliasList.isEmpty()) {
        //perform actions for each tenant
        aliasList.forEach(alias -> {
            TenantContext.setTenantId(alias);
            employeeRepository.deleteAll();
            Employee employee = Employee.builder()
                    .firstName(alias)
                    .lastName(alias)
                    .email(String.format("%s%s", alias, "@localhost.com" ))
                    .build();
            employeeRepository.save(employee);
            TenantContext.clear();
        });
    }
}