Antarmuka http.Handler

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan GO di Coddy. Pelajaran 77 dari 107.

Interface http.Handler adalah dasar arsitektur server web Go. Interface ini menentukan cara permintaan HTTP diproses, dan tipe apa pun yang mengimplementasikannya dapat melayani permintaan web.

Antarmukanya sangat sederhana:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Setiap tipe yang memiliki method ServeHTTP dapat menangani permintaan HTTP. Berikut handler khusus:

type GreetHandler struct {
    Greeting string
}

func (h GreetHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "%s, visitor!", h.Greeting)
}

Kamu bisa menggunakan handler ini langsung dengan server:

handler := GreetHandler{Greeting: "Welcome"}
http.Handle("/greet", handler)

Untuk kasus yang lebih sederhana, Go menyediakan http.HandlerFunc, tipe yang memungkinkan kamu mengubah fungsi biasa menjadi handler:

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello!")
}

http.Handle("/hello", http.HandlerFunc(hello))

Kekuatan antarmuka ini terlihat jelas saat kamu menyadari bahwa handler dapat membungkus handler lain. Hal ini memungkinkan pola middleware, sehingga kamu dapat menambahkan pencatatan log, autentikasi, atau hal lain yang berlaku lintas bagian tanpa mengubah logika handler asli.

Tantangan

Mudah

Mari buat sistem handler HTTP sederhana yang menyimulasikan cara permintaan web diproses! Karena kita tidak bisa menjalankan server HTTP sungguhan di lingkungan ini, kamu akan membuat handler yang mengimplementasikan interface http.Handler dan menunjukkan cara handler tersebut memproses permintaan dengan menggunakan object permintaan/respons tiruan.

Kamu akan mengatur kodemu dalam dua file:

handlers.go: Definisikan handler HTTP kustommu.
Buat struct MockResponseWriter yang menangkap data yang akan ditulis ke respons HTTP. Struct ini harus menyimpan isi respons sebagai string dan mengimplementasikan method Write(data []byte) (int, error) yang menambahkan data ke isi respons. Tambahkan method Body() string untuk mengambil respons yang sudah terkumpul.

Buat struct MockRequest dengan field string Path dan Method untuk menyimulasikan permintaan HTTP.

Sekarang buat dua struct handler yang mengikuti pola interface http.Handler dengan method ServeHTTP yang menerima *MockResponseWriter dan *MockRequest:
- WelcomeHandler dengan field Message, menulis pesan diikuti path permintaan
- MethodHandler, menulis respons berbeda berdasarkan method permintaan: "Fetching data" untuk GET, "Creating resource" untuk POST, dan "Method not supported" untuk yang lainnya
main.go: Proses permintaan melalui handler-mu.
Baca tipe handler (welcome atau method), lalu baca detail permintaan. Untuk handler welcome, baca juga pesan sambutannya.

Buat handler yang sesuai, buat request tiruan, lalu panggil ServeHTTP untuk memprosesnya. Cetak isi respons.

Input berikut akan diberikan:

Baris 1: Tipe handler (welcome atau method)
Baris 2: Path permintaan
Baris 3: Method permintaan
Baris 4 (hanya untuk welcome): Pesan sambutan

Sebagai contoh, jika diberikan:

welcome
/home
GET
Hello from

Outputmu seharusnya:

Hello from /home

Dan jika diberikan:

method
/api/users
POST

Outputmu seharusnya:

Creating resource

Dan jika diberikan:

method
/api/data
GET

Outputmu seharusnya:

Fetching data

Dan jika diberikan:

method
/api/items
DELETE

Outputmu seharusnya:

Method not supported

Tantangan ini menunjukkan konsep inti interface http.Handler: tipe apa pun yang memiliki method ServeHTTP dapat menangani permintaan. Dalam aplikasi nyata, http.ResponseWriter dan *http.Request berasal dari standard library Go, tetapi pola implementasi handler tetap sama persis.

Coba sendiri

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Baca tipe handler
	scanner.Scan()
	handlerType := scanner.Text()
	
	// Baca path request
	scanner.Scan()
	path := scanner.Text()
	
	// Baca method request
	scanner.Scan()
	method := scanner.Text()
	
	// Buat request tiruan
	request := &MockRequest{
		Path:   path,
		Method: method,
	}
	
	// Buat penulis response tiruan
	response := &MockResponseWriter{}
	
	// TODO: Berdasarkan handlerType, buat handler yang sesuai
	// Jika handlerType adalah "welcome", baca pesan sambutan dan buat WelcomeHandler
	// Jika handlerType adalah "method", buat MethodHandler
	// Panggil ServeHTTP pada handler dengan response dan request
	
	if handlerType == "welcome" {
		scanner.Scan()
		message := scanner.Text()
		// TODO: Buat WelcomeHandler dengan pesan tersebut dan panggil ServeHTTP
		_ = message // Hapus baris ini saat mengimplementasikannya
	} else if handlerType == "method" {
		// TODO: Buat MethodHandler dan panggil ServeHTTP
	}
	
	// Cetak isi respons
	fmt.Println(response.Body())
}