Introduction to Oracle NoSQL and Helidon
Oracle NoSQL is a highly scalable, distributed key-value database built for fast and reliable performance, particularly suited for modern, high-demand applications. Helidon, on the other hand, is a lightweight, reactive framework for building microservices in Java. In this tutorial, we will explore how to build a RESTful application using Oracle NoSQL as the backend database and Helidon to handle the REST endpoints.
Prerequisites
Before we begin, make sure you have the following installed:
- Java Development Kit (JDK) version 11 or later
- Maven build tool
- Oracle NoSQL database installed and configured
Setting Up the Project
First, let’s create a new Maven project. Open your terminal and run the following command:
mvn archetype:generate -DarchetypeGroupId=io.helidon.archetypes -DarchetypeArtifactId=helidon-quickstart-se -DarchetypeVersion=2.3.1 -DinteractiveMode=false -DgroupId=com.example -DartifactId=helidon-nosql-app -Dpackage=com.example.nosqlapp
This will generate a new Helidon project with a standard directory structure.
Next, we need to add the Oracle NoSQL dependency to our project’s pom.xml
file:
<dependency>
<groupId>com.oracle.nosql</groupId>
<artifactId>nosqldb-cloudsim</artifactId>
<version>22.1.5</version>
</dependency>
Make sure to replace the version with the latest available version.
Configuring Oracle NoSQL
We need to configure Oracle NoSQL connection settings in our application. Create a new configuration file named application.yaml
in the src/main/resources
directory:
nosql:
endpoint: "https://nosql.us-ashburn-1.oci.oraclecloud.com"
region: "us-ashburn-1"
compartment: "your-compartment-id"
auth:
iam:
tenantId: "your-tenant-id"
userId: "your-user-id"
fingerprint: "your-fingerprint"
privateKeyFile: "path-to-your-private-key-file"
Replace the placeholder values with your actual Oracle Cloud Infrastructure (OCI) credentials and configuration.
Creating REST Endpoints
Now, let’s create our REST endpoints using Helidon’s WebServer module. Create a new Java class named UserResource
in the src/main/java/com/example/nosqlapp
directory:
package com.example.nosqlapp;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
public class UserResource {
public List<User> getAllUsers() {
// Retrieve and return all users from the database
}
public Response getUserById( { String id)
// Retrieve user by ID from the database
}
public Response createUser(User user) {
// Create a new user in the database
}
public Response updateUser( { String id, User user)
// Update an existing user in the database
}
public Response deleteUser( { String id)
// Delete user from the database
}
}
In the above code, we define endpoints for retrieving all users, retrieving a user by ID, creating a new user, updating an existing user, and deleting a user.
Integrating with Oracle NoSQL
Now, let’s integrate our REST endpoints with Oracle NoSQL. We’ll use the Oracle NoSQL Java SDK to interact with the database. Add the following dependency to your pom.xml
file:
<dependency>
<groupId>com.oracle.nosql</groupId>
<artifactId>nosqldb-driver</artifactId>
<version>4.3.9</version>
</dependency>
Next, we’ll inject an instance of NoSQLClient
into our UserResource
class and use it to perform CRUD operations on the database.
import com.oracle.nosql.driver.NoSQLHandleConfig;
import com.oracle.nosql.driver.NoSQLHandleFactory;
import com.oracle.nosql.driver.values.MapValue;
import com.oracle.nosql.driver.values.StringValue;
import java.util.List;
public class UserResource {
private final NoSQLHandleConfig config = NoSQLHandleConfig.builder()
.endpoint(System.getProperty(“nosql.endpoint”))
.region(System.getProperty(“nosql.region”))
.compartment(System.getProperty(“nosql.compartment”))
.authConfig(NoSQLHandleConfig.AuthConfig.builder()
.iamConfig(NoSQLHandleConfig.AuthConfig.IAMConfig.builder()
.tenantId(System.getProperty(“nosql.auth.iam.tenantId”))
.userId(System.getProperty(“nosql.auth.iam.userId”))
.fingerprint(System.getProperty(“nosql.auth.iam.fingerprint”))
.privateKeyFile(System.getProperty(“nosql.auth.iam.privateKeyFile”))
.build())
.build())
.build();
private final NoSQLClient client = NoSQLHandleFactory.createNoSQLHandle(config);
public List<User> getAllUsers() {
// Retrieve and return all users from the database
}
// Other endpoint methods
}
In the above code, we configure the NoSQLHandleConfig
with the connection properties specified in the application.yaml
file and create a new instance of NoSQLClient
to interact with the Oracle NoSQL database.
Implementing CRUD Operations
Now, let’s implement the methods in UserResource
to perform CRUD operations using Oracle NoSQL.
import com.oracle.nosql.driver.ops.GetRequest;
import com.oracle.nosql.driver.ops.GetResult;
import com.oracle.nosql.driver.ops.PutRequest;
import com.oracle.nosql.driver.ops.PutResult;
import com.oracle.nosql.driver.ops.DeleteRequest;
import com.oracle.nosql.driver.ops.DeleteResult;
import java.util.List;
public class UserResource {
// Constructor and injection of NoSQLClient
public List<User> getAllUsers() {
// Retrieve and return all users from the database
return client.table(“users”)
.read()
.all()
.execute()
.asPojo(User.class);
}
public Response getUserById( { String id)
GetRequest getRequest = GetRequest.builder()
.tableName(“users”)
.key(MapValue.of(“id”, StringValue.fromString(id)))
.build();
GetResult getResult = client.get(getRequest);
if (getResult.isSuccessful()) {
User user = getResult.getValue().asPojo(User.class);
return Response.ok(user).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
}
public Response createUser(User user) {
PutRequest putRequest = PutRequest.builder()
.tableName(“users”)
.value(MapValue.ofPojo(user))
.build();
PutResult putResult = client.put(putRequest);
if (putResult.isSuccessful()) {
return Response.status(Response.Status.CREATED).build();
} else {
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
}
}
public Response updateUser( { String id, User user)
// Update an existing user in the database
}
public Response deleteUser( { String id)
// Delete user from the database
}
}
Conclusion
In this article, we’ve explored how to build a RESTful application using Oracle NoSQL Database and Helidon. We started by setting up our development environment, creating a Helidon project, adding Oracle NoSQL dependency, and implementing REST endpoints to perform CRUD operations on data stored in Oracle NoSQL Database. With the combination of these technologies, developers can build high-performance and scalable applications with ease.
This is just the beginning, and there’s much more to explore in terms of advanced features, security, and performance tuning. However, with the foundation laid out in this article, you should now have a good understanding of how to integrate Oracle NoSQL Database with Helidon to build modern Java applications.