Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Neo4j With Scala: REST Endpoints with Akka-HTTP

DZone's Guide to

Neo4j With Scala: REST Endpoints with Akka-HTTP

By using Neo4j and Scala with Akka-HTTP, you are able to create REST endpoints and try to connect with the server with them.

· Integration Zone ·
Free Resource

How to Transform Your Business in the Digital Age: Learn how organizations are re-architecting their integration strategy with data-driven app integration for true digital transformation.

Welcome back to our series of Neo4j with Scala. Let’s start our journey again. Check out the other parts of the series before reading this one:

  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 Neo4j and Scala with Akka-HTTP. We will create REST endpoints and try to connect with the server with them.

The basic idea behind using Akka-HTTP for creating REST endpoints is that 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 about how to development this REST API. You will able to run this API on your server and start hitting REST endpoints.

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 relationships between the nodes. We will define our ciphers 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 endpoints to the client so that they can interact with the server and perform the operations that are mentioned in factories using REST endpoints. 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 the HTTP's interface, the port, and Neo4j’s URL, userName, and userPassword. We define this file in the resources folder.

5. boot.scala

This is the file from where we will start the server and create connections with the server.

This is the basic idea for developing REST endpoints with Akka-http. If you want to see code, you can find info here or you can just follow the README.md file.

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

Here is an example URL:

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

This will return the user’s name if the user is present in the Neo4j. Otherwise, it will return data that is not fetched.

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

Reference

Make your mark on the industry’s leading annual report. Fill out the State of API Integration 2019 Survey and receive $25 to the Cloud Elements store.

Topics:
scala ,neo4j ,integration ,tutorial ,rest api

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}