Integra MongoDB con Quarkus

Verificar los prerrequisitos.

Para crear la aplicación Quick Start, instala el siguiente software en tu entorno de desarrollo:

Crea un clúster de MongoDB Atlas.

MongoDB Atlas es un servicio de base de datos en la nube completamente gestionado que aloja tus implementaciones de MongoDB. Si no tienes una implementación de MongoDB, puedes crear un clúster de MongoDB de forma gratuita al completar el Tutorial de Introducción a MongoDB. El tutorial Get Started de MongoDB también demuestra cómo cargar conjuntos de datos de muestra en tu clúster, incluido el sample_restaurants base de datos que se emplea en este tutorial.

Para conectarte a tu clúster de MongoDB, debes usar una cadena de conexión. Para aprender cómo recuperar tu cadena de conexión, consulta la sección Agregar tu cadena de conexión del tutorial de introducción de MongoDB.

Crea tu proyecto Quarkus.

Desde tu terminal, ejecuta el siguiente comando para crear un nuevo proyecto de Quarkus llamado quarkus-quickstart que configure la extensión Quarkus JNoSQL para MongoDB y la serialización JSON para los endpoints REST:

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

A continuación, navega hasta tu directorio de proyecto ejecutando el siguiente comando:

cd quarkus-quickstart

Configurar la conexión de tu base de datos.

Navegue hasta el archivo src/main/resources/application.properties y agregue las siguientes propiedades de configuración:

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

Este código configura tu conexión a la base de datos sample_restaurants en tu clúster de MongoDB. Reemplazá el marcador de posición <connection string> con la cadena de conexión que guardaste en un paso anterior.

Limpiar archivos de plantilla.

La plantilla del proyecto Quarkus incluye algunos archivos de muestra que puedes remover para este tutorial. Para borrar estos archivos innecesarios, selecciona la pestaña correspondiente a tu sistema operativo y ejecuta los siguientes comandos desde tu directorio 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

Crea el Restaurant modelo.

Cree un archivo llamado Restaurant.java en el directorio src/main/java/org/acme y pegue el siguiente 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 archivo define la clase de entidad Restaurant, la cual se corresponde con documentos en la colección sample_restaurants.restaurants. La anotación @Entity marca esta clase como una entidad JNoSQL, y las anotaciones de campo mapean las propiedades Java a los campos del documento.

Crea la clase de repositorio.

Cree un archivo llamado RestaurantRepository.java en el directorio src/main/java/org/acme y pegue el siguiente 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 clase de repositorio proporciona métodos para acceder a los datos de restaurantes en MongoDB. Define métodos de findByBorough() y findByCuisine() query personalizados, y también puedes utilizar una instancia RestaurantRepository para acceder a los métodos incorporados de creación, lectura, actualización y eliminación.

Crea la clase de recurso REST.

En el directorio src/main/java/org/acme, crea un archivo llamado RestaurantResource.java y pega el siguiente 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 clase de recurso REST define los siguientes puntos finales HTTP:

• GET /restaurants/:Recupera todos los documentos de la colección restaurants

• GET /restaurants/browse: Recupera documentos que representan restaurantes en Queens que contienen "Moon" en su nombre, realizando una query insensible a mayúsculas y minúsculas

• GET /restaurants/cuisine/{cuisine}: Recupera documentos que representan restaurantes que ofrecen el valor de cuisine especificado

Crear una clase de prueba.

En el directorio src/test/java/org/acme, crea un archivo llamado RestaurantRepositoryTest.java y pega el siguiente 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 archivo utiliza el marco de pruebas de Quarkus para pruebas de integración. El código define los siguientes métodos para probar tu conexión a MongoDB:

• testRetrieveRestaurants(): Verifica que tu clase RestaurantRepository acceda a MongoDB

• testFindRestaurantsByBorough(): Verifica que el método findByBorough() recupere datos de MongoDB

Ejecuta las pruebas.

En primer lugar, ejecuta el siguiente comando desde el directorio de tu proyecto para ejecutar el conjunto de pruebas:

./mvnw test

Este comando ejecuta la clase RestaurantRepositoryTest y verifica que tu aplicación pueda acceder a los datos de MongoDB. Si es exitoso, la salida de tu comando contiene la siguiente información:

[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] ------------------------------------------------------------------------

Inicia la aplicación Quarkus.

Desde el directorio de su proyecto, ejecute el siguiente comando para compilar e iniciar la aplicación en modo de desarrollo:

./mvnw quarkus:dev

Prueba manualmente los endpoints REST.

En una ventana de terminal separada, ejecuta los siguientes comandos de curl para probar los endpoints REST. Cada endpoint devuelve datos JSON que contienen información de restaurantes de la colección sample_restaurants.restaurants. Si es exitoso, tus comandos devolverán datos similares a los resultados de las muestras.

1. Recuperar todos los restaurantes.

   curl http://localhost:8080/restaurants/

   VER SALIDA

   [{"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. Recuperar restaurantes en Queens que tengan "Moon" en el nombre.

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

   VER SALIDA

   [{"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. Recuperar restaurantes por tipo de cocina.

   El siguiente comando consulta restaurantes que tienen un valor cuisine de "Czech", pero puedes cambiar este parámetro por cualquier tipo de cocina:

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

   VER SALIDA

   [{"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"}]