Bahasa Go dan pangkalan data MySQL: Bagaimana untuk membahagikan kebenaran peranan data?

Dengan pembangunan dan pempopularan Internet, keselamatan data dan pengurusan hak telah menjadi isu penting yang mesti dihadapi oleh syarikat dan individu. Pangkalan data ialah salah satu alat storan dan pengurusan data yang paling biasa digunakan dalam perusahaan, dan pembahagian kebenaran peranan data ialah cara penting dalam keselamatan pangkalan data dan pengurusan kebenaran. Artikel ini akan memperkenalkan cara menggunakan bahasa Go digabungkan dengan pangkalan data MySQL untuk membahagikan kebenaran peranan data.

1. Apakah pembahagian kebenaran peranan data?

Bahagian kebenaran peranan data merujuk kepada membahagikan pengguna yang berbeza kepada peranan yang berbeza mengikut fungsi atau identiti mereka dan memberikan kebenaran operasi khusus kepada peranan ini. Sebagai contoh, pentadbir sistem dalam perusahaan boleh mempunyai kawalan penuh ke atas pangkalan data, manakala pekerja biasa hanya boleh melakukan pertanyaan mudah dan operasi pengubahsuaian, yang memerlukan pembahagian peranan dan peruntukan kebenaran untuk pengguna yang berbeza. Pembahagian kebenaran peranan data bukan sahaja dapat memastikan keselamatan data, tetapi juga meningkatkan kecekapan kerja dan kesan penggunaan data Ia adalah tugas yang mesti ada dalam perusahaan.

2. Gunakan bahasa Go untuk menyambung ke pangkalan data MySQL

Bahasa Go ialah bahasa pengaturcaraan yang mudah dan cekap mempunyai sokongan terbina dalam untuk MySQL dan boleh digunakan tanpa menggunakan bergantung tambahan perpustakaan melaksanakan operasi pangkalan data MySQL di bawah keadaan.

Langkah-langkah untuk menyambung ke pangkalan data MySQL menggunakan bahasa Go adalah seperti berikut:

1. Pasang pemacu MySQL

Dalam bahasa Go, anda perlu pasang pemacu MySQL dahulu Pemacu yang biasa digunakan termasuk pemacu go-sql dan pemacu mysql-go.

Mengambil go-sql-driver sebagai contoh, anda boleh menggunakan arahan berikut untuk memasangnya:

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

2. Sambung ke pangkalan data MySQL

Sebelum menyambung ke pangkalan data MySQL, Anda perlu mengkonfigurasi maklumat sambungan pangkalan data terlebih dahulu, termasuk alamat pangkalan data, port, nama pengguna, kata laluan, nama pangkalan data, dll. Dalam bahasa Go, anda boleh menggunakan kod berikut untuk menyambung ke pangkalan data 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()
}

Kod di atas menggunakan fungsi sql.Open untuk menyambung ke pangkalan data Fungsi ini menerima dua parameter Nama pemacu MySQL ("mysql") , parameter kedua ialah rentetan sambungan ("nama pengguna:kata laluan@tcp(alamat pangkalan data:nombor port)/nama pangkalan data"). Selepas konfigurasi sambungan selesai, sambungan pangkalan data perlu ditutup selepas program tamat.

3. Melaksanakan pernyataan SQL

Selepas sambungan berjaya, anda boleh menggunakan bahasa Go untuk melaksanakan pernyataan SQL untuk mengendalikan pangkalan data MySQL. Contohnya, untuk menanyakan data dalam pangkalan data MySQL, anda boleh menggunakan kod berikut:

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
    }
    //数据处理
}

Kod di atas menggunakan fungsi db.Query untuk melaksanakan pernyataan pertanyaan SQL dan mengembalikan set hasil satu parameter, iaitu pernyataan SQL yang akan dilaksanakan. Set hasil pertanyaan perlu dibaca satu demi satu, yang boleh dicapai menggunakan fungsi baris.Seterusnya dan baris.Imbas. Parameter fungsi Imbasan adalah penunjuk kepada setiap nilai medan dalam set hasil Semasa membaca data, anda perlu memberi perhatian kepada jenis medan dan susunan. Selepas pertanyaan selesai, set keputusan perlu ditutup.

3. Pelaksanaan bahagian kebenaran peranan data

Langkah-langkah untuk melaksanakan bahagian kebenaran peranan data menggunakan bahasa Go dan pangkalan data MySQL adalah seperti berikut:

1. Buat peranan pengguna table

Mula-mula anda perlu mencipta jadual peranan pengguna untuk menyimpan maklumat pengguna dan peranan. Struktur jadual peranan pengguna adalah seperti berikut:

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

Kod di atas mencipta jadual bernama user_role, yang merangkumi dua medan: user_id dan role_id, mewakili ID pengguna dan ID peranan. Memandangkan pengguna mungkin mempunyai berbilang peranan, terdapat perhubungan banyak-ke-banyak dalam jadual peranan_pengguna, menggunakan (user_id, role_id) sebagai kunci utama komposit.

2. Buat jadual kebenaran peranan

Kemudian anda perlu mencipta jadual kebenaran peranan untuk menyimpan maklumat peranan dan kebenaran. Struktur jadual kebenaran peranan adalah seperti berikut:

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

Kod di atas mencipta jadual bernama role_permission, termasuk dua medan: role_id dan permission_id, yang mewakili ID peranan dan ID kebenaran. Juga gunakan (role_id, permission_id) sebagai kunci utama komposit.

3. Tetapkan peranan dan kebenaran pengguna

Apabila pengguna mendaftar atau mengubah suai maklumat peribadi, atur cara perlu menyimpan ID pengguna dan maklumat ID peranan ke jadual peranan_pengguna, sampel kod Seperti berikut:

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
}

Kod di atas menggunakan fungsi db.Exec untuk melaksanakan pernyataan sisipan SQL dan memasukkan hubungan yang sepadan antara pengguna dan peranan. Begitu juga, anda juga boleh menggunakan fungsi db.Exec untuk menyimpan hubungan yang sepadan antara peranan dan kebenaran ke dalam jadual role_permission.

4. Sahkan kebenaran pengguna

Apabila pengguna melakukan operasi, peranan dan maklumat kebenaran pengguna perlu disahkan. Sebagai contoh, pengguna dengan peranan pentadbir boleh memadam maklumat pengguna, manakala pengguna biasa hanya boleh melihat maklumat pengguna. Untuk merealisasikan fungsi ini, peranan dan maklumat kebenaran perlu digunakan dalam program untuk menanyakan pangkalan data untuk menentukan sama ada pengguna yang sepadan mempunyai kebenaran yang mencukupi untuk beroperasi. Kod sampel adalah seperti berikut:

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
}

Kod di atas menanyakan jadual pengguna_peranan untuk mendapatkan maklumat peranan yang menjadi milik pengguna, kemudian menanyakan jadual kebenaran_peranan untuk mendapatkan maklumat kebenaran yang dimiliki oleh peranan, dan akhirnya menentukan sama ada pengguna mempunyai kebenaran yang sepadan untuk beroperasi. Jika pengguna mempunyai kebenaran, ia mengembalikan benar jika tidak, ia mengembalikan palsu.

4. Ringkasan

Gabungan bahasa Go dan pangkalan data MySQL dapat merealisasikan pembahagian kebenaran peranan data, yang boleh menjadikan data lebih selamat dan pengurusan lebih berkesan. Dalam pembangunan sebenar, peranan pengguna dan maklumat kebenaran perlu ditetapkan secara fleksibel mengikut senario perniagaan dan keperluan program yang berbeza untuk mencapai kesan terbaik kawalan kebenaran dan pengurusan data.

Atas ialah kandungan terperinci Bahasa Go dan pangkalan data MySQL: Bagaimana untuk membahagikan kebenaran peranan data?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!