Coding with Java Part 1

In a previous lesson, we explained how a ScyllaDB Administrator could backup and restore a cluster. As the number of mutants is on the rise, Division 3 decided that we must use more applications to connect to the mutant catalog and decided to hire Java developers to create powerful applications that can monitor the mutants. In this lesson, we will explore how to connect to a ScyllaDB cluster using the driver for Java.

When creating applications that communicate with a database such as ScyllaDB, it is crucial that the programming language being used has support for database connectivity. Since ScyllaDB is compatible with Cassandra, we can use any of the available Cassandra libraries. For example, in Go, there is Gocql and Gocqlx. In Node.js, there is cassandra-driver. For Java, we have this driver available. Since Division 3 wants to start investing in Java, let’s begin by writing a sample Java application.

Note: If you are taking this lesson as part of the MMS course, keep in mind that there are more lessons on using drivers for other languages in the Using ScyllaDB Drivers course.

Creating a Sample Java Application

The sample application that we will go over will connect to a ScyllaDB cluster, display the contents of the Mutant Catalog table, insert and delete data, and show the contents of the table after each action. We will first go through each section of the code that will be used and then explain how to run the code in a Docker container that will access the ScyllaDB Mutant Monitoring cluster. You can see this file here: scylla-code-samples/mms/java-app/src/App.java

In the application, we first need to import the driver for Java:

The Cluster library provides the ability to connect to the cluster. The ResultSet library will allow us to run queries such as SELECT statements and store the output. The Row library will enable us to get the value of a CQL Row returned in a ResultSet. The session library provides the ability to connect to a specific keyspace.

For this application, the main class is called App, and the code is stored in a file called App.java. After the class is defined, we can begin defining which cluster and keyspace to use:

To display the data, we will need to create a function that will run a select statement from the ScyllaDB cluster. The function below will use the ResultSet, Session, and Row libraries to gather the data and print it on the screen:

The next function is used to insert a new Mutant into the Mutant Catalog table. Since this is a simple query, only the Session library is used. After the insert takes place, the previous function, selectQuery(), is called to display the contents of the table after the new data is added.

After the data is added and displayed in the terminal, we will delete it and then display the contents of the table again:

This is the main method of the application and is the starting point for any Java application. In this function, we will add the functions that were created above to be executed in the order below. When all of the functions are completed, the application will exit.

With the coding part done, let’s set up the ScyllaDB Cluster and then run the sample application in Docker.

Setting up the ScyllaDB Cluster

The example requires a single DC cluster. Follow this procedure to remove previous clusters and set up a new cluster.

Once the cluster is up, we’ll create the catalog keyspace and populate it with data.

The first task is to create the keyspace for the catalog.

docker exec -it scylla-node1 cqlsh

CREATE KEYSPACE catalog WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy','DC1' : 3};

Now that the keyspace is created, it is time to create the table.

use catalog;

CREATE TABLE mutant_data (
   first_name text,
   last_name text,
   address text,
   picture_location text,
   PRIMARY KEY((first_name, last_name)));

Now let’s add a few mutants to the catalog with the following statements:

insert into mutant_data ("first_name","last_name","address","picture_location") VALUES ('Bob','Loblaw','1313 Mockingbird Lane', 'http://www.facebook.com/bobloblaw');
insert into mutant_data ("first_name","last_name","address","picture_location") VALUES ('Bob','Zemuda','1202 Coffman Lane', 'http://www.facebook.com/bzemuda');
insert into mutant_data ("first_name","last_name","address","picture_location") VALUES ('Jim','Jeffries','1211 Hollywood Lane', 'http://www.facebook.com/jeffries');

Building the Java Example

If you previously built the java  Docker you can skip directly to “Running the Java Example”.

Otherwise, to build the application in Docker, change into the java subdirectory in scylla-code-samples:

exit

cd scylla-code-samples/mms/java

Now we can build and run the container:

docker build -t java-app .

docker run -d --net=mms_web --name some-java-app java-app

To connect to the shell of the container, run the following command:

docker exec -it some-java-app sh

Running the Java Example

Finally, the sample Java application can be run:

cd java-app/target

java -jar App-jar-with-dependencies.jar

The output of the application will be:

Conclusion

In this lesson, we explained how to create a sample Java application that executes a few basic CQL statements with a ScyllaDB cluster using the Java driver. This is only the basics, and there are more exciting topics that Division 3 wants developers to explore. In one of the next lesson, we will go over prepared statements using the Java driver.

In the meantime, please be safe out there and continue to monitor the mutants!