Golang apprend des outils communs pour le développement Web

Cet article présentera certains outils couramment utilisés pour le développement Web dans l'apprentissage Golang. Ces outils peuvent vous aider à développer et à déployer des applications Web plus efficacement.

1. Gin Framework

Gin est un framework Web rapide, flexible et minimaliste. Il fournit de nombreuses fonctions utiles, telles que le middleware, les fonctions de routage, la gestion des erreurs, etc., facilitant le développement d'applications Web. Gin adopte les fonctionnalités hautes performances du langage Go et peut être utilisé pour créer des applications Web avec une concurrence élevée et des performances élevées.

L'utilisation de Gin est très simple. Il vous suffit d'utiliser la commande go get pour l'installer, puis d'importer Gin dans le code pour commencer à l'utiliser. Par exemple :

package main

import "github.com/gin-gonic/gin"

func main() {
    router := gin.Default()
    router.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, World!",
        })
    })
    router.Run()
}

Le code ci-dessus crée un simple serveur HTTP qui répond aux requêtes GET pour le chemin racine. Le middleware et les fonctions de routage par défaut de Gin sont utilisés ici, et davantage de fonctions peuvent être personnalisées pour répondre à davantage de besoins.

2. Gorm ORM Framework

Gorm est un framework ORM léger basé sur Golang. Il fournit de nombreuses fonctions utiles, telles que la requête de base de données, la structure de table synchronisée, l'insertion, la mise à jour, la suppression, etc. Le framework peut interagir avec une variété de bases de données relationnelles, telles que MySQL, PostgreSQL, SQLite, etc.

L'utilisation de Gorm est également très simple. Il vous suffit d'utiliser la commande go get pour l'installer, puis d'importer Gorm dans le code pour commencer à l'utiliser. Par exemple :

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "log"
)

type User struct {
    gorm.Model
    Name   string
    Age    int
}

func main() {
    dsn := "user:password@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal(err)
    }

    // 自动同步表结构
    db.AutoMigrate(&User{})

    // 插入数据
    user := &User{Name: "张三", Age: 18}
    db.Create(user)

    // 查询数据
    var users []*User
    db.Find(&users)
    for _, u := range users {
        log.Println(u.Name, u.Age)
    }
}

Le code ci-dessus utilise Gorm pour faire fonctionner la base de données MySQL, définit une structure utilisateur, crée un utilisateur, interroge tous les utilisateurs et imprime le résultat. Comme vous pouvez le constater, il est très pratique d'utiliser Gorm pour développer des applications de bases de données.

3. Bibliothèque de configuration Viper

Viper est une bibliothèque Go pour la gestion de la configuration qui peut facilement gérer plusieurs sources d'entrée telles que les fichiers de configuration, les variables d'environnement et les paramètres de ligne de commande. Il prend en charge les fichiers de configuration dans plusieurs formats, tels que JSON, YAML, TOML, etc. Des formats personnalisés peuvent également être utilisés.

L'utilisation de Viper est également très simple. Il vous suffit d'utiliser la commande go get pour l'installer, puis d'importer Viper dans le code pour commencer à l'utiliser. Par exemple :

package main

import (
    "github.com/spf13/viper"
    "log"
)

type Config struct {
    AppName  string
    LogLevel string
}

func main() {
    viper.SetConfigFile("config.yaml") // 配置文件名
    viper.SetConfigType("yaml") // 配置文件类型
    viper.AddConfigPath(".") // 配置文件路径
    err := viper.ReadInConfig()
    if err != nil {
        log.Fatal(err)
    }

    config := Config{
        AppName:  viper.GetString("app.name"),
        LogLevel: viper.GetString("log.level"),
    }

    log.Println(config.AppName, config.LogLevel)
}

Le code ci-dessus utilise Viper pour lire un fichier de configuration nommé config.yaml, obtenir les attributs app.name et log.level et imprimer le résultat. Comme vous pouvez le constater, il est très pratique d'utiliser Viper pour gérer les fichiers de configuration.

4. Bibliothèque de ligne de commande Cobra

Cobra est une bibliothèque Go permettant de créer de puissantes applications CLI Avec Cobra, vous pouvez facilement définir et analyser les paramètres de ligne de commande et gérer diverses sous-commandes, options, etc. En utilisant Cobra, vous pouvez créer un meilleur outil de ligne de commande interactif pour vos applications.

L'utilisation de Cobra est également très simple. Il vous suffit d'utiliser la commande go get pour l'installer, puis d'importer Cobra dans le code pour commencer à l'utiliser. Par exemple :

package main

import (
    "fmt"
    "github.com/spf13/cobra"
)

func main() {
    var cmdPrint = &cobra.Command{
        Use:   "print",
        Short: "Print something",
        Long:  "This command print something.",
        Run: func(cmd *cobra.Command, args []string) {
            fmt.Println("Print something.")
        },
    }

    var rootCmd = &cobra.Command{Use: "app"}
    rootCmd.AddCommand(cmdPrint)

    err := rootCmd.Execute()
    if err != nil {
        fmt.Println(err)
    }
}

Le code ci-dessus utilise Cobra pour définir une sous-commande nommée print et définit certaines informations et opérations de base pour la sous-commande. Ensuite, il définit une commande racine nommée app et y ajoute la sous-commande print dans la commande racine. Comme vous pouvez le constater, il est très pratique d'utiliser Cobra pour créer des outils en ligne de commande.

5. Air Hot Loading Tool

Air est un outil de chargement à chaud Go efficace qui peut apporter des modifications au code pendant l'exécution de l'application et se recompiler et s'exécuter automatiquement. Air peut aider les développeurs à tester et déboguer le code plus facilement.

Utiliser Air est également très simple. Il vous suffit d'utiliser la commande go get pour l'installer, puis d'exécuter air dans le répertoire de l'application pour commencer à l'utiliser. Par exemple :

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Le code ci-dessus est un simple programme Hello World. Lorsque vous utilisez air pour exécuter et modifier le test, vous pouvez voir que air détectera les changements de code en temps réel et se recompilera et s'exécutera automatiquement, ce qui améliore considérablement l'efficacité du développement. .

Ce qui précède présente certains outils couramment utilisés pour le développement Web dans l'apprentissage Golang, notamment le framework Gin, le framework Gorm ORM, la bibliothèque de configuration Viper, la bibliothèque de ligne de commande Cobra et l'outil de rechargement à chaud Air. Ces outils peuvent aider les développeurs à développer et déployer des applications Web plus efficacement, améliorant ainsi l'efficacité du développement et la qualité du code.

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!