Bina blog dengan golang

Dalam beberapa tahun kebelakangan ini, Golang (bahasa Go) secara beransur-ansur menjadi bahasa yang popular untuk pembangunan Internet kerana kelajuan larian yang cekap dan sintaks yang mudah Sebagai aplikasi Internet yang sangat popular, blog juga telah menunjukkan sepenuhnya kelebihan Golang. Dalam artikel ini, kami akan memperkenalkan cara menggunakan Golang untuk membina blog yang mudah.

Langkah 1: Pasang Golang
Mula-mula, kita perlu memasang persekitaran Golang secara setempat. Anda boleh memuat turun versi terkini Golang dengan melawati laman web rasmi dan memasangnya mengikut arahan di laman web rasmi Saya tidak akan pergi ke butiran di sini. Selepas pemasangan selesai, kita perlu mengkonfigurasi pembolehubah persekitaran GOPATH.

Langkah 2: Pasang Gin
Untuk membina blog dengan lebih mudah, kita perlu menggunakan Gin, rangka kerja web yang ringan. Anda boleh menggunakan arahan berikut dalam terminal untuk memasang:
go get -u github.com/gin-gonic/gin
Selepas pemasangan selesai, kami perlu memperkenalkannya ke dalam projek kami.

Langkah 3: Reka bentuk pangkalan data
Seterusnya, kita perlu mereka bentuk pangkalan data untuk menyimpan kandungan blog kita. Kita boleh menggunakan pangkalan data hubungan seperti MySQL atau PostgreSQL, tetapi di sini kita memilih untuk menggunakan SQLite. Sebab untuk menggunakan SQLite ialah ia kecil dan mudah digunakan, dan tidak memerlukan memulakan pelayan yang berasingan. Anda boleh menggunakan arahan berikut dalam terminal untuk memasang SQLite:
go get -u github.com/mattn/go-sqlite3
Selepas pemasangan selesai, kami boleh mewujudkan sambungan pangkalan data melalui kod berikut:

db, err := sql.Open("sqlite3", "./blog.db")
if err != nil {
    panic(err)
}
defer db.Close()

Kod di atas akan mula-mula panggil kaedah sql.Open() Sambung ke pangkalan data dan panggil kaedah db.Close() untuk melepaskan sumber pada penghujungnya. Anda boleh menetapkan laluan di mana fail data disimpan dengan mengubah suai parameter kedua. Di sini kami menamakan siaran jadual data blog Anda boleh menggunakan pernyataan SQL berikut untuk mencipta jadual data siaran:

CREATE TABLE posts (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title VARCHAR(64) NOT NULL,
    content TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Pernyataan SQL di atas mencipta jadual data bernama siaran, termasuk id, tajuk, kandungan, created_at dan dikemas kini_di lima medan.

Langkah 4: Laksanakan penambahan, pemadaman, pengubahsuaian dan pertanyaan
Selepas memiliki pangkalan data, kita boleh mula melaksanakan fungsi penambahan, pemadaman, pengubahsuaian dan pertanyaan. Di sini, kami boleh mereka bentuk antara muka kami berdasarkan idea RESTful API. Dalam rangka kerja Gin, kami menggunakan empat kaedah HTTP POST, GET, PUT dan DELETE untuk sepadan dengan operasi tambah, pertanyaan, kemas kini dan padam masing-masing. Berikut ialah contoh penggunaan rangka kerja Gin:

package main

import (
    "database/sql"
    "net/http"

    "github.com/gin-gonic/gin"
    _ "github.com/mattn/go-sqlite3"
)

type post struct {
    ID        int    `json:"id"`
    Title     string `json:"title"`
    Content   string `json:"content"`
    CreatedAt string `json:"created_at"`
    UpdatedAt string `json:"updated_at"`
}

func main() {
    r := gin.Default()

    db, err := sql.Open("sqlite3", "./blog.db")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    r.GET("/posts", func(c *gin.Context) {
        var p []post
        rows, err := db.Query("SELECT * FROM posts")
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        defer rows.Close()

        for rows.Next() {
            var ps post
            rows.Scan(&ps.ID, &ps.Title, &ps.Content, &ps.CreatedAt, &ps.UpdatedAt)
            p = append(p, ps)
        }
        if err := rows.Err(); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"data": p})
    })

    r.POST("/posts", func(c *gin.Context) {
        var p post
        if err := c.ShouldBindJSON(&p); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        result, err := db.Exec("INSERT INTO posts (title, content) VALUES (?, ?)", p.Title, p.Content)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        p.ID, err = result.LastInsertId()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"data": p})
    })

    r.GET("/posts/:id", func(c *gin.Context) {
        var p post

        row := db.QueryRow("SELECT * FROM posts WHERE id = ?", c.Param("id"))
        err := row.Scan(&p.ID, &p.Title, &p.Content, &p.CreatedAt, &p.UpdatedAt)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"data": p})
    })

    r.PUT("/posts/:id", func(c *gin.Context) {
        var p post
        if err := c.ShouldBindJSON(&p); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        result, err := db.Exec("UPDATE posts SET title = ?, content = ? WHERE id = ?", p.Title, p.Content, c.Param("id"))
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        p.ID, err = result.LastInsertId()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"data": p})
    })

    r.DELETE("/posts/:id", func(c *gin.Context) {
        _, err := db.Exec("DELETE FROM posts WHERE id = ?", c.Param("id"))
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"data": "Post deleted"})
    })

    r.Run(":8080")
}

Kod di atas melaksanakan empat kaedah GET, POST, PUT dan DELETE, dan alamat permintaan yang sepadan ialah /posts, /posts/:id, / posts/ :id dan /posts/:id. Antaranya, kaedah GET digunakan untuk menanyakan semua artikel, kaedah POST digunakan untuk menambah artikel, kaedah GET (dengan parameter) digunakan untuk pertanyaan artikel dengan ID yang ditentukan, kaedah PUT digunakan untuk mengubah suai artikel, dan Kaedah DELETE digunakan untuk memadam artikel.

Langkah 5: Mulakan perkhidmatan
Selepas melengkapkan langkah di atas, kita boleh menggunakan arahan berikut dalam terminal untuk memulakan perkhidmatan:
go run main.go
Selepas perkhidmatan dimulakan dengan jayanya , kita boleh menggunakan pelayar Masukkan http://localhost:8080/posts untuk melihat semua artikel.

Ringkasan
Melalui langkah di atas, kami berjaya membina blog menggunakan Golang, dan menggunakan rangka kerja Gin dan pangkalan data SQLite untuk melaksanakan fungsi penambahan, pemadaman, pengubahsuaian dan pertanyaan data. Sudah tentu, ini hanyalah contoh yang sangat asas dan anda boleh memanjangkannya mengikut keperluan anda.

Atas ialah kandungan terperinci Bina blog dengan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!