Golang Web Development

Arsitektur Web di Golang

Golang memiliki pendirian "Batteries Included" untuk pengembangan web. Package standar net/http menyediakan HTTP Server & Client kelas produksi tanpa memerlukan framework pihak ketiga.

Komponen	Peran di Go
Client (Browser/Postman)	Mengirim HTTP Request ke Server
http.Server	Mendengarkan Port TCP & menerima koneksi HTTP
http.Handler	Memproses request dan menulis HTTP Response

package main

import (
	"fmt"
	"net/http"
)

func main() {
	fmt.Println("=== NET/HTTP PACKAGE ===")
	fmt.Println("Golang memiliki Web Server bawaan yang sangat kencang di package net/http.")
	_ = http.Server{}
}

Menjalankan HTTP Server

Fungsi http.ListenAndServe("localhost:8080", handler) digunakan untuk menyalakan web server pada address tertentu.

server := http.Server{
    Addr: "localhost:8080",
    Handler: mux,
}
err := server.ListenAndServe()

package main

import (
	"fmt"
	"net/http"
)

func main() {
	server := &http.Server{
		Addr: "localhost:8080",
	}
	fmt.Println("Server siap berjalan pada address:", server.Addr)
}

Interface http.Handler

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

Kita dapat mengubah fungsi biasa menjadi `http.Handler` menggunakan adapter `http.HandlerFunc`:

var handler http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello Golang Web!")
}

package main

import (
	"fmt"
	"net/http"
)

func main() {
	var handler http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Halo Pengunjung Web Go!")
	}
	fmt.Println("HandlerFunc berhasil dikonfigurasi:", handler != nil)
}

Pengenalan http.ServeMux

http.ServeMux adalah HTTP request multiplexer bawaan Go. Mux mencocokkan URL dari setiap request yang masuk dengan daftar pola (pattern) yang didaftarkan.

mux := http.NewServeMux()
mux.HandleFunc("/", homeHandler)
mux.HandleFunc("/about", aboutHandler)

package main

import (
	"fmt"
	"net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Index Page")
	})
	mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello Page")
	})
	fmt.Println("ServeMux siap dengan 2 endpoint (/ dan /hello).")
}

Struktur *http.Request

Objek *http.Request menampung seluruh atribut request yang dikirim client:

• r.Method: "GET", "POST", "PUT", "DELETE"
• r.URL.Path: "/users/profile"
• r.Header: Map header HTTP

package main

import (
	"fmt"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "/api/users", nil)
	fmt.Println("Method:", req.Method)
	fmt.Println("Path:", req.URL.Path)
}

Package net/http/httptest

Go memiliki package khusus untuk menguji handler web secara instan:

req := httptest.NewRequest("GET", "/hello", nil)
recorder := httptest.NewRecorder()

HelloHandler(recorder, req)

res := recorder.Result()
fmt.Println("Status:", res.StatusCode)

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
)

func main() {
	handler := func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "OK Test")
	}

	req := httptest.NewRequest("GET", "/", nil)
	rec := httptest.NewRecorder()

	handler(rec, req)
	fmt.Println("Hasil Response Test Body:", rec.Body.String())
}

Membaca Query Parameter

Query parameter diambil dari `r.URL.Query()` yang mengembalikan tipe url.Values (map[string][]string):

name := r.URL.Query().Get("name") // Nilai pertama
tags := r.URL.Query()["tags"]     // Multi-values slice

package main

import (
	"fmt"
	"net/url"
)

func main() {
	u, _ := url.Parse("http://localhost:8080/search?q=golang&page=2&tags=go&tags=web")
	q := u.Query()

	fmt.Println("Keyword (q):", q.Get("q"))
	fmt.Println("Page:", q.Get("page"))
	fmt.Println("Tags (slice):", q["tags"])
}

HTTP Headers

// Membaca Header Request
contentType := r.Header.Get("Content-Type")

// Menulis Header Response (Wajib sebelum WriteHeader/Write)
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-Powered-By", "Golang")

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
)

func main() {
	handler := func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprintln(w, `{"message":"Hello JSON"}`)
	}

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/", nil)
	handler(rec, req)

	fmt.Println("Response Content-Type Header:", rec.Header().Get("Content-Type"))
}

Membaca Data POST Form

err := r.ParseForm()
firstName := r.PostFormValue("first_name")
email := r.PostForm.Get("email")

package main

import (
	"fmt"
	"net/http"
	"strings"
)

func main() {
	req, _ := http.NewRequest("POST", "/login", strings.NewReader("username=eko&password=secret123"))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	
	req.ParseForm()
	fmt.Println("Username:", req.PostFormValue("username"))
	fmt.Println("Password:", req.PostFormValue("password"))
}

HTTP Response Code

w.WriteHeader(http.StatusNotFound) // 404
fmt.Fprintln(w, "Halaman Tidak Ditemukan")

Jika w.WriteHeader() tidak dipanggil eksplisit, Go secara otomatis mengirimkan 200 OK saat pertama kali w.Write() dipanggil.

package main

import (
	"fmt"
	"net/http"
)

func main() {
	fmt.Println("Konstanta Status Code Go:")
	fmt.Println("Status OK:", http.StatusOK)
	fmt.Println("Status Bad Request:", http.StatusBadRequest)
	fmt.Println("Status Not Found:", http.StatusNotFound)
	fmt.Println("Status Internal Error:", http.StatusInternalServerError)
}

Operasi Cookie

// Menulis Cookie
cookie := &http.Cookie{
    Name: "X-User-Token",
    Value: "abc123token",
    Path: "/",
}
http.SetCookie(w, cookie)

// Membaca Cookie
cookie, err := r.Cookie("X-User-Token")

package main

import (
	"fmt"
	"net/http"
)

func main() {
	c := &http.Cookie{
		Name:  "session_id",
		Value: "xyz987654",
		Path:  "/",
	}
	fmt.Printf("Cookie Struct: %s=%s (Path: %s)
", c.Name, c.Value, c.Path)
}

Static File Server

directory := http.Dir("./static")
fileServer := http.FileServer(directory)

// Menghapus prefix URL sebelum meneruskan ke folder
mux.Handle("/static/", http.StripPrefix("/static", fileServer))

package main

import (
	"fmt"
	"net/http"
)

func main() {
	fs := http.FileServer(http.Dir("./static"))
	handler := http.StripPrefix("/assets", fs)
	fmt.Println("FileServer & StripPrefix terkonfigurasi:", handler != nil)
}

Package html/template

tmpl, err := template.ParseFiles("./templates/index.gohtml")
tmpl.Execute(w, data)

package main

import (
	"bytes"
	"fmt"
	"html/template"
)

func main() {
	text := "<h1>Selamat Datang, {{.}}!</h1>"
	tmpl, _ := template.New("index").Parse(text)

	var buf bytes.Buffer
	tmpl.Execute(&buf, "Budi Kurniawan")

	fmt.Println("Hasil Render Template:")
	fmt.Println(buf.String())
}

Mengirim Data ke Template

type PageData struct {
    Title string
    Name  string
}

tmpl.Execute(w, PageData{Title: "Home", Name: "Eko"})

Di dalam HTML Template, field diakses menggunakan tanda titik: {{.Title}} dan {{.Name}}.

package main

import (
	"bytes"
	"fmt"
	"html/template"
)

type UserProfile struct {
	Name string
	Role string
}

func main() {
	htmlTmpl := "<p>User: {{.Name}} | Role: {{.Role}}</p>"
	tmpl, _ := template.New("profile").Parse(htmlTmpl)

	var buf bytes.Buffer
	tmpl.Execute(&buf, UserProfile{Name: "Eko Khannedy", Role: "Software Engineer"})

	fmt.Println(buf.String())
}

Sintaks Template Actions

{{if .IsAdmin}}
    <p>Admin Dashboard</p>
{{else}}
    <p>User Dashboard</p>
{{end}}

{{range $index, $element := .Hobbies}}
    <li>{{$index}}: {{$element}}</li>
{{end}}

package main

import (
	"bytes"
	"fmt"
	"html/template"
)

func main() {
	src := `Hobi:
{{range .Hobbies}}
 - {{.}}
{{end}}`
	tmpl, _ := template.New("hobbies").Parse(src)

	data := map[string]interface{}{
		"Hobbies": []string{"Coding", "Gaming", "Reading"},
	}

	var buf bytes.Buffer
	tmpl.Execute(&buf, data)

	fmt.Println(buf.String())
}

Template Layout

{{define "header"}}
    <header><h1>{{.Title}}</h1></header>
{{end}}

{{define "main"}}
    {{template "header" .}}
    <main><p>Konten Utama</p></main>
{{end}}

package main

import (
	"bytes"
	"fmt"
	"html/template"
)

func main() {
	tmpl := template.New("layout")
	template.Must(tmpl.New("header").Parse("<header>Header Site</header>
"))
	template.Must(tmpl.New("body").Parse("{{template "header" .}}<main>Main Body</main>"))

	var buf bytes.Buffer
	tmpl.ExecuteTemplate(&buf, "body", nil)

	fmt.Println(buf.String())
}

Custom FuncMap

funcMap := template.FuncMap{
    "upper": strings.ToUpper,
}
tmpl := template.New("test").Funcs(funcMap)

Penggunaan di HTML: {{upper .Name}}

package main

import (
	"bytes"
	"fmt"
	"html/template"
	"strings"
)

func main() {
	funcMap := template.FuncMap{
		"upper": strings.ToUpper,
	}

	tmpl, _ := template.New("funcTest").Funcs(funcMap).Parse("Hello {{upper .}}")

	var buf bytes.Buffer
	tmpl.Execute(&buf, "kodeloka")

	fmt.Println(buf.String())
}

Template Caching

package main

import (
	"fmt"
	"html/template"
)

// Template diparse sekali pada level paket/global
var templates = template.Must(template.New("app").Parse("<h1>Cached Template</h1>"))

func main() {
	fmt.Println("Template berhasil di-cache pada startup!", templates != nil)
}

Auto Escaping Security

Jika pengguna memasukkan input mengandung script jahat <script>alert('xss')</script>, html/template otomatis mengonversinya menjadi safe entities: <script>...

Jika ingin merender HTML asli tanpa escaping (hanya dari sumber terpercaya), gunakan tipe template.HTML.

package main

import (
	"bytes"
	"fmt"
	"html/template"
)

func main() {
	userInput := "<script>alert('hack')</script>"
	tmpl, _ := template.New("xss").Parse("Input: {{.}}
")

	var buf bytes.Buffer
	tmpl.Execute(&buf, userInput)

	fmt.Println("Hasil Render Safe Escaped:")
	fmt.Println(buf.String())
}

Penggunaan http.Redirect

func LoginHandler(w http.ResponseWriter, r *http.Request) {
    // Pengalihan ke halaman /dashboard dengan status 303 See Other
    http.Redirect(w, r, "/dashboard", http.StatusSeeOther)
}

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
)

func main() {
	handler := func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, "/login", http.StatusSeeOther)
	}

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/old-path", nil)
	handler(rec, req)

	fmt.Println("Redirect Status Code:", rec.Code)
	fmt.Println("Redirect Location Header:", rec.Header().Get("Location"))
}

File Upload Handling

file, header, err := r.FormFile("avatar")
if err != nil { return }
defer file.Close()

// Simpan file ke disk
targetFile, _ := os.Create("./uploads/" + header.Filename)
io.Copy(targetFile, file)

package main

import (
	"fmt"
	"net/http"
)

func main() {
	fmt.Println("=== FILE UPLOAD HANDLER ===")
	fmt.Println("1. HTML Form: enctype="multipart/form-data"")
	fmt.Println("2. Go Handler: file, header, err := r.FormFile("fieldname")")
	fmt.Println("3. Simpan dengan io.Copy(destFile, file)")
	_ = http.Request{}
}

File Download

Untuk memaksa browser mengunduh file alih-alih mengabarkannya di layar, set header Content-Disposition:

w.Header().Set("Content-Disposition", "attachment; filename="laporan.pdf"")
http.ServeFile(w, r, "./files/laporan.pdf")

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
)

func main() {
	handler := func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Disposition", "attachment; filename="document.txt"")
		fmt.Fprintln(w, "Isi dokumen rahasia")
	}

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/download", nil)
	handler(rec, req)

	fmt.Println("Header Content-Disposition:", rec.Header().Get("Content-Disposition"))
}

Pola Middleware di Go

type Middleware func(http.Handler) http.Handler

func LogMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Log Request:", r.Method, r.URL.Path)
        next.ServeHTTP(w, r) // Lanjut ke handler berikutnya
    })
}

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
)

func SimpleLogMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Println("[LOG] Incoming Request:", r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

func main() {
	mainHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Core Handler Executed")
	})

	wrapped := SimpleLogMiddleware(mainHandler)

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/dashboard", nil)
	wrapped.ServeHTTP(rec, req)
}