Re-using Redigo connection instead of recreating it every time

Question

Connecting to Redigo and manipulating data inside a function is easy like butter, but the problem comes when you have to re-use its connection, obviously for performance/practicality reasons.

Doing it inside a function like this works:

func main() {

    client, err := redis.Dial("tcp", ":6379")
    if err != nil {
        panic(err)
    }
    defer client.Close()

    client.Do("GET", "test:1")
}

But bringing it outside doesn't:

var Client = redis.Dial("tcp", ":6379")
defer Client.Close()

func main() {

        Client.Do("GET", "test:1")
    }

With the following error(s) returned:

./main.go:1: multiple-value redis.Dial() in single-value context
./main.go:2: non-declaration statement outside function body

I've tried putting the connection as a const(ant), putting defer inside the main function to my dismay not working too.

This is an even bigger concern as I have many other functions that have to communicate to Redis, but recreating the connection to Redis everytime seems silly.

The Redigo API just shows how to create a Dial instance but doesn't go further by explaining how to re-use it.

You may've been lost in my talk, but I wanted to put a bit of context here, so my clear and concise question is: How do you go about re-using (not recreating everytime) a Redigo connection?

Answer 1

The best way turned out to be using Pools, which are briefly documented here: Redigo Pools.

A global variable won't eventually reuse a connection, so I ended up with something like this (using Pools as noted before):

func newPool() *redis.Pool {
return &redis.Pool{
            MaxIdle: 80,
            MaxActive: 12000, // max number of connections
            Dial: func() (redis.Conn, error) {
                    c, err := redis.Dial("tcp", ":6379")
                    if err != nil {
                            panic(err.Error())
                    }
                    return c, err
            },
    } 

}

var pool = newPool()

func main() {

        c := pool.Get()
        defer c.Close()

        test,_:=c.Do("HGETALL", "test:1")
        fmt.Println(test)
}

If for example you want to reuse a pool inside another function you do it like this:

func test() {
        c := pool.Get()
        defer c.Close()

        test2,_:=c.Do("HGETALL", "test:2")
        fmt.Println(test2)
}