寻求quarkus-hibernate-reactive-panache结合Panache ORM反应式仓库的示例

我刚好有类似的使用经验，给你分享一个完整的实操示例，完全基于PanacheRepositoryBase和SmallRye Mutiny，适配PostgreSQL数据库：

1. 依赖配置（pom.xml） #

先确保项目引入核心依赖：

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-hibernate-reactive-panache</artifactId>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-reactive-pg-client</artifactId>
</dependency>

2. 实体类定义 #

创建一个简单的Book实体，继承PanacheEntityBase：

import io.quarkus.hibernate.reactive.panache.PanacheEntityBase;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;

@Entity
public class Book extends PanacheEntityBase {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Long id;
    public String title;
    public String author;
    public int publicationYear;
}

3. 反应式仓库实现（基于PanacheRepositoryBase） #

定义仓库接口并继承PanacheRepositoryBase，指定实体和ID类型：

import io.quarkus.hibernate.reactive.panache.PanacheRepositoryBase;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.List;

@ApplicationScoped
public class BookRepository implements PanacheRepositoryBase<Book, Long> {

    // 自定义反应式查询：按作者找书籍
    public Uni<List<Book>> findByAuthor(String author) {
        return find("author", author).list();
    }

    // 自定义反应式查询：按书名找单本
    public Uni<Book> findByTitle(String title) {
        return find("title", title).firstResult();
    }

    // 自定义反应式统计：按出版年份计数
    public Uni<Long> countBooksByYear(int year) {
        return count("publicationYear", year);
    }
}

4. 服务层调用仓库 #

创建服务类注入仓库，封装业务逻辑：

import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.List;

@ApplicationScoped
public class BookService {

    @Inject
    BookRepository bookRepository;

    public Uni<List<Book>> getAllBooks() {
        return bookRepository.listAll();
    }

    public Uni<Book> getBookById(Long id) {
        return bookRepository.findById(id);
    }

    public Uni<Book> createBook(Book book) {
        return bookRepository.persist(book)
                .chain(() -> Uni.createFrom().item(book));
    }

    public Uni<Void> deleteBook(Long id) {
        return bookRepository.deleteById(id);
    }

    public Uni<List<Book>> getBooksByAuthor(String author) {
        return bookRepository.findByAuthor(author);
    }
}

5. REST接口暴露 #

创建控制器层，提供外部访问的API：

import io.smallrye.mutiny.Uni;
import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import java.util.List;

@Path("/books")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class BookResource {

    @Inject
    BookService bookService;

    @GET
    public Uni<List<Book>> getAllBooks() {
        return bookService.getAllBooks();
    }

    @GET
    @Path("/{id}")
    public Uni<Book> getBookById(@PathParam("id") Long id) {
        return bookService.getBookById(id);
    }

    @POST
    public Uni<Book> createBook(Book book) {
        return bookService.createBook(book);
    }

    @DELETE
    @Path("/{id}")
    public Uni<Void> deleteBook(@PathParam("id") Long id) {
        return bookService.deleteBook(id);
    }

    @GET
    @Path("/author/{author}")
    public Uni<List<Book>> getBooksByAuthor(@PathParam("author") String author) {
        return bookService.getBooksByAuthor(author);
    }
}

6. PostgreSQL数据库配置（application.properties） #

最后配置数据库连接信息：

quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=your-db-username
quarkus.datasource.password=your-db-password
quarkus.datasource.reactive.url=postgresql://localhost:5432/your-db-name
quarkus.hibernate-orm.database.generation=update

这个示例覆盖了CRUD操作和自定义查询，完全贴合你想要的PanacheRepositoryBase+反应式+PostgreSQL的组合。另外必须夸夸Quarkus团队，把反应式ORM的复杂度降得这么低，真的做了很棒的工作！

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