这是不可能的，因为方言会影响某些引用规则等。你不能只是在运行时根据租户标识符“换出”。只需创建两个持久性单元，每个持久性单元针对每种数据库类型指向不同的数据源。您将不得不以某种方式根据您的租户标识符查找适当的EntityManager/EntityManagerFactory，这使得当您想要使用Spring Data JPA时变得有点困难，因为它需要实体管理器工厂的编译静态名称引用。也许您可以创建一个自定义的EntityManagerFactory，根据租户标识符将所有方法调用委托给适当的示例。总的来说，这并不是那么容易，你可能要做很多的试验和错误。
IMO最好是有一个单独的应用程序部署与单独的配置，如果可能的话，每个数据库类型。

我终于找到了解决这个问题的办法。我设法通过为每种方言（在本例中为MySQL、Postgres和MS SQL Server）创建一个实体管理器工厂来解决方言的问题。
为EntityManagerFactory创建一个bean，并返回该接口的代理，在处理程序中，根据您的逻辑，您可以切换使用哪个EMF来适应所使用的数据源。
我已经为此创建了一个视频，因为它似乎没有在线文档。
Session Scoped Connection
这与您试图实现的目标非常相似，但在我的情况下，用户提供凭据，因此它更加复杂。

@Tsvetelin的回答给我指出了正确的方向，但是，在应用它之后，我开始遇到另一个库的问题，比如Hazelcast，它被用作二级缓存。
所以，这就是我所做的：
1.我没有创建EntityManagerFactory bean，而是创建了一个示例化DynamicTenantEntityManagerFactoryBean的LocalContainerEntityManagerFactoryBean。

@Bean
 public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

     DynamicTenantEntityManagerFactoryBean em = new DynamicTenantEntityManagerFactoryBean();
     em.setPackagesToScan(getPackagesToScan());
     em.setJpaProperties(additionalProperties());
     em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
     return em;

 }

getPackagesToScan()和additionalProperties()是读取Sping Boot 在应用程序上下文上设置的参数的函数。

private String[] getPackagesToScan() {

    //Check if the defaults packagesToScan needs to be overrided
    String[] packagesToScan = dynamicTenantRoutingPropertiesConfig.getPackagesToScan();

    if (packagesToScan == null) {

        List<String> packageNames = EntityScanPackages.get(context).getPackageNames();
        if (packageNames.isEmpty() && AutoConfigurationPackages.has(context)) {
            packageNames = AutoConfigurationPackages.get(context);
        }

        packagesToScan = packageNames.toArray(new String[0]);

    }

    return packagesToScan;

}

private Properties additionalProperties() {
    
    //jpaProperties is an Autowired bean of type 
    //org.springframework.boot.autoconfigure.orm.jpa.JpaProperties

    final Properties properties = new Properties();
    properties.putAll(jpaProperties.getProperties());
    return properties;
}

DynamicTenantEntityManagerFactoryBean扩展LocalContainerEntityManagerFactoryBean并覆盖createNativeEntityManagerFactory()，使用与@tsvetelin-yakimov相同的技术

@Log4j2
@Configurable
public class DynamicTenantEntityManagerFactoryBean extends LocalContainerEntityManagerFactoryBean {

    @Autowired
    private ApplicationContext context;

    @PostConstruct
    public void postConstruct() {

        //Obtem a referencia para o Datasource
        AbstractDynamicTenantRoutingDataSource dataSource
                = context.getBean(AbstractDynamicTenantRoutingDataSource.class);

        //Define o Datasource
        this.setDataSource(dataSource);

    }

    @Override
    protected EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException {

        log.info("(DynamicTenantEntityManagerFactory): Iniciando Proxy...");
        final int hashcode = UUID.randomUUID().toString().hashCode();
        final Map<String, EntityManagerFactory> entityManagerFactoryMap = new HashMap<>();

        Object emf = Proxy.newProxyInstance(
                Thread.currentThread().getContextClassLoader(),
                new Class[]{SessionFactory.class},
                (proxy, method, args) -> {

                    if (method.getName().equals("hashCode")) {
                        return hashcode;
                    }

                    if (method.getName().equals("equals")) {
                        return proxy == args[0];
                    }

                    //Verifica se o DataSource esta preenchido
                    if (this.getDataSource() == null)
                        throw new PersistenceException("O DataSource não pode ser nulo");

                    //Verifica se ja temos o EntityManager para esse Datasource
                    String currentDriver = ((AbstractDynamicTenantRoutingDataSource) this.getDataSource()).resolveCurrentDriver();
                    EntityManagerFactory instance = entityManagerFactoryMap.get(currentDriver);

                    if (instance == null) {

                        //Obtem o dialeto
                        Dialect dialect = ((AbstractDynamicTenantRoutingDataSource) this.getDataSource()).resolveDialect(currentDriver);

                        log.info(
                                "(DynamicTenantEntityManagerFactory): Iniciando EntityManagerFactory para Driver {} Dialeto {}...",
                                currentDriver,
                                dialect
                        );

                        instance = this.createEntityManagerFactory(
                                dialect
                        );

                        entityManagerFactoryMap.put(
                                currentDriver,
                                instance
                        );

                    }

                    log.debug(
                            "(DynamicTenantEntityManagerFactory): Retornando EntityManagerFactory para Driver {}...",
                            currentDriver
                    );
                    return method.invoke(instance);

                }
        );

        log.info("(DynamicTenantEntityManagerFactory): Iniciando Proxy... Concluido!");
        return (SessionFactory) emf;

    }

    private EntityManagerFactory createEntityManagerFactory(Dialect dialect) {

        EntityManagerFactory factory = super.createNativeEntityManagerFactory();
        factory
                .getProperties()
                .put("hibernate.dialect", dialect.getClass().getName());

        return factory;

    }

}