如何在Spring中实现基于用户请求的MongoDB多数据库连接？

这种每个用户独占独立MongoDB数据库的场景，在多租户系统里挺常见的，Spring生态里有一套很清晰的实现方案，我一步步给你讲清楚：

本质上是动态切换MongoDB数据源：在请求到来时，先识别当前用户的标识，再根据这个标识匹配到对应的MongoDB连接，最后用这个连接完成数据库操作。核心是用线程上下文存储用户标识，再结合动态实例化的MongoTemplate来实现切换。

1. 配置多用户的MongoDB连接信息 #

首先在application.yml里配置所有用户的数据库连接参数，用一个Map来存储，方便后续读取：

spring:
  data:
    mongodb:
      multi-users:
        user_001:
          uri: mongodb://localhost:27017/db_user_001
          database-name: db_user_001
        user_002:
          uri: mongodb://localhost:27017/db_user_002
          database-name: db_user_002
        # 更多用户的配置可以继续往下加

2. 实现MongoClient的动态管理工厂 #

MongoClient是线程安全的，每个用户只需要一个实例就行。我们写一个工厂类来初始化并缓存所有用户的MongoClient，需要时直接根据用户ID获取：

@Component
public class DynamicMongoClientFactory {
    private final Map<String, MongoClient> clientCache = new ConcurrentHashMap<>();
    private final Map<String, String> dbNameCache = new ConcurrentHashMap<>();

    // 从配置文件加载所有用户的MongoDB配置，初始化连接
    public DynamicMongoClientFactory(@Value("${spring.data.mongodb.multi-users}") Map<String, Map<String, String>> userConfigs) {
        userConfigs.forEach((userId, config) -> {
            String uri = config.get("uri");
            String dbName = config.get("database-name");
            MongoClient client = MongoClients.create(uri);
            clientCache.put(userId, client);
            dbNameCache.put(userId, dbName);
        });
    }

    // 根据用户ID获取对应的MongoClient
    public MongoClient getClient(String userId) {
        MongoClient client = clientCache.get(userId);
        if (client == null) {
            throw new IllegalArgumentException("No MongoDB connection found for user: " + userId);
        }
        return client;
    }

    // 获取用户对应的数据库名
    public String getDbName(String userId) {
        return dbNameCache.get(userId);
    }
}

3. 用ThreadLocal存储用户上下文 #

因为请求是多线程的，我们需要用ThreadLocal来存储当前请求的用户ID，确保每个线程能拿到自己对应的用户标识：

public class UserContextHolder {
    private static final ThreadLocal<String> USER_ID_HOLDER = new ThreadLocal<>();

    // 设置当前线程的用户ID
    public static void setCurrentUserId(String userId) {
        USER_ID_HOLDER.set(userId);
    }

    // 获取当前线程的用户ID
    public static String getCurrentUserId() {
        return USER_ID_HOLDER.get();
    }

    // 请求结束后清理ThreadLocal，避免内存泄漏
    public static void clear() {
        USER_ID_HOLDER.remove();
    }
}

4. 实现动态MongoTemplate #

Spring操作MongoDB最常用的是MongoTemplate，我们写一个动态类，根据当前上下文的用户ID，返回对应的MongoTemplate实例：

@Component
public class DynamicMongoTemplateProvider {
    private final DynamicMongoClientFactory clientFactory;

    public DynamicMongoTemplateProvider(DynamicMongoClientFactory clientFactory) {
        this.clientFactory = clientFactory;
    }

    public MongoTemplate getCurrentMongoTemplate() {
        String userId = UserContextHolder.getCurrentUserId();
        if (userId == null) {
            throw new IllegalStateException("User ID not found in request context");
        }
        MongoClient client = clientFactory.getClient(userId);
        String dbName = clientFactory.getDbName(userId);
        return new MongoTemplate(client, dbName);
    }
}

5. 拦截请求，自动设置用户上下文 #

写一个请求拦截器，在请求进来时从请求头/参数里提取用户ID，存入ThreadLocal；请求结束后清理上下文：

@Component
public class UserContextInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 这里假设用户ID从请求头的X-USER-ID字段传递，你可以根据实际情况调整（比如从token解析）
        String userId = request.getHeader("X-USER-ID");
        if (userId == null || userId.isBlank()) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "User ID is required");
            return false;
        }
        UserContextHolder.setCurrentUserId(userId);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserContextHolder.clear();
    }
}

然后注册这个拦截器到Spring MVC：

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    private final UserContextInterceptor userContextInterceptor;

    public WebMvcConfig(UserContextInterceptor userContextInterceptor) {
        this.userContextInterceptor = userContextInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(userContextInterceptor)
                .addPathPatterns("/**"); // 拦截所有请求
    }
}

6. 在业务代码中使用 #

现在你就可以在Service里注入DynamicMongoTemplateProvider，直接获取当前用户的MongoTemplate做数据库操作了：

@Service
public class UserDataService {
    private final DynamicMongoTemplateProvider mongoTemplateProvider;

    public UserDataService(DynamicMongoTemplateProvider mongoTemplateProvider) {
        this.mongoTemplateProvider = mongoTemplateProvider;
    }

    public void saveUserInfo(UserInfo userInfo) {
        MongoTemplate mongoTemplate = mongoTemplateProvider.getCurrentMongoTemplate();
        mongoTemplate.save(userInfo);
    }

    public UserInfo getUserInfo(String id) {
        MongoTemplate mongoTemplate = mongoTemplateProvider.getCurrentMongoTemplate();
        return mongoTemplate.findById(id, UserInfo.class);
    }
}

• 连接池配置：在MongoDB的URI里可以加上连接池参数（比如maxPoolSize=20），避免单个用户的连接数过多导致资源耗尽。
• 动态新增用户：如果用户是动态创建的，不用提前在配置文件里写死，可以在DynamicMongoClientFactory里加一个方法，动态创建并缓存MongoClient。
• 异常处理：要针对用户ID不存在、MongoDB连接失败等情况做兜底处理，返回合理的错误信息。
• 线程安全：一定要记得在请求结束后清理ThreadLocal，否则会导致内存泄漏。

内容的提问来源于stack exchange，提问作者Young Young