这种多租户单实例的场景我之前在项目里落地过，结合你提到的「客户数量10-25个、添加新客户允许重启服务」的前提，给你几个非常实用的Spring生态解决方案，都是经过验证的：

方案一：ThreadLocal + 工厂模式（最推荐） #

这个方案对现有代码入侵最小，实现起来也简单，核心思路是：

1. 从请求中提取企业（租户）标识，放到ThreadLocal中（绑定请求上下文）
2. 预先初始化所有租户的第三方Bean实例
3. 通过工厂类根据当前请求的租户标识，返回对应的Bean实例

具体实现步骤 #

1. 定义租户上下文Holder（存储当前请求的租户ID）

public class TenantContextHolder {
    private static final ThreadLocal<String> CURRENT_TENANT = new ThreadLocal<>();

    // 设置当前租户ID
    public static void setTenantId(String tenantId) {
        CURRENT_TENANT.set(tenantId);
    }

    // 获取当前租户ID
    public static String getTenantId() {
        return CURRENT_TENANT.get();
    }

    // 请求结束后清理，避免内存泄漏和线程复用串号
    public static void clear() {
        CURRENT_TENANT.remove();
    }
}

2. 添加拦截器/过滤器，提取租户标识并注入上下文

比如从请求头X-Tenant-Id中获取租户ID，在请求开始时设置，结束时清理：

@Component
public class TenantInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从请求头提取租户ID，也可以从路径参数、Cookie等地方获取
        String tenantId = request.getHeader("X-Tenant-Id");
        if (StringUtils.isNotBlank(tenantId)) {
            TenantContextHolder.setTenantId(tenantId);
        } else {
            // 没有租户标识的情况，根据业务需求处理，比如返回400
            response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Missing X-Tenant-Id header");
            return false;
        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 必须清理，否则线程池复用会导致租户ID串号
        TenantContextHolder.clear();
    }
}

记得在配置类中注册这个拦截器，让它生效。

3. 创建第三方Bean工厂，管理所有租户的Bean实例

Spring会自动把同类型的所有Bean注入到Map<String, ThirdPartyBean>中，key就是Bean的名称（可以用@Qualifier指定）：

@Component
public class ThirdPartyBeanFactory {
    private final Map<String, ThirdPartyBean> tenantBeanMap;

    // 构造函数注入所有ThirdPartyBean实例
    public ThirdPartyBeanFactory(Map<String, ThirdPartyBean> tenantBeanMap) {
        this.tenantBeanMap = tenantBeanMap;
    }

    // 获取当前租户对应的第三方Bean
    public ThirdPartyBean getCurrentTenantBean() {
        String tenantId = TenantContextHolder.getTenantId();
        ThirdPartyBean bean = tenantBeanMap.get(tenantId);
        if (bean == null) {
            throw new IllegalArgumentException("No third-party bean found for tenant: " + tenantId);
        }
        return bean;
    }
}

4. 配置所有租户的第三方Bean

因为允许重启添加客户，我们可以在配置类中批量初始化所有租户的Bean，或者从配置文件读取租户信息动态创建：

@Configuration
public class ThirdPartyBeanConfig {
    @Autowired
    private Environment environment;

    // 假设配置文件中定义了所有租户ID：tenants=tenantA,tenantB,tenantC
    @Value("#{'${tenants}'.split(',')}")
    private List<String> tenantIds;

    // 动态创建每个租户的第三方Bean
    @Bean
    public List<ThirdPartyBean> allTenantThirdPartyBeans() {
        return tenantIds.stream()
                .map(this::createTenantBean)
                .collect(Collectors.toList());
    }

    private ThirdPartyBean createTenantBean(String tenantId) {
        // 从配置文件读取对应租户的数据库信息
        String dbUrl = environment.getProperty("tenants." + tenantId + ".db.url");
        String dbUser = environment.getProperty("tenants." + tenantId + ".db.username");
        String dbPass = environment.getProperty("tenants." + tenantId + ".db.password");
        
        // 创建第三方Bean实例（这里根据你的实际Bean构造逻辑调整）
        return new ThirdPartyBean(dbUrl, dbUser, dbPass);
    }
}

这样添加新租户时，只需要在配置文件中新增租户ID和对应的数据库配置，重启服务即可。

5. 在业务服务中使用工厂获取Bean

把原来直接注入ThirdPartyBean的地方，改成注入ThirdPartyBeanFactory，然后动态获取对应租户的Bean：

@Service
public class BusinessService {
    private final ThirdPartyBeanFactory beanFactory;

    @Autowired
    public BusinessService(ThirdPartyBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public void processBusinessRequest() {
        // 获取当前租户对应的第三方Bean
        ThirdPartyBean thirdPartyBean = beanFactory.getCurrentTenantBean();
        // 调用第三方RPC接口
        thirdPartyBean.callRpcMethod();
    }
}

方案优势 #

• 对现有代码改动极小，只需要替换Bean注入方式
• 所有Bean预先初始化，性能稳定
• 完全适配你的「客户少、允许重启」的场景

方案二：基于Spring Lookup方法注入（备选） #

如果你的第三方Bean是prototype作用域（非线程安全，需要每次请求创建新实例），可以用Spring的Lookup方法注入，不过这个方案对代码的侵入性稍大：

@Service
public abstract class BusinessService {
    // Lookup方法，Spring会动态实现这个方法，返回对应租户的Bean
    protected abstract ThirdPartyBean getThirdPartyBean();

    public void processBusinessRequest() {
        ThirdPartyBean bean = getThirdPartyBean();
        bean.callRpcMethod();
    }
}

然后需要自定义Scope或者结合ThreadLocal来让Lookup方法返回对应租户的Bean，不过这个方案比工厂模式复杂，除非你的Bean必须是prototype，否则不推荐。

关键注意事项 #

1. ThreadLocal必须清理：一定要在请求结束后调用TenantContextHolder.clear()，否则线程池复用会导致租户ID串号，引发严重的业务错误。
2. Bean的线程安全性：如果第三方Bean是单例，必须确保它是线程安全的（因为多个租户的请求会复用同一个Bean实例）；如果Bean不是线程安全的，建议把它的作用域改成prototype，或者在工厂中为每个线程创建独立实例。
3. 租户标识的校验：在拦截器中一定要校验租户标识的合法性，避免非法请求进入业务逻辑。

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