Integrate MongoDB with Quarkus

Verify the prerequisites.

To create the Quick Start application, install the following software in your development environment:

Create a MongoDB Atlas cluster.

MongoDB Atlas is a fully managed cloud database service that hosts your MongoDB deployments. If you do not have a MongoDB deployment, you can create a MongoDB cluster for free by completing the MongoDB Get Started tutorial. The MongoDB Get Started tutorial also demonstrates how to load sample datasets into your cluster, including the sample_restaurants database that is used in this tutorial.

To connect to your MongoDB cluster, you must use a connection string. To learn how to retrieve your connection string, see the Add your connection string section of the MongoDB Get Started tutorial.

Create your Quarkus project.

From your terminal, run the following command to create a new Quarkus project named quarkus-quickstart that configures the Quarkus JNoSQL Extension for MongoDB and JSON serialization for REST endpoints:

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

Then, navigate to your project directory by running the following command:

cd quarkus-quickstart

Configure your database connection.

Navigate to the src/main/resources/application.properties file and add the following configuration properties:

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

This code configures your connection to the sample_restaurants database in your MongoDB cluster. Replace the <connection string> placeholder with the connection string that you saved in a previous step.

Clean up template files.

The Quarkus project template includes some sample files that you can remove for this tutorial. To delete these unneeded files, select the tab corresponding to your operating system and run the following commands from your quarkus-quickstart directory:

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

Create the Restaurant model.

Create a file named Restaurant.java in the src/main/java/org/acme directory and paste the following code:

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; }
}

This file defines the Restaurant entity class, which maps to documents in the sample_restaurants.restaurants collection. The @Entity annotation marks this class as a JNoSQL entity, and the field annotations map Java properties to document fields.

Create the repository class.

Create a file named RestaurantRepository.java in the src/main/java/org/acme directory and paste the following code:

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);
}

This repository class provides methods for accessing restaurant data in MongoDB. It defines custom findByBorough() and findByCuisine() query methods, and you can also use a RestaurantRepository instance to access built-in create, read, update, and delete methods.

Create the REST resource class.

In the src/main/java/org/acme directory, create a file named RestaurantResource.java and paste the following code:

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();
        }
    }
}

This REST resource class defines the following HTTP endpoints:

• GET /restaurants/: Retrieves all documents from the restaurants collection

• GET /restaurants/browse: Retrieves documents that represent restaurants in Queens containing "Moon" in their name, performing a case-insenstive query

• GET /restaurants/cuisine/{cuisine}: Retrieves documents that represent restaurants offering the specified cuisine value

Create a test class.

In the src/test/java/org/acme directory, create a file named RestaurantRepositoryTest.java and paste the following code:

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();
    }
}

This file uses Quarkus's testing framework for integration testing. The code defines the following methods to test your MongoDB connection:

• testRetrieveRestaurants(): Verifies that your RestaurantRepository class accesses MongoDB

• testFindRestaurantsByBorough(): Verifies that the findByBorough() method retrieves MongoDB data

Run the tests.

First, run the following command from your project directory to run the test suite:

./mvnw test

This command runs the RestaurantRepositoryTest class and verifies that your application can access MongoDB data. If successful, your command output contains the following information:

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

Start the Quarkus application.

From your project directory, run the following command to compile and start the application in development mode:

./mvnw quarkus:dev

Manually test the REST endpoints.

In a separate terminal window, run the following curl commands to test the REST endpoints. Each endpoint returns JSON data containing restaurant information from the sample_restaurants.restaurants collection. If successful, your commands return data similar to the sample outputs.

1. Retrieve all restaurants.

   curl http://localhost:8080/restaurants/

   VIEW OUTPUT

   [{"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. Retrieve restaurants in Queens that have "Moon" in the name.

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

   VIEW OUTPUT

   [{"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. Retrieve restaurants by cuisine type.

   The following command queries for restaurants that have a cuisine value of "Czech", but you can replace this parameter with any cuisine:

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

   VIEW OUTPUT

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