Documentation
¶
Overview ¶
Package gredis provides convenient client for redis server.
Redis Client.
Redis Commands Official: https://redis.io/commands
Redis Chinese Documentation: http://redisdoc.com/
Example (AutoMarshalUnmarshalMap) ¶
package main
import (
"fmt"
"github.com/gogf/gf/container/gvar"
"github.com/gogf/gf/frame/g"
)
func main() {
var (
err error
result *gvar.Var
key = "user"
data = g.Map{
"id": 10000,
"name": "john",
}
)
_, err = g.Redis().Do("SET", key, data)
if err != nil {
panic(err)
}
result, err = g.Redis().DoVar("GET", key)
if err != nil {
panic(err)
}
fmt.Println(result.Map())
}
Output:
Example (AutoMarshalUnmarshalStruct) ¶
package main
import (
"fmt"
"github.com/gogf/gf/container/gvar"
"github.com/gogf/gf/frame/g"
)
func main() {
type User struct {
Id int
Name string
}
var (
err error
result *gvar.Var
key = "user"
user = &User{
Id: 10000,
Name: "john",
}
)
_, err = g.Redis().Do("SET", key, user)
if err != nil {
panic(err)
}
result, err = g.Redis().DoVar("GET", key)
if err != nil {
panic(err)
}
var user2 *User
if err = result.Struct(&user2); err != nil {
panic(err)
}
fmt.Println(user2.Id, user2.Name)
}
Output:
Example (AutoMarshalUnmarshalStructSlice) ¶
package main
import (
"fmt"
"github.com/gogf/gf/container/gvar"
"github.com/gogf/gf/frame/g"
)
func main() {
type User struct {
Id int
Name string
}
var (
err error
result *gvar.Var
key = "user-slice"
users1 = []User{
{
Id: 1,
Name: "john1",
},
{
Id: 2,
Name: "john2",
},
}
)
_, err = g.Redis().Do("SET", key, users1)
if err != nil {
panic(err)
}
result, err = g.Redis().DoVar("GET", key)
if err != nil {
panic(err)
}
var users2 []User
if err = result.Structs(&users2); err != nil {
panic(err)
}
fmt.Println(users2)
}
Output:
Example (HashSet) ¶
package main
import (
"fmt"
"github.com/gogf/gf/container/gvar"
"github.com/gogf/gf/frame/g"
)
func main() {
var (
err error
result *gvar.Var
key = "user"
)
_, err = g.Redis().Do("HSET", key, "id", 10000)
if err != nil {
panic(err)
}
_, err = g.Redis().Do("HSET", key, "name", "john")
if err != nil {
panic(err)
}
result, err = g.Redis().DoVar("HGETALL", key)
if err != nil {
panic(err)
}
fmt.Println(result.Map())
// May Output:
// map[id:10000 name:john]
}
Output:
Index ¶
- Constants
- func ClearConfig()
- func RemoveConfig(name ...string)
- func SetConfig(config Config, name ...string)
- func SetConfigByStr(str string, name ...string) error
- type Config
- type Conn
- type PoolStats
- type Redis
- func (r *Redis) Close() error
- func (r *Redis) Conn() *Conn
- func (r *Redis) Do(command string, args ...interface{}) (interface{}, error)
- func (r *Redis) DoVar(command string, args ...interface{}) (*gvar.Var, error)
- func (r *Redis) GetConn() *Conn
- func (r *Redis) SetIdleTimeout(value time.Duration)
- func (r *Redis) SetMaxActive(value int)
- func (r *Redis) SetMaxConnLifetime(value time.Duration)
- func (r *Redis) SetMaxIdle(value int)
- func (r *Redis) Stats() *PoolStats
Examples ¶
Constants ¶
const ( DEFAULT_GROUP_NAME = "default" // Default configuration group name. DEFAULT_REDIS_PORT = 6379 // Default redis port configuration if not passed. )
Variables ¶
This section is empty.
Functions ¶
func ClearConfig ¶
func ClearConfig()
ClearConfig removes all configurations and instances of redis.
func RemoveConfig ¶
func RemoveConfig(name ...string)
RemoveConfig removes the global configuration with specified group. If <name> is not passed, it removes configuration of the default group name.
func SetConfig ¶
SetConfig sets the global configuration for specified group. If <name> is not passed, it sets configuration for the default group name.
func SetConfigByStr ¶
SetConfigByStr sets the global configuration for specified group with string. If <name> is not passed, it sets configuration for the default group name.
Types ¶
type Config ¶
type Config struct {
Host string
Port int
Db int
Pass string // Password for AUTH.
MaxIdle int // Maximum number of connections allowed to be idle (default is 10)
MaxActive int // Maximum number of connections limit (default is 0 means no limit).
IdleTimeout time.Duration // Maximum idle time for connection (default is 10 seconds, not allowed to be set to 0)
MaxConnLifetime time.Duration // Maximum lifetime of the connection (default is 30 seconds, not allowed to be set to 0)
ConnectTimeout time.Duration // Dial connection timeout.
TLS bool //support tls
TLSSkipVerify bool //tls skip verify
}
Redis configuration.
func ConfigFromStr ¶
ConfigFromStr parses and returns config from given str. Eg: host:port[,db,pass?maxIdle=x&maxActive=x&idleTimeout=x&maxConnLifetime=x]
type Conn ¶
Redis connection.
func (*Conn) Do ¶
Do sends a command to the server and returns the received reply. It uses json.Marshal for struct/slice/map type values before committing them to redis.
type Redis ¶
type Redis struct {
// contains filtered or unexported fields
}
Redis client.
func Instance ¶
Instance returns an instance of redis client with specified group. The <name> param is unnecessary, if <name> is not passed, it returns a redis instance with default configuration group.
func New ¶
New creates a redis client object with given configuration. Redis client maintains a connection pool automatically.
func NewFromStr ¶
NewFromStr creates a redis client object with given configuration string. Redis client maintains a connection pool automatically. The parameter <str> like: 127.0.0.1:6379,0 127.0.0.1:6379,0,password
func (*Redis) Close ¶
Close closes the redis connection pool, it will release all connections reserved by this pool. It is not necessary to call Close manually.
func (*Redis) Conn ¶
Conn returns a raw underlying connection object, which expose more methods to communicate with server. **You should call Close function manually if you do not use this connection any further.**
func (*Redis) Do ¶
Do sends a command to the server and returns the received reply. Do automatically get a connection from pool, and close it when the reply received. It does not really "close" the connection, but drops it back to the connection pool.
func (*Redis) SetIdleTimeout ¶
SetIdleTimeout sets the IdleTimeout attribute of the connection pool. It closes connections after remaining idle for this duration. If the value is zero, then idle connections are not closed. Applications should set the timeout to a value less than the server's timeout.
func (*Redis) SetMaxActive ¶
SetMaxActive sets the maximum number of connections allocated by the pool at a given time. When zero, there is no limit on the number of connections in the pool.
Note that if the pool is at the MaxActive limit, then all the operations will wait for a connection to be returned to the pool before returning.
func (*Redis) SetMaxConnLifetime ¶
SetMaxConnLifetime sets the MaxConnLifetime attribute of the connection pool. It closes connections older than this duration. If the value is zero, then the pool does not close connections based on age.
func (*Redis) SetMaxIdle ¶
SetMaxIdle sets the maximum number of idle connections in the pool.
Source Files