自己使用Golang编写Redis客户端（一）

最新推荐文章于 2024-08-20 22:13:00 发布
最新推荐文章于 2024-08-20 22:13:00 发布
阅读量390 收藏 5
点赞数 8
文章标签： golang redis 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33999481/article/details/138394297
版权

动机

突然想试着用golang写一个自己的redis连接客户端，尽可能的让操作变简单，也通过写代码的过程中，学习一些知识点，不想一直局限于写web项目

简介

目前实现了简单的get和set操作，加入了直接set结构体和get结构体数据的方法,添加了拦截器链，在执行redis命令的过程中进行前置拦截和后置拦截。也加入了事务，但是事务的实现可能不够完善，后续会继续修改。使用了连接池管理对象。写这个需要很多的时间，所以后续我会慢慢的补齐其他的功能。如果有志同道合的朋友我们可以一起写，也是当锻炼能力了。
代码在github上可以看到

部分代码如下

package redis

import (
	"fmt"
	"time"
)

/**
redis 中间层主要代码，负责在redisClient 和 connect 中起到承上启下的作用
*/

type Redis struct {
	//  配置类
	Config *Config
	// 连接池
	connPool *ConnPool
	// 前置拦截器，查询前拦截器
	preInterceptors []func(redisContext *InterceptorContext)
	// 后置拦截器，查询后的拦截器
	postInterceptors []func(redisContext *InterceptorContext)
}

func (r *Redis) GetByteArr(cmd *RedisCommand, t *transaction) (res []byte) {
	// 获取连接对象
	var conn *RedisConn
	if t == nil {
		conn = r.connPool.Get()
		// 归还连接对象
		defer r.connPool.Put(conn)
	} else {
		if t.status > 0 {
			return nil
		}
		conn = t.conn
	}
	// 构建一个命令对象
	context := newInterceptorContext(conn, cmd)
	// 执行前置拦截器链
	r.doPreInterceptor(context)
	result, success := conn.CommandGetResult(cmd.Cmd())
	if success {
		res = result
		cmd.SetRes(res)
	} else if t != nil {
		t.status = 2
	}
	// 执行后置拦截链
	r.doPostInterceptor(context)
	// 置空，方便垃圾回收
	context = nil
	return
}

// Set 默认set方法，未携带过期时间
func (r *Redis) Set(cmd *RedisCommand, t *transaction) (success bool) {
	// 获取连接对象
	var conn *RedisConn
	if t == nil {
		conn = r.connPool.Get()
		// 归还连接对象
		defer r.connPool.Put(conn)
	} else {
		if t.status > 0 {
			return false
		}
		conn = t.conn
	}
	// 构建一个命令对象
	context := newInterceptorContext(conn, cmd)
	// 执行前置拦截器链
	r.doPreInterceptor(context)
	if conn.CommandNoResult(cmd.Cmd()) {
		success = true
	} else if t != nil {
		t.status = 2
	}
	// 执行后置拦截链
	r.doPostInterceptor(context)
	// 归还连接对象
	r.connPool.Put(conn)
	// 置空，方便垃圾回收
	context = nil
	return
}

// SetWithExp set顺便设置过期时间，-1表示用不过期，大于0的数表示过期时间，单位为毫秒，
func (r *Redis) SetWithExp(key string, value interface{}, expireTime time.Duration) (success bool) {
	return
}

// AddPreInterceptor 添加前置拦截器
func (r *Redis) AddPreInterceptor(interceptor func(redisContext *InterceptorContext)) {
	r.preInterceptors = append(r.preInterceptors, interceptor)
}

// AddPostInterceptor 添加后置拦截器
func (r *Redis) AddPostInterceptor(interceptor func(redisContext *InterceptorContext)) {
	r.postInterceptors = append(r.postInterceptors, interceptor)
}

func (r *Redis) doPreInterceptor(redisContext *InterceptorContext) {
	for _, interceptor := range r.preInterceptors {
		interceptor(redisContext)
	}
}

func (r *Redis) doPostInterceptor(redisContext *InterceptorContext) {
	for _, interceptor := range r.postInterceptors {
		interceptor(redisContext)
	}
}

func (r *Redis) getRedisConn() *RedisConn {
	return r.connPool.Get()
}

func (r *Redis) putRedisConn(c *RedisConn) {
	r.connPool.Put(c)
}

/*
事务
*/
type transaction struct {
	// 当前事务的连接对象
	conn *RedisConn
	// 当前事务的状态 0表示开启，1表示结束，2表示回滚
	status int
}

func (t *transaction) Open() {
	if t.conn.BeginTransaction() {
		fmt.Println("事务开启失败！")
	}
}

func (t *transaction) Close() {
	if t.conn.EndTransaction() {
		fmt.Println("关闭事务失败")
	}
}

func (t *transaction) Rollback() {
	if t.conn.Rollback() {
		fmt.Println("回滚失败")
	}
}


package redis

import (
	"fmt"
	"github.com/vmihailenco/msgpack/v5"
)

type redisCli struct {
	redis Redis
}

// CreateRedisCli 创建连接对象
func CreateRedisCli(config *Config) *redisCli {
	// 初始化中间连接层
	redis := Redis{
		Config: config,
	}
	// 创建连接池
	pool := NewConnPool(config, nil, 5, 10, 8)
	redis.connPool = pool
	// 判断是否开启debug 模式
	if config.Debug {
		redis.AddPostInterceptor(PrintDebug)
	}
	// TODO 还可以继续干很多事情，后面再写
	r := redisCli{
		redis,
	}
	return &r
}

func (r *redisCli) xxx(key string) {

}

// Get 默认Get方法，直接转化为string类型返回
func (r *redisCli) Get(key string, arg ...*transaction) (res string) {
	arr := r.GetByte(key, arg...)
	res = string(arr)
	return
}

// GetByte 获取原始二进制结果
func (r *redisCli) GetByte(key string, arg ...*transaction) (res []byte) {
	command := newGetCommand(key, -1)
	var t *transaction = nil
	if len(arg) > 0 {
		t = arg[0]
	}
	res = r.redis.GetByteArr(command, t)
	return
}

// Set 设置任意值，结构体除外
func (r *redisCli) Set(key string, value interface{}, arg ...*transaction) (success bool) {
	cmd := key + " " + convertInterfaceToString(value)
	command := newSetCommand(cmd, -1)
	command.AddArgs(value)
	var t *transaction = nil
	if len(arg) > 0 {
		t = arg[0]
	}
	success = r.redis.Set(command, t)
	return
}

// SetWithStruct 直接设置一个结构体对象
func (r *redisCli) SetWithStruct(key string, value interface{}, arg ...*transaction) (success bool) {
	v, err := msgpack.Marshal(value)
	if err != nil {
		fmt.Printf("不能将[]byte转为%T\n", v)
		fmt.Println(err)
		return
	}
	cmd := key + " " + convertInterfaceToString(v)
	command := newSetCommand(cmd, -1)
	command.AddArgs(value)
	var t *transaction = nil
	if len(arg) > 0 {
		t = arg[0]
	}
	success = r.redis.Set(command, t)
	return
}

// GetWithStruct 获取结构体对象，获取的对象就在传进来的对象中
func (r *redisCli) GetWithStruct(key string, vt interface{}, arg ...*transaction) {
	arr := r.GetByte(key, arg...)
	err := msgpack.Unmarshal(arr, vt)
	if err != nil {
		fmt.Printf("不能将[]byte转为%T\n", vt)
	}
	return
}

// AddPreInterceptor 添加前置拦截器
func (r *redisCli) AddPreInterceptor(interceptor func(redisContext *InterceptorContext)) {
	r.redis.preInterceptors = append(r.redis.preInterceptors, interceptor)
}

// AddPostInterceptor 添加后置拦截器
func (r *redisCli) AddPostInterceptor(interceptor func(redisContext *InterceptorContext)) {
	r.redis.postInterceptors = append(r.redis.postInterceptors, interceptor)
}

// CreateTransaction 创建一个事务对象
func (r *redisCli) CreateTransaction() *transaction {
	t := transaction{conn: nil, status: 0}
	return &t
}

// DoTransaction 事务执行
func (r *redisCli) DoTransaction(t *transaction, f func() (err error)) {
	// 开启事务
	t.conn = r.redis.getRedisConn()
	defer r.redis.putRedisConn(t.conn)
	t.Open()
	err := f()
	if err != nil {
		// 回滚
		t.status = 2
		fmt.Println(err, "事务回滚")
		t.Rollback()
	}
	// 提交事务
	t.status = 1
	t.Close()
}


package redis

import (
	"time"
)

type Config struct {
	// redis连接地址
	IpAddr string
	// 端口
	Port int
	// 网络连接类型，默认Tcp
	NetType string
	//redis-server 协议类型，默认协议为3
	Protocol int
	//用户名
	Username string
	//密码
	Password string
	//数据库的索引
	DataBase int
	// 最大失败尝试次数
	MaxRetries int
	//连接超时时间
	ConnectionTimeOut time.Duration
	//最大读取时间
	ReadTimeOut time.Duration
	// 最大写入时间
	WriteTimeout time.Duration
	//连接池大小
	PoolSize int
	// 最大空闲连接数量
	MaxIdleConn int
	// 最大活动连接数量
	MaxActiveConn int
	// 是否开启Debug模式，开启日志打印,默认为false
	Debug bool
}

func FastConfig(addr string, port int, password string) *Config {
	return &Config{
		IpAddr:   addr,
		Port:     port,
		Password: password,
		NetType:  "tcp",
		DataBase: 16,
		Debug:    true,
	}
}


package redis

import (
	"time"
)

const (
	get = iota
	set
	setex
	sel
	ping
	del
	flushdb
	flushall
	keys
	expire
)

const (
	Get     = "GET "
	END     = "\r\n"
	Set     = "SET "
	Multl   = "MULTI"
	Exec    = "EXEC"
	Discard = "DISCARD"
	AUTH    = "auth"
)

// RedisCommand 表示一个Redis命令
type RedisCommand struct {
	// 命令名
	cmd string

	// 参数，依次为key,value……等
	args []interface{}

	// 超时时间
	timeout time.Duration

	// 返回结果
	res []byte

	// 命令种类
	cmdType int

	// 附加参数

}

func (r *RedisCommand) Res() []byte {
	return r.res
}

func (r *RedisCommand) SetRes(res []byte) {
	r.res = res
}

func (r *RedisCommand) Args() []interface{} {
	return r.args
}

func (r *RedisCommand) SetArgs(args []interface{}) {
	r.args = args
}

func (r *RedisCommand) CmdType() int {
	return r.cmdType
}

func (r *RedisCommand) AddArgs(item interface{}) {
	r.args = append(r.args, item)
}

func (r *RedisCommand) SetCmdType(cmdType int) {
	r.cmdType = cmdType
}

func (r *RedisCommand) Cmd() string {
	return r.cmd
}

func (r *RedisCommand) SetCmd(cmd string) {
	r.cmd = cmd
}

func (r *RedisCommand) Timeout() time.Duration {
	return r.timeout
}

func (r *RedisCommand) SetTimeout(timeout time.Duration) {
	r.timeout = timeout
}

func newRedisCommand(cmd string, timeout time.Duration, res []byte, cmdType int) *RedisCommand {
	return &RedisCommand{cmd: cmd, timeout: timeout, res: res, cmdType: cmdType}
}

func newGetCommand(cmd string, timeout time.Duration) *RedisCommand {
	cmd = Get + cmd + END
	return newRedisCommand(cmd, timeout, nil, get)
}

func newSetCommand(cmd string, timeout time.Duration) *RedisCommand {
	cmd = Set + cmd + END
	return newRedisCommand(cmd, timeout, nil, set)
}


package redis

import (
	"bufio"
	"fmt"
	"net"
	"strings"
)

type RedisConn struct {
	// 连接对象
	conn net.Conn
	//是否开启事务
}

// NewRedisConn 创建一个新的连接，使用Golang的net包
func NewRedisConn(netType string, addr string) (*RedisConn, error) {
	conn, err := net.Dial(netType, addr)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	return &RedisConn{conn: conn}, err
}

func (r *RedisConn) Auth(password string) bool {
	authCommand := AUTH + " " + password + END
	_, err := r.conn.Write([]byte(authCommand))
	if err != nil {
		fmt.Println("Redis权限认证错误:", err)
		return false
	}
	reader := bufio.NewReader(r.conn)
	response, err := reader.ReadString('\n')
	if err != nil {
		fmt.Println("认证时读取Redis返回值出错:", err)
		return false
	}
	// 如果认证成功，可以继续发送其他命令进行操作
	if response != "+OK\r\n" {
		fmt.Println("Redis 认证失败.")
		return false
	}
	return true
}

func (r *RedisConn) CommandNoResult(cmd string) (success bool) {
	_, err := r.conn.Write([]byte(cmd))
	if err != nil {
		fmt.Println("执行命令失败", err)
		return false
	}
	return true
}

func (r *RedisConn) CommandGetResult(cmd string) (result []byte, success bool) {
	_, err := r.conn.Write([]byte(cmd))
	success = true
	if err != nil {
		fmt.Println("执行命令失败", err)
		success = false
		return
	}
	if success {
		reader := bufio.NewReader(r.conn)
		respLenBytes, err := reader.ReadBytes('\n')
		if err != nil {
			fmt.Println("无法读取响应长度:", err)
			return
		}

		// 解析响应长度
		respLenStr := strings.TrimPrefix(string(respLenBytes), "$")
		respLen := 0
		_, err = fmt.Sscanf(respLenStr, "%d", &respLen)
		if err != nil {
			return nil, false
		}
		// 读取响应内容
		for i := 0; i < respLen; i++ {
			responseByte, err := reader.ReadByte()
			if err != nil {
				fmt.Println("无法读取响应内容:", err)
				return
			}
			result = append(result, responseByte)
		}

		// 读取响应结束符
		_, err = reader.ReadBytes('\n')
		if err != nil {
			fmt.Println("无法读取响应结束符:", err)
			return
		}
	}
	return
}

// BeginTransaction 开启事务
func (r *RedisConn) BeginTransaction() bool {
	_, f := r.CommandGetResult("MULTI" + END)
	return f
}

// EndTransaction 结束事务
func (r *RedisConn) EndTransaction() bool {
	_, f := r.CommandGetResult("EXEC" + END)
	return f
}

// Rollback 添加一个 Rollback 方法来执行回滚操作
func (r *RedisConn) Rollback() bool {
	_, f := r.CommandGetResult("DISCARD" + END) // 发送 DISCARD 命令来取消事务
	return f

}


package redis

import (
	"fmt"
	"strconv"
	"sync"
)

type ConnPool struct {
	pool         chan *RedisConn
	maxOpenConns int
	maxIdleConns int
	mu           sync.Mutex
	factory      func() *RedisConn
}

func (p *ConnPool) SetFactory(factory func() *RedisConn) {
	p.factory = factory
}

func (p *ConnPool) MaxOpenConns() int {
	return p.maxOpenConns
}

func (p *ConnPool) SetMaxOpenConns(maxOpenConns int) {
	p.maxOpenConns = maxOpenConns
}

func (p *ConnPool) MaxIdleConns() int {
	return p.maxIdleConns
}

func (p *ConnPool) SetMaxIdleConns(maxIdleConns int) {
	p.maxIdleConns = maxIdleConns
}

// DefaultFactory 默认创建连接工厂
func DefaultFactory(config *Config) *RedisConn {
	dst := config.IpAddr + ":" + strconv.Itoa(config.Port)
	conn, err := NewRedisConn(config.NetType, dst)
	if err != nil {
		return nil
	}
	return conn
}

func NewConnPool(config *Config, factory func() *RedisConn, initialOpenConns, maxOpenConns, maxIdleConns int) *ConnPool {
	// 创建一个连接池
	pool := &ConnPool{
		pool:         make(chan *RedisConn, maxOpenConns),
		maxOpenConns: maxOpenConns,
		maxIdleConns: maxIdleConns,
		factory:      factory,
	}
	df := factory == nil
	// 初始化若干个连接对象
	for i := 0; i < initialOpenConns; i++ {
		// 使用工厂方法对连接进行创建，如果没有传入，使用默认实现的工厂对象
		var conn *RedisConn
		if df {
			conn = DefaultFactory(config)
			// 建立连接对象失败
			if conn == nil {
				fmt.Println("创建连接对象失败！")
				break
			}
		} else {
			//TODO 执行自定义的连接创建工厂
		}
		// 直到创建完成initialOpenConns个连接对象才停止循环
		if conn.Auth(config.Password) {
			pool.Put(conn)
		}
	}
	return pool
}

func (p *ConnPool) Get() *RedisConn {
	select {
	case item := <-p.pool:
		return item
	default:
		p.mu.Lock()
		defer p.mu.Unlock()
		if len(p.pool) >= p.maxOpenConns {
			return nil
		}
		conn := p.factory()
		return conn
	}
}

func (p *ConnPool) Put(item *RedisConn) {
	select {
	case p.pool <- item:
		if len(p.pool) > p.maxIdleConns {
			item.conn.Close()
		}
	default:
		item.conn.Close()
	}
}
jolly_xu
关注
Golang websocket 客户端开发
J_Lee
11-26 1949
Golang websocket 客户端开发
golang中使用redis
shnbiot的博客
08-01 524
获取redis g o get github.com/garyburd/redigo/redis 1、连接redis package main import ( "fmt" "github.com/garyburd/redigo/redis" ) func main() { c, err := redis.Dial("tcp", "127.0.0.1:6379"...
Golang的HTTP客户端-Golang开发
05-26
受Javascript-axios Python请求的启发，向HTTP客户端请求golang。 如果您有关于axios或请求的经验，那么您会喜欢的。 没有第三个依赖项。 功能从Golang发出HTTP请求，以受Javascript-axios Python-request的启发，向golang请求HTTP客户端。 如果您有关于axios或请求的经验，那么您会喜欢的。 没有第三个依赖项。 功能从Golang发出HTTP请求拦截请求和响应转换请求和响应数据安装go mod：go get github.com/monaco-io/request方法选项获取头POST删除跟踪连接示例GET包main import（“ log”“ github .com / monaco-io / request“）func
golang Redis的使用
lff的博客
01-30 2241
1、Redis的介绍 1）Redis：REmote DIctionary Server（远程字典服务器），是NoSQL数据库，不睡传统的关系型数据库。Redis性能非常高，单机能够达到15w qps，通常适合做缓存，也可以持久化。 官网：https://redis.io/ 快速进行命令查找：Redis 命令参考 — Redis 命令参考 2）Redis五大数据类型：String（字符串）、Hash（哈希）、List（列表）、Set（集合）、zset（sorted set：有序集合） 2、Re.
手把手教你用Go开发客户端软件（使用Go + HTML）
最新发布
no_reg的博客
08-20 1755
开发桌面客户端软件一直是程序员的常见任务之一，而Go语言凭借其简洁、高效以及丰富的第三方库，越来越多地被用于开发各类应用程序。今天我们将结合Go语言和HTML，使用开源项目 Sciter 的 Go 绑定库 go-sciter，为大家展示如何用最少的开发精力构建一个跨平台的桌面客户端。 什么是Sciter？ Sciter 是一个支持多平台的嵌入式HTML/CSS/脚本引擎，适用于构建本地桌面应用程序，且它的性能非常好。通过 go-sciter，我们可以用Go语言来调用Sciter引擎，进而使用HTML、CSS
golang 客户端
weixin_30378311的博客
05-20 866
package main import ( "fmt" "io/ioutil" "net/http" ) func main() { fmt.Println(http.Status) res, err := http.Get("https://www.baidu.com/") if err != nil { fmt.Printl...
Golang中Redis的使用
qq_53267860的博客
02-08 2961
redis的五大基本类型，golang对redis的操作以及redis连接池的运用
Golang使用lua脚本实现redis原子操作
12-20
在Golang中，你可以编写一个Lua脚本来处理排行榜的更新逻辑。例如，当一个新的评分（ARGV[3]）进来时，脚本会根据期望的最大存储成员数量（ARGV[1]）和评分上限（ARGV[2]）更新ZSET。这个脚本可能会包括检查现有成员...
在golang中去写redis客户端，建立连接
茂茂的博客
11-17 1019
Redis在golang中的应用 我们在平时使用golang开发服务器的过程中，会遇见使用Redis的业务场景，Redis简单的来说就是一个缓存数据库。可以对其进行操作。首先，我们需要去在golang后端的项目中写一个Redis的客户端，以此和redis服务器来建立连接。 package redis import ( "context" "github.com/go-redis/redis/v8" "github.com/spf13/viper" ) var RedisClient *redis
用于Golang的类型安全的Redis客户端-Golang开发
05-26
Golang的Redis客户端支持：Redis 3命令（QUIT，MONITOR，SLOWLOG和SYNC除外）。 具有断路器支持的自动连接池。 发布/订阅。 交易。 管道和TxPipeline。 脚本编写。 Golang文档参考示例的Redis客户端赞助Uptrace.dev-...
去Redis的客户端-Golang开发
05-26
Redigo Redigo是Redis数据库的Go客户端。 具有类似于Print的API，并支持所有Redis命令。 流水线，包括流水线交易。 发布/订阅。 连接池。 Sc Redigo Redigo是Redis数据库的Go客户端。 具有类似于Print的API，并支持所有Redis命令。 流水线，包括流水线交易。 发布/订阅。 连接池。 乐观使用EVALSHA的脚本帮助程序类型。 帮助程序功能，用于处理命令答复。 文档API参考FAQ示例安装使用“ go get”命令安装Redigo：go get github.com/gomodule/redigo/redis Go发行版是Redigo的唯一依赖项。
【golang】golang redis 的使用
zhonglinzhang
08-11 4901
前言     Redis 是一个开源的、使用C语言编写的、基于内存也可持久化的 Key-Value 数据库。     Redis 优势      性能高 – Redis 读速度 110000 次/s，写速度 81000次/s 。    支持的数据类型多 – Redis支持 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型。
Golang编写客户端SDK，并开源发布包到GitHub，供其他项目import使用
trinityleo5的博客
09-05 2155
使用Golang编写一个客户端SDK，并开源发布包到GitHub，供其他项目import使用
Golang：go-redis支持Redis Server和Redis Cluster的客户端
彭世瑜的博客
06-04 413
多种客户端：支持单机Redis Server、Redis Cluster、Redis Sentinel、Redis分片服务器。功能完善：go-redis支持管道(pipeline)、事务、pub/sub、Lua脚本、mock、分布式锁等功能。数据类型：go-redis会根据不同的redis命令处理成指定的数据类型，不必进行繁琐的数据类型转换。go-redis是支持Redis Server和Redis Cluster的Golang客户端。
在Golang中使用Redis
ninininiwowo的专栏
11-27 711
在Golang中使用Redis
最简单的Redis客户端实现——Golang
Linux平台软件设计与开发
11-30 1564
使用Golang分析Redis协议，实现一个简单客户端；使用方法简单，Connect完成后直接Write、Read进行操作，或者使用Cmd。可有助于理解Redis协议，其实挺简单的。 package redisimport ( "bufio" "errors" "fmt" "io" "net" "strconv" "time" )const (
Go-基于golang和redis实现的简单易用的队列
08-14
本文将深入探讨如何使用Golang（Go语言）与Redis构建一个简单易用的消息队列系统，以此来提升系统的可扩展性和解耦性。 首先，我们来看标题"Go-基于golang和redis实现的简单易用的队列"，这表明我们将使用Go语言...
Redis(十)[client-Golang]
weixin_42366378的博客
05-05 362
Redis-client-Golang1.下载2.入门1.创建项目2.在redis-cli中查询 redis官方地址： https://redis.io/ redis中文官方地址： http://redis.cn/ redis文档地址： http://redis.cn/documentation.html 官方参考client-golang地址： http://redis.cn/clien...
Golang操作Redis
weixin_57023347的博客
04-26 1615
Redis是完全开源免费的，遵循BSD协议，是一个高性能的key-value数据库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值