Golang met en œuvre le processus de révision

Avec le développement rapide d'Internet, les exigences en matière d'exactitude et de sécurité des informations sont de plus en plus élevées. Par conséquent, dans de nombreux sites Web et systèmes, il est particulièrement important de mettre en œuvre un processus de révision complet. Cet article présentera en détail comment mettre en œuvre rapidement un processus d'audit via le langage Golang.

1. Qu'est-ce que le processus d'examen ?

Le processus d'examen consiste généralement en une série de transferts de statut et d'opérations d'examen. Sa fonction principale est de garantir l'exactitude, l'exhaustivité et la légalité des informations, y compris, mais sans s'y limiter, l'examen de l'enregistrement. Revue d’articles, revue de commande, etc. La mise en œuvre d'un processus d'audit répondant aux besoins d'affaires de l'entreprise joue un rôle très important pour assurer le fonctionnement normal de l'entreprise et l'intégrité des données.

2. Introduction au langage Golang

Golang est un langage de programmation efficace, fortement typé et hautement simultané. Il dispose d'un excellent mécanisme de gestion de la mémoire qui peut garantir la stabilité et l'efficacité du programme dans des conditions de concurrence élevée. Comparé à d'autres langages de programmation, Golang est plus adapté au traitement d'une concurrence élevée et de grandes quantités de données. De plus, Golang est facile à apprendre, léger et peut être utilisé sur n’importe quelle plateforme.

3. Mise en œuvre du processus de révision

Discutons de la manière de mettre en œuvre un processus de révision basé sur le langage Golang.

1. Analyse des besoins

Avant de mettre en œuvre le processus d'examen, nous devons d'abord effectuer une analyse des besoins. Par exemple, le processus de révision des articles est le suivant :

• Révision en attente : une fois l'article soumis, il est en attente de révision.
• En cours de révision : le critique est en train de réviser l'article, mais la révision n'est pas encore terminée.
• Approuvé : le critique a examiné et publié avec succès l'article sur la chaîne officielle.
• Rejet de la révision : le réviseur échoue à la révision et l'auteur original est informé de la modification ou du refus de publication.

2. Conception de la base de données

L'étape suivante consiste à concevoir une base de données pour stocker les informations d'audit. Nous devons concevoir une table Article, comprenant les champs suivants : ID, Title, Content, CreateTime, Status, AuditID, AuditTime. Parmi eux, Status représente le statut de l'article, AuditID représente l'ID du réviseur et AuditTime représente l'heure de révision.

3. Construire un serveur

Nous devons créer un serveur HTTP pour gérer les demandes des clients. Nous pouvons utiliser le package net/http fourni par Golang pour y parvenir.

4. Conception du routage

Avant de construire le serveur HTTP, nous devons d'abord concevoir le routage. Vous pouvez utiliser des frameworks de routage tiers tels que gorilla/mux pour gérer différentes requêtes.

5. Authentification des utilisateurs

Pendant le processus d'examen, nous devons authentifier et autoriser les utilisateurs. Ceci peut être réalisé en utilisant des cadres d'authentification tiers tels que JWT.

6. Soumettre pour révision

Dans le processus de révision, l'article doit attendre sa révision après sa soumission. Nous pouvons représenter le statut de l'article via le champ Statut de la table Article.

7. Traitement des critiques

Le traitement des critiques nécessite une révision par les évaluateurs, et les articles ne peuvent être publiés qu'après avoir réussi la révision. Au cours du processus d'audit, les auditeurs doivent être certifiés, autorisés et effectuer d'autres opérations, ce qui peut être réalisé via des cadres d'authentification tiers tels que JWT.

8. Notification des résultats de la révision

Une fois la révision terminée, l'auteur original doit être informé des résultats de la révision. Les notifications peuvent être envoyées par e-mail, SMS, WeChat, etc.

4. Exemple de code du processus de révision

Ensuite, nous prendrons le processus de révision des articles comme exemple pour démontrer comment l'implémenter via le langage Golang.

1. Conception de routage

Utilisez le package gorilla/mux pour implémenter la conception de routage :

router := mux.NewRouter()
router.HandleFunc("/article/add", AddArticle)
router.HandleFunc("/article/list", GetArticles)
router.HandleFunc("/audit/list", GetAuditList)
router.HandleFunc("/audit/pass", AuditPass)
router.HandleFunc("/audit/reject", AuditReject)

2.Authentification JWT

Utilisez le package jwt-go pour implémenter l'authentification JWT :

//生成JWT Token
func createToken(user string) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user":user,
        "exp":time.Now().Add(time.Hour * 24).Unix(),
    })
    return token.SignedString([]byte("mysecret"))
}

//中间件JWT认证
func tokenMiddleware(handler http.HandlerFunc) http.HandlerFunc {
    return func(writer http.ResponseWriter, request *http.Request) {
        tokenString := request.Header.Get("Authorization")
        if tokenString == "" {
            http.Error(writer, "Token required", http.StatusUnauthorized)
            return
        }
        tokenString = strings.Replace(tokenString, "Bearer ", "", -1)
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            return []byte("mysecret"), nil
        })
        if err != nil || !token.Valid {
            http.Error(writer, "Unauthorized", http.StatusUnauthorized)
            return
        }
        handler(writer, request)
    }
}

3.Implémentation de l'interface HTTP

// 添加文章
func AddArticle(writer http.ResponseWriter, request *http.Request) {
    title := request.FormValue("title")
    content := request.FormValue("content")
    if title == "" || content == "" {
        http.Error(writer, "Invalid params", http.StatusBadRequest)
        return
    }

    // 获取当前用户
    user, ok := request.Context().Value("user").(string)
    if !ok {
        http.Error(writer, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 添加文章
    status := "wait"
    err := db.Exec("INSERT INTO articles (title, content, status, create_time, author) VALUES (?, ?, ?, ?, ?)", title, content, status, time.Now().Unix(), user).Error
    if err != nil {
        http.Error(writer, err.Error(), http.StatusBadRequest)
        return
    }

    writer.Write([]byte("success"))
}

// 获取文章列表
func GetArticles(writer http.ResponseWriter, request *http.Request) {
    // 获取当前用户
    user, ok := request.Context().Value("user").(string)
    if !ok {
        http.Error(writer, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 获取文章列表
    var articles []Article
    err := db.Where("author = ?", user).Find(&articles).Error
    if err != nil {
        http.Error(writer, err.Error(), http.StatusBadRequest)
        return
    }

    // 返回文章列表
    writer.Header().Set("Content-Type", "application/json")
    json.NewEncoder(writer).Encode(articles)
}

// 获取审核列表
func GetAuditList(writer http.ResponseWriter, request *http.Request) {
    // 获取当前用户
    user, ok := request.Context().Value("user").(string)
    if !ok {
        http.Error(writer, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 查询审核列表
    var articles []Article
    err := db.Where("status = ?", "wait").Find(&articles).Error
    if err != nil {
        http.Error(writer, err.Error(), http.StatusBadRequest)
        return
    }

    // 返回审核列表
    writer.Header().Set("Content-Type", "application/json")
    json.NewEncoder(writer).Encode(articles)
}

// 审核通过
func AuditPass(writer http.ResponseWriter, request *http.Request) {
    id := request.FormValue("id")
    if id == "" {
        http.Error(writer, "Invalid params", http.StatusBadRequest)
        return
    }

    // 获取当前用户
    user, ok := request.Context().Value("user").(string)
    if !ok {
        http.Error(writer, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 审核文章
    status := "pass"
    err := db.Exec("UPDATE articles SET status = ?, audit_id = ?, audit_time = ? WHERE id = ?", status, user, time.Now().Unix(), id).Error
    if err != nil {
        http.Error(writer, err.Error(), http.StatusBadRequest)
        return
    }

    writer.Write([]byte("success"))
}

// 审核拒绝
func AuditReject(writer http.ResponseWriter, request *http.Request) {
    id := request.FormValue("id")
    if id == "" {
        http.Error(writer, "Invalid params", http.StatusBadRequest)
        return
    }

    // 获取当前用户
    user, ok := request.Context().Value("user").(string)
    if !ok {
        http.Error(writer, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 审核文章
    status := "reject"
    err := db.Exec("UPDATE articles SET status = ?, audit_id = ?, audit_time = ? WHERE id = ?", status, user, time.Now().Unix(), id).Error
    if err != nil {
        http.Error(writer, err.Error(), http.StatusBadRequest)
        return
    }

    writer.Write([]byte("success"))
}

5. Résumé

Cet article présente comment mettre en œuvre un processus de révision basé sur la révision d'articles via le langage Golang. Lors de la mise en œuvre du processus de révision, nous avons également appris la conception du routage, l'authentification JWT, la mise en œuvre de l'interface HTTP, etc. J'espère que cet article sera utile aux lecteurs qui développent 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!