Menggunakan Gin untuk Perutean

Panduan ini menunjukkan cara mengintegrasikan kerangka kerja web Gin dengan Wails v3. Gin adalah kerangka kerja web HTTP berperforma tinggi yang ditulis dalam Go dan memudahkan pembuatan aplikasi web serta API.

Pendahuluan

Wails v3 menyediakan sistem aset fleksibel yang memungkinkan Anda menggunakan handler HTTP apa pun, termasuk kerangka kerja web populer seperti Gin. Integrasi ini memungkinkan Anda untuk:

Menyajikan konten web menggunakan perutean dan middleware Gin
Membuat API RESTful yang dapat diakses dari aplikasi Wails Anda
Menggunakan fitur Gin sambil mempertahankan integrasi desktop Wails

Menyiapkan Gin dengan Wails

Untuk mengintegrasikan Gin dengan Wails, Anda perlu membuat router Gin dan mengonfigurasinya sebagai handler aset dalam aplikasi Wails Anda. Berikut panduan langkah demi langkahnya:

1. Instal Dependensi

Pertama, pastikan paket Gin telah terinstal:

bash

go get -u github.com/gin-gonic/gin

2. Buat Middleware untuk Gin

Buat fungsi middleware yang akan menangani integrasi antara Wails dan Gin:

// GinMiddleware creates a middleware that passes requests to Gin if they're not handled by Wails
func GinMiddleware(ginEngine *gin.Engine) application.Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// Let Wails handle the `/wails` route
			if strings.HasPrefix(r.URL.Path, "/wails") {
				next.ServeHTTP(w, r)
				return
			}
			// Let Gin handle everything else
			ginEngine.ServeHTTP(w, r)
		})
	}
}

Middleware ini meneruskan semua permintaan HTTP ke router Gin.

3. Konfigurasikan Router Gin Anda

Siapkan router Gin Anda dengan rute, middleware, dan handler:

// Create a new Gin router
ginEngine := gin.New() // Using New() instead of Default() to add custom middleware

// Add middlewares
ginEngine.Use(gin.Recovery())
ginEngine.Use(LoggingMiddleware()) // Your custom middleware

// Define routes
ginEngine.GET("/", func(c *gin.Context) {
    // Serve your main page
})

ginEngine.GET("/api/hello", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello from Gin API!",
        "time":    time.Now().Format(time.RFC3339),
    })
})

4. Integrasikan dengan Aplikasi Wails

Konfigurasikan aplikasi Wails Anda agar menggunakan router Gin sebagai handler asetnya:

// Create a new Wails application
app := application.New(application.Options{
    Name:        "Gin Example",
    Description: "A demo of using Gin with Wails",
    Mac: application.MacOptions{
        ApplicationShouldTerminateAfterLastWindowClosed: true,
    },
    Assets: application.AssetOptions{
        Handler:    ginEngine,
        Middleware: GinMiddleware(ginEngine),
    },
})

// Create window
app.Window.NewWithOptions(application.WebviewWindowOptions{
    Title:    "Wails + Gin Example",
    Width:    900,
    Height:   700,
    URL:      "/", // This will load the route handled by Gin
})

Menyajikan Konten Statis

Gunakan paket embed milik Go untuk menyematkan berkas statis ke dalam biner Anda:

//go:embed static
var staticFiles embed.FS

ginEngine.StaticFS("/static", http.FS(staticFiles))
ginEngine.GET("/", func(c *gin.Context) {
    file, _ := staticFiles.ReadFile("static/index.html")
    c.Data(http.StatusOK, "text/html; charset=utf-8", file)
})

Untuk pengembangan, sajikan berkas langsung dari disk menggunakan ginEngine.Static("/static", "./static").

Middleware Kustom

Gin memungkinkan Anda membuat middleware kustom untuk berbagai keperluan. Berikut contoh middleware pencatatan log:

// LoggingMiddleware is a Gin middleware that logs request details
func LoggingMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Start timer
        startTime := time.Now()

        // Process request
        c.Next()

        // Calculate latency
        latency := time.Since(startTime)

        // Log request details
        log.Printf("[GIN] %s | %s | %s | %d | %s",
            c.Request.Method,
            c.Request.URL.Path,
            c.ClientIP(),
            c.Writer.Status(),
            latency,
        )
    }
}

Menangani Permintaan API

Gin memudahkan pembuatan API RESTful. Berikut cara mendefinisikan endpoint API:

// GET endpoint
ginEngine.GET("/api/users", func(c *gin.Context) {
    c.JSON(http.StatusOK, users)
})

// POST endpoint with JSON binding
ginEngine.POST("/api/users", func(c *gin.Context) {
    var newUser User
    if err := c.ShouldBindJSON(&newUser); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    // Process the new user...
    c.JSON(http.StatusCreated, newUser)
})

// Path parameters
ginEngine.GET("/api/users/:id", func(c *gin.Context) {
    id := c.Param("id")
    // Find user by ID...
    c.JSON(http.StatusOK, user)
})

// Query parameters
ginEngine.GET("/api/search", func(c *gin.Context) {
    query := c.DefaultQuery("q", "")
    limit := c.DefaultQuery("limit", "10")
    // Perform search...
    c.JSON(http.StatusOK, results)
})

Menggunakan Fitur Wails

Konten web yang disajikan oleh Gin dapat berinteraksi dengan fitur Wails menggunakan paket @wailsio/runtime.

Menangani Peristiwa

Daftarkan handler peristiwa di Go:

app.Event.On("my-event", func(event *application.CustomEvent) {
    log.Printf("Received event: %v", event.Data)
})

Panggil dari JavaScript menggunakan runtime:

html

<script type="module">
    import { Events } from '@wailsio/runtime';

    Events.Emit("my-event", { message: "Hello from frontend" });
    Events.On("response-event", (data) => console.log(data));
</script>

Konfigurasi Lanjutan

Menyesuaikan Mode Gin

Atur Gin ke mode rilis untuk produksi:

gin.SetMode(gin.ReleaseMode)  // Use gin.DebugMode for development
ginEngine := gin.New()

Menangani WebSocket

Anda dapat mengintegrasikan WebSocket dengan Gin menggunakan pustaka seperti Gorilla WebSocket:

import "github.com/gorilla/websocket"

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        return true // Allow all connections
    },
}

// In your route handler:
ginEngine.GET("/ws", func(c *gin.Context) {
    conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()
    
    // Handle WebSocket connection...
})

Praktik Terbaik

Gunakan Paket embed Go: Sematkan berkas statis ke dalam biner Anda agar lebih mudah didistribusikan.
Pisahkan Tanggung Jawab: Pisahkan logika API dari logika antarmuka pengguna Anda.
Penanganan Kesalahan: Terapkan penanganan kesalahan yang tepat pada rute Gin dan kode frontend.
Keamanan: Perhatikan aspek keamanan, terutama saat menangani input pengguna.
Performa: Gunakan mode rilis Gin dalam produksi untuk meningkatkan performa.
Pengujian: Tulis pengujian untuk rute Gin menggunakan utilitas pengujian Gin.

Kesimpulan

Mengintegrasikan Gin dengan Wails menghasilkan kombinasi yang tangguh untuk membangun aplikasi desktop dengan teknologi web. Performa dan rangkaian fitur Gin melengkapi kemampuan integrasi desktop Wails, sehingga Anda dapat membuat aplikasi canggih yang memanfaatkan keunggulan keduanya.

Untuk informasi selengkapnya, lihat dokumentasi Gin dan dokumentasi Wails.

Aksesibilitas

Edit dokumentasi ini