如何让Redis与Go密切配合

$ go get github.com/mediocregopher/radix.v2

$ gogetgithub.com/mediocregopher/radix.v2 

import (     "github.com/mediocregopher/radix.v2/redis" )

import (     "github.com/mediocregopher/radix.v2/redis" ) 

127.0.0.1:6379> HMSET album:1 title "Electric Ladyland" artist "Jimi Hendrix" price 4.95 likes 8 OK

127.0.0.1:6379> HMSETalbum:1 title "Electric Ladyland" artist "Jimi Hendrix" price 4.95 likes 8 OK 

File: main.go package main  import (     "fmt"     // Import the Radix.v2 redis package.     "github.com/mediocregopher/radix.v2/redis"     "log" )  func main() {     // Establish a connection to the Redis server listening on port 6379 of the     // local machine. 6379 is the default port, so unless you've already     // changed the Redis configuration file this should work.     conn, err := redis.Dial("tcp", "localhost:6379")     if err != nil {         log.Fatal(err)     }     // Importantly, use defer to ensure the connection is always properly     // closed before exiting the main() function.     defer conn.Close()      // Send our command across the connection. The first parameter to Cmd()     // is always the name of the Redis command (in this example HMSET),     // optionally followed by any necessary arguments (in this example the     // key, followed by the various hash fields and values).     resp := conn.Cmd("HMSET", "album:1", "title", "Electric Ladyland", "artist", "Jimi Hendrix", "price", 4.95, "likes", 8)     // Check the Err field of the *Resp object for any errors.     if resp.Err != nil {         log.Fatal(resp.Err)     }      fmt.Println("Electric Ladyland added!") }

File: main.go package main   import (     "fmt"     // Import the Radix.v2 redis package.     "github.com/mediocregopher/radix.v2/redis"     "log" )   funcmain() {     // Establish a connection to the Redis server listening on port 6379 of the     // local machine. 6379 is the default port, so unless you've already     // changed the Redis configuration file this should work.     conn, err := redis.Dial("tcp", "localhost:6379")     if err != nil {         log.Fatal(err)     }     // Importantly, use defer to ensure the connection is always properly     // closed before exiting the main() function.     deferconn.Close()       // Send our command across the connection. The first parameter to Cmd()     // is always the name of the Redis command (in this example HMSET),     // optionally followed by any necessary arguments (in this example the     // key, followed by the various hash fields and values).     resp := conn.Cmd("HMSET", "album:1", "title", "Electric Ladyland", "artist", "Jimi Hendrix", "price", 4.95, "likes", 8)     // Check the Err field of the *Resp object for any errors.     if resp.Err != nil {         log.Fatal(resp.Err)     }       fmt.Println("Electric Ladyland added!") } 

err = conn.Cmd("HMSET", "album:1", "title", "Electric Ladyland", "artist", "Jimi Hendrix", "price", 4.95, "likes", 8).Err if err != nil {     log.Fatal(err) }

err = conn.Cmd("HMSET", "album:1", "title", "Electric Ladyland", "artist", "Jimi Hendrix", "price", 4.95, "likes", 8).Err if err != nil {     log.Fatal(err) } 

package main  import (     "fmt"     "github.com/mediocregopher/radix.v2/redis"     "log" )  func main() {     conn, err := redis.Dial("tcp", "localhost:6379")     if err != nil {         log.Fatal(err)     }     defer conn.Close()      // Issue a HGET command to retrieve the title for a specific album, and use     // the Str() helper method to convert the reply to a string.     title, err := conn.Cmd("HGET", "album:1", "title").Str()     if err != nil {         log.Fatal(err)     }      // Similarly, get the artist and convert it to a string.     artist, err := conn.Cmd("HGET", "album:1", "artist").Str()     if err != nil {         log.Fatal(err)     }      // And the price as a float64...     price, err := conn.Cmd("HGET", "album:1", "price").Float64()     if err != nil {         log.Fatal(err)     }      // And the number of likes as an integer.     likes, err := conn.Cmd("HGET", "album:1", "likes").Int()     if err != nil {         log.Fatal(err)     }      fmt.Printf("%s by %s: £%.2f [%d likes]/n", title, artist, price, likes) }

package main   import (     "fmt"     "github.com/mediocregopher/radix.v2/redis"     "log" )   funcmain() {     conn, err := redis.Dial("tcp", "localhost:6379")     if err != nil {         log.Fatal(err)     }     deferconn.Close()       // Issue a HGET command to retrieve the title for a specific album, and use     // the Str() helper method to convert the reply to a string.     title, err := conn.Cmd("HGET", "album:1", "title").Str()     if err != nil {         log.Fatal(err)     }       // Similarly, get the artist and convert it to a string.     artist, err := conn.Cmd("HGET", "album:1", "artist").Str()     if err != nil {         log.Fatal(err)     }       // And the price as a float64...     price, err := conn.Cmd("HGET", "album:1", "price").Float64()     if err != nil {         log.Fatal(err)     }       // And the number of likes as an integer.     likes, err := conn.Cmd("HGET", "album:1", "likes").Int()     if err != nil {         log.Fatal(err)     }       fmt.Printf("%s by %s: £%.2f [%d likes]/n", title, artist, price, likes) } 

$ go run main.go Electric Ladyland by Jimi Hendrix: £4.95 [8 likes]

$ gorunmain.go ElectricLadylandbyJimiHendrix: £4.95 [8 likes] 

File: main.go package main  import (     "fmt"     "github.com/mediocregopher/radix.v2/redis"     "log"     "strconv" )  // Define a custom struct to hold Album data. type Album struct {     Title  string     Artist string     Price  float64     Likes  int }  func main() {     conn, err := redis.Dial("tcp", "localhost:6379")     if err != nil {         log.Fatal(err)     }     defer conn.Close()      // Fetch all album fields with the HGETALL command. Because HGETALL     // returns an array reply, and because the underlying data structure in     // Redis is a hash, it makes sense to use the Map() helper function to     // convert the reply to a map[string]string.     reply, err := conn.Cmd("HGETALL", "album:1").Map()     if err != nil {         log.Fatal(err)     }      // Use the populateAlbum helper function to create a new Album object from     // the map[string]string.     ab, err := populateAlbum(reply)     if err != nil {         log.Fatal(err)     }      fmt.Println(ab) }  // Create, populate and return a pointer to a new Album struct, based on data // from a map[string]string. func populateAlbum(reply map[string]string) (*Album, error) {     var err error     ab := new(Album)     ab.Title = reply["title"]     ab.Artist = reply["artist"]     // We need to use the strconv package to convert the 'price' value from a     // string to a float64 before assigning it.     ab.Price, err = strconv.ParseFloat(reply["price"], 64)     if err != nil {         return nil, err     }     // Similarly, we need to convert the 'likes' value from a string to an     // integer.     ab.Likes, err = strconv.Atoi(reply["likes"])     if err != nil {         return nil, err     }     return ab, nil }

File: main.go package main   import (     "fmt"     "github.com/mediocregopher/radix.v2/redis"     "log"     "strconv" )   // Define a custom struct to hold Album data. type Album struct {     Title  string     Artiststring     Price  float64     Likes  int }   funcmain() {     conn, err := redis.Dial("tcp", "localhost:6379")     if err != nil {         log.Fatal(err)     }     deferconn.Close()       // Fetch all album fields with the HGETALL command. Because HGETALL     // returns an array reply, and because the underlying data structure in     // Redis is a hash, it makes sense to use the Map() helper function to     // convert the reply to a map[string]string.     reply, err := conn.Cmd("HGETALL", "album:1").Map()     if err != nil {         log.Fatal(err)     }       // Use the populateAlbum helper function to create a new Album object from     // the map[string]string.     ab, err := populateAlbum(reply)     if err != nil {         log.Fatal(err)     }       fmt.Println(ab) }   // Create, populate and return a pointer to a new Album struct, based on data // from a map[string]string. funcpopulateAlbum(replymap[string]string) (*Album, error) {     var errerror     ab := new(Album)     ab.Title = reply["title"]     ab.Artist = reply["artist"]     // We need to use the strconv package to convert the 'price' value from a     // string to a float64 before assigning it.     ab.Price, err = strconv.ParseFloat(reply["price"], 64)     if err != nil {         return nil, err     }     // Similarly, we need to convert the 'likes' value from a string to an     // integer.     ab.Likes, err = strconv.Atoi(reply["likes"])     if err != nil {         return nil, err     }     return ab, nil } 

$ go run main.go &{Electric Ladyland Jimi Hendrix 4.95 8}

$ gorunmain.go &{ElectricLadylandJimiHendrix 4.95 8} 

$ cd $GOPATH/src $ mkdir -p recordstore/models $ cd recordstore $ touch main.go models/albums.go $ tree . ├── main.go └── models     └── albums.go

$ cd $GOPATH/src $ mkdir -p recordstore/models $ cdrecordstore $ touchmain.gomodels/albums.go $ tree . ├── main.go └── models     └── albums.go 

HMSET album:1 title "Electric Ladyland" artist "Jimi Hendrix" price 4.95 likes 8 HMSET album:2 title "Back in Black" artist "AC/DC" price 5.95 likes 3 HMSET album:3 title "Rumours" artist "Fleetwood Mac" price 7.95 likes 12 HMSET album:4 title "Nevermind" artist "Nirvana" price 5.95 likes 8 ZADD likes 8 1 3 2 12 3 8 4

HMSETalbum:1 title "Electric Ladyland" artist "Jimi Hendrix" price 4.95 likes 8 HMSETalbum:2 title "Back in Black" artist "AC/DC" price 5.95 likes 3 HMSETalbum:3 title "Rumours" artist "Fleetwood Mac" price 7.95 likes 12 HMSETalbum:4 title "Nevermind" artist "Nirvana" price 5.95 likes 8 ZADDlikes 8 1 3 2 12 3 8 4 

File: models/albums.go package models  import (     "errors"     // Import the Radix.v2 pool package, NOT the redis package.     "github.com/mediocregopher/radix.v2/pool"     "log"     "strconv" )  // Declare a global db variable to store the Redis connection pool. var db *pool.Pool  func init() {     var err error     // Establish a pool of 10 connections to the Redis server listening on     // port 6379 of the local machine.     db, err = pool.New("tcp", "localhost:6379", 10)     if err != nil {         log.Panic(err)     } }  // Create a new error message and store it as a constant. We'll use this // error later if the FindAlbum() function fails to find an album with a // specific id. var ErrNoAlbum = errors.New("models: no album found")  type Album struct {     Title  string     Artist string     Price  float64     Likes  int }  func populateAlbum(reply map[string]string) (*Album, error) {     var err error     ab := new(Album)     ab.Title = reply["title"]     ab.Artist = reply["artist"]     ab.Price, err = strconv.ParseFloat(reply["price"], 64)     if err != nil {         return nil, err     }     ab.Likes, err = strconv.Atoi(reply["likes"])     if err != nil {         return nil, err     }     return ab, nil }  func FindAlbum(id string) (*Album, error) {     // Use the connection pool's Get() method to fetch a single Redis     // connection from the pool.     conn, err := db.Get()     if err != nil {         return nil, err     }     // Importantly, use defer and the connection pool's Put() method to ensure     // that the connection is always put back in the pool before FindAlbum()     // exits.     defer db.Put(conn)      // Fetch the details of a specific album. If no album is found with the     // given id, the map[string]string returned by the Map() helper method     // will be empty. So we can simply check whether it's length is zero and     // return an ErrNoAlbum message if necessary.     reply, err := conn.Cmd("HGETALL", "album:"+id).Map()     if err != nil {         return nil, err     } else if len(reply) == 0 {         return nil, ErrNoAlbum     }      return populateAlbum(reply) }

File: models/albums.go package models   import (     "errors"     // Import the Radix.v2 pool package, NOT the redis package.     "github.com/mediocregopher/radix.v2/pool"     "log"     "strconv" )   // Declare a global db variable to store the Redis connection pool. var db *pool.Pool   funcinit() {     var errerror     // Establish a pool of 10 connections to the Redis server listening on     // port 6379 of the local machine.     db, err = pool.New("tcp", "localhost:6379", 10)     if err != nil {         log.Panic(err)     } }   // Create a new error message and store it as a constant. We'll use this // error later if the FindAlbum() function fails to find an album with a // specific id. var ErrNoAlbum = errors.New("models: no album found")   type Album struct {     Title  string     Artiststring     Price  float64     Likes  int }   funcpopulateAlbum(replymap[string]string) (*Album, error) {     var errerror     ab := new(Album)     ab.Title = reply["title"]     ab.Artist = reply["artist"]     ab.Price, err = strconv.ParseFloat(reply["price"], 64)     if err != nil {         return nil, err     }     ab.Likes, err = strconv.Atoi(reply["likes"])     if err != nil {         return nil, err     }     return ab, nil }   funcFindAlbum(idstring) (*Album, error) {     // Use the connection pool's Get() method to fetch a single Redis     // connection from the pool.     conn, err := db.Get()     if err != nil {         return nil, err     }     // Importantly, use defer and the connection pool's Put() method to ensure     // that the connection is always put back in the pool before FindAlbum()     // exits.     deferdb.Put(conn)       // Fetch the details of a specific album. If no album is found with the     // given id, the map[string]string returned by the Map() helper method     // will be empty. So we can simply check whether it's length is zero and     // return an ErrNoAlbum message if necessary.     reply, err := conn.Cmd("HGETALL", "album:"+id).Map()     if err != nil {         return nil, err     } else if len(reply) == 0 {         return nil, ErrNoAlbum     }       return populateAlbum(reply) } 

func FindAlbum(id string) (*Album, error) {     reply, err := db.Cmd("HGETALL", "album:"+id).Map()     if err != nil {         return nil, err     } else if len(reply) == 0 {         return nil, ErrNoAlbum     }      return populateAlbum(reply) }

funcFindAlbum(idstring) (*Album, error) {     reply, err := db.Cmd("HGETALL", "album:"+id).Map()     if err != nil {         return nil, err     } else if len(reply) == 0 {         return nil, ErrNoAlbum     }       return populateAlbum(reply) } 

File: main.go package main  import (     "fmt"     "net/http"     "recordstore/models"     "strconv" )  func main() {     // Use the showAlbum handler for all requests with a URL path beginning     // '/album'.     http.HandleFunc("/album", showAlbum)     http.ListenAndServe(":3000", nil) }  func showAlbum(w http.ResponseWriter, r *http.Request) {     // Unless the request is using the GET method, return a 405 'Method Not     // Allowed' response.     if r.Method != "GET" {         w.Header().Set("Allow", "GET")         http.Error(w, http.StatusText(405), 405)         return     }      // Retrieve the id from the request URL query string. If there is no id     // key in the query string then Get() will return an empty string. We     // check for this, returning a 400 Bad Request response if it's missing.     id := r.URL.Query().Get("id")     if id == "" {         http.Error(w, http.StatusText(400), 400)         return     }     // Validate that the id is a valid integer by trying to convert it,     // returning a 400 Bad Request response if the conversion fails.     if _, err := strconv.Atoi(id); err != nil {         http.Error(w, http.StatusText(400), 400)         return     }      // Call the FindAlbum() function passing in the user-provided id. If     // there's no matching album found, return a 404 Not Found response. In     // the event of any other errors, return a 500 Internal Server Error     // response.     bk, err := models.FindAlbum(id)     if err == models.ErrNoAlbum {         http.NotFound(w, r)         return     } else if err != nil {         http.Error(w, http.StatusText(500), 500)         return     }      // Write the album details as plain text to the client.     fmt.Fprintf(w, "%s by %s: £%.2f [%d likes] /n", bk.Title, bk.Artist, bk.Price, bk.Likes) }

File: main.go package main   import (     "fmt"     "net/http"     "recordstore/models"     "strconv" )   funcmain() {     // Use the showAlbum handler for all requests with a URL path beginning     // '/album'.     http.HandleFunc("/album", showAlbum)     http.ListenAndServe(":3000", nil) }   funcshowAlbum(w http.ResponseWriter, r *http.Request) {     // Unless the request is using the GET method, return a 405 'Method Not     // Allowed' response.     if r.Method != "GET" {         w.Header().Set("Allow", "GET")         http.Error(w, http.StatusText(405), 405)         return     }       // Retrieve the id from the request URL query string. If there is no id     // key in the query string then Get() will return an empty string. We     // check for this, returning a 400 Bad Request response if it's missing.     id := r.URL.Query().Get("id")     if id == "" {         http.Error(w, http.StatusText(400), 400)         return     }     // Validate that the id is a valid integer by trying to convert it,     // returning a 400 Bad Request response if the conversion fails.     if _, err := strconv.Atoi(id); err != nil {         http.Error(w, http.StatusText(400), 400)         return     }       // Call the FindAlbum() function passing in the user-provided id. If     // there's no matching album found, return a 404 Not Found response. In     // the event of any other errors, return a 500 Internal Server Error     // response.     bk, err := models.FindAlbum(id)     if err == models.ErrNoAlbum {         http.NotFound(w, r)         return     } else if err != nil {         http.Error(w, http.StatusText(500), 500)         return     }       // Write the album details as plain text to the client.     fmt.Fprintf(w, "%s by %s: £%.2f [%d likes] /n", bk.Title, bk.Artist, bk.Price, bk.Likes) } 

$ go run main.go

$ gorunmain.go 

$ curl -i localhost:3000/album?id=2 HTTP/1.1 200 OK Content-Length: 42 Content-Type: text/plain; charset=utf-8  Back in Black by AC/DC: £5.95 [3 likes]

$ curl -i localhost:3000/album?id=2 HTTP/1.1 200 OK Content-Length: 42 Content-Type: text/plain; charset=utf-8   Backin BlackbyAC/DC: £5.95 [3 likes] 

File: models/albums.go ... func IncrementLikes(id string) error {     conn, err := db.Get()     if err != nil {         return err     }     defer db.Put(conn)      // Before we do anything else, check that an album with the given id     // exists. The EXISTS command returns 1 if a specific key exists     // in the database, and 0 if it doesn't.     exists, err := conn.Cmd("EXISTS", "album:"+id).Int()     if err != nil {         return err     } else if exists == 0 {         return ErrNoAlbum     }      // Use the MULTI command to inform Redis that we are starting a new     // transaction.     err = conn.Cmd("MULTI").Err     if err != nil {         return err     }      // Increment the number of likes in the album hash by 1. Because it     // follows a MULTI command, this HINCRBY command is NOT executed but     // it is QUEUED as part of the transaction. We still need to check     // the reply's Err field at this point in case there was a problem     // queueing the command.     err = conn.Cmd("HINCRBY", "album:"+id, "likes", 1).Err     if err != nil {         return err     }     // And we do the same with the increment on our sorted set.     err = conn.Cmd("ZINCRBY", "likes", 1, id).Err     if err != nil {         return err     }      // Execute both commands in our transaction together as an atomic group.     // EXEC returns the replies from both commands as an array reply but,     // because we're not interested in either reply in this example, it     // suffices to simply check the reply's Err field for any errors.     err = conn.Cmd("EXEC").Err     if err != nil {         return err     }     return nil }

File: models/albums.go ... funcIncrementLikes(idstring) error {     conn, err := db.Get()     if err != nil {         return err     }     deferdb.Put(conn)       // Before we do anything else, check that an album with the given id     // exists. The EXISTS command returns 1 if a specific key exists     // in the database, and 0 if it doesn't.     exists, err := conn.Cmd("EXISTS", "album:"+id).Int()     if err != nil {         return err     } else if exists == 0 {         return ErrNoAlbum     }       // Use the MULTI command to inform Redis that we are starting a new     // transaction.     err = conn.Cmd("MULTI").Err     if err != nil {         return err     }       // Increment the number of likes in the album hash by 1. Because it     // follows a MULTI command, this HINCRBY command is NOT executed but     // it is QUEUED as part of the transaction. We still need to check     // the reply's Err field at this point in case there was a problem     // queueing the command.     err = conn.Cmd("HINCRBY", "album:"+id, "likes", 1).Err     if err != nil {         return err     }     // And we do the same with the increment on our sorted set.     err = conn.Cmd("ZINCRBY", "likes", 1, id).Err     if err != nil {         return err     }       // Execute both commands in our transaction together as an atomic group.     // EXEC returns the replies from both commands as an array reply but,     // because we're not interested in either reply in this example, it     // suffices to simply check the reply's Err field for any errors.     err = conn.Cmd("EXEC").Err     if err != nil {         return err     }     return nil } 

File: main.go func main() {     http.HandleFunc("/album", showAlbum)     http.HandleFunc("/like", addLike)     http.ListenAndServe(":3000", nil) } ... func addLike(w http.ResponseWriter, r *http.Request) {     // Unless the request is using the POST method, return a 405 'Method Not     // Allowed' response.     if r.Method != "POST" {         w.Header().Set("Allow", "POST")         http.Error(w, http.StatusText(405), 405)         return     }      // Retreive the id from the POST request body. If there is no parameter     // named "id" in the request body then PostFormValue() will return an     // empty string. We check for this, returning a 400 Bad Request response     // if it's missing.     id := r.PostFormValue("id")     if id == "" {         http.Error(w, http.StatusText(400), 400)         return     }     // Validate that the id is a valid integer by trying to convert it,     // returning a 400 Bad Request response if the conversion fails.     if _, err := strconv.Atoi(id); err != nil {         http.Error(w, http.StatusText(400), 400)         return     }      // Call the IncrementLikes() function passing in the user-provided id. If     // there's no album found with that id, return a 404 Not Found response.     // In the event of any other errors, return a 500 Internal Server Error     // response.     err := models.IncrementLikes(id)     if err == models.ErrNoAlbum {         http.NotFound(w, r)         return     } else if err != nil {         http.Error(w, http.StatusText(500), 500)         return     }      // Redirect the client to the GET /ablum route, so they can see the     // impact their like has had.     http.Redirect(w, r, "/album?id="+id, 303) }

File: main.go funcmain() {     http.HandleFunc("/album", showAlbum)     http.HandleFunc("/like", addLike)     http.ListenAndServe(":3000", nil) } ... funcaddLike(w http.ResponseWriter, r *http.Request) {     // Unless the request is using the POST method, return a 405 'Method Not     // Allowed' response.     if r.Method != "POST" {         w.Header().Set("Allow", "POST")         http.Error(w, http.StatusText(405), 405)         return     }       // Retreive the id from the POST request body. If there is no parameter     // named "id" in the request body then PostFormValue() will return an     // empty string. We check for this, returning a 400 Bad Request response     // if it's missing.     id := r.PostFormValue("id")     if id == "" {         http.Error(w, http.StatusText(400), 400)         return     }     // Validate that the id is a valid integer by trying to convert it,     // returning a 400 Bad Request response if the conversion fails.     if _, err := strconv.Atoi(id); err != nil {         http.Error(w, http.StatusText(400), 400)         return     }       // Call the IncrementLikes() function passing in the user-provided id. If     // there's no album found with that id, return a 404 Not Found response.     // In the event of any other errors, return a 500 Internal Server Error     // response.     err := models.IncrementLikes(id)     if err == models.ErrNoAlbum {         http.NotFound(w, r)         return     } else if err != nil {         http.Error(w, http.StatusText(500), 500)         return     }       // Redirect the client to the GET /ablum route, so they can see the     // impact their like has had.     http.Redirect(w, r, "/album?id="+id, 303) } 

$ curl -i -L -d "id=2" localhost:3000/like HTTP/1.1 303 See Other Location: /album?id=2 Date: Thu, 25 Feb 2016 17:08:19 GMT Content-Length: 0 Content-Type: text/plain; charset=utf-8  HTTP/1.1 200 OK Content-Length: 42 Content-Type: text/plain; charset=utf-8  Back in Black by AC/DC: £5.95 [4 likes]

$ curl -i -L -d "id=2" localhost:3000/like HTTP/1.1 303 SeeOther Location: /album?id=2 Date: Thu, 25 Feb 2016 17:08:19 GMT Content-Length: 0 Content-Type: text/plain; charset=utf-8   HTTP/1.1 200 OK Content-Length: 42 Content-Type: text/plain; charset=utf-8   Backin BlackbyAC/DC: £5.95 [4 likes] 

File: models/albums.go package models  import (     "errors"     "github.com/mediocregopher/radix.v2/pool"     // Import the Radix.v2 redis package (we need access to its Nil type).     "github.com/mediocregopher/radix.v2/redis"     "log"     "strconv" ) ... func FindTopThree() ([]*Album, error) {     conn, err := db.Get()     if err != nil {         return nil, err     }     defer db.Put(conn)      // Begin an infinite loop.     for {         // Instruct Redis to watch the likes sorted set for any changes.         err = conn.Cmd("WATCH", "likes").Err         if err != nil {             return nil, err         }          // Use the ZREVRANGE command to fetch the album ids with the highest         // score (i.e. most likes) from our 'likes' sorted set. The ZREVRANGE         // start and stop values are zero-based indexes, so we use 0 and 2         // respectively to limit the reply to the top three. Because ZREVRANGE         // returns an array response, we use the List() helper function to         // convert the reply into a []string.         reply, err := conn.Cmd("ZREVRANGE", "likes", 0, 2).List()         if err != nil {             return nil, err         }          // Use the MULTI command to inform Redis that we are starting a new         // transaction.         err = conn.Cmd("MULTI").Err         if err != nil {             return nil, err         }          // Loop through the ids returned by ZREVRANGE, queuing HGETALL         // commands to fetch the individual album details.         for _, id := range reply {             err := conn.Cmd("HGETALL", "album:"+id).Err             if err != nil {                 return nil, err             }         }          // Execute the transaction. Importantly, use the Resp.IsType() method         // to check whether the reply from EXEC was nil or not. If it is nil         // it means that another client changed the WATCHed likes sorted set,         // so we use the continue command to re-run the loop.         ereply := conn.Cmd("EXEC")         if ereply.Err != nil {             return nil, err         } else if ereply.IsType(redis.Nil) {             continue         }          // Otherwise, use the Array() helper function to convert the         // transaction reply to an array of Resp objects ([]*Resp).         areply, err := ereply.Array()         if err != nil {             return nil, err         }          // Create a new slice to store the album details.         abs := make([]*Album, 3)          // Iterate through the array of Resp objects, using the Map() helper         // to convert the individual reply into a map[string]string, and then         // the populateAlbum function to create a new Album object         // from the map. Finally store them in order in the abs slice.         for i, reply := range areply {             mreply, err := reply.Map()             if err != nil {                 return nil, err             }             ab, err := populateAlbum(mreply)             if err != nil {                 return nil, err             }             abs[i] = ab         }          return abs, nil     } }

File: models/albums.go package models   import (     "errors"     "github.com/mediocregopher/radix.v2/pool"     // Import the Radix.v2 redis package (we need access to its Nil type).     "github.com/mediocregopher/radix.v2/redis"     "log"     "strconv" ) ... funcFindTopThree() ([]*Album, error) {     conn, err := db.Get()     if err != nil {         return nil, err     }     deferdb.Put(conn)       // Begin an infinite loop.     for {         // Instruct Redis to watch the likes sorted set for any changes.         err = conn.Cmd("WATCH", "likes").Err         if err != nil {             return nil, err         }           // Use the ZREVRANGE command to fetch the album ids with the highest         // score (i.e. most likes) from our 'likes' sorted set. The ZREVRANGE         // start and stop values are zero-based indexes, so we use 0 and 2         // respectively to limit the reply to the top three. Because ZREVRANGE         // returns an array response, we use the List() helper function to         // convert the reply into a []string.         reply, err := conn.Cmd("ZREVRANGE", "likes", 0, 2).List()         if err != nil {             return nil, err         }           // Use the MULTI command to inform Redis that we are starting a new         // transaction.         err = conn.Cmd("MULTI").Err         if err != nil {             return nil, err         }           // Loop through the ids returned by ZREVRANGE, queuing HGETALL         // commands to fetch the individual album details.         for _, id := range reply {             err := conn.Cmd("HGETALL", "album:"+id).Err             if err != nil {                 return nil, err             }         }           // Execute the transaction. Importantly, use the Resp.IsType() method         // to check whether the reply from EXEC was nil or not. If it is nil         // it means that another client changed the WATCHed likes sorted set,         // so we use the continue command to re-run the loop.         ereply := conn.Cmd("EXEC")         if ereply.Err != nil {             return nil, err         } else if ereply.IsType(redis.Nil) {             continue         }           // Otherwise, use the Array() helper function to convert the         // transaction reply to an array of Resp objects ([]*Resp).         areply, err := ereply.Array()         if err != nil {             return nil, err         }           // Create a new slice to store the album details.         abs := make([]*Album, 3)           // Iterate through the array of Resp objects, using the Map() helper         // to convert the individual reply into a map[string]string, and then         // the populateAlbum function to create a new Album object         // from the map. Finally store them in order in the abs slice.         for i, reply := range areply {             mreply, err := reply.Map()             if err != nil {                 return nil, err             }             ab, err := populateAlbum(mreply)             if err != nil {                 return nil, err             }             abs[i] = ab         }           return abs, nil     } } 

File: main.go func main() {     http.HandleFunc("/album", showAlbum)     http.HandleFunc("/like", addLike)     http.HandleFunc("/popular", listPopular)     http.ListenAndServe(":3000", nil) } ... func listPopular(w http.ResponseWriter, r *http.Request) {   // Unless the request is using the GET method, return a 405 'Method Not   // Allowed' response.   if r.Method != "GET" {     w.Header().Set("Allow", "GET")     http.Error(w, http.StatusText(405), 405)     return   }    // Call the FindTopThree() function, returning a return a 500 Internal   // Server Error response if there's any error.   abs, err := models.FindTopThree()   if err != nil {     http.Error(w, http.StatusText(500), 500)     return   }    // Loop through the 3 albums, writing the details as a plain text list   // to the client.   for i, ab := range abs {     fmt.Fprintf(w, "%d) %s by %s: £%.2f [%d likes] /n", i+1, ab.Title, ab.Artist, ab.Price, ab.Likes)   } }

File: main.go funcmain() {     http.HandleFunc("/album", showAlbum)     http.HandleFunc("/like", addLike)     http.HandleFunc("/popular", listPopular)     http.ListenAndServe(":3000", nil) } ... funclistPopular(w http.ResponseWriter, r *http.Request) {   // Unless the request is using the GET method, return a 405 'Method Not   // Allowed' response.   if r.Method != "GET" {     w.Header().Set("Allow", "GET")     http.Error(w, http.StatusText(405), 405)     return   }     // Call the FindTopThree() function, returning a return a 500 Internal   // Server Error response if there's any error.   abs, err := models.FindTopThree()   if err != nil {     http.Error(w, http.StatusText(500), 500)     return   }     // Loop through the 3 albums, writing the details as a plain text list   // to the client.   for i, ab := range abs {     fmt.Fprintf(w, "%d) %s by %s: £%.2f [%d likes] /n", i+1, ab.Title, ab.Artist, ab.Price, ab.Likes)   } } 

$ curl -i localhost:3000/popular HTTP/1.1 200 OK Content-Length: 147 Content-Type: text/plain; charset=utf-8  1) Rumours by Fleetwood Mac: £7.95 [12 likes] 2) Nevermind by Nirvana: £5.95 [8 likes] 3) Electric Ladyland by Jimi Hendrix: £4.95 [8 likes]

$ curl -i localhost:3000/popular HTTP/1.1 200 OK Content-Length: 147 Content-Type: text/plain; charset=utf-8   1) RumoursbyFleetwoodMac: £7.95 [12 likes] 2) NevermindbyNirvana: £5.95 [8 likes] 3) ElectricLadylandbyJimiHendrix: £4.95 [8 likes]