Golang 入门系列(七)Redis的使用

安装

1. Redis 的安装很简单,我这里测试直接用的是windows 的版本。如何安装就不细说了。想了解的可以看之前的文章:https://www.cnblogs.com/zhangweizhong/category/771056.html

2. golang 客户端,用的是 go-redis,

  1.   go get github.com/go-redis

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

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

基本操作

创建Redis连接客户端

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

// 创建 redis 客户端

func GetRedisClient() *Client {
    redisdb := NewClient(&Options{
        Addr:     "127.0.0.1:6379",
        Password: "", // no password set
        DB:       0,                 // use default DB
    })

    pong, err := redisdb.Ping().Result()
    if err != nil {
        fmt.Println(pong, err)
    }
    return redisdb
}

通过 cient.Ping() 来检查是否成功连接到了 redis 服务器

String 操作

  Set(key, value):给数据库中名称为key的string赋予值valueget(key):返回数据库中名称为key的string的value

  GetSet(key, value):给名称为key的string赋予上一次的value

  MGet(key1, key2,…, key N):返回库中多个string的value

  SetNX(key, value):添加string,名称为key,值为value

  SetXX(key, time, value):向库中添加string,设定过期时间time

  MSet(key N, value N):批量设置多个string的值

  MSetNX(key N, value N):如果所有名称为key i的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的值附加valuesubstr(key, start, end):返回名称为key的string的value的子串

func StringDemo() {
    fmt.Println("-----------------------welcome to StringDemo-----------------------")
    redisClient:=GetRedisClient()
    if redisClient ==nil{
        fmt.Errorf("StringDemo redisClient is nil")
        return
    }

    name := "张三"
    key :="name:zhangsan"
    redisClient.Set(key , name,1 * time.Second)
    val := redisClient.Get(key)
    if val == nil {
        fmt.Errorf("StringDemo get error")
    }
    fmt.Println("name", val)
}

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的头部

func ListDemo(){
    fmt.Println("-----------------------welcome to ListDemo-----------------------")
    redisClient:=GetRedisClient()
    if redisClient == nil {
        fmt.Errorf("ListDemo redisClient is nil")
        return
    }
    articleKey := "article"
    result,err:=redisClient.RPush(articleKey, "a","b","c").Result() //
    if err!=nil {
        fmt.Println(err)
        return
    }
    fmt.Println("result:",result)

    result,err = redisClient.LPush(articleKey, "d").Result() //
    if err!=nil {
        fmt.Println(err)
        return
    }
    fmt.Println("result:",result)

    length, err := redisClient.LLen(articleKey).Result()
    if err != nil {
        fmt.Println("ListDemo LLen is nil")
    }
    fmt.Println("length: ", length) // 长度

    mapOut,err1:=redisClient.LRange(articleKey,0,100).Result()
    if err1!=nil {
        fmt.Println(err1)
        return
    }
    for inx, item := range mapOut {
        fmt.Printf("\n %s:%s", inx, item)
    }
}

Hash 操作

  HSet(key, field, value):向名称为key的hash中添加元素field

  HGet(key, field):返回名称为key的hash中field对应的value

  HMget(key, (fields)):返回名称为key的hash中field i对应的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

func HashDemo() {
	fmt.Println("-----------------------welcome to HashDemo-----------------------")
	redisClient := GetRedisClient()
	if redisClient == nil {
		fmt.Errorf("HashDemo redisClient is nil")
		return
	}
	article := Article{18, "测试文章内容22222", "测试文章内容22222测试文章内容22222测试文章内容22222", 10, 0}
	articleKey := "article:18"

	redisClient.HMSet(articleKey, ToStringDictionary(&article))
	mapOut := redisClient.HGetAll(articleKey).Val()
	for inx, item := range mapOut {
		fmt.Printf("\n %s:%s", inx, item)
	}
	fmt.Print("\n")

	redisClient.HSet(articleKey, "Content", "测试文章内容")
	mapOut = redisClient.HGetAll(articleKey).Val()
	for inx, item := range mapOut {
		fmt.Printf("\n %s:%s", inx, item)
	}
	fmt.Print("\n")

	view, err := redisClient.HIncrBy(articleKey, "Views", 1).Result()
	if err != nil {
		fmt.Printf("\n HIncrBy error=%s ", err)
	} else {
		fmt.Printf("\n HIncrBy Views=%d ", view)
	}
	fmt.Print("\n")

	mapOut = redisClient.HGetAll(articleKey).Val()
	for inx, item := range mapOut {
		fmt.Printf("\n %s:%s", inx, item)
	}
	fmt.Print("\n")

}

连接池

go-redis 已经实现了 redis 的连接池管理, 因此我们不需要自己手动管理 redis 的连接。

默认情况下,连接池大小是10, 可以通过 redis.Options 的 PoolSize 属性, 我们设置了 redis 连接池的大小为5。

func GetRedisClientPool() *Client{
    redisdb := NewClient(&Options{
        Addr: "127.0.0.1:6379",
        Password: "",
        DB: 0,
        PoolSize: 5,})

    pong, err := redisdb.Ping().Result()
    if err != nil {
        fmt.Println(pong, err)
    }
    return redisdb
}
// 连接池测试
func connectPoolTest() {
    fmt.Println("-----------------------welcome to connect Pool Test-----------------------")
    client :=GetRedisClientPool()
    wg := sync.WaitGroup{}
    wg.Add(10)

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

            for j := 0; j < 1000; 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, IdleConns: %d\n", client.PoolStats().TotalConns, client.PoolStats().IdleConns);
        }()
    }

    wg.Wait()
}

完整代码

package main

import (
    "fmt"
    . "github.com/go-redis/redis"
    . "redisDemo/models"
    "time"
    "sync"
)

func main() {
    fmt.Println("-----------------------welcome to redisdemo-----------------------")
    //StringDemo()
    //ListDemo()
    //HashDemo()
    connectPoolTest()
}

func StringDemo() {
    fmt.Println("-----------------------welcome to StringDemo-----------------------")
    redisClient:=GetRedisClient()
    if redisClient ==nil{
        fmt.Errorf("StringDemo redisClient is nil")
        return
    }

    name := "张三"
    key :="name:zhangsan"
    redisClient.Set(key , name,1 * time.Second)
    val := redisClient.Get(key)
    if val == nil {
        fmt.Errorf("StringDemo get error")
    }
    fmt.Println("name", val)
}

func ListDemo(){
    fmt.Println("-----------------------welcome to ListDemo-----------------------")
    redisClient:=GetRedisClient()
    if redisClient == nil {
        fmt.Errorf("ListDemo redisClient is nil")
        return
    }
    articleKey := "article"
    result,err:=redisClient.RPush(articleKey, "a","b","c").Result() //在名称为 key 的list尾添加一个值为value的元素
    if err!=nil {
        fmt.Println(err)
        return
    }
    fmt.Println("result:",result)

    result,err = redisClient.LPush(articleKey, "d").Result() //在名称为 key 的list头添加一个值为value的元素
    if err!=nil {
        fmt.Println(err)
        return
    }
    fmt.Println("result:",result)

    length, err := redisClient.LLen(articleKey).Result()
    if err != nil {
        fmt.Println("ListDemo LLen is nil")
    }
    fmt.Println("length: ", length) // 长度

    mapOut,err1:=redisClient.LRange(articleKey,0,100).Result()
    if err1!=nil {
        fmt.Println(err1)
        return
    }
    for inx, item := range mapOut {
        fmt.Printf("\n %s:%s", inx, item)
    }
}

func HashDemo() {
    fmt.Println("-----------------------welcome to HashDemo-----------------------")
    redisClient := GetRedisClient()
    if redisClient == nil {
        fmt.Errorf("HashDemo redisClient is nil")
        return
    }
    article := Article{18, "测试文章内容22222", "测试文章内容22222测试文章内容22222测试文章内容22222", 10, 0}
    articleKey := "article:18"

    redisClient.HMSet(articleKey, ToStringDictionary(&article))
    mapOut := redisClient.HGetAll(articleKey).Val()
    for inx, item := range mapOut {
        fmt.Printf("\n %s:%s", inx, item)
    }
    fmt.Print("\n")

    redisClient.HSet(articleKey, "Content", "测试文章内容")
    mapOut = redisClient.HGetAll(articleKey).Val()
    for inx, item := range mapOut {
        fmt.Printf("\n %s:%s", inx, item)
    }
    fmt.Print("\n")

    view, err := redisClient.HIncrBy(articleKey, "Views", 1).Result()
    if err != nil {
        fmt.Printf("\n HIncrBy error=%s ", err)
    } else {
        fmt.Printf("\n HIncrBy Views=%d ", view)
    }
    fmt.Print("\n")

    mapOut = redisClient.HGetAll(articleKey).Val()
    for inx, item := range mapOut {
        fmt.Printf("\n %s:%s", inx, item)
    }
    fmt.Print("\n")

}

func GetRedisClient() *Client {
    redisdb := NewClient(&Options{
        Addr:     "127.0.0.1:6379",
        Password: "", // no password set
        DB:       0,                 // use default DB
    })

    pong, err := redisdb.Ping().Result()
    if err != nil {
        fmt.Println(pong, err)
    }
    return redisdb
}

func GetRedisClientPool() *Client{
    redisdb := NewClient(&Options{
        Addr: "127.0.0.1:6379",
        Password: "",
        DB: 0,
        PoolSize: 5,})

    pong, err := redisdb.Ping().Result()
    if err != nil {
        fmt.Println(pong, err)
    }
    return redisdb
}

// 连接池测试
func connectPoolTest() {
    fmt.Println("-----------------------welcome to connect Pool Test-----------------------")
    client :=GetRedisClientPool()
    wg := sync.WaitGroup{}
    wg.Add(10)

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

            for j := 0; j < 1000; 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, IdleConns: %d\n", client.PoolStats().TotalConns, client.PoolStats().IdleConns);
        }()
    }

    wg.Wait()
}

最后

1. go语言使用Redis 还是非常简单的,以上已经把Redis 的基本的用法讲完了。大家可以自己动手写代码试试。

2. 完整代码:点击下载

原文地址:https://www.cnblogs.com/zhangweizhong/p/10341460.html

时间: 2024-11-02 13:32:48

Golang 入门系列(七)Redis的使用的相关文章

C语言快速入门系列(七)

C语言快速入门系列(七) C语言指针进阶 本章引言: 在前面第5节中我们对C语言的指针进行了初步的学习理解;作为C语言的灵魂, C指针肯定没那么简单,在这一节中,我们将会对指针进行进一步的学习,比如二级指针, 指针数组,内存分配和const修饰指针常量等!下面就请大家跟随笔者的脚步,对 C指针神秘的一面进行进一步的解析吧! 本节学习路线图: 函数与指针: ①指针作为函数的形参: ②指向函数的指针: ③指针函数: ④带参数的主函数 ps:该代码的运行:先要编译生成exe文件后,来到exe所在文件目

Golang 入门系列(十五)如何理解go的并发?

前面已经讲过很多Golang系列知识,感兴趣的可以看看以前的文章,https://www.cnblogs.com/zhangweizhong/category/1275863.html, 接下来要说的是golang的并发,其实之前简单介绍过协程(goroutine)和管道(channel) 等基础内容,只是比较简单,只讲了基本的语法.今天就详细说说golang的并发编程. 一.并发和并行 Go是并发语言,而不是并行语言.所以我们在讨论,我们首先必须了解什么是并发,以及它与并行性有什么不同. 什么

Golang 入门系列-八怎样实现定时任务,极简版.

感谢平台分享-http://bjbsair.com/2020-04-10/tech-info/53303.html 前面讲介绍了Go 语言的基础入门及Golang的语法结构.同时也介绍Golang的接口及协程等内容.感兴趣的朋友可以先看看之前的文章.接下来说一说Golang 如何实现定时任务. golang 实现定时服务很简单,只需要简单几步代码便可以完成,不需要配置繁琐的服务器,直接在代码中实现. 1.使用的包 github.com/robfig/cron 2.示例 1.创建最简单的最简单cr

Metasploit入门系列(七)——Armitage

其实这一章不该出现的这么早的,然而最近有几个小伙伴私信我聊到了gui的问题,那么就提前写一下吧.正在学msf的小伙伴们可能在一些就资料是看到了msfgui的命令,然而,没有用了.其实msfgui还是存在的,但是无论kali还是parrot都没有预装,而是预装了它的替代品Armitage. 然而我们就要好好说道说道下Armitage了,它的作者似乎不怎么上心,所以更新也比较慢,然而大家在Armitage使用中碰上了许多问题,又没有社区维护或解决,所以并没有流行起来.然而它又的的确确是为懒人准备的,

Golang 入门系列(十) mysql数据库的使用

之前,已经讲过一些Golang的基础的东西,感兴趣的可以看看以前的文章,https://www.cnblogs.com/zhangweizhong/category/1275863.html, 今天简单介绍下Golang是如何使用mysql数据库的.由于Go本身不提供具体数据库驱动,只提供驱动接口和管理.各个数据库驱动需要第三方实现,并且注册到Go中的驱动管理中.github上面的mysql驱动有好几个,我在这里选择的https://github.com/go-sql-driver/mysql.

spring cloud 入门系列七:基于Git存储的分布式配置中心--Spring Cloud Config

我们前面接触到的spring cloud组件都是基于Netflix的组件进行实现的,这次我们来看下spring cloud 团队自己创建的一个全新项目:Spring Cloud Config.它用来为分布式系统中的基础设施和微服务提供集中化的外部配置支持,分为服务端和客户端两个部分. 其中服务端也称为分布式配置中心,他是独立的微服务应用,用来连接配置仓库并为客户端提供获取接口(这些接口返回配置信息.加密.解密信息等): 客户端是微服务架构中的各个微服务应用或基础设施,它们通过制定的配置中心来管理

Java程序员的Golang入门指南(上)

Java程序员的Golang入门指南 1.序言 Golang作为一门出身名门望族的编程语言新星,像豆瓣的Redis平台Codis.类Evernote的云笔记leanote等. 1.1 为什么要学习 如果有人说X语言比Y语言好,两方的支持者经常会激烈地争吵.如果你是某种语言老手,你就是那门语言的"传道者",下意识地会保护它.无论承认与否,你都已被困在一个隧道里,你看到的完全是局限的.<肖申克的救赎>对此有很好的注脚: [Red] These walls are funny.

saltstack之基础入门系列文章简介

使用saltstack已有一段时间,最近由于各种原因,特来整理了saltstack基础入门系列文章,已备后续不断查阅(俗话说好记性不如烂笔头),也算是使用此工具的一个总结.saltstack的前六篇文章主要讲述了saltstack的安装.远程执行.配置管理.数据系统以及jinjia模板等知识点,从第七篇往后的文章是一些使用saltstack的案例,包括系统初始化,rpm包以及源码安装等. 博客中saltstack系列的文章,适合初学者从零开始学习直到逐渐熟练使用.文章具有一定的连贯性,如果没有任

22Python标准库系列之Redis模块

Python标准库系列之Redis模块 What is redis? Redis is an open source (BSD licensed), in-memory data structure store, used as database, cache and message broker. It supports data structures such as strings, hashes, lists, sets, sorted sets with range queries, b