前言
今天，我将奉上《Redis缓存技术系列（一）：概念以及使用》，以自身经验&所见所闻，旨在告诉大家，如何使用Redis，希望你们会喜欢。
核心内容
从为什么，是什么，到初级使用，再到高级使用。
概念
场景一：页面获取的数据很大，每次加载都要几秒中，给客户带来的体验很不好，如果老板去访问，那么。。。
场景二：我们项目部署在多个服务器，如何保证用户每次访问，不同的服务器可以知道是同一个用户操作呢，不然数据就会不一致。比如我们登录的时候存储的session。
所以引出我们今天的主题，Redis。
Redis（key - value 存储系统，区别于 MySQL，他存储的是键值对）
为什么获取数据慢，是因为mysql打开一个连接，和关闭一个连接，是磁盘操作。大部分用户的请求都是读操作，而且都是重复查询一个东西，所以就有了Redis的诞生，他可以给数据库做一个缓存。
特点
Redis 是基于内存操作的，吞吐量非常高，可以在 1s内完成十万次读写操作
Redis 的读写模块是单线程，每个操作都具原子性
Redis 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启可以再次加载，但可能会有极短时间内数据丢失
Redis 支持多种数据结构，String，list，set，zset，hash等
Java实现方式
Spring Data Redis（推荐）
Spring Data：通用的数据访问框架，定义了一组 增删改查 的接口，可以接入mysql、redis、jpa等。直接引入对应的库就可以操作了。这样不管你整合的是redis，还是jpa，都可以用这个方法去操作。简单来说，就是接口和实现类的区别。
1.引入依赖
<!--在springboot里引入redis，能够操作redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.6.4</version>
</dependency>
2.配置Redis地址
spring:
redis:
port: 6379
host: localhost
database: 0 #可以设置成其他，1，2，3等
3.增查
@SpringBootTest
public class RedisTest {
@Resource
private RedisTemplate redisTemplate;
@Test
public void test(){
//得到一个可以操作redis的集合类
ValueOperations valueOperations = redisTemplate.opsForValue();//操作字符串的
//添加
valueOperations.set("name","zwl");
}
}
大家可以下载一个QuickRedis来查看。
我们发现显示不出来，因为乱码了。我们可以使用StringRedisTemplate
@Autowired
private StringRedisTemplate redisTemplate;
@Test
public void test(){
//得到一个可以操作redis的集合类
ValueOperations valueOperations = redisTemplate.opsForValue();//操作字符串的
//添加
valueOperations.set("name1","zwl");
//查询
String name = (String)valueOperations.get("name1");
System.out.println(name);
}
但如果我不像使用string呢，因为RedisTemplate，他好像再我们前面加了些什么东西。做了一个序列化。那么我们可以自定义序列化器。
4.序列化，对存入redis的key，或value进行序列化成我们看得懂的，比如string
@Configuration
public class RedisTemplateConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
//配置这个工厂主要是配置 Redis 的连接池
redisTemplate.setConnectionFactory(connectionFactory);
//序列化成string 我们将键的序列化器设置成String的
redisTemplate.setKeySerializer(RedisSerializer.string());
return redisTemplate;
}
}
实战一：获取首页列表数据
- key 是需要进行设计的
systemId:moduleId:func:options
比如我们是zwl系统，用户模块，列表数据，用户id - 存储的key-value，是需要设置过期时间的，不能内存无限增加。
1)不加缓存的时候
/**
* 推荐页面
* @param request
* @return
*/
@GetMapping("/recommend")
public BaseResponse<Page<User>> recommendUsers(long pageSize, long pageNum, HttpServletRequest request){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
Page<User> userList = userService.page(new Page<>(pageNum, pageSize), queryWrapper);
return ResultUtils.success(userList);
}
2)加缓存的时候
/**
* 推荐页面
* @param request
* @return
*/
@GetMapping("/recommend")
public BaseResponse<Page<User>> recommendUsers(long pageSize, long pageNum, HttpServletRequest request){
User currentUser = userService.getCurrentUser(request);
//key
String key = String.format("user:recommed:%s",currentUser.getId());
ValueOperations valueOperations = redisTemplate.opsForValue();
Page<User> userList = (Page<User> )valueOperations.get(key);
if (userList!=null) {
return ResultUtils.success(userList);
}
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
userList = userService.page(new Page<>(pageNum, pageSize), queryWrapper);
try{
valueOperations.set(key,userList,30000, TimeUnit.MILLISECONDS);
}catch (Exception e){
log.error("redis set key error",e);
}
return ResultUtils.success(userList);
}
我们可以测试第一请求和第二次请求的差距，但前提是数据要够大，才能测出效果…
缓存预热
还是存在一个问题，那就是第一个用户访问还是很慢，如果这个时候是老板登录看的，那么。。。。
可以通过定时预热去解决，预热就是事先把数据先加入到缓存。
如何实现定时任务呢？
Spring Scheduler（spring boot 默认整合了）【一个注解搞定】
需求：用定时任务，每天刷新所有用户的推荐列表
1）主类开启 @EnableScheduling
@SpringBootApplication
@MapperScan("com.usercenter.mapper")
@EnableScheduling
public class UserCenterApplication {
public static void main(String[] args) {
SpringApplication.run(UserCenterApplication.class, args);
}
}
package com.yupi.usercenter.job;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yupi.usercenter.model.domain.User;
import com.yupi.usercenter.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
@Component
@Slf4j
public class PreCacheJob {
@Resource
private RedisTemplate redisTemplate;
@Resource
private UserService userService;
//重点id才做这个预热，不能所有的用户都做这个预热,怕内存不够
private List<Long> mainUserList = Arrays.asList(1l);
@Scheduled(cron = "0 59 23 * * *")
public void doCacheRecommendUser(){
for (Long aLong : mainUserList) {
//首先我们查询出数据
QueryWrapper queryWrapper = new QueryWrapper();
Page<User> userList = userService.page(new Page<User>(1, 20), queryWrapper);
String key = String.format("user:recommed:%s",aLong);
ValueOperations valueOperations = redisTemplate.opsForValue();
try{
valueOperations.set(key,userList,30000, TimeUnit.MILLISECONDS);
}catch (Exception e){
log.error("redis set key error",e);
}
}
}
}
但使用了定时任务，就会存在一个问题，加入说，我有多个项目，部署在不同的服务器，那么这个定时任务就会同时执行，如果数据很大，项目部署很多，那么这个就是很大的消耗量，并且重复执行没有意义。如何解决呢？，这里我们要引入一个知识点，分布式锁
分布式锁
要控制定时任务在同一时间只有 1 个服务器能执行。怎么做呢？分布式锁，只有抢到锁的服务器才能执行业务逻辑。
借助Redis 实现：因为他是内存数据库，读写速度快（所以不使用mysql） 。支持 setnx、lua 脚本，比较方便我们实现分布式锁。setnx：set if not exists 如果不存在，则设置；只有设置成功才会返回 true，否则返回 false，如下，就设置不了。这样就可以保证只有一个人可以拿到锁。
1）引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.18.0</version>
</dependency>
2）写Redisson配置
/**
* Redisson 配置
*/
@Configuration
@ConfigurationProperties(prefix = "spring.redis")//读取配置文件中内容
@Data
public class RedissonConfig {
private String host;//会被自动赋值，记得名字要一样哦
private String port;
@Bean
public RedissonClient redissonClient(){
//1、创建配置
Config config = new Config();
String redisAddress = String.format("redis://%s:%s", host, port);
config.useSingleServer().setAddress(redisAddress).setDatabase(3);//这里就写死了。
//2.创建实例:有很多种，这里我们就使用这一种
RedissonClient redisson = Redisson.create(config);
return redisson;
}
}
3)对定时任务加锁
@Slf4j
@Component
public class PreCacheJob {
@Resource
private UserService userService;
@Resource
private RedissonClient redissonClient;
@Resource
private RedisTemplate<String,Object> redisTemplate;
//重点用户
private List<Long> mainUserList = Arrays.asList(1l);
//每天执行，预热推荐用户
@Scheduled(cron = "0 24 18 * * *")
public void doCacheRecommendUser(){
RLock lock = redissonClient.getLock("precachejob:docache:lock");
try{
//只有一个线程能获取到锁
if (lock.tryLock(0,30000L,TimeUnit.MILLISECONDS)){
System.out.println("getLock: "+Thread.currentThread().getId());
for (Long userId: mainUserList){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
Page<User> userPage = userService.page(new Page<>(1, 20), queryWrapper);
String redisKey = String.format("yupao:user:recommend:%s", userId);
ValueOperations<String,Object> valueOperations = redisTemplate.opsForValue();
//写缓存
try {
valueOperations.set(redisKey,userPage,30000, TimeUnit.MILLISECONDS);
}catch (Exception e){
log.error("redis set key error",e);
}
}
}
}catch(InterruptedException e){
log.error("doCacheRecommendUser error ",e);
}finally {
//只能释放自己的锁
if (lock.isHeldByCurrentThread()){
System.out.println("unlock: "+Thread.currentThread().getId());
lock.unlock();
}
}
}
}
总结
看完本文，相信你已经熟悉Redis的基本使用了，我们下篇文章见
扫一扫
1594
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
