Redis缓存优化、本地锁及分布式锁的入门使用思想实现

1、依赖启动器引入

org.springframework.bootspring-boot-starter-data-redis

org.apache.commonscommons-pool22.6.0

2、操作Redis序列化配置类

万能是配置类，只要使用redis作为缓存的都可以实体下面的配置类

序列化与默认序列化的区别

package com.zcl.gmall.common.config;import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;/*** @author: xiao_zhong* @description: Redis配置类* @date: 2022/11/16 9:55* @param: null* @return:*/
@Configuration
@EnableCaching
public class RedisConfig {@Beanpublic RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate redisTemplate = new RedisTemplate<>();//  设置redis的连接池工厂。redisTemplate.setConnectionFactory(redisConnectionFactory);//  设置序列化的(在查看redis数据的时候不会出现乱码)。Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);ObjectMapper objectMapper = new ObjectMapper();objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(objectMapper);//  将Redis 中 string ，hash 数据类型，自动序列化！redisTemplate.setKeySerializer(new StringRedisSerializer());redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);//  设置数据类型是Hash 的 序列化！redisTemplate.setHashKeySerializer(new StringRedisSerializer());redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);redisTemplate.afterPropertiesSet();return redisTemplate;}
}

3、配置Redis的连接信息

spring: redis:host: xxx.xxx.xxx.xxxport: 6379database: 0timeout: 1800000password:lettuce:pool:max-active: 20 #最大连接数max-wait: -1    #最大阻塞等待时间(负数表示没限制)max-idle: 5    #最大空闲min-idle: 0     #最小空闲

4、定义操作Redis的Key常量

redis的key是不能进行重复的，否则数据会覆盖，同时也不会通过硬编码的形式写死在储存的key位置上，这样不便于后面的维护，一般都是通过定义枚举、接口、静态类进行统一的描述key的使用，这样在后面需要进行key重新定义的时候就可以一处修改处处生效

package com.zcl.gmall.common.constant;public class RedisConst {/**单位：秒 尝试获取锁的最大等待时间*/public static final long SKULOCK_EXPIRE_PX1 = 1;/**单位：秒 锁的持有时间*/public static final long SKULOCK_EXPIRE_PX2 = 1;/**锁的后缀*/public static final String SKULOCK_SUFFIX = ":lock";
}

5、本地锁和分布式锁的基本思路流程图

5.1、本地锁

5.2、分布式锁

6、本地锁实现案例

6.1、定义Redis中的初始化数据

6.2、控制器编写

package com.zcl.gmall.product.controller;import com.zcl.gmall.product.service.TestService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import javax.annotation.Resource;/*** @Author: zcl* @description: 测试Redis分布式锁控制器* @DATE: 2022/12/8 10:21 星期四* @Version 1.0*/
@RestController
@RequestMapping("/admin/product/test")
public class TestRedisController {/*** 描述：注入业务接口*/@Resourceprivate TestService testService;/*** @author: mac* @description: 测试本地锁* @date: 2022/12/8 10:23* @param:* @return: java.lang.String*/@GetMapping("/testLock")public String testLock() {return testService.testLock();}
}

6.3、业务接口实现

package com.zcl.gmall.product.service.impl;import com.zcl.gmall.product.service.TestService;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;import javax.annotation.Resource;/*** @Author: zcl* @description: 测试Redis测试接口实现类* @DATE: 2022/12/8 10:25 星期四* @Version 1.0*/
@Service
public class TestServiceImpl implements TestService {/*** 描述：注入redis的操作模板接口*/@Resourceprivate StringRedisTemplate stringRedisTemplate;/*** @author: mac* @description: 测试本地锁的局限性* @date: 2022/12/8 10:26* @param:* @return: java.lang.String*/@Overridepublic String testLock() {/*** 实现步骤：* 1、从redis中获取数据* 2、对num数据进行+1操作* 3、设置新的num到redis中*/String numValue = stringRedisTemplate.opsForValue().get("num");if (StringUtils.isEmpty(numValue)) {return "0";}Integer num = Integer.parseInt(numValue);stringRedisTemplate.opsForValue().set("num", String.valueOf(++num));return String.valueOf(num);}
}

6.4、访问测试

1、单点访问

不是高并发访问，访问一次处理一次，再次查看Redis中储存的num是否也等于12
注意：这里是点击了12次所以返回的也就是12

2、ab高并发测试

mac是自带ab压测，但是默认的有并发数限制需要重新安装

3、压测结果：

当没有个业务接口加锁的时候，修改的num数据是不到5000的，也就是不能保证数据的唯一性存在很大的问题
如何加锁，只需要在业务接口实现类上添加synchronized关键字进行修饰即可添加上本地锁，再次通过上面的压测命令就可以得到redis中的num=5000，保证了数据的唯一性

4、集群测试本地锁思路

1. 复制多个服务修改启动端口号进行启动
2. 服务注册到nacos
3. 创建网关服务并设置对应的请求断言，网关默认是80直接访问会负载均衡到测试服务
4. 再次通过ab压测查看最后的redis中的num数据

分布式本地锁的局限性：
1、synchronized本地锁由jvm进行管理
2、搭建了集群模式就是三个不同的jvm管理synchronized本地锁
3、本地锁只能锁住同一工程内的资源，在分布式系统里面都存在局限性

7、Redis分布式锁案例

先完成三个微服务的穿件以及网关模块的搭建，能够正常访问到请求再进行下面的操作

为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：

- 互斥性。在任意时刻，只有一个客户端能持有锁。

- 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。

- 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

- 加锁和解锁必须具有原子性

7.1、setnx占坑思想实现

1、创建控制器

/**
* @author: mac
* @description: redis的setnx占坑思想
* @date: 2022/12/8 14:46
* @param:
* @return: java.lang.String
*/
@GetMapping("/testLock2")
public String testLock2() {return testService.testLock2();
}

2、业务接口实现

下面的业务接口实现了较为完善的redis分布式锁处理，通过使用uuId和lua脚本保证了删除锁的原子性

/*** @author: mac* @description: redis占坑思想实现* @date: 2022/12/8 14:47* @param:* @return: java.lang.String*/
@Override
public String testLock2() {String uuId = UUID.randomUUID().toString().replaceAll("-", "");/*** 实现步骤：* 1、获取锁* 2、判断锁* 3、释放锁*/Integer num = null;// 设置过期时间，注意【过期时间需要根据业务的执行速度最终计算获得否则就会乱释放锁】// 场景：7秒执行完的业务所的过期时间设置3秒，往后想想就知道锁会被释放错Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuId, 3, TimeUnit.SECONDS);if (lock) {String numValue = stringRedisTemplate.opsForValue().get("num");if (StringUtils.isEmpty(numValue)) {return "0";}num = Integer.parseInt(numValue);stringRedisTemplate.opsForValue().set("num", String.valueOf(++num));// 定义lua脚本final String lu = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +"then\n" +"    return redis.call(\"del\",KEYS[1])\n" +"else\n" +"    return 0\n" +"end";DefaultRedisScript redisScript = new DefaultRedisScript<>();// 设置lua脚本redisScript.setScriptText(lu);// 设置返回值类型redisScript.setResultType(Long.class);// 通过lua脚本进行删除，只要当key的值域uuId的值一致时才会进行删除(反之误删除，lua保证原子性)stringRedisTemplate.execute(redisScript, Arrays.asList("lock"), uuId);} else {try {// 没有获取到锁就自旋Thread.sleep(100);testLock2();} catch (InterruptedException e) {throw new RuntimeException(e);}}return String.valueOf(num);
}

3、ab测试

重新启动三个集群微服务，通过ab进行压测网关然后负载均衡到各个微服务端口集合完成测试，当查询查看redis中的num=5000时，说明上面的setnx占坑实现的分布式锁是可以正常的使用的

7.2、redisson解决分布式锁

官网文档地址：https://github.com/redisson/redisson/wiki/8.-distributed-locks-and-synchronizers/#81-lock

加锁和释放锁的方法

RLock lock = redisson.getLock("myLock");// traditional lock method
lock.lock();// or acquire lock and automatically unlock it after 10 seconds
lock.lock(10, TimeUnit.SECONDS);// or wait for lock aquisition up to 100 seconds 
// and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {try {...} finally {lock.unlock();}
}

1、引入依赖

org.redissonredisson3.18.0
  

2、搭建配置类

package com.zcl.gmall.common.config;import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;/*** @author: xiao_zhong* @description: redisson配置信息* @date: 2022/11/16 19:05* @param: null* @return:*/
@Data
@Configuration
@ConfigurationProperties("spring.redis")
public class RedissonConfig {/**连接主机IP*/private String host;/**地址*/private String addresses;/**连接密码*/private String password;/**连接端口号*/private String port;/**连接超时时间*/private int timeout = 3000;/**连接池大小*/private int connectionPoolSize = 64;/**最小空闲大小*/private int connectionMinimumIdleSize=10;/**ping连接间隔*/private int pingConnectionInterval = 60000;private static String ADDRESS_PREFIX = "redis://";/*** @author: xiao_zhong* @description: 自动装配* @date: 2022/11/16 19:05* @param:* @return: org.redisson.api.RedissonClient*/@BeanRedissonClient redissonSingle() {Config config = new Config();if(StringUtils.isEmpty(host)){throw new RuntimeException("host is  empty");}SingleServerConfig serverConfig = config.useSingleServer()// redis://127.0.0.1:7181.setAddress(ADDRESS_PREFIX + this.host + ":" + port).setTimeout(this.timeout).setPingConnectionInterval(pingConnectionInterval).setConnectionPoolSize(this.connectionPoolSize).setConnectionMinimumIdleSize(this.connectionMinimumIdleSize);if(!StringUtils.isEmpty(this.password)) {serverConfig.setPassword(this.password);}return Redisson.create(config);}
}

3、创建控制器

    /*** @author: mac* @description: redisson解决分布式锁* @date: 2022/12/8 18:18* @param:* @return: java.lang.String*/@GetMapping("testLock3")public String testLock3() {return testService.testLock3();}

4、业务接口实现【可重入锁】

/*** @author: xiao_zhong* @description: redisson测试分布式锁* @date: 2022/11/16 19:10* @param:* @return: void*/
@Override
public void testLock3() {// 1、定义缓存的keyString skuKey = "sku:" + 1317 + "info";// 2、获取锁RLock lock = redissonClient.getLock(skuKey);try {// 3、加锁一// lock.lock();// 加锁二：设置超时时间// 加锁以后10秒钟自动解锁,无需调用unlock方法手动解锁// lock.lock(7,TimeUnit.SECONDS);// 加锁三：尝试加锁，最多等待100秒，上锁以后10秒自动解锁boolean tryLock = lock.tryLock(100, 10, TimeUnit.SECONDS);if(tryLock){// 4、查询redis中的num数据++String num = stringRedisTemplate.opsForValue().get("num");if(StringUtils.isBlank(num)){return;}int val = Integer.parseInt(num);// 5、设置数据添加stringRedisTemplate.opsForValue().set("num",String.valueOf(++val));}else {Thread.sleep(50);testLock3();}} catch (InterruptedException e) {throw new RuntimeException(e);}finally {// 6、释放锁lock.unlock();}
}

7.3、redisson（ReadWriteLock）读写锁操作

1、创建控制器

/*** 注入测试业务接口*/
@Autowired
private TestService testService;/*** @author: xiao_zhong* @description: 写锁测试* @date: 2022/11/16 20:04* @param:* @return: java.lang.String*/
@GetMapping("/write")
public String write(){return testService.writeLock4();
}/*** @author: xiao_zhong* @description: 读锁测试* @date: 2022/11/16 20:04* @param:* @return: java.lang.String*/
@GetMapping("/read")
public String read(){return testService.readLock4();
}

2、业务接口实现类编写

 	/*** @author: mac* @description: 写锁测试* @date: 2022/12/8 19:06* @param:* @return: java.lang.String*/@Overridepublic String writeLock4() {// 1、初始化获取锁RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");// 2、获取读锁RLock rLock = readWriteLock.writeLock();// 3、写锁rLock.lock(10, TimeUnit.SECONDS);// 4、写入redisstringRedisTemplate.opsForValue().set("msg", String.valueOf(System.currentTimeMillis()));// 5、释放锁// rLock.unlock();return "写入一条数据到redis中";}/*** @author: mac* @description: 读锁测试* @date: 2022/12/8 19:06* @param:* @return: java.lang.String*/@Overridepublic String readLock4() {// 1、初始化获取锁RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");// 2、获取读锁RLock rLock = readWriteLock.readLock();// 3、写锁rLock.lock(10, TimeUnit.SECONDS);// 4、写入redisString msg = stringRedisTemplate.opsForValue().get("msg");// 5、释放锁// rLock.unlock();return msg;}

3、读写锁测试互斥性

同时将【读和写】的业务代码统一修改加锁的时间为rLock.lock(10,TimeUnit.SECONDS);,并且将释放锁的代码rLock.unlock();注释掉

说明：互斥说明，就是在请求的时候需要等待上面所设置的10秒过期时间才能真正访问到数据，否则浏览器一直在转圈等待

解决：只要涉及到写，就必须互斥

说明：如果上面的知识点有不妥或描述有误的地方请留言或私信交流更正