Neo4j With Scala: Rest End Points with AKKA HTTP


Hello Folks,

Welcome back again in the series of Neo4j with Scala 😉. Let’s start our journey again. But before starting our journey here is the links for recap who join late us in the journey :

  1. Getting Started Neo4j with Scala : An Introduction
  2. Neo4j with Scala: Defining User Defined Procedures and APOC
  3. Neo4j with Scala: Migrate Data From Other Database to Neo4j
  4. Neo4j with Scala: Awesome Experience with Spark
  5. Neo4j vs ElasticSearch and Full Text Search

Today we will discuss about Neo4j, Scala with Akka-HTTP. We will create rest-endpoints and try to connect with server with them.

The basic idea behind using Akka-HTTP for creating Rest end points is modules implement a full server and client-side HTTP stack on top of akka-actor and akka-stream. We can customize these routes according to our use case. It’s not a web-framework but rather a more general toolkit for providing and consuming HTTP-based services.

We will talk step by step to develop this Rest API after which you will able to run this API on your server and start hitting Rest end points.

Now we start coding :

  1. build.sbt:
    We will start our implementation with the build.sbt file. We will keep all require dependencies in this file.
  2. Factories:
    This is the part where we interact with the Neo4j database. This code shows how to do CRUD operations and Create Relation between the nodes. We will define our Cypher here and execute them. Example:

     def retrieveRecord(email: String): Option[User] = {
        val driver = GraphDatabase.driver(neo4jUrl, AuthTokens.basic(userName, userPassword))
        val session = driver.session
        val script = s"MATCH (a:Users) WHERE a.name = '$email' RETURN a.name AS name, a.email AS " +
                     s"email, a.age AS age, a.city AS city"
        val result = session.run(script)
        val record_data: Option[User] = if (result.hasNext()) {
          val record = result.next()
          val results: User = new User(record.get("name").asString(),
            record.get("email").asString(),
            record.get("age").asInt(),
            record.get("city").asString())
          Some(results)
        } else {
          None
        }
        session.close()
        driver.close()
        record_data
      }

  3. Routes:
    This is the part where we develop routes to provide rest end points to the client so that they can interact with server and perform the operation which are mention in Factories using REST end points. Example:

    path("get" / "email" / Segment) { (email: String) =>
          get {
            complete {
              try {
                val idAsRDD: Option[User] = retrieveRecord(email)
                idAsRDD match {
                  case Some(data) =>
                    HttpResponse(StatusCodes.OK, entity = data.name)
                  case None => HttpResponse(StatusCodes.InternalServerError,
                    entity = s"Data is not fetched and something went wrong")
                }
              } catch {
                case ex: Throwable =>
                  logger.error(ex, ex.getMessage)
                  HttpResponse(StatusCodes.InternalServerError,
                    entity = s"Error found for email : $email")
              }
            }
          }
        }
  4. application.conf:
    This is the part where we define our configuration like http’s interface , port and Neo4j’s URL, userName, userPassword. We define this file in resources folder.
  5. boot.scala:
    This is the file from where we will start the server and create connection with the server.

This is the basic idea for developing a Rest end points with Akka-http. If you want to see code, you can find here or you all can just follow the README.md file and you will ready to hit the server.

This is the basic implementation of how to perform CRUD operation and create relation on Neo4j using the Akka-HTTP.

Here is some example for URL :

0.0.0.0:8080/get/email/anurag@knoldus.com

This will return the user’s name if user is present in the Neo4j otherwise it will return Data is not fetched and something went wrong.

You can find Activator for the Neo4j with Scala and Akka-http here.

Reference:

    1. Akka Http Documentation

KNOLDUS-advt-sticker

Advertisements
This entry was posted in akka-http, Scala, scalatest and tagged , , . Bookmark the permalink.

One Response to Neo4j With Scala: Rest End Points with AKKA HTTP

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s