[Quarkus] 프로젝트 구조 설정 및 메모리 기반 REST API 구현

.
├── README.md
├── mvnw
├── mvnw.cmd
├── pom.xml
├── qodana.yaml
└── src
    ├── main
    │   ├── docker
    │   ├── java
    │   │   └── com
    │   │       └── nalutbae
    │   │           └── example
    │   │               ├── domain
    │   │               │   ├── Book.java
    │   │               │   ├── CustomRuntimeException.java
    │   │               │   └── enumeration
    │   │               │       └── Genre.java
    │   │               ├── rest
    │   │               │   ├── BookResource.java
    │   │               │   ├── CustomError.java
    │   │               │   └── GlobalErrorHandler.java
    │   │               └── service
    │   │                   └── BookService.java
    │   └── resources
    │       └── application.properties
    └── test
        ├── http
        │   └── book.http
        └── java
            └── com
                └── nalutbae
                    └── example
                        ├── rest
                        │   └── BookResourceTest.java
                        └── service
                            └── BookServiceTest.java

package com.nalutbae.example.domain.enumeration;

public enum Genre {
    FICTION,
    NON_FICTION,
    MYSTERY,
    HORROR,
    ROMANCE,
    SCIENCE_FICTION,
    FANTASY,
    THRILLER,
    BIOGRAPHY,
    HISTORY,
    SELF_HELP,
    POETRY,
    DRAMA,
    COMEDY,
    CHILDREN,
    YOUNG_ADULT
}

package com.nalutbae.example.domain;

import com.nalutbae.example.domain.enumeration.Genre;
import jakarta.validation.constraints.NotBlank;

public class Book {
    private String title;
    private String author;
    private String isbn;
    private Genre genre;
    private String publisher;
    private int yearPublished;

    public Book(String title, String author, String isbn, Genre genre, String publisher, int yearPublished) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.genre = genre;
        this.publisher = publisher;
        this.yearPublished = yearPublished;
    }

    @NotBlank
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    // Another Getters and Setters...
}

package com.nalutbae.example.service;

import com.nalutbae.example.domain.Book;
import com.nalutbae.example.domain.enumeration.Genre;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.Multi;

import javax.enterprise.context.ApplicationScoped;
import java.util.Collection;
import java.util.Comparator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.time.Duration;

@ApplicationScoped
public class BookService {
    private final ConcurrentMap<String, Book> books = new ConcurrentHashMap<>();

    public BookService() {
        // ISBN을 키로 하여 메모리 상에 데이터를 입력
        books.put("9780747532743", new Book("Harry Potter and the Philosopher's Stone", "J.K. Rowling", "9780747532743", Genre.FANTASY, "Bloomsbury Publishing", 1997));
        books.put("9780061120084", new Book("To Kill a Mockingbird", "Harper Lee", "9780061120084", Genre.FICTION, "Harper Perennial Modern Classics", 1960));
        books.put("9780451524935", new Book("1984", "George Orwell", "9780451524935", Genre.SCIENCE_FICTION, "Signet Classics", 1949));
    }

    public Collection<Book> getBooks() {
        return this.books.values();
    }

    public Uni<Book> getBook(String bookId) {
        return Uni.createFrom().item(this.books.get(bookId));
    }

    public Uni<Book> addOrUpdateBook(Book book) {
        this.books.put(book.getIsbn(), book);
        return Uni.createFrom().item(book);
    }

    public Uni<Void> deleteBook(String bookId) {
        this.books.remove(bookId);
        return Uni.createFrom().voidItem();
    }

    public Multi<Book> streamBooks() {
        return Multi.createFrom()
            .ticks()
            .every(Duration.ofSeconds(1))
            .map(tick ->
                this.books.values()
                    .stream()
                    .sorted(Comparator.comparing(Book::getTitle))
                    .toList()
                    .get(tick.intValue())
            )
            .select().first(this.books.size());
    }
}

package com.nalutbae.example.rest;

import com.nalutbae.example.domain.Book;
import com.nalutbae.example.service.BookService;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.Multi;

import javax.inject.Inject;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

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

    @Inject
    BookService bookService;

    @GET
    public Uni<Collection<Book>> getAllBooks() {
        return Uni.createFrom().item(bookService.getBooks());
    }

    @GET
    @Path("/{isbn}")
    public Uni<Response> getBookByIsbn(@PathParam("isbn") String isbn) {
        return bookService.getBook(isbn)
                .onItem().ifNotNull().transform(book -> Response.ok(book).build())
                .onItem().ifNull().continueWith(Response.status(Response.Status.NOT_FOUND).build());
    }

    @POST
    public Uni<Response> createOrUpdateBook(Book book) {
        return bookService.addOrUpdateBook(book)
                .onItem().transform(savedBook -> Response.status(Response.Status.CREATED).entity(savedBook).build());
    }

    @DELETE
    @Path("/{isbn}")
    public Uni<Response> deleteBook(@PathParam("isbn") String isbn) {
        return bookService.deleteBook(isbn)
                .onItem().transform(ignored -> Response.noContent().build());
    }

    @GET
    @Path("/stream")
    @Produces(MediaType.SERVER_SENT_EVENTS)
    public Multi<Book> streamBooks() {
        return bookService.streamBooks();
    }
}

package com.nalutbae.example.rest;

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;

import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.is;

@QuarkusTest
public class BookResourceTest {

    @Test
    public void testGetAllBooks() {
        given()
          .when().get("/books")
          .then()
             .statusCode(200);
    }

    @Test
    public void testGetBookByIsbn() {
        given()
          .when().get("/books/9780747532743")
          .then()
             .statusCode(200)
             .body("title", is("Harry Potter and the Philosopher's Stone"));
    }
}

./mvnw quarkus:dev

import io.smallrye.mutiny.Uni;

public class MyService {

    public Uni<String> getGreeting() {
        return Uni.createFrom().item("Hello, Quarkus!");
    }
}

Uni<String> greeting = service.getGreeting();

greeting
    .onItem().transform(item -> item.toUpperCase())
    .subscribe().with(
        item -> System.out.println("Received: " + item),
        failure -> System.err.println("Failed with " + failure)
    );

import io.smallrye.mutiny.Multi;

public class MyService {

    public Multi<String> getGreetings() {
        return Multi.createFrom().items("Hello", "Hi", "Greetings", "Salutations");
    }
}

Multi<String> greetings = service.getGreetings();
greetings
    .onItem().transform(String::toUpperCase)
    .subscribe().with(
        item -> System.out.println("Received: " + item),
        failure -> System.err.println("Failed with " + failure),
        () -> System.out.println("Completed!")
    );