Golang implémente l'enregistrement et la connexion

À l'ère d'Internet, avec les progrès continus de la technologie Internet et la demande croissante d'informations de la part des gens, les fonctions d'enregistrement et de connexion des sites Web et des applications sont devenues de plus en plus courantes. Cet article expliquera comment utiliser le langage Golang pour implémenter la fonction d'enregistrement et de connexion.

1. Introduction à golang

golang est un langage de programmation développé par Google. Il présente les caractéristiques d'un traitement simultané efficace, d'un garbage collection automatique, d'un temps de compilation extrêmement faible, etc. caractéristiques des systèmes. Ces fonctionnalités font de Golang un très excellent langage côté serveur. Par conséquent, l’utiliser pour mettre en œuvre la fonction d’enregistrement et de connexion est un très bon choix.

2. Configuration de l'environnement

Pour utiliser Golang pour implémenter la fonction d'enregistrement et de connexion, vous devez d'abord installer le langage Golang dans l'environnement local. Avant l'installation, vous devez déterminer le type de système d'exploitation de votre ordinateur (Windows, Linux, Mac, etc.) et sélectionner la version Golang correspondante à télécharger et à installer.

Une fois l'installation terminée, vous pouvez saisir la commande suivante dans la ligne de commande pour vérifier si l'installation a réussi :

go version

Si le numéro de version de Golang est affiché, l'installation est réussie.

3. Implémentation de la fonction d'enregistrement

1. Créer un dossier de projet

Créez un dossier nommé "login" pour placer les fichiers de ce projet. Créez deux dossiers dans ce dossier : contrôleur et modèle. Parmi eux, le contrôleur est utilisé pour placer le code du contrôleur de l'interface Web et le modèle est utilisé pour placer le code des opérations de base de données.

2. Connexion à la base de données et création de table

Créez un fichier nommé "db.go" dans le dossier modèle, et écrivez-y le code suivant pour établir une connexion à la base de données :

package model

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

const (
    USERNAME = "root"
    PASSWORD = ""
    NETWORK  = "tcp"
    SERVER   = "localhost"
    PORT     = 3306
    DATABASE = "login_system"
)

func DbConn() (db *sql.DB) {
    dbDriver := "mysql"
    dbUser := USERNAME
    dbPass := PASSWORD
    dbName := DATABASE
    db, err := sql.Open(dbDriver, dbUser+":"+dbPass+"@tcp("+SERVER+":"+strconv.Itoa(PORT)+")/"+dbName)
    if err != nil {
        fmt.Println("无法连接数据库：", err)
    } else {
        fmt.Println("成功连接数据库！")
    }
    return db
}

Dans le code ci-dessus, un tiers est utilisé la bibliothèque "go-sql-driver/mysql" pour réaliser la connexion à la base de données. Dans le code, nous devons également définir certaines informations de base de la base de données, telles que le nom d'utilisateur, le mot de passe, l'adresse de l'hôte, le numéro de port, le nom de la base de données, etc.

Prochaine étape, nous devons créer un fichier nommé "user.sql" pour écrire l'instruction SQL permettant de créer la table utilisateur, qui contient des champs tels que l'ID utilisateur, le nom d'utilisateur et le mot de passe.

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) NOT NULL,
  `password` varchar(40) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

En exécutant l'instruction SQL ci-dessus, la table utilisateur peut être créée dans la base de données.

3. Écrire le code du contrôleur

Créez un fichier nommé "register.go" dans le dossier du contrôleur pour écrire le code du contrôleur pour l'interface d'enregistrement. Dans ce fichier, vous devez importer la bibliothèque tierce « net/http » et écrire le code suivant :

package controller

import (
    "crypto/md5"
    "database/sql"
    "encoding/hex"
    "fmt"
    "io/ioutil"
    "net/http"
    "server/model"
)

func Register(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        username := r.FormValue("username")
        password := r.FormValue("password")
        // 密码加密
        h := md5.New()
        h.Write([]byte(password))
        password = hex.EncodeToString(h.Sum(nil))
        // 数据库操作
        db := model.DbConn()
        defer db.Close()
        stmt, err := db.Prepare("INSERT INTO user(username, password) VALUES (?, ?)")
        if err != nil {
            fmt.Println("SQL语句执行失败：", err)
            return
        }
        _, err = stmt.Exec(username, password)
        if err != nil {
            fmt.Println("用户注册失败：", err)
            return
        }
        fmt.Println("用户注册成功！")
    }
    // 返回页面内容
    data, err := ioutil.ReadFile("register.html")
    if err != nil {
        fmt.Println("读取文件失败：", err)
        return
    }
    w.Write([]byte(data))
}

Dans le code ci-dessus, nous déterminons d'abord si la méthode de requête est POST. S'il s'agit d'une requête POST, le nom d'utilisateur et le mot de passe sont obtenus, le mot de passe est crypté MD5 et le mot de passe et le nom d'utilisateur cryptés sont stockés dans la base de données.

A la fin du fichier, utilisez la fonction ioutil.ReadFile() pour lire un fichier nommé "register.html" et renvoyer le contenu du fichier au navigateur. De cette manière, le navigateur peut afficher notre interface d'inscription.

4. Écriture de l'interface d'inscription

Créez un fichier nommé "register.html" dans le dossier de connexion pour écrire le code de la page d'inscription. Dans cette page, vous devez utiliser la balise

et la balise pour obtenir les informations de nom d'utilisateur et de mot de passe, et soumettre ces informations au backend pour traitement. Le code spécifique est le suivant :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册</title>
</head>
<body>
    <form action="/register" method="post">
        <p>用户名：<input type="text" name="username" /></p>
        <p>密码：<input type="password" name="password" /></p>
        <input type="submit" value="注册" />
    </form>
</body>
</html>

Dans le code ci-dessus, l'attribut action de la balise représente l'adresse de soumission du formulaire, qui est l'adresse URL de l'interface d'inscription, et l'attribut méthode représente la soumission. méthode du formulaire, c'est-à-dire soumis à l'aide de la méthode POST.

5. Démarrez le serveur

Créez un fichier nommé "main.go" dans le dossier de connexion pour démarrer le serveur. Dans ce fichier, vous devez importer la bibliothèque tierce "net/http" et écrire le code suivant :

package main

import (
    "net/http"
    "login/controller"
)

func main() {
    // 注册接口路由
    http.HandleFunc("/register", controller.Register)
    // 启动服务器
    http.ListenAndServe(":8080", nil)
}

Dans le code ci-dessus, nous utilisons la fonction http.HandleFunc() pour spécifier l'adresse de routage pour l'interface d'enregistrement . Une fois le programme démarré, vous pouvez accéder à « http://localhost:8080/register » via le navigateur pour ouvrir l'interface d'enregistrement.

4. Implémentation de la fonction de connexion

1. Écriture du code du contrôleur

Créez un fichier nommé "login.go" dans le dossier du contrôleur pour écrire le code du contrôleur pour l'interface de connexion. Dans ce fichier, vous devez importer les bibliothèques tierces "net/http" et "database/sql" et écrire le code suivant :

package controller

import (
    "crypto/md5"
    "database/sql"
    "encoding/hex"
    "fmt"
    "io/ioutil"
    "net/http"
    "server/model"    
)

func Login(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        username := r.FormValue("username")
        password := r.FormValue("password")
        h := md5.New()
        h.Write([]byte(password))
        password = hex.EncodeToString(h.Sum(nil))
        // 根据用户名和密码查询数据库
        db := model.DbConn()
        defer db.Close()
        rows, err := db.Query("SELECT * FROM user WHERE username=? AND password=?", username, password)
        if err != nil {
            fmt.Println("SQL语句执行失败：", err)
            return
        }
        defer rows.Close()
        if rows.Next() {
            fmt.Println("登录成功！")
            // 返回登录成功页面
            data, err := ioutil.ReadFile("success.html")
            if err != nil {
                fmt.Println("读取文件失败：", err)
                return
            }
            w.Write([]byte(data))
        } else {
            fmt.Println("用户名或密码不正确！")
            // 返回登录失败页面
            data, err := ioutil.ReadFile("fail.html")
            if err != nil {
                fmt.Println("读取文件失败：", err)
                return
            }
            w.Write([]byte(data))
        }
    }
    // 返回登录页面
    data, err := ioutil.ReadFile("login.html")
    if err != nil {
        fmt.Println("读取文件失败：", err)
        return
    }
    w.Write([]byte(data))
}

Dans le code ci-dessus, nous déterminons d'abord si la méthode de requête est POST. S'il s'agit d'une requête POST, le nom d'utilisateur et le mot de passe sont obtenus, et le mot de passe est crypté avec MD5. Ensuite, nous interrogeons la base de données en fonction du nom d'utilisateur et du mot de passe. Si le résultat de la requête n'est pas vide, cela signifie que la connexion a réussi, sinon cela signifie que la connexion a échoué.

À la fin du fichier, nous lisons deux autres fichiers nommés "success.html" et "fail.html", qui sont utilisés pour représenter le contenu de la page après une connexion réussie et échouée respectivement.

2. Écriture de l'interface de connexion

Créez un fichier nommé "login.html" dans le dossier de connexion pour écrire le code de la page de connexion. Cette page est similaire à la page d'inscription. Elle doit également utiliser les balises et pour obtenir les informations de nom d'utilisateur et de mot de passe, et soumettre ces informations au backend pour traitement. Le code spécifique est le suivant :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
    <form action="/login" method="post">
        <p>用户名：<input type="text" name="username" /></p>
        <p>密码：<input type="password" name="password" /></p>
        <input type="submit" value="登录" />
    </form>
</body>
</html>

3. 成功和失败页面编写

在login文件夹中创建一个名为“success.html”的文件，用来编写登录成功后的页面代码。具体代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录成功</title>
</head>
<body>
    <h1>恭喜，登录成功！</h1>
</body>
</html>

在login文件夹中再创建一个名为“fail.html”的文件，用来编写登录失败后的页面代码。具体代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录失败</title>
</head>
<body>
    <h1>对不起，用户名或密码错误！</h1>
</body>
</html>

4. 注册接口路由修改

在“main.go”文件中，将注册接口路由的地址改为“/”即可。最终代码如下：

package main

import (
    "net/http"
    "login/controller"
)

func main() {
    // 注册接口路由
    http.HandleFunc("/", controller.Register)
    // 登录接口路由
    http.HandleFunc("/login", controller.Login)
    // 启动服务器
    http.ListenAndServe(":8080", nil)
}

五、总结

本文介绍了如何使用golang语言来实现注册登录功能。通过本文的学习，我们可以看到golang语言实现简洁高效、性能优越，适合用于实现服务器端开发。同时，本文也向读者展示了如何使用golang与数据库进行交互，以及如何使用golang实现Web接口的功能。希望本文能够为读者带来一些参考和启发。

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!