Belajar Fiber - Konsep Dasar & Arsitektur Utama

#Pendahuluan

Episode 1 membahas mengapa Fiber ada. Episode 2 sekarang membongkar konsep dasar dan arsitektur utama — bagaimana Fiber bekerja di balik layar. Kalian tidak perlu menghafal kode pada episode ini; tujuan utamanya membangun model mental yang benar.

Model mental ini penting karena menentukan cara kalian memecahkan masalah nanti: mengapa value di c.Params hanya valid dalam handler, mengapa alokasi harus diminimalkan, dan mengapa hooks bisa menangani siklus hidup aplikasi. Semua pertanyaan tersebut bersumber dari arsitektur yang akan kita bedah sekarang.

#Alur Request di Balik Layar

#Dari Socket ke Handler

Ketika sebuah request masuk, jalur yang dilaluinya sangat pendek. Fasthttp menerima koneksi, membuat fasthttp.RequestCtx, lalu menyerahkannya ke handler yang dihasilkan fiber.App lewat app.Handler(). Di sinilah router Fiber bekerja: mencocokkan path dan method ke rangkaian handler.

client → fasthttp server → fiber.App → router stack → middleware → handler → response
                                 ↓
                    fiber.Ctx membungkus fasthttp.RequestCtx

Konsekuensi penting: fiber.Ctx bukan alokasi baru per request yang mahal. Fiber mengambilnya dari pool, mengisinya ulang, dan mengembalikannya ke pool setelah request selesai. Inilah sumber kecepatan Fiber.

#Buffer yang Di-Reuse

Karena buffer fasthttp di-reuse, string dan byte yang diperoleh dari request hanya valid selama handler berjalan. Jika kalian menyimpan c.Params("id") ke variabel global, nilainya bisa berubah oleh request lain. Untuk menyimpan data lintas request, kalian harus menyalinnya — pola ini kita gunakan lagi di episode 12 dan 19.

#Komponen Utama Fiber

#App, Router, dan Ctx

• App: instance fiber.App yang menyimpan config, router, dan hooks. Dibuat dengan fiber.New().
• Router: struktur data yang memetakan method dan path ke daftar handler, termasuk group, mount, dan domain.
• Ctx: interface fiber.Ctx yang membungkus fasthttp.RequestCtx dan menyediakan helper request, respons, cookie, dan locals.
• Handler: fungsi func(fiber.Ctx) error yang menjadi unit eksekusi terkecil di Fiber.

#Middleware, Hooks, Binding, dan Error Handler

• Middleware: handler yang dipanggil sebelum handler tujuan, didaftarkan lewat app.Use.
• Hooks: panggilan balik pada momen siklus hidup, seperti saat listen dimulai atau sebelum shutdown.
• Binding dan Extractors: mekanisme v3 untuk memetakan body, query, header, dan URI ke struct, serta mengekstrak nilai dengan fallback.
• Default Error Handler: penangan error bawaan yang mengubah error menjadi respons HTTP.

#fiber.Ctx: Jantung Setiap Handler

#Jembatan ke Fasthttp

Semua interaksi request dan respons terjadi lewat fiber.Ctx. Di balik layar, ia menyimpan pointer ke fasthttp.RequestCtx yang bisa diakses lewat c.RequestCtx(). Beberapa metode yang paling sering dipakai:

func handler(c fiber.Ctx) error {
    name := c.Params("name")
    age := c.Query("age", "0")
    body := c.Body()
    c.Locals("request_id", "abc-123")
 
    return c.JSON(fiber.Map{
        "name": name,
        "age":  age,
        "body": string(body),
    })
}

c.Params("name") mengambil nilai path parameter, c.Query("age", "0") membaca query parameter dengan default, dan c.Body() mengambil isi body sebagai byte. Semua nilai ini dijamin hanya valid selama handler berjalan karena berasal dari buffer yang di-reuse.

#Melihat Struktur Route

Untuk memverifikasi bagaimana router menyimpan rute, Fiber menyediakan app.Stack():

routes, err := json.MarshalIndent(app.Stack(), "", "  ")
if err != nil {
    log.Fatal(err)
}
log.Println(string(routes))

app.Stack() mengembalikan slice per method HTTP, masing-masing berisi path dan nama parameter. Memahami output ini sangat membantu saat memecahkan konflik route di episode 19.

#Alokasi Minimal dan Zero-Copy

#Prinsip Desain

Fiber mengambil prinsip minimal allocation: sebisa mungkin tidak membuat object baru per request. Struct binding di-reuse, buffer fasthttp dikelola sync.Pool, dan string tidak disalin kecuali diperlukan. Hasilnya terlihat dari go test -benchmem — topik yang akan kita eksplorasi di episode 17.

go test -bench=. -benchmem -benchtime=1s

Output kolom B/op dan allocs/op memperlihatkan byte dan jumlah alokasi per operasi. go test -bench=. -benchmem -benchtime=1s akan menjadi senjata utama kita saat mengukur performa di episode 17 dan 19.

#Konsekuensi Praktis

Karena prinsip zero-copy, ada aturan yang harus diingat: jika ingin menyimpan nilai dari request untuk dipakai setelah handler selesai, gunakan c.App().GetString(...) atau strings.Clone. Fiber menyediakan helper GetString dan GetBytes khusus untuk kasus ini ketika Immutable diaktifkan. Rinciannya kita bahas saat membahas context dan concurrency.

#Penutup

Inti yang harus dibawa pulang:

• fiber.App dibangun di atas fasthttp, bukan net/http.
• fiber.Ctx membungkus fasthttp.RequestCtx dan hanya valid dalam handler.
• Komponen inti: App, Router, Ctx, Handler, Middleware, Hooks, Binding, dan default error handler.
• Buffer fasthttp di-reuse, jadi data request harus disalin jika ingin disimpan.
• app.Stack() membantu melihat struktur route; go test -benchmem mengukur alokasi.

Di episode 3 selanjutnya kita membangun setup dan hello world pertama — menginstall Fiber v3, membuat instance App, menambahkan middleware default Logger dan Recover, lalu mengembalikan respons JSON dan teks dengan status code yang benar. Saatnya kode pertama kalian.