Redis概述
Redis（Remote Dictionary Server )，即遠端字典服務，是一個開源的使用ANSI C語言編寫、支援網絡、可基于記憶體亦可持久化的日志型、Key-Value資料庫，并提供多種語言的API。
Redis作用
- 記憶體存儲，持久化
- 效率高，用于高速緩存
- 釋出訂閱系統
- 地圖資訊分析
- 計時器，計數器（浏覽量~）
- .................
Redis特性
- 多樣資料類型
- 持久化
- 叢集
- 事務
- .............
Redis指令
進入redis
COPYdocker exec -it 容器id redis-cli 複制
執行相關指令
- ping：測試連接配接
- set 【key】 【value】 設定鍵值對
- get 【key】 擷取值
- shutdown 退出關閉redis
COPYps -ef|gref redis 檢視程序是否存在 # 非docker
docker stats #可檢視容器 複制
- 測試100個連接配接100000個請求
COPYredis-benchmark -h localhost -p 6379 -c 100 -n 100000 複制
-
切換資料庫select
COPY 127.0.0.1:6379> SELECT 3 OK 127.0.0.1:6379[3]> DBSIZE (integer) 0
- 清除目前資料庫 flushdb
COPY 127.0.0.1:6379[3]> set name hcode
OK
127.0.0.1:6379[3]> get name
"hcode"
127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> get name
(nil) 複制
- 清除全部資料庫 flushall
Redis是單線程的！Redis是基于記憶體操作，速度很快~，Redis的性能瓶頸跟機器的記憶體和網絡帶寬有關！跟CPU沒有多大關系。
Redis是将所有資料放在記憶體中的，是以使用單線程取操作效率是最高的
五大資料類型
Redis-Key
COPY
exists key #判斷值是否存在
expire key 10 #設定key值10s後過程
ttl key #檢視值的緩存時間還剩下多少
move key 2 #将key資料移到2号資料庫
type key #檢視類型 複制
String
COPY127.0.0.1:6379> APPEND k "xixi"
(integer) 5
127.0.0.1:6379> get k
"vxixi"
append key “追加的字元串” #如果目前key不存在，就相當于set key
strlen key #擷取字元串長度
incr key #每次讓key對應的值加1
incrby key 10 #每次讓key對應的值加10
相對于 decr 用法一樣，隻是變成減
decr key
decr key 10
getrange key 0 10 #擷取前11個字元
setrange key 1 字元串 #替換指定位置開始的字元串 複制
COPYsetex k2 10 hello #設定值過期時間為10s
setnx k2 xixi #不存在值就設定值 分布式鎖中常常使用 複制
批量操作
COPYmset k1 v1 k2 v2 ... #設定值
mget k1 k2 k3.. #擷取值
msetnx k1 v1 k2 v2 #不存在值就建立，但是這是原子性的操作，一個key失敗全部失敗 複制
設定對象
COPYmset user:1:name hcode user:1:age 12
mget user:1:name 複制
如果有key就擷取值，沒有就設定值value
COPYgetset key value 複制
List
COPYlpush list value # 将值插入清單的頭部，或者最左邊
rpush list value # 将值插入清單的尾部，或者最右邊
lrange list 0 -1 #從左到右讀取list
lpop list #将最左邊的值移除
rpop list #将最右邊的之移除
lindex list 1 #擷取下标為1的值
llen list #擷取list長度
lrem list 2 value #移除list中的2個value
ltrim list 0 1 #隻截取0 1下标的值。其它在list剔除了
rpoplpush list1 list2 #移除list1最後一個元素。移到到list2中
lset list 0 newvalue #将list中第0個值換成newvalue
linsert list before【after】 value newvalue #往value之前插入newvalue 複制
Set
set的值不可重複
COPYsadd set value #添加值
smembers set #檢視set裡面全部的值
sismember set value #判斷value是否存在在set裡面
scard set #擷取set集合中的個數
srem set value #移除set中的value
srandmember set 【num】 #随機擷取set中的一個值,可以在後面添加個數
spop set #随機移除一個value
smove set1 set2 value #将set1中的value移除，然後移到set2
sdiff set1 set2 #擷取set1中set2沒有的值 差集
sinter set1 set2 #擷取set1和set2相同的值 交集
sunion set1 set2 #擷取set1和set2全部的值 并集
複制
Hash
key-map 現在的值是一個map集合，跟String差不多
更适合對象的存儲~
COPYhset myhash k1 v1 #加入一個map
hmset myhash k1 v1 k2 v2 #批量加入map k存在就覆寫
hmget myhash k1 k2 #批量擷取值
hgetall myhash #擷取全部的map
hdel myhash k1 #删除指定的map
hlen myhash #擷取map的個數
hexists myhash k1 #判斷是否存在k1的值
hvals myhash #擷取所有的value
hkeys myhash #擷取所有的key
hincrby myhash k1 1 #給k1對應的值加1
hdecrby myhash k1 1 #給k1對應的值減1
hsetnx myhash k1 v1 #不存在就設定一個map
複制
Zset
在set基礎上增加了一個值
COPYzadd myset 1 one 2 two #多了一個序号
zrange 0 -1 #查詢全部
zrangebyscore myset -inf +inf #從序号最小到最大排序
ZREVRANGEBYLEX myset max min #傳回max到min之間的降序
zrem myset value # 删除一個value
zcard myset # 查詢set的個數
zrevrange myset 0 -1 # 倒着查出全部
zcount myset 0 2 # 查詢下标0到2的值 複制
三種特殊的資料類型
geospatial 地理位置
geoadd
COPY127.0.0.1:6379> GEOADD china:beicity 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379> GEOADD china:beicity 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> GEOADD CHINA:beicity 114.05 22.52 shenzhen
(integer) 1
GEOADD key 經度 次元 名稱
南北兩極不可添加 複制
geopos
獲得目前定位
COPY127.0.0.1:6379> GEOPOS china:beicity beijing
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
# 擷取指定城市的經緯度 複制
geodist
m 表示機關為米。 km 表示機關為千米。 mi 表示機關為英裡。 ft 表示機關為英尺。
查詢兩地之間的距離可以指定機關
COPY127.0.0.1:6379> GEODIST china:beicity beijing shanghai
"1067378.7564"
127.0.0.1:6379> GEODIST china:beicity beijing shanghai km
"1067.3788" 複制
georadius
擷取半徑内的所有城市
COPYGEORADIUS china:beicity 110 20 1000 km #擷取經緯度110，20在china：beicity這個key裡面對應1000km之内的value
withdist withcoord count 2 #參數對應為顯示距離，顯示經緯度，隻顯示2個 複制
GEORADIUSBYMEMBER
COPY# 找出位于指定元素周圍的其他元素！
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km 1) "beijing"
2) "xian" 複制
GEOHASH 指令 - 傳回一個或多個位置元素的 Geohash 表示
該指令将傳回11個字元的Geohash字元串!
COPY# 将二維的經緯度轉換為一維的字元串，如果兩個字元串越接近，那麼則距離越近！ 127.0.0.1:6379> geohash china:city beijing chongqi
1) "wx4fbxxfke0"
2) "wm5xzrybty0" 複制
Hyperloglog
可以容錯再使用
COPY127.0.0.1:6379> PFadd mykey a b c d e f g h i j # 建立第一組元素
mykey (integer) 1
127.0.0.1:6379> PFCOUNT mykey # 統計 mykey 元素的基數數量 (integer) 10
127.0.0.1:6379> PFadd mykey2 i j z x c v b n m # 建立第二組元素 mykey2
(integer) 1
127.0.0.1:6379> PFCOUNT mykey2
(integer) 9
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2 # 合并兩組 mykey mykey2 => mykey3 并集 OK
127.0.0.1:6379> PFCOUNT mykey3 # 看并集的數量！ (integer) 15 複制
Bitmaps
常用于隻有兩種狀态的資料
檢視某一天是否有打卡
COPY127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0 複制
統計打卡的天數
COPY127.0.0.1:6379> bitcount sign # 統計這周的打卡記錄，就可以看到是否有全勤！
(integer) 3
複制
事務
一次性，順序性，排他性。
Redis事務沒有沒有隔離級别的概念！ 所有的指令在事務中，并沒有直接被執行！隻有發起執行指令的時候才會執行！Exec
Redis單條指令式儲存原子性的，但是事務不保證原子性！
redis的事務：
- 開啟事務（multi）
- 指令入隊（......）
- 執行事務（exec）
放棄事務
COPY127.0.0.1:6379> MULTI #開啟事務
OK
127.0.0.1:6379>
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> DISCARD #取消事務
OK
127.0.0.1:6379> get k4
(nil)
複制
- 編譯型異常（代碼有問題！ 指令有錯！） ，事務中所有的指令都不會被執行
- 運作時異常（1/0）， 如果事務隊列中存在文法性，那麼執行指令的時候，其他指令是可以正常執行 的，錯誤指令抛出異常！
Jedis
COPY<!--導入jedis的包-->
<dependencies>
<!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency>
<groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.2.0</version>
</dependency> <!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.62</version>
</dependency>
</dependencies> 複制
事務
COPYpublic class TestTX {
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1", );
jedis.flushDB();
JSONObject jsonObject = new JSONObject();
jsonObject.put("hello","world");
jsonObject.put("name","kuangshen");
Transaction multi = jedis.multi(); // 開啟事務
String result = jsonObject.toJSONString();
// jedis.watch(result) 監視資料
try {
multi.set("user1",result);
multi.set("user2",result);
int i = / ; // 代碼抛出異常事務，執行失敗！
multi.exec(); // 執行事務！
} catch (Exception e) {
multi.discard(); // 放棄事務
e.printStackTrace();
} finally {
System.out.println(jedis.get("user1"));
System.out.println(jedis.get("user2"));
jedis.close(); // 關閉連接配接
}
}
} 複制
Springboot整合
- pom.xml導入操作redis的依賴
- 說明： 在 SpringBoot2.x 之後，原來使用的jedis 被替換為了 lettuce?
- jedis : 采用的直連，多個線程操作的話，是不安全的，如果想要避免不安全的，使用 jedis pool 連接配接 池！ 更像 BIO 模式
- lettuce : 采用netty，執行個體可以再多個線程中進行共享，不存線上程不安全的情況！可以減少線程資料 了，更像 NIO 模式
COPY <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency> 複制
- 編寫配置
COPYspring.redis.host=127.0.0.1
spring.redis.port=
#如果是叢集的化，配置還應該改變 複制
- 重寫一個定義一個RedisTemplate，因為原來的是jdk的序列化，本地的redis打開檢視會有中文亂玩，是以需要更換為json序列化，還有類型String Object更适合開發
COPY@Configuration
public class RedisConfig {
// 自己定義了一個 RedisTemplate
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// 我們為了自己開發友善，一般直接使用 <String, Object>
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
// Json序列化配置
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// String 的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
} 複制
- Redis常用的操作工具類
COPY
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定緩存失效時間
* @param key 鍵
* @param time 時間(秒)
*/
public boolean expire(String key, long time) {
try {
if (time > ) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根據key 擷取過期時間
* @param key 鍵 不能為null
* @return 時間(秒) 傳回0代表為永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判斷key是否存在
* @param key 鍵
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除緩存
* @param key 可以傳一個值 或多個
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > ) {
if (key.length == ) {
redisTemplate.delete(key[]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通緩存擷取
* @param key 鍵
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通緩存放入
* @param key 鍵
* @param value 值
* @return true成功 false失敗
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通緩存放入并設定時間
* @param key 鍵
* @param value 值
* @param time 時間(秒) time要大于0 如果time小于等于0 将設定無限期
* @return true成功 false 失敗
*/
public boolean set(String key, Object value, long time) {
try {
if (time > ) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 遞增
* @param key 鍵
* @param delta 要增加幾(大于0)
*/
public long incr(String key, long delta) {
if (delta < ) {
throw new RuntimeException("遞增因子必須大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 遞減
* @param key 鍵
* @param delta 要減少幾(小于0)
*/
public long decr(String key, long delta) {
if (delta < ) {
throw new RuntimeException("遞減因子必須大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
* @param key 鍵 不能為null
* @param item 項 不能為null
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 擷取hashKey對應的所有鍵值
* @param key 鍵
* @return 對應的多個鍵值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
* @param key 鍵
* @param map 對應多個鍵值
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并設定時間
* @param key 鍵
* @param map 對應多個鍵值
* @param time 時間(秒)
* @return true成功 false失敗
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > ) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一張hash表中放入資料,如果不存在将建立
*
* @param key 鍵
* @param item 項
* @param value 值
* @return true 成功 false失敗
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一張hash表中放入資料,如果不存在将建立
*
* @param key 鍵
* @param item 項
* @param value 值
* @param time 時間(秒) 注意:如果已存在的hash表有時間,這裡将會替換原有的時間
* @return true 成功 false失敗
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > ) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 鍵 不能為null
* @param item 項 可以使多個 不能為null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判斷hash表中是否有該項的值
*
* @param key 鍵 不能為null
* @param item 項 不能為null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash遞增 如果不存在,就會建立一個 并把新增後的值傳回
*
* @param key 鍵
* @param item 項
* @param by 要增加幾(大于0)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash遞減
*
* @param key 鍵
* @param item 項
* @param by 要減少記(小于0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根據key擷取Set中的所有值
* @param key 鍵
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根據value從一個set中查詢,是否存在
*
* @param key 鍵
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将資料放入set緩存
*
* @param key 鍵
* @param values 值 可以是多個
* @return 成功個數
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return ;
}
}
/**
* 将set資料放入緩存
*
* @param key 鍵
* @param time 時間(秒)
* @param values 值 可以是多個
* @return 成功個數
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > )
expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return ;
}
}
/**
* 擷取set緩存的長度
*
* @param key 鍵
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return ;
}
}
/**
* 移除值為value的
*
* @param key 鍵
* @param values 值 可以是多個
* @return 移除的個數
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return ;
}
}
// ===============================list=================================
/**
* 擷取list緩存的内容
*
* @param key 鍵
* @param start 開始
* @param end 結束 0 到 -1代表所有值
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 擷取list緩存的長度
*
* @param key 鍵
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return ;
}
}
/**
* 通過索引 擷取list中的值
*
* @param key 鍵
* @param index 索引 index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入緩存
*
* @param key 鍵
* @param value 值
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入緩存
* @param key 鍵
* @param value 值
* @param time 時間(秒)
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > )
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入緩存
*
* @param key 鍵
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入緩存
*
* @param key 鍵
* @param value 值
* @param time 時間(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > )
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根據索引修改list中的某條資料
*
* @param key 鍵
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N個值為value
*
* @param key 鍵
* @param count 移除多少個
* @param value 值
* @return 移除的個數
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return ;
}
}
} 複制
最後，學習筆記
- PDF:https://cdn.jsdelivr.net/gh/HimitZH/Redis/Redis.pdf
- GitHub：https://github.com/HimitZH/Redis