blog de création de golang-Golang-php.cn

Ces dernières années, Golang (langage Go) est progressivement devenu un langage populaire pour le développement Internet en raison de sa vitesse d'exécution efficace et de sa syntaxe simple. En tant qu'application Internet très populaire, les blogs ont également pleinement démontré les avantages de Golang. Dans cet article, nous expliquerons comment utiliser Golang pour créer un blog simple.

Étape 1 : Installer Golang
Tout d’abord, nous devons installer l’environnement Golang localement. Vous pouvez télécharger la dernière version de Golang en visitant le site officiel et l'installer selon les instructions sur le site officiel. Je n'entrerai pas dans les détails ici. Une fois l'installation terminée, nous devons configurer la variable d'environnement GOPATH.

Étape 2 : Installer Gin
Afin de créer un blog plus facilement, nous devons utiliser Gin, un framework Web léger. Vous pouvez utiliser la commande suivante dans le terminal pour installer :
go get -u github.com/gin-gonic/gingo get -u github.com/gin-gonic/gin
安装完成后，我们需要将其引入我们的项目中。

步骤三：数据库设计
接下来，我们需要设计一个数据库来存储我们的博客内容。我们可以使用MySQL或PostgreSQL等关系型数据库，这里我们选择使用SQLite。使用SQLite的原因是它既小巧又易于使用，而且不需要单独启动一个服务端。你可以在终端中使用如下命令安装SQLite：
go get -u github.com/mattn/go-sqlite3
安装完成后，我们可以通过如下代码建立一个数据库连接：

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

Copier après la connexion

以上代码首先会调用sql.Open()方法连接到数据库，并在结束时调用db.Close()方法释放资源。你可以通过修改第二个参数来设置数据文件存储的路径。这里我们将博客的数据表命名为posts，可以使用以下的SQL语句创建posts数据表：

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
);

Copier après la connexion

以上SQL语句创建了一个名为posts的数据表，包含id，title，content，created_at和updated_at五个字段。

步骤四：实现增删改查
有了数据库之后，我们可以开始实现增删改查功能了。这里，我们可以根据RESTful API的思想来设计我们的接口。在Gin框架中，我们使用HTTP的四个方法POST，GET，PUT和DELETE来分别对应添加、查询、更新和删除操作。下面是一个使用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")
}

Copier après la connexion

以上代码实现了GET，POST，PUT和DELETE四个方法，并且相应的请求地址分别为/posts，/posts/:id，/posts/:id以及/posts/:id。其中，GET方法用于查询所有的文章，POST方法用于添加文章，GET方法（带参数）用于查询指定id的文章，PUT方法用于修改文章，DELETE方法用于删除文章。

步骤五：启动服务
在完成以上步骤后，我们可以在终端中使用以下命令启动服务：
go run main.goUne fois l'installation terminée, nous devons l'introduire dans notre projet.

Étape 3 : Conception de la base de données

Ensuite, nous devons concevoir une base de données pour stocker le contenu de notre blog. Nous pouvons utiliser des bases de données relationnelles telles que MySQL ou PostgreSQL, mais ici nous choisissons d'utiliser SQLite. La raison d'utiliser SQLite est qu'il est petit et facile à utiliser, et ne nécessite pas le démarrage d'un serveur séparé. Vous pouvez installer SQLite en utilisant la commande suivante dans le terminal :
go get -u github.com/mattn/go-sqlite3

Une fois l'installation terminée, nous pouvons établir une connexion à la base de données via le code suivant : 🎜rrreee🎜 Le code ci-dessus appellera d'abord la méthode sql.Open() pour se connecter à la base de données, et à la fin appellera la méthode db.Close() pour libérer des ressources. Vous pouvez définir le chemin où le fichier de données est stocké en modifiant le deuxième paramètre. Ici, nous nommons les articles de la table de données du blog. Vous pouvez utiliser l'instruction SQL suivante pour créer la table de données des articles : 🎜rrreee🎜L'instruction SQL ci-dessus crée une table de données nommée articles, comprenant l'identifiant, le titre, le contenu, les champs Create_at et Update_at. 🎜🎜Étape 4 : Implémenter l'ajout, la suppression, la modification et la requête🎜Après avoir la base de données, nous pouvons commencer à implémenter la fonction d'ajout, de suppression, de modification et de requête. Ici, nous pouvons concevoir notre interface basée sur l'idée de l'API RESTful. Dans le framework Gin, nous utilisons les quatre méthodes HTTP POST, GET, PUT et DELETE pour correspondre respectivement aux opérations d'ajout, de requête, de mise à jour et de suppression. Voici un exemple d'utilisation du framework Gin : 🎜rrreee🎜Le code ci-dessus implémente les quatre méthodes GET, POST, PUT et DELETE, et les adresses de requête correspondantes sont /posts, /posts/:id, /posts/:id et /posts/:id. Parmi eux, la méthode GET est utilisée pour interroger tous les articles, la méthode POST est utilisée pour ajouter des articles, la méthode GET (avec paramètres) est utilisée pour interroger les articles avec un ID spécifié, la méthode PUT est utilisée pour modifier les articles et la méthode PUT est utilisée pour modifier les articles. La méthode DELETE est utilisée pour supprimer des articles. 🎜🎜Étape 5 : Démarrez le service🎜Après avoir terminé les étapes ci-dessus, nous pouvons utiliser la commande suivante dans le terminal pour démarrer le service : 🎜go run main.go🎜Une fois le service démarré avec succès, nous pouvons démarrer le service dans le navigateur. Entrez http://localhost:8080/posts pour voir tous les articles. 🎜🎜Résumé🎜Grâce aux étapes ci-dessus, nous avons réussi à créer un blog en utilisant Golang et à utiliser le framework Gin et la base de données SQLite pour implémenter les fonctions d'ajout, de suppression, de modification et de requête de données. Bien entendu, il ne s’agit que d’un exemple très simple et vous pouvez l’étendre en fonction de vos besoins. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!