Clean Architecture dalam Pengembangan Aplikasi Go

Clean Architecture adalah pendekatan arsitektur perangkat lunak yang bertujuan untuk membuat sistem lebih terstruktur, mudah diuji, dan scalable. Dengan menggunakan Clean Architecture, kode aplikasi dipisahkan menjadi beberapa lapisan yang memiliki tanggung jawab masing-masing. Artikel ini akan membahas konsep, prinsip, dan implementasi Clean Architecture dalam pengembangan aplikasi menggunakan bahasa Go.

Apa Itu Clean Architecture?

Clean Architecture diperkenalkan oleh Robert C. Martin (Uncle Bob) sebagai pendekatan yang memungkinkan aplikasi tetap fleksibel, modular, dan mudah dikembangkan. Clean Architecture berfokus pada pemisahan antara logika bisnis inti dengan detail implementasi seperti framework, database, atau UI.

Prinsip utama dari Clean Architecture meliputi:

• Independensi Framework: Aplikasi tidak bergantung pada framework tertentu.
• Independensi Database: Aplikasi tidak terikat pada teknologi database tertentu.
• Independensi UI: Antarmuka pengguna dapat diganti tanpa mempengaruhi logika bisnis.
• Testability: Setiap komponen dapat diuji secara terpisah.
• Dependency Rule: Lapisan dalam tidak boleh bergantung pada lapisan luar.

Struktur Clean Architecture dalam Go

Dalam pengembangan aplikasi dengan Go, Clean Architecture umumnya dibagi menjadi beberapa lapisan berikut:

1. Entity (Domain Layer)
   • Berisi model data dan aturan bisnis inti aplikasi.
2. Use Case (Application Layer)
   • Menyediakan logika bisnis utama dan berinteraksi dengan repository.
3. Repository (Infrastructure Layer)
   • Mengelola akses data dari database atau sumber lain.
4. Delivery (Interface Layer)
   • Menangani komunikasi dengan pengguna, seperti HTTP handler.

Implementasi Clean Architecture dalam Aplikasi Go

1. Membuat Entity (Domain Layer)

package entity

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

2. Membuat Repository Interface

package repository

import "myapp/entity"

type UserRepository interface {
    GetByID(id int) (*entity.User, error)
    Create(user *entity.User) error
}

3. Implementasi Use Case

package usecase

import (
    "myapp/entity"
    "myapp/repository"
)

type UserUseCase struct {
    userRepo repository.UserRepository
}

func (u *UserUseCase) GetUser(id int) (*entity.User, error) {
    return u.userRepo.GetByID(id)
}

4. Implementasi Handler (Delivery Layer)

package handler

import (
    "net/http"
    "strconv"
    "github.com/labstack/echo/v4"
    "myapp/usecase"
)

type UserHandler struct {
    userUC *usecase.UserUseCase
}

func (h *UserHandler) GetUser(c echo.Context) error {
    id, _ := strconv.Atoi(c.Param("id"))
    user, err := h.userUC.GetUser(id)
    if err != nil {
        return c.JSON(http.StatusNotFound, map[string]string{"error": "User not found"})
    }
    return c.JSON(http.StatusOK, user)
}

Kesimpulan

Dengan menerapkan Clean Architecture dalam pengembangan aplikasi Go, kita dapat menjaga modularitas, fleksibilitas, dan kemudahan pemeliharaan kode. Setiap lapisan memiliki tanggung jawabnya sendiri, sehingga memungkinkan pengembangan yang lebih terstruktur dan scalable.