golang redis连接池的使用

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "time"

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

const (
    RedisURL            = "redis://*****:6379"
    redisMaxIdle        = 3   //最大空闲连接数
    redisIdleTimeoutSec = 240 //最大空闲连接时间
    RedisPassword       = "*****"
)

// NewRedisPool 返回redis连接池
func NewRedisPool(redisURL string) *redis.Pool {
    return &redis.Pool{
        MaxIdle:     redisMaxIdle,
        IdleTimeout: redisIdleTimeoutSec * time.Second,
        Dial: func() (redis.Conn, error) {
            c, err := redis.DialURL(redisURL)
            if err != nil {
                return nil, fmt.Errorf("redis connection error: %s", err)
            }
            //验证redis密码
            if _, authErr := c.Do("AUTH", RedisPassword); authErr != nil {
                return nil, fmt.Errorf("redis auth password error: %s", authErr)
            }
            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            if err != nil {
                return fmt.Errorf("ping redis error: %s", err)
            }
            return nil
        },
    }
}

func set(k, v string) {
    c := NewRedisPool(RedisURL).Get()
    defer c.Close()
    _, err := c.Do("SET", k, v)
    if err != nil {
        fmt.Println("set error", err.Error())
    }
}

func getStringValue(k string) string {
    c := NewRedisPool(RedisURL).Get()
    defer c.Close()
    username, err := redis.String(c.Do("GET", k))
    if err != nil {
        fmt.Println("Get Error: ", err.Error())
        return ""
    }
    return username
}

func SetKeyExpire(k string, ex int) {
    c := NewRedisPool(RedisURL).Get()
    defer c.Close()
    _, err := c.Do("EXPIRE", k, ex)
    if err != nil {
        fmt.Println("set error", err.Error())
    }
}

func CheckKey(k string) bool {
    c := NewRedisPool(RedisURL).Get()
    defer c.Close()
    exist, err := redis.Bool(c.Do("EXISTS", k))
    if err != nil {
        fmt.Println(err)
        return false
    } else {
        return exist
    }
}

func DelKey(k string) error {
    c := NewRedisPool(RedisURL).Get()
    defer c.Close()
    _, err := c.Do("DEL", k)
    if err != nil {
        fmt.Println(err)
        return err
    }
    return nil
}

func SetJson(k string, data interface{}) error {
    c := NewRedisPool(RedisURL).Get()
    defer c.Close()
    value, _ := json.Marshal(data)
    n, _ := c.Do("SETNX", k, value)
    if n != int64(1) {
        return errors.New("set failed")
    }
    return nil
}

func getJsonByte(k string) ([]byte, error) {
    jsonGet, err := redis.Bytes(c.Do("GET", key))
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    return jsonGet, nil
}