java一个系统连接两个数据库yml配置

原创

mob64ca12f5c08e 2024-09-18 04:17:56 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12f5c08e的原创作品，请联系作者获取转载授权，否则将追究法律责任

在 Java 中配置多个数据库连接

在 Java 开发中，连接多个数据库的场景并不少见，特别是在微服务架构中，每个服务可能会使用不同的数据库。为了实现这一功能，通常我们会使用 Spring Boot 框架，这样可以通过配置文件（如 YML）来简化我们的代码。本文将详细讲述如何在 Spring Boot 项目中连接两个数据库，并给出具体的步骤、代码和结构图。

流程概述

下面是实现 Java 连接两个数据库的详细步骤：

步骤	说明
1	创建 Spring Boot 项目
2	添加依赖
3	配置 application.yml 文件
4	创建数据源配置类
5	创建实体类
6	创建 Repository 接口
7	测试数据库连接

步骤详细说明

步骤 1: 创建 Spring Boot 项目

可以使用 Spring Initializr ( 创建一个新的 Spring Boot 项目。选择以下选项：

项目：Maven Project
语言：Java
Spring Boot：2.x.x
依赖：Spring Web, Spring Data JPA, MySQL Driver

步骤 2: 添加依赖

在 pom.xml 文件中添加两个数据库所需的依赖（以 MySQL 为例）：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>

步骤 3: 配置 application.yml 文件

在 src/main/resources 目录下创建 application.yml 配置文件，定义两个数据源的配置。

spring:
  datasource:
    first-db:
      url: jdbc:mysql://localhost:3306/first_database
      username: root
      password: your_password
      driver-class-name: com.mysql.cj.jdbc.Driver
      
    second-db:
      url: jdbc:mysql://localhost:3306/second_database
      username: root
      password: your_password
      driver-class-name: com.mysql.cj.jdbc.Driver

步骤 4: 创建数据源配置类

接下来，我们需要创建两个配置类来管理数据库的连接。这些类会指定每个数据源的名称。

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.boot.jdbc.DataSourceBuilder;
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.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

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

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.repository.first", // 第一数据库的 Repository
    entityManagerFactoryRef = "firstEntityManagerFactory",
    transactionManagerRef = "firstTransactionManager"
)
public class FirstDatabaseConfig {
    
    @Bean(name = "firstDataSource")
    public DataSource firstDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "firstEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
        return builder
            .dataSource(firstDataSource())
            .packages("com.example.model.first") // 第一数据库的实体类
            .persistenceUnit("first")
            .build();
    }

    @Bean(name = "firstTransactionManager")
    public PlatformTransactionManager firstTransactionManager(
        @Qualifier("firstEntityManagerFactory") EntityManagerFactory firstEntityManagerFactory) {
        return new JpaTransactionManager(firstEntityManagerFactory);
    }
}

同样，我们需要为第二个数据库创建一个类似的配置类：

@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.repository.second", // 第二数据库的 Repository
    entityManagerFactoryRef = "secondEntityManagerFactory",
    transactionManagerRef = "secondTransactionManager"
)
public class SecondDatabaseConfig {
    
    @Bean(name = "secondDataSource")
    public DataSource secondDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
        return builder
            .dataSource(secondDataSource())
            .packages("com.example.model.second") // 第二数据库的实体类
            .persistenceUnit("second")
            .build();
    }

    @Bean(name = "secondTransactionManager")
    public PlatformTransactionManager secondTransactionManager(
        @Qualifier("secondEntityManagerFactory") EntityManagerFactory secondEntityManagerFactory) {
        return new JpaTransactionManager(secondEntityManagerFactory);
    }
}

步骤 5: 创建实体类

分别在两个不同的包中创建数据模型类（实体类）。

第一数据库实体类：

package com.example.model.first;

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

@Entity
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // getters and setters
}

第二数据库实体类：

package com.example.model.second;

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

@Entity
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String orderDetails;
    
    // getters and setters
}

步骤 6: 创建 Repository 接口

为每个实体类创建 Repository 接口。

第一数据库 Repository：

package com.example.repository.first;

import com.example.model.first.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

第二数据库 Repository：

package com.example.repository.second;

import com.example.model.second.Order;
import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
}

步骤 7: 测试数据库连接

可以创建一个简单的控制器，来测试两个数据库的连接。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private OrderRepository orderRepository;

    @GetMapping("/test")
    public String testDatabases() {
        userRepository.save(new User("Alice"));
        orderRepository.save(new Order("Order 1"));
        return "Data saved in both databases!";
    }
}

类图

以下是类图示例，描述项目的结构。

classDiagram
    class User {
        + Long id
        + String name
        + getId()
        + getName()
        + setId(Long id)
        + setName(String name)
    }

    class Order {
        + Long id
        + String orderDetails
        + getId()
        + getOrderDetails()
        + setId(Long id)
        + setOrderDetails(String orderDetails)
    }
    
    class UserRepository {
        + List<User> findAll()
        + User save(User user)
    }

    class OrderRepository {
        + List<Order> findAll()
        + Order save(Order order)
    }

    User --> UserRepository
    Order --> OrderRepository

流程图

以下是一个简单的流程图，展示连接两个数据库的步骤。

journey
    title 连接两个数据库的流程
    section 创建项目
      通过 Spring Initializr 创建项目: 5: Project
    section 添加依赖
      在 pom.xml 中添加 MySQL 依赖: 3: Developer
    section 配置 YML
      在 application.yml 中配置两个数据库: 4: Developer
    section 创建配置类
      创建 FirstDatabaseConfig 和 SecondDatabaseConfig 类: 5: Developer
    section 创建实体类
      创建 User 和 Order 实体类: 5: Developer
    section 创建 Repository
      创建 UserRepository 和 OrderRepository 接口: 5: Developer
    section 测试连接
      通过控制器测试数据库连接: 4: Developer

结尾

通过以上步骤，我们实现了一个简单的 Java 应用程序，连接了两个不同的数据库。这种结构可以帮助我们在更复杂的应用中切换和扩展功能。希望这篇文章能帮助刚入行的小白们快速实现自己的需求，如果有任何问题，欢迎随时询问！

上一篇：mysql 导入 dat文件

下一篇：java规则引擎ui

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯