DEV Community: Aman Bhardwaj

Dagger2 Dependency Injection in Kotlin & Ktor

Aman Bhardwaj — Sat, 27 Jan 2024 14:01:05 +0000

Introduction

In this article, we will delve into the world of Dagger2 Dependency Injection (DI) in Kotlin, particularly focusing on integrating it with the Ktor framework. If you've previously worked with Spring Boot, you might be familiar with the concept of dependency injection through annotations like @Autowired. However, Ktor does not provide the same level of abstraction, so we'll explore how to set up dependency injection from scratch using Dagger2 by Google.

Setting Up Dependencies

Before diving into the implementation, let's ensure we have the necessary dependencies in our project. You can find the complete Gradle setup in the provided GitHub repository. Note that I've made some adjustments to the versions, so ensure that your Kotlin, Ktor, and Dagger2 versions are in sync.

// build.gradle

// Kotlin version and plugins
kotlin {
    version = "1.7.20"
    // other Kotlin plugins...
}

// Ktor dependencies
implementation "io.ktor:ktor-server-core:1.7.0"
implementation "io.ktor:ktor-server-netty:1.7.0"

// Dagger2 dependencies
implementation "com.google.dagger:dagger:2.44"
kapt "com.google.dagger:dagger-compiler:2.44"

Project Structure

Let's organize our project structure to accommodate Dagger2. We'll create two packages: modules and components under the dagger package. Additionally, we can introduce layers such as handlers, services, and repos to structure our application.

src
|-- main
    |-- kotlin
        |-- your.package.name
            |-- dagger
                |-- components
                |-- modules
            |-- handlers
            |-- services
            |-- repos

Creating User Handlers

First, let's set up the user handling layers. We'll define an interface UserHandler with a method createUser and provide an implementation for it.

// UserHandler.kt

interface UserHandler {
    fun createUser(user: UserModel): Boolean
}

// UserHandlerImpl.kt

class UserHandlerImpl : UserHandler {
    override fun createUser(user: UserModel): Boolean {
        // Implementation logic (logging for now)
        return true
    }
}

Dagger2 Modules

Now, we'll create Dagger2 modules for our user handling components. Start with the UserHandlerModule.

// UserHandlerModule.kt

@Module
class UserHandlerModule {

    @Provides
    @Singleton
    fun provideUserHandler(): UserHandler {
        return UserHandlerImpl()
    }
}

Dagger2 Components

Next, let's create Dagger2 components for our user handling layers.

// UserHandlerComponent.kt

@Component(modules = [UserHandlerModule::class])
interface UserHandlerComponent {
    fun getUserHandler(): UserHandler
}

Integrating with Ktor
Now, let's integrate our Dagger2 components with Ktor. We'll update our routing configuration to use the UserHandler instance.

// Application.kt

fun Application.module() {
    // Other Ktor configurations...

    install(ContentNegotiation) {
        // Content negotiation configuration...
    }

    val userHandler = DaggerUserHandlerComponent.create().getUserHandler()

    routing {
        route("/users") {
            post {
                val user = call.receive<UserModel>()
                if (userHandler.createUser(user)) {
                    call.respond(HttpStatusCode.Created)
                } else {
                    call.respond(HttpStatusCode.InternalServerError)
                }
            }
        }
    }
}

Conclusion
In this article, we've successfully integrated Dagger2 for dependency injection in a Kotlin Ktor application. We've organized our project structure, created modules and components, and demonstrated how to inject dependencies into Ktor routes. This lays a solid foundation for future expansion, such as introducing a database layer or integrating with external APIs and for that, checkout my Udemy course:

REST API in Kotlin & Ktor

What you'll learn in this course?

Build a REST API in Kotlin & Ktor
User PostgreSQL as the Database
Structure project with dependency injection using Dagger2
Hands on coding tutorials with no slides

I will see you in the next article. Until then, scatter.

You know where to find me:
LinkedIn
YouTube
Github
Udemy

Building a Golang HTTP Server: From Hello World to Dependency Injection

Aman Bhardwaj — Tue, 23 Jan 2024 15:15:03 +0000

Introduction:

In this article, we'll explore the process of building an HTTP server using Golang, from the initial setup of a blank project to implementing routes and utilizing dependency injection for a cleaner and more maintainable codebase.

Setting Up the Project:

To kick things off, let's start by creating a new Golang project in Visual Studio Code. Navigate to a blank folder, open VS Code, and create a file named "main.go." Begin with the standard package declaration and a simple "Hello, World!" output using the fmt package.



package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

Spinning Up the Basic HTTP Server:

Moving on, we'll evolve our project into an HTTP server. Golang provides a straightforward way to accomplish this, as demonstrated by the following code snippet:



package main

import (
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, Go!")
    })

    http.ListenAndServe(":3000", nil)
}

This basic setup responds with "Hello, Go!" when accessing the root URL. However, the absence of defined routes results in a 404 page.

Cleaning Up with Gorilla Mux:

To enhance the structure of our server, we'll employ the Gorilla Mux package for handling routes. First, initialize the Go module and add the Gorilla Mux package.



go mod init github.com/your-username/your-project
go get github.com/gorilla/mux



package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    router := mux.NewRouter()

    router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, Go!")
    })

    http.Handle("/", router)
    http.ListenAndServe(":3000", nil)
}

Implementing Dependency Injection:

To further enhance our project's structure, we'll implement dependency injection by creating a new file named "api.go." This new file introduces a more organized approach to managing the server instance.



package main

import (
    "net/http"
    "github.com/gorilla/mux"
)

// API struct represents the API server.
type APIServer struct {
    address string
}

// NewAPI initializes a new APIServer instance.
func NewAPIServer(address string) *APIServer{
    return &APIServer{
        address: address,
    }
}

// Run starts the API server.
func (a *APIServer) Run() error {
    router := mux.NewRouter()
    router.HandleFunc("/hello", a.handleGreet)

    fmt.Printf("Server starting on address %s", a.addr)
    return http.ListenAndServe(a.address, router)
}

With this approach, we have a more modular and organized project structure.
Now let's embed our handler into the API to handle our "/hello" route.
Let's create a new file named "routes.go"



func (a *APIServer) handleGreet(w http.ResponseWriter, r *http.Request) {
   w.Write([]byte("Method not supported"))
   return
}

The main.go file now looks cleaner:



package main

func main() {
    api := NewAPIServer(":3000")

    if err := api.Run(); err != nil {
        fmt.Println("Error starting the server:", err)
    }
}

Conclusion:

In this article, we've progressed from a basic "Hello, World!" program to building a more organized Golang HTTP server. By incorporating Gorilla Mux for routing and implementing dependency injection, our project becomes scalable, modular, and easier to maintain.
This was a mere glimpse of what we did in this Udemy course of mine:
REST API using GoLang, PostgreSQL, Keycloak, Docker
I will see you in the next article. Until then, scatter.

Now you know where to find me:
LinkedIn
YouTube
Github
Udemy