Implementasi GORM dan MariaDB pada Golang

Setelah memahami konsep Clean Architecture dalam pengembangan aplikasi Go, selanjutnya kita akan mengimplementasikan database menggunakan GORM dan MariaDB. GORM adalah ORM (Object Relational Mapping) yang populer di Golang, sedangkan MariaDB adalah sistem manajemen basis data yang kompatibel dengan MySQL.

1. Instalasi dan Konfigurasi

a. Instalasi MariaDB

Pastikan MariaDB sudah terinstal pada sistem. Jika belum, Anda bisa menginstalnya dengan perintah berikut:

Ubuntu/Linux:

sudo apt update
sudo apt install mariadb-server

Windows: Unduh installer MariaDB dari situs resmi.

Setelah instalasi, jalankan MariaDB:

sudo systemctl start mariadb

Buat database baru:

CREATE DATABASE my_database;

b. Instalasi GORM dan Driver MySQL/MariaDB

Dalam proyek Go, instalasi GORM dan driver MariaDB dapat dilakukan dengan perintah:

go get -u gorm.io/gorm

Untuk driver MySQL/MariaDB:

go get -u gorm.io/driver/mysql

2. Koneksi Database di Golang

Buat file database.go untuk mengatur koneksi ke MariaDB.

package database

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "log"
)

var DB *gorm.DB

func ConnectDB() {
    dsn := "user:password@tcp(127.0.0.1:3306)/my_database?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Gagal terhubung ke database: ", err)
    }
    DB = db
}

Pastikan untuk mengganti user dan password sesuai dengan kredensial MariaDB Anda.

3. Implementasi Model (Entity Layer)

Buat model untuk entitas yang akan digunakan. Misalnya, kita memiliki entitas User.

package entity

import "gorm.io/gorm"

type User struct {
    gorm.Model
    Name  string `gorm:"size:100"`
    Email string `gorm:"unique"`
    Age   int
}

4. Implementasi Repository (Infrastructure Layer)

Buat user_repository.go untuk mengelola akses data.

package repository

import (
    "my_project/entity"
    "gorm.io/gorm"
)

type UserRepository struct {
    db *gorm.DB
}

func NewUserRepository(db *gorm.DB) *UserRepository {
    return &UserRepository{db}
}

func (r *UserRepository) Create(user *entity.User) error {
    return r.db.Create(user).Error
}

func (r *UserRepository) FindByID(id uint) (*entity.User, error) {
    var user entity.User
    err := r.db.First(&user, id).Error
    return &user, err
}

5. Implementasi Use Case (Application Layer)

Buat user_usecase.go untuk menangani logika bisnis.

package usecase

import (
    "my_project/entity"
    "my_project/repository"
)

type UserUseCase struct {
    repo *repository.UserRepository
}

func NewUserUseCase(repo *repository.UserRepository) *UserUseCase {
    return &UserUseCase{repo}
}

func (uc *UserUseCase) RegisterUser(name, email string, age int) (*entity.User, error) {
    user := &entity.User{Name: name, Email: email, Age: age}
    err := uc.repo.Create(user)
    return user, err
}

6. Implementasi Delivery (Interface Layer)

Buat handler untuk menangani HTTP request menggunakan Echo.

package delivery

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

type UserHandler struct {
    useCase *usecase.UserUseCase
}

func NewUserHandler(useCase *usecase.UserUseCase) *UserHandler {
    return &UserHandler{useCase}
}

func (h *UserHandler) RegisterUser(c echo.Context) error {
    var req struct {
        Name  string `json:"name"`
        Email string `json:"email"`
        Age   int    `json:"age"`
    }
    if err := c.Bind(&req); err != nil {
        return c.JSON(http.StatusBadRequest, map[string]string{"error": err.Error()})
    }

    user, err := h.useCase.RegisterUser(req.Name, req.Email, req.Age)
    if err != nil {
        return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
    }

    return c.JSON(http.StatusCreated, user)
}

7. Implementasi main.go

Buat file main.go untuk menghubungkan semua komponen dan menjalankan server HTTP menggunakan Echo.

package main

import (
    "my_project/database"
    "my_project/delivery"
    "my_project/repository"
    "my_project/usecase"
    "github.com/labstack/echo/v4"
    "log"
)

func main() {
    // Koneksi ke database
    database.ConnectDB()

    // Inisialisasi repository, use case, dan handler
    userRepo := repository.NewUserRepository(database.DB)
    userUseCase := usecase.NewUserUseCase(userRepo)
    userHandler := delivery.NewUserHandler(userUseCase)

    // Setup Echo
    e := echo.New()
    e.POST("/users", userHandler.RegisterUser)

    // Menjalankan server
    log.Println("Server berjalan di port 8080")
    e.Start(":8080")
}

Kesimpulan

Dengan implementasi ini, kita telah berhasil menghubungkan GORM dengan MariaDB dalam proyek Golang yang menggunakan Clean Architecture. Struktur ini memungkinkan pemisahan tanggung jawab yang jelas antara entity, use case, repository, dan delivery, serta menggunakan Echo sebagai framework HTTP untuk meningkatkan efisiensi dan kemudahan pengembangan.