redis

1.redis介绍
2.redis常用数据类型及应用场景
3.Java中操作redis
4.redis集群
5.redis事务

1.redis介绍
redis是一个key-value存储系统，它支持存储的value类型相对更多，包括string(字符串)、hash（哈希类型）、list(链表)、set(集合)、SortedSet(有序集合)。
这些数据类型都支持push/pop、add/remove及取交集并集和差集的操作，而且这些操作都是原子性的。
在此基础上，redis支持各种不同方式的排序。为了保证效率，数据都是缓存在内存中。
Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器

2.redis常用数据类型及应用场景
（1）Key
1)keys 查找所有符合条件的key
2)del 删除
3)exists 是否存在
4)expire 设置生存时间(以秒为单位)
5)persist 将生存时间移除
5)ttl 查看剩余生存时间(以秒为单位)
6)pexpire 设置生存时间(以毫秒为单位)
7)pttl 查看剩余生存时间(以毫秒为单位)
8)randomkey 从数据库随机返回一个key
9)sort 返回键值从小到大排序 desc 从大到小排序
10)type 所存储的值的类型

（2）String
1)get 返回一个
2)mget 返回一个或多个
3)set 设置一个
4)mset 设置一个或多个
5)setex key seconds value 将值value关联到key,并将key的生存时间设为seconds(以秒为单位)
6)setnx 设置一个key值，当且仅当key不存在
7)append 追加值
8)decr 减1
9)decrby key decrement 值减去减量decrement
10)incr 加1
11)incrby key incrment 值加上增量increment
12)getrange key start end 字符串截取0开始
13)strlen 字符串长度
应用场景：
String是最常用的一种数据类型，普通的key/value存储都可以归为此类

（3）Hash
1)hset 将哈希表key中的域field的值设为value (旧值将被覆盖)
2)hmset 同时将多个field-value(域-值)对设置到哈希表key中 (旧值将被覆盖)
3)hsetnx 将哈希表key中的域field的值设置为value,当且仅当域field不存在
4)hget 返回给定域field的值
5)hmget 返回一个或多个给定域的值
6)hgetall 返回所有的域和值
7)hdel 删除一个或多个指定域
8)hexists 查看给定域field是否存在
9)hincrby key field increment 值加上增量increment(增量也可以为负数,相当于对给定域进行减法操作)
10)hkeys 返回所有域
11)hvals 返回所有域的值
12)hlen 返回域的数量
应用场景：
比如我们要存储一个用户信息对象数据，包含以下信息：
用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储，主要有以下2种存储方式：

第一种方式将用户ID作为查找key,把其他信息封装成一个对象以序列化的方式存储，这种方式的缺点是，增加了序列化/反序列化的开销，并且在需要修改其中一项信息时，需要把整个对象取回。

 

第二种方法是这个用户信息对象有多少成员就存成多少个key-value对儿，用用户ID+对应属性的名称作为唯一标识来取得对应属性的值，虽然省去了序列化开销和并发问题，但是用户ID为重复存储，如果存在大量这样的数据，会造成内存浪费。
Redis提供的Hash很好的解决了这个问题，Redis的Hash实际是内部存储的Value为一个HashMap，并提供了直接存取这个Map成员的接口：

Key仍然是用户ID, value是一个Map，这个Map的key是成员的属性名，value是属性值，这样对数据的修改和存取都可以直接通过其内部Map的Key, 也就是通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不会带来序列化的问题。

（4）List
1)lset 将下标为index的元素的值设置为value
2)lpush 将一个或多个值插入到列表的表头
3)lpushx 将值插入到列表的表头，当且仅当key存在并且是一个列表
4)lpop 移除并返回列表的头元素
5)rpush 将一个或多个值插入到列表的表尾(最右边)
6)rpushx 将值插入到列表的表尾，当且仅当key存在并且是一个列表
7)rpop 移除并返回列表的尾元素
8)linsert key BEFORE|AFTER pivot value 将值value插入到列表key当中，位于值pivot之前或之后
9)lindex 返回列表中,下标为index的元素
10)lrange 返回列表中指定区间内的元素,区间以偏移量start和stop指定 -1表示最后一个元素
11)llen 返回列表的长度
应用场景：
list的应用场景非常多，也是Redis最重要的数据结构之一，比较适用于列表式存储且顺序相对比较固定，例如：省份、城市列表。

（5）Set
1)sadd 将一个或多个元素加入到集合中
2)scard 集合中元素的数量
3)sismember 元素是否集合的成员
4)smembers 返回集合中的所有成员
5)spop 将随机元素从集合中移除并返回
6)srandmember 返回随机元素
7)srem 移除集合中的一个或多个元素
应用场景：
set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，可以使用set，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

（6）SortedSet
1)zadd 将一个或多个元素加入到有序集中
2)zcard 集合中元素的数量
3)zincrby key increment member 为有序集的成员值加上增量increment
4)zrem 移除有序集中的一个或多个成员
5)zscore 返回有序集中,成员的值
6)zrevrange 返回有序集中,指定区间内的成员
应用场景：
sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构。

3.Java中操作redis
Java中使用Jedis操作Redis,具体实现代码部分讲解。

package redis;

import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.HashMap;
import java.util.Map;


public class TestRedis {
    private Jedis jedis;

    @Before
    public void setup() {
        jedis = new Jedis("127.0.0.1", 6379);
    }

    /**
     * Key
     * 1)keys 查找所有符合条件的key
     * 2)del  删除
     * 3)exists 是否存在
     * 4)expire 设置生存时间(以秒为单位)
     * 5)persist 将生存时间移除
     * 5)ttl  查看剩余生存时间(以秒为单位)
     * 6)pexpire 设置生存时间(以毫秒为单位)
     * 7)pttl 查看剩余生存时间(以毫秒为单位)
     * 8)randomkey 从数据库随机返回一个key
     * 9)sort  返回键值从小到大排序  desc 从大到小排序
     * 10)type 所存储的值的类型
     */
    @Test
    public void keyTest() {
        jedis.mset("one", "1", "two", "2", "three", "3");
        System.out.println("所有值：" + jedis.keys("*"));
        System.out.println("删除：" + jedis.del("one"));
        System.out.println("存在：" + jedis.exists("one"));
        System.out.println("存在：" + jedis.exists("two"));
        System.out.println("有效时间：" + jedis.expire("two", 3600));//生存时间 秒
        System.out.println("剩余有效时间：" + jedis.ttl("two"));//剩余生存时间
        System.out.println("随机返回：" + jedis.randomKey());
        System.out.println("值类型：" + jedis.type("three"));
        System.out.println("key的数量：" + jedis.dbSize());
        System.out.println("删除全部key:" + jedis.flushDB());
    }


    /**
     * redis存储字符串
     * 1)get 返回一个
     * 2)mget 返回一个或多个
     * 3)set  设置一个
     * 4)mset 设置一个或多个
     * 5)setex key seconds value  将值value关联到key,并将key的生存时间设为seconds(以秒为单位)
     * 6)setnx 设置一个key值，当且仅当key不存在
     * 7)append 追加值
     * 8)decr 减1
     * 9)decrby key decrement 值减去减量decrement
     * 10)incr 加1
     * 11)incrby key incrment  值加上增量increment
     * 12)getrange key start end 字符串截取0开始
     * 13)strlen 字符串长度
     */
    @Test
    public void testString() {
        jedis.set("one", "1");
        System.out.println("单个值：" + jedis.get("one"));

        jedis.mset("two", "2", "three", "3", "four", "4", "five", "5");
        System.out.println("多个值：" + jedis.mget("two", "three", "four", "five"));

        jedis.setex("six", 3600, "6");
        System.out.println(jedis.get("six") + "，有效时间：" + jedis.ttl("six"));

        System.out.println(jedis.setnx("six", "6"));
        System.out.println(jedis.setnx("seven", "7"));

        System.out.println("six长度：" + jedis.append("six", "66") + ",six新值：" + jedis.get("six"));

        System.out.println("six:" + jedis.decr("six"));
        System.out.println("six:" + jedis.decrBy("six", 659));

        System.out.println("six:" + jedis.incr("six"));
        System.out.println("six:" + jedis.incrBy("six", 659));

        jedis.set("java", "hello word");
        System.out.println(jedis.getrange("java", 0, 4));//字符串截取0开始
        System.out.println(jedis.getrange("java", -4, -1));
        System.out.println(jedis.strlen("java"));

        System.out.println("key的数量：" + jedis.dbSize());
        System.out.println("删除全部key:" + jedis.flushDB());
    }

    /**
     * redis操作Map
     * 1)hset    将哈希表key中的域field的值设为value (旧值将被覆盖)
     * 2)hmset   同时将多个field-value(域-值)对设置到哈希表key中 (旧值将被覆盖)
     * 3)hsetnx  将哈希表key中的域field的值设置为value,当且仅当域field不存在
     * 4)hget    返回给定域field的值
     * 5)hmget   返回一个或多个给定域的值
     * 6)hgetall 返回所有的域和值
     * 7)hdel    删除一个或多个指定域
     * 8)hexists 查看给定域field是否存在
     * 9)hincrby key field increment 值加上增量increment(增量也可以为负数,相当于对给定域进行减法操作)
     * 10)hkeys  返回所有域
     * 11)hvals  返回所有域的值
     * 12)hlen   返回域的数量
     */
    @Test
    public void testMap() {
        jedis.hset("user", "name", "cheng");

        Map<String, String> map = new HashMap<String, String>();
        map.put("age", "10");
        map.put("qq", "123456");

        jedis.hmset("user", map);

        jedis.hsetnx("user", "name", "chengwei");

        System.out.println("name值：" + jedis.hget("user", "name"));

        System.out.println(jedis.hmget("user", "name", "age", "qqq"));

        System.out.println("所有的域:" + jedis.hkeys("user"));
        System.out.println("所有的域的值:" + jedis.hvals("user"));
        System.out.println("所有的域和值:" + jedis.hgetAll("user"));
        System.out.println("域的数量:" + jedis.hlen("user"));

        jedis.hdel("user", "name");
        System.out.println("name值：" + jedis.hmget("user", "name"));

        System.out.println(jedis.exists("user"));

        jedis.hincrBy("user", "age", 10L);
        System.out.println("age值加后：" + jedis.hget("user", "age"));
        jedis.hincrBy("user", "age", -10L);
        System.out.println("age值减后：" + jedis.hget("user", "age"));

        System.out.println("删除全部key:" + jedis.flushDB());
    }

    /**
     * jedis操作List
     * 1)lset    将下标为index的元素的值设置为value
     * 2)lpush   将一个或多个值插入到列表的表头
     * 3)lpushx  将值插入到列表的表头，当且仅当key存在并且是一个列表
     * 4)lpop    移除并返回列表的头元素
     * 5)rpush   将一个或多个值插入到列表的表尾(最右边)
     * 6)rpushx  将值插入到列表的表尾，当且仅当key存在并且是一个列表
     * 7)rpop    移除并返回列表的尾元素
     * 8)linsert key BEFORE|AFTER pivot value 将值value插入到列表key当中，位于值pivot之前或之后
     * 9)lindex  返回列表中,下标为index的元素
     * 10)lrange 返回列表中指定区间内的元素,区间以偏移量start和stop指定  -1表示最后一个元素
     * 11)llen   返回列表的长度
     */
    @Test
    public void testList() {
        jedis.lpush("java", "struts");
        jedis.lpush("java", "mybatis");

        jedis.lset("java", 0L, "spring");

        System.out.println("1." + jedis.lrange("java", 0, -1));

        System.out.println("2." + jedis.lpop("java"));
        System.out.println("2.1." + jedis.lrange("java", 0, -1));

        jedis.del("java");
        jedis.rpush("java", "spring");
        jedis.rpush("java", "struts");
        jedis.rpush("java", "mybatis");

        System.out.println("3." + jedis.lrange("java", 0, -1));

        System.out.println("4." + jedis.rpop("java"));
        System.out.println("4.1." + jedis.lrange("java", 0, -1));

        jedis.linsert("java", BinaryClient.LIST_POSITION.AFTER, "spring", "springMVC");
        System.out.println("5." + jedis.lrange("java", 0, -1));

        System.out.println("6." + jedis.lindex("java", 0L));

        System.out.println("7." + jedis.llen("java"));

        System.out.println("删除全部key:" + jedis.flushDB());
    }

    /**
     * jedis操作Set
     * 1)sadd         将一个或多个元素加入到集合中
     * 2)scard        集合中元素的数量
     * 3)sismember    元素是否集合的成员
     * 4)smembers     返回集合中的所有成员
     * 5)spop         将随机元素从集合中移除并返回
     * 6)srandmember  返回随机元素
     * 7)srem         移除集合中的一个或多个元素
     */
    @Test
    public void testSet() {
        //添加
        jedis.sadd("java", "spring", "struts", "mybatis", "struts2");

        System.out.println("集合中元素的数量:" + jedis.scard("java"));

        System.out.println("所有成员:" + jedis.smembers("java"));

        jedis.srem("java", "spring");
        System.out.println("移除spring后所有成员:" + jedis.smembers("java"));

        System.out.println("元素是否集合的成员:" + jedis.sismember("java", "struts2"));

        System.out.println("将随机元素从集合中移除并返回:" + jedis.spop("java"));

        System.out.println("所有成员:" + jedis.smembers("java"));

        System.out.println("返回随机元素:" + jedis.srandmember("java"));

        System.out.println("所有成员:" + jedis.smembers("java"));

        System.out.println("删除全部key:" + jedis.flushDB());
    }

    /**
     * jedis操作SortedSet
     * 1)zadd         将一个或多个元素加入到有序集中
     * 2)zcard        集合中元素的数量
     * 3)zincrby key increment member    为有序集的成员值加上增量increment
     * 4)zrem         移除有序集中的一个或多个成员
     * 5)zscore       返回有序集中,成员的值
     * 6)zrevrange    返回有序集中,指定区间内的成员
     */
    @Test
    public void testSortedSet() {
        jedis.zadd("java", 3.1, "spring");
        System.out.println("1." + jedis.zcard("java"));

        Map map = new HashMap();
        map.put(2.0, "struts");
        map.put(3.0, "mybatis");
        jedis.zadd("java", map);
        System.out.println("2." + jedis.zcard("java"));//集合中元素的数量

        System.out.println("3." + jedis.zrevrange("java", 0L, -1));//返回有序集中,指定区间内的成员

        jedis.zincrby("java", 1, "mybatis");

        System.out.println("4." + jedis.zrevrange("java", 0L, -1));

        jedis.zrem("java", "spring");//移除有序集中的一个或多个成员

        System.out.println("5." + jedis.zrevrange("java", 0L, -1));

        System.out.println("6." + jedis.zscore("java", "mybatis"));//返回有序集中,成员的值

        System.out.println("删除全部key:" + jedis.flushDB());
    }

    
}

 

4.redis集群
1)Redis集群的分配数据是采用另外一种叫做哈希槽 (hash slot)的方式来分配的。redis集群默认分配了16384个哈希槽，当我们set一个key时，会用CRC16算法来取模得到所属的槽，然后将这个key分到哈希槽区间的节点上，具体算法就是：CRC16(key)%16384。

节点：一个端口的redis服务便是一个节点
槽（集群将整个系统分为16384个hash槽）：这16384个槽位要全部分布在集群中的主节点上。
重新分片：若某个主节点故障了，将该主节点的槽位分配到其他可以用的主节点上。
上线/下线状态：是否全部的槽位都分布在节点上。

2)集群中的每个节点负责处理一部分哈希槽。举个例子，一个集群可以有三个哈希槽，其中：
节点A负责处理0号至5500号哈希槽。
节点B负责处理5501号至11000号哈希槽。
节点C负责处理11001号至16384号哈希槽。
这种将哈希槽分布到不同节点的做法使得用户可以很容易地向集群中添加或者删除节点。 比如说：
如果用户将新节点D添加到集群中， 那么集群只需要将节点A 、B 、 C中的某些槽移动到节点D就可以了。
与此类似，如果用户要从集群中移除节点A ，那么集群只需要将节点A中的所有哈希槽移动到节点B和节点C ，然后再移除空白（不包含任何哈希槽）的节点A就可以了。

5.事务
事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

MULTI 命令用于开启一个事务
EXEC 执行所有事务块内的命令
DISCARD 取消事务
WATCH 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断

 

package redis;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.List;

/**
 * 模拟刷一次信用卡的交易
 */
public class TestTransaction {
    @Test
    public void test(){
        boolean retValue = false;
        boolean Interrupted = false;

        try {
            retValue = transMethod(100);
        } catch (Exception e) {
            Interrupted = true;
            System.out.println("事务被打断，请重新执行!");
        } finally {
            if (retValue) {
                System.out.println("使用信用卡消费成功！");
            } else {
                if (!Interrupted) {
                    System.out.println("使用信用卡消费失败！余额不足！");
                }
            }
        }
    }


    /**
     * 通俗点讲，watch命令就是标记一个键，如果标记了一个键，
     * 在提交事务前如果该键被别人修改过，那事务就会失败，这种情况通常可以在程序中
     * 重新再尝试一次。
     * <p>
     * 首先标记了balance，然后检查余额是否足够，不足就取消标记，并不做扣减；
     * 足够的话，就启动事务进行更新操作。
     * 如果在此期间键balance被其他人修改，拿在提交事务(执行exec)时就会报错，
     * 程序中通常可以捕获这类错误再重新执行一次，直到成功。
     */
    private boolean transMethod(int amount) throws Exception {

        System.out.println("您使用信用卡预付款" + amount + "元");

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

        int balance = 1000;//可用余额
        int debt;//欠额
        int amtToSubtract = amount;//实刷额度

        jedis.set("balance", String.valueOf(balance));
        jedis.watch("balance");
//        jedis.set("balance", "1100");//为了模拟其他程序已经修改了该条目
        balance = Integer.parseInt(jedis.get("balance"));
        if (balance < amtToSubtract) {//可用余额小于实刷金额，拒绝交易
            jedis.unwatch();
            System.out.println("可用余额不足！");
            return false;
        } else {//可用余额够用的时候再去执行扣费操作
            System.out.println("扣费transaction事务开始执行...");
            Transaction transaction = jedis.multi();
            transaction.decrBy("balance", amtToSubtract);//余额减去amtToSubtract的钱数
            transaction.incrBy("debt", amtToSubtract);//信用卡欠款增加amtToSubtract的钱数
            List<Object> result = transaction.exec();//执行事务

            if (result == null) {//事务提交失败，说明在执行期间数据被修改过

                System.out.println("扣费transaction事务执行中断...");
                throw new Exception();

            } else {//事务提交成功
                balance = Integer.parseInt(jedis.get("balance"));
                debt = Integer.parseInt(jedis.get("debt"));
                System.out.println("扣费transaction事务执行结束...");

                System.out.println("您的可用余额:" + balance);
                System.out.println("您目前欠款:" + debt);

                return true;
            }
        }
    }
}

 

redis的事务存在的问题。redis只能保证事务的每个命令连续执行，但是如果事务中的一个命令失败了，并不回滚其他命令

以下是这种做法的优点:
1.Redis 命令只会因为错误的语法而失败（并且这些问题不能在入队时发现），或是命令用在了错误类型的键上面，从实用性的角度来说，失败的命令是由编程错误造成的，而这些错误应该在开发的过程中被发现，而不应该出现在生产环境中。
2.因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。

参考资料：http://doc.redisfans.com/index.html