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

To store and retrieve cat data , we'll need to connect to a database. We'll use PostgreSQL for that purpose, although using another SQL database won't be any different.

## Adding the `exposed` library

First, we'll need a new library to connect to the database. We'll use the Exposed library, which is also developed by JetBrains.

Let's add the following dependency to our `build.gradle.kts` file:
```
dependencies {
    implementation("org.jetbrains.exposed:exposed:0.17.14")
    implementation("org.postgresql:postgresql:42.2.24")
    ...
}
```
## Connecting to the database

Once the libraries are in place, we need to connect to them. To do that, let's create a new file called `db.kt` under `/src/main/kotlin/catshostel` with the following contents:
```
object DB {
     private val host=System.getenv("DB_HOST")?:"localhost"
     .
     .
     .
     fun connect() = Database.connect(
         "jdbc:postgresql://$host:$port/$dbName",
         driver = "org.postgresql.Driver",
         user = dbUser,
         password = dbPassword
     )
}
```
Since our application needs exactly one instance of a database, the `DB` object can use the Singleton pattern. For that, we will use the `object` keyword.

Then, for each of the variables that we need to connect to the database, we will attempt to read them from our environment. If the `environment` variable is not set, we will use a default value using the Elvis operator.

To create a database and an admin we can simply run the following two commands in our command line:
```
$ createuser cats_admin -W –d
$ createdb cats_db -U cats_admin
```

The first command creates a database user called `cats_admin` and asks us to specify a password for this user. Our application will use this `cats_admin` user to interact with the database. The second command creates a database called `cats_db` that belongs to the `cats_admin` user. Now that our database has been created, all we need to do is create a table that will store our cats in it.


## Creating the `CatsTable`

For storing the cats' data, we'll create a table called `CatsTable`. Let's define another Singleton object in our `db.kt` file that will represent a table:

```
object CatsTable : IntIdTable() {
     val name = varchar("name", 20).uniqueIndex()
     val age = integer("age").default(0)
}
```

Let's understand what the preceding definition means:
* `IntIdTable` means that we want to create a table with a primary key of the `Int` type.
* In the body of our object, we define the columns. In addition to the `ID` column, we'll have a name column that is of the `varchar` type, or in other words, a string, and is `20` characters at the most.
* The cat's `name` column is also unique, meaning that no two cats can have the same name.
* We also have a third column that is of the `integer` type, or `Int` in Kotlin terms, and is defaulted to `0`.

## Creating the Cat data class

We'll also have a `data` class to represent a single cat:
```
data class Cat(val id: Int,
               val name: String,
               val age: Int)
```
The only thing that is left for us to do is add the following lines of code to our `mainModule()` function in `App.kt`:
```
DB.connect()
transaction {
    SchemaUtils.create(CatsTable)
}
```

Each time our application starts, the preceding code will connect to the database. Then, it will attempt to create a table that stores our entities. If a table already exists, nothing will happen.


Let's see the output by running the application:



Learn how to connect to a database in Ktor application using Kotlin language.

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

Connecting to the Database

Adding the `exposed` library

Connecting to the Database

Adding the exposed library

Adding the `exposed` library