如何在同一线程中强制使用第二个JDBC连接访问同一MySQL数据库

这种情况我太熟了——MySQL的流式查询对连接的独占性很强，同一个连接上只要有活跃的流式结果集，就绝对不允许执行其他查询。既然你明确要在同一线程里同时用两个连接（一个跑流式查询，一个处理每行的数据库操作），那核心方案就是配置多数据源+独立的EntityManager/事务管理器，让两个操作完全隔离在不同的连接实例上。

具体实现步骤 #

1. 配置两个独立的数据源 #

首先得在Spring里配置两个数据源，它们可以指向同一个MySQL库，但必须是不同的连接池实例（相当于两个独立的连接通道）。比如我们命名为streamingDataSource（用于流式查询）和operationDataSource（用于每行的数据库操作）：

@Configuration
public class DataSourceConfig {

    // 流式查询用的数据源
    @Bean(name = "streamingDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.streaming")
    public DataSource streamingDataSource() {
        return DataSourceBuilder.create().build();
    }

    // 行操作专用的数据源
    @Bean(name = "operationDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.operation")
    public DataSource operationDataSource() {
        return DataSourceBuilder.create().build();
    }
}

对应的application.properties里要配置两个数据源的参数（可以完全一样，只是前缀不同）：

# 流式查询数据源
spring.datasource.streaming.url=jdbc:mysql://localhost:3306/your_db?useCursorFetch=true&defaultFetchSize=1000
spring.datasource.streaming.username=root
spring.datasource.streaming.password=xxx
spring.datasource.streaming.driver-class-name=com.mysql.cj.jdbc.Driver

# 操作数据源
spring.datasource.operation.url=jdbc:mysql://localhost:3306/your_db?useCursorFetch=true
spring.datasource.operation.username=root
spring.datasource.operation.password=xxx
spring.datasource.operation.driver-class-name=com.mysql.cj.jdbc.Driver

注意：流式查询的数据源要加useCursorFetch=true和defaultFetchSize=1000，这是MySQL开启流式查询的必要参数。

2. 为每个数据源配置独立的EntityManagerFactory和TransactionManager #

接下来要给每个数据源绑定自己的EntityManagerFactory和事务管理器，这样Spring才会把不同的操作分配到对应的连接上：

@Configuration
@EnableJpaRepositories(
        basePackages = "com.yourpackage.streamingrepo",
        entityManagerFactoryRef = "streamingEntityManagerFactory",
        transactionManagerRef = "streamingTransactionManager"
)
public class StreamingJpaConfig {

    @Autowired
    @Qualifier("streamingDataSource")
    private DataSource streamingDataSource;

    @Bean(name = "streamingEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean streamingEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(streamingDataSource)
                .packages("com.yourpackage.entity")
                .persistenceUnit("streamingPU")
                .build();
    }

    @Bean(name = "streamingTransactionManager")
    public PlatformTransactionManager streamingTransactionManager(
            @Qualifier("streamingEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

然后是操作数据源的配置类：

@Configuration
@EnableJpaRepositories(
        basePackages = "com.yourpackage.operationrepo",
        entityManagerFactoryRef = "operationEntityManagerFactory",
        transactionManagerRef = "operationTransactionManager"
)
public class OperationJpaConfig {

    @Autowired
    @Qualifier("operationDataSource")
    private DataSource operationDataSource;

    @Bean(name = "operationEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean operationEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(operationDataSource)
                .packages("com.yourpackage.entity")
                .persistenceUnit("operationPU")
                .build();
    }

    @Bean(name = "operationTransactionManager")
    public PlatformTransactionManager operationTransactionManager(
            @Qualifier("operationEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

这里要注意：两个@EnableJpaRepositories的basePackages要分开，把流式查询的Repository放在streamingrepo包，操作的Repository放在operationrepo包，避免Spring混淆。

3. 编写流式查询的Repository #

在流式查询的Repository里，要确保用的是streamingTransactionManager，并且开启流式查询。比如用Spring Data JPA的@Query配合Stream返回值：

package com.yourpackage.streamingrepo;

import com.yourpackage.entity.BigTableEntity;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.transaction.annotation.Transactional;
import java.util.stream.Stream;

public interface BigTableStreamingRepo extends CrudRepository<BigTableEntity, Long> {

    @Transactional(transactionManager = "streamingTransactionManager", readOnly = true)
    @Query(value = "SELECT * FROM big_table", nativeQuery = true)
    Stream<BigTableEntity> streamAllData();
}

这里的@Transactional必须指定transactionManager为我们配置的streamingTransactionManager，确保用的是流式数据源的连接。

4. 在业务逻辑中双连接协作 #

最后在业务代码里，注入两个Repository（或者直接注入两个EntityManager），用流式查询的Repository拉取数据，同时用操作Repository执行每行的数据库操作——这时候两个操作会分别使用不同的连接，完全不会冲突：

@Service
public class DataProcessingService {

    @Autowired
    private BigTableStreamingRepo streamingRepo;

    @Autowired
    private OperationRepo operationRepo;

    public void processData() {
        // 用streamingDataSource的连接开启流式查询
        try (Stream<BigTableEntity> stream = streamingRepo.streamAllData()) {
            stream.forEach(entity -> {
                // 这里用operationDataSource的连接执行操作，完全独立
                operationRepo.doSomethingWithEntity(entity);
            });
        } // try-with-resources会自动关闭流式结果集和连接
    }
}

关键注意点：一定要用try-with-resources包裹流式查询的Stream，确保结果集和连接能被正确关闭，避免资源泄漏。

为什么这个方案可行？ #

因为我们通过多数据源配置，让流式查询和后续操作分别绑定了不同的EntityManagerFactory，每个Factory都会从自己的数据源获取独立的连接池实例。在同一线程中，Spring会根据事务管理器的配置，为不同的操作分配不同的连接，完全避开了MySQL流式查询对连接的独占限制。

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