❶ 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
效率很 高 高
容量 低 低
靈活性 低 高
序列化 簡單 復雜