Melaksanakan redis dengan Golang

Redis ialah pangkalan data NoSQL yang popular Ia popular secara meluas kerana keupayaan membaca dan menulis berkelajuan tinggi serta keupayaan penyimpanan data ultra tinggi, dan boleh digunakan secara meluas dalam pelbagai bidang.

Golang ialah bahasa pengaturcaraan yang agak baharu dan pantas Ia juga sangat baik dalam senario konkurensi tinggi dan digunakan secara meluas dalam sistem teragih. Jadi bagaimana untuk menggunakan Golang untuk melaksanakan Redis?

Pertama sekali, kita perlu memahami prinsip pelaksanaan asas Redis. Struktur teras Redis ialah pasangan nilai kunci, dan semua operasi Redis adalah berdasarkan ini. Apabila melaksanakan Redis, kita perlu mencipta struktur untuk mewakili pasangan nilai kunci Struktur ini boleh disimpan dalam ingatan atau bersiri dan disimpan pada cakera keras.

Berikut ialah kod sampel ringkas:

type Redis struct {
    data map[string]string
}

func New() *Redis {
    return &Redis{
        data: make(map[string]string),
    }
}

func (r *Redis) Get(key string) (string, error) {
    value, ok := r.data[key]
    if !ok {
        return "", errors.New("Key not found")
    }
    return value, nil
}

func (r *Redis) Set(key string, value string) error {
    r.data[key] = value
    return nil
}

func (r *Redis) Delete(key string) error {
    delete(r.data, key)
    return nil
}

Dalam kod sampel ini, kami mencipta struktur Redis, yang mengandungi ahli data jenis peta yang boleh melaksanakan kunci Penyimpanan pasangan nilai. Fungsi Dapatkan, Tetapkan dan Padam melaksanakan operasi dapatkan, tetapkan dan padam Redis masing-masing.

Seterusnya, kami boleh menggabungkan perpustakaan rangkaian terbina dalam Golang untuk melaksanakan bahagian rangkaian Redis. Kita perlu mencipta pelayan TCP untuk Redis, menghuraikan protokol Redis ke dalam operasi, mengendalikan nilai utama dan mengembalikan hasilnya kepada klien.

Berikut ialah kod pelaksanaan mudah menggunakan modul net, bufio dan fmt:

func (r *Redis) ListenAndServe(addr string) error {
    ln, err := net.Listen("tcp", addr)
    if err != nil {
        return err
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            log.Println("Failed to accept connection:", err)
            continue
        }
        go r.serveConn(conn)
    }

    return nil
}

func (r *Redis) serveConn(conn net.Conn) {
    defer conn.Close()

    reader := bufio.NewReader(conn)
    writer := bufio.NewWriter(conn)

    for {
        // Read command
        cmdLine, _, err := reader.ReadLine()
        if err != nil {
            log.Println("Failed to read from connection:", err)
            break
        }

        // Parse command
        parts := strings.Split(string(cmdLine), " ")
        if len(parts) < 1 {
            err := fmt.Errorf("Invalid command")
            log.Println(err.Error())
            fmt.Fprintln(writer, fmt.Sprintf("%s
", err.Error()))
            writer.Flush()
            continue
        }

        var result string
        switch strings.ToLower(parts[0]) {
        case "get":
            if len(parts) != 2 {
                err := fmt.Errorf("Invalid command")
                log.Println(err.Error())
                fmt.Fprintln(writer, fmt.Sprintf("%s
", err.Error()))
                writer.Flush()
                continue
            }
            value, err := r.Get(parts[1])
            if err != nil {
                log.Println("Failed to get value for key:", parts[1], err)
                result = "$-1
"
            } else {
                result = fmt.Sprintf("$%d
%s
", len(value), value)
            }
        case "set":
            if len(parts) != 3 {
                err := fmt.Errorf("Invalid command")
                log.Println(err.Error())
                fmt.Fprintln(writer, fmt.Sprintf("%s
", err.Error()))
                writer.Flush()
                continue
            }
            err := r.Set(parts[1], parts[2])
            if err != nil {
                log.Println("Failed to set value:", err)
                result = "-ERR
"
            } else {
                result = "+OK
"
            }
        case "delete":
            if len(parts) != 2 {
                err := fmt.Errorf("Invalid command")
                log.Println(err.Error())
                fmt.Fprintln(writer, fmt.Sprintf("%s
", err.Error()))
                writer.Flush()
                continue
            }
            err := r.Delete(parts[1])
            if err != nil {
                log.Println("Failed to delete value for key:", parts[1], err)
                result = "-ERR
"
            } else {
                result = "+OK
"
            }
        default:
            err := fmt.Errorf("Invalid command")
            log.Println(err.Error())
            fmt.Fprintln(writer, fmt.Sprintf("%s
", err.Error()))
            writer.Flush()
            continue
        }

        // Write response
        fmt.Fprint(writer, result)
        writer.Flush()
    }
}

Dalam kod pelaksanaan ini, kami menggunakan fungsi ListenAndServe untuk mencipta pelayan TCP untuk mendengar mesej yang dihantar daripada klien Sambungan masuk kemudiannya digunakan untuk memproses permintaan sambungan menggunakan fungsi serveConn, yang melibatkan penghuraian protokol Redis dan operasi pasangan nilai kunci, dan akhirnya mengembalikan respons kepada klien.

Ringkasnya, menggunakan Golang untuk melaksanakan Redis boleh membolehkan kami memahami dengan lebih baik prinsip pelaksanaan Redis Pada masa yang sama, kerana ciri-ciri Golang, pelayan Redis yang cekap dan sangat serentak dapat direalisasikan.

Atas ialah kandungan terperinci Melaksanakan redis dengan Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!