Développement d'applications Web d'apprentissage Golang basé sur AbanteCart

Golang est un langage de programmation rapide, efficace et puissant doté de puissantes capacités de traitement simultané. Il est également largement utilisé dans le domaine du développement d'applications Web. Cet article présentera le développement d'applications Web de Golang basé sur AbanteCart (une plateforme de commerce électronique gratuite et open source).

1. Introduction à AbanteCart

AbanteCart est une plateforme de commerce électronique gratuite et open source qui peut aider les développeurs à créer facilement une boutique en ligne entièrement fonctionnelle. AbanteCart se caractérise par une forte évolutivité, une personnalisation facile, une facilité d'utilisation et des performances élevées.

2. Démarrez le développement de Golang

Afin de démarrer le développement de Golang, nous devons installer l'environnement Golang. Vous pouvez télécharger le programme d'installation du système d'exploitation correspondant depuis https://golang.org/dl/ pour l'installation.

Ensuite, nous utiliserons le framework web gin de Golang pour créer une application web basée sur AbanteCart.

1. Créer un projet

Nous devons d'abord créer un projet Golang. Utilisez la commande suivante :

mkdir abantecart
cd abantecart
go mod init github.com/username/abantecart

2. Introduisez les packages de dépendances requis

Créez un fichier nommé go.mod dans le répertoire racine du projet et saisissez le contenu suivant : # 🎜🎜 #

module github.com/username/abantecart
go 1.16

require (
    github.com/gin-gonic/gin v1.6.3
    github.com/go-sql-driver/mysql v1.6.0
)

Ce fichier décrit notre projet et ses dépendances. Ici, nous spécifions le framework gin et la version du pilote go-sql-driver/mysql.

Utilisez la commande suivante pour télécharger les dépendances :

go mod download

Nous sommes maintenant prêts à commencer à développer notre application Web.

3. Connectez-vous à la base de données

AbanteCart utilise la base de données MySQL pour stocker les données. Nous devons utiliser le pilote go-sql-driver/mysql pour nous connecter à la base de données :

import (
    "database/sql"
    "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }

    defer db.Close()
}

Ici, nous utilisons la fonction sql.Open pour ouvrir une connexion à la base de données MySQL. Veuillez remplacer "user", "password" et "dbname" par le nom d'utilisateur, le mot de passe et le nom de votre propre base de données MySQL.

4. Créer une route API

Afin de créer une route API, nous utiliserons le framework gin. Nous pouvons utiliser la fonction Default de gin dans la fonction principale pour créer une nouvelle route :

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

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

    defer router.Run(":8080")
}

Ici, nous utilisons la fonction gin.Default pour créer un moteur gin par défaut, puis appelons la fonction Run pour démarrer le service, le port d'écoute est 8080.

5. Gestion des requêtes API

Maintenant que nous avons créé la route API, nous pouvons commencer à traiter les requêtes des clients. Nous utiliserons la fonction GET de gin pour créer un gestionnaire de requêtes GET :

func main() {
    // ...

    router.GET("/products", func(c *gin.Context) {
        rows, err := db.Query(`
            SELECT products.product_id, products.product_name, products.product_price, products.product_quantity
            FROM abt_product_description
            INNER JOIN abt_products
            ON abt_product_description.product_id = abt_products.product_id
        `)

        var products []Product

        if err != nil {
            log.Printf("Error retrieving products from database: %v", err)
        } else {
            for rows.Next() {
                var product Product
                err := rows.Scan(&product.ID, &product.Name, &product.Price, &product.Quantity)
                
                if err != nil {
                    log.Printf("Error scanning product data: %v", err)
                    continue
                }
                
                products = append(products, product)
            }
        }

        c.JSON(http.StatusOK, gin.H{
            "products": products,
        })
    })
}

Dans ce gestionnaire de requêtes GET, nous utilisons la fonction db.Query pour récupérer les données produit de la base de données. Nous convertissons ensuite ces données en un objet Product et les ajoutons à un tableau contenant tous les produits. Enfin, nous renvoyons ce tableau au client sous forme de réponse JSON.

6. Exemple de code complet

package main

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

    "github.com/gin-gonic/gin"
    _ "github.com/go-sql-driver/mysql"
)

type Product struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Price    int    `json:"price"`
    Quantity int    `json:"quantity"`
}

func main() {
    db, err := sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }

    defer db.Close()

    router := gin.Default()

    router.GET("/products", func(c *gin.Context) {
        rows, err := db.Query(`
            SELECT products.product_id, products.product_name, products.product_price, products.product_quantity
            FROM abt_product_description
            INNER JOIN abt_products
            ON abt_product_description.product_id = abt_products.product_id
        `)

        var products []Product

        if err != nil {
            log.Printf("Error retrieving products from database: %v", err)
        } else {
            for rows.Next() {
                var product Product
                err := rows.Scan(&product.ID, &product.Name, &product.Price, &product.Quantity)

                if err != nil {
                    log.Printf("Error scanning product data: %v", err)
                    continue
                }

                products = append(products, product)
            }
        }

        c.JSON(http.StatusOK, gin.H{
            "products": products,
        })
    })

    defer router.Run(":8080")
}

7. Exécutez l'application

Utilisez la commande suivante pour démarrer l'application :

go run main.go

# 🎜 🎜#Maintenant que nous avons terminé le développement de l'application Web basée sur AbanteCart, nous pouvons la tester sur la page Web après avoir exécuté l'application.

8. Résumé

Dans cet article, nous avons présenté comment utiliser le framework Web de Golang et l'API d'AbanteCart pour développer une application Web basée sur AbanteCart. Nous avons appris à nous connecter à une base de données MySQL et à gérer les requêtes API. Espérons que notre didacticiel vous aidera à mieux comprendre le développement d’applications Web dans Golang.

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!