Redis är en förkortning för remote dictionary server. Det är ett datastrukturlager i minnet som stöder listor, strängar, kartor, sekvenser, uppsättningar och andra strukturer för lagring av abstrakta data.
Redis är en fullständig databasmästare, men det är NoSQL. Det är en av de mest älskade NoSQL-lösningarna och en av de mest populära nyckel-värde-databaserna. För det mesta används Redis för sessionscache, sidcache, meddelandekö.
I grund och botten är den här databasen bättre för cachelagring eftersom den låter dig konfigurera hur länge data ska lagras och vilken data som ska renas först. Redis är också känt för att vara snabb och högpresterande, vilket gör den perfekt för cachningsuppgifter.
Innan du ansluter till en Redis-databas, se först till att du har Redis and Go installerat på din Mac.Du kan använda Redis Docker-avbildningen istället för att ha Redis direkt på din maskin om du vill.
Du måste också installera ir-redis, en Redis-klient för Go.
Börja med att initiera Go-modulen med detta kommando:
go mod init github.com/my/repo
Installera sedan go-redis, ett av de två mest populära paketen för gränssnitt med Redis på Golang:
go get github.com/go-redis/redis/v8
Anslut till en Redis-databas
Börja med att se till att din Docker Redis-behållare körs:
Annars kör du Redis Docker-behållaren:
docker run -d -p 6379:6379 redislabs/redismod
Nu kan vi införliva vår kod för att installera go-redis från föregående steg i vår process:
go get github.com/go-redis/redis/v8
Innan vårt sista steg måste vi skapa en main.go-fil med vårt nuvarande program. Vi använder följande kod:
package main
import (
"fmt"
"github.com/go-redis/redis"
)
func main() {
fmt.Println("We are testing Go-Redis")
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
}
För att skriva vårt Go-program använde vi CodeRunner, en app för blixtsnabb kodning på över 25 språk, inklusive Go.
Du kan använda CodeRunner eller ett annat redigeringsprogram.
Ändra din katalog i Terminal med cd-kommandot så att den ligger i samma mapp som din main.go-fil från föregående steg, och låt sedan Go köra filen för att upprätta anslutningen med go run main.go-kommandot.
Du bör få ett PONG-svar om anslutningen lyckas:
Interagera med Redis-databaser
Grunderna för att interagera med en Redis-databas kretsar kring setet och få kommandon.
Här är koden för att ställa in ett värde i en Redis-databas:
err = client.Set("name", "Billie", 0).Err()
if err != nil {
fmt.Println(err)
}
För att vara säker på att du gör allt rätt kan du också bädda in get-koden i ditt program och få värdet du just lagt till utskrivet.
Här är den fullständiga koden vi använder för den åtgärden i vårt Go-program:
package main
import (
"fmt"
"github.com/go-redis/redis"
)
func main() {
fmt.Println("We are testing Go-Redis")
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
if err != nil {return}
err = client.Set("name", "Billie", 0).Err()
if err != nil {
fmt.Println(err)
return
}
val, err := client.Get("name").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(val)
}
För att spara dina kodavsnitt för senare, kan du använda SnippetsLab, en app designad speciellt för uppgiften. Du kan behålla dina kodbitar där för enkel åtkomst när du behöver dem:
Du kan också spara dem som vanliga textfiler, men vi föredrar SnippetsLab så att vi bättre kan strukturera våra utdrag.
Se också till att lagra kodexempel, eftersom ibland när du modifierar dem kan du oavsiktligt introducera en bugg, och det är bra att ha en originalreferens som fungerade innan du modifierade den.
Konfigurera utgångstiden för Redis databasvärden
En av de mest värdefulla funktionerna i Redis in-memory-databasen är att den låter dig lagra dina värden med ett utgångsdatum. I våra exempel ovan använde vi 0 för att undvika att ställa in varaktigheten för att lagra vårt inställda värde, men vad händer när vi gör det?
Här är motsvarande kodrad för det:
err = client.Set("name", "Tom", time.Second*5).Err()
Hur kan vi verifiera att säkerheten förfaller inom vår fastställda tidsram? Det finns några sätt att göra detta, men med vårt exempel är det enklaste sättet att kontrollera med denna kodrad:
time.Sleep(time.Second*6)
Det tillåter oss att be vårt program att vänta en viss tid innan vi får vårt inställda värde. Om vi ställer in tiden på mindre än 5 sekunder får vi tillbaka Tom. Men när tiden är mer än så får vi ingenting tillbaka:
package main
import (
"fmt"
"github.com/go-redis/redis"
"time"
)
func main() {
fmt.Println("We are testing Go-Redis")
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
if err != nil {return}
err = client.Set("name", "Tom", time.Second*5).Err()
if err != nil {
fmt.Println(err)
return
}
time.Sleep(time.Second*4)
val, err := client.Get("name").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(val)
}
Här kör vi vår main.go-fil med utgångstiden inställd på 4 sekunder först och ändrar den sedan till 6. Så, som svar på vår första körning av main.go, får vi namnet vi ställt in, Tom, tillbaka till oss, men andra gången vi körde det fick vi bara noll.
Använder JSON med Redis
För att lagra sammansatta värden kan vi använda JSON i vår kod:
package main
import (
"fmt"
"encoding/json"
"github.com/go-redis/redis"
)
type Author struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
json, err := json.Marshal(Author{Name: "Ben", Age: 85})
if err != nil {
fmt.Println(err)
}
err = client.Set("id4", json, 0).Err()
if err != nil {
fmt.Println(err)
}
val, err := client.Get("id4").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(val)
}
Med den här koden kunde vi lagra ett värde som består av ett namn och en ålder i vår Redis-databas:
slutgiltiga tankar
Som du kan se är det mycket enkelt att arbeta med Redis in Go: allt du behöver göra är att upprätta anslutningen och börja konfigurera dina inställningar.
Redis-databaser är utmärkta för att lagra information med utgångsdatum, vilket är en av huvudorsakerna till att en av dess primära användningsområden är cachning och meddelandelagring. Du kan infoga flera Redis-databaser i dina projekt efter behov.
I den tidigare guiden lärde du dig hur du ställer in utgångstiden för dina värden och verifierar att de fungerar, samt hur du använder JSON med dina Redis-databaser.
Apparna vi har använt i hela vår handledning, CodeRunner och SnippetsLab, är tillgängliga från Tecnologar, en tjänst med en utvald samling produktivitetsverktyg för dina Mac- och iOS-enheter.
Bläddra bland Tecnologars noggrant organiserade samlingar av temaappar för en mängd olika vardagliga uppgifter på Mac eller iPhone, välj de verktyg du vill använda och prova dem alla med en enda prenumeration. Behåll de du använder mest på dina enheter hela tiden och skaffa de du bara behöver ibland när du har en uppgift att göra.
Prova Tecnologar med vår 7-dagars gratis provperiod nu och utforska alla tillgängliga verktyg i vårt urval!
