Skip to content
Let your servers and clients communicate over function calls! JSON-RPC 2.0 library for Scala and Scala.js
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
circe-json-serializer
examples
json-serializer/shared/src/main/scala/io/github/shogowada/scala/jsonrpc/serializers
project
shared/src
tutorials
upickle-json-serializer
.editorconfig
.gitignore
.travis.yml
CONTRIBUTING.md
LICENSE
README.md
build.sbt

README.md

scala-json-rpc

master: Master Build Status

Let your servers and clients communicate over function calls!

scala-json-rpc is a Remote Procedure Call (RPC) library honorring JSON-RPC 2.0 spec.

JSON-RPC defines a specification of RPC in JSON format. This means that you can achieve RPC between your components as long as they are capable of

  • Serializing and deserializing JSON
  • Passing strings around
+--------+                          +--------+
|        | ---[request as JSON]---> |        |
| Client |                          | Server |
|        | <--[response as JSON]--- |        |
+--------+                          +--------+

Quick look

Shared between server and client

Using scala-json-rpc, your server and client can communicate over statically typed interfaces like below:

trait LoggerAPI {
  def log(message: String): Unit
}

case class Foo(id: String)

trait FooRepositoryAPI {
  def add(foo: Foo): Future[Unit]
  def remove(foo: Foo): Future[Unit]
  def getAll(): Future[Set[Foo]]
}

Server

class LoggerAPIImpl extends LoggerAPI {
  override def log(message: String): Unit = println(message)
}

class FooRepositoryAPIImpl extends FooRepositoryAPI {
  var foos: Set[Foo] = Set()

  override def add(foo: Foo): Future[Unit] = this.synchronized {
    foos = foos + foo
    Future() // Acknowledge
  }

  override def remove(foo: Foo): Future[Unit] = this.synchronized {
    foos = foos - foo
    Future() // Acknowledge
  }

  override def getAll(): Future[Set[Foo]] = Future {
    foos
  }
}

val jsonSerializer = // ...
val server = JSONRPCServer(jsonSerializer)
server.bindAPI[LoggerAPI](new LoggerAPIImpl)
server.bindAPI[FooRepositoryAPI](new FooRepositoryAPIImpl)

def onRequestJSONReceived(requestJSON: String): Unit = {
  server.receive(requestJSON).onComplete {
    case Success(Some(responseJSON: String)) => sendResponseJSONToClient(responseJSON)
    case _ =>
  }
}

Client

val jsonSerializer = // ...
val jsonSender = // ...
val client = JSONRPCClient(jsonSerializer, jsonSender)

val loggerAPI = client.createAPI[LoggerAPI]
val fooRepositoryAPI = client.createAPI[FooRepositoryAPI]

loggerAPI.log("Hello, World!")

fooRepositoryAPI.add(Foo("A"))
fooRepositoryAPI.add(Foo("B"))

fooRepositoryAPI.remove(Foo("A"))

fooRepositoryAPI.getAll().onComplete {
  case Success(foos: Set[Foo]) => println(s"Received all the foos: $foos")
  case _ =>
}

def onResponseJSONReceived(responseJSON: String): Unit = {
  client.receive(responseJSON)
}

Dependency

Platform SBT Scala Version Scala JS Version
JVM "io.github.shogowada" %% "scala-json-rpc" % "0.9.3" 2.12
JS "io.github.shogowada" %%% "scala-json-rpc" % "0.9.3" 2.12 0.6.17+

scala-json-rpc has no external dependency, so it should fit into any of your Scala JVM & JS applications.

Tutorials

Examples

TODOs

It should already serve you well as a RPC library, but it still does not fully support JSON-RPC spec yet. Here are list of known JSON-RPC features that's not supported yet.

  • Send/receive named parameter
    • Define custom parameter name
  • Send/receive custom JSON-RPC error
  • Define custom JSON-RPC request ID
You can’t perform that action at this time.