A tiny example API written in Go using Martini and Redigo

api.go

package main

import (
	"flag"
	"fmt"
	"net/http"

	"github.com/codegangsta/martini"
	"github.com/garyburd/redigo/redis"
	"github.com/martini-contrib/render"
)

var (
	redisAddress   = flag.String("redis-address", ":6379", "Address to the Redis server")
	maxConnections = flag.Int("max-connections", 10, "Max connections to Redis")
)

func main() {
	martini.Env = martini.Prod

	flag.Parse()

	redisPool := redis.NewPool(func() (redis.Conn, error) {
		c, err := redis.Dial("tcp", *redisAddress)

		if err != nil {
			return nil, err
		}

		return c, err
	}, *maxConnections)

	defer redisPool.Close()

	m := martini.Classic()

	m.Map(redisPool)

	m.Use(render.Renderer())

	m.Get("/", func() string {
		return "Hello from Martini!"
	})

	m.Get("/set/:key", func(r render.Render, pool *redis.Pool, params martini.Params, req *http.Request) {
		key := params["key"]
		value := req.URL.Query().Get("value")

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

		status, err := c.Do("SET", key, value)

		if err != nil {
			message := fmt.Sprintf("Could not SET %s:%s", key, value)

			r.JSON(400, map[string]interface{}{
				"status":  "ERR",
				"message": message})
		} else {
			r.JSON(200, map[string]interface{}{
				"status": status})
		}
	})

	m.Get("/get/:key", func(r render.Render, pool *redis.Pool, params martini.Params) {
		key := params["key"]

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

		value, err := redis.String(c.Do("GET", key))

		if err != nil {
			message := fmt.Sprintf("Could not GET %s", key)

			r.JSON(400, map[string]interface{}{
				"status":  "ERR",
				"message": message})
		} else {
			r.JSON(200, map[string]interface{}{
				"status": "OK",
				"value":  value})
		}
	})

	m.Run()
}

You can just use m.Map(redisPool) to map the redis pool into your handlers and then just call redisPool.Get() to retrieve a connection, something like this:

func getFoo(render render.Render, pool *redis.Pool) {
    v, err := redis.Values(redisPool.Get().Do("HGETALL", "foo")) // or any redis command
    if err != nil {
        panic(err)
    }
    render.JSON(200, &v)
}

I too cannot map directly a *redis.Conn (it is backed as a *redis.conn which is not exported) into a handler, I have to use a connection pool, which is after all not a bad thing ;-)

@agrison Thank you, I’ve now updated the example.

Thank you for the example! I have it working saving some MySQL results, and I've made a middleware handler that seems to work fine:

func SetupRedis() *redis.Pool {
    redisPool := redis.NewPool(func() (redis.Conn, error) {
        c, err := redis.Dial("tcp", *redisAddress)

        PanicIf(err)

        return c, err
    }, *maxConnections)

    return redisPool
}

but when I have defer redisPool.Close() in the middleware function, it won't run redis commands in the controllers because the connection pool closes. When I remove defer redisPool.Close() it all works fine, doing some local tests looks like it's reusing the connection as it should without using defer redisPool.Close(), so I'm not sure if this is really an issue or not, any thoughts on this?

Disregard that last comment, here's what I did that keeps the main func a bit cleaner.

func SetupRedis() *redis.Pool {
    return redis.NewPool(func() (redis.Conn, error) {
        c, err := redis.Dial("tcp", *redisAddress)

        PanicIf(err)

        return c, err
    }, *maxConnections)
}

func main() {
        ...
    redisPool := SetupRedis()
    defer redisPool.Close()

    m.Map(redisPool)
        ...
}

Use the struct instead of the NewPool function.

NewPool creates a new pool. This function is deprecated. Applications should initialize the Pool fields directly as shown in example.

https://github.com/garyburd/redigo/blob/master/redis/pool.go#L89