redisgo 代码示例（set， get， del， mget， mset，Pipelining）

萌新，写的差轻喷！！！

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/gomodule/redigo/redis"
)

var (
	Pool *redis.Pool
)

func init() {
	redisHost := "106.14.39.56:6379"
	redispass := "foobared"
	db := 6
	Pool = newPool(redisHost, redispass, db)
	close()
}

func newPool(server string, password string, db int) *redis.Pool {
	return &redis.Pool{
		// 最大的空闲连接数，表示即使没有redis连接时依然可以保持N个空闲的连接，而不被清除，随时处于待命状态
		MaxIdle: 3,
		//最大的空闲连接等待时间，超过此时间后，空闲连接将被关闭
		IdleTimeout: 240 * time.Second,
		// 最大的激活连接数，表示同时最多有N个连接 ，为0事表示没有限制
		// MaxActive int
		// 当链接数达到最大后是否阻塞，如果不的话，达到最大后返回错误
		// Wait bool

		Dial: func() (redis.Conn, error) {
			c, err := redis.Dial("tcp", server)
			if err != nil {
				return nil, err
			}
			if _, err := c.Do("AUTH", password); err != nil {
				c.Close()
				return nil, err
			}
			if _, err := c.Do("SELECT", db); err != nil {
				c.Close()
				return nil, err
			}
			return c, err
		},

		//TestOnBorrow 是一个测试链接可用性的方法
		TestOnBorrow: func(c redis.Conn, t time.Time) error {
			_, err := c.Do("PING")
			return err
		},
	}
}

func close() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	signal.Notify(c, syscall.SIGTERM)
	signal.Notify(c, syscall.SIGKILL)
	go func() {
		<-c
		Pool.Close()
		os.Exit(0)
	}()
}

func Get(key string) ([]byte, error) {
	conn := Pool.Get()
	defer conn.Close()

	var data []byte
	data, err := redis.Bytes(conn.Do("GET", key))
	if err != nil {
		return data, fmt.Errorf("error get key %s: %v", key, err)
	}
	return data, err
}

func MGet(key ...interface{}) ([]string, error) {
	conn := Pool.Get()
	defer conn.Close()

	var data []string
	data, err := redis.Strings(conn.Do("MGET", key...))

	if err != nil {
		return data, fmt.Errorf("error get key %s: %v", key, err)
	}
	return data, err
}

func Set(key string, value interface{}, args ...interface{}) ([]byte, error) {
	args_len := len(args)
	new_args := make([]interface{}, args_len+2)
	copy(new_args[2:], args)
	new_args[0] = key
	new_args[1] = value

	conn := Pool.Get()
	defer conn.Close()
	var data []byte
	data, err := redis.Bytes(conn.Do("SET", new_args...))
	if err != nil {
		return data, fmt.Errorf("error get key %s: %v", key, err)
	}
	return data, err
}

func Mset(args ...interface{}) ([]byte, error) {
	conn := Pool.Get()
	defer conn.Close()

	var data []byte
	data, err := redis.Bytes(conn.Do("MSET", args...))
	if err != nil {
		return data, fmt.Errorf("error get key: %v", err)
	}
	return data, err
}

// DEL 
func Del(key string) (int64, error) {
	conn := Pool.Get()
	defer conn.Close()
	var data int64
	data, err := redis.Int64(conn.Do("DEL", key))

	if err != nil {
		return data, fmt.Errorf("error get key %s: %v", key, err)
	}
	return data, nil
}

//设置过期时间(毫秒级)
func Pexp(key string, timeint int64) (int64, error) {
	conn := Pool.Get()
	defer conn.Close()
	data, err := redis.Int64(conn.Do("PEXPIRE", key, timeint))

	if err != nil {
		return data, fmt.Errorf("error get key %s: %v", key, err)
	}
	return data, nil
}

//同一个类型的操作只需要一个conn.Receive()接受
//不同的操作需要多个conn.Receive()
//只支持SET功能
func Pipe(mapdata map[string][]map[string]interface{}) (interface{}, error) {
	conn := Pool.Get()
	defer conn.Close()

	senddata := []interface{}{"test", 1}
	for _, v := range mapdata {
		for _, sdata := range v {
			senddata = []interface{}{}
			for sk, sv := range sdata {
				senddata = append(senddata, sk)
				senddata = append(senddata, sv)
			}
			fmt.Println(senddata)
			conn.Send("SET", senddata...)
		}
	}
	conn.Flush()
	data, err := conn.Receive()
	if err != nil {
		return data, fmt.Errorf("error get key : %v", err)
	}
	return data, nil
}

func main() {
	// set 数据
	// v, err := Set("test", 3, "EX", "180")
	// if err != nil {
	// 	fmt.Println(err)
	// 	return
	// }
	// data := string(v[:])
	// fmt.Println(data)

	// mset 数据
	// v, err := Mset("test", 2, "test1", "2")
	// if err != nil {
	// 	fmt.Println(err)
	// 	return
	// }
	// data := string(v[:])
	// fmt.Println(data)

	// get 数据
	// v, err := Get("pool")
	// data := string(v[:])
	// fmt.Println(data, err)

	//MGET 数据
	// v, err := MGet("test", "test1")
	// fmt.Println(v, err)

	//批量获取数据
	// key_data := []string{}
	// fmt.Println(key_data)
	// v, err := MGet()
	// data := string(v[:])
	// fmt.Println(data, err)

	//删除数据
	// v, err := Del("test1")
	// fmt.Println(v, err)

	//修改过期时间（毫秒级）
	// v, err := Pexp("test1", 100000)
	// if v == 1 {
	// 	fmt.Println("修改成功")
	// }
	// fmt.Println(v, err)

	mapa := map[string][]map[string]interface{}{}
	mapb := map[string]interface{}{"test": 1, "EX": "1000"}
	mapc := map[string]interface{}{"test1": 2, "EX": "1000"}
	mapa["SET"] = append(mapa["SET"], mapb)
	mapa["SET"] = append(mapa["SET"], mapc)

	v, err := Pipe(mapa)
	fmt.Println(v, err)

}

有疑问加站长微信联系（非本文作者）