Decrypting the Basics to Develop a Corda Application with Spring Boot

Basics to Develop a Corda Application with Spring Boot

Posted by : deepak.maurya | 26-Dec-2019

  • Corda Spring boot

    In this article, we have explained how to make use of a client proxy to make RPCs for a Corda Node. The RPC client can be written in any JVM compatible language using the CordaRPCClient class. Once connected, you can trigger the vault and the flow, and get results.

    Begin with adding a variable for the spring boot version and Corda version that should’ve been installed locally, including spring classpath dependencies.

    buildscript {

        ext {

            corda_release_group = net.corda”

            corda_release_version=”4.0″

             corda_gradle_plugins_version=”4.0.42″

            kotlin_version=”1.2.71″

            junit_version=”4.12″

            quasarVersion=”0.7.10″

            spring_boot_version = ‘2.0.2.RELEASE’

            spring_boot_gradle_plugin_version = ‘2.1.1.RELEASE’

        }

        repositories {

            mavenLocal()

            mavenCentral()

            jcenter()

            maven { url ‘https://ci-artifactory.corda.r3cev.com/artifactory/corda-releases’ }

        }

        dependencies {

            classpath org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version”

            classpath net.corda.plugins:cordapp:$corda_gradle_plugins_version”

            classpath net.corda.plugins:cordformation:$corda_gradle_plugins_version”

            classpath
    net.corda.plugins:quasar-utils:$corda_gradle_plugins_version”

            classpath org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_gradle_plugin_version”

        } 

    repositories {

        jcenter()

        mavenCentral()

        maven { url ‘https://ci-artifactory.corda.r3cev.com/artifactory/corda’ }

        //Corda testing node-driver requires gradle-tooling-api

        maven { url ‘https://repo.gradle.org/gradle/libs-releases-local/’ }

     //Required for Corda SNPASHOTs

        maven { url ‘https://ci-artifactory.corda.r3cev.com/artifactory/corda-dev’ }

        maven { url ‘https://jitpack.io’ }

    }

    Add corda and spring dependencies in build.gradle file

    dependencies {

        compile “org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version”

        testCompile “org.jetbrains.kotlin:kotlin-test:$kotlin_version”

        testCompile “junit:junit:$junit_version”

      // Corda dependencies.

        cordaCompile $corda_release_group:corda-core:$corda_release_version”

        cordaCompile $corda_release_group:corda-jackson:$corda_release_version”

        cordaCompile $corda_release_group:corda-rpc:$corda_release_version”

        cordaCompile $corda_release_group:corda-node-api:$corda_release_version”

        cordaRuntime “$corda_release_group:corda:$corda_release_version”

        testCompile “$corda_release_group:corda-node-driver:$corda_release_version”

        cordaRuntime “org.apache.logging.log4j:log4j-slf4j-impl:$log4j_version”

        compile(“org.springframework.boot:spring-boot-starter-websocket:$spring_boot_version”) {

            exclude group: “org.springframework.boot”, module: “spring-boot-starter-logging”

        }

        compile “org.apache.logging.log4j:log4j-web:$log4j_version”

    }

    Add a task for deploying your Node 

    task deployNodes(type: net.corda.plugins.Cordform, dependsOn: [jar]) {

        nodeDefaults {

            projectCordapp {

                deploy = false

            }

        

        }

        signing {

            enabled false

        }

        node {

            name O=PartyA,L=London,C=GB”

            p2pPort 10005

            rpcSettings {

                address(“localhost:10006”)

                adminAddress(“localhost:10046”)

            }

            rpcUsers = [[ username: “user1”, “password”: “test”, “permissions”: [“ALL”]]]

        }

    }Add Task for Server 

    Add Task for Server 

    task runPartyAServer (type: JavaExec ,dependsOn: assemble) {

        classpath = sourceSets.main.runtimeClasspath

        main =’net.corda.server.ServerKt’

        

    } 

    The Server

    Similar to any other Spring Boot app, we define the main entry point with a SpringApplication instance. The @SpringBootApplication annotation should be added to the class consuming the SpringApplication instance, which in this case is Server.

    @SpringBootApplication

    open class Starter

    fun main(args: Array<String>) {

            val app = SpringApplication(Starter::class.java)

            app.setBannerMode(Banner.Mode.CONSOLE) app.isWebEnvironment = true

            app.run(*args)

        }

    Connecting to the Node

    In corda application, to allow the server to interact with the Corda node a long-lasting connection via RPC needs to be established. We can do this by using CordaRPCConnection and CordaRPCClient .

    private const val CORDA_USER_NAME = “config.rpc.username”

    private const val CORDA_USER_PASSWORD = “config.rpc.password”

    private const val CORDA_NODE_HOST = “config.rpc.host”

    private const val CORDA_RPC_PORT = “config.rpc.port”

    private const val CORDA__RPC_PORT1 = “configNode1.rpc.port”

    @Component

    open class NodeRPCConnection (

        @Value(“\${$CORDA_NODE_HOST}”>) private val host: String ,

        @Value(“\${$CORDA_NODE_HOST}”>) private val username : String ,

        @Value(“\${$CORDA_NODE_HOST}”>) private val password : String ,

        @Value(“\${$CORDA_NODE_HOST}”>) private val rpcPort : Int ,

        @Value(“\${$CORDA_NODE_HOST}”>) private val host: rpcPort1 : In
    ) :AutoCloseable{

        lateinit var rpcConnection: CordaRPCConnection

     private set

        lateinit var proxy: CordaRPCOps

         private

     @PostConstruct

       fun initialiseNodeRPCConnectionDelhi()

       {

       val rpcAddress = NetworkHostAndPort(host, rpcPort)

       val rpcClient = CordaRPCClient(rpcAddress)

       println(“rpcClient=======” + rpcClient)

       val rpcConnection = rpcClient.start(username, password)

        proxy = rpcConnection.proxy

           

       }

        @PreDestroy

        override fun close() {
    {

            rpcConnection.notifyServerAndClose()

        }

    Spring API

    Rest Controller

    @RestController

    class CustomController(rpc: NodeRPCConnection) {

        private val proxy = rpc.proxy

       @GetMapping(value = “/me” , produces =
    arrayOf(MediaType.APPLICATION_JSON_VALUE))

      /**

          Returns the node’s name where spring Application running.

        **/

         private fun me() : ResponseEntity<Map<String,Any>> {

        return
      ResponseHandler.generateResponse(HttpStatus.OK,true,proxy.nodeInfo().legalIdentities.first().name)

        }/**

         * Returns all parties registered with the [NetworkMapService]. 

       */

         @GetMapping(value = “/peers”, produces =
    , produces = arrayOf(MediaType.APPLICATION_JSON_VALUE))

         private fun peers() :ResponseEntity<Map<String,Any>> {

         var partylist = proxy.networkMapSnapshot().flatMap { it.legalIdentities}

          var peers : ArrayList = ArrayList()

          for (i in partylist)

            {

              peers.add(i.name)

            }

            return ResponseHandler.generateResponse(HttpStatus.OK,true,peers)

        }

    }

    Application Properties

    spring.jackson.serialization.fail-on-empty-beans=afalse

    config.rpc.username = user1

    config.rpc.password = test

    config.rpc.host=localhost

    config.rpc.port= 10006

    Conclusion

    We hope this post helps you understand how to develop a Corda application with spring boot. However, there is a lot to learn. We have only covered the basics in this post. We have implemented the CordaRPCConnection and CordaRPCClient. We have planned to write more posts on developing Corda while focusing on explaining more complex features. Also, take a look at our Corda blockchain development services for enterprise as well as public solutions.


Leave a Comment

Name is required

Comment is required

Recaptcha is required.

No Comments Yet.

About Author

deepak.maurya (Writer)

More From Oodles

Cookies are important to the proper functioning of a site. To improve your experience, we use cookies to remember log-in details and provide secure log-in, collect statistics to optimize site functionality, and deliver content tailored to your interests. Click Agree and Proceed to accept cookies and go directly to the site or click on View Cookie Settings to see detailed descriptions of the types of cookies and choose whether to accept certain cookies while on the site.