一.初识Redis
1.什么是Redis与Redis配置
Redis是一种键值型的NoSql数据库。有两个关键词：
*键值型
*NoSql
特点：C语言开发 基于内存 开源 键值对（key-value）结构数据库
高性能，官方提供的数据是可以达到100000+的QPS（每秒内查询次数），简单说就是查询快。
但因为是基于内存的，内存又有限，所以一般用来存热点数据（短时间或者经常访问）。
【1】键值型
指Redis中存储的数据都是以key,value堆的形式存储，而value的形式多种多样，可以是字符串，数值，甚至是json:
【2】NoSql
NoSql可以翻译做Not Only Sql（不仅仅是SQL），或者是No Sql（非Sql的）数据库。称被之为非关系型数据库。NoSql数据库并不是要取代非关系型数据库，而是关系型数据库的补充。
（1）结构化与非结构化
传统关系型数据库是结构化数据，每一张表都有严格的约束信息：字段名，字段数据类型，字段约束等等信息，插入的数据必须遵循这些约束：
而NoSql数据库格式没有严格要求，可以是键值型，文档型，甚至可以是图格型。
（2）关联与非关联
传统数据库表与表之间往往存在关联，例如外键。而非关系型数据库不存在关联关系，要维护关系只能靠代码业务逻辑和数据之间的耦合。
（3）查询
非关系型数据库语法差异大。
（4）事务
非关系型数据库往往不支持事务，或者不能严格保证ACID的特性。
应用场景：缓存，任务队列，消息队列，分布式锁等。
2.Redis下载与安装
3.Redis服务启动与停止
【1】启动服务
(1)Linux服务端：Linux中使用redis-server命令启动redis服务，默认端口号为6379。（在所有位置都能使用redis-server）
ctrl+c停止Redis服务；或者ps -ef | grep 'redis'查看对应的进程 kill -9 进程号来停止Redis服务。
相关操作：。
(2)Linux客户端：定位到redis文件夹,然后输入redis-cli就可以启动客户端
(1)Windows服务端：在Windows上点击redis-server.exe，就可以启动服务端，
(2)Windows客户端：然后再点击redis-cli.exe就可以启用客户端输入命令。
【2】相关操作
通过配置将redis-server挂后台运行
通过配置实现开机自启
修改配置文件让客户端需要密码认证
修改配置文件让服务端可以被远程客户端连接
修改完配置文件后怎么重启redis
怎么用控制台让Windows的redis-cli远程连接linux的redis-server
图形化界面：
GitHub上的大神编写了Redis的图形化桌面客户端，地https://github.com/uglide/RedisDesktopManager
不过该仓库提供的是RedisDesktopManager的源码，并未提供windows安装包。
在下面这个仓库可以找到安装包：https://github.com/lework/RedisDesktopManager-Windows/releases
二.Redis数据类型
1.Redis的类型有哪些
Redis存储的是key-value数据类型，其中Key是字符串类型，value包含了很多不同的类型。
不同类型的命令称为一个group，我们也可以通过help命令来查看各种不同group的命令。
接下来，我们就学习常见的五种基本数据类型的相关命令：
2.通用命令
通用指令是部分数据类型的，都可以使用的指令，常见的有：
- KEYS：查看符合模板的所有key
- DEL：删除一个指定的key
- EXISTS：判断key是否存在
- EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
- TTL：查看一个KEY的剩余有效期
通过help [command] 可以查看一个命令的具体用法。
3.Key的命名
Redis没有类似MySQL中的Table的概念，我们该如何区分不同类型的key呢？
例如，需要存储用户、商品信息到redis，有一个用户id是1，有一个商品id恰好也是1，此时如果使用id作为key，那就会冲突了，该怎么办？
我们可以通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范：
Redis的key允许有多个单词形成层级结构，多个单词之间用':'隔开，格式如下：
[业务名称]:[数据名]:[id]这个格式并非固定，也可以根据自己的需求来删除或添加词条。这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。
例如：
我项目中key的定义：
public static final String USER_INFO_KEY="user:info:";
public static final Long USER_INFO_TTL=30L;
public static final String USER_BLACKLIST_KEY="user:blacklist:";
public static final Long USER_BLACKLIST_TTL = 30L;
public static final String EMAIL_VERIFYCODE_KEY="email:verifycode:";
public static final Long EMAIL_VERIFYCODE_TTL=120L;
public static final String MUSIC_RANKLIST_KEY="music:rankList:";
并且，在Redis的桌面客户端中，还会以相同前缀作为层级结构，让数据看起来层次分明，关系清晰。
key的长度不超过44字节:key是string类型，底层编码包含int、embstr和raw三种。embstr在小于44字节使用，采用连续内存空间，内存占用更小。当字节数大于44字节时，会转为raw模式存储，在raw模式下，内存空间不是连续的，而是采用一个指针指向了另外一段内存空间，在这段空间里存储SDS内容，这样空间不连续，访问的时候性能也就会收到影响，还有可能产生内存碎片
3.类型详解
1.String类型--主要用来存储整数，浮点数和字符串这些普通数据类型以及对象
String类型，也就是字符串类型，是Redis中最简单的存储类型。
其value是字符串，不过根据字符串的格式不同，又可以分为3类：
string：普通字符串
int：整数类型，可以做自增、自减操作
float：浮点类型，可以做自增、自减操作
不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m.
如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储。
2.Hash类型--主要用来存储hash表和对象
Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。
String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便。
Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD：
简单说存储的值是键值对，键值对套键值对，哈哈哈
问题：存储对象什么时候用String，什么时候用Hash
String一般用于缓存简单数据和对象，而Hash一般用于缓存Hash表和对象。
1.如果你经常需要更新对象的部分字段而不是整个对象，hash类型可以避免读取和写入整个对象的开销。例如，用户的在线状态、最后登录时间等信息需要独立更新。
2.对于包含多个字段的小对象，使用hash类型可以比使用多个string类型更节省内存。Redis对小的hash对象进行了优化，使其能够更高效地存储。
简单说在存储对象的内存方面一个String类型优于一个Hash类型优于多个字段分开存储的String类型
示例：
假设你有一个用户对象，包含用户名、年龄和地址三个字段：
使用String类型--这种方式适用于你不需要频繁更新单个字段的情况
SET user:1001 '{"username": "alice", "age": 30, "address": "Wonderland"}'使用Hash类型：这种方式适用于你需要独立操作各个字段的情况
HMSET user:1001 username "alice" age 30 address "Wonderland"比如只更新用户的地址：
HSET user:1001 address "New Wonderland"
总结来说，选择使用string类型还是hash类型主要取决于你的数据结构和操作需求。对于简单值和需要整体操作的数据，使用string类型更合适；对于多字段对象和需要部分更新的数据，使用hash类型更高效。
3.List类型--常用来存储一个有序数据
Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。
特征也与LinkedList类似：
- 有序
- 元素可以重复
- 插入和删除快
- 查询速度一般
常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。
4.Set类型--集合
Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：
-无序
-元素不可重复
-查找快
-支持交集、并集、差集等功能
5.SortedSet类型--不可重复，便于排序
Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。
SortedSet具备下列特性：
- 可排序
- 元素不重复
- 查询速度快
因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。
更多命令详情可以到这个网站学习：redis命令手册
三.在Java中操作Reidis
1.介绍
Redis的Java客户端很多，官方推荐的有三种：Jedis,Lettuce,Redisson
Spring对Redis客户端进行了整合，提供了Spring Data Redis，在Spring Boot项目中还提供了对应的Start，即spring-boot-start-data-redis。
2.Jedis（只是简单介绍一下）
导入依赖与一个小demo
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.0</version>
</dependency>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);
//删除
//jedis.del("username");
jedis.hset("myhash","addr","bj");
String hValue = jedis.hget( "myhash", "addr");
System.out.println(hValue);
Set<String> keys=jedis.keys("*");
for(String key:keys){
System.out.println(key);
}
//3.关闭连接
jedis.close();
}
}
3.Spring Data Redis入门（底层是对jedis做的封装）
SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis。
-
提供了对不同Redis客户端的整合（Lettuce和Jedis）
-
提供了RedisTemplate统一API来操作Redis
-
支持Redis的发布订阅模型
-
支持Redis哨兵和Redis集群
-
支持基于Lettuce的响应式编程
-
支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
-
支持基于Redis的JDKCollection实现
SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：
【1】导入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>【2】Spring Data Redis的使用非常简单，只需要用@Autowired或@Resource注入RedisTemplate就可以调用RedisTemplate里面的方法操作redis了。
例如下面在redis中添加了键值对city:beijing
@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringDataRedisTest {
@Resource
private RedisTemplate redisTemplate;
@Test
public void testString(){
redisTemplate.opsForValue().set("city","beijing");
}
}【3】配置
spring.redis.host=localhost
spring.redis.port=6379
#spring.redis.password=123456
#redis为我们提供16个数据库（具体数量可以在配置文件下载），默认操作0号数据库
spring.redis.database=0
#Redis连接池配置
##最大连接数
#spring.redis.jedis.pool.max-active
##连接池最小空塞等待时间
#spring.redis.jedis.pool.max-wait
##连接池中的最大空闲时间
#spring.redis.jedis.pool.max-idle
##连接池中的最小空闲时间
#spring.redis.jedis.pool.min-idle注：连接池配置
Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。
【4】添加配置类，替换JDK序列化为JSON序列化
前面的知识--序列化：将对象转化为字符串
打开redis客户端执行key *命令，我们会发现key不是city。因为在写入前会把Object序列化为字节形式，默认是采用JDK序列化。
类似于下面这样：
缺点：
- 可读性差
- 内存占用较大
我们可以自定义RedisTemplate的序列化方式，代码如下：
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
// 创建RedisTemplate对象
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 设置连接工厂
template.setConnectionFactory(connectionFactory);
// 创建JSON序列化工具
GenericJackson2JsonRedisSerializer jsonRedisSerializer =
new GenericJackson2JsonRedisSerializer();
// 设置Key的序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// 设置Value的序列化
template.setValueSerializer(jsonRedisSerializer);
template.setHashValueSerializer(jsonRedisSerializer);
// 返回
return template;
}
}这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果类似下图：
整体可读性有了很大提升，并且能将Java对象自动的序列化为JSON字符串，并且查询时能自动把JSON反序列化为Java对象。不过，其中记录了序列化时对应的class名称，目的是为了查询时实现自动反序列化。这会带来额外的内存开销。
【5】StringRedisTemplate--无序列化，自己手动序列化
为了节省内存空间，我们可以不使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。
因为存入和读取时的序列化及反序列化都是我们自己实现的，SpringDataRedis就不会将class信息写入Redis了。
这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式。
省去了我们自定义RedisTemplate的序列化方式的步骤，而是直接使用【一般redis存储字符串类型都会使用StringRedisTemplate】：
@Autowired
private StringRedisTemplate stringRedisTemplate;
// JSON序列化工具
private static final ObjectMapper mapper = new ObjectMapper();
@Test
void testSaveUser() throws JsonProcessingException {
// 创建对象
User user = new User("虎哥", 21);
// 手动序列化
String json = mapper.writeValueAsString(user);
// 写入数据
stringRedisTemplate.opsForValue().set("user:200", json);
// 获取数据
String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
// 手动反序列化
User user1 = mapper.readValue(jsonUser, User.class);
System.out.println("user1 = " + user1);
}
【6】我们还会将RedisTemplate的方法进一步封装为工具类
这是我在网上找的一个工具类：
package com.flyingpig.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key)
{
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public long deleteObject(final Collection collection)
{
return redisTemplate.delete(collection);
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey)
{
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 删除Hash中的数据
*
* @param key
* @param hkey
*/
public void delCacheMapValue(final String key, final String hkey)
{
HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.delete(key, hkey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern)
{
return redisTemplate.keys(pattern);
}
}然后的话我们在别的类中
@Autowired
private RedisCache redisCache;就可以使用这个工具类了。例如我们可以在登录的使用将用户信息存入redis中：
//如果认证通过了，使用userid生成一个jwt jwt存入ResponseResult返回
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userid = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userid);
//把完整的用户信息存入redis userid作为key
redisCache.setCacheObject("login:"+userid,loginUser);4.Spring Cache框架
Spring Cache 是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。
Spring Cache 提供了一层抽象，底层可以切换不同的缓存实现，例如：
【1】EHCache
【2】Caffeine
【3】Redis(常用)
起步依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>常用注解
在SpringCache中提供了很多缓存操作的注解，常见的是以下的几个：
| 注解 | 说明 |
|---|---|
| @EnableCaching | 开启缓存注解功能，通常加在启动类上 |
| @Cacheable | 在方法执行前先查询缓存中是否有数据，如果有数据，则直接返回缓存数据；如果没有缓存数据，调用方法并将方法返回值放到缓存中 |
| @CachePut | 将方法的返回值放到缓存中 |
| @CacheEvict | 将一条或多条数据从缓存中删除 |
901
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
