在 Quarkus 应用中配置与管理多类型数据库持久化-java教程-PHP中文网

在 Quarkus 应用中配置与管理多类型数据库持久化

本教程详细阐述了如何在 quarkus 应用中集成并使用多种不同类型的数据库，例如 postgresql 和 mysql。文章涵盖了多数据源的配置、hibernate orm 多持久化单元的设置，以及如何将实体与特定数据库关联并进行数据持久化操作，旨在提供清晰的实践指导。

Quarkus 多数据源配置

Quarkus 框架原生支持在单个应用中配置和使用多个数据源，即使这些数据源是不同类型的数据库。这通过在 application.properties 文件中为每个数据源定义独立的配置前缀来实现。

首先，确保 pom.xml 中包含了相应数据库的 JDBC 驱动依赖。例如，对于 PostgreSQL 和 MySQL：

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-jdbc-postgresql</artifactId>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-jdbc-mysql</artifactId>
</dependency>

登录后复制

接着，在 application.properties 文件中为每个数据源指定配置。Quarkus 推荐使用 quarkus.datasource.<datasource-name> 的命名约定。

# PostgreSQL 数据源配置
quarkus.datasource.pg.db-kind=postgresql
quarkus.datasource.pg.username=pg_user
quarkus.datasource.pg.password=pg_password
quarkus.datasource.pg.jdbc.url=jdbc:postgresql://localhost:5432/pg_db
quarkus.datasource.pg.max-pool-size=10

# MySQL 数据源配置
quarkus.datasource.mysql.db-kind=mysql
quarkus.datasource.mysql.username=mysql_user
quarkus.datasource.mysql.password=mysql_password
quarkus.datasource.mysql.jdbc.url=jdbc:mysql://localhost:3306/mysql_db
quarkus.datasource.mysql.max-pool-size=10

登录后复制

在上述配置中，pg 和 mysql 是我们为各自数据源定义的逻辑名称。这些名称将在后续的持久化单元配置中被引用。

配置 Hibernate ORM 多持久化单元

仅仅配置了多个数据源不足以让 Hibernate ORM 知道如何将实体映射到特定的数据库。为此，我们需要为每个数据源定义一个独立的 Hibernate ORM 持久化单元 (Persistence Unit)。

每个持久化单元都需要通过 quarkus.hibernate-orm.<persistence-unit-name> 前缀进行配置，并明确关联到一个已定义的数据源。

# PostgreSQL 数据源的持久化单元
quarkus.hibernate-orm.pg-unit.datasource=pg
quarkus.hibernate-orm.pg-unit.packages=com.example.pg.entities
quarkus.hibernate-orm.pg-unit.generate-ddl=true # 根据实体自动生成表结构

# MySQL 数据源的持久化单元
quarkus.hibernate-orm.mysql-unit.datasource=mysql
quarkus.hibernate-orm.mysql-unit.packages=com.example.mysql.entities
quarkus.hibernate-orm.mysql-unit.generate-ddl=true # 根据实体自动生成表结构

登录后复制

这里，pg-unit 和 mysql-unit 是我们定义的持久化单元名称。datasource 属性将持久化单元与前面定义的数据源关联起来。packages 属性则指示 Hibernate ORM 扫描指定包下的实体类，将它们归属于当前持久化单元。通过 generate-ddl=true，Quarkus 会在应用启动时为每个持久化单元自动创建或更新其关联数据库中的表结构。

实体与持久化操作

为了将实体持久化到正确的数据库，我们需要确保：

实体类被正确地扫描并关联到相应的持久化单元。
在执行持久化操作时，使用对应持久化单元的 EntityManager。

1. 实体类组织

建议将属于不同数据库的实体类放置在不同的 Java 包中，以便通过 quarkus.hibernate-orm.<persistence-unit-name>.packages 进行精确控制。

v3.4.0智睿报修管理系统

智睿报修管理系统定位行政企业，单位，机关加快网络无纸办公化，网络信息报修管理系统，系统支持城市区域模块管理，会员信息模块，报修种类，维修工人信息显示，达到快速准确到位，支持在线打印，数据导出，汇总数据,报修次数统计。本系统为免费版本，不收取任何费用，可直接使用。功能模块：权限设置 - 可设多个管理员，自由分配选项管理权限数据备份 - 支持在线数据库备份及还原数据库类别管理 - 支持

161

查看详情

例如：

com.example.pg.entities.PgProduct 对应 PostgreSQL
com.example.mysql.entities.MySqlOrder 对应 MySQL

// src/main/java/com/example/pg/entities/PgProduct.java
package com.example.pg.entities;

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;

@Entity
@Table(name = "products") // 明确表名
public class PgProduct extends PanacheEntity {
    public String name;
    public double price;

    public PgProduct() {
    }

    public PgProduct(String name, double price) {
        this.name = name;
        this.price = price;
    }
}

登录后复制

// src/main/java/com/example/mysql/entities/MySqlOrder.java
package com.example.mysql.entities;

import io.quarkus.hibernate.orm.panache.PanacheEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;

@Entity
@Table(name = "orders") // 明确表名
public class MySqlOrder extends PanacheEntity {
    public String orderNumber;
    public int quantity;

    public MySqlOrder() {
    }

    public MySqlOrder(String orderNumber, int quantity) {
        this.orderNumber = orderNumber;
        this.quantity = quantity;
    }
}

登录后复制

2. 使用特定持久化单元的 EntityManager

Quarkus 允许通过 @PersistenceContext 注解结合持久化单元名称来注入特定的 EntityManager。

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.transaction.Transactional;

import com.example.pg.entities.PgProduct;
import com.example.mysql.entities.MySqlOrder;

@ApplicationScoped
public class MultiDbService {

    // 注入用于 PostgreSQL 的 EntityManager
    @Inject
    @PersistenceContext(unitName = "pg-unit")
    EntityManager pgEntityManager;

    // 注入用于 MySQL 的 EntityManager
    @Inject
    @PersistenceContext(unitName = "mysql-unit")
    EntityManager mysqlEntityManager;

    @Transactional
    public void createPgProduct(String name, double price) {
        PgProduct product = new PgProduct(name, price);
        pgEntityManager.persist(product);
    }

    @Transactional
    public void createMySqlOrder(String orderNumber, int quantity) {
        MySqlOrder order = new MySqlOrder(orderNumber, quantity);
        mysqlEntityManager.persist(order);
    }
}

登录后复制

3. 使用 Panache ORM 进行操作

对于 Panache 用户，可以通过 Panache.using() 方法来指定操作的持久化单元，或者为每个持久化单元创建独立的 Panache Repository。

方法一：使用 Panache.using() 动态切换持久化单元

import io.quarkus.hibernate.orm.panache.Panache;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.transaction.Transactional;

import com.example.pg.entities.PgProduct;
import com.example.mysql.entities.MySqlOrder;

@ApplicationScoped
public class PanacheMultiDbService {

    @Transactional
    public void createPgProductWithPanache(String name, double price) {
        // 在 pg-unit 上下文中执行操作
        Panache.using("pg-unit", () -> {
            PgProduct product = new PgProduct(name, price);
            product.persist(); // 此操作将使用 pg-unit 的 EntityManager
        });
    }

    @Transactional
    public void createMySqlOrderWithPanache(String orderNumber, int quantity) {
        // 在 mysql-unit 上下文中执行操作
        Panache.using("mysql-unit", () -> {
            MySqlOrder order = new MySqlOrder(orderNumber, quantity);
            order.persist(); // 此操作将使用 mysql-unit 的 EntityManager
        });
    }
}

登录后复制

方法二：为每个持久化单元创建独立的 Panache Repository

这种方法更适用于当您希望为每个数据库实体拥有独立的、类型安全的 Repository 接口时。

// src/main/java/com/example/pg/repositories/PgProductRepository.java
package com.example.pg.repositories;

import com.example.pg.entities.PgProduct;
import io.quarkus.hibernate.orm.panache.PanacheRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.PersistenceUnit;

@ApplicationScoped
@PersistenceUnit("pg-unit") // 指定此 Repository 关联的持久化单元
public class PgProductRepository implements PanacheRepository<PgProduct> {
    // 可以添加自定义查询方法
}

登录后复制

// src/main/java/com/example/mysql/repositories/MySqlOrderRepository.java
package com.example.mysql.repositories;

import com.example.mysql.entities.MySqlOrder;
import io.quarkus.hibernate.orm.panache.PanacheRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.PersistenceUnit;

@ApplicationScoped
@PersistenceUnit("mysql-unit") // 指定此 Repository 关联的持久化单元
public class MySqlOrderRepository implements PanacheRepository<MySqlOrder> {
    // 可以添加自定义查询方法
}

登录后复制

然后，您可以在服务中注入并使用这些 Repository：

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;

import com.example.pg.repositories.PgProductRepository;
import com.example.mysql.repositories.MySqlOrderRepository;

@ApplicationScoped
public class RepositoryMultiDbService {

    @Inject
    PgProductRepository pgProductRepository;

    @Inject
    MySqlOrderRepository mySqlOrderRepository;

    @Transactional
    public void createPgProductViaRepo(String name, double price) {
        PgProduct product = new PgProduct(name, price);
        pgProductRepository.persist(product);
    }

    @Transactional
    public void createMySqlOrderViaRepo(String orderNumber, int quantity) {
        MySqlOrder order = new MySqlOrder(orderNumber, quantity);
        mySqlOrderRepository.persist(order);
    }
}

登录后复制

注意事项

事务管理： 默认情况下，Quarkus 的 @Transactional 注解管理的是当前线程的默认事务。当涉及多个数据库时，如果需要跨数据库的原子性操作（即分布式事务，XA 事务），会增加显著的复杂性，通常需要额外的配置和协调器。对于不要求强一致性的独立操作，使用各自数据库的本地事务通常是更简单且性能更好的选择。
命名清晰： 为数据源和持久化单元选择清晰、有意义的名称（如 pg-unit, mysql-unit），有助于提高代码的可读性和可维护性。

以上就是在 Quarkus 应用中配置与管理多类型数据库持久化的详细内容，更多请关注php中文网其它相关文章！