Gain insights into Kotlin language essentials and delve into design patterns and best practices. Discover functional programming techniques to enhance code reuse, robustness, and build reliable, scalable projects.

Packt MBE - Kotlin Design Patterns and Best Practices.png

Kotlin_optimized.tar.gz

Kotlin

Kotlin_Co

Kotlin_SPA

Cats_Hostel

Cats_Shelter(1..5)

Cats_Shelter(6-7-8)

Design patterns enable developers to speed up the development process by providing proven development paradigms. Reusing design patterns helps prevent complex issues that can cause major problems. Moreover, it improves your codebase, promotes code reuse, and makes an architecture more robust.

In this course, you will start with a gentle introduction of the Kotlin language. You will explore design patterns that are part of the best practices that help developers use Kotlin efficiently. Design patterns appeared in the era of object-oriented languages such as C++ and Java. You will learn the language features that Kotlin provides, which allow developers to program in a functional style and implement the design patterns.

After taking this course, you’ll be able to take your knowledge of Kotlin, design patterns, and associated best practices to the software industry and apply it to build reliable, scalable, and maintainable projects.

Kotlin Design Patterns and Best Practices

## Event Bus and Message Passing

**Event Bus** is an implementation of the Observable design pattern. 

We've already mentioned that Vert.x is based on the concept of verticles, which are isolated actors.  Kotlin's `coroutines` library provides the `actor()` and `producer()` coroutine generators, which create a coroutine bound to a channel.

Similarly, all the verticles in the Vert.x framework are bound by Event Bus and can pass messages to one another using it. Now, let's extract the code from our `ServerVerticle` class into a new class, which we'll call `CatVerticle`.

Any verticle can send a message over Event Bus by choosing between the following methods:

* `request()` will send a message to only one subscriber and wait for a response.
* `send()` will send a message to only one subscriber, without waiting for a response.
* `publish()` will send a message to all subscribers, without waiting for a response.

No matter which method is used to send the message, we subscribe to it using the `consumer()` method on Event Bus.

Now, let's subscribe to an event in our `CatsVerticle` class:

```
class CatsVerticle : CoroutineVerticle() {
     override suspend fun start() {
         val db = Db.connect(vertx)
         vertx.eventBus().consumer<Int("cats:delete"){req->
             launch {
                 val id = req.body()
                 db.preparedQuery("DELETE FROM
                   cats WHERE ID = $1")
                     .execute(Tuple.of(id)).await()
                 req.reply(null)
             }
         }
     }
}
```

The generic type of the `consumer()` method specifies the type of message we'll receive. In this case, it's `Int`.

The string that we provide to the method---in our case, `cats:delete`---is the address we subscribe to. It can be any string, but it is good to have some convention, such as what type of object we operate on and what we want to do with it.

Once the delete action has been executed, we respond to our publisher with the `reply()` method. Since we don't have any information to send back, we simply send `null`.

Now, let's replace our previous `delete` route with the following code:
```
router.delete("/:id").handler { ctx ->
    val id = ctx.request().getParam("id").toInt()
    vertx.eventBus().request<Nothing>("cats:delete", id) {
        ctx.end()
    }
}
```

Here, we send the ID of the cat we received from the request to one of our listeners using the `request()` method, and we specify that the type of our message is `Int`. We also use the same address we specified in the consumer code.

Because we've split our code into a new verticle, we need to remember to start it as well. Add the following line to both the `main()` function and the `setup()` method in the test:

```
vertx.deployVerticle(CatsVerticle())
```
Next, let's learn how to send complex objects over Event Bus.

## Sending JSON over Event Bus
As our final exercise, let's learn how to update a cat. For that, we'll need to send more than just an ID over Event Bus.

Let's rewrite our `put` handler, as follows:

```
router.put("/:id").handler { ctx ->
     launch {
        val id = ctx.request().getParam("id").toInt()
        val body: JsonObject = ctx.bodyAsJson.mergeIn(json{
            obj("id" to id)
         })
         
         vertx.eventBus().request<Int>("cats:update", body)
         { res ->
             ctx.end(res.result().body().toString())
         }
     }
}
```
Here, we can see that we can send JSON objects over Event Bus easily. We merge the ID we receive as a URL parameter with the rest of the request body and send this JSON over an Event Bus. When a response is received, we output it back to the user.
Now, let's see how we consume the event we just sent:

```
vertx.eventBus().consumer<JsonObject>("cats:update"){req ->
    launch {
        val body = req.body()
        db.preparedQuery("UPDATE cats SET name = $1, age = $2 WHERE ID = $3")
           .execute(
                Tuple.of(
                   body.getString("name"),
                   body.getInteger("age"),
                   body.getInteger("id")
                )
           ).await()
        req.reply(body.getInteger("id"))
    }
}
```

We moved our logic from `Router` to our `CatsVerticle` class, but because we used JSON to communicate, the code stayed almost the same. In our verticle, we listen to the `cats:update` event, and once we receive the response, we extract `name`, `age`, and `id` from the JSON object to confirm that the operation was successful.




Learn how to split all the routes into a separate file and organize the application using communication with Event Bus.

Getting Started with Kotlin

Working with Creational Patterns

Understanding Structural Patterns

Getting Familiar with Behavioral Patterns

Introducing Functional Programming

Threads and Coroutines

Controlling the Data Flow

Designing for Concurrency

Idioms and Anti-Patterns

Concurrent Microservices with Ktor

Reactive Microservices with Vert.x

Conclusion

Communicating with Event Bus

Event Bus and Message Passing