admin管理员组
文章数量:1130349

Project Structure

com.example.multidb
├── mysql
│   ├── entity
│   ├── repository
│   └── config
├── postgres
│   ├── entity
│   ├── repository
│   └── config
└── mongodb
    ├── document
    ├── repository
    └── config

Maven (pom.xml):

<dependencies>
    <!-- Spring Boot Starter Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- PostgreSQL Driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>

    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.34</version>
    </dependency>

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

    <!-- Other necessary dependencies -->
    <!-- ... -->
</dependencies>

Setting up Configuration Classes

Set up separate configuration classes for each relational database (PostgreSQL and MySQL) and MongoDB.

PostgreSQL Configuration

Create a configuration class for PostgreSQL in com.example.multidb.postgres.config. package com.example.multidb.postgres.config;


import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.postgres.repository",
    entityManagerFactoryRef = "postgresEntityManagerFactory",
    transactionManagerRef = "postgresTransactionManager"
)
@EntityScan("com.example.multidb.postgres.entity")
public class PostgresConfig {

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

    @Bean(name = "postgresEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean postgresEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("postgresDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.postgres.entity")
                .persistenceUnit("postgres")
                .build();
    }

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

MySQL Configuration

Create a configuration class for MySQL in com.example.multidb.mysql.config.


package com.example.multidb.mysql.config;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.mysql.repository",
    entityManagerFactoryRef = "mysqlEntityManagerFactory",
    transactionManagerRef = "mysqlTransactionManager"
)
@EntityScan("com.example.multidb.mysql.entity")
public class MySQLConfig {

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

    @Bean(name = "mysqlEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("mysqlDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.mysql.entity")
                .persistenceUnit("mysql")
                .build();
    }

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

MongoDB Configuration

For MongoDB, Spring Data MongoDB provides auto-configuration. However, if you need custom configurations, you can define them. Create a configuration class in com.example.multidb.mongodb.config.

package com.example.multidb.mongodb.config;

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

@Configuration
@EnableMongoRepositories(
    basePackages = "com.example.multidb.mongodb.repository",
    mongoTemplateRef = "mongoTemplate"
)
public class MongoConfig {
    // Default configurations are usually sufficient.
    // Customize if necessary.
}

Define Entity and Document Classes

Create entity classes for PostgreSQL and MySQL, and document classes for MongoDB.

PostgreSQL Entity

package com.example.multidb.postgres.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "postgres_entities")
public class PostgresEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    // Other fields, getters, setters
}

MySQL Entity

package com.example.multidb.mysql.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "mysql_entities")
public class MySQLEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String description;
    // Other fields, getters, setters
}

MongoDB

package com.example.multidb.mongodb.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "mongodb_documents")
public class MongoDocument {

    @Id
    private String id;

    private String title;
    // Other fields, getters, setters
}

Create Repository Interfaces

Define repository interfaces for each database type within their respective packages.

PostgreSQL

package com.example.multidb.postgres.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.postgres.entity.PostgresEntity;

@Repository
public interface PostgresEntityRepository extends JpaRepository<PostgresEntity, Long> {
    // Define query methods if needed
}

MySQL Repository

package com.example.multidb.mysql.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mysql.entity.MySQLEntity;

@Repository
public interface MySQLEntityRepository extends JpaRepository<MySQLEntity, Long> {
    // Define query methods if needed
}

MongoDB

package com.example.multidb.mongodb.repository;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mongodb.document.MongoDocument;

@Repository
public interface MongoDocumentRepository extends MongoRepository<MongoDocument, String> {
    // Define query methods if needed
}

Error

Consider defining a bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' in your configuration.

Description:

Parameter 0 of method mysqlEntityManagerFactory in com.example.multidb.mysql.config.MySQLConfig required a bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' that could not be found.

Project Structure

com.example.multidb
├── mysql
│   ├── entity
│   ├── repository
│   └── config
├── postgres
│   ├── entity
│   ├── repository
│   └── config
└── mongodb
    ├── document
    ├── repository
    └── config

Maven (pom.xml):

<dependencies>
    <!-- Spring Boot Starter Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- PostgreSQL Driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>

    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.34</version>
    </dependency>

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

    <!-- Other necessary dependencies -->
    <!-- ... -->
</dependencies>

Setting up Configuration Classes

Set up separate configuration classes for each relational database (PostgreSQL and MySQL) and MongoDB.

PostgreSQL Configuration

Create a configuration class for PostgreSQL in com.example.multidb.postgres.config. package com.example.multidb.postgres.config;


import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.postgres.repository",
    entityManagerFactoryRef = "postgresEntityManagerFactory",
    transactionManagerRef = "postgresTransactionManager"
)
@EntityScan("com.example.multidb.postgres.entity")
public class PostgresConfig {

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

    @Bean(name = "postgresEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean postgresEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("postgresDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.postgres.entity")
                .persistenceUnit("postgres")
                .build();
    }

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

MySQL Configuration

Create a configuration class for MySQL in com.example.multidb.mysql.config.


package com.example.multidb.mysql.config;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.mysql.repository",
    entityManagerFactoryRef = "mysqlEntityManagerFactory",
    transactionManagerRef = "mysqlTransactionManager"
)
@EntityScan("com.example.multidb.mysql.entity")
public class MySQLConfig {

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

    @Bean(name = "mysqlEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("mysqlDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.mysql.entity")
                .persistenceUnit("mysql")
                .build();
    }

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

MongoDB Configuration

For MongoDB, Spring Data MongoDB provides auto-configuration. However, if you need custom configurations, you can define them. Create a configuration class in com.example.multidb.mongodb.config.

package com.example.multidb.mongodb.config;

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

@Configuration
@EnableMongoRepositories(
    basePackages = "com.example.multidb.mongodb.repository",
    mongoTemplateRef = "mongoTemplate"
)
public class MongoConfig {
    // Default configurations are usually sufficient.
    // Customize if necessary.
}

Define Entity and Document Classes

Create entity classes for PostgreSQL and MySQL, and document classes for MongoDB.

PostgreSQL Entity

package com.example.multidb.postgres.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "postgres_entities")
public class PostgresEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    // Other fields, getters, setters
}

MySQL Entity

package com.example.multidb.mysql.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "mysql_entities")
public class MySQLEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String description;
    // Other fields, getters, setters
}

MongoDB

package com.example.multidb.mongodb.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "mongodb_documents")
public class MongoDocument {

    @Id
    private String id;

    private String title;
    // Other fields, getters, setters
}

Create Repository Interfaces

Define repository interfaces for each database type within their respective packages.

PostgreSQL

package com.example.multidb.postgres.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.postgres.entity.PostgresEntity;

@Repository
public interface PostgresEntityRepository extends JpaRepository<PostgresEntity, Long> {
    // Define query methods if needed
}

MySQL Repository

package com.example.multidb.mysql.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mysql.entity.MySQLEntity;

@Repository
public interface MySQLEntityRepository extends JpaRepository<MySQLEntity, Long> {
    // Define query methods if needed
}

MongoDB

package com.example.multidb.mongodb.repository;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mongodb.document.MongoDocument;

@Repository
public interface MongoDocumentRepository extends MongoRepository<MongoDocument, String> {
    // Define query methods if needed
}

Error

Consider defining a bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' in your configuration.

Description:

Share Improve this question edited 2 days ago Shadow 34.2k10 gold badges62 silver badges72 bronze badges asked 2 days ago SHIVAM SINGH 14 bronze badges

Wellyour question is not really clear; I mean... when do you want to use MySQL instead of PostgreSQL or MongoDB? And, in the postgreSQL and mySQL case, why to split entities and repositories? wouldn't they be always the same? In any case, on relational DB side you can use the RoutingDatabase concept provided by spring (spring.io/blog/2007/01/23/dynamic-datasource-routing); in this case by using a custom logic (e.g. a custom HTTP header in requests) you can switch from MySQL to PostgreSQL and viceversa. With mongo you can try to extend the datasource routing concept but I never tried it – Angelo Immediata Commented 2 days ago
I want to Set Up and Manage Multiple Databases in Spring Boot – SHIVAM SINGH Commented 2 days ago

Add a comment |

1 Answer 1

Sorted by: Reset to default 0

EntityManagerFactoryBuilder is a bean provided by org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration which kick in only by org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaConfiguration

@ConditionalOnSingleCandidate(DataSource.class)
class HibernateJpaConfiguration extends JpaBaseConfiguration {

Notice the @ConditionalOnSingleCandidate(DataSource.class), in your case, it is not truthy, hence the exception bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' that could not be found

I see 2 options:

You mark one of your Datasource with @Primay as @ConditionalOnSingleCandidate stipulate "The condition will also match if multiple matching bean instances are already contained in the BeanFactory but a primary candidate has been defined; essentially, the condition match if auto-wiring"
You create an instance of the builder for each datasource with a specific qualifier (like you did for the rest of the beans)

Then it should works just as expected

Project Structure

com.example.multidb
├── mysql
│   ├── entity
│   ├── repository
│   └── config
├── postgres
│   ├── entity
│   ├── repository
│   └── config
└── mongodb
    ├── document
    ├── repository
    └── config

Maven (pom.xml):

<dependencies>
    <!-- Spring Boot Starter Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- PostgreSQL Driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>

    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.34</version>
    </dependency>

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

    <!-- Other necessary dependencies -->
    <!-- ... -->
</dependencies>

Setting up Configuration Classes

Set up separate configuration classes for each relational database (PostgreSQL and MySQL) and MongoDB.

PostgreSQL Configuration

Create a configuration class for PostgreSQL in com.example.multidb.postgres.config. package com.example.multidb.postgres.config;


import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.postgres.repository",
    entityManagerFactoryRef = "postgresEntityManagerFactory",
    transactionManagerRef = "postgresTransactionManager"
)
@EntityScan("com.example.multidb.postgres.entity")
public class PostgresConfig {

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

    @Bean(name = "postgresEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean postgresEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("postgresDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.postgres.entity")
                .persistenceUnit("postgres")
                .build();
    }

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

MySQL Configuration

Create a configuration class for MySQL in com.example.multidb.mysql.config.


package com.example.multidb.mysql.config;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.mysql.repository",
    entityManagerFactoryRef = "mysqlEntityManagerFactory",
    transactionManagerRef = "mysqlTransactionManager"
)
@EntityScan("com.example.multidb.mysql.entity")
public class MySQLConfig {

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

    @Bean(name = "mysqlEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("mysqlDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.mysql.entity")
                .persistenceUnit("mysql")
                .build();
    }

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

MongoDB Configuration

For MongoDB, Spring Data MongoDB provides auto-configuration. However, if you need custom configurations, you can define them. Create a configuration class in com.example.multidb.mongodb.config.

package com.example.multidb.mongodb.config;

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

@Configuration
@EnableMongoRepositories(
    basePackages = "com.example.multidb.mongodb.repository",
    mongoTemplateRef = "mongoTemplate"
)
public class MongoConfig {
    // Default configurations are usually sufficient.
    // Customize if necessary.
}

Define Entity and Document Classes

Create entity classes for PostgreSQL and MySQL, and document classes for MongoDB.

PostgreSQL Entity

package com.example.multidb.postgres.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "postgres_entities")
public class PostgresEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    // Other fields, getters, setters
}

MySQL Entity

package com.example.multidb.mysql.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "mysql_entities")
public class MySQLEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String description;
    // Other fields, getters, setters
}

MongoDB

package com.example.multidb.mongodb.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "mongodb_documents")
public class MongoDocument {

    @Id
    private String id;

    private String title;
    // Other fields, getters, setters
}

Create Repository Interfaces

Define repository interfaces for each database type within their respective packages.

PostgreSQL

package com.example.multidb.postgres.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.postgres.entity.PostgresEntity;

@Repository
public interface PostgresEntityRepository extends JpaRepository<PostgresEntity, Long> {
    // Define query methods if needed
}

MySQL Repository

package com.example.multidb.mysql.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mysql.entity.MySQLEntity;

@Repository
public interface MySQLEntityRepository extends JpaRepository<MySQLEntity, Long> {
    // Define query methods if needed
}

MongoDB

package com.example.multidb.mongodb.repository;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mongodb.document.MongoDocument;

@Repository
public interface MongoDocumentRepository extends MongoRepository<MongoDocument, String> {
    // Define query methods if needed
}

Error

Consider defining a bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' in your configuration.

Description:

Project Structure

com.example.multidb
├── mysql
│   ├── entity
│   ├── repository
│   └── config
├── postgres
│   ├── entity
│   ├── repository
│   └── config
└── mongodb
    ├── document
    ├── repository
    └── config

Maven (pom.xml):

<dependencies>
    <!-- Spring Boot Starter Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- PostgreSQL Driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>

    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.34</version>
    </dependency>

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

    <!-- Other necessary dependencies -->
    <!-- ... -->
</dependencies>

Setting up Configuration Classes

Set up separate configuration classes for each relational database (PostgreSQL and MySQL) and MongoDB.

PostgreSQL Configuration

Create a configuration class for PostgreSQL in com.example.multidb.postgres.config. package com.example.multidb.postgres.config;


import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.postgres.repository",
    entityManagerFactoryRef = "postgresEntityManagerFactory",
    transactionManagerRef = "postgresTransactionManager"
)
@EntityScan("com.example.multidb.postgres.entity")
public class PostgresConfig {

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

    @Bean(name = "postgresEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean postgresEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("postgresDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.postgres.entity")
                .persistenceUnit("postgres")
                .build();
    }

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

MySQL Configuration

Create a configuration class for MySQL in com.example.multidb.mysql.config.


package com.example.multidb.mysql.config;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.multidb.mysql.repository",
    entityManagerFactoryRef = "mysqlEntityManagerFactory",
    transactionManagerRef = "mysqlTransactionManager"
)
@EntityScan("com.example.multidb.mysql.entity")
public class MySQLConfig {

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

    @Bean(name = "mysqlEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("mysqlDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.multidb.mysql.entity")
                .persistenceUnit("mysql")
                .build();
    }

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

MongoDB Configuration

For MongoDB, Spring Data MongoDB provides auto-configuration. However, if you need custom configurations, you can define them. Create a configuration class in com.example.multidb.mongodb.config.

package com.example.multidb.mongodb.config;

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

@Configuration
@EnableMongoRepositories(
    basePackages = "com.example.multidb.mongodb.repository",
    mongoTemplateRef = "mongoTemplate"
)
public class MongoConfig {
    // Default configurations are usually sufficient.
    // Customize if necessary.
}

Define Entity and Document Classes

Create entity classes for PostgreSQL and MySQL, and document classes for MongoDB.

PostgreSQL Entity

package com.example.multidb.postgres.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "postgres_entities")
public class PostgresEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    // Other fields, getters, setters
}

MySQL Entity

package com.example.multidb.mysql.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "mysql_entities")
public class MySQLEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String description;
    // Other fields, getters, setters
}

MongoDB

package com.example.multidb.mongodb.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "mongodb_documents")
public class MongoDocument {

    @Id
    private String id;

    private String title;
    // Other fields, getters, setters
}

Create Repository Interfaces

Define repository interfaces for each database type within their respective packages.

PostgreSQL

package com.example.multidb.postgres.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.postgres.entity.PostgresEntity;

@Repository
public interface PostgresEntityRepository extends JpaRepository<PostgresEntity, Long> {
    // Define query methods if needed
}

MySQL Repository

package com.example.multidb.mysql.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mysql.entity.MySQLEntity;

@Repository
public interface MySQLEntityRepository extends JpaRepository<MySQLEntity, Long> {
    // Define query methods if needed
}

MongoDB

package com.example.multidb.mongodb.repository;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import com.example.multidb.mongodb.document.MongoDocument;

@Repository
public interface MongoDocumentRepository extends MongoRepository<MongoDocument, String> {
    // Define query methods if needed
}

Error

Consider defining a bean of type 'org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder' in your configuration.

Description:

Share Improve this question edited 2 days ago Shadow 34.2k10 gold badges62 silver badges72 bronze badges asked 2 days ago SHIVAM SINGH 14 bronze badges

Wellyour question is not really clear; I mean... when do you want to use MySQL instead of PostgreSQL or MongoDB? And, in the postgreSQL and mySQL case, why to split entities and repositories? wouldn't they be always the same? In any case, on relational DB side you can use the RoutingDatabase concept provided by spring (spring.io/blog/2007/01/23/dynamic-datasource-routing); in this case by using a custom logic (e.g. a custom HTTP header in requests) you can switch from MySQL to PostgreSQL and viceversa. With mongo you can try to extend the datasource routing concept but I never tried it – Angelo Immediata Commented 2 days ago
I want to Set Up and Manage Multiple Databases in Spring Boot – SHIVAM SINGH Commented 2 days ago

Add a comment |

1 Answer 1

Sorted by: Reset to default 0

@ConditionalOnSingleCandidate(DataSource.class)
class HibernateJpaConfiguration extends JpaBaseConfiguration {

I see 2 options:

You mark one of your Datasource with @Primay as @ConditionalOnSingleCandidate stipulate "The condition will also match if multiple matching bean instances are already contained in the BeanFactory but a primary candidate has been defined; essentially, the condition match if auto-wiring"
You create an instance of the builder for each datasource with a specific qualifier (like you did for the rest of the beans)

Then it should works just as expected

本文标签：

版权声明：本文标题：jpa - How Configuring Multiple Databases (PostgreSQL, MongoDB, and MySQL) in a Spring Boot project? - Stack Overflow 内容由热心网友自发贡献，该文观点仅代表作者本人，转载请联系作者并注明出处：https://it.en369.cn/questions/1735923635a1358670.html，本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。

369IT编程

jpa - How Configuring Multiple Databases (PostgreSQL, MongoDB, and MySQL) in a Spring Boot project? - Stack Overflow

Project Structure

Maven (pom.xml):

Setting up Configuration Classes

PostgreSQL Configuration

MySQL Configuration

MongoDB Configuration

Define Entity and Document Classes

Create Repository Interfaces

PostgreSQL

MySQL Repository

MongoDB

Error

Project Structure

Maven (pom.xml):

Setting up Configuration Classes

PostgreSQL Configuration

MySQL Configuration

MongoDB Configuration

Define Entity and Document Classes

Create Repository Interfaces

PostgreSQL

MySQL Repository

MongoDB

Error

1 Answer 1

Project Structure

Maven (pom.xml):

Setting up Configuration Classes

PostgreSQL Configuration

MySQL Configuration

MongoDB Configuration

Define Entity and Document Classes

Create Repository Interfaces

PostgreSQL

MySQL Repository

MongoDB

Error

Project Structure

Maven (pom.xml):

Setting up Configuration Classes

PostgreSQL Configuration

MySQL Configuration

MongoDB Configuration

Define Entity and Document Classes

Create Repository Interfaces

PostgreSQL

MySQL Repository

MongoDB

Error

1 Answer 1

更多相关文章

MySQL5.7.32 64位解压缩版 windows操作系统安装教程图解

计算机基础----32位操作系统和64位操作系统的区别

STM32的USB虚拟串口驱动在Windows 7 64位和32位系统上无法正常安装的解决办法-STM虚拟串口驱动在Windows 7上的终极解决方案

7zip下载、安装

windows下，python3.6 32位、64位共存及开发工具vscode配置

关于Windows 7 64位系统 HP M1319f 打印机无法扫描的解决办法

在win7 32位系统中安装配置Python的机器学习包scikit-learn

64位windows下安装eclipse及其所需32位版JDK详细教程

32位系统无法运行64位系统安装文件

计算机怎么弄64位,64位系统怎么装？安装64位系统教程

32位系统安装 64位windows 7的方法

Windows XP2000Vista788.110系统 hosts文件位置及使用

JetBrains PyCharm windows32位 安装

jumpserver 修改源码实现密钥+密码

【免费下载】 VNCViewer 注册码资源下载

Royal TSX许可证密钥(6.x后所有版本都可以用)

【亲测免费】 Proxifer 安装包与注册码

【亲测免费】 抖音直播伴侣推流密钥获取工具使用教程

windows下载安装远程桌面工具RealVNC-Server教程(RealVNC_E4_6_1版带注册码)

Sublime 32位 激活码

发表评论

推荐文章

2011年度国内10佳Android应用

东方时尚网上约车的用户名密码是什么_路由器的登录名与密码忘了怎么解决【解决方法】...

bonsai软件使用经验（1）

老人与海好词100英文带翻译_老人与海英文版好词好句摘抄

【Tools】VMware Workstation 17 Pro安装教程

JetBrains PyCharm windows32位安装

【亲测免费】抖音直播伴侣推流密钥获取工具使用教程

Sublime 32位激活码

Sublime 32位激活码

【亲测免费】抖音直播伴侣推流密钥获取工具使用教程