Redis instalación y razón de por favor refiérase a la información relevante para aprender.
Redis básicos y ha desarrollado usando:
1,0-16 15 biblioteca Total.
2. almacenamiento KV típica.
3. Operación Común Comandos:
(1) añadir kV SET
(2) Encuentra toda la llave: teclas <patrón regular>
GET: (3) para encontrar el valor de la clave correspondiente
base de datos (4). Conmutación: SELECT <0-15 NUM>
. (5 ) número de clave-valor Ver: dbsize (no hay parámetros para la biblioteca actual)
(6) base de datos vacía: flushdb (actual biblioteca); flushall (todos los bancos)
4. cinco tipos de datos: cadena, de hash (diccionario similar, una pluralidad de pares kv) , lista, conjunto, zConfigurar (conjunto ordenado):
-
(1) Cadena:
Redis tipo más básico, en kV;
almacenamiento binario, además de la cadena puede poner imágenes y otros datos, el programa lee a cabo sin problemas, excepto binario chino.
512MB valor máximo de la cadena;
setex(set with expire): setex <keyname> <n seconds> <value> //多少秒过后，这个value就被销毁了； mset(多个kv对设置): mset <k1> <v1> <k2> <k2> //如何获得： mget <k1> <k2>。 -
(2) Hash:
clave para la recogida, el diccionario similares, mapa var golang [string] cadena ;
particularmente adecuado para almacenamiento de objetos, es decir, en el golang estructura;
hset cxk hobby sing ; hset cxk name caixukun // hget cxk name 就能取到name对应的value。 hmset cxk name caixk age 20 song "鸡你太美" // hmget cxk name age song 一次取到设置并取多个字段的values。 hlen cxk //查看Hash元素有多少个。 hexists cxk song //查看cxk这个hash中是否有song这个字段。 -
(3) de lista:
una simple lista de secuencias, orden de clasificación de acuerdo con la inserción, un elemento puede ser añadido a la cabeza o la cola de la lista;
Lista es esencialmente una lista, los elementos de lista están clasificadas ([n] List), el valor del elemento se puede repetir;
nota de uso lpop / RPOP es muy común; lpush empuje similares, rpush cola similar. -
(4) Set (zConfigurar mismo modo):
el conjunto de colección desordenada de tipo cadena;
estructura de datos subyacente es Hashtable, mantenga una gran cantidad de elementos de cadena, elemento de cadena no ordenado, y los valores de los elementos no se puede repetir, por ejemplo, un almacenamiento de identificación de empleado número, correo electrónico, número de teléfono, número de QQ y por lo que el contenido sólo no duplicados;
sadd emails [email protected] [email protected] //创建并添加集合的k名和v的内容； smembers emails //遍历所有集合中的内容； sismenber emails damn //检查集合中是否存在damn，有返回1，没有就返回0； srem emails [email protected] //删除集合中指定值；
El tipo de datos y la ABM:
String (1.):
CU: SET <KeyName> <ValueName> // la tecla SET no se crea, no habría modificar
D: del <KeyName>
R ^: GET <KeyName>
(2) del Hash:
CU: PONH <hashname> <KeyName> <ValueName>
R ^: hget <hashname> <KeyName>; hgetall
D: HDEL <hashname>
(. 3) Lista:
CU: LPUSH / RPUSH <nombre de la lista> ... // VALOR1 dejó valor3 valor2 derecha los datos se insertan
lpop / RPOP <nombredelista> // toman la izquierda / derecha tomar cada elemento
R: lrange <nombredelista> [número] [Último número] // comienzan a mostrar solamente el lado izquierdo desde el inicio hasta el final 0 -1 segmento de datos
lindex <nombredelista> <índice> // obtener la lista por el valor de índice en el elemento correspondiente
llen <nombredelista> // Comprobar el número de elementos
D: del <nombredelista>
el conjunto (4).:
la CU: Sadd <KeyName> < valor1> <valor2>
R: smembers <nombre de clave> // a través de todos los valores;
sismember <nombre de clave> <dest-valor > // si hay x, una presencia, ausencia 0;
D: Syrmie <KeyName> <dest-valor> // devuelve un exitoso retorno de eliminación sin éxito 0;
Cómo ReDiS por Golang
- Para asegurar que el sistema está instalado git .
- Cambiar al directorio GOPATH: "ir a buscar github.com \ garyburd \ Redigo \ Redis" puede descargar el paquete Redis relacionados src a la siguiente, de esta manera importación ReDiS paquetes, y los métodos de propiedades relacionadas con el uso.
Caso 1: Operación Golang Redis, una cadena de instrucciones de cadena, el tipo de datos de los parámetros restantes pasó Redis exactamente de la misma línea de comandos:
package main
import (
"fmt"
"github.com/garyburd/redigo/redis"
)
func main() {
//连接数据库
conn, err := redis.Dial("tcp","127.0.0.1:6379")
if err != nil {
fmt.Println("连接失败，错误为：",err)
return
}
defer conn.Close()
//添加一对键值对，我们所需要的仅仅是添加结果成功就可以，无需返回值
_, err = conn.Do("set", "email", "damn") //conn.Do()用的是最多的，把命令行中的args一个个写进去
if err != nil {
fmt.Println("设置kv失败，错误原因为：",err)
return
}
_, err = conn.Do("setex", "email1", 10，"shit") //conn.Do()用的是最多的，把命令行中的args一个个写进去
if err != nil {
fmt.Println("设置kv失败，错误原因为：",err)
return
}
//取得一个键对应的一个值，判断获取的值得类型为xx
//get返回时空接口类型，使用断言报错，直接使用redis提供的转换方法即可
res, err := redis.String(conn.Do("get","email"))
if err != nil {
fmt.Println("获取key失败，错误原因为：",err)
return
}
fmt.Println(res)
}
Caso 2: Golang Redis funcionamiento, uso el hash de la cadena
package main
import (
"fmt"
"github.com/garyburd/redigo/redis"
)
func main() {
//连接数据库
conn, err := redis.Dial("tcp","127.0.0.1:6379")
if err != nil {
fmt.Println("连接失败，错误为：",err)
return
}
defer conn.Close()
//添加一个hash
_, err = conn.Do("hmset", "hhash", "name","damn","age",27)
if err != nil {
fmt.Println("设置kv失败，错误原因为：",err)
return
}
//取得一个键对应的一个值，判断获取的值得类型为xx
//get返回时空接口类型，使用断言报错，直接使用redis提供的转换方法即可
res, err := redis.Strings(conn.Do("hmget","hhash","name","age")) //注意这里变为Strings
if err != nil {
fmt.Println("获取key失败，错误原因为：",err)
return
}
for i, v := range res { //res应该是集合类数据，在golang中也应该是数组切片之类的。
fmt.Println(v) //遍历的方式，也可以带上索引或者不带
}
}
agrupación de conexiones Redis
- Enlace inicialización lograr un cierto número de enlaces en la piscina;
- Ir cuando se requiere una acción redis, toma directamente de enlace a células enlace;
- Esto ahorra los Redis enlace temporales tienen tiempo para mejorar la eficiencia.
Caso: init () se fundó Redis la agrupación de conexiones, enlaces de recursos directamente para obtener el código detrás de la relación de la piscina y leer y escribir
package main
import (
"fmt"
"github.com/garyburd/redigo/redis"
)
var pool *redis.Pool
/*
type Pool struct {
Dial func() (Conn, error)
// Maximum number of idle connections in the pool.
MaxIdle 8 //最大空闲数为8
MaxActive 0 //0表示无限制链接，支持最高并发数
IdleTimeout 100 //time.Duration
}
*/
func init() { //初始化函数，执行main之前优先创建链接池，链接池的意义在于迅速响应go链接，不用从头开始建立tcp链接
pool = &redis.Pool{
Dial: func() (redis.Conn, error){
return redis.Dial("tcp","127.0.0.1:6379")
},
MaxIdle: 8, //最大空闲数为8
MaxActive: 0, //0表示无限制链接，支持最高并发数
IdleTimeout: 100, //time.Duration
}
}
func main() {
//从创建好的链接池中取出一个链接
/*
func (p *Pool) Get() Conn {
pc, err := p.get(nil)
if err != nil {
return errorConn{err}
}
return &activeConn{p: p, pc: pc}
}
*/
conn := pool.Get() //从redis链接池中取出一个链接，和之前redis.Dial是一个意思
defer conn.Close() //开销类资源一定要使用defer关闭，如果要取值一定要保证链接池开启，关闭后 get on closed pool报错
//链接redis，创建添加一个kv，并查询kv
_, err := conn.Do("Set","cxk","鸡你太美")
if err != nil {
fmt.Println("SET 添加字段有误，错误为：",err)
return
}
ret, err1 := redis.String(conn.Do("Get","cxk"))
if err1 != nil {
fmt.Println("GET 读取字段有误，错误为：",err1)
return
}
fmt.Println("Get 取值为：",ret) //Get 取值为： 鸡你太美
}
