Golang redis 入门操作

最新推荐文章于 2024-10-15 15:59:01 发布
最新推荐文章于 2024-10-15 15:59:01 发布
阅读量5.4k 收藏 10
点赞数 1
分类专栏： Golang Redis 文章标签： go-redis golang redis redis集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010649766/article/details/79623972
版权

Golang redis 入门操作

安装

我使用的是 https://github.com/go-redis/redis 这个 golang 客户端, 因此安装方式如下:

go get gopkg.in/redis.v4

接着在代码中导入此包即可:

import "gopkg.in/redis.v4"

基本操作

创建客户端

通过 redis.NewClient 函数即可创建一个 redis 客户端, 这个方法接收一个 redis.Options 对象参数, 通过这个参数, 我们可以配置 redis 相关的属性, 例如 redis 服务器地址, 数据库名, 数据库密码等.
下面是一个连接的例子:

// 创建 redis 客户端
func createClient() *redis.Client {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })

    // 通过 cient.Ping() 来检查是否成功连接到了 redis 服务器
    pong, err := client.Ping().Result()
    fmt.Println( pong, err )

    return client
}

String 操作

redis 的 String 操作有:

  • set( key, value )：给数据库中名称为 key 的 string 赋予值 value
  • get( key )：返回数据库中名称为 key 的 string 的 value
  • getset( key, value )：给名称为 key 的 string 赋予上一次的 value
  • mget( key1, key2,…, key N )：返回库中多个 string 的 value
  • setnx( key, value )：添加 string，名称为 key，值为 value
  • setex( key, time, value )：向库中添加 string，设定过期时间 time
  • mset( key N, value N )：批量设置多个 string 的值
  • msetnx( key N, value N )：如果所有名称为 key 的 string 都不存在
  • incr( key )：名称为 key 的 string 增 1 操作
  • incrby( key, integer )：名称为 key 的 string 增加 integer
  • decr( key )：名称为 key 的 string 减 1 操作
  • decrby( key, integer )：名称为 key 的 string 减少 integer
  • append( key, value )：名称为 key 的 string 的值附加 value
  • substr( key, start, end )：返回名称为 key 的 string 的 value 的子串

在 go-redis 中, 我们可以直接找到对应的操作方法, 直接上代码:

// String 操作
func stringOperation( client *redis.Client ) {
    // 第三个参数是过期时间, 如果是0, 则表示没有过期时间.
    err := client.Set( "name", "xys", 0 ).Err()
    if err != nil {
        panic(err)
    }

    val, err := client.Get( "name" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "name", val )

    // 这里设置过期时间.
    err = client.Set( "age", "20", 1 * time.Second ).Err()
    if err != nil {
        panic(err)
    }

    client.Incr( "age" ) // 自增
    client.Incr( "age" ) // 自增
    client.Decr( "age" ) // 自减

    val, err = client.Get( "age" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "age", val ) // age 的值为21

    // 因为 key "age" 的过期时间是一秒钟, 因此当一秒后, 此 key 会自动被删除了.
    time.Sleep(1 * time.Second)
    val, err = client.Get( "age" ).Result()
    if err != nil {
        // 因为 key "age" 已经过期了, 因此会有一个 redis: nil 的错误.
        fmt.Printf( "error: %v\n", err )
    }
    fmt.Println( "age", val )
}

list 操作

redis 的 list 操作有:

  • rpush( key, value )：在名称为 key 的 list 尾添加一个值为 value 的元素
  • lpush( key, value )：在名称为 key 的 list 头添加一个值为 value 的元素
  • llen( key )：返回名称为 key 的 list 的长度
  • lrange( key, start, end )：返回名称为 key 的 list 中 start 至 end 之间的元素
  • ltrim( key, start, end )：截取名称为 key 的 list
  • lindex( key, index )：返回名称为 key 的 list 中 index 位置的元素
  • lset( key, index, value )：给名称为 key 的 list 中 index 位置的元素赋值
  • lrem( key, count, value )：删除 count 个 key 的 list 中值为 value 的元素
  • lpop( key )：返回并删除名称为 key 的 list 中的首元素
  • rpop( key )：返回并删除名称为 key 的 list 中的尾元素
  • blpop( key1, key2,… key N, timeout )：lpop 命令的 block 版本。
  • brpop( key1, key2,… key N, timeout )：rpop 的 block 版本。
  • rpoplpush( srckey, dstkey )：返回并删除名称为 srckey 的 list 的尾元素，并将该元素添加到名称为 dstkey 的 list 的头部

同样地, 在 go-redis 中也可以找到对应的方法, 下面是一个简单的示例:

// list 操作
func listOperation( client *redis.Client ) {
    client.RPush( "fruit", "apple" ) // 在名称为 fruit 的list尾添加一个值为value的元素
    client.LPush( "fruit", "banana" ) // 在名称为 fruit 的list头添加一个值为value的 元素
    length, err := client.LLen( "fruit" ).Result() // 返回名称为 fruit 的list的长度
    if err != nil {
        panic(err)
    }
    fmt.Println( "length: ", length ) // 长度为2

    value, err := client.LPop( "fruit" ).Result() // 返回并删除名称为 fruit 的list中的首元素
    if err != nil {
        panic(err)
    }
    fmt.Println( "fruit: ", value )

    value, err = client.RPop( "fruit" ).Result() // 返回并删除名称为 fruit 的list中的尾元素
    if err != nil {
        panic(err)
    }
    fmt.Println( "fruit: ", value )
}

set 操作

redis 的 set 操作:

  • sadd( key, member )：向名称为 key 的 set 中添加元素 member
  • srem( key, member )：删除名称为 key 的 set 中的元素 member
  • spop( key )：随机返回并删除名称为 key 的 set 中一个元素
  • smove( srckey, dstkey, member )：移到集合元素
  • scard( key )：返回名称为 key 的 set 的基数
  • sismember( key, member )：member 是否是名称为 key 的 set 的元素
  • sinter( key1, key2,…key N )：求交集
  • sinterstore( dstkey, ( keys ))`：求交集并将交集保存到 dstkey 的集合
  • sunion( key1, ( keys ))`：求并集
  • sunionstore( dstkey, ( keys ))`：求并集并将并集保存到 dstkey 的集合
  • sdiff( key1, ( keys ))`：求差集
  • sdiffstore( dstkey, ( keys ))`：求差集并将差集保存到 dstkey 的集合
  • smembers( key )：返回名称为 key 的 set 的所有元素
  • srandmember( key )：随机返回名称为 key 的 set 的一个元素

接下来是 go-redis 的 set 操作:

// set 操作
func setOperation( client *redis.Client ) {
    client.SAdd( "blacklist", "Obama" ) // 向 blacklist 中添加元素
    client.SAdd( "blacklist", "Hillary" ) // 再次添加
    client.SAdd( "blacklist", "the Elder" ) // 添加新元素

    client.SAdd( "whitelist", "the Elder" ) // 向 whitelist 添加元素

    // 判断元素是否在集合中
    isMember, err := client.SIsMember( "blacklist", "Bush" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "Is Bush in blacklist: ", isMember )


    // 求交集, 即既在黑名单中, 又在白名单中的元素
    names, err := client.SInter( "blacklist", "whitelist" ).Result()
    if err != nil {
        panic(err)
    }
    // 获取到的元素是 "the Elder"
    fmt.Println( "Inter result: ", names )


    // 获取指定集合的所有元素
    all, err := client.SMembers( "blacklist" ).Result()
    if err != nil {
        panic( err )
    }
    fmt.Println( "All member: ", all )
}

hash 操作

redis 的 hash 操作:

  • hset( key, field, value )：向名称为 key 的 hash 中添加元素 field
  • hget( key, field )：返回名称为 key 的 hash 中 field 对应的 value
  • hmget( key, ( fields ) )：返回名称为 key 的 hash 中 field 对应的 value
  • hmset( key, ( fields ) )：向名称为 key 的 hash 中添加元素 field
  • hincrby( key, field, integer )：将名称为 key 的 hash 中 field 的 value 增加 integer
  • hexists( key, field )：名称为 key 的 hash 中是否存在键为 field 的域
  • hdel( key, field )：删除名称为 key 的 hash 中键为 field 的域
  • hlen( key )：返回名称为 key 的 hash 中元素个数
  • hkeys( key )：返回名称为 key 的 hash 中所有键
  • hvals( key )：返回名称为 key 的 hash 中所有键对应的 value
  • hgetall( key )：返回名称为 key 的 hash 中所有的键（ field ）及其对应的 value

go-redis 中的 hash 操作:

// hash 操作
func hashOperation( client *redis.Client ) {
    client.HSet( "user_xys", "name", "xys" ); // 向名称为 user_xys 的 hash 中添加元素 name
    client.HSet( "user_xys", "age", "18" ); // 向名称为 user_xys 的 hash 中添加元素 age

    // 批量地向名称为 user_test 的 hash 中添加元素 name 和 age
    client.HMSet( "user_test", map[string]string{"name": "test", "age":"20"} )
    // 批量获取名为 user_test 的 hash 中的指定字段的值.
    fields, err := client.HMGet( "user_test", "name", "age" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "fields in user_test: ", fields )


    // 获取名为 user_xys 的 hash 中的字段个数
    length, err := client.HLen( "user_xys" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "field count in user_xys: ", length ) // 字段个数为2

    // 删除名为 user_test 的 age 字段
    client.HDel( "user_test", "age" )
    age, err := client.HGet("user_test", "age" ).Result()
    if err != nil {
        fmt.Printf( "Get user_test age error: %v\n", err )
    } else {
        fmt.Println( "user_test age is: ", age ) // 字段个数为2
    }
}

关于连接池

redis.v4 包实现了 redis 的连接池管理, 因此我们就不需要自己手动管理 redis 的连接了.
默认情况下, redis.v4 的 redis 连接池大小是10, 不过我们可以在初始化 redis 客户端时自行设置连接池的大小, 例如:

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

通过 redis.Options 的 PoolSize 属性, 我们设置了 redis 连接池的大小为 5.
那么接下来我们来看一下这个设置有什么效果吧:

// redis.v4 的连接池管理
func connectPool( client *redis.Client ) {
    wg := sync.WaitGroup{}
    wg.Add(10)

    for i := 0; i < 10; i++ {
        go func() {
            defer wg.Done()

            for j := 0; j < 100; j++ {
                client.Set( fmt.Sprintf( "name%d", j ), fmt.Sprintf( "xys%d", j ), 0 ).Err()
                client.Get( fmt.Sprintf( "name%d", j ) ).Result()
            }

            fmt.Printf( "PoolStats, TotalConns: %d, FreeConns: %d\n", client.PoolStats().TotalConns, client.PoolStats().FreeConns );
        }()
    }

    wg.Wait()
}

上面的例子启动了 10 个 routine 来不断向 redis 读写数据, 然后我们通过 client.PoolStats() 获取连接池的信息. 运行这个例子, 输出如下:

PoolStats, TotalConns: 5, FreeConns: 1
PoolStats, TotalConns: 5, FreeConns: 1
PoolStats, TotalConns: 5, FreeConns: 1
PoolStats, TotalConns: 5, FreeConns: 1
PoolStats, TotalConns: 5, FreeConns: 1
PoolStats, TotalConns: 5, FreeConns: 2
PoolStats, TotalConns: 5, FreeConns: 2
PoolStats, TotalConns: 5, FreeConns: 3
PoolStats, TotalConns: 5, FreeConns: 4
PoolStats, TotalConns: 5, FreeConns: 5

通过输出可以看到, 此时最大的连接池数量确实是 5 了, 并且一开始时, 因为 coroutine 的数量大于 5, 会造成 redis 连接不足的情况(反映在 FreeConns 上就是前几次的输出 FreeConns 一直是 1 ), 当某个 coroutine 结束后, 会释放此 redis 连接, 因此 FreeConns 会增加.

完整示例

package main

import (
    "fmt"
    "time"
    "sync"
    "gopkg.in/redis.v4"
)

func main() {
    client := createClient()
    defer client.Close()

    stringOperation( client )
    listOperation( client )
    setOperation( client )
    hashOperation( client )

    connectPool( client )

}

// 创建 redis 客户端
func createClient() *redis.Client {
    client := redis.NewClient( &redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
        PoolSize: 5,
    } )

    pong, err := client.Ping().Result()
    fmt.Println( pong, err )

    return client
}


// String 操作
func stringOperation( client *redis.Client ) {
    // 第三个参数是过期时间, 如果是 0, 则表示没有过期时间.
    err := client.Set( "name", "xys", 0 ).Err()
    if err != nil {
        panic( err )
    }

    val, err := client.Get( "name" ).Result()
    if err != nil {
        panic( err )
    }
    fmt.Println( "name", val )


    // 这里设置过期时间.
    err = client.Set( "age", "20", 1 * time.Second ).Err()
    if err != nil {
        panic( err )
    }

    client.Incr( "age" ) // 自增
    client.Incr( "age" ) // 自增
    client.Decr( "age" ) // 自减

    val, err = client.Get( "age" ).Result()
    if err != nil {
        panic( err )
    }
    fmt.Println( "age", val ) // age 的值为21

    // 因为 key "age" 的过期时间是一秒钟, 因此当一秒后, 此 key 会自动被删除了.
    time.Sleep( 1 * time.Second )
    val, err = client.Get( "age" ).Result()
    if err != nil {
        // 因为 key "age" 已经过期了, 因此会有一个 redis: nil 的错误.
        fmt.Printf( "error: %v\n", err )
    }
    fmt.Println( "age", val )
}

// list 操作
func listOperation( client *redis.Client ) {
    client.RPush( "fruit", "apple" ) // 在名称为 fruit 的list尾添加一个值为value的元素
    client.LPush( "fruit", "banana" ) // 在名称为 fruit 的list头添加一个值为value的 元素
    length, err := client.LLen( "fruit" ).Result() // 返回名称为 fruit 的list的长度
    if err != nil {
        panic( err )
    }
    fmt.Println( "length: ", length ) // 长度为2

    value, err := client.LPop( "fruit" ).Result() //返回并删除名称为 fruit 的list中的首元素
    if err != nil {
        panic(err)
    }
    fmt.Println( "fruit: ", value )

    value, err = client.RPop( "fruit" ).Result() // 返回并删除名称为 fruit 的list中的尾元素
    if err != nil {
        panic(err)
    }
    fmt.Println( "fruit: ", value )
}

// set 操作
func setOperation( client *redis.Client ) {
    client.SAdd( "blacklist", "Obama" ) // 向 blacklist 中添加元素
    client.SAdd( "blacklist", "Hillary" ) // 再次添加
    client.SAdd( "blacklist", "the Elder" ) // 添加新元素

    client.SAdd( "whitelist", "the Elder" ) // 向 whitelist 添加元素

    // 判断元素是否在集合中
    isMember, err := client.SIsMember( "blacklist", "Bush" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "Is Bush in blacklist: ", isMember )


    // 求交集, 即既在黑名单中, 又在白名单中的元素
    names, err := client.SInter( "blacklist", "whitelist" ).Result()
    if err != nil {
        panic(err)
    }
    // 获取到的元素是 "the Elder"
    fmt.Println( "Inter result: ", names )


    // 获取指定集合的所有元素
    all, err := client.SMembers( "blacklist" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "All member: ", all )
}

// hash 操作
func hashOperation( client *redis.Client ) {
    client.HSet( "user_xys", "name", "xys" ); // 向名称为 user_xys 的 hash 中添加元素 name
    client.HSet( "user_xys", "age", "18" ); // 向名称为 user_xys 的 hash 中添加元素 age

    // 批量地向名称为 user_test 的 hash 中添加元素 name 和 age
    client.HMSet( "user_test", map[string]string{"name": "test", "age":"20"} )
    // 批量获取名为 user_test 的 hash 中的指定字段的值.
    fields, err := client.HMGet( "user_test", "name", "age" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "fields in user_test: ", fields )

    // 获取名为 user_xys 的 hash 中的字段个数
    length, err := client.HLen( "user_xys" ).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println( "field count in user_xys: ", length ) // 字段个数为2

    // 删除名为 user_test 的 age 字段
    client.HDel( "user_test", "age" )
    age, err := client.HGet( "user_test", "age" ).Result()
    if err != nil {
        fmt.Printf( "Get user_test age error: %v\n", err )
    } else {
        fmt.Println( "user_test age is: ", age ) // 字段个数为2
    }
}

// redis.v4 的连接池管理
func connectPool( client *redis.Client ) {
    wg := sync.WaitGroup{}
    wg.Add( 10 )

    for i := 0; i < 10; i++ {
        go func() {
            defer wg.Done()

            for j := 0; j < 100; j++ {
                client.Set( fmt.Sprintf( "name%d", j ), fmt.Sprintf( "xys%d", j ), 0 ).Err()
                client.Get( fmt.Sprintf( "name%d", j ) ).Result()
            }

            fmt.Printf( "PoolStats, TotalConns: %d, FreeConns: %d\n", client.PoolStats().TotalConns, client.PoolStats().FreeConns );
        }()
    }

    wg.Wait()
}

参考文章：
https://segmentfault.com/a/1190000007078961
https://godoc.org/github.com/go-redis/redis#example-NewClusterClient

独一无二的小个性
关注
专栏目录
GO语言操作redis
m0_56137272的博客
04-30 7497
本文仅仅简单介绍了如何使用go语言操作redis，分别展示了两种客户端包如何实现对redis的访问和操作，并展示了redis的部分指令，而redis提供的指令远不止这些。写博客的过程中，个人还是感觉Redigo使用起来更加易懂，而go-redis支持连接哨兵和集群模式的redis，还是要根据情况选择使用。
redis golang使用入门
小二黑嘿嘿的博客
04-10 702
本篇文章和大家分享下golang如何使用redis，包括redis的连接，及redis五种常用数据结构的key-value设定。 redis客户端使用依赖包为：github.com/garyburd/redigo/redis 一：redis服务端连接及字符串类型数据结构key-value值设定 字符串数据结构的key-value设定，通用命令为 set key value [EX seconds]...
Golang操作Redis，基本操作
mrtwenty的博客
06-24 1659
Golang操作Redis，先下载一个第三方的包: go get github.com/garyburd/redigo/redis Redis安装就不必介绍了，我们直接看代码，代码演示基本命令，包括连接，密码认证AUTH、设置key、删除key、测试连接PING、设置过期时间、判断键是否存在，获取键的类型。 package main import ( "fmt" "github...
Go语言操作redis详解(超详细)
最新发布
Soul丶君的博客
10-15 1408
目录。
Golang 操作 Redis
qq_39297673的博客
09-03 92
Go 通过链接池来操作 Redis package main import ( "fmt" "github.com/garyburd/redigo/redis" //定义一个全局的pool （链接池) var pool *redis.Pool //当启动程序时，就初始化链接池 func init(){ pool = &redis.Pool{ MaxIdle:8, //最大空闲链接数 MaxActive:0, //表示和数据库的最大链接数.
go 操作 redis
go|Python的个人博客
08-11 2372
文档地址：https://pkg.go.dev/github.com/go-redis/redis。安装：go get github.com/garyburd/redigo/redis。安装：go get -u github.com/go-redis/redis。go-redis：star数更多，支持连接哨兵及集群模式的Redis。补充: go-redis 的连接池配置直接在。redigo：star数少一些，操作更简单。golang操作redis主要有两个库，，默认是采用连接池链接。中配置参数即可,并且。.
Golang使用Redis
懒人程序员的博客
04-12 323
go使用Redis 文档链接：https://godoc.org/github.com/go-redis/redis import ( "fmt" "github.com/go-redis/redis" ) var ClientRedis *redis.Client const ( REDIS_NETWORK = "tcp" REDIS_HOST = "" REDIS_PORT ...
Golang redis(一)redigo安装及简单示例
comprel的博客
07-14 3804
go 使用redis go操作redis， 拥有很多第三方包， 官方推荐使用radix 和redigo 这里选用redigo 注意redigo已经迁移 打开githup ：https://github.com/garyburd/redigo 提示如下： 项目已经迁移到了https://github.com/gomodule/redigo 因此， 我们使用最新的gomodule下的版本，不使用...
Go语言从入门到精通九——使用golang操作mysql、redis和RabbitMQ
Dev-L的博客
03-03 699
操作mysql 增 package main import ( &amp;quot;fmt&amp;quot; &amp;quot;github.com/jmoiron/sqlx&amp;quot; _ &amp;quot;github.com/go-sql-driver/mysql&amp;quot; //初始化一个mysql驱动，必须 ) type Person struct { UserId int `db:&
Golang快速入门
起岸星辰
04-12 1098
Golang基础学习笔记整理，快速了解Golang的基础语法。 学习资料 超全golang面试题合集+golang学习指南+golang知识图谱+入门成长路线 ;一份涵盖大部分golang程序员所需要掌握的核心知识. 韩顺平的golang视频教程 ，视频在B站上，最好倍速播放。 go语言环境配置 Go 包网站 golang.com.cn是中文版本的 Go 包网站。 golang.org 是Go开源项目的主站, 而 golang.com.cn 集中为Go用户提供了丰富的资源和文档，是Go生态重要的一环。
golang_starter:用golang编写的REST API入门套件
05-14
Golang REST API入门 此入门工具供您选择并根据需要进行修改。 这个项目促进思想上的代码。 并且，如果有任何零件的设计模式不正确，希望您通过提出一个问题来提供反馈。 这是什么？ 这个想法是使所有项目（包括...
Go---Redis使用
weixin_47328424的博客
01-21 1677
Redis 1.Redis是NoSQL数据库，不是传统的关系型数据库 2.Redis: REmoteDlctionary Server(远程字典版务器)，Redis性能非常高，单机能够达到 15wqps，通常适合做缓存,也可以持久化。 3.是完全开源免费的，高性能的(keylvalue)分布式内存数据库，基于内存运行并支持持久化的NoSQL数据库，是最热门的NoSql数据库之—,也称为数据结构服务器 4.Redis工作原理图 启动redis Redis的命令参数 网站Redis...
Go语言中使用redis
CrazyDemo的博客
12-04 711
Redis数据类型 redis是键值对的数据结库，有5中主要数据类型： 字符串类型（string）、散列类型（hash）、列表类型（list）、集合类型（set）、有序集合类型（zset） 基本命令 KEYS * 获得当前数据库的所有键 EXISTS key [key …] 判断键是否存在，返回个数，如果key有一样的也是叠加数 DEL key [key …] 删除键，返回删除的个数...
Redis命令参考手册(五大基本数据类型)
qq_36581961的博客
01-27 1733
参考文档：http://redisdoc.com/
golang操作Redis数据库
文杰的博客
12-19 1845
一、基本介绍 二、Redis的安装 Redis不推荐在Windows上使用，所以官网没有Windows版本 https://redis.com.cn/download.html 下载, 解压和编译 Redis 方法: $ wget https://download.redis.io/releases/redis-6.0.8.tar.gz $ tar xzf redis-6.0.8.tar.gz $ cd redis-6.0.8 $ make 编译好的二进制文件在 src 目录里。启动 Redis: $
Redis数据库4：Go与Redis的交互
尹成的技术博客
11-16 1067
1. Redis简介 Redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。 特点 支持更多数据类型 和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set 有序集合)和hash（哈希类型）。 支持复杂操作 这些数据类型都支持push/po...
golang学习demo5-redis和redis连接池的使用
姬小野的博客
11-25 632
知识点 redis 的安装与了解 golang中对redis的操作 golang中的redis 连接池 安装并启动redis server之后的界面 我们就可以使用了, 默认端口是6379 在client客户端里可以进行命令操作 一个基本的golang redis demo, 在go中队redis进行操作 /* 在go中操作redis的demo */ package main im...
Go语言操作Redis
张音乐的博客
04-29 785
package main import ( "fmt" "github.com/go-redis/redis" "time" ) func main() { //字符串操作 client := redis.NewClient(&redis.Options{ Addr: "10.181.13.126:6379", Password: "root", // no...
Go语言Redis理解和使用（十）—— Redis
qq_54353206的博客
02-15 2284
1、redis是什么 2、redis应用案例 3、redis使用注意事项
Golang Redis 学习指南：安装和基本操作
本文介绍了使用Golang编程语言进行Redis学习和使用的指南。首先，作者推荐了一个Golang的Redis客户端，即https://github.com/go-redis/r...，并提供了相应的安装方式。接下来，作者介绍了如何创建一个Redis客户端，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值