Go langage et base de données MySQL : Comment diviser les autorisations des rôles de données ?

Avec le développement et la vulgarisation d'Internet, la sécurité des données et la gestion des droits sont devenues des enjeux importants auxquels les entreprises et les particuliers doivent faire face. La base de données est l'un des outils de stockage et de gestion de données les plus couramment utilisés dans les entreprises, et la division des autorisations des rôles de données est un moyen important de sécurité de la base de données et de gestion des autorisations. Cet article explique comment utiliser le langage Go combiné à la base de données MySQL pour diviser les autorisations des rôles de données.

1. Quelle est la répartition des autorisations des rôles de données ?

La division des autorisations de rôle de données fait référence à la division de différents utilisateurs en différents rôles en fonction de leurs fonctions ou identités, et à l'attribution d'autorisations d'opération spécifiques à ces rôles. Par exemple, les administrateurs système d'une entreprise peuvent avoir un contrôle total sur la base de données, tandis que les employés ordinaires ne peuvent effectuer que de simples opérations de requête et de modification, ce qui nécessite une répartition des rôles et une allocation d'autorisations pour différents utilisateurs. La division des autorisations des rôles de données peut non seulement garantir la sécurité des données, mais également améliorer l'efficacité du travail et les effets de l'utilisation des données. Il s'agit d'une tâche incontournable dans l'entreprise.

2. Utilisez le langage Go pour vous connecter à la base de données MySQL

Le langage Go est un langage de programmation simple et efficace. Sa bibliothèque standard prend en charge MySQL et les opérations de base de données MySQL peuvent être effectuées sans utiliser de bibliothèques dépendantes supplémentaires.

Les étapes pour se connecter à une base de données MySQL en utilisant le langage Go sont les suivantes :

1. Installer le pilote MySQL

En langage Go, vous devez d'abord installer le pilote MySQL. Les pilotes couramment utilisés incluent go-sql-driver et. mysql-go-driver attendez.

Prenons go-sql-driver comme exemple. Vous pouvez utiliser la commande suivante pour l'installer :

go get github.com/go-sql-driver/mysql

2. Connectez-vous à la base de données MySQL

Avant de vous connecter à la base de données MySQL, vous devez configurer les informations de connexion à la base de données, y compris adresse de la base de données, port et nom d'utilisateur, mot de passe, nom de la base de données, etc. En langage Go, vous pouvez utiliser le code suivant pour vous connecter à la base de données MySQL :

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

func main() {
    db, err := sql.Open("mysql", "用户名:密码@tcp(数据库地址:端口号)/数据库名称")
    if err != nil {
        //连接失败处理
        return
    }
    defer db.Close()
}

Le code ci-dessus utilise la fonction sql.Open pour vous connecter à la base de données. Cette fonction accepte deux paramètres. "mysql"), et le deuxième paramètre Le paramètre est la chaîne de connexion ("nom d'utilisateur:mot de passe@tcp(adresse de la base de données:numéro de port)/nom de la base de données"). Une fois la configuration de la connexion terminée, la connexion à la base de données doit être fermée une fois le programme terminé.

3. Exécuter des instructions SQL

Une fois la connexion réussie, vous pouvez utiliser le langage Go pour exécuter des instructions SQL afin de faire fonctionner la base de données MySQL. Par exemple, pour interroger des données dans une base de données MySQL, vous pouvez utiliser le code suivant :

rows, err := db.Query("SELECT * FROM 表名")
if err != nil {
    //查询失败处理
    return
}
defer rows.Close()
for rows.Next() {
    var id int
    var name string
    var age int
    err := rows.Scan(&id, &name, &age)
    if err != nil {
        //数据读取失败处理
        continue
    }
    //数据处理
}

Le code ci-dessus utilise la fonction db.Query pour exécuter une instruction de requête SQL et renvoyer un ensemble de résultats. La fonction Query accepte un paramètre, qui. est l'instruction SQL à exécuter. L'ensemble de résultats de la requête doit être lu un par un, ce qui peut être réalisé à l'aide des fonctions rows.Next et rows.Scan. Les paramètres de la fonction Scan sont des pointeurs vers chaque valeur de champ dans l'ensemble de résultats. Lors de la lecture des données, vous devez faire attention au type et à l'ordre des champs. Une fois la requête terminée, le jeu de résultats doit être fermé.

3. Implémentation de la division des autorisations des rôles de données

Les étapes pour implémenter la division des autorisations des rôles de données à l'aide du langage Go et de la base de données MySQL sont les suivantes :

1. Créer une table de rôles utilisateur

Vous devez d'abord créer une table de rôles utilisateur pour stocker les utilisateurs et les informations sur les rôles. La structure de la table des rôles utilisateur est la suivante :

CREATE TABLE user_role (
    user_id INT NOT NULL,
    role_id INT NOT NULL,
    PRIMARY KEY (user_id, role_id)
);

Le code ci-dessus crée une table nommée user_role, comprenant deux champs : user_id et role_id, qui représentent l'ID utilisateur et l'ID de rôle. Puisqu'un utilisateur peut avoir plusieurs rôles, il existe une relation plusieurs-à-plusieurs dans la table user_role, utilisant (user_id, role_id) comme clé primaire composite.

2. Créer une table d'autorisations de rôle

Ensuite, vous devez créer une table d'autorisations de rôle pour stocker les informations sur les rôles et les autorisations. La structure de la table d'autorisation de rôle est la suivante :

CREATE TABLE role_permission (
    role_id INT NOT NULL,
    permission_id INT NOT NULL,
    PRIMARY KEY (role_id, permission_id)
);

Le code ci-dessus crée une table nommée role_permission, comprenant deux champs : role_id et permission_id, qui représentent l'ID de rôle et l'ID d'autorisation. Utilisez également (role_id, permission_id) comme clé primaire composite.

3. Attribuer des rôles et des autorisations aux utilisateurs

Lorsqu'un utilisateur enregistre ou modifie des informations personnelles, le programme doit enregistrer les informations d'ID utilisateur et d'ID de rôle dans la table user_role. L'exemple de code est le suivant :

func assignRole(user_id, role_id int) error {
    db, err := sql.Open("mysql", "用户名:密码@tcp(数据库地址:端口号)/数据库名称")
    if err != nil {
        return err
    }
    defer db.Close()
    //插入用户角色信息
    _, err = db.Exec("INSERT INTO user_role (user_id, role_id) VALUES (?, ?)", user_id, role_id)
    if err != nil {
        return err
    }
    return nil
}

Le code ci-dessus. utilise la fonction db.Exec Exécutez l'instruction SQL insert pour insérer la relation correspondante entre les utilisateurs et les rôles. De même, vous pouvez également utiliser la fonction db.Exec pour enregistrer la relation correspondante entre les rôles et les autorisations dans la table role_permission.

4. Vérifier les autorisations de l'utilisateur

Lorsqu'un utilisateur effectue une opération, son rôle et ses informations d'autorisation doivent être vérifiés. Par exemple, un utilisateur doté du rôle d'administrateur peut supprimer les informations utilisateur, tandis qu'un utilisateur ordinaire ne peut afficher que les informations utilisateur. Afin de réaliser cette fonction, les informations de rôle et d'autorisation doivent être utilisées dans le programme pour interroger la base de données afin de déterminer si l'utilisateur correspondant dispose des autorisations suffisantes pour fonctionner. L'exemple de code est le suivant :

func checkPermission(user_id, permission_id int) (bool, error) {
    db, err := sql.Open("mysql", "用户名:密码@tcp(数据库地址:端口号)/数据库名称")
    if err != nil {
        return false, err
    }
    defer db.Close()
    //查询用户角色
    rows, err := db.Query("SELECT role_id FROM user_role WHERE user_id=?", user_id)
    if err != nil {
        return false, err
    }
    defer rows.Close()
    role_ids := []int{}
    for rows.Next() {
        var role_id int
        err := rows.Scan(&role_id)
        if err != nil {
            return false, err
        }
        role_ids = append(role_ids, role_id)
    }
    //查询角色权限
    for _, role_id := range role_ids {
        rows, err := db.Query("SELECT COUNT(*) FROM role_permission WHERE role_id=? AND permission_id=?", role_id, permission_id)
        if err != nil {
            return false, err
        }
        defer rows.Close()
        count := 0
        for rows.Next() {
            err := rows.Scan(&count)
            if err != nil {
                return false, err
            }
        }
        //判断是否有权限
        if count > 0 {
            return true, nil
        }
    }
    return false, nil
}

Le code ci-dessus interroge la table user_role pour obtenir les informations sur le rôle auquel appartient l'utilisateur, puis interroge la table role_permission pour obtenir les informations d'autorisation appartenant au rôle, et enfin détermine si l'utilisateur a les autorisations d'exploitation correspondantes. Si l'utilisateur a l'autorisation, il renvoie vrai ; s'il ne l'a pas, il renvoie faux.

4. Résumé

En combinant le langage Go et la base de données MySQL pour réaliser la division des autorisations de rôle de données, il peut rendre les données plus sécurisées et les gérer plus efficacement. Dans le développement réel, les rôles des utilisateurs et les informations d'autorisation doivent être définis de manière flexible en fonction de différents scénarios commerciaux et exigences du programme afin d'obtenir les meilleurs effets de contrôle des autorisations et de gestion des données.

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!