❶ redis循环查询map好还是根据field查询好
两者都可以
1.1、启动Redis> redis-server [--port 6379]如果命令参数过多，建议通过配置文件来启动Redis。
2、连接Redis
3、停止Redis
4、发送命令给Redis发送命令有两种方式
5、测试连通性127.0.0.1:6379> pingPONGkey操作命令
获取所有键
❷ 深入了解Redis操作五大数据类型常用命令
我们知道Redis默认有16个数据库，默认是第0个数据库，那么如果在需要对数据库进行切换的时候，我们就可以使用下面这个命令：
使用如下命令进行切换
如果想要清除指定某一个数据库的数据
清除所有数据库的数据
接下来这个命令应该是最常用的了
平常在开发中，我们还需要经常对key进行判断，判断其是否存在
因为我们设置的缓存数据一般都不能是永久的，这个时候就需要我们在存储数据的时候，就为其设置过期时间。
string类型是Redis中五大基本数据类型之一，这也是最常使用到的一个数据类型，所有很多小伙伴们对Redis的认识和操作就仅仅的停留在了对Redis的操作层面，但是你是否知道string类型中的相关命令，还是有非常多实用的
接下来先看一下对string类型进行基本存储和获取的命令。
如果我们存储的string中的内容是数字的话，我们也可以对其进行增或减操作，Redis可以自动的对字符串进行相关的操作。实现的命令如下：
使用msetnx时，同时设置一个或多个 key-value 对，当且仅当所有给定 key都不存在时才成立。
getset命令从字面意思就可以看出来，他的作用是先get再set。
总结string类似的使用场景：
在使用list类型进行存取的时候，有两个命令需要进行区分：
注意：只有pop和push才分左右，其他的l都是list的意思
总结：
总结set集合一般用于元素的不重复的场景，比如抽奖系统，轮播等场景下
在使用hash集合的时候，要注意，hash其实就是一个Map集合，key-map的时候，值是一个map集合的形式进行存储的，也和java中的hashmap有一个类似。
HVALS获取所有的value，HKEYS获取所有的key，HGETALL获取所有的键值
总结：
hash可以用于存储变更的数据，比如user，name，age等，尤其是用户信息之类的，hash更加适合用于对象的存储，string更加适合用于字符串的存储。
在set集合的基础上增加一个序列号，来进行排序
ZRANGEBYSCORE使用语法
总结
以上是在对五种数据类型进行存取时的一些常用命令操作。关于其他的命令使用，小伙伴们在用到的时候可以直接入官网查看就可以了。
❸ java 监听redis map是否有修改
/**
* @param args
*/
public static void main(String[] args) {
//连接 redis 服务
Jedis jedis = new Jedis( "192.168.88.15" ,6379);
//密码验证-如果你没有设置 redis 密码可不验证即可使用相关命令
// jedis.auth(" abcdefg ");
//简单的key-value 存储
jedis.set( "redis" , "myredis" );
System. out .println(jedis.get( "redis" ));
//在原有值得基础上添加,如若之前没有该key，则导入该key
//之前已经设定了 redis 对应" myredis ",此句执行便会使 redis 对应"myredisyourredis "
jedis.append( "redis" , "yourredis" );
jedis.append( "content" , "rabbit" );
// mset 是设置多个key-value值 参数（key1,value1,key2,value2,..., keyn , valuen）
// mget 是获取多个key所对应的value值 参数（key1,key2,key3,..., keyn ） 返回的是个list
jedis.mset( "name1" , "yangw" , "name2" , "demon" , "name3" , "elena" );
System. out .println(jedis.mget( "name1" , "name2" , "name3" ));
//map
Map<String,String> user = new HashMap<String,String>();
user.put( "name" , "cd" );
user.put( "password" , "123456" );
//map存入 redis
jedis.hmset( "user" , user);
// mapkey 个数
System. out .println(String. format ( "len:%d" , jedis.hlen( "user" )));
//map中的所有键值
System. out .println(String. format ( "keys: %s" , jedis.hkeys( "user" ) ));
//map中的所有value
System. out .println(String. format ( "values: %s" , jedis.hvals( "user" ) ));
//取出map中的name字段值
List<String> rsmap = jedis.hmget( "user" , "name" , "password" );
System. out .println(rsmap);
//删除map中的某一个键值 password
jedis.hdel( "user" , "password" );
System. out .println(jedis.hmget( "user" , "name" , "password" ));
//list
jedis.del( "listDemo" );
System. out .println(jedis.lrange( "listDemo" , 0, -1));
jedis.lpush( "listDemo" , "A" );
jedis.lpush( "listDemo" , "B" );
jedis.lpush( "listDemo" , "C" );
System. out .println(jedis.lrange( "listDemo" , 0, -1));
System. out .println(jedis.lrange( "listDemo" , 0, 1));
//set
jedis.sadd( "sname" , "wobby" );
jedis.sadd( "sname" , "kings" );
jedis.sadd( "sname" , "demon" );
System. out .println(String. format ( "set num: %d" , jedis.scard( "sname" )));
System. out .println(String. format ( "all members: %s" , jedis.smembers( "sname")));
System. out .println(String. format ( "is member: %B" , jedis.sismember( "sname" , "wobby" )));
System. out .println(String. format ( "rand member: %s" , jedis.srandmember("sname" )));
//删除一个对象
jedis.srem( "sname" , "demon" );
System. out .println(String. format ( "all members: %s" , jedis.smembers( "sname")));
}
二、将自定义对象保存到redis中：
1、自定义pojo 实现Serializable 接口：
package cn.mingyuan.redis;
import java.io.Serializable;
/**
* 测试用 pojo ，实现了 Serializable ，以便进行系列化操作
*
* @author mingyuan
*
*/
public class Person implements Serializable {
private static final long serialVersionUID = -3562550857760039655L;
private String name ;
private int age ;
public Person(){}
public Person(String name, int age) {
super ();
this . name = name;
this . age = age;
}
public String getName() {
return name ;
}
public void setName(String name) {
this . name = name;
}
public int getAge() {
return age ;
}
public void setAge( int age) {
this . age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]" ;
}
}
2、测试类：
package cn.mingyuan.redis;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import redis.clients.jedis.Jedis;
public class Test {
/**
* @param args
* @throws IOException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws IOException,
ClassNotFoundException {
// Jedis redis = new Jedis ("192.168.88.15");
Jedis redis = new Jedis( "192.168.88.15" , 6379);
// connect可以不要，因为在执行set操作的时候会先进行判断客户端是否于服务器端建立了连接，若无，则启动连接过程
redis.connect();
String set = redis.set( "mingyuan" , "1" );
System. out .println( " set result \t" + set);
redis.incr( "mingyuan" );
String string = redis.get( "mingyuan" );
System. out .println( " get result of key 'mingyuan' \t" + string);
// 下面是对对象进行存储的测试代码
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
Person person = new Person( "liudehua" ,22);
oos.writeObject(person);
byte [] byteArray = bos.toByteArray();
oos.close();
bos.close();
String setObjectRet = redis.set( "mingyuan" .getBytes(), byteArray);
System. out .println( " set object return \t" + setObjectRet);
byte [] bs = redis.get( "mingyuan" .getBytes());
ByteArrayInputStream bis = new ByteArrayInputStream(bs);
ObjectInputStream inputStream = new ObjectInputStream(bis);
Person readObject = (Person) inputStream.readObject();
System. out .println( " read object \t" + readObject.toString());
inputStream.close();
bis.close();
redis.disconnect();
}
}
❹ 京东面试官：Redis 这些我必问
缓存好处：高性能 + 高并发
数据库查询耗费了800ms，其他用户对同一个数据再次查询 ，假设该数据在10分钟以内没有变化过，并且 10 分钟之内有 1000 个用户 都查询了同一数据，10 分钟之内，那 1000 每个用户，每个人查询这个数据都感觉很慢 800ms
比如 ：某个商品信息，在 一天之内都不会改变，但是这个商品每次查询一次都要耗费2s，一天之内被浏览 100W次
mysql 单机也就 2000qps,缓存单机轻松几万几十万qps,单机 承载并发量是 mysql 单机的几十倍。
在中午高峰期，有 100W 个用户访问系统 A，每秒有 4000 个请求去查询数据库，数据库承载每秒 4000 个请求会宕机，加上缓存后，可以 3000 个请求走缓存 ，1000 个请求走数据库。
缓存是走内存的，内存天然可以支撑4w/s的请求，数据库（基于磁盘）一般建议并发请求不要超过 2000/s
redis 单线程 ，memcached 多线程
redis 是单线程 nio 异步线程模型
一个线程+一个队列
redis 基于 reactor 模式开发了网络事件处理器，这个处理器叫做文件事件处理器，file event handler，这个文件事件处理器是单线程的，所以redis 是单线程的模型，采用 io多路复用机制同时监听多个 socket,根据socket上的事件来选择对应的事件处理器来处理这个事件。
文件事件处理器包含：多个 socket,io多路复用程序，文件事件分派器，事件处理器（命令请求处理器、命令恢复处理器、连接应答处理器）
文件事件处理器是单线程的，通过 io 多路复用机制监听多个 socket，实现高性能和线程模型简单性
被监听的 socket 准备好执行 accept,read,write,close等操作的时候，会产生对应的文件事件，调用之前关联好的时间处理器处理
多个 socket并发操作，产生不同的文件事件，i/o多路复用会监听多个socket，将这些 socket放入一个队列中排队。事件分派器从队列中取出socket给对应事件处理器。
一个socket时间处理完后，事件分派器才能从队列中拿到下一个socket，给对应事件处理器来处理。
文件事件：
AE_READABLE 对应 socket变得可读（客户端对redis执行 write操作）
AE_WRITABLE 对应 socket 变得可写（客户端对 redis执行 read操作）
I/O 多路复用可以同时监听AE_REABLE和 AE_WRITABLE ，如果同时达到则优先处理 AE_REABLE 时间
文件事件处理器：
连接应答处理器 对应 客户端要连接 redis
命令请求处理器 对应 客户端写数据到 redis
命令回复处理器 对应 客户端从 redis 读数据
流程：
一秒钟可以处理几万个请求
普通的 set,get kv缓存
类型 map结构，比如一个对象（没有嵌套对象）缓存到 redis里面，然后读写缓存的时候，可以直接操作hash的字段（比如把 age 改成 21，其他的不变）
key=150
value = {
}
有序列表 ，元素可以重复
可以通过 list 存储一些列表型数据结构，类似粉丝列表，文章评论列表。
例如：微信大 V的粉丝，可以以 list 的格式放在 redis 里去缓存
key=某大 V value=[zhangsan,lisi,wangwu]
比如 lrange 可以从某个元素开始读取多少个元素，可以基于 list 实现分页查询功能，基于 redis实现高性能分页，类似微博下来不断分页东西。
可以搞个简单的消息队列，从 list头怼进去（lpush），list尾巴出来 (brpop)
无序集合，自动去重
需要对一些数据快速全局去重，（当然也可以基于 HashSet，但是单机）
基于 set 玩差集、并集、交集的操作。比如：2 个人的粉丝列表整一个交集，看看 2 个人的共同好友是谁？
把 2 个大 V 的粉丝都放在 2 个 set中，对 2 个 set做交集（sinter）
排序的 set，去重但是可以排序，写进去的时候给一个分数，自动根据分数排序
排行榜：
zadd board score username
例如：
zadd board 85 zhangsan
zadd board 72 wangwu
zadd board 96 lis
zadd board 62 zhaoliu
自动排序为：
96 lisi
85 zhangsan
72 wangwu
62 zhaoliu
获取排名前 3 的用户 ： zrevrange board 0 3
96 lisi
85 zhangsan
72 wangwu
查看zhaoliu的排行 ：zrank board zhaoliu 返回 4
内存是宝贵的，磁盘是廉价的
给key设置过期时间后，redis对这批key是定期删除+惰性删除
定期删除：
redis 默认每隔 100ms随机抽取一些设置了过期时间的 key，检查其是否过期了，如果过期就删除。
注意：redis是每隔100ms随机抽取一些 key来检查和删除，而不是遍历所有的设置过期时间的key（否则CPU 负载会很高，消耗在检查过期 key 上）
惰性删除：
获取某个key的时候， redis 会检查一下，这个key如果设置了过期时间那么是否过期，如果过期了则删除。
如果定期删除漏掉了许多过期key，然后你也没及时去查，也没走惰性删除，如果大量过期的key堆积在内存里，导致 redis 内存块耗尽，则走内存淘汰机制。
内存淘汰策略：
LRU 算法：
缓存架构（多级缓存架构、热点缓存）
redis 高并发瓶颈在单机，读写分离，一般是支撑读高并发，写请求少，也就 一秒一两千，大量请求读，一秒钟二十万次。
一主多从，主负责写，将数据同步复制到其他 slave节点，从节点负责读，所有读的请求全部走从节点。主要是解决读高并发。、
主从架构->读写分离->支撑10W+读QPS架构
master->slave 复制，是异步的
核心机制：
master持久化对主从架构的意义：
如果开启了主从架构，一定要开启 master node的持久化，不然 master宕机重启数据是空的，一经复制，slave的数据也丢了
主从复制原理：
第一次启动或者断开重连情况：
正常情况下：
master 来一条数据，就异步给 slave
全年 99.99%的时间，都是出于可用的状态，那么就可以称为高可用性
redis 高可用架构叫故障转移，failover，也可以叫做主备切换，切换的时间不可用，但是整体高可用。
sentinal node(哨兵)
作用：
quorum = 1 （代表哨兵最低个数可以尝试故障转移，选举执行的哨兵）
master 宕机，只有 S2 存活，因为 quorum =1 可以尝试故障转移，但是没达到 majority =2 （最低允许执行故障转移的哨兵存活数）的标准，无法执行故障转移
如果 M1 宕机了，S2,S3 认为 master宕机，选举一个执行故障转移，因为 3 个哨兵的 majority = 2，所以可以执行故障转移
丢数据：
解决方案：
sdown 主观宕机，哨兵觉得一个 master 宕机（ping 超过了 is-master-down-after-milliseconds毫秒数）
odown 客观宕机，quorum数量的哨兵都觉得 master宕机
哨兵互相感知通过 redis的 pub/sub系统，每隔 2 秒往同一个 channel里发消息（自己的 host,ip,runid），其他哨兵可以消费这个消息
以及同步交换master的监控信息。
哨兵确保其他slave修改master信息为新选举的master
当一个 master被认为 odown && marjority哨兵都同意，那么某个哨兵会执行主备切换，选举一个slave成为master（考虑 1. 跟master断开连接的时长 2. slave 优先级 3.复制 offset 4. runid）
选举算法：
quorum 数量哨兵认为odown->选举一个哨兵切换->获得 majority哨兵的授权（quorum majority 需要 majority个哨兵授权，quorum >= majority 需要 quorum 哨兵授权）
第一个选举出来的哨兵切换失败了，其他哨兵等待 failover-time之后，重新拿confiuration epoch做为新的version 切换，保证拿到最新配置，用于 configuration传播（通过 pu/sub消息机制，其他哨兵对比 version 新旧更新 master配置）
高并发：主从架构
高容量：Redis集群，支持每秒几十万的读写并发
高可用：主从+哨兵
持久化的意义在于故障恢复数据备份（到其他服务器）+故障恢复（遇到灾难，机房断电，电缆被切）
AOF 只有一个，Redis 中的数据是有一定限量的，内存大小是一定的,AOF 是存放写命令的，当大到一定的时候，AOF 做 rewrite 操作，就会基于当时 redis 内存中的数据，来重新构造一个更小的 AOF 文件，然后将旧的膨胀很大的文件给删掉，AOF 文件一直会被限制在和Redis内存中一样的数据。AOF同步间隔比 RDB 小，数据更完整
优点：
缺点：
AOF 存放的指令日志，数据恢复的时候，需要回放执行所有指令日志，RDB 就是一份数据文件，直接加载到内存中。
优点：
缺点：
AOF 来保证数据不丢失，RDB 做不同时间的冷备
支持 N 个 Redis master node,每个 master node挂载多个 slave node
多master + 读写分离 + 高可用
数据量很少，高并发 -> replication + sentinal 集群
海量数据 + 高并发 + 高可用 -> redis cluster
hash算法->一致性 hash 算法-> redis cluster->hash slot算法
redis cluster :自动对数据进行分片，每个 master 上放一部分数据，提供内置的高可用支持，部分master不可用时，还是可以继续工作
cluster bus 通过 16379进行通信，故障检测，配置更新，故障转移授权，另外一种二进制协议，主要用于节点间进行高效数据交换，占用更少的网络带宽和处理时间
key进行hash，然后对节点数量取模，最大问题只有任意一个 master 宕机，大量数据就要根据新的节点数取模，会导致大量缓存失效。
key进行hash，对应圆环上一个点，顺时针寻找距离最近的一个点。保证任何一个 master 宕机，只受 master 宕机那台影响，其他节点不受影响，此时会瞬间去查数据库。
缓存热点问题：
可能集中在某个 hash区间内的值特别多，那么会导致大量的数据都涌入同一个 master 内，造成 master的热点问题，性能出现瓶颈。
解决方法：
给每个 master 都做了均匀分布的虚拟节点，这样每个区间内大量数据都会均匀的分布到不同节点内，而不是顺时针全部涌入到同一个节点中。
redis cluster 有固定 16384 个 hash slot,对每个key计算 CRC16 值，然后对16384取模，可以获取 key对应的 hash slot
redis cluster 中每个 master 都会持有部分 slot ,当一台 master 宕机时候，会最快速度迁移 hash slot到可用的机器上（只会短暂的访问不到）
走同一个 hash slot 通过 hash tag实现
集群元数据：包括 hashslot->node之间的映射表关系，master->slave之间的关系，故障的信息
集群元数据集中式存储（storm），底层基于zookeeper（分布式协调中间件）集群所有元数据的维护。好处：元数据的更新和读取，时效性好，一旦变更，其他节点立刻可以感知。缺点：所有元数据的更新压力全部集中在一个地方，可能会导致元数据的存储有压力。
goosip: 好处：元数据的更新比较分散，有一定的延时，降低了压力。缺点：更新有延时，集群的一些操作会滞后。（reshared操作时configuration error）
自己提供服务的端口号+ 10000 ，每隔一段时间就会往另外几个节点发送ping消息，同时其他几点接收到ping之后返回pong
故障信息，节点的增加和移除， hash slot 信息
meet:某个节点发送 meet给新加入的节点，让新节点加入集群中，然后新节点就会开始于其他节点进行通信
ping:每个节点都会频繁给其他节点发送ping，其中包含自己的状态还有自己维护的集群元数据，互相通过ping交换元数据
ping:返回ping和meet，包含自己的状态和其他信息
fail:某个节点判断另一个节点fail之后，就发送 fail 给其他节点，通知其他节点，指定的节点宕机了
ping 很频繁，且携带元数据，会加重网络负担
每个节点每秒会执行 10 次 ping，每次选择 5 个最久没有通信的其他节点
当如果发现某个节点通信延迟达到了 cluster_node_timeout /2 ，那么立即发送 ping， 避免数据交换延迟过长，落后时间太长（2 个节点之间 10 分钟没有交换数据，整个集群处于严重的元数据不一致的情况）。
每次ping，一个是带上自己的节点信息，还有就是带上1/10其他节点的信息，发送出去，进行数据交换
至少包含 3 个其他节点信息，最多包含总节点-2 个其他节点的信息
客户端发送到任意一个redis实例发送命令，每个redis实例接受到命令后，都会计算key对应的hash slot，如果在本地就本地处理，否则返回moved给客户端，让客户端进行重定向 （redis-cli -c）
通过tag指定key对应的slot,同一个 tag 下的 key，都会在一个 hash slot中，比如 set key1:{100} 和 set key2:{100}
本地维护一份hashslot->node的映射表。
JedisCluster 初始化的时候，随机选择一个 node，初始化 hashslot->node 映射表，同时为每个节点创建一个JedisPool连接池，每次基于JedisCluster执行操作，首先JedisCluster都会在本地计算key的hashslot，然后再本地映射表中找到对应的节点，如果发现对应的节点返回moved，那么利用该节点的元数据，更新 hashslot->node映射表（重试超过 5 次报错）
hash slot正在迁移，那么会返回ask 重定向给jedis,jedis 接受到ask重定向之后，，会重定向到目标节点去执行
判断节点宕机：
如果一个节点认为另外一个节点宕机了， 就是pfail,主观宕机
如果多个节点都认为另外一个节点宕机了，那么就是fail，客观宕机（跟哨兵原理一样）
在cluster-node-timeout内，某个节点一直没有返回 pong,那么就被认为是 pfail
如果一个节点认为某个节点pfail了，那么会在gossip消息中，ping给其他节点，如果超过半数的节点认为pfail了，那么就会变成fail。
从节点过滤：
对宕机的 mster node ，从其所有的 slave node中，选择一个切换成 master node
检查每个 slave node与master node断开连接的时间，如果超过了cluster-node-timeout * cluster-slave-validity-factor，那么就没资格切换成 master（和哨兵一致）
从节点选举：
每个从节点，根据自己对 master 复制数据的 offset，设置一个选举时间，offset越大（复制数据越多）的从节点，选举时间越靠前，所有的 master node 开始投票，给要进行选举的 slave进行投票，如果大部分 master node(N/2 +1) 都投票给某个从节点，那么选举通过，从节点执行主备切换，从节点切换成主节点
总结：和哨兵很像，直接集成了 replication 和 sentinal
方案：
事前：保证 redis 集群高可用性 （主从+哨兵或 redis cluster），避免全盘崩溃
事中：本地 ehcache 缓存 + hystrix 限流（保护数据库） & 降级，避免 MySQL被打死
事后： redis持久化，快速恢复缓存数据，继续分流高并发请求
限制组件每秒就 2000 个请求通过限流组件进入数据库，剩余的 3000 个请求走降级，返回一些默认 的值，或者友情提示
好处 ：
4000 个请求黑客攻击请求数据库里没有的数据
解决方案：把黑客查数据库中不存在的数据的值，写到缓存中，比如： set -999 UNKNOWN
读的时候，先读缓存，缓存没有，就读数据库，然后取出数据后放入缓存，同时返回响应
更新的时候，删除缓存，更新数据库
为什么不更新缓存：
更新缓存代价太高（更新 20 次，只读 1 次），lazy思想，需要的时候再计算，不需要的时候不计算
方案：先删除缓存，再修改数据库
方案：写，读路由到相同的一个内存队列（唯一标识，hash，取模）里，更新和读操作进行串行化（后台线程异步执行队列串行化操作），（队列里只放一个更新查询操作即可，多余的过滤掉，内存队列里没有该数据更新操作，直接返回 ）有该数据更新操作则轮询取缓存值，超时取不到缓存值，直接取一次数据库的旧值
TP 99 意思是99%的请求可以在200ms内返回
注意点：多个商品的更新操作都积压在一个队列里面（太多操作积压只能增加机器），导致读请求发生大量的超时，导致大量的读请求走数据库
一秒 500 写操作，每200ms，100 个写操作，20 个内存队列，每个队列积压 5 个写操作，一般在20ms完成
方案：分布式锁 + 时间戳比较
10台机器，5 主 5 从，每个节点QPS 5W ，一共 25W QPS（Redis cluster 32G + 8 核 ，Redis 进程不超过 10G）总内存 50g，每条数据10kb，10W 条数据1g，200W 条数据 20G，占用总内存不到50%，目前高峰期 3500 QPS
作者： mousycoder
❺ redis 命令get什么意思
redis 127.0.0.1:6379> config get *max-*-entries*
1) "hash-max-zipmap-entries"
2) "512"
3) "list-max-ziplist-entries"
4) "512"
5) "set-max-intset-entries"
6) "512"
❻ 如何在Java中应用Redis操作HashMap
HASHMAP最好与实例联系起来..它主要存的是键与值的关系.
举个例子如你现在有一个学生类
import java.util.HashMap;
public class Student {
String name;
String sex;
public Student(String n,String s) {
name=n;
sex=s;
}
public String toString(){
return ("姓名:"+name+"\n"+"性别:"+sex+"\n");
}
public static void main(String [] args){
HashMap hm=new HashMap();
Student s1=new Student("张三","男");
Student s2=new Student("李四","男");
Student s3=new Student("小利","女");
//存值是根据学生编号存的学生信息
hm.put("001",s1);
hm.put("002",s2);
hm.put("003",s3);
//查找学生编号是001的学生
//因为hm.get("001")反回的是Object所以加上强转
Student s=(Student)hm.get("001");
System.out.println(s.toString());
//其余的类似
}
}
❼ Redis --- 八种数据类型（基本命令）
String、Hash、List、Set和Zset。
等同于java中的， Map<String,String> string 是redis里面的最基本的数据类型，一个key对应一个value。
应用场景 ：String是最常用的一种数据类型，普通的key/value存储都可以归为此类，如用户信息，登录信息和配置信息等；
实现方式 ：String在redis内部存储默认就是一个字符串，被redisObject所引用，当遇到incr、decr等操作（自增自减等原子操作）时会转成数值型进行计算，此时redisObject的encoding字段为int。
Redis虽然是用C语言写的，但却没有直接用C语言的字符串，而是自己实现了一套字符串。目的就是为了提升速度，提升性能。 Redis构建了一个叫做简单动态字符串（Simple Dynamic String），简称SDS。
Redis的字符串也会遵守C语言的字符串的实现规则，即 最后一个字符为空字符。然而这个空字符不会被计算在len里头。
Redis动态扩展步骤：
Redis字符串的性能优势
常用命令 ：set/get/decr/incr/mget等，具体如下；
ps：计数器（字符串的内容为整数的时候可以使用），如 set number 1。
补充：
等同于java中的： Map<String,Map<String,String>> ，redis的hash是一个string类型的field和value的映射表， 特别适合存储对象。 在redis中，hash因为是一个集合，所以有两层。第一层是key：hash集合value，第二层是hashkey：string value。所以判断是否采用hash的时候可以参照有两层key的设计来做参考。并且注意的是， 设置过期时间只能在第一层的key上面设置。
应用场景 ：我们要存储一个用户信息对象数据，其中包括用户ID、用户姓名、年龄和生日，通过用户ID我们希望获取该用户的姓名或者年龄或者生日；
实现方式 ：Redis的Hash实际是内部存储的Value为一个HashMap，并提供了直接存取这个Map成员的接口。如，Key是用户ID, value是一个Map。 这个Map的key是成员的属性名，value是属性值 。这样对数据的修改和存取都可以直接通过其内部Map的Key(Redis里称内部Map的key为field), 也就是通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据。 当前HashMap的实现有两种方式 ：当HashMap的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，这时对应的value的redisObject的encoding为zipmap，当成员数量增大时会自动转成真正的HashMap,此时redisObject的encoding字段为int。
常用命令 ：hget/hset/hgetall等，具体如下：
等同于java中的 Map<String,List<String>> ，list 底层是一个链表，在redis中，插入list中的值，只需要找到list的key即可，而不需要像hash一样插入两层的key。 list是一种有序的、可重复的集合。
应用场景 ：Redis list的应用场景非常多，也是Redis最重要的数据结构之一，比如twitter的关注列表，粉丝列表等都可以用Redis的list结构来实现；
实现方式 ：Redis list的实现为一个 双向链表 ，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，Redis内部的很多实现，包括 发送缓冲队列 等也都是用的这个数据结构。
常用命令 ：lpush/rpush/lpop/rpop/lrange等，具体如下：
性能总结 :
它是一个字符串链表，left、right都可以插入添加。
等同于java中的 Map<String,Set<String>> ，Set 是一种无序的，不能重复的集合。并且在redis中，只有一个key它的底层由hashTable实现的，天生去重。
应用场景 ：Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动去重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且 set提供了判断某个成员是否在一个set集合内的重要接口 ，这个也是list所不能提供的；如保存一些标签的名字。标签的名字不可以重复，顺序是可以无序的。
实现方式 ：set 的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因。
常用命令 ：sadd/spop/smembers/sunion等，具体如下：
ZSet(Sorted Set：有序集合) 每个元素都会关联一个double类型的分数score，分数允许重复，集合元素按照score排序（ 当score相同的时候，会按照被插入的键的字典顺序进行排序 ），还可以通过 score 的范围来获取元素的列表。
应用场景 ：Redis sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以 通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。 当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构，比如twitter 的public timeline可以以发表时间作为score来存储，这样获取时就是自动按时间排好序的。
底层实现 ： zset 是 Redis 提供的一个非常特别的数据结构，常用作排行榜等功能，以用户 id 为 value ，关注时间或者分数作为 score 进行排序。实现机制分别是 zipList 和 skipList 。规则如下：
zipList：满足以下两个条件
skipList：不满足以上两个条件时使用跳表、组合了hash和skipList
为什么用skiplist不用平衡树？
主要从内存占用、对范围查找的支持和实现难易程度这三方面总结的原因。
拓展：mysql为什么不用跳表？
常用命令 ：zadd/zrange/zrem/zcard等；
官网地址： https://redis.io/commands/geoadd
可以用来推算两地之间的距离，方圆半径内的人。
关于经度纬度的限制： https://www.redis.net.cn/order/3685.html
一般我们使用Hyperloglog做基数统计。
什么是基数？就是一个集合中不重复的数的个数。
集合A：{1,3,5,7,9,7}
集合B：{1,3,5,7,9}
AB集合的基数都是5
应用：统计网站的访问量（一个人访问网站很多次仍然算作一次）。
优点：占用的内存是固定的，找2^64次方个数的基数，只需要12KB内存。
缺点：有0.81%的错误率，可以忽略不计
概述： bitmap 存储的是连续的二进制数字（0 和 1），通过 bitmap, 只需要一个 bit 位来表示某个元素对应的值或者状态，key 就是对应元素本身 。 我们知道 8 个 bit 可以组成一个 byte，所以 bitmap 本身会极大的节省储存空间。
应用场景: 适合需要保存状态信息（比如是否签到、是否登录...）并需要进一步对这些信息进行分析的场景。比如用户签到情况、活跃用户情况、用户行为统计（比如是否点赞过某个视频）。
针对上面提到的一些场景，这里进行进一步说明。
使用场景一：用户行为分析 很多网站为了分析你的喜好，需要研究你点赞过的内容。
使用场景二：统计活跃用户
使用时间作为 key，然后用户 ID 为 offset，如果当日活跃过就设置为 1
那么我该如果计算某几天/月/年的活跃用户呢(暂且约定，统计时间内只有有一天在线就称为活跃)，有请下一个 redis 的命令
使用场景三：用户在线状态
对于获取或者统计用户在线状态，使用 bitmap 是一个节约空间效率又高的一种方法。
只需要一个 key，然后用户 ID 为 offset，如果在线就设置为 1，不在线就设置为 0。
补充 ：
巨人的肩膀：
https://www.cnblogs.com/Small-sunshine/p/11687809.html
https://mp.weixin.qq.com/s/CMu7oXVIKp2s-PXTdMlimA
❽ 如何安装Redis集群
创建目录，配置文件
如何安装Redis集群
修改配置文件
按照此方式修改7001~7005的配置文件，注意修改端口号。
如何安装Redis集群
启动各个实例
如何安装Redis集群
创建集群
现在我们已经有了六个正在运行中的 Redis 实例， 接下来我们需要使用这些实例来创建集群， 并为每个节点编写配置文件。
通过使用 Redis 集群命令行工具redis-trib，编写节点配置文件的工作可以非常容易地完成redis-trib位于Redis 源码的src文件夹中，它是一个 Ruby 程序，这个程序通过向实例发送特殊命令来完成创建新集群，检查集群，或者对集群进行重新分片（reshared）等工作。
我们需要执行以下命令来创建集群：
[root@localhost src]# ./redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005
/usr/bin/env: ruby: No such file or directory
如何安装Redis集群
系统中没有安装ruby，所以报上面的错误。
先安装ruby
[root@localhost yum.repos.d]# yum install ruby
[root@localhost yum.repos.d]# yum install rubygems
[root@localhost yum.repos.d]# gem install redis
Successfully installed redis-3.2.2
1 gem installed
Installing ri documentation for redis-3.2.2...
Installing RDoc documentation for redis-3.2.2...
如何安装Redis集群
再次创建集群
[root@localhost src]# ./redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005
Redis自动选择主从
如何安装Redis集群
连接集群
redis-cli 也可以作为集群的客户端工具，要想访问集群，只需连接任意一个redis实例即可。使用-c参数
[root@localhost bin]# ./redis-cli -c -p 7000
总结
set 命令写数据，集群将数据写到7001实例上，当你使用get命令获取数据时，客户端即自动切换到7001端口。
redis-cli对集群的支持是非常基本的， 所以它总是依靠 Redis 集群节点来将它转向（redirect）至正确的节点。一个真正的（serious）集群客户端应该做得比这更好： 它应该用缓存记录起哈希槽与节点地址之间的映射（map）， 从而直接将命令发送到正确的节点上面。
❾ 如何设置redis一秒钟持久化一次
此外，我还讨论过较为常见的基于服务器的数据存储，比如MongoDB和CouchDB。每个数据存储都有其优势和劣势，特别是当应用于特定领域时。本期的Java开发2.0关注的是Redis，一种轻量级键值对数据存储。多数NoSQL实现本质上都是键值对，但是Redis支持非常丰富的值集，其中包括字符串、列表、集以及散列。因此，Redis通常被称为数据结构服务器。Redis也以异常快速而闻名，这使得它成为某一特定类型使用案例的最优选择。当我们想要了解一种新事物时，将其同熟知的事物进行比较可能会有所帮助，因此，我们将通过对比其与memcached的相似性以开启Redis探索之旅。接着我们将介绍Redis的主要功能，这些功能可以使其在某些应用场景可以胜过memcached。最后我将向您展示如何将Redis作为一个传统数据存储用于模型对象。Redis和memcachedMemcached是一个众所周知的内存对象缓存系统，通过将目标键和值导入内存缓存运行。因此，Memcached能回避读取磁盘时发生的I/O成本问题。在Web应用程序和数据库之间粘贴memcached时会产生更好的读取性能。因此，对于那些需要快速数据查询的应用程序，Memcached是一个不错的选择。其中的一个例子为股票查询服务，需要另外访问数据库获取相对静态数据，如股票名称或价格信息。MemcacheDB将Redis与memcached相比较并不公平，它与MemcacheDB相比要好的多，MemcacheDB是一个分布式键值对存储系统，专为数据持久化而设计。MemcacheDB与Redis较为相似，其新增优势可以使其轻松地与memcached实现的客户端进行通信。但是memcached也有其局限性，其中一个事实就是它所有的值均是简单的字符串。Redis作为memcached的替代者，支持更加丰富的功能集。一些基准(benchmarks)也表明Redis的速度要比memcached快很多。Redis提供的丰富数据类型使其可以在内存中存储更为复杂的数据，这是使用memcached无法实现的。同memcached不一样，Redis可以持久化其数据。Redis解决了一个重大的缓存问题，而其丰富的功能集又为其找到了其他用途。由于Redis能够在磁盘上存储数据以及跨节点复制数据，因而可以作为数据仓库用于传统数据模式（也就是说，您可以使用Redis，就像使用RDBMS一样）。Redis还经常被用作队列系统。在本用例中，Redis是备份和工作队列持久化存储（利用Redis的列表类型）的基础。GitHub是以此种方法使用Redis的大规模基础架构示例准备好Redis，立即开始!要开始使用Redis，您需要访问它，可以通过本地安装或者托管供应商来实现访问。如果您使用的MAC，安装过程可能就不那么简单。如果您使用的是Windows??，您需要先安装Cygwin。如果您正在寻找一个托管供应商，Redis4You拥有一个免费计划。不管您以何种方式访问，您都能够根据本文下列示例进行操作，但是我需要指出的是，使用一个托管供应商进行缓存可能并不是很好的缓存解决方案，因为网络延迟可能会抵消任何性能优势。您需要通过命令与Redis进行交互，这就是说，这里没有SQL类查询语言。使用Redis工作非常类似于使用传统map数据结构，即所有的一切都拥有一个键和一个值，每个值都有多种与之关联的数据类型。每个数据类型都有其自己的命令集。例如，如果您计划使用简单数据类型，比如某种缓存模式，您可以使用命令set和get。您可以通过命令行shell与一个Reids实例进行交互。还有多个客户端实现，可以以编程方式与Redis进行交互。清单1展示了一个使用基础命令的简单命令行shell交互：清单1.使用基础的Redis命令redis127.0.0.1:6379>setpageregistrationOKredis127.0.0.1:6379>keys*1)"foo"2)"page"redis127.0.0.1:6379>getpage"registration"在这里，我通过set命令将键"page"与值"registration"相关联。接着，我发出keys命令（后缀*表示我想看到所有可用的实例键。keys命令显示有一个page值和一个foo，我可以通过get命令检索到与一个键关联的值。请记住，使用get检索到的值只能是一个字符串。如果一个键的值是一个列表，那么您必须使用一个特定列表的命令来检索列表元素。（注意，有可以查询值类型的命令）。Java与Jedis集成对于那些想要将Redis集成到Java应用程序的编程人员，Redis团队建议使用一个名为Jedis的项目，Jedis是一个轻量级库，可以将本地Redis命令映射到Java方法。例如Jedis可以获取并设置简单值，如清单2所示：清单2.Java代码中的基础Redis命令JedisPoolpool=newJedisPool(newJedisPoolConfig(),"localhost");Jedisjedis=pool.getResource();jedis.set("foo","bar");Stringfoobar=jedis.get("foo");assertfoobar.equals("bar");pool.returnResource(jedis);pool.destroy();在清单2中，我配置了一个连接池并捕获连接，（与您在典型JDBC场景中的操作非常相似）然后我在清单的底部设置了返回操作。在连接池逻辑之间，我设置了值"bar"和键"foo"，这是我通过get命令检索到的。与memcached类似，Redis允许您将过期（expiration）时间关联到一个值。因此我设置了这样一个值（比如，股票临时交易价格），最终将从Redis缓存中清除掉。如果我想在Jedis中设置一个过期时间，需要在发出set调用之后将其和一个过期时间关联。如清单3所示：清单3.Redis值可以设置为终止jedis.set("gone","daddy,gone");jedis.expire("gone",10);Stringthere=jedis.get("gone");assertthere.equals("daddy,gone");Thread.sleep(4500);StringnotThere=jedis.get("gone");assertnotThere==null;在清单3中，我使用了一个expire调用将"gone"的值设置为在10秒钟内终止。调用Thread.sleep之后，"gone"的get调用会返回null。Redis中的数据类型使用Redis数据类型，比如列表和散列需要专用命令用法。例如，我可以通过为键附加值来创建列表。
❿ redis中list和hash的基本命令和使用场景
Redis的数据类型
Redis的数据类型共有五种：string，list，hash，set，zset；
String 字符串相对来说做平常，key-value，类似是hashmap的用法；
List 队列，可以双向的存值，设计时，也可以简单用来当队列模式；
Hash 字典，一个key 对应多个值；
Set 无序的集合；
Zset 有序的集合；
列表 list
Redis列表是简单的字符串行表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）
列表 list—— 基本命令
lpush
语法：lpush key value [value„]
作用：将一个或多个值 value 插入到列表 key 的表头（最左边），从左边开始加入值，从左到右的顺序依次插入到表头
返回值：数字，新列表的长度
rpush
语法：rpush key value [value„]
作用：将一个或多个值 value 插入到列表 key 的表尾（最右边），各个 value 值按从左到右 的顺序依次插入到表尾
返回值：数字，新列表的长度
lrange
语法：lrange key start stop
作用：获取列表 key 中指定区间内的元素，0 表示列表的第一个元素，以 1 表示列表的第二个元素；
start ,
stop 是列表的下标值，也可以负数的下标， -1 表示列表的最后一个元素， -2 表示列表的倒 数第二个元素，以此类推。
start ，stop 超出列表的范围不会出现错误。
返回值：指定区间的列表
lindex
语法：lindex key index
作用：获取列表 key 中下标为指定 index 的元素，列表元素不删除，只是查询。
0 表示列表的第一个元素，以 1 表示列表的第二个元素；
start ,
stop 是列表的下标值，也可以负数的下标， -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
返回值：指定下标的元素；index 不在列表范围，返回nil
llen
语法：llen key
作用：获取列表 key 的长度 返回值：数值，列表的长度； key 不存在返回0
lrem
语法：lrem key count value
作用：根据参数count的值，移除列表中与参数value相等的元素，
count>0，从列表的左侧向右开始移 除；
count<0从列表的尾部开始移除；
count=0 移除表中所有与value相等的值。
返回值：数值，移除的元素个数
lset
语法：lset key index value
作用：将列表 key 下标为 index 的元素的值设置为 value。
返回值：设置成功返回 ok ; key 不存在或者 index 超出范围返回错误信息
linsert
语法：linsert key BEFORE(前)|AFTER(后) pivot value
作用：
将值value插入到列表key当中位于值pivot之前或之后的位置。
key不存在，pivot不在列表中， 不执行任何操作。
返回值：命令执行成功，返回新列表的长度。没有找到 pivot 返回 -1， key 不存在返回 0。
RPOP key
移除列表的最后一个元素，返回值为移除的元素。
RPOPLPUSH source destination
移除列表的最后一个元素，并将该元素添加到另一个列表并返回
LPOP key
移除列表的第一个元素，返回值为移除的元素。
使用场景
1. 消息队列
队列模式的情况下，可以使用，左进右出的原则，但不建议使用，因为现在市面上有很多成熟的消息中间件，没有必要造轮子；
2．排行榜
某一段时间统计数据的排行榜可以放在list里面，需要分页的话，也可以使用lrange start stop实现；
3. list类型的lpush命令和lrange命令能实现最新列表的功能，每次通过lpush命令往列表里插入新的元素，然后通过lrange命令读取最新的元素列表，如朋友圈的点赞列表、评论列表。
但是，并不是所有的最新列表都能用list类型实现，因为对于频繁更新的列表，list类型的分页可能导致列表元素重复或漏掉，举个例子，当前列表里由表头到表尾依次有（E，D，C，B，A）五个元素，每页获取3个元素，用户第一次获取到（E，D，C）三个元素，然后表头新增了一个元素F，列表变成了（F，E，D，C，B，A），此时用户取第二页拿到（C，B，A），元素C重复了。只有不需要分页（比如每次都只取列表的前5个元素）或者更新频率低（比如每天凌晨更新一次）的列表才适合用list类型实现
哈希类型hash
redis hash是一个 string 类型的 field 和 value 的映射表，hash特别适合用于存储对象，每个 hash 可以存储 232 - 1键值对（40多亿）；
哈希类型 hash—— 基本命令
hset /hget /hmset /hmget /hgetall /hkeys /hvals /hexists
hset
语法：hset hash 表的key field value
作用：将哈希表 key 中的域 field 的值设为value ，如果 key 不存在，则新建 hash 表，执行赋值，如果有 field ,则覆盖值。
返回值： ①如果 field 是 hash 表中新field，且设置值成功，返回 1 ②如果 field 已经存在，旧值覆盖新值，返回0
hget
语法：hget key field
作用：获取哈希表 key 中给定域 field 的值
返回值：field 域的值，如果 key 不存在或者 field 不存在返回nil
hmset
语法：hmset key field value [field value„]
说明：同时将多个field-value(域-值)设置到哈希表key中，此命令会覆盖已经存在的field， hash表key不存在，创建空的hash表，执行hmset.
返回值：设置成功返回ok， 如果失败返回一个错误
hmget
语法：hmget key field [field„]
作用:获取哈希表key中一个或多个给定域的值
返回值：返回和field顺序对应的值，如果field不存在，返回nil
hgetall
语法：hgetall key
作用：获取哈希表key中所有的域和值
返回值：以列表形式返回hash中域和域的值 ，key不存在，返回空hash
hdel
语法：hdel key field [field„]
作用：删除哈希表 key 中的一个或多个指定域 field，不存在 field 直接忽略
返回值：成功删除的 field 的数量
hkeys
语法：hkeys key
作用：查看哈希表 key 中的所有 field 域
返回值：包含所有 field 的列表，key 不存在返回空列表
hvals
语法：hvals key
作用：返回哈希表中所有域的值 返回值：包含哈希表所有域值的列表，key 不存在返回空列表
hexists
语法：hexists key field
作用：查看哈希表 key 中，给定域 field 是否存在
返回值：如果 field 存在，返回 1， 其他返回0
使用场景
1、购物车
以用户id为key，商品id为field，商品数量为value，恰好构成了购物车的3个要素，如下图所示。
2、hash还是比较适合存储对象（key field value）或者是字典表（type，key，vlaue），刚好符合对象的要素，但string + json也可以存储，两则比较有什么区别？
String + json Hash
效率很 高 高
容量 低 低
灵活性 低 高
序列化 简单 复杂