Linux 系统中 Redis 的安装及其使用

本文详细介绍Redis的安装过程及如何在Go语言中使用Redis。包括设置密码、远程访问、基本命令演示,以及通过go-redis库进行连接、操作字符串、列表、散列和发布订阅等操作。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

安装及使用 redis

安装

sudo apt-get install redis-server

# 安装后, Redis 会自动启动,通过下列命令检查

ps -elf|grep redis 

netstat -nltp}grep 6379

官网

设置

  • 默认,访问 Redis 服务器不需要密码,如需要可通过如下命令设置。
sudo vi /etc/redis/redis.conf

# 取消注释 requirepass, 如下 *** 表示密码
requirepass  ***
  • 打开 Redis 服务器可被远程访问
sudo vi /etc/redis/redis.conf

# 注释 bind
# bind 127.0.0.1

# 开启可远程访问后,可以通过命令检查
netstat -nltp|grep 6379 

# 发现绑定的 ip 由 127.0.0.1 变成了 0.0.0.0
  • 修改后,重启 Redis 服务器
sudo /etc/init.d/redis-server restart
  • 若打开密码后,再次无密登录 redis-cli ,会发现可以登录,但是不能执行命令。
redis-cli -a  ***

# 远程访问 
redis-cli -a *** -h  192.168.1.199

简单使用

  • 关于命令的 API 或者使用方法,可以参见官网,见文前。
列出所有的 key 列表
> keys * 

# 之外,可以通过 help 命令,查看使用方式

Type: "help @<group>" to get a list of commands in <group>
      "help <command>" for help on <command>
      "help <tab>" to get a list of possible help topics
      "quit" to exit
  • Redis 可以存储的常用数据结构有:

    • String: 字符串
    • Hash: 散列
    • List: 列表
    • Set: 集合
    • Sorted Set: 有序集合 (zset)
  • Redis支持多个数据库,并且每个数据库的数据是隔离的不能共享,并且基于单机才有,如果是集群就没有数据库的概念。Redis是一个字典结构的存储服务器,而实际上一个Redis实例提供了多个用来存储数据的字典,客户端可以指定将数据存储在哪个字典中。这与我们熟知的在一个关系数据库实例中可以创建多个数据库类似,所以可以将其中的每个字典都理解成一个独立的数据库。每个数据库对外都是一个从0开始的递增数字命名,Redis默认支持16个数据库(可以通过配置文件支持更多,无上限),可以通过配置databases来修改这一数字。客户端与Redis建立连接后会自动选择0号数据库,不过可以随时使用SELECT命令更换数据库,如要选择1号数据库.select 1

在这里插入图片描述

Go 语言中连接 Redis 的包

两个都是非常优秀的 redisclient 库,也是redis官网上推荐,笔者选择是的是go-redis,因为go-redis封装了redis的大部分命令,不用关心 redis 的命令的细节,直接调用相应接口就行;redigo 是基于命令的,发送一个命令,然后在解析 reply。

go-redis 连接 Redis 的 Demo

// redis_test project main.go
package main

import (
    "fmt"
    "time"

    "github.com/go-redis/redis"
)

func err_handler(err error) {
    fmt.Printf("err_handler, error:%s\n", err.Error())
    panic(err.Error())
}

func standalon_redis_test() {
    fmt.Printf("standalon_redis_test")

    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })

    defer client.Close()

    pong, err := client.Ping().Result()
    if err != nil {
        fmt.Printf("ping error[%s]\n", err.Error())
        err_handler(err)
    }
    fmt.Printf("ping result: %s\n", pong)

    fmt.Printf("----------------------------------------\n")

    // set / get test
    fmt.Printf("set/get test\n")
    err = client.Set("foo", "bar", 0).Err()
    if err != nil {
        fmt.Printf("try set key[foo] to value[bar] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    err = client.Set("foo1", "bar1", time.Hour*2).Err()
    if err != nil {
        fmt.Printf("try set key[foo1] to value[bar1] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    // get value
    value, err := client.Get("foo").Result()
    if err != nil {
        fmt.Printf("try get key[foo] error[%s]\n", err.Error())
        // err_handler(err)
    }

    fmt.Printf("key[foo]'s value is %s\n", value)

    value, err = client.Get("foo1").Result()
    if err != nil {
        fmt.Printf("try get key[foo1] error[%s]\n", err.Error())
        // err_handler(err)
    }

    fmt.Printf("key[foo1]'s value is %s\n", value)

    value, err = client.Get("foo2").Result()
    if err != nil {
        fmt.Printf("try get key[foo2] error[%s]\n", err.Error())
        // err_handler(err)
    }

    fmt.Printf("key[foo2]'s value is %s\n", value)

    // get ttl
    duration, err := client.TTL("foo").Result()
    if err != nil {
        fmt.Printf("try get ttl of key[foo] error[%s]\n", err.Error())
        err_handler(err)
    }

    fmt.Printf("key[foo]' ttl is [%s] %fs\n",
        duration.String(), duration.Seconds())

    duration, err = client.TTL("foo1").Result()
    if err != nil {
        fmt.Printf("try get ttl of key[foo1] error[%s]\n", err.Error())
        err_handler(err)
    }

    fmt.Printf("key[foo1]' ttl is [%s] %ds\n",
        duration.String(), int64(duration.Seconds()))

    fmt.Printf("----------------------------------------\n")

    // list test
    fmt.Printf("list test\n")

    err = client.RPush("tqueue", "tmsg1").Err()
    if err != nil {
        fmt.Printf("rpush list[tqueue] error[%s]\n", err.Error())
        err_handler(err)
    }

    list_len, err := client.LLen("tqueue").Result()
    if err != nil {
        fmt.Printf("try get len of list[tqueue] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    fmt.Printf("len of list[tqueue] is %d\n", list_len)

    result, err := client.BLPop(time.Second*1, "tqueue").Result()
    if err != nil {
        fmt.Printf("blpop list[tqueue] error[%s]\n", err.Error())
        err_handler(err)
    }
    fmt.Printf("blpop list[tqueue], value[%s]\n", result[1])

    fmt.Printf("----------------------------------------\n")

    fmt.Printf("hmap test\n")

    err = client.HSet("tmap", "1", "f1").Err()
    if err != nil {
        fmt.Printf("try hset map[tmap] field[1] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    err = client.HSet("tmap", "2", "f2").Err()
    if err != nil {
        fmt.Printf("try hset map[tmap] field[2] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    kv_map := make(map[string]interface{})
    kv_map["3"] = "f3"
    kv_map["4"] = "f4"

    err = client.HMSet("tmap", kv_map).Err()
    if err != nil {
        fmt.Printf("try mset map[tmap] field[3] field[4] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    map_len, err := client.HLen("tmap").Result()
    if err != nil {
        fmt.Printf("try get len of map[tmap] error[%s]\n", err.Error())
        err_handler(err)
    }
    fmt.Printf("len of map[tmap] is %d\n", map_len)

    // get map value
    value, err = client.HGet("tmap", "1").Result()
    if err != nil {
        fmt.Printf("try get field[1] value of map[tmap] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    fmt.Printf("field[1] value of map[tmap] is %s\n", value)

    // hgetall
    result_kv, err := client.HGetAll("tmap").Result()
    if err != nil {
        fmt.Printf("try hgetall map[tmap] error[%s]\n", err.Error())
        err_handler(err)
    }

    for k, v := range result_kv {
        fmt.Printf("map[tmap] %s = %s\n", k, v)
    }

    fmt.Printf("----------------------------------------\n")

    fmt.Printf("pubsub test\n")

    pubsub := client.Subscribe("test_channel")

    _, err = pubsub.Receive()
    if err != nil {
        fmt.Printf("try subscribe channel[test_channel] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    // go channel to used to receive message
    ch := pubsub.Channel()

    // publish a message
    err = client.Publish("test_channel", "hello").Err()
    if err != nil {
        fmt.Printf("try publish message to channel[test_channel] error[%s]\n",
            err.Error())
        err_handler(err)
    }

    time.AfterFunc(time.Second*2, func() {
        _ = pubsub.Close()
    })

    // consume message
    for {
        msg, ok := <-ch
        if !ok {
            break
        }

        fmt.Printf("recv message[%s] from channel[%s]\n",
            msg.Payload, msg.Channel)
    }
}

func main() {
    fmt.Println("redis_test!")

    standalon_redis_test()

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

smilejiasmile

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值