redigosrv

README

redigosrv

what

redis server侧的golang版本实现。

why

作为后端RD，你开发的，维护的最多的应该就是你的server，作为服务的提供方来说，想要和客户端进行有效的交互，首先要要能理解信息的含义，因此一套通信协议是必须的。

为什么选择redis协议，应用层有很多成熟的协议，比如

• http
• http2
• websockets

当然，上述协议都很强大，但是作为内网的服务来说，需要的协议最重要的一点是可阅读的文本，因为文本协议是好理解，便于观察的，而且内网做好权限收敛即可，不需要做加密的二进制协议。

那么为什么不使用http呢？http很强大，适用范围也比redis更广。但是任何东西都是有限制的，比如：

• 服务是存储介质/proxy
• 协议数据包尽可能的小，提高带宽利用率

这时候redis协议更加适合！

很多开发者自己实现redis server的时候，都是自己解析协议，根据参数找到对应的handler。开发者初期通常认为程序很小，没有做抽象，因此最终的实现都耦合在一起，并且一旦规模大起来后很难再维护。

因此你需要一个库帮你屏蔽底层，提高可维护性，它拥有的能力包括：

• 路由注册/寻址
• 连接限制策略
• 支持监控接口
• 中间件能力
• 异常捕获
• 优雅关闭

什么，你担心不安全，放心，这是在我在百度项目中已经使用很久的库了，重构的服务支持了**500+**微服务，历经一年没出过性能问题和资源问题。并且解决了当时耦合导致的很多性能问题和资源泄露问题。

放心大胆的使用它，如果有什么需求可以直接issue搞起，长期维护。

how

在go语言的net/http的基础上修改开发，接口完全兼容，将你的学习成本降到最低。你完全可以在5分钟内学会如何使用！

在example中附带了一个小例子，为了方便阅读，内容直接copy到下面了。

package main

import (
	"context"
	"fmt"
	"log"
	"runtime/debug"
	"strings"
	"sync"
	"time"

	"github.com/Saner-Lee/redigosrv/redis"
)

func main() {
	ExampleServer()
}

func ExampleServer() {
	// 限制连接数量为1024
	// 达到上限时，不完全阻塞
	// 阻塞到500ms未等到可用连接返回redis错误
	sema, err := redis.NewSemaphore(1024, redis.WithBlock(false), redis.WithWaitDura(500*time.Millisecond))
	if err != nil {
		panic(err)
	}

	// cmd get -> handler
	redis.HandleFunc("GET", func(_ context.Context, w redis.ResponseWriter, r *redis.Request) {
		fmt.Printf("rece get cmd, req %v\n", r)
		w.Text("OK")
	})

	opts := []redis.Option{
		// 连接限制策略
		redis.WithSemaphore(sema),
		// 异常捕获机制
		redis.WithPanicStack(func(format string, args ...interface{}) {
			fmt.Printf("redis rece a panic, err %s", fmt.Sprintf(format, args...))
			debug.PrintStack()
		}),
		// access日志，为监控提供数据源
		redis.WithLoggerFactory(func() redis.Logger { return &logger{} }),
	}

	// 启动Server
	redis.ListenAndServe("0.0.0.0:6379", nil, opts...)
}

type logger struct {
	mu sync.RWMutex
	m  map[string]string
}

func (l *logger) prefix() string {
	l.mu.RLock()
	defer l.mu.RUnlock()

	if len(l.m) == 0 {
		return ""
	}

	var secs []string
	for k, v := range l.m {
		secs = append(secs, fmt.Sprintf("%s:%s", k, v))
	}
	return strings.Join(secs, " ")
}

func (l *logger) Debug(s string, args ...interface{}) {
	p := l.prefix()
	log.Printf(p+s, args...)
}

func (l *logger) Info(s string, args ...interface{}) {
	p := l.prefix()
	log.Printf(p+s, args...)
}

func (l *logger) Notice(s string, args ...interface{}) {
	p := l.prefix()
	log.Printf(p+s, args...)
}

func (l *logger) Warn(s string, args ...interface{}) {
	p := l.prefix()
	log.Printf(p+s, args...)
}

func (l *logger) Error(s string, args ...interface{}) {
	p := l.prefix()
	log.Printf(p+s, args...)
}

func (l *logger) AddMeta(k, v string) {
	l.mu.Lock()
	defer l.mu.Unlock()

	if l.m != nil {
		l.m = make(map[string]string)
	}
	l.m[k] = v
}