尚品汇商城

一、商品详情页面优化

1.1 思路

  1. 虽然咱们实现了页面需要的功能，但是考虑到该页面是被用户高频访问的，所以性能需要优化。<br />一般一个系统最大的性能瓶颈，就是数据库的io操作。从数据库入手也是调优性价比最高的切入点。<br />**一般分为两个层面，一是提高数据库sql本身的性能，二是尽量避免直接查询数据库。**<br />重点要讲的是另外一个层面：尽量避免直接查询数据库。<br />解决办法就是：缓存

1.2 整合redis到工程

由于redis作为缓存数据库，要被多个项目使用，所以要制作一个通用的工具类，方便工程中的各个模块使用。
而主要使用redis的模块，都是后台服务的模块，service工程。所以咱们把redis的工具类放到service-util模块中，这样所有的后台服务模块都可以使用redis。

1.2.1 首先在service-util引入依赖包


<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>

<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.6.0</version> </dependency>

1.2.2 添加redis配置类

package com.atguigu.gmall.common.config @Configuration
@EnableCaching
public class RedisConfig {

@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
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);

_// 序列号key value
_redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

redisTemplate.afterPropertiesSet();
return redisTemplate;
}

}


说明：由于service-util属于公共模块，所以我们把它引入到service父模块，其他service子模块都自动引入了

1.3 使用redis进行业务开发相关规则

开始开发先说明redis key的命名规范，由于Redis不像数据库表那样有结构，其所有的数据全靠key进行索引，所以redis数据的可读性，全依靠key。
企业中最常用的方式就是：object:id:field
比如：sku:1314:info
user:1092:info
:表示根据windows的 /一个意思
重构getSkuInfo方法
在RedisConst中定义redis的常量，RedisConst类在service-util模块中，所有的redis常量我们都配置在这里

package com.atguigu.gmall.common.constant;

/*
 Redis常量配置类
/
public class RedisConst {

public static final String SKUKEY_PREFIX = “sku:”;
public static final String SKUKEY_SUFFIX = “:info”;
//单位：秒 public static final long SKUKEY_TIMEOUT = 24 60 60;
}


如何使用缓存：
07 商品详情进阶 - 图1
以上基本实现使用缓存的方案。

1.4 缓存常见问题

缓存最常见的3个问题： 面试
1. 缓存穿透
2. 缓存雪崩
3. 缓存击穿
缓存穿透: 是指查询一个不存在的数据，由于缓存无法命中，将去查询数据库，但是数据库也无此记录，并且出于容错考虑，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。
解决：空结果也进行缓存，但它的过期时间会很短，最长不超过五分钟。

缓存雪崩:是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。

解决：原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

缓存击穿: 是指对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：如果这个key在大量请求同时进来之前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。
与缓存雪崩的区别：
1. 击穿是一个热点key失效
2. 雪崩是很多key集体失效
解决：锁
07 商品详情进阶 - 图2

二、分布式锁

2.1 本地锁的局限性

之前，我们学习过synchronized及lock锁，这些锁都是本地锁。接下来写一个案例，演示本地锁的问题

2.1.1 编写测试代码

在service-product中的TestController中添加测试方法

package com.atguigu.gmall.product.controller;


@Api(tags = “测试接口”)
@RestController
@RequestMapping(“admin/product/test”)
public class TestController {

@Autowired
private TestService testService;

@GetMapping(“testLock“)
public Result testLock() {
testService.testLock();
return Result.ok();
}
}
接口
package com.atguigu.gmall.product.service;

public interface TestService {

void testLock();

}
实现类
package com.atguigu.gmall.product.service.impl;
@Service
public class TestServiceImpl implements TestService {

@Autowired
private StringRedisTemplate redisTemplate; @Override
public void testLock() {
// 查询redis中的num值
_String value = (String)this.redisTemplate.opsForValue().get(“num”);
// 没有该值return
if (StringUtils._isBlank(value)){
return ;
}
// 有值就转成成int
int num = Integer.parseInt(value);
// 把redis中的num值+1
this.redisTemplate.opsForValue().set(“num”, String.valueOf(++num));
}
}


说明：通过reids客户端设置num=0

2.1.2 使用ab工具测试

使用ab测试工具：httpd-tools（yum install -y httpd-tools）

ab -n（一次发送的请求数） -c（请求的并发数） 访问路径
测试如下：5000请求，100并发

ab -n 5000 -c 100 http://192.168.200.1:8206/admin/product/test/testLock


07 商品详情进阶 - 图3
查看redis中的值：
07 商品详情进阶 - 图4

2.1.3 使用本地锁

@Override
public synchronized void testLock() {
// 查询redis中的num值
_String value = (String)this.redisTemplate.opsForValue().get(“num”);
// 没有该值return
if (StringUtils._isBlank(value)){
return ;
}
// 有值就转成成int
int num = Integer.parseInt(value);
// 把redis中的num值+1
this.redisTemplate.opsForValue().set(“num”, String.valueOf(++num));
}


使用ab工具压力测试：5000次请求，并发100
07 商品详情进阶 - 图5
查看redis中的结果：
07 商品详情进阶 - 图6
完美！与预期一致，是否真的完美？
接下来再看集群情况下，会怎样？

2.1.4 本地锁问题演示锁

接下来启动8206 8216 8226 三个运行实例。
运行多个service-product实例：
server.port=8216
server.port=8226

07 商品详情进阶 - 图7
注意：bootstrap.properties 添加一个server.port = 8206; 将nacos的配置注释掉！
通过网关压力测试：
启动网关：
ab -n 5000 -c 100 http://192.168.200.1/admin/product/test/testLock
07 商品详情进阶 - 图8
查看redis中的值：
07 商品详情进阶 - 图9
集群情况下又出问题了！！！
以上测试，可以发现：
本地锁只能锁住同一工程内的资源，在分布式系统里面都存在局限性。
此时需要分布式锁。。

2.2 分布式锁实现的解决方案

随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！
分布式锁主流的实现方案：
1. 基于数据库实现分布式锁
2. 基于缓存（Redis等）
3. 基于Zookeeper
每一种分布式锁解决方案都有各自的优缺点：
1. 性能：redis最高
2. 可靠性：zookeeper最高
这里，我们就基于redis实现分布式锁。

2.3 使用redis实现分布式锁

07 商品详情进阶 - 图10
1. 多个客户端同时获取锁（setnx）
2. 获取成功，执行业务逻辑{从db获取数据，放入缓存}，执行完成释放锁（del）
3. 其他客户端等待重试

2.3.1 编写代码

@Override
public void testLock() {
// 1. 从redis中获取锁,setnx
_Boolean lock = this.redisTemplate.opsForValue().setIfAbsent(“lock”, “111”);
if (lock) {
// 查询redis中的num值
String value = (String)this.redisTemplate.opsForValue().get(“num”);
// 没有该值return
if (StringUtils._isBlank(value)){
return ;
}
// 有值就转成成int
int num = Integer.parseInt(value);
// 把redis中的num值+1
this.redisTemplate.opsForValue().set(“num”, String.valueOf(++num));

// 2. 释放锁 del
this.redisTemplate.delete(“lock”);
} else {
// 3. 每隔1秒钟回调一次，再次尝试获取锁
try {
Thread.sleep(100);
testLock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


重启，服务集群，通过网关压力测试：
07 商品详情进阶 - 图11
查看redis中num的值：
07 商品详情进阶 - 图12
基本实现。
问题：setnx刚好获取到锁，业务逻辑出现异常，导致锁无法释放
解决：设置过期时间，自动释放锁。

2.3.2 优化之设置锁的过期时间

设置过期时间有两种方式：

1. 首先想到通过expire设置过期时间（缺乏原子性：如果在setnx和expire之间出现异常，锁也无法释放）
2. 在set时指定过期时间（推荐）
07 商品详情进阶 - 图13
设置过期时间：
07 商品详情进阶 - 图14
压力测试肯定也没有问题。自行测试
问题：可能会释放其他服务器的锁。

场景：如果业务逻辑的执行时间是7s。执行流程如下
1. index1业务逻辑没执行完，3秒后锁被自动释放。
2. index2获取到锁，执行业务逻辑，3秒后锁被自动释放。
3. index3获取到锁，执行业务逻辑
4. index1业务逻辑执行完成，开始调用del释放锁，这时释放的是index3的锁， 导致index3的业务只执行1s就被别人释放。
最终等于没锁的情况。

解决：setnx获取锁时，设置一个指定的唯一值（例如：uuid）；释放前获取这个值，判断是否自己的锁

2.3.3 优化之UUID防误删

07 商品详情进阶 - 图15
07 商品详情进阶 - 图16

问题：删除操作缺乏原子性。

场景：
1. index1执行删除时，查询到的lock值确实和uuid相等
07 商品详情进阶 - 图17
2. index1执行删除前，lock刚好过期时间已到，被redis自动释放
在redis中没有了锁。
07 商品详情进阶 - 图18
3. index2获取了lock,index2线程获取到了cpu的资源，开始执行方法
4. index1执行删除，此时会把index2的lock删除

index1 因为已经在方法中了，所以不需要重新上锁。index1有执行的权限。index1已经比较完成了，这个时候，开始执行
07 商品详情进阶 - 图19
删除的index2的锁！

2.3.4 优化之LUA脚本保证删除的原子性

@Override
public void testLock() {
// 设置uuId
_String uuid = UUID._randomUUID().toString();
// 缓存的lock 对应的值 ，应该是index2 的uuid
_Boolean flag = redisTemplate.opsForValue().setIfAbsent(“lock”, uuid,1, TimeUnit.**_SECONDS);
// 判断flag index=1
if (flag){
_// 说明上锁成功！ 执行业务逻辑 _String value = redisTemplate.opsForValue().get(“num”);
// 判断 if(StringUtils.isEmpty(value)){
return;
}
// 进行数据转换 int num = Integer.parseInt(value);
// 放入缓存 redisTemplate.opsForValue().set(“num”,String.valueOf(++num));

_// 定义一个lua 脚本 _String script = “if redis.call(‘get’, KEYS[1]) == ARGV[1] then return redis.call(‘del’, KEYS[1]) else return 0 end”;

_// 准备执行lua 脚本 _DefaultRedisScript redisScript = new DefaultRedisScript<>();
// 将lua脚本放入DefaultRedisScript 对象中 _redisScript.setScriptText(script);
// 设置DefaultRedisScript 这个对象的泛型 _redisScript.setResultType(Long.class);
// 执行删除 redisTemplate.execute(redisScript, Arrays.asList(“lock”),uuid);

}else {
// 没有获取到锁！ try {
Thread.sleep(1000);
_// 睡醒了之后，重试 _testLock();
} catch **(InterruptedException e) {
e.printStackTrace();
}
}
}


Lua 脚本详解：http://doc.redisfans.com/string/set.html
07 商品详情进阶 - 图20

2.3.5 总结

1、加锁

// 1. 从redis中获取锁,set k1 v1 px 20000 nx _String uuid = UUID._randomUUID().toString();
Boolean lock = this.redisTemplate.opsForValue()
.setIfAbsent(“lock”, uuid, 2, TimeUnit.SECONDS);


2、使用lua释放锁

// 2. 释放锁 del
_String script = “if redis.call(‘get’, KEYS[1]) == ARGV[1] then return redis.call(‘del’, KEYS[1]) else return 0 end”;
// 设置lua脚本返回的数据类型
DefaultRedisScript redisScript = new DefaultRedisScript<>();
// 设置lua脚本返回类型为Long
redisScript.setResultType(Long.class);
redisScript.setScriptText(script);
redisTemplate.execute(redisScript, Arrays._asList(“lock”),uuid);


3、重试

Thread.sleep(500);
testLock();


为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：
- 互斥性。在任意时刻，只有一个客户端能持有锁。
- 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
- 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。
- 加锁和解锁必须具有原子性

redis集群状态下的问题：
1. 客户端A从master获取到锁
2. 在master将锁同步到slave之前，master宕掉了。
3. slave节点被晋级为master节点
4. 客户端B取得了同一个资源被客户端A已经获取到的另外一个锁。
安全失效！
解决方案：了解即可！
07 商品详情进阶 - 图21

2.4 使用redisson 解决分布式锁

Github 地址：https://github.com/redisson/redisson
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。
07 商品详情进阶 - 图22
官方文档地址：https://github.com/redisson/redisson/wiki

2.4.1 实现代码

1. 导入依赖 service-util

<dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.15.3</version> </dependency>
配置_redissonpackage com.atguigu.gmall.common.config; @Data
@Configuration
@ConfigurationProperties(“spring.redis”)
public class RedissonConfig {

private String host;

private String password;

private String port;

private int timeout = 3000;
private static String _ADDRESS_PREFIX = “redis://“;

/*
 自动装配 */
@Bean
RedissonClient redissonSingle() {
Config config = new Config();

if(StringUtils.isEmpty(host)){
throw new RuntimeException(“host is empty”);
}
SingleServerConfig serverConfig = config.useSingleServer()
.setAddress(ADDRESS_PREFIX + this.host + “:” + port)
.setTimeout(this.timeout);
if(!StringUtils.isEmpty(this.password)) {
serverConfig.setPassword(this.password);
}
return Redisson.create(config);
}
}
2. 修改实现类
@Autowired
private RedissonClient redissonClient;

@Override
public void testLock() {
// 创建锁： _String skuId=“25”;
String locKey =“lock:”+skuId;
// 锁的是每个商品 RLock lock = redissonClient.getLock(locKey);
// 开始加锁 lock.lock();
// 业务逻辑代码 // 获取数据 String value = redisTemplate.opsForValue().get(“num”);
if (StringUtils._isBlank(value)){
return;
}
// 将value 变为int
int num = Integer.parseInt(value);
// 将num +1 放入缓存 redisTemplate.opsForValue().set(“num”,String.valueOf(++num));
_// 解锁： _lock.unlock();
}

2.4.2 可重入锁（Reentrant Lock）

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。
大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。
另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。
快速入门使用的就是可重入锁。也是最常使用的锁。
最常见的使用：

RLock lock = redisson.getLock(“anyLock”);
// 最常使用
lock.lock();
// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
try {
…
} finally {
lock.unlock();
}
}


改造程序：
07 商品详情进阶 - 图23
重启后在浏览器测试：

2.4.3 读写锁（ReadWriteLock）

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。
分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。

RReadWriteLock rwlock = redisson.getReadWriteLock(“anyRWLock”);
// 最常见的使用方法
rwlock.readLock().lock();
// 或
rwlock.writeLock().lock();

// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// 或
rwlock.writeLock().lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// 或
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
…
lock.unlock();


代码实现

TestController

@GetMapping(“read”)
public Result read(){
String msg = testService.readLock();

return Result.ok(msg);
}

@GetMapping(“write”)
public Result write(){
String msg = testService.writeLock();

return Result.ok(msg);
}
TestService接口String readLock();

String writeLock();
实现类
读锁，写锁要想达到互斥效果，那么锁的key ，必须是同一把 readwriteLock
@Override
public String readLock() {
// 初始化读写锁
_RReadWriteLock readWriteLock = redissonClient.getReadWriteLock(“readwriteLock”);
RLock rLock = readWriteLock.readLock(); // 获取读锁

rLock.lock(10, TimeUnit.**_SECONDS); _// 加10s锁

_String msg = this.redisTemplate.opsForValue().get(“msg”);

//rLock.unlock(); // 解锁
return msg;
}

@Override
public String writeLock() {
_// 初始化读写锁
_RReadWriteLock readWriteLock = redissonClient.getReadWriteLock(“readwriteLock”);
RLock rLock = readWriteLock.writeLock(); _// 获取写锁

_rLock.lock(10, TimeUnit.SECONDS); // 加10s锁

this.redisTemplate.opsForValue().set(“msg”, UUID.randomUUID().toString());

//rLock.unlock(); // 解锁
return “成功写入了内容。。。。。。”**;
}


打开两个浏览器窗口测试：
http://localhost:8206/admin/product/test/read
http://localhost:8206/admin/product/test/write
- 同时访问写：一个写完之后，等待一会儿（约10s），另一个写开始
- 同时访问读：不用等待
- 先写后读：读要等待（约10s）写完成
- 先读后写：写要等待（约10s）读完成

三、分布式锁改造获取sku信息

3.1 使用redis

RedisConst 类中追加一个变量

// 商品如果在数据库中不存在那么会缓存一个空对象进去，但是这个对象是没有用的，所以这个对象的过期时间应该不能太长， // 如果太长会占用内存。 // 定义变量，记录空对象的缓存过期时间 public static final long SKUKEY_TEMPORARY_TIMEOUT = 10 * 60;
在实现类中引入@Autowired
private RedisTemplate redisTemplate;// 使用redis’ 做分布式锁 private SkuInfo getSkuInfoRedis(Long skuId) {
SkuInfo skuInfo = null;
try {
// 缓存存储数据：key-value
// 定义key sku:skuId:info
_String skuKey = RedisConst.**_SKUKEY_PREFIX+skuId+RedisConst.SKUKEY_SUFFIX;
_// 获取里面的数据？ redis 有五种数据类型 那么我们存储商品详情 使用哪种数据类型？ // 获取缓存数据 _skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
// 如果从缓存中获取的数据是空 if (skuInfo==null){
_// 直接获取数据库中的数据，可能会造成缓存击穿。所以在这个位置，应该添加锁。 // 第一种：redis ，第二种：redisson
// 定义锁的key sku:skuId:lock set k1 v1 px 10000 nx
_String lockKey = RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKULOCK_SUFFIX;
// 定义锁的值 _String uuid = UUID._randomUUID().toString().replace(“-“,“”);
_// 上锁 _Boolean isExist = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
if (isExist){
_// 执行成功的话，则上锁。 _System.out.println(“获取到分布式锁！”);
// 真正获取数据库中的数据 {数据库中到底有没有这个数据 = 防止缓存穿透}
_skuInfo = getSkuInfoDB(skuId);
// 从数据库中获取的数据就是空 _if (skuInfo==null){
_// 为了避免缓存穿透 应该给空的对象放入缓存 _SkuInfo skuInfo1 = new SkuInfo(); //对象的地址 redisTemplate.opsForValue().set(skuKey,skuInfo1,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
return skuInfo1;
}
// 查询数据库的时候，有值 redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);
_// 解锁：使用lua 脚本解锁 _String script = “if redis.call(‘get’, KEYS[1]) == ARGV[1] then return redis.call(‘del’, KEYS[1]) else return 0 end”;
_// 设置lua脚本返回的数据类型 _DefaultRedisScript redisScript = new DefaultRedisScript<>();
_// 设置lua脚本返回类型为Long
_redisScript.setResultType(Long.class);
redisScript.setScriptText(script);
// 删除key 所对应的 value
redisTemplate.execute(redisScript, Arrays.asList(lockKey),uuid);

return skuInfo;
}else {
// 其他线程等待 _Thread._sleep(1000);
return getSkuInfo(skuId);
}
}else {
return skuInfo;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// 为了防止缓存宕机：从数据库中获取数据 return **getSkuInfoDB(skuId);
}
@Override
public SkuInfo getSkuInfoDB(Long skuId) {

SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
if (skuInfo!=null){
QueryWrapper skuImageQueryWrapper = new QueryWrapper<>();
skuImageQueryWrapper.eq(“sku_id”,skuId);
List skuImageList = skuImageMapper.selectList(skuImageQueryWrapper);
skuInfo.setSkuImageList(skuImageList);
}

return skuInfo;
}


3.2 使用redisson

在实现类添加@Autowired
private RedissonClient redissonClient;private SkuInfo getSkuInfoRedisson(Long skuId) {
SkuInfo skuInfo = null;
try {
// 缓存存储数据：key-value
// 定义key sku:skuId:info
_String skuKey = RedisConst.**_SKUKEY_PREFIX+skuId+RedisConst.SKUKEY_SUFFIX;
_// 获取里面的数据？ redis 有五种数据类型 那么我们存储商品详情 使用哪种数据类型？ // 获取缓存数据 _skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
// 如果从缓存中获取的数据是空 if (skuInfo==null){
_// 直接获取数据库中的数据，可能会造成缓存击穿。所以在这个位置，应该添加锁。 // 第二种：redisson
// 定义锁的key sku:skuId:lock set k1 v1 px 10000 nx
_String lockKey = RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKULOCK_SUFFIX;
RLock lock = redissonClient.getLock(lockKey);
/
第一种： lock.lock();
第二种: lock.lock(10,TimeUnit.SECONDS);
第三种： lock.tryLock(100,10,TimeUnit.SECONDS);
/
// 尝试加锁 boolean res = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
if (res){
try {
// 处理业务逻辑 获取数据库中的数据 // 真正获取数据库中的数据 {数据库中到底有没有这个数据 = 防止缓存穿透}
_skuInfo = getSkuInfoDB(skuId);
// 从数据库中获取的数据就是空 _if (skuInfo==null){
_// 为了避免缓存穿透 应该给空的对象放入缓存 _SkuInfo skuInfo1 = new SkuInfo(); //对象的地址 redisTemplate.opsForValue().set(skuKey,skuInfo1,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
return skuInfo1;
}
// 查询数据库的时候，有值 redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);

// 使用redis 用的是lua 脚本删除 ，但是现在用么？ lock.unlock
return skuInfo;

}catch (Exception e){
e.printStackTrace();
}finally {
_// 解锁： _lock.unlock();
}
}else {
// 其他线程等待 _Thread._sleep(1000);
return getSkuInfo(skuId);
}
}else {
return skuInfo;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// 为了防止缓存宕机：从数据库中获取数据 return **getSkuInfoDB(skuId);
}

3.3 在getSkuInfo 中调用上述两个方法进行测试

@Override
public SkuInfo getSkuInfo(Long skuId) {
// 使用框架redisson解决分布式锁！ return getSkuInfoRedisson(skuId);

// return getSkuInfoRedis(skuId);
}

四、分布式锁 + AOP实现缓存

随着业务中缓存及分布式锁的加入，业务代码变的复杂起来，除了需要考虑业务逻辑本身，还要考虑缓存及分布式锁的问题，增加了程序员的工作量及开发难度。而缓存的玩法套路特别类似于事务，而声明式事务就是用了aop的思想实现的。
07 商品详情进阶 - 图24
1. 以 @Transactional 注解为植入点的切点，这样才能知道@Transactional注解标注的方法需要被代理。
2. @Transactional注解的切面逻辑类似于@Around

模拟事务，缓存可以这样实现：

1. 自定义缓存注解@GmallCache（类似于事务@Transactional）
2. 编写切面类，使用环绕通知实现缓存的逻辑封装
07 商品详情进阶 - 图25

4.1 定义一个注解

package com.atguigu.gmall.common.cache;

import java.lang.annotation.;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME) public @interface GmallCache {
_/**
 缓存key的前缀
@return
** **/
_String prefix() default “cache”;
}

4.2 定义一个切面类加上注解

Spring aop 参考文档：
https://docs.spring.io/spring-framework/docs/5.3.9-SNAPSHOT/reference/html/core.html#aop 07 商品详情进阶 - 图26

07 商品详情进阶 - 图27

package com.atguigu.gmall.common.cache;

import com.alibaba.fastjson.JSON;
import com.atguigu.gmall.common.constant.RedisConst;
import lombok.SneakyThrows;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

/
* @author **atguigu__-mqx
处理环绕通知 /
@Component
@Aspect
public class GmallCacheAspect {

@Autowired
private RedisTemplate redisTemplate;

@Autowired
private RedissonClient redissonClient;

// 切GmallCache注解 @SneakyThrows
@Around(“@annotation(com.atguigu.gmall.common.cache.GmallCache)”)
public Object cacheAroundAdvice(ProceedingJoinPoint joinPoint){
// 声明一个对象 _Object object = new Object();
// 在环绕通知中处理业务逻辑 {实现分布式锁}
// 获取到注解，注解使用在方法上！ MethodSignature signature = (MethodSignature) joinPoint.getSignature();
GmallCache gmallCache = signature.getMethod().getAnnotation(GmallCache.class);

// 获取到注解上的前缀 String prefix = gmallCache.prefix(); // sku

// 方法传入的参数 Object[] args = joinPoint.getArgs();

// 组成缓存的key 需要前缀+方法传入的参数 String key = prefix+ Arrays._asList(args).toString();

// 防止redis ，redisson 出现问题！ try {
// 从缓存中获取数据 // 类似于skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
_object = cacheHit(key,signature);
// 判断缓存中的数据是否为空！ if (object==null){
// 从数据库中获取数据，并放入缓存，防止缓存击穿必须上锁 // perfix = sku index1 skuId = 32 , index2 skuId = 33
// public SkuInfo getSkuInfo(Long skuId)
// key+”:lock”
String lockKey = prefix + “:lock”;
// 准备上锁 RLock lock = redissonClient.getLock(lockKey);
boolean result = lock.tryLock(RedisConst.**_SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
// 上锁成功 if (result){
try {
// 表示执行方法体 getSkuInfoDB(skuId);
_object = joinPoint.proceed(joinPoint.getArgs());
// 判断object 是否为空 _if (object==null){
_// 防止缓存穿透 _Object object1 = new Object();
redisTemplate.opsForValue().set(key, JSON.toJSONString(object1),RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
// 返回数据 return object1;
}
// 放入缓存 redisTemplate.opsForValue().set(key, JSON.toJSONString(object),RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);

// 返回数据 return object;
} finally {
lock.unlock();
}
}else{
// 上锁失败,睡眠自旋 _Thread._sleep(1000);
return cacheAroundAdvice(joinPoint);
// 理想状态 // return cacheHit(key, signature);
}
}else {
return object;
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
// 如果出现问题数据库兜底 return joinPoint.proceed(joinPoint.getArgs());
}
_/
表示从缓存中获取数据 @param **_key _缓存的key
* @param _signature _获取方法的返回值类型 * @return
* /
private Object cacheHit(String key, MethodSignature signature) {
// 通过key 来获取缓存的数据 String strJson = (String) redisTemplate.opsForValue().get(key);
// 表示从缓存中获取到了数据 if (!StringUtils._isEmpty(strJson)){
// 字符串存储的数据是什么? 就是方法的返回值类型 _Class returnType = signature.getReturnType();
// 将字符串变为当前的返回值类型 return JSON._parseObject(strJson,returnType);
}
return null;
}
}

4.3 使用注解完成缓存

@GmallCache(prefix = RedisConst.SKUKEY_PREFIX)
@Override
public SkuInfo getSkuInfo(Long skuId) {

return getSkuInfoDB(skuId);
}
@GmallCache(prefix = “saleAttrValuesBySpu:”)
public Map getSaleAttrValuesBySpu(Long spuId) {….}
@GmallCache(prefix = “spuSaleAttrListCheckBySku:”)
public List getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {….}
@Override
@GmallCache(prefix = “SpuPosterList:”)
public List getSpuPosterList(Long spuId) {
// select * from spu_poster where spu_id = spuId;
return spuPosterMapper.selectList(new QueryWrapper().eq(“spu_id”,spuId));
}
@GmallCache(prefix = “categoryViewByCategory3Id:”)
public BaseCategoryView getCategoryViewByCategory3Id(Long category3Id) {….}
@Override
@GmallCache(prefix = “BaseAttrInfoList:”)
public List getBaseAttrInfoList(Long skuId) {
// 根据skuId 获取数据 return baseAttrInfoMapper.selectBaseAttrInfoList(skuId);
}
@Override
public BigDecimal getPrice(Long skuId) {
// select price from sku_info where id = skuId;
// select from sku_info where id = skuId;
// SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
// 不需要将数据放入缓存！ _RLock lock = redissonClient.getLock(skuId + *”:lock”);
// 上锁 lock.lock();
SkuInfo skuInfo = null;
BigDecimal price = new BigDecimal(0);
try {
QueryWrapper skuInfoQueryWrapper = new QueryWrapper<>();
skuInfoQueryWrapper.eq(“id”,skuId);
skuInfoQueryWrapper.select(“price”);
skuInfo = skuInfoMapper.selectOne(skuInfoQueryWrapper);
if (skuInfo!=null){
price = skuInfo.getPrice();
}
} catch (Exception e) {
e.printStackTrace();
}finally {
// 解锁！ lock.unlock();
}
// 返回价格 _return price;
}