[分散式][Redis]Redis分散式框架搭建與整合
1.啟動服務：
如果基礎以瞭解，請從後往前看。
n 下載安裝檔案(2.8.24 zip)
https://github.com/MSOpenTech/redis/releases
1.1開啟cmd到你redis目錄下：例如cd D:\Develop\Redis\64bit
1.2然後 d:
1.3然後在目錄下輸入 redis-server.exe redis-conf
1.4啟動服務成功。
1.5 redis-cli --raw 啟動客戶端 解決中文編碼
Liunx安裝：
n 下載安裝檔案:
http://download.redis.io/releases/redis-3.2.0.tar.gz
1.切到壓縮檔案路徑下解壓：tar -zxvf redis.gz
2.切到redis3.2.0路徑：make
3.修改配置檔案
4.檢視埠狀況：ps auxf | grep redis-server
5.啟動服務：./redis-server redis.conf(你的redis路徑再前)
6.關閉服務：./src/redis-cli -h 172.30.23.77 -p 6604 shutdown(你的redis路徑在前)
2.Redis練習
jedis下載
http://mvnrepository.com/artifact/redis.clients/jedis/2.8.1
2.1建立專案匯入
commons-pool-1.5.4.jar//連線池
jedis-2.8.1.jar //java操作redis的兩個jar包。
2.2建立一個Redis池
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisUtil {
/**
* 伺服器Ip 172.0.0為預設IP可以再配置檔案中更改
*/
private static StringADDR ="127.0.0.1";
/**
* //埠號 同上
*/
private static int PORT = 6379;
/**
* //訪問密碼
*/
private static StringAUTH ="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 JedisPooljedisPool =null;
//初始化
public RedisUtil(){
initialPool();
}
/**
* 初始化redis連線池
*/
private static void initialPool(){
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWait(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config,ADDR,PORT,TIMEOUT,AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 獲取redis 例項
*/
public synchronized static Jedis getJedis(){
try {
if(jedisPool !=null){
Jedis rescoues = jedisPool.getResource();
return rescoues;
}else{
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 釋放jedis資源
*/
public static void returnResource(final Jedis jedis) {
if (jedis !=null) {
jedisPool.returnResource(jedis);
}
}
2.3建立例項運算元據
2.3.1 獲取redis連線池
jedis= new RedisUtil().getJedis();
2.3.2對KEY的操作
**網上參考
System.out.println("======================key==========================");
// 清空資料
System.out.println("清空庫中所有資料："+jedis.flushDB());
// 判斷key否存在
System.out.println("判斷key999鍵是否存在："+shardedJedis.exists("key999"));
System.out.println("新增key001,value001鍵值對："+shardedJedis.set("key001", "value001"));
System.out.println("判斷key001是否存在："+shardedJedis.exists("key001"));
// 輸出系統中所有的key
System.out.println("新增key002,value002鍵值對："+shardedJedis.set("key002", "value002"));
System.out.println("系統中所有鍵如下：");
Set<String> keys = jedis.keys("*");
Iterator<String> it=keys.iterator() ;
while(it.hasNext()){
String key = it.next();
System.out.println(key);
}
// 刪除某個key,若key不存在，則忽略該命令。
System.out.println("系統中刪除key002: "+jedis.del("key002"));
System.out.println("判斷key002是否存在："+shardedJedis.exists("key002"));
// 設定 key001的過期時間
System.out.println("設定 key001的過期時間為5秒:"+jedis.expire("key001", 5));
try{
Thread.sleep(2000);
}
catch (InterruptedException e){
}
// 檢視某個key的剩餘生存時間,單位【秒】.永久生存或者不存在的都返回-1
System.out.println("檢視key001的剩餘生存時間："+jedis.ttl("key001"));
// 移除某個key的生存時間
System.out.println("移除key001的生存時間："+jedis.persist("key001"));
System.out.println("檢視key001的剩餘生存時間："+jedis.ttl("key001"));
// 檢視key所儲存的值的型別
System.out.println("檢視key所儲存的值的型別："+jedis.type("key001"));
/*
* 一些其他方法：1、修改鍵名：jedis.rename("key6", "key0");
* 2、將當前db的key移動到給定的db當中：jedis.move("foo", 1)
*/
執行結果：
======================key==========================
清空庫中所有資料：OK
判斷key999鍵是否存在：false
新增key001,value001鍵值對：OK
判斷key001是否存在：true
新增key002,value002鍵值對：OK
系統中所有鍵如下：
key002
key001
系統中刪除key002: 1
判斷key002是否存在：false
設定 key001的過期時間為5秒:1
檢視key001的剩餘生存時間：3
移除key001的生存時間：1
檢視key001的剩餘生存時間：-1
檢視key所儲存的值的型別：string
2.3.3操作字串
System.out.println("======================String_1==========================");
// 清空資料
System.out.println("清空庫中所有資料："+jedis.flushDB());
System.out.println("=============增=============");
jedis.set("key001","value001");
jedis.set("key002","value002");
jedis.set("key003","value003");
System.out.println("已新增的3個鍵值對如下：");
System.out.println(jedis.get("key001"));
System.out.println(jedis.get("key002"));
System.out.println(jedis.get("key003"));
System.out.println("=============刪=============");
System.out.println("刪除key003鍵值對："+jedis.del("key003"));
System.out.println("獲取key003鍵對應的值："+jedis.get("key003"));
System.out.println("=============改=============");
//1、直接覆蓋原來的資料
System.out.println("直接覆蓋key001原來的資料："+jedis.set("key001","value001-update"));
System.out.println("獲取key001對應的新值："+jedis.get("key001"));
//2、直接覆蓋原來的資料
System.out.println("在key002原來值後面追加："+jedis.append("key002","+appendString"));
System.out.println("獲取key002對應的新值"+jedis.get("key002"));
System.out.println("=============增，刪，查（多個）=============");
/**
* mset,mget同時新增，修改，查詢多個鍵值對
* 等價於：
* jedis.set("name","ssss");
* jedis.set("jarorwar","xxxx");
*/
System.out.println("一次性新增key201,key202,key203,key204及其對應值："+jedis.mset("key201","value201",
"key202","value202","key203","value203","key204","value204"));
System.out.println("一次性獲取key201,key202,key203,key204各自對應的值："+
jedis.mget("key201","key202","key203","key204"));
System.out.println("一次性刪除key201,key202："+jedis.del(new String[]{"key201", "key202"}));
System.out.println("一次性獲取key201,key202,key203,key204各自對應的值："+
jedis.mget("key201","key202","key203","key204"));
System.out.println();
//jedis具備的功能shardedJedis中也可直接使用，下面測試一些前面沒用過的方法
System.out.println("======================String_2==========================");
// 清空資料
System.out.println("清空庫中所有資料："+jedis.flushDB());
System.out.println("=============新增鍵值對時防止覆蓋原先值=============");
System.out.println("原先key301不存在時，新增key301："+shardedJedis.setnx("key301", "value301"));
System.out.println("原先key302不存在時，新增key302："+shardedJedis.setnx("key302", "value302"));
System.out.println("當key302存在時，嘗試新增key302："+shardedJedis.setnx("key302", "value302_new"));
System.out.println("獲取key301對應的值："+shardedJedis.get("key301"));
System.out.println("獲取key302對應的值："+shardedJedis.get("key302"));
System.out.println("=============超過有效期鍵值對被刪除=============");
// 設定key的有效期，並儲存資料
System.out.println("新增key303，並指定過期時間為2秒"+shardedJedis.setex("key303", 2, "key303-2second"));
System.out.println("獲取key303對應的值："+shardedJedis.get("key303"));
try{
Thread.sleep(3000);
}
catch (InterruptedException e){
}
System.out.println("3秒之後，獲取key303對應的值："+shardedJedis.get("key303"));
System.out.println("=============獲取原值，更新為新值一步完成=============");
System.out.println("key302原值："+shardedJedis.getSet("key302", "value302-after-getset"));
System.out.println("key302新值："+shardedJedis.get("key302"));
System.out.println("=============獲取子串=============");
System.out.println("獲取key302對應值中的子串："+shardedJedis.getrange("key302", 5, 7));
執行結果：
======================String_1==========================
清空庫中所有資料：OK
=============增=============
已新增的3個鍵值對如下：
value001
value002
value003
=============刪=============
刪除key003鍵值對：1
獲取key003鍵對應的值：null
=============改=============
直接覆蓋key001原來的資料：OK
獲取key001對應的新值：value001-update
在key002原來值後面追加：21
獲取key002對應的新值value002+appendString
=============增，刪，查（多個）=============
一次性新增key201,key202,key203,key204及其對應值：OK
一次性獲取key201,key202,key203,key204各自對應的值：[value201, value202, value203, value204]
一次性刪除key201,key202：2
一次性獲取key201,key202,key203,key204各自對應的值：[null, null, value203, value204]
======================String_2==========================
清空庫中所有資料：OK
=============新增鍵值對時防止覆蓋原先值=============
原先key301不存在時，新增key301：1
原先key302不存在時，新增key302：1
當key302存在時，嘗試新增key302：0
獲取key301對應的值：value301
獲取key302對應的值：value302
=============超過有效期鍵值對被刪除=============
新增key303，並指定過期時間為2秒OK
獲取key303對應的值：key303-2second
3秒之後，獲取key303對應的值：null
=============獲取原值，更新為新值一步完成=============
key302原值：value302
key302新值：value302-after-getset
=============獲取子串=============
獲取key302對應值中的子串：302
2.3.4操作LIST
System.out.println("======================list==========================");
// 清空資料
System.out.println("清空庫中所有資料："+jedis.flushDB());
System.out.println("=============增=============");
shardedJedis.lpush("stringlists", "vector");
shardedJedis.lpush("stringlists", "ArrayList");
shardedJedis.lpush("stringlists", "vector");
shardedJedis.lpush("stringlists", "vector");
shardedJedis.lpush("stringlists", "LinkedList");
shardedJedis.lpush("stringlists", "MapList");
shardedJedis.lpush("stringlists", "SerialList");
shardedJedis.lpush("stringlists", "HashList");
shardedJedis.lpush("numberlists", "3");
shardedJedis.lpush("numberlists", "1");
shardedJedis.lpush("numberlists", "5");
shardedJedis.lpush("numberlists", "2");
System.out.println("所有元素-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
System.out.println("所有元素-numberlists："+shardedJedis.lrange("numberlists", 0, -1));
System.out.println("=============刪=============");
// 刪除列表指定的值 ，第二個引數為刪除的個數（有重複時），後add進去的值先被刪，類似於出棧
System.out.println("成功刪除指定元素個數-stringlists："+shardedJedis.lrem("stringlists", 2, "vector"));
System.out.println("刪除指定元素之後-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
// 刪除區間以外的資料
System.out.println("刪除下標0-3區間之外的元素："+shardedJedis.ltrim("stringlists", 0, 3));
System.out.println("刪除指定區間之外元素後-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
// 列表元素出棧
System.out.println("出棧元素："+shardedJedis.lpop("stringlists"));
System.out.println("元素出棧後-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
System.out.println("=============改=============");
// 修改列表中指定下標的值
shardedJedis.lset("stringlists", 0, "hello list!");
System.out.println("下標為0的值修改後-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
System.out.println("=============查=============");
// 陣列長度
System.out.println("長度-stringlists："+shardedJedis.llen("stringlists"));
System.out.println("長度-numberlists："+shardedJedis.llen("numberlists"));
// 排序
/*
* list中存字串時必須指定引數為alpha，如果不使用SortingParams，而是直接使用sort("list")，
* 會出現"ERR One or more scores can't be converted into double"
*/
SortingParams sortingParameters = new SortingParams();
sortingParameters.alpha();
sortingParameters.limit(0, 3);
System.out.println("返回排序後的結果-stringlists："+shardedJedis.sort("stringlists",sortingParameters));
System.out.println("返回排序後的結果-numberlists："+shardedJedis.sort("numberlists"));
// 子串： start為元素下標，end也為元素下標；-1代表倒數一個元素，-2代表倒數第二個元素
System.out.println("子串-第二個開始到結束："+shardedJedis.lrange("stringlists", 1, -1));
// 獲取列表指定下標的值
System.out.println("獲取下標為2的元素："+shardedJedis.lindex("stringlists", 2)+"\n");
執行結果：
======================list==========================
清空庫中所有資料：OK
=============增=============
所有元素-stringlists：[HashList, SerialList, MapList, LinkedList, vector, vector, ArrayList, vector]
所有元素-numberlists：[2, 5, 1, 3]
=============刪=============
成功刪除指定元素個數-stringlists：2
刪除指定元素之後-stringlists：[HashList, SerialList, MapList, LinkedList, ArrayList, vector]
刪除下標0-3區間之外的元素：OK
刪除指定區間之外元素後-stringlists：[HashList, SerialList, MapList, LinkedList]
出棧元素：HashList
元素出棧後-stringlists：[SerialList, MapList, LinkedList]
=============改=============
下標為0的值修改後-stringlists：[hello list!, MapList, LinkedList]
=============查=============
長度-stringlists：3
長度-numberlists：4
返回排序後的結果-stringlists：[LinkedList, MapList, hello list!]
返回排序後的結果-numberlists：[1, 2, 3, 5]
子串-第二個開始到結束：[MapList, LinkedList]
獲取下標為2的元素：LinkedList
2.3.5 操作SET
System.out.println("======================set==========================");
// 清空資料
System.out.println("清空庫中所有資料："+jedis.flushDB());
System.out.println("=============增=============");
System.out.println("向sets集合中加入元素element001："+jedis.sadd("sets", "element001"));
System.out.println("向sets集合中加入元素element002："+jedis.sadd("sets", "element002"));
System.out.println("向sets集合中加入元素element003："+jedis.sadd("sets", "element003"));
System.out.println("向sets集合中加入元素element004："+jedis.sadd("sets", "element004"));
System.out.println("檢視sets集合中的所有元素:"+jedis.smembers("sets"));
System.out.println();
System.out.println("=============刪=============");
System.out.println("集合sets中刪除元素element003："+jedis.srem("sets", "element003"));
System.out.println("檢視sets集合中的所有元素:"+jedis.smembers("sets"));
/*System.out.println("sets集合中任意位置的元素出棧："+jedis.spop("sets"));//注：出棧元素位置居然不定？--無實際意義
System.out.println("檢視sets集合中的所有元素:"+jedis.smembers("sets"));*/
System.out.println();
System.out.println("=============改=============");
System.out.println();
System.out.println("=============查=============");
System.out.println("判斷element001是否在集合sets中："+jedis.sismember("sets", "element001"));
System.out.println("迴圈查詢獲取sets中的每個元素：");
Set<String> set = jedis.smembers("sets");
Iterator<String> it=set.iterator() ;
while(it.hasNext()){
Object obj=it.next();
System.out.println(obj);
}
System.out.println();
System.out.println("=============集合運算=============");
System.out.println("sets1中新增元素element001："+jedis.sadd("sets1", "element001"));
System.out.println("sets1中新增元素element002："+jedis.sadd("sets1", "element002"));
System.out.println("sets1中新增元素element003："+jedis.sadd("sets1", "element003"));
System.out.println("sets1中新增元素element002："+jedis.sadd("sets2", "element002"));
System.out.println("sets1中新增元素element003："+jedis.sadd("sets2", "element003"));
System.out.println("sets1中新增元素element004："+jedis.sadd("sets2", "element004"));
System.out.println("檢視sets1集合中的所有元素:"+jedis.smembers("sets1"));
System.out.println("檢視sets2集合中的所有元素:"+jedis.smembers("sets2"));
System.out.println("sets1和sets2交集："+jedis.sinter("sets1", "sets2"));
System.out.println("sets1和sets2並集："+jedis.sunion("sets1", "sets2"));
System.out.println("sets1和sets2差集："+jedis.sdiff("sets1", "sets2"));//差集：set1中有，set2中沒有的元素
執行結果：
======================set==========================
清空庫中所有資料：OK
=============增=============
向sets集合中加入元素element001：1
向sets集合中加入元素element002：1
向sets集合中加入元素element003：1
向sets集合中加入元素element004：1
檢視sets集合中的所有元素:[element001, element002, element003, element004]
=============刪=============
集合sets中刪除元素element003：1
檢視sets集合中的所有元素:[element001, element002, element004]
=============改=============
=============查=============
判斷element001是否在集合sets中：true
迴圈查詢獲取sets中的每個元素：
element001
element002
element004
=============集合運算=============
sets1中新增元素element001：1
sets1中新增元素element002：1
sets1中新增元素element003：1
sets1中新增元素element002：1
sets1中新增元素element003：1
sets1中新增元素element004：1
檢視sets1集合中的所有元素:[element001, element002, element003]
檢視sets2集合中的所有元素:[element002, element003, element004]
sets1和sets2交集：[element002, element003]
sets1和sets2並集：[element001, element002, element003, element004]
sets1和sets2差集：[element001]
2.3.6 操作SortedSet（有序集合）
System.out.println("======================zset==========================");
// 清空資料 System.out.println(jedis.flushDB());
System.out.println("=============增=============");
System.out.println("zset中新增元素element001："+shardedJedis.zadd("zset", 7.0, "element001"));
System.out.println("zset中新增元素element002："+shardedJedis.zadd("zset", 8.0, "element002"));
System.out.println("zset中新增元素element003："+shardedJedis.zadd("zset", 2.0, "element003"));
System.out.println("zset中新增元素element004："+shardedJedis.zadd("zset", 3.0, "element004"));
System.out.println("zset集合中的所有元素："+shardedJedis.zrange("zset", 0, -1));//按照權重值排序 System.out.println();
System.out.println("=============刪=============");
System.out.println("zset中刪除元素element002："+shardedJedis.zrem("zset", "element002"));
System.out.println("zset集合中的所有元素："+shardedJedis.zrange("zset", 0, -1));
System.out.println();
System.out.println("=============改=============");
System.out.println();
System.out.println("=============查=============");
System.out.println("統計zset集合中的元素中個數："+shardedJedis.zcard("zset"));
System.out.println("統計zset集合中權重某個範圍內（1.0——5.0），元素的個數："+shardedJedis.zcount("zset", 1.0, 5.0));
System.out.println("檢視zset集合中element004的權重："+shardedJedis.zscore("zset", "element004"));
System.out.println("檢視下標1到2範圍內的元素值："+shardedJedis.zrange("zset", 1, 2));
執行結果：
======================zset==========================
OK
=============增=============
zset中新增元素element001：1
zset中新增元素element002：1
zset中新增元素element003：1
zset中新增元素element004：1
zset集合中的所有元素：[element003, element004, element001, element002]
=============刪=============
zset中刪除元素element002：1
zset集合中的所有元素：[element003, element004, element001]
=============改=============
=============查=============
統計zset集合中的元素中個數：3
統計zset集合中權重某個範圍內（1.0——5.0），元素的個數：2
檢視zset集合中element004的權重：3.0
檢視下標1到2範圍內的元素值：[element004, element001]
2.3.7操作Hash功能
System.out.println("======================hash==========================");
//清空資料 System.out.println(jedis.flushDB());
System.out.println("=============增=============");
System.out.println("hashs中新增key001和value001鍵值對："+shardedJedis.hset("hashs", "key001", "value001"));
System.out.println("hashs中新增key002和value002鍵值對："+shardedJedis.hset("hashs", "key002", "value002"));
System.out.println("hashs中新增key003和value003鍵值對："+shardedJedis.hset("hashs", "key003", "value003"));
System.out.println("新增key004和4的整型鍵值對："+shardedJedis.hincrBy("hashs", "key004", 4l));
System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("=============刪=============");
System.out.println("hashs中刪除key002鍵值對："+shardedJedis.hdel("hashs", "key002"));
System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("=============改=============");
System.out.println("key004整型鍵值的值增加100："+shardedJedis.hincrBy("hashs", "key004", 100l));
System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("=============查=============");
System.out.println("判斷key003是否存在："+shardedJedis.hexists("hashs", "key003"));
System.out.println("獲取key004對應的值："+shardedJedis.hget("hashs", "key004"));
System.out.println("批量獲取key001和key003對應的值："+shardedJedis.hmget("hashs", "key001", "key003"));
System.out.println("獲取hashs中所有的key："+shardedJedis.hkeys("hashs"));
System.out.println("獲取hashs中所有的value："+shardedJedis.hvals("hashs"));
System.out.println();
執行結果：
======================hash==========================
OK
=============增=============
hashs中新增key001和value001鍵值對：1
hashs中新增key002和value002鍵值對：1
hashs中新增key003和value003鍵值對：1
新增key004和4的整型鍵值對：4
hashs中的所有值：[value001, value002, value003, 4]
=============刪=============
hashs中刪除key002鍵值對：1
hashs中的所有值：[value001, value003, 4]
=============改=============
key004整型鍵值的值增加100：104
hashs中的所有值：[value001, value003, 104]
=============查=============
判斷key003是否存在：true
獲取key004對應的值：104
批量獲取key001和key003對應的值：[value001, value003]
獲取hashs中所有的key：[key004, key003, key001]
獲取hashs中所有的value：[value001, value003, 104]
3.Redis常用命令：
1）連線操作命令
quit：關閉連線（connection）
auth：簡單密碼認證
help cmd： 檢視cmd幫助，例如：help quit
2）持久化
save：將資料同步儲存到磁碟
bgsave：將資料非同步儲存到磁碟
lastsave：返回上次成功將資料儲存到磁碟的Unix時戳
shundown：將資料同步儲存到磁碟，然後關閉服務
3）遠端服務控制
info：提供伺服器的資訊和統計
monitor：實時轉儲收到的請求
slaveof：改變複製策略設定
config：在執行時配置Redis伺服器
4）對value操作的命令
exists(key)：確認一個key是否存在
del(key)：刪除一個key
type(key)：返回值的型別
keys(pattern)：返回滿足給定pattern的所有key
randomkey：隨機返回key空間的一個
keyrename(oldname, newname)：重新命名key
dbsize：返回當前資料庫中key的數目
expire：設定一個key的活動時間（s）
ttl：獲得一個key的活動時間
select(index)：按索引查詢
move(key, dbindex)：移動當前資料庫中的key到dbindex資料庫
flushdb：刪除當前選擇資料庫中的所有key
flushall：刪除所有資料庫中的所有key
5）String
set(key, value)：給資料庫中名稱為key的string賦予值value
get(key)：返回資料庫中名稱為key的string的value
getset(key, value)：給名稱為key的string賦予上一次的value
mget(key1, key2,…, key N)：返回庫中多個string的value
setnx(key, value)：新增string，名稱為key，值為value
setex(key, time, value)：向庫中新增string，設定過期時間time
mset(key N, value N)：批量設定多個string的值
msetnx(key N, value N)：如果所有名稱為key i的string都不存在
incr(key)：名稱為key的string增1操作
incrby(key, integer)：名稱為key的string增加integer
decr(key)：名稱為key的string減1操作
decrby(key, integer)：名稱為key的string減少integer
append(key, value)：名稱為key的string的值附加value
substr(key, start, end)：返回名稱為key的string的value的子串
6）List
rpush(key, value)：在名稱為key的list尾新增一個值為value的元素
lpush(key, value)：在名稱為key的list頭新增一個值為value的 元素
llen(key)：返回名稱為key的list的長度
lrange(key, start, end)：返回名稱為key的list中start至end之間的元素
ltrim(key, start, end)：擷取名稱為key的list
lindex(key, index)：返回名稱為key的list中index位置的元素
lset(key, index, value)：給名稱為key的list中index位置的元素賦值
lrem(key, count, value)：刪除count個key的list中值為value的元素
lpop(key)：返回並刪除名稱為key的list中的首元素
rpop(key)：返回並刪除名稱為key的list中的尾元素
blpop(key1, key2,… key N, timeout)：lpop命令的block版本。
brpop(key1, key2,… key N, timeout)：rpop的block版本。
rpoplpush(srckey, dstkey)：返回並刪除名稱為srckey的list的尾元素，
並將該元素新增到名稱為dstkey的list的頭部
7）Set
sadd(key, member)：向名稱為key的set中新增元素member
srem(key, member) ：刪除名稱為key的set中的元素member
spop(key) ：隨機返回並刪除名稱為key的set中一個元素
smove(srckey, dstkey, member) ：移到集合元素
scard(key) ：返回名稱為key的set的基數
sismember(key, member) ：member是否是名稱為key的set的元素
sinter(key1, key2,…key N) ：求交集
sinterstore(dstkey, (keys)) ：求交集並將交集儲存到dstkey的集合
sunion(key1, (keys)) ：求並集
sunionstore(dstkey, (keys)) ：求並集並將並集儲存到dstkey的集合
sdiff(key1, (keys)) ：求差集
sdiffstore(dstkey, (keys)) ：求差集並將差集儲存到dstkey的集合
smembers(key) ：返回名稱為key的set的所有元素
srandmember(key) ：隨機返回名稱為key的set的一個元素
8）Hash
hset(key, field, value)：向名稱為key的hash中新增元素field
hget(key, field)：返回名稱為key的hash中field對應的value
hmget(key, (fields))：返回名稱為key的hash中field i對應的value
hmset(key, (fields))：向名稱為key的hash中新增元素field
hincrby(key, field, integer)：將名稱為key的hash中field的value增加integer
hexists(key, field)：名稱為key的hash中是否存在鍵為field的域
hdel(key, field)：刪除名稱為key的hash中鍵為field的域
hlen(key)：返回名稱為key的hash中元素個數
hkeys(key)：返回名稱為key的hash中所有鍵
hvals(key)：返回名稱為key的hash中所有鍵對應的value
hgetall(key)：返回名稱為key的hash中所有的鍵（field）及其對應的value
4.redis與多執行緒的小練習：
1.連線池同上
2.建立一個執行緒類運算元據
public class ThreadToolimplements Runnable{
private Jedis j;
public ThreadTool(Jedis j) {
super();
this.j = j;
}
@Override
public void run() {
synchronized (j) {//因為要操作同一個資料所以必須同步
j.incr("age");
System.out.println(Thread.currentThread().getName()+": "
+j.get("name") +"-" +j.get("age") +"-" +j.get("qq"));
}
}
}
3.建立redis例項加入資料呼叫執行緒：
public class MyRedis {
private Jedis jedis;
public void setUp(){
//jedis = new Jedis("127.0.0.1",6379);
//jedis.auth("admin");
jedis = new RedisUtil().getJedis();
//-----新增資料----------
jedis.set("name","張三");//向key-->name中放入了value-->xinxin
System.out.println("剛加進去的："+jedis.get("name"));//執行結果：xinxin
jedis.append("name"," is crasy");//拼接
System.out.println("拼接後："+jedis.get("name"));
jedis.del("name"); //刪除某個鍵
System.out.println("刪除後："+jedis.get("name"));
//設定多個鍵值對
jedis.mset("name","張三","age","23","qq","476777XXX");
jedis.incr("age");//進行加1操作
System.out.println("name原值"+jedis.getSet("name","李四"));
// Jedis jedis2 = new RedisUtil().getJedis();
// jedis2.lpush("list", "arrayList");
// jedis2.lpush("list", "arrayList2");
// jedis2.lpush("number", "0");
// jedis2.lpush("number", "1");
System.out.println("**********************************");
}
public static void main(String[] args) {
new MyRedis().setUp();
//new RedisUtil().getJedis().set("name", "測試");
//System.out.println(RedisUtil.getJedis().get("name"));
Jedis j = new Jedis("127.0.0.1",6379);
j.auth("admin");
System.out.println(j.get("name") +"-" + j.get("age") +"-" + j.get("qq"));
//System.out.println("所有元素list: "+j.lrange("list", 0, -1));
//System.out.println("所有元素number: "+j.lrange("number", 0, -1));
//System.out.println("刪除下標0-1區間之外的元素："+j.ltrim("number", 0, 1));
//System.out.println("刪除指定區間之外元素後-stringlists："+j.lrange("number", 0, -1));
Thread t =new Thread(new ThreadTool(j));
Thread t2 =new Thread(new ThreadTool(j));
Thread t3 =new Thread(new ThreadTool(j));
t.start();
t2.start();
t3.start();
}
4.執行結果：
控制檯：
剛加進去的： 張三
拼接後： 張三 is crasy
刪除後： null
name原值張三
**********************************
李四-24-476777XXX
Thread-1: 李四-25-476777XXX
Thread-3: 李四-26-476777XXX
Thread-2: 李四-27-476777XXX
5.Spring整合redis
1.配置檔案：
<!--引入redis配置檔案-->
<context:property-placeholderlocation="classpath*:config/redis.properties"/>
<!-- Spring Data Redis 設定 -->
<!-- redis 序列化策略 ，通常情況下key值採用String序列化策略，-->
<!-- 如果不指定序列化策略，StringRedisTemplate的key和value都將採用String序列化策略；-->
<beanid="stringRedisSerializer"
class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
<beanid="jdkRedisSerializer"
class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
<!--單點Redis配置 -->
<beanid="jedisConnectionFactory"class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:hostName="${redis.host}"p:port="${redis.port}"p:password="${redis.pass}"
p:poolConfig-ref="jedisPoolConfig"/>
<!-- 對string操作的封裝-->
<beanid="stringRedisTemplate"class="org.springframework.data.redis.core.StringRedisTemplate"
p:connectionFactory-ref="jedisConnectionFactory"/>
<!-- redis template definition p表示對該bean裡面的屬性進行注入，格式為p:屬性名=注入的物件 效果與在bean裡面使用<property>標籤一樣-->
<beanid="redisTemplate"class="org.springframework.data.redis.core.RedisTemplate"
p:connectionFactory-ref="jedisConnectionFactory"
p:keySerializer-ref="stringRedisSerializer"p:hashKeySerializer-ref="stringRedisSerializer"
p:valueSerializer-ref="jdkRedisSerializer"p:hashValueSerializer-ref="jdkRedisSerializer"/>
<beanid="jedisPoolConfig"class="redis.clients.jedis.JedisPoolConfig"
p:maxTotal="${redis.maxActive}"
p:maxIdle="${redis.maxIdle}"
p:maxWaitMillis="${redis.maxWait}"
p:testOnBorrow="${redis.testOnBorrow}"
p:testOnReturn="true"/>
6.Redis分散式：
1：配置檔案（主從）：
主服務：
port 6379 //埠
bind 172.0.0.1 //IP地址 後面接空格ip可以繫結多個IP地址。
requirepass admin //密碼
1.啟動服務 cmd --> cd redis安裝路徑-->redis-server.exe redis.conf
2.再啟動從服務連線到主服務。
從服務：可以設定多個
port 6380 //埠
bind 172.16.3.16 //IP地址
requirepass admin //密碼
slaveof 127.0.0.1 6379 //主機的ip埠
masterauth admin //主機的密碼認證
啟動：開啟測試 redis-cli.exe -h 從配置中繫結ip -p 配置中的埠。
此時主服務set key value
從服務 auth admin
get key ------------------OK！。
7.java操作redis分散式：
1.概念性的東西：
Redis實現叢集的方法主要是採用一致性哈稀分片（Shard），將不同的key分配到不同的redis server上，達到橫向擴充套件的目的。
shared一致性雜湊採用以下方案：
1. Redis伺服器節點劃分：將每臺伺服器節點採用hash演算法劃分為160個虛擬節點(可以配置劃分權重)
2. 將劃分虛擬節點採用TreeMap儲存
3. 對每個Redis伺服器的物理連線採用LinkedHashMap儲存對Key or KeyTag 採用同樣的hash演算法，然後從TreeMap獲取大於等於鍵hash值得節點，取最鄰近節點儲存；當key的hash值大於虛擬節點hash值得最大值時，存入第一個虛擬節點。
4. sharded採用的hash演算法：MD5 和 MurmurHash兩種；預設採用64位的MurmurHash演算法；
sharding的核心理念就是將資料按照一定的策略"分散"儲存在叢集中不同的物理server上,本質上實現了"大資料"分散式儲存,以及體現了"叢集"的高可用性.比如1億資料,我們按照資料的hashcode雜湊儲存在5個server上.
2.redis分片程式碼：
1.ShardedJedisPool連線池：
這裡直接寫spring配置檔案。和new一樣。
<beanid="RedisInitBean"name="RedisInitBean"class="com.utils.RedisInitBean">
<!-- IP:Port：name 多個請求進redispool-->
<constructor-argindex="0"type="List">
<list>
<value>172.16.3.16:6380:master</value>
<value>127.0.0.1:6379:clint</value>
<value>172.16.3.34:6381:clint2</value>
</list>
</constructor-arg>
<!-- maxWaitMillis -->
<constructor-argindex="1"type="long">
<value>1000</value>
</constructor-arg>
<!-- MaxIdle -->
<constructor-argindex="2"type="int">
<value>200</value>
</constructor-arg>
<!-- testOnBorrow -->
<constructor-argindex="3"type="Boolean">
<value>true</value>
</constructor-arg>
</bean>
2.RedisInitBean：
public class RedisInitBean {
private List Host;//連線請求
private long maxWaitMillis;
private int MaxIdle;
private Boolean testOnBorrow;
private static List<JedisShardInfo>shards ;//分片資訊
private static ShardedJedisPoolpool;//分片池
private static ShardedJedisjedis;//分片jedis例項
//以下在構造方法中把分片資訊處理好放在list中並初始化好連線池
public RedisInitBean(List host,long maxWaitMillis,int maxIdle,
Boolean testOnBorrow) {
super();
Host = host;
this.maxWaitMillis = maxWaitMillis;
MaxIdle = maxIdle;
this.testOnBorrow = testOnBorrow;
if(host.size()!=0){
JedisShardInfo[] array = new JedisShardInfo[Host .size()];
for (int i = 0; i <Host .size(); i++) {
//配置多個埠ip : host .prot. timeout.name
String h[] = ((String) Host .get(i)).split(":");
JedisShardInfo s= new JedisShardInfo(h[0].trim(),Integer.parseInt(h[1].trim()), 30000, h[2].trim().toString());
array[i] = s;
}
shards = Arrays.asList(array);
//配置密碼
// for (JedisShardInfo j : shards) {
//j.setPassword("admin");
//}
System.out.println(shards);
}else{
System.out.println("請檢查Redis配置，host項為必填項！格式[IP:PORT]");
}
pool = new ShardedJedisPool(new JedisPoolConfig(),shards);
jedis = pool.getResource(); //獲取資源
}
public synchronized ShardedJedis getSingletonInstance(){
return jedis; //獲取資源
}
public synchronized static void returnResource(){
pool.returnResource(jedis);//釋放
}
public synchronized static void destroy(){
pool.destroy();
}
}
3.測試程式碼：
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("springAnnotation-core.xml");
RedisInitBean rb = (RedisInitBean) context.getBean("RedisInitBean");
ShardedJedis jedis = rb.getSingletonInstance();
ShardedJedisPipeline pipeline = jedis.pipelined();
//long start = System.currentTimeMillis();
// for (int i = 0; i < 10; i++) {
// pipeline.set("key1" + i, "張" + i);
// }
// List<Object> results = pipeline.syncAndReturnAll();//管道的資料提交server
// long end = System.currentTimeMillis();
// rb.returnResource();
// rb.destroy();
// System.out.println("分散式連線池非同步呼叫耗時: " + ((end - start)/1000.0) + "秒");
// try {
// Thread.sleep(5000);//睡5秒，然後列印jedis返回的結果
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println("返回結果："+results);
System.out.println(jedis.get("kk"));
System.out.println(jedis.getShardInfo("kk").getName());
}
另外：
//jde.set("cnblog", "cnblog");
//jde.set("redis", "redis");
//jde.set("test", "test");
//jde.set("123456", "1234567");
// Client client1 = jde.getShard("cnblog").getClient();
// Client client2 = jde.getShard("redis").getClient();
// Client client3 = jde.getShard("test").getClient();
// Client client4 = jde.getShard("123456").getClient();
// System.out.println(DataCaChe.getData("cnblog"));
// ////列印key在哪個server中
// System.out.println("cnblog in server:" + client1.getHost() + " and port is:" + client1.getPort());
// System.out.println("redis in server:" + client2.getHost() + " and port is:" + client2.getPort());
// System.out.println("test in server:" + client3.getHost() + " and port is:" + client3.getPort());
// System.out.println("123456 in server:" + client4.getHost() + " and port is:" + client4.getPort());
可以看出來 存到了那個伺服器。
以上增加資料後。在加入的任何服務都可以get到。
配置檔案中只加入主服務。從服務雖然沒在池中但是由於主從關係 從服務也可以get到主服務的資料。所以可以配置多個主從關係的分佈。
8.redis解決併發：
Redis為單程式單執行緒模式，採用佇列模式將併發訪問變成序列訪問，且多客戶端對Redis的連線並不存在競爭關係。其次Redis提供一些命令SETNX，GETSET，可以方便實現分散式鎖機制。
也可以使用佇列以及redis釋出訂閱來消費方式處理。
因為這次是可行性的DEMO測試所以很多東西沒有來得及做實戰研究我就不BB了。
叢集，哨兵，佇列等模式等真正釋出生產後在進行分享記錄。
9.redis實際應用：
簡單介紹一下我們實際應用的例子確定KEY的形式是必須的，這很重要關乎到你效率的快慢。
值我們一般插入序列化後的值，因為這樣安全一些。
DEMO中的核心程式碼：
redis分片工廠在上述內容中：然後分享一個公用抽象方法。redis序列化的存取。
/**
* 根據key，使用管道，批量取value(value:取得是序列化物件)
* return Map<String, Object> String:傳入的key，Object：序列化物件
*/
public static Map<String, Object> batchGetObject(Map<String, String> keyMap){
ShardedJedis jedis = null;
Map<String, Object> returnMap = new HashMap<String, Object>();
try {
jedis = getJedisOfPool();
//呼叫管道非同步處理
HashMap<byte[], Response<byte[]>> valueMap = shardedJedisPipeline(keyMap,jedis);
for(Iterator ite = valueMap.entrySet().iterator(); ite.hasNext();){
Map.Entry entry = (Map.Entry) ite.next();
Response<byte[]> response=(Response<byte[]>)entry.getValue();
byte[] value = response.get();
if(null == value){
String newKey = new String((byte[])entry.getKey());
LoadDate(jedis, newKey);
value = jedis.get(newKey.getBytes());
}
returnMap.put(new String((byte[])entry.getKey()), value==null?
null:SerializationUtil.deserialize(value));
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("DataCaChe:批量查詢Redis時有誤,"+e.getMessage());
}
return returnMap;
}
/**
* 根據key，使用管道，批量取value(value:String物件)
* return Map<String, String> String:傳入的key，String：value 值
*/
public static Map<String, String> batchGetString(Map<String, String> keyMap){
ShardedJedis jedis = null;
Map<String, String> returnMap = new HashMap<String, String>();
try {
jedis = getJedisOfPool();
HashMap<byte[], Response<byte[]>> valueMap = shardedJedisPipeline(keyMap, jedis);
//獲取後把value加工一下，不可以在上面加工因為是非同步獲取value
for(Iterator ite = valueMap.entrySet().iterator(); ite.hasNext();){
Map.Entry entry = (Map.Entry) ite.next();
Response<byte[]> response=(Response<byte[]>)entry.getValue();
byte[] value = response.get();
if(null == value){
LoadDate(jedis, (String)entry.getKey());
String stringValue = jedis.get((String)entry.getKey());
if(EmptyUtils.isEmpty(stringValue)){
value = null;
}else{
value = stringValue.getBytes();
}
}
returnMap.put((String)entry.getKey(), value==null?null:new String(value));
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("批量查詢Redis時有誤"+e.getMessage());
} finally{
jedis.close();
}
return returnMap;
}
/**
* 非同步管道處理
*/
public static HashMap<byte[], Response<byte[]>> shardedJedisPipeline(Map<String, String> keyMap,ShardedJedis jedis){
HashMap<byte[], Response<byte[]>> valueMap=new HashMap<byte[], Response<byte[]>>();
try {
ShardedJedisPipeline pipeline = jedis.pipelined();//獲取管道非同步處理
for(Iterator ite = keyMap.entrySet().iterator(); ite.hasNext();){
Map.Entry entry = (Map.Entry) ite.next();
valueMap.put(((String) entry.getKey()).getBytes(), pipeline.get(((String) entry.getKey()).getBytes()));
}
pipeline.sync();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("批量查詢Redis時有誤"+e.getMessage());
} finally{
jedis.close();
}
return valueMap;
}
/**
* 存入序列化物件
* @param key
* @return
*/
public static void setSerialObject(String key,Object value) {
ShardedJedis jedis = null;
try {
jedis = getJedisOfPool();
jedis.set(key.getBytes(), SerializationUtil.serialize(value));
} catch (Exception e) {
e.printStackTrace();
} finally{
jedis.close();
}
}
/**
* 通過key 取物件值
* @param key
* @return
*/
public static Object getSerialObject(String newKey) {
ShardedJedis jedis = null;
Object obj = null;
try {
jedis = getJedisOfPool();
//有直接取，直接用jedis物件判斷不要再去池中拿了
if(jedis.exists(newKey)){
return SerializationUtil.deserialize(jedis.get(newKey.getBytes()));
}
synchronized (lock) {
obj = jedis.get(newKey);//再次獲取防止別的操作已經載入
if (obj == null){
LoadDate(jedis,newKey);//獲取不到去資料庫查
return jedis.get(newKey.getBytes())==null?
null:SerializationUtil.deserialize(jedis.get(newKey.getBytes()));
}
}
} catch (Exception e) {
e.printStackTrace();
} finally{
jedis.close();
}
return null;
}
序列化工具類：
/**
* 序列化工具
* @author Harley 2017 01 04
*
*/
public class SerializationUtil {
/**
* 序列化
*
* @param object
* @return
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
}
return null;
}
/**
* 反序列化
*
* @param bytes
* @return
*/
public static Object deserialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
}
return null;
}
}
可以直接拿去用，省的寫了。
---------------------
作者：ServiceGood
來源：CSDN
原文：https://blog.csdn.net/liud1/article/details/54946644
版權宣告：本文為博主原創文章，轉載請附上博文連結！
相關文章
- 搭建分散式 Redis Cluster 叢集與 Redis 入門分散式Redis
- 分散式鎖-Redis分散式Redis
- redis 分散式鎖Redis分散式
- Redis分散式鎖Redis分散式
- 十九、Redis分散式鎖、Zookeeper分散式鎖Redis分散式
- Redis 分散式鎖（一）Redis分散式
- Redis 分散式儲存Redis分散式
- Redis分散式鎖解析Redis分散式
- Redis分散式概覽Redis分散式
- redis系列：分散式鎖Redis分散式
- redis→分散式快取Redis分散式快取
- 【Redis】利用 Redis 實現分散式鎖Redis分散式
- 細說Redis分散式鎖?Redis分散式
- Redis分散式鎖實戰Redis分散式
- 分散式鎖----Redis實現分散式Redis
- Redis 應用-分散式鎖Redis分散式
- Redis實現分散式鎖Redis分散式
- 基於 Redis 分散式鎖Redis分散式
- 詳解Redis分散式鎖Redis分散式
- SmartSql Redis 分散式快取SQLRedis分散式快取
- Redis分散式實現原理Redis分散式
- Redis面試系列：Redis實現分散式鎖Redis面試分散式
- 關於分散式鎖原理的一些學習與思考-redis分散式鎖，zookeeper分散式鎖分散式Redis
- Redis之分散式鎖實現Redis分散式
- 分散式鎖之Redis實現分散式Redis
- 分散式Redis深度歷險-Clustor分散式Redis
- 分散式Redis深度歷險-Cluster分散式Redis
- 分散式Redis主備複製分散式Redis
- redis分散式鎖-可重入鎖Redis分散式
- redis分散式鎖-java實現Redis分散式Java
- Redis如何實現分散式鎖Redis分散式
- Redis分散式鎖解決方案Redis分散式
- Redis 分散式鎖解決方案Redis分散式
- 分散式鎖--Redis小試牛刀分散式Redis
- 分散式Redis深度歷險-Sentinel分散式Redis
- 分散式鎖實現（一）：Redis分散式Redis
- 利用Redis實現分散式鎖Redis分散式
- Redis分散式鎖加鎖案例Redis分散式