SpringBoot开发Mongo到Postgres迁移工具：双库连接配置问题

核心问题分析 #

你遇到的两个错误本质是混淆了关系型数据库（PostgreSQL）和NoSQL数据库（MongoDB）的接入方式：

1. dataSource or dataSourceClassName or jdbcUrl is required.：MongoDB不是JDBC兼容数据库，不能放在spring.datasource下配置，且配置类中@ConfigurationProperties的路径与yml不匹配。
2. Access to DialectResolutionInfo cannot be null...：Hibernate（JPA）仅支持关系型数据库，不存在MongoDBDialect，不能用JPA连接MongoDB。

正确解决方案 #

需要分开配置Spring Data JPA（处理PostgreSQL）和Spring Data MongoDB（处理MongoDB），两者是独立的技术栈，不能共用一套JPA配置。

1. 确保依赖正确

在pom.xml（Maven）中引入对应依赖：

<!-- PostgreSQL + Spring Data JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- Spring Data MongoDB -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

2. 修正application.yml配置

将PostgreSQL作为JDBC数据源配置，MongoDB单独配置（不要放在spring.datasource下）：

spring:
  # PostgreSQL 配置
  datasource:
    legacy:
      url: jdbc:postgresql://localhost:5432/postgres
      username: root
      password: root
      driver-class-name: org.postgresql.Driver
  # MongoDB 配置
  data:
    mongodb:
      uri: mongodb://root:root@localhost:27017/fromdb
  # JPA 全局配置（针对PostgreSQL）
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        physical_naming_strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
        implicit_naming_strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy

3. 配置PostgreSQL的JPA数据源

创建单独的配置类，隔离PostgreSQL的JPA相关配置：

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = "com.dbmigrater.repository.legacy", // PostgreSQL的Repository包
        entityManagerFactoryRef = "legacyEntityManagerFactory",
        transactionManagerRef = "legacyTransactionManager"
)
public class LegacyPostgreSQLConfig {

    @Primary
    @Bean(name = "legacyDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.legacy")
    public DataSource legacyDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean(name = "legacyEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean legacyEntityManagerFactory(EntityManagerFactoryBuilder builder,
                                                                             @Qualifier("legacyDataSource") DataSource dataSource) {
        Map<String, Object> properties = new HashMap<>();
        properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
        properties.put("hibernate.physical_naming_strategy", "org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy");
        properties.put("hibernate.implicit_naming_strategy", "org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy");

        return builder
                .dataSource(dataSource)
                .packages("com.dbmigrater.model.legacy") // PostgreSQL的实体类包
                .persistenceUnit("legacyPU")
                .properties(properties)
                .build();
    }

    @Primary
    @Bean(name = "legacyTransactionManager")
    public PlatformTransactionManager legacyTransactionManager(
            @Qualifier("legacyEntityManagerFactory") LocalContainerEntityManagerFactoryBean legacyEntityManagerFactory) {
        return new JpaTransactionManager(legacyEntityManagerFactory.getObject());
    }
}

4. 配置MongoDB的数据源

创建MongoDB专属配置类，指定Repository扫描路径：

import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

@Configuration
@EnableMongoRepositories(basePackages = "com.dbmigrater.repository.migration") // MongoDB的Repository包
public class MigrationMongoDBConfig {
    // Spring Boot会自动读取spring.data.mongodb的配置，无需额外手动配置数据源
}

5. 编写对应的Repository

• PostgreSQL的Repository（继承JpaRepository）：

package com.dbmigrater.repository.legacy;

import com.dbmigrater.model.legacy.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface LegacyUserRepository extends JpaRepository<User, Long> {
}

• MongoDB的Repository（继承MongoRepository）：

package com.dbmigrater.repository.migration;

import com.dbmigrater.model.migration.MongoUser;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface MongoUserRepository extends MongoRepository<MongoUser, String> {
}

关键说明 #

• 不要用JPA连接MongoDB：JPA是关系型数据库的规范，MongoDB是文档型NoSQL，需用Spring Data MongoDB接入，它有自己的Repository和操作模板（MongoTemplate）。
• 双数据源的核心是隔离两个技术栈的配置：分别指定各自的Repository包、实体类包，避免Spring自动扫描时混淆。

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