共计 8337 个字符，预计需要花费 21 分钟才能阅读完成。
1.Redis 简介
Redis 是用 C 语言开发的一个开源的高性能键值对 (key-value) 数据库，官网提供的数据是能够达到 100000+ 的 QPS（每秒内查问次数）。它存储的 value 类型比拟丰盛，也被称为结构化的 NoSql 数据库。
特点：
1. 基于内存存储，读写性能高
2. 适宜存储热点数据(热点商品、资讯、新闻等)
3. 企业应用宽泛
简而言之，Redis 个别用来存热点数据 (微博热搜这些) 因为用户要频繁拜访。
2.Redis 罕用数据类型
Redis 存储的是 key-value 构造的数据，其中 key 是字符串类型，value 有 5 种罕用的数据类型：
1. 字符串
2. 哈希 hash
3. 列表
4. 汇合 set
5. 有序汇合 sorted set
3.Redis 常用命令
1. 字符串操作
SET key value
设置指定 key 的值
GET key
获取指定 key 值
SETEX key seconds value
设置指定 key 的值，并将 key 的过期工夫设为 seconds 秒
SETNX key value
只有在 key 不存在时设置 key 的值
2. 哈希 hash 操作命令
HSET key field value 将哈希表 key 中的字段 field 的值设为 value
HGET key field 获取存储在哈希表中指定字段的值
HDEL key field 删除存储在哈希表中的指定字段
HKEYS key 获取哈希表中所有字段
HVALS key 获取哈希表中所有值
HGETALL key 获取在哈希表中指定 key 的所有字段和值
3. 列表 List 操作常用命令
LPUSH key value1 [value2] 将一个或多个值插入到列表头部
LRANGE key start stop 获取列表指定范畴内的元素
RPOP key 移除并获取列表最初一个元素
LLEN key 获取列表长度
BRPOP key1 [key2] timeout 移出并获取列表的最初一个元素，如果列表没有元素会阻塞列表直到期待超时或发现可弹出元素为止
4. 汇合 set 操作常用命令
Redis set 汇合成员是惟一的，这就意味着汇合中不能呈现反复的数据，常用命令：
SADD key member1 [member2] 向汇合增加一个或多个成员
SMEMBERS key 返回汇合中的所有成员
SCARD key 获取汇合的成员数
SINTER key1 [key2] 返回给定所有汇合的交加
SUNION key1 [key2] 返回所有给定汇合的并集
SDIFF key1 [key2] 返回给定所有汇合的差集
SREM key member1 [member2] 移除汇合中一个或多个成员
5. 有序汇合 sorted set 操作常用命令
Redis sorted set 有序汇合是 string 类型元素的汇合，且不容许反复的成员。每个元素都会关联一个 double 类型的分数 (score)。redis 正是通过分数来为汇合中的成员进行从小到大排序。有序汇合的成员是惟一的，但分数却能够反复。
常用命令：
ZADD key score1 member1 [score2 member2]
向有序汇合增加一个或多个成员，或者更新已存在成员的分数
ZRANGE key start stop [WITHSCORES]
通过索引区间返回有序汇合中指定区间内的成员
ZINCRBY key increment member
有序汇合中对指定成员的分数加上增量 increment
ZREM key member [member …]
移除有序汇合中的一个或多个成员
6. 通用命令
KEYS pattern
查找所有合乎给定模式 (pattern) 的 key
EXISTS key
查看给定 key 是否存在
TYPE key
返回 key 所贮存的值的类型
TTL key
返回给定 key 的残余生存工夫(TTL, time to live)，以秒为单位
DEL key
该命令用于在 key 存在是删除 key
4.JAVA 中操作 Redis
1. 简介
Redis 的 JAVA 客户端有很多，官网举荐的有：
1.Jedis
2.Lettuce
3.Redisson
这里应用 Jedis
2. 新建 Maven 工程
3.pom 文件中导入依赖
别离导入 junit 单元测试和 redis 依赖
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.3.0-m2</version>
</dependency>
</dependencies>4. 启动 redis 服务
双击装置目录下 redis-server.exe 即可
5. 编写 Jedis 类并启动
package com.dawn.test;
import org.junit.Test;
import redis.clients.jedis.Jedis;
public class JedisTest {
@Test
public void testRedis(){
//1. 获取连贯
Jedis jedis = new Jedis("localhost",6379);
//2. 执行具体操作
jedis.set("username","xiaoming");
//3. 敞开连贯
jedis.close();}
}6. 操作 redis-cli
在 java 外面启动 Redis，无需启动 redis-cli
启动 redis-cli
输出命令行，未启动 Jedis 类前为空, 启动 Jedis 后不为空
也可持续在 java 外面操作 Jedis
package com.dawn.test;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.Set;
public class JedisTest {
@Test
public void testRedis(){
//1. 获取连贯
Jedis jedis = new Jedis("localhost",6379);
//2. 执行具体操作
jedis.set("username","xiaoming");
// 取值
String value = jedis.get("username");
System.out.println(value);
// 操作 Hash
jedis.hset("myhash","addr","bj");
String hValue = jedis.hget("myhash","addr");
System.out.println(hValue);
// 循环输入 redis 值
Set<String> keys = jedis.keys("*");
for (String key : keys) {System.out.println(key);
}
//3. 敞开连贯
jedis.close();}
}后果如下
5.Spring Data Redis
在 Spring Boot 我的项目中，能够应用 Spring Data Redis 来简化 Redis 操作
1. 导入 Maven 依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.7.4</version>
</dependency>2. 操作类
Spring Data Redis 中提供了一个高度封装的类：RedisTemplate, 针对 Jedis 客户端中大量 ap 进行了归类和封装，将同一类型操作封装为 Operation 接口，具体分类如下：
导入坐标
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>所有的依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.5</version>
<relativePath/>
</parent>
<groupId>com.itheima</groupId>
<artifactId>springdataredis_demo</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.4.5</version>
</plugin>
</plugins>
</build>
</project>application.yml 文件
spring:
application:
name: springdataredis_demo
#Redis 相干配置
redis:
host: localhost
port: 6379
#password: 123456
database: 0 #操作的是 0 号数据库
jedis:
#Redis 连接池配置
pool:
max-active: 8 #最大连接数
max-wait: 1ms #连接池最大阻塞等待时间
max-idle: 4 #连接池中的最大闲暇连贯
min-idle: 0 #连接池中的最小闲暇连贯
启动类
package com.itheima;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class App {public static void main(String[] args) {SpringApplication.run(App.class,args);
}
}测试类
package com.itheima.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringDataRedisTest {
@Autowired
private RedisTemplate redisTemplate;
}1. 字符串操作
#### public void String(){ValueOperations valueOperations = redisTemplate.opsForValue();
// 三种设置值 间接设置，增加 DDL，判断不存在再退出
valueOperations.set("city147","beijing");
valueOperations.set("key1","value1",10,TimeUnit.SECONDS);
Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city147", "beijing");
// 取值, 输入
String city147 = (String) redisTemplate.opsForValue().get("city147");
System.out.println(city147);
}
2. 对 Hash 进行操作
@Test
public void testHash(){HashOperations hashOperations = redisTemplate.opsForHash();
// 存值
hashOperations.put("002","name","xiaoming");
hashOperations.put("002","age","20");
hashOperations.put("002","address","bj");
// 取值
String name = (String) hashOperations.get("002", "name");
System.out.println(name);
String age = (String) hashOperations.get("002", "age");
System.out.println(age);
// 取得 hash 构造中的所有字段 name,age,address
Set keys = hashOperations.keys("002");
for (Object key : keys) {System.out.println(key);
}
// 取得 hash 构造中的所有值 xiaoming 20 bj
List values = hashOperations.values("002");
for (Object value : values) {System.out.println(value);
}
}3. 对 List 进行操作
@Test
public void testList(){ListOperations listOperations = redisTemplate.opsForList();
// 存值 存一个和存多个
listOperations.leftPush("mylist1","a");
listOperations.leftPushAll("mylist1","b","c","d");
// 取值
List<String> mylist = listOperations.range("mylist1", 0, -1);
for (String value : mylist) {System.out.println(value);
}
// 取得列表长度 llen
Long size =listOperations.size("mylist1");
int lSize = size.intValue();
for (int i = 0; i < lSize; i++) {
// 出队列
String element = (String) listOperations.rightPop("mylist1");
System.out.println(element);
}
}
4. 对 Set 进行操作
@Test
public void testSet(){
// 存值
SetOperations setOperations = redisTemplate.opsForSet();
setOperations.add("myset1","a","b","c","a");
// 取值
Set<String> myset = setOperations.members("myset1");
for (String s : myset) {System.out.println(s);
}
// 删除成员
setOperations.remove("myset1","a","b");
// 取值
Set<String> myset1 = setOperations.members("myset");
for (String s : myset1) {System.out.println(s);
}
}5. 对 Zset 进行操作
@Test
public void testZset(){ZSetOperations zSetOperations = redisTemplate.opsForZSet();
// 存值, 反复则笼罩掉
zSetOperations.add("myZset1","a",10);
zSetOperations.add("myZset1","b",11);
zSetOperations.add("myZset1","c",12);
zSetOperations.add("myZset1","a",13);
// 取值，加一个泛型，存进来是字符串的类型, 从小到大排序
Set<String> myZset = zSetOperations.range("myZset1", 0, -1);
for (String s : myZset) {System.out.println(s);
}
// 批改分数, 查看分数
zSetOperations.incrementScore("myZset1","b",20);
myZset = zSetOperations.range("myZset1", 0, -1);
for (String s : myZset) {System.out.println(s);
}
// 删除成员, 取值
zSetOperations.remove("myZset1","a","b");
myZset = zSetOperations.range("myZset1", 0, -1);
for (String s : myZset) {System.out.println(s);
}
}6. 通用操作
@Test
public void testCommon(){
// 获取 Redis 中所有的 key
Set<String> keys = redisTemplate.keys("*");
for (String key : keys) {System.out.println(key);
}
// 判断某个 key 是否存在
Boolean itcast = redisTemplate.hasKey("itcast");
System.out.println(itcast);
// 删除指定 key
redisTemplate.delete("myZset");
// 获取指定 key 对应的 value 的数据类型
DataType dataType = redisTemplate.type("myset");
System.out.println(dataType.name());
}