redis 入门

1.nosql

not only sql
四类
1.key,value存储 redis
2.列存储的数据库 hbase
3.文档数据库 mongoDB
4.图形数据库 infogrid

2.redis概述

官网 https://redis.io/
支持类型

1.字符串类型	2.列表类型
3.有序集合类型	4.散列类型
5.集合类型

性能 读11万qps 写8万qps

3.redis指令

① 字符串

指令	解释
redis-server	启动redis服务端
redis-cli	启动客户端
set key value	设置值
get key	取值
getset key value	先取key的值，再替换
del key	删除某个key
incr key	自增1，如果原来的是nil，则值为1
decr key	自减1，如果原来的是nil，则值为-1
incrby key num	增加加具体的数值
decrby key num	增加加具体的数值
append key value	在key后追加value

② 存储hash
String key,String value的map
每个hash可以存储4294967295键值对

指令	解释
hset key hashkey hashvalue	单个值添加
hget key hashkey	单个值取出
hmset key hk1 hv1 hk2 hv2..	多个添加
hmget key hk1 hk2..	多个取值
hmgetall key	会把hk，hv全部取出
hdel key	清空某个key（和del有区别 del为nil,hdel清空）
hincrby key hk1 num	增加加具体的数值
hexists key hk1	是否存在（1存在，0不存在）
hlen key	属性个数
hkeys key	取所有的key
hvals key	取所有的value

③list
按照插入顺序排序的列表
使用arraylist
使用linkedlist

指令	解释
lpush key v1 v2 v3	左侧（头部）插入(2.4之前版本只能单个插入)
rpush key v1 v2 v3	右侧（尾部）插入
lrange key hk1 hv1 hk2 hv2..	多个添加
lpop key v1 v2 v3	左侧(头部)取出
rpop key v1 v2 v3	右侧(尾部)取出
lpushx key value	如果key存在，向链表头部插入，如果不存在不插入
lrem key count [value]	count>0从头向尾遍历 删除第conut元素，从尾向头遍历，删除第count元素，等于0 删除所有值为value的元素
lset key count value	在第count位替换值为value
linsert key before/after v1 v2	在v1前/后插入v2
rpoplpush key1 key2	将key1尾部的值插入到key2头部

④set
没有排序的字符集合，不允许重复数值
最多存储4294967295元素

指令	解释
sadd key v1 v2 v3	向set中添加值
srem key v1 v2 v3	删除set中某个元素
smembers key	查看元素
sisnenbers key value	判断某个元素是否存在 1存在 0 不存在
sdiff key1 key2	差集运算
sinter key1 key2	交集运算
sunion key1 key2	并集运算
scard key	成员个数
sdiffstore newkey key1 key2	两个集合差集插入一个新的set中
sinterstore newkey key1 key2	两个集合交集插入一个新的set中
sunionstore newkey key1 key2	两个集合并集插入一个新的set中

⑤Sorted-set
和set相似，每一个元素都有一个数值关联，根据数值排序，元素唯一，数值可以重复
有序的set，所以访问中部元素也是高效的

指令	解释
zadd key number value	向s-set中添加值,nmber为排序的数值
zscore key value	获得某个元素的数值
zcard key	获得元素数量
zrem key value	删除具体元素
zrange key n m	查看元素 (0 -1 获取所有)从小到大
zrange key n m withscore	查看元素，携带数值
zrevrangekey1 key n m withscore	查看元素，从大到小
zremrangebyrank key n m	按范围删除
zrangebyscore key n m withscore limit i j	按数值排序，携带数值，第i到j显示
zincrby key number value	增加指定元素的数值
zcount key number1 number2	计算数值区间内元素的个数

⑥通用操作

指令	解释
keys *	查询所有的key
del key1 key2 key3	删除指定key
exists key	指定key是否存在， 0不存在，1存在
rename oldkey newkey	重命名
expire key s	设置过期时间，单位为秒
ttl key	所剩超时时间，如果没有设置返回-1
type key	查看类型
zremrangebyrank key n m	按范围删除
zrangebyscore key n m withscore limit i j	按数值排序，携带数值，第i到j显示
zincrby key number value	增加指定元素的数值
zcount key number1 number2	计算数值区间内元素的个数

4.特性

1.多数据库，2.事务
一个redis实例有16个数据库，默认连接第0号数据库 ，可以通过select n选择连接哪一个
move key n 将当前的key移动到指定数据库
multi exec discard，实现事务，执行事务时会串行化执行，不再对其他客户端提供服务
在事务中某一个命令执行失败，其后的指令依然会执行
multi 开启事务
exec 提交事务
discard 回滚事务

5.持久化

两种持久化 rdb，aof
①rdb
在指定时间将数据的快照存储到磁盘中。
优点 备份完整。数据集大比aof快
缺点 备份不完全，可能数据丢失
conf中 save 900 1 每900秒 有1个key变化会写入一次

@aof
日志形式记录每一次操作，启动时根据日志重新构建
优点
更高数据安全性
缺点
文件更大，效率低
appendonly no 默认没有打开
appendfsync always 每次执行同步
appendfsync everysec 每秒同步
appendfsync no 不同步

redis-server 文件名 启动

6.java相关

 <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.7.3</version>
    </dependency>

package org.seckill.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public final class RedisUtil {

    //Redis服务器IP
    private static String ADDR = "127.0.0.1";

    //Redis的端口号
    private static int PORT = 6379;

    //访问密码
    private static String AUTH = "admin";

    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;

    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;

    private static int TIMEOUT = 10000;

    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;

    private static JedisPool jedisPool = null;

    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            //config.setMaxActive(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 释放jedis资源
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
}

也可以直接使用jedis创建对象

 jedis = new Jedis("127.0.0.1", 6379);

package org.seckill.redis;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestRedis {
    private Jedis jedis; 

    @Before
    public void setup() {
        //连接redis服务器，192.168.0.100:6379
        jedis = new Jedis("127.0.0.1", 6379);
        //权限认证
        //jedis.auth("admin");  
    }

    /**
     * redis存储字符串
     */
    @Test
    public void testString() {
        //-----添加数据----------  
        jedis.set("name","xinxin");//向key-->name中放入了value-->xinxin  
        System.out.println(jedis.get("name"));//执行结果：xinxin  

        jedis.append("name", " is my lover"); //拼接
        System.out.println(jedis.get("name")); 

        jedis.del("name");  //删除某个键
        System.out.println(jedis.get("name"));
        //设置多个键值对
        jedis.mset("name","liuling","age","23","qq","476777XXX");
        jedis.incr("age"); //进行加1操作
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

    }

    /**
     * redis操作Map
     */
    @Test
    public void testMap() {
        //-----添加数据----------  
        Map<String, String> map = new HashMap<String, String>();
        map.put("name", "xinxin");
        map.put("age", "22");
        map.put("qq", "123456");
        jedis.hmset("user",map);
        //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的List  
        //第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数  
        List<String> rsmap = jedis.hmget("user", "name", "age", "qq");
        System.out.println(rsmap);  

       //删除map中的某个键值  
        jedis.hdel("user","age");
        System.out.println(jedis.hmget("user", "age")); //因为删除了，所以返回的是null  
        System.out.println(jedis.hlen("user")); //返回key为user的键中存放的值的个数2 
        System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true  
        System.out.println(jedis.hkeys("user"));//返回map对象中的所有key  
        System.out.println(jedis.hvals("user"));//返回map对象中的所有value 

        Iterator<String> iter=jedis.hkeys("user").iterator();  
        while (iter.hasNext()){  
            String key = iter.next();  
            System.out.println(key+":"+jedis.hmget("user",key));  
        }  
    }

    /** 
     * jedis操作List 
     */  
    @Test  
    public void testList(){  
        //开始前，先移除所有的内容  
        jedis.del("java framework");  
        System.out.println(jedis.lrange("java framework",0,-1));  
        //先向key java framework中存放三条数据  
        jedis.lpush("java framework","spring");  
        jedis.lpush("java framework","struts");  
        jedis.lpush("java framework","hibernate");  
        //再取出所有数据jedis.lrange是按范围取出，  
        // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有  
        System.out.println(jedis.lrange("java framework",0,-1));  

        jedis.del("java framework");
        jedis.rpush("java framework","spring");  
        jedis.rpush("java framework","struts");  
        jedis.rpush("java framework","hibernate"); 
        System.out.println(jedis.lrange("java framework",0,-1));
    }  

    /** 
     * jedis操作Set 
     */  
    @Test  
    public void testSet(){  
        //添加  
        jedis.sadd("user","liuling");  
        jedis.sadd("user","xinxin");  
        jedis.sadd("user","ling");  
        jedis.sadd("user","zhangxinxin");
        jedis.sadd("user","who");  
        //移除noname  
        jedis.srem("user","who");  
        System.out.println(jedis.smembers("user"));//获取所有加入的value  
        System.out.println(jedis.sismember("user", "who"));//判断 who 是否是user集合的元素  
        System.out.println(jedis.srandmember("user"));  
        System.out.println(jedis.scard("user"));//返回集合的元素个数  
    }  

    @Test  
    public void test() throws InterruptedException {  
        //jedis 排序  
        //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）  
        jedis.del("a");//先清除数据，再加入数据进行测试  
        jedis.rpush("a", "1");  
        jedis.lpush("a","6");  
        jedis.lpush("a","3");  
        jedis.lpush("a","9");  
        System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]  
        System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //输入排序后结果  
        System.out.println(jedis.lrange("a",0,-1));  
    }  

    @Test
    public void testRedisPool() {
        RedisUtil.getJedis().set("newname", "中文测试");
        System.out.println(RedisUtil.getJedis().get("newname"));
    }
}