Hello, everyone!! In the previous post, we talk about Scylla DB and some characteristics of the database. For those who have not seen it yet, this is the link https://dev.to/j_a_o_v_c_t_r/working-with-scylla-database-3al9. Today I intend to integrate the database with an application Java and to help us I decided to use Java + Quarkus. Quarkus is a Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best-of-breed Java libraries and standards. It is known as Supersonic Subatomic java because it is fast and small. To those interested, the link will be at the final of the post. Ok, now that we know our goal, let's start!!
The first step is to create the application and for that, Quarkus gives us a simple interface that we can access at this link https://code.quarkus.io/.
On this page we put information like groupId, artifactId, build tools, and select which dependencies we will use.
Let's know about the selected dependencies
- Datastack Apache Cassandra client: Driver to connect to Apache Cassandra databases. How we saw, Scylla DB is based on Cassandra, so we can use the same client.
- RESTEasy JSON-B: JSON-B serialization support for RESTEasy. We will use endpoints to interact with our application
- RESTEasy Mutiny: Mutiny support for RESTEasy server. If we want to call async resources (We don't use them in this example).
- SmallRye Health: Monitor service health.
- Micrometer Registry Prometheus: Enable Prometheus support for micrometer, so with this dependency, we can collect metrics for our application.
Ok, now we can generate our application in the Generate your application button.
Let's import the application in our IDE.
Quarkus gives us a GET resource for testing, but we are not going to use it so we can delete it.
If you want test, is enough execute mvn package quarkus:dev command, wait application is up and call http://localhost:8080/hello-reasteasy
Now we can create our entity. Entity class is a model for objects that we will work on. This object will be
Car. In the name of the class will use the annotation
@Entity. The name of the class should be the same as the table of database. The object will have the fields id, brand, color, and model. How we saw in the previous post, the id field is a primary key, so we will use the annotation
In the next post, I will talk about Scylla Primary Key and the differences in relation the relational databases
How we can see, the class does not compile, because we need to add some dependencies in our
pom.xml. This dependencies are:
com.datastax.oss:java-driver-core: A modern, feature-rich, and highly tunable Java client library for Apache Cassandra® (2.1+) and DataStax Enterprise (4.7+), and DataStax Astra, using exclusively Cassandra's binary protocol and Cassandra Query Language (CQL) v3.
com.datastax.oss:java-driver-mapper-runtime: The mapper generates the boilerplate to execute queries and convert the results into application-level objects.
The dependencies can be downloaded in https://mvnrepository.com/
And we need to change the original maven-compiler-plugin in
pom.xml for the below.
This is necessary because Quarkus need know the annotations in compile time for injecting the resources like DAO and others. We'll see that soon.
After including the dependencies in
pom.xml, we can import annotations and include constructors and getters/setters.
rest of the methods omitted!
The next step is to create the Data Access Object or more commonly DAO. Is enough for this post two methods, one select method and one insert method.
@Dao comes from the DataStax Object Mapper, which will also automatically generate an implementation of this interface for us.
@Select generate an implementation of methods. Note also the special return type of the
PagingIterable: it’s the base type of result sets returned by the driver.
Now let's create a mapper that is responsible for constructing instances of DAOs. In this case, will create an instance of
CarDAO. The name will be
To interact with the saved information or save new information in the database, we will create a REST endpoint and for that will create a
CarResource class. For our example, we will need a POST and a GET method.
In relation to the image above, let's talk about some details. The resource for access the application will be
cars. We should send JSON for the application and consume JSON of the application. To save or retrieve information, we need access to the database, so for that, we inject the
The last step will be to configure the information of the database in the application. For that, we will use
And we can see the information above when we up our node Scylla.
Let's start the application using
mvn package quarkus:dev command
And to use our browser to do a request for the application
New saved information
Tested requests, our application is complete and functional. We can now explore more features.
The reason we put in our
quarkus-smallrye-health dependency is automatically add a readiness health check to validate the connection to the Scylla cluster. We can access http://localhost:8080/q/health/ready to know if our connection is healthy or not.
Now I will pause the docker that is running ScyllaDB
And test connection again
We can see the metrics of Scylla session and about individual Scylla nodes and for this is enough add a property
quarkus.cassandra.metrics.enabled=true in our
application.properties what we already did. To see metrics we can access http://localhost:8080/metrics
My intention with this post is to show how we can integrate an application Java with Scylla DB and how easy that is using Quarkus. Some details can explorer yet, like primary key, but we can see this in the next post. I hope that you liked it and any doubt, critics, or suggestions tell me. Will be a pleasure to help you.