Menghubungkan Golang dengan Database MySQL/PostgreSQL

Golang, atau Go, telah menjadi bahasa pemrograman yang sangat populer karena kemudahan penggunaannya, performa tinggi, dan dukungan kuat dari komunitas.

Golang, atau Go, telah menjadi bahasa pemrograman yang sangat populer karena kemudahan penggunaannya, performa tinggi, dan dukungan kuat dari komunitas. Salah satu aspek penting dalam pengembangan aplikasi adalah kemampuan untuk berinteraksi dengan database. Dalam artikel ini, kita akan membahas cara menghubungkan aplikasi Golang dengan dua database populer, yaitu MySQL dan PostgreSQL. Dengan pemahaman ini, Anda dapat membangun aplikasi yang lebih dinamis dan kaya fitur. Kami juga akan menunjukkan bagaimana melakukan operasi dasar seperti membuat, membaca, memperbarui, dan menghapus (CRUD) data dalam database. Untuk tutorial yang lebih mendetail, Anda dapat merujuk ke tutorial Golang database .

1. Persiapan Lingkungan

Sebelum memulai, pastikan Golang sudah terinstal di sistem Anda. Jika belum, Anda dapat mengunduh dan menginstalnya dari situs resmi Golang . Selain itu, pastikan Anda telah menginstal MySQL dan/atau PostgreSQL di sistem Anda. Jika belum, Anda dapat mengikuti petunjuk instalasi dari situs resmi masing-masing database.

2. Instalasi dan Konfigurasi Library

Untuk menghubungkan Golang dengan MySQL dan PostgreSQL, kita membutuhkan library khusus. Gunakan perintah berikut untuk menginstal library yang diperlukan:

Untuk MySQL:

1go get -u github.com/go-sql-driver/mysql

Untuk PostgreSQL:

1go get -u github.com/lib/pq

3. Membuat Struktur Proyek

Buat struktur direktori untuk proyek Anda:

bash

 1database-connection/
 2├── main.go
 3├── config/
 4│   └── config.go
 5├── models/
 6│   └── user.go
 7├── repositories/
 8│   └── userRepository.go
 9├── services/
10│   └── userService.go

4. Konfigurasi Database

Buat file config/config.go untuk mengatur konfigurasi koneksi database:

 1package config
 2
 3import (
 4    "database/sql"
 5    "log"
 6
 7    _ "github.com/go-sql-driver/mysql"
 8    _ "github.com/lib/pq"
 9)
10
11func ConnectMySQL() (*sql.DB, error) {
12    dsn := "user:password@tcp(127.0.0.1:3306)/dbname"
13    db, err := sql.Open("mysql", dsn)
14    if err != nil {
15        log.Fatal(err)
16        return nil, err
17    }
18    if err := db.Ping(); err != nil {
19        log.Fatal(err)
20        return nil, err
21    }
22    return db, nil
23}
24
25func ConnectPostgreSQL() (*sql.DB, error) {
26    dsn := "postgres://user:password@localhost/dbname?sslmode=disable"
27    db, err := sql.Open("postgres", dsn)
28    if err != nil {
29        log.Fatal(err)
30        return nil, err
31    }
32    if err := db.Ping(); err != nil {
33        log.Fatal(err)
34        return nil, err
35    }
36    return db, nil
37}

5. Membuat Model User

Buat file models/user.go untuk mendefinisikan model data pengguna:

1package models
2
3type User struct {
4    ID    int    `json:"id"`
5    Name  string `json:"name"`
6    Email string `json:"email"`
7}

6. Membuat Repository User

Repository bertanggung jawab untuk berinteraksi dengan database. Buat file repositories/userRepository.go:

 1package repositories
 2
 3import (
 4    "database/sql"
 5    "webapp/models"
 6)
 7
 8type UserRepository struct {
 9    DB *sql.DB
10}
11
12func NewUserRepository(db *sql.DB) *UserRepository {
13    return &UserRepository{DB: db}
14}
15
16func (r *UserRepository) CreateUser(user models.User) error {
17    _, err := r.DB.Exec("INSERT INTO users (name, email) VALUES (?, ?)", user.Name, user.Email)
18    return err
19}
20
21func (r *UserRepository) GetAllUsers() ([]models.User, error) {
22    rows, err := r.DB.Query("SELECT id, name, email FROM users")
23    if err != nil {
24        return nil, err
25    }
26    defer rows.Close()
27
28    users := []models.User{}
29    for rows.Next() {
30        var user models.User
31        err := rows.Scan(&user.ID, &user.Name, &user.Email)
32        if err != nil {
33            return nil, err
34        }
35        users = append(users, user)
36    }
37    return users, nil
38}
39
40func (r *UserRepository) GetUserByID(id int) (models.User, error) {
41    var user models.User
42    err := r.DB.QueryRow("SELECT id, name, email FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name, &user.Email)
43    return user, err
44}
45
46func (r *UserRepository) UpdateUser(user models.User) error {
47    _, err := r.DB.Exec("UPDATE users SET name = ?, email = ? WHERE id = ?", user.Name, user.Email, user.ID)
48    return err
49}
50
51func (r *UserRepository) DeleteUser(id int) error {
52    _, err := r.DB.Exec("DELETE FROM users WHERE id = ?", id)
53    return err
54}

7. Membuat Service User

Service mengandung logika bisnis aplikasi Anda. Buat file services/userService.go:

 1package services
 2
 3import (
 4    "webapp/models"
 5    "webapp/repositories"
 6)
 7
 8type UserService struct {
 9    Repo *repositories.UserRepository
10}
11
12func NewUserService(repo *repositories.UserRepository) *UserService {
13    return &UserService{Repo: repo}
14}
15
16func (s *UserService) CreateUser(user models.User) error {
17    return s.Repo.CreateUser(user)
18}
19
20func (s *UserService) GetAllUsers() ([]models.User, error) {
21    return s.Repo.GetAllUsers()
22}
23
24func (s *UserService) GetUserByID(id int) (models.User, error) {
25    return s.Repo.GetUserByID(id)
26}
27
28func (s *UserService) UpdateUser(user models.User) error {
29    return s.Repo.UpdateUser(user)
30}
31
32func (s *UserService) DeleteUser(id int) error {
33    return s.Repo.DeleteUser(id)
34}

8. Membuat Fungsi Utama

Terakhir, buat file main.go untuk menjalankan aplikasi:

  1package main
  2
  3import (
  4    "database/sql"
  5    "log"
  6    "net/http"
  7    "webapp/config"
  8    "webapp/models"
  9    "webapp/repositories"
 10    "webapp/services"
 11
 12    "github.com/gin-gonic/gin"
 13)
 14
 15func main() {
 16    // Pilih koneksi database: MySQL atau PostgreSQL
 17    db, err := config.ConnectMySQL()
 18    // db, err := config.ConnectPostgreSQL()
 19    if err != nil {
 20        log.Fatal(err)
 21    }
 22    defer db.Close()
 23
 24    userRepo := repositories.NewUserRepository(db)
 25    userService := services.NewUserService(userRepo)
 26
 27    router := gin.Default()
 28
 29    router.POST("/users", func(c *gin.Context) {
 30        var user models.User
 31        if err := c.ShouldBindJSON(&user); err != nil {
 32            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 33            return
 34        }
 35        if err := userService.CreateUser(user); err != nil {
 36            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 37            return
 38        }
 39        c.JSON(http.StatusOK, user)
 40    })
 41
 42    router.GET("/users", func(c *gin.Context) {
 43        users, err := userService.GetAllUsers()
 44        if err != nil {
 45            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 46            return
 47        }
 48        c.JSON(http.StatusOK, users)
 49    })
 50
 51    router.GET("/users/:id", func(c *gin.Context) {
 52        id, err := strconv.Atoi(c.Param("id"))
 53        if err != nil {
 54            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
 55            return
 56        }
 57        user, err := userService.GetUserByID(id)
 58        if err != nil {
 59            c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
 60            return
 61        }
 62        c.JSON(http.StatusOK, user)
 63    })
 64
 65    router.PUT("/users/:id", func(c *gin.Context) {
 66        id, err := strconv.Atoi(c.Param("id"))
 67        if err != nil {
 68            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
 69            return
 70        }
 71        var user models.User
 72        if err := c.ShouldBindJSON(&user); err != nil {
 73            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 74            return
 75        }
 76        user.ID = id
 77        if err := userService.UpdateUser(user); err != nil {
 78            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 79            return
 80        }
 81        c.JSON(http.StatusOK, user)
 82    })
 83
 84    router.DELETE("/users/:id", func(c *gin.Context) {
 85        id, err := strconv.Atoi(c.Param("id"))
 86        if err != nil {
 87            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
 88            return
 89        }
 90       
 91
 92 if err := userService.DeleteUser(id); err != nil {
 93            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 94            return
 95        }
 96        c.JSON(http.StatusOK, gin.H{"message": "User deleted"})
 97    })
 98
 99    router.Run(":8080")
100}

Kesimpulan

Dalam artikel ini, kita telah membahas cara menghubungkan Golang dengan database MySQL dan PostgreSQL. Dengan mengikuti langkah-langkah di atas, Anda dapat membangun aplikasi yang dapat berinteraksi dengan database untuk melakukan operasi CRUD dasar. Koneksi database yang efisien sangat penting untuk aplikasi yang membutuhkan penyimpanan dan pengambilan data yang cepat. Untuk tutorial yang lebih mendalam, Anda dapat merujuk ke tutorial Golang database untuk mendapatkan pemahaman yang lebih lengkap. Semoga artikel ini membantu Anda dalam mengembangkan aplikasi Golang yang terintegrasi dengan baik dengan database. Selamat mencoba dan selamat berkoding!

# golang database # golang mysql # golang postgresql

Ihsan Arif

Backend engineer & penulis di Santekno. Aktif menulis tentang Go, Laravel, dan arsitektur backend modern.

Menghubungkan Golang dengan Database MySQL/PostgreSQL

1. Persiapan Lingkungan

2. Instalasi dan Konfigurasi Library

3. Membuat Struktur Proyek

4. Konfigurasi Database

6. Membuat Repository User

7. Membuat Service User

8. Membuat Fungsi Utama

Kesimpulan

💬 Komentar

Berita lainnya

Go 1.23 Rilis: Range over Functions, Iterators, dan Timer Fix

Rental Mobil Kapasitas 7 Seat Bandung Murah

Rekomendasi Keyboard Keychron Bekas di Bawah 1 Juta – Pilihan Hemat dan Berkualitas