Integrar MongoDB com Quartokus

Verifique os pré-requisitos.

Para criar o aplicativo Quick Start, instale o seguinte software em seu ambiente de desenvolvimento:

Criar um cluster MongoDB Atlas .

O MongoDB Atlas é um serviço de banco de dados de nuvem totalmente gerenciado que hospeda suas implementações do MongoDB . Se você não tiver uma implementação do MongoDB , poderá criar um cluster do MongoDB gratuitamente concluindo o tutorial de Introdução ao MongoDB . O tutorial de Introdução ao MongoDB também demonstra como carregar conjuntos de dados de exemplo em seu cluster, incluindo o sample_restaurants banco de dados usado neste tutorial.

Para se conectar ao cluster MongoDB , você deve usar uma string de conexão. Para saber como recuperar sua string de conexão, consulte a seção Adicionar sua string de conexão do tutorial de Introdução ao MongoDB .

Crie seu projeto no Quartokus .

A partir do seu terminal, execute o seguinte comando para criar um novo projeto Quartokus denominado quarkus-quickstart que configura a Extensão JNoSQL do Horakus para MongoDB e serialização JSON para endpoints REST:

quarkus create app quarkus-quickstart --extensions=jnosql-mongodb,resteasy-jackson

Em seguida, navegue até o diretório do projeto executando o seguinte comando:

cd quarkus-quickstart

Configure sua conexão do banco de dados .

Navegue até o arquivo src/main/resources/application.properties e adicione as seguintes propriedades de configuração:

jnosql.document.database=sample_restaurants
quarkus.mongodb.connection-string=<connection string>

Este código configura sua conexão com o sample_restaurants banco de dados do em seu agrupamento MongoDB . Substitua <connection string> o espaço reservado pela string de conexão que você salvou em uma etapa anterior.

Limpe os arquivos de modelo.

O modelo de projeto Quarkus inclui alguns arquivos de exemplo que você pode remover para este tutorial. Para excluir estes arquivos desnecessários, selecione a guia correspondente ao seu sistema operacional e execute os seguintes comandos do diretório quarkus-quickstart:

rm src/main/java/org/acme/Car.java
rm src/main/java/org/acme/Garage.java
rm src/test/java/org/acme/GarageTest.java
rm src/main/java/org/acme/GreetingResource.java
rm src/test/java/org/acme/GreetingResourceIT.java
rm src/test/java/org/acme/GreetingResourceTest.java

del src/main/java/org/acme/Car.java
del src/main/java/org/acme/Garage.java
del src/test/java/org/acme/GarageTest.java
del src/main/java/org/acme/GreetingResource.java
del src/test/java/org/acme/GreetingResourceIT.java
del src/test/java/org/acme/GreetingResourceTest.java

Criar o Restaurant modelo.

Crie um arquivo denominado Restaurant.java no diretório src/main/java/org/acme e cole o seguinte código:

package org.acme;
import jakarta.nosql.Column;
import jakarta.nosql.Entity;
import jakarta.nosql.Id;
/**
 * Represents a restaurant entity from the sample_restaurants database .
 * This class is used as an entity in the MongoDB database.
 */
@Entity("restaurants")
public class Restaurant {
    
    @Id 
    private String id;
    
    @Column 
    private String name;
    
    @Column 
    private String borough;
    
    @Column 
    private String cuisine;
    // Default constructor required by JNoSQL
    public Restaurant() {}
    // Constructor
    public Restaurant(String id, String name, String borough,String cuisine) {
        this.id = id;
        this.name = name;
        this.borough = borough;
        this.cuisine = cuisine;
    }
    // Getters and setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getBorough() { return borough; }
    public void setBorough(String borough) { this.borough = borough; }
    
    public String getCuisine() { return cuisine; }
    public void setCuisine(String cuisine) { this.cuisine = cuisine; }
}

Este arquivo define a classe de entidade Restaurant , que mapeia para documentos na coleção sample_restaurants.restaurants. A anotação @Entity marca esta classe como uma entidade JNoSQL e as anotações de campo mapeiam propriedades Java para campos de documento .

Crie a classe de repositório .

Crie um arquivo denominado RestaurantRepository.java no diretório src/main/java/org/acme e cole o seguinte código:

package org.acme;
import jakarta.data.repository.Repository;
import org.eclipse.jnosql.mapping.NoSQLRepository;
import java.util.List;
/**
 * Interface for managing restaurant data.
 *
 * It uses the Jakarta Data Specification capabilities.
 *
 */
@Repository
public interface RestaurantRepository extends NoSQLRepository<Restaurant, String> {
    List<Restaurant> findByBorough(String borough);
    List<Restaurant> findByCuisine(String cuisine);
}

Esta classe de repositório fornece métodos para acessar dados de restaurantes no MongoDB. Ela define métodos de query personalizados do findByBorough() e findByCuisine(), e você também pode utilizar uma instância do RestaurantRepository para acessar os métodos integrados de criação, leitura, atualização e exclusão.

Crie a classe de recurso REST.

No diretório src/main/java/org/acme, crie um arquivo denominado RestaurantResource.java e cole o seguinte código:

package org.acme;
import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.util.List;
/**
 * REST API controller for restaurant operations.
 * Provides endpoints for retrieving restaurant data from MongoDB.
 */
@Path("/restaurants")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class RestaurantResource {
    @Inject
    RestaurantRepository restaurantRepository;
    /**
     * Retrieves all restaurants from the database.
     * 
     * @return List of all restaurants
     */
    @GET
    public Response getAllRestaurants() {
        try {
            List<Restaurant> restaurants = restaurantRepository.findAll().toList();
            System.out.println("Found " + restaurants.size() + " restaurants");
            return Response.ok(restaurants).build();
        } catch (Exception e) {
            e.printStackTrace();
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity("Error retrieving restaurants: " + e.getMessage())
                    .build();
        }
    }
    /**
     * Retrieves filtered restaurants in Queens that contain "Moon" in the name.
     * 
     * @return List of filtered restaurants
     */
    @GET
    @Path("/browse")
    public Response getFilteredRestaurants() {
        try {
            // Temporarily use findAll() to test basic connectivity
            List<Restaurant> allRestaurants = restaurantRepository.findAll().toList();
            System.out.println("Total restaurants found: " + allRestaurants.size());
            
            // Filter for Queens restaurants that also have "Moon" in the name
            List<Restaurant> queensRestaurants = allRestaurants.stream()
                    .filter(restaurant -> "Queens".equals(restaurant.getBorough()) &&
                            restaurant.getName() != null && 
                            restaurant.getName().toLowerCase().contains("moon"))
                    .toList();
            System.out.println("Queens restaurants found: " + queensRestaurants.size());
            
            return Response.ok(queensRestaurants).build();
        } catch (Exception e) {
            e.printStackTrace();
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity("Error retrieving filtered restaurants: " + e.getMessage())
                    .build();
        }
    }
    /**
     * Retrieves restaurants by cuisine type.
     * 
     * @param cuisine The cuisine type to filter for
     * @return List of restaurants that have the specified cuisine
     */
    @GET
    @Path("/cuisine/{cuisine}")
    public Response getRestaurantsByCuisine(@PathParam("cuisine") String cuisine) {
        try {
            List<Restaurant> restaurants = restaurantRepository.findByCuisine(cuisine);
            return Response.ok(restaurants).build();
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity("Error retrieving restaurants by cuisine: " + e.getMessage())
                    .build();
        }
    }
}

Esta classe de recurso REST define os seguintes endpoints HTTP:

• GET /restaurants/: Recupera todos os documentos da coleção restaurants

• GET /restaurants/browse: Recupera documentos que representam restaurantes no Queins contendo "Moon" em seu nome, realizando uma query sem distinção entre maiúsculas e minúsculas

• GET /restaurants/cuisine/{cuisine}: recupera documentos que representam restaurantes que oferecem o valor de cuisine especificado

Crie uma classe de teste .

No diretório src/test/java/org/acme, crie um arquivo denominado RestaurantRepositoryTest.java e cole o seguinte código:

package org.acme;
import io.quarkus.test.junit.QuarkusTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
/**
 * RestaurantRepositoryTest is a test class for testing the RestaurantRepository operations.
 *
 * It uses the Quarkus Test framework to test the restaurant data access.
 */
@QuarkusTest
public class RestaurantRepositoryTest {
    @Inject
    RestaurantRepository restaurantRepository;
    @Test
    @DisplayName("Should retrieve restaurants from the database")
    public void testRetrieveRestaurants() {
        // Test repository injection and MongoDB connection
        assertThat(restaurantRepository).isNotNull();
    }
    @Test
    @DisplayName("Should find restaurants by borough")
    public void testFindRestaurantsByBorough() {
        // Test that the method exists and returns data
        List<Restaurant> restaurants = restaurantRepository.findByBorough("Queens");
        assertThat(restaurants).isNotNull();
    }
}

Este arquivo usa a estrutura de testes do Quartokus para testes de integração. O código define os seguintes métodos para testar sua conexão MongoDB :

• testRetrieveRestaurants(): verifica se sua classe RestaurantRepository acessa o MongoDB

• testFindRestaurantsByBorough(): verifica se o método findByBorough() recupera dados do MongoDB

Execute os testes.

Primeiro, execute o seguinte comando no diretório do projeto para executar a suíte de testes:

./mvnw test

Este comando executa a classe RestaurantRepositoryTest e verifica se seu aplicação pode acessar dados MongoDB . Se for bem-sucedida, a saída do comando conterá as seguintes informações:

[INFO] Results:
[INFO]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  ... s
[INFO] Finished at: ...
[INFO] ------------------------------------------------------------------------

Inicie o aplicação Quarkus .

No diretório do projeto , execute o seguinte comando para compilar e iniciar o aplicação no modo de desenvolvimento:

./mvnw quarkus:dev

Teste manualmente os endpoints REST.

Em uma janela de terminal separada, execute os seguintes comandos curl para testar os endpoints REST. Cada endpoint retorna dados JSON contendo informações de restaurante da coleção sample_restaurants.restaurants. Se bem-sucedidos, seus comandos retornarão dados semelhantes aos resultados da amostra.

1. Recupere todos os restaurantes.

   curl http://localhost:8080/restaurants/

   VISUALIZAR SAÍDA

   [{"id":"...","name":"Morris Park Bake Shop","borough":"Bronx","cuisine":"Bakery"},
   {"id":"...","name":"Wilken'S Fine Food","borough":"Brooklyn","cuisine":"Delicatessen"},
   {"id":"...","name":"Taste The Tropics Ice Cream","borough":"Brooklyn","cuisine":"Ice Cream,
   Gelato, Yogurt, Ices"},
   {"id":"...","name":"Carvel Ice Cream","borough":"Queens","cuisine":"Ice Cream, Gelato, Yogurt,
   Ices"},
   ...]

2. Recupere restaurantes no Queins que tenham "Moon" no nome.

   curl http://localhost:8080/restaurants/browse

   VISUALIZAR SAÍDA

   [{"id":"...","name":"Somoon","borough":"Queens","cuisine":"Asian"},
   {"id":"...","name":"New Moon Star Restaurant","borough":"Queens","cuisine":"Chinese"},
   {"id":"...","name":"Moon Tikka Grill","borough":"Queens","cuisine":"Indian"},
   {"id":"...","name":"Silver Moon Diner","borough":"Queens","cuisine":"American"},
   {"id":"...","name":"Mooney'S Public House","borough":"Queens","cuisine":"Irish"},
   {"id":"...","name":"Moon Light Crill Rest.","borough":"Queens","cuisine":"Indian"},
   {"id":"...","name":"Full Moon Cafe","borough":"Queens","cuisine":"Café/Coffee/Tea"},
   {"id":"...","name":"Pacific Moon","borough":"Queens","cuisine":"Chinese"},
   {"id":"...","name":"Moon Palace Kitchen","borough":"Queens","cuisine":"Chinese"},
   {"id":"...","name":"Honey Moon Coffee Shop 1766096115682","borough":"Queens","cuisine":"Café/Coffee/Tea"},
   {"id":"...","name":"Honey Moon Coffee Shop","borough":"Queens","cuisine":"Café/Coffee/Tea"}]

3. Recupere restaurantes por tipo de cozinha.

   As seguintes queries de comando para restaurantes que têm um cuisine valor de "Czech", mas você pode substituir este parâmetro por qualquer cozinha:

   curl http://localhost:8080/restaurants/cuisine/Czech

   VISUALIZAR SAÍDA

   [{"id":"...","name":"Koliba Restaurant","borough":"Queens","cuisine":"Czech"},
   {"id":"...","name":"Milan'S Restaurant","borough":"Brooklyn","cuisine":"Czech"},
   {"id":"...","name":"Bohemian Beer Garden","borough":"Queens","cuisine":"Czech"},
   {"id":"...","name":"Hospoda","borough":"Manhattan","cuisine":"Czech"},
   {"id":"...","name":"Olde Prague Tavern","borough":"Queens","cuisine":"Czech"},
   {"id":"...","name":"Brooklyn Beet Company","borough":"Brooklyn","cuisine":"Czech"}]