crud flutter

Halo AnakInformatika! Pernah kepikiran gimana caranya aplikasi Android atau iOS yang kamu buat bisa menyimpan data, mengambil data, atau berinteraksi dengan dunia luar? Jawabannya ada di API (Application Programming Interface)! Nah, di tutorial kali ini, kita akan belajar Tutorial Golang: Bikin API CRUD dalam 15 Menit untuk Aplikasi Android/iOS. Yup, kamu tidak salah dengar, hanya dalam hitungan menit kita akan setup backend API yang powerful menggunakan Golang. Mari kita buktikan!

Golang, atau sering disebut Go, adalah bahasa pemrograman yang super efisien, cepat, dan sangat digandrungi untuk membangun backend service, microservices, hingga API. Dengan sintaksnya yang bersih dan fitur konkurensinya yang ciamik, Golang bisa jadi pilihan tepat buat kamu yang ingin membangun API untuk aplikasi mobile-mu dengan performa tinggi.

API Itu Apa Sih? Analoginya Mirip Pelayan Restoran!

Sebelum kita mulai ngoding, mari kita pahami dulu apa itu API dengan analogi sederhana. Bayangkan kamu sedang makan di restoran. Kamu (aplikasi mobile) ingin memesan makanan (data). Tapi kamu tidak bisa langsung masuk dapur (database) dan ambil makanan sendiri, kan?

Di sinilah peran pelayan restoran (API) muncul. Kamu memberitahu pelayan apa yang kamu mau (request ke API), lalu pelayan meneruskan pesananmu ke dapur. Setelah makanan siap, pelayan akan membawakan makanan itu kepadamu (response dari API). Sederhana, bukan?

Nah, dalam konteks API CRUD (Create, Read, Update, Delete), itu seperti:

  • Create (C): Memesan makanan baru (mengirim data baru ke database).
  • Read (R): Melihat daftar menu atau menanyakan status pesanan (mengambil data dari database).
  • Update (U): Mengganti pesanan atau menambah pesanan (mengubah data yang sudah ada).
  • Delete (D): Membatalkan pesanan (menghapus data dari database).

Semua interaksi ini dilakukan si pelayan (API) antara kamu (aplikasi mobile) dan dapur (database). Paham kan sekarang?

Persiapan Dulu Yuk! (Prasyarat)

Untuk mengikuti tutorial ini dengan lancar, kamu perlu beberapa "amunisi" berikut:

  1. Go Language Terinstal: Pastikan kamu sudah menginstal Golang di komputermu. Minimal versi 1.20 ke atas. Kalau belum, download dan instal dari website resmi Golang.
  2. Text Editor: Visual Studio Code adalah rekomendasi kami karena ekosistemnya yang kaya untuk Go.
  3. Terminal/Command Prompt: Untuk menjalankan perintah Go.
  4. Pemahaman Dasar Go: Sedikit tahu sintaks dasar Go, struct, dan fungsi akan sangat membantu.
  5. Pemahaman Dasar HTTP & JSON: Karena kita akan berinteraksi via HTTP dan data akan dikirim/diterima dalam format JSON.
  6. Postman/Insomnia/Curl: Untuk mengetes API kita nanti.
💡 Tip: Pastikan `GOPATH` dan `GOROOT` sudah tersetting dengan benar di environment variables kamu setelah instalasi Go. Kamu bisa cek dengan perintah `go env`.

Langkah-langkah Praktis: Bikin API Golang CRUD

Oke, kita mulai inti dari Tutorial Golang: Bikin API CRUD dalam 15 Menit untuk Aplikasi Android/iOS ini. Mari kita buat API untuk mengelola daftar buku. Cukup sederhana, tapi mencakup semua operasi CRUD.

1. Inisialisasi Proyek Golang

Pertama, buat folder proyek dan inisialisasi module Go:


mkdir golang-crud-api
cd golang-crud-api
go mod init golang-crud-api

Perintah go mod init golang-crud-api akan membuat file go.mod yang berfungsi untuk mengelola dependensi proyek kita.

2. Install Dependensi yang Dibutuhkan

Untuk API kita, kita butuh dua library:

  • github.com/gorilla/mux: Router HTTP yang powerful dan fleksibel. Standar banget di komunitas Go.
  • github.com/mattn/go-sqlite3: Driver untuk database SQLite. Kita pakai SQLite agar setup database-nya gampang dan cepat, cocok untuk proyek kecil atau prototype.

go get github.com/gorilla/mux
go get github.com/mattn/go-sqlite3

3. Struktur Data (Model)

Buat file main.go di dalam folder golang-crud-api. Kita akan definisikan struktur data untuk buku:


// main.go
package main

import (
	"database/sql" // Untuk berinteraksi dengan database
	"encoding/json" // Untuk encoding/decoding JSON
	"fmt" // Untuk formatting string
	"log" // Untuk logging error dan informasi
	"net/http" // Untuk membangun server HTTP
	"strconv" // Untuk konversi string ke integer

	"github.com/gorilla/mux" // Router HTTP
	_ "github.com/mattn/go-sqlite3" // Driver SQLite, tanda _ berarti import untuk side effect (inisialisasi driver)
)

// Book merepresentasikan struktur data sebuah buku
type Book struct {
	ID     int    `json:"id"`     // ID unik buku, tag json untuk marshalling/unmarshalling JSON
	Title  string `json:"title"`  // Judul buku
	Author string `json:"author"` // Penulis buku
	ISBN   string `json:"isbn"`   // ISBN buku (Unique Identifier)
}

var db *sql.DB // Variabel global untuk koneksi database

4. Inisialisasi Database (SQLite)

Kita akan membuat fungsi initDB yang bertugas menginisialisasi koneksi ke database SQLite dan membuat tabel books jika belum ada.


// initDB menginisialisasi koneksi database dan membuat tabel books jika belum ada
func initDB() {
	var err error
	// Membuka koneksi ke database SQLite. Jika file books.db tidak ada, akan dibuat otomatis.
	db, err = sql.Open("sqlite3", "./books.db")
	if err != nil {
		log.Fatalf("Gagal membuka koneksi database: %v", err) // Hentikan program jika gagal
	}

	// Ping database untuk memastikan koneksi berhasil
	err = db.Ping()
	if err != nil {
		log.Fatalf("Gagal terhubung ke database: %v", err)
	}

	// SQL query untuk membuat tabel books jika belum ada
	createTableSQL := `
	CREATE TABLE IF NOT EXISTS books (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		title TEXT NOT NULL,
		author TEXT NOT NULL,
		isbn TEXT UNIQUE NOT NULL
	);`

	// Jalankan query pembuatan tabel
	_, err = db.Exec(createTableSQL)
	if err != nil {
		log.Fatalf("Gagal membuat tabel books: %v", err)
	}

	log.Println("Database dan tabel 'books' berhasil diinisialisasi!")
}
⚠️ Catatan Penting: Untuk aplikasi produksi, kamu tidak boleh menggunakan variabel global untuk koneksi database seperti ini. Gunakan dependency injection atau passing koneksi sebagai parameter untuk praktik yang lebih baik dan aman. Tapi untuk tutorial 15 menit, ini adalah cara tercepat.

5. Implementasi Handler API (CRUD Operations)

Sekarang kita akan membuat fungsi-fungsi handler untuk setiap operasi CRUD.

a. Get All Books (READ)

Handler ini akan mengambil semua buku dari database.


// getBooks mengambil semua buku dari database
func getBooks(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json") // Set header response ke JSON

	rows, err := db.Query("SELECT id, title, author, isbn FROM books") // Query semua data buku
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError) // Kirim error jika query gagal
		return
	}
	defer rows.Close() // Pastikan rows ditutup setelah selesai

	var books []Book // Slice untuk menampung data buku
	for rows.Next() { // Iterasi setiap baris hasil query
		var book Book
		err := rows.Scan(&book.ID, &book.Title, &book.Author, &book.ISBN) // Scan data ke struct Book
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		books = append(books, book) // Tambahkan buku ke slice
	}

	json.NewEncoder(w).Encode(books) // Encode slice books ke JSON dan kirim sebagai response
}

b. Get Single Book by ID (READ)

Handler ini akan mengambil satu buku berdasarkan ID-nya.


// getBook mengambil satu buku berdasarkan ID
func getBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r) // Ambil parameter dari URL (misal: /books/{id})

	id, err := strconv.Atoi(params["id"]) // Konversi ID dari string ke integer
	if err != nil {
		http.Error(w, "ID buku tidak valid", http.StatusBadRequest)
		return
	}

	var book Book
	// Query buku berdasarkan ID
	row := db.QueryRow("SELECT id, title, author, isbn FROM books WHERE id = ?", id)
	err = row.Scan(&book.ID, &book.Title, &book.Author, &book.ISBN) // Scan hasilnya
	if err == sql.ErrNoRows { // Jika buku tidak ditemukan
		http.Error(w, "Buku tidak ditemukan", http.StatusNotFound)
		return
	} else if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(book) // Encode buku ke JSON dan kirim
}

c. Create Book (CREATE)

Handler ini akan menambahkan buku baru ke database.


// createBook menambahkan buku baru ke database
func createBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var book Book
	// Decode body request (JSON) ke struct Book
	err := json.NewDecoder(r.Body).Decode(&book)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Insert data buku baru ke database
	result, err := db.Exec("INSERT INTO books (title, author, isbn) VALUES (?, ?, ?)", book.Title, book.Author, book.ISBN)
	if err != nil {
		http.Error(w, fmt.Sprintf("Gagal menambahkan buku: %v", err), http.StatusInternalServerError)
		return
	}

	id, _ := result.LastInsertId() // Ambil ID buku yang baru saja di-insert
	book.ID = int(id) // Update ID buku di struct

	w.WriteHeader(http.StatusCreated) // Set status code ke 201 Created
	json.NewEncoder(w).Encode(book) // Encode buku yang baru dibuat dan kirim
}

d. Update Book (UPDATE)

Handler ini akan memperbarui data buku yang sudah ada.


// updateBook memperbarui data buku yang sudah ada
func updateBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)

	id, err := strconv.Atoi(params["id"]) // Ambil ID buku dari URL
	if err != nil {
		http.Error(w, "ID buku tidak valid", http.StatusBadRequest)
		return
	}

	var book Book
	// Decode body request ke struct Book
	err = json.NewDecoder(r.Body).Decode(&book)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	book.ID = id // Pastikan ID buku yang diupdate sesuai dengan ID di URL

	// Update data buku di database
	result, err := db.Exec("UPDATE books SET title = ?, author = ?, isbn = ? WHERE id = ?", book.Title, book.Author, book.ISBN, book.ID)
	if err != nil {
		http.Error(w, fmt.Sprintf("Gagal memperbarui buku: %v", err), http.StatusInternalServerError)
		return
	}

	rowsAffected, _ := result.RowsAffected() // Cek berapa baris yang terpengaruh
	if rowsAffected == 0 { // Jika tidak ada baris yang terpengaruh, berarti buku tidak ditemukan
		http.Error(w, "Buku tidak ditemukan", http.StatusNotFound)
		return
	}

	json.NewEncoder(w).Encode(book) // Encode buku yang sudah diupdate dan kirim
}

e. Delete Book (DELETE)

Handler ini akan menghapus buku dari database.


// deleteBook menghapus buku dari database
func deleteBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)

	id, err := strconv.Atoi(params["id"]) // Ambil ID buku dari URL
	if err != nil {
		http.Error(w, "ID buku tidak valid", http.StatusBadRequest)
		return
	}

	// Hapus buku dari database berdasarkan ID
	result, err := db.Exec("DELETE FROM books WHERE id = ?", id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	rowsAffected, _ := result.RowsAffected()
	if rowsAffected == 0 { // Jika tidak ada baris yang terpengaruh, berarti buku tidak ditemukan
		http.Error(w, "Buku tidak ditemukan", http.StatusNotFound)
		return
	}

	w.WriteHeader(http.StatusNoContent) // Set status code ke 204 No Content (berhasil dihapus tanpa body)
	// Bisa juga kirim pesan sukses: json.NewEncoder(w).Encode(map[string]string{"message": "Buku berhasil dihapus"})
}

6. Setup Router dan Jalankan Server

Terakhir, di fungsi main, kita akan memanggil initDB, setup router menggunakan Gorilla Mux, dan menjalankan server HTTP.


// main adalah entry point aplikasi kita
func main() {
	initDB() // Inisialisasi database saat aplikasi dimulai
	defer db.Close() // Pastikan koneksi database ditutup saat aplikasi berhenti

	router := mux.NewRouter() // Buat router baru dari Gorilla Mux

	// Definisikan rute-rute API dan kaitkan dengan handler masing-masing
	router.HandleFunc("/books", getBooks).Methods("GET")
	router.HandleFunc("/books/{id}", getBook).Methods("GET")
	router.HandleFunc("/books", createBook).Methods("POST")
	router.HandleFunc("/books/{id}", updateBook).Methods("PUT")
	router.HandleFunc("/books/{id}", deleteBook).Methods("DELETE")

	// Log informasi bahwa server akan dimulai
	log.Println("Server akan dimulai di port :8080")
	// Mulai server HTTP di port 8080 dengan router yang sudah kita definisikan
	log.Fatal(http.ListenAndServe(":8080", router)) // http.ListenAndServe akan blocking, program akan terus berjalan sampai dihentikan atau ada error
}

7. Jalankan Aplikasi dan Uji Coba!

Sekarang, saatnya melihat hasil kerja keras kita! Buka terminal di folder proyekmu dan jalankan:


go run main.go

Kamu akan melihat output seperti ini:


2023/10/27 10:00:00 Database dan tabel 'books' berhasil diinisialisasi!
2023/10/27 10:00:00 Server akan dimulai di port :8080

Server sudah berjalan! Sekarang kita bisa tes API-nya menggunakan curl atau Postman/Insomnia.

💡 Tip: Jika kamu menggunakan Postman atau Insomnia, buat request baru dengan URL `http://localhost:8080` dan set method serta body (untuk POST/PUT) sesuai contoh di bawah.

a. CREATE Book (POST)

Kirim request POST ke http://localhost:8080/books dengan body JSON:


curl -X POST -H "Content-Type: application/json" -d '{
    "title": "Belajar Go Lang",
    "author": "Anak Informatika",
    "isbn": "978-602-000-123-1"
}' http://localhost:8080/books

Output yang diharapkan:


{"id":1,"title":"Belajar Go Lang","author":"Anak Informatika","isbn":"978-602-000-123-1"}

Ulangi beberapa kali dengan data berbeda.

b. GET All Books (GET)

Kirim request GET ke http://localhost:8080/books:


curl http://localhost:8080/books

Output yang diharapkan:


[{"id":1,"title":"Belajar Go Lang","author":"Anak Informatika","isbn":"978-602-000-123-1"},{"id":2,"title":"Mastering API Golang","author":"Dev Pro","isbn":"978-602-000-456-7"}]

c. GET Single Book (GET)

Kirim request GET ke http://localhost:8080/books/1 (ganti 1 dengan ID buku yang ada):


curl http://localhost:8080/books/1

Output yang diharapkan:


{"id":1,"title":"Belajar Go Lang","author":"Anak Informatika","isbn":"978-602-000-123-1"}

d. UPDATE Book (PUT)

Kirim request PUT ke http://localhost:8080/books/1 dengan body JSON yang diubah:


curl -X PUT -H "Content-Type: application/json" -d '{
    "title": "Belajar Go Lang Edisi Revisi",
    "author": "Anak Informatika Tim",
    "isbn": "978-602-000-123-1"
}' http://localhost:8080/books/1

Output yang diharapkan:


{"id":1,"title":"Belajar Go Lang Edisi Revisi","author":"Anak Informatika Tim","isbn":"978-602-000-123-1"}

e. DELETE Book (DELETE)

Kirim request DELETE ke http://localhost:8080/books/1:


curl -X DELETE http://localhost:8080/books/1

Output yang diharapkan (kosong, karena status 204 No Content):


(tidak ada output, tapi jika GET /books/1 lagi akan 404)

Selamat! Kamu sudah berhasil membuat API CRUD lengkap menggunakan Golang hanya dalam waktu singkat. Ini bisa langsung kamu gunakan sebagai backend dasar untuk aplikasi Android atau iOS-mu!

Best Practices & Tips untuk Proyek Lebih Lanjut

Meskipun kita sudah berhasil bikin API cepat kilat, ada beberapa hal yang perlu kamu perhatikan untuk proyek yang lebih serius:

💡 Tip: Penanganan Error yang Lebih Baik

Saat ini kita hanya mengembalikan error string mentah. Untuk produksi, buatlah struktur error yang seragam (misal: JSON dengan kode error dan pesan yang jelas) agar klien (aplikasi mobile) bisa menanganinya dengan lebih baik.


// Contoh struktur error
type APIError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

func sendError(w http.ResponseWriter, code int, message string) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    json.NewEncoder(w).Encode(APIError{Code: code, Message: message})
}
// Lalu panggil: sendError(w, http.StatusNotFound, "Buku tidak ditemukan")
⚠️ Catatan Penting: Validasi Input

Di tutorial ini, kita belum melakukan validasi input (misalnya, memastikan title tidak kosong atau isbn unik). Dalam aplikasi nyata, validasi input sangat krusial untuk mencegah data yang tidak valid dan serangan keamanan.


// Contoh validasi sederhana di createBook
if book.Title == "" || book.Author == "" || book.ISBN == "" {
    http.Error(w, "Semua field (title, author, isbn) harus diisi", http.StatusBadRequest)
    return
}
// Untuk validasi lebih kompleks, bisa pakai library seperti 'go-playground/validator'
  1. Lingkungan Produksi: Untuk aplikasi produksi, gunakan database yang lebih robust seperti PostgreSQL atau MySQL. Koneksi database juga harus menggunakan connection pool.
  2. Autentikasi & Otorisasi: API yang kita buat sekarang "terbuka" untuk siapa saja. Untuk aplikasi nyata, kamu perlu menambahkan mekanisme autentikasi (misal: JWT) dan otorisasi untuk memastikan hanya pengguna yang berhak yang bisa mengakses atau mengubah data tertentu.
  3. Logging Terstruktur: Gunakan library logging yang lebih canggih (misal: Zap atau Logrus) daripada log bawaan Go untuk logging yang lebih terstruktur dan mudah dianalisis.
  4. Environment Variables: Jangan menyimpan kredensial database langsung di kode. Gunakan environment variables atau file konfigurasi terpisah.
  5. Migrasi Database: Untuk mengelola perubahan skema database, gunakan tools migrasi (misal: Goose atau Migrate) daripada manual CREATE TABLE IF NOT EXISTS.
  6. Organisasi Kode: Untuk proyek yang lebih besar, pisahkan kode ke dalam file dan package yang berbeda (misal: models, handlers, database, routes).
  7. Pengujian (Testing): Selalu tulis unit test dan integration test untuk API kamu. Golang punya fitur testing bawaan yang sangat baik.

Kesimpulan dan Sampai Jumpa di Tutorial Berikutnya!

Wow! Kita sudah berhasil menyelesaikan Tutorial Golang: Bikin API CRUD dalam 15 Menit untuk Aplikasi Android/iOS. Kamu sekarang punya dasar yang kuat untuk mulai membangun backend API menggunakan Golang yang cepat dan efisien.

Ingat, ini hanyalah permulaan. Dunia pengembangan backend itu luas dan menarik. Teruslah bereksplorasi,