第七章：优化和缓存
一、首页整合
1）为product引入thymeleaf和devtools依赖和配置
开发环境关闭缓存，生成环境需要打开
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
spring:
thymeleaf:
cache: false
2）获取分类的信息
@GetMapping({"/","/index.html"})
public String indexPage(Model model){
System.out.println(""+Thread.currentThread().getId());
//TODO 1、查出所有的1级分类
List<CategoryEntity> categoryEntities = categoryService.getLevel1Categorys();
// 视图解析器进行拼串：
// classpath:/templates/ +返回值+ .html
model.addAttribute("categorys",categoryEntities);
return "index";
}
@Override
public List<CategoryEntity> getLevel1Categorys() {
List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>()
.eq("parent_cid", 0));
return categoryEntities;
}3）三级分类实时启动
<!--轮播主体内容-->
<div class="header_main">
<div class="header_banner">
<div class="header_main_left">
<ul>
<li th:each=" category : ${categorys}">
<a href="#" class="header_main_left_a" th:attr="ctg-data=${category.catId}"><b th:text="${category.name}">家用电器</b></a>
</li>
</ul>4）添加Catelog2Vo实体类
//2级分类vo
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Catelog2Vo {
private String catalog1Id; //1级父分类id
private String id;
private String name;
private List<Catelog3Vo> catalog3List; //三级子分类
/**
*
* 三级分类vo
* "catalog2Id":"1",
* "id":"1",
* "name":"电子书"
*/
@NoArgsConstructor
@AllArgsConstructor
@Data
public static class Catelog3Vo{
private String catalog2Id;//父分类，2级分类id
private String id;
private String name;
}
}5）获取三级分类的信息
//index/catalog.json
@ResponseBody
@GetMapping("/index/catalog.json")
public Map<String, List<Catelog2Vo>> getCatalogJson(){
Map<String, List<Catelog2Vo>> catalogJson = categoryService.getCatalogJson();
return catalogJson;
}
@Cacheable(value = "category",key = "#root.methodName")
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
System.out.println("查询了数据库.....");
List<CategoryEntity> selectList = baseMapper.selectList(null);
List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);
//2、封装数据
Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
//1、每一个的一级分类，查到这个一级分类的二级分类
List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());
//2、封装上面面的结果
List<Catelog2Vo> catelog2Vos = null;
if (categoryEntities != null) {
catelog2Vos = categoryEntities.stream().map(l2 -> {
Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
//1、找当前二级分类的三级分类封装成vo
List<CategoryEntity> level3Catelog = getParent_cid(selectList, l2.getCatId());
if (level3Catelog != null) {
List<Catelog2Vo.Catelog3Vo> collect = level3Catelog.stream().map(l3 -> {
//2、封装成指定格式
Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
return catelog3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(collect);
}
return catelog2Vo;
}).collect(Collectors.toList());
}
return catelog2Vos;
}));
return parent_cid;
}二、nginx
//TODO
三、压力测试
1.JMeter配置
配置线程组
配置http请求
配置结果
2.性能监控
方法1)启动jconsole
方法2）启动jvisualvm
安装插件
检查自己java的版本
这里是0_301的版本
去VisualVM: Plugins Centers找到对应的版本的插件地址
复制catalog URL的地址到配置中心
下载Visual GC后重启jvisualvm
观察到垃圾回收机制
四、优化
1.动静分离
将静态资源放到nginx下进行回显
1）将static下的index文件夹都移动到服务器的nginx下
2）修改index.html的配置路径
替换href
替换src
2.优化数据库
为数据库parent_cid加普通索引
3.优化业务
@Cacheable(value = "category",key = "#root.methodName")
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
System.out.println("查询了数据库.....");
List<CategoryEntity> selectList = baseMapper.selectList(null);
List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);
//2、封装数据
Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
//1、每一个的一级分类，查到这个一级分类的二级分类
List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());
//2、封装上面面的结果
List<Catelog2Vo> catelog2Vos = null;
if (categoryEntities != null) {
catelog2Vos = categoryEntities.stream().map(l2 -> {
Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
//1、找当前二级分类的三级分类封装成vo
List<CategoryEntity> level3Catelog = getParent_cid(selectList, l2.getCatId());
if (level3Catelog != null) {
List<Catelog2Vo.Catelog3Vo> collect = level3Catelog.stream().map(l3 -> {
//2、封装成指定格式
Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
return catelog3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(collect);
}
return catelog2Vo;
}).collect(Collectors.toList());
}
return catelog2Vos;
}));
return parent_cid;
}
private List<CategoryEntity> getParent_cid(List<CategoryEntity> selectList, Long parent_cid) {
List<CategoryEntity> collect = selectList.stream().filter(item -> item.getParentCid().equals(parent_cid)).collect(Collectors.toList());
//return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
return collect;
}五、redis
1.引入和配置redis环境
1.为product中引入redis的依赖
<!--引入redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
spring:
redis:
host: 101.43.79.94
port: 63792.使用redistemplate进行测试
@Resource
StringRedisTemplate stringRedisTemplate;
@Test
public void testStringRedisTemplate(){
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
//保存数据
ops.set("hello","world_"+ UUID.randomUUID().toString());
//查询数据
String hello = ops.get("hello");
System.out.println("保存的数据是"+ hello);
}2.修改业务逻辑
1.将原来的业务修改名字为getDataFromDb
private Map<String, List<Catelog2Vo>> getDataFromDb() {
String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
if (!StringUtils.isEmpty(catalogJSON)) {
//缓存不为null直接返回
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
});
return result;
}
System.out.println("查询了数据库.....");
List<CategoryEntity> selectList = baseMapper.selectList(null);
List<CategoryEntity> level1Categorys = getParent_cid(selectList, 0L);
//2、封装数据
Map<String, List<Catelog2Vo>> parent_cid = level1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
//1、每一个的一级分类，查到这个一级分类的二级分类
List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());
//2、封装上面面的结果
List<Catelog2Vo> catelog2Vos = null;
if (categoryEntities != null) {
catelog2Vos = categoryEntities.stream().map(l2 -> {
Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
//1、找当前二级分类的三级分类封装成vo
List<CategoryEntity> level3Catelog = getParent_cid(selectList, l2.getCatId());
if (level3Catelog != null) {
List<Catelog2Vo.Catelog3Vo> collect = level3Catelog.stream().map(l3 -> {
//2、封装成指定格式
Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
return catelog3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(collect);
}
return catelog2Vo;
}).collect(Collectors.toList());
}
return catelog2Vos;
}));
//3、查到的数据再放入缓存，将对象转为json放在缓存中
String s = JSON.toJSONString(parent_cid);
redisTemplate.opsForValue().set("catalogJSON", s, 1, TimeUnit.DAYS);
return parent_cid;
}2.新建一个业务getCatalogJson，使用redis调用getDataFromDb
//TODO 产生堆外内存溢出：OutOfDirectMemoryError
//1）、springboot2.0以后默认使用lettuce作为操作redis的客户端。它使用netty进行网络通信。
//2）、lettuce的bug导致netty堆外内存溢出 -Xmx300m；netty如果没有指定堆外内存，默认使用-Xmx300m
// 可以通过-Dio.netty.maxDirectMemory进行设置
//解决方案：不能使用-Dio.netty.maxDirectMemory只去调大堆外内存。
//1）、升级lettuce客户端。 2）、切换使用jedis
// redisTemplate：
// lettuce、jedis操作redis的底层客户端。Spring再次封装redisTemplate；
// @Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
//给缓存中放json字符串，拿出的json字符串，还用逆转为能用的对象类型；【序列化与反序列化】
/**
* 1、空结果缓存：解决缓存穿透
* 2、设置过期时间（加随机值）：解决缓存雪崩
* 3、加锁：解决缓存击穿
*/
//1、加入缓存逻辑,缓存中存的数据是json字符串。
//JSON跨语言，跨平台兼容。
String catalogJSON = stringRedisTemplate.opsForValue().get("catalogJSON");
if (StringUtils.isEmpty(catalogJSON)) {
//2、缓存中没有,查询数据库
//保证数据库查询完成以后，将数据放在redis中，这是一个原子操作。
System.out.println("缓存不命中....将要查询数据库...");
Map<String, List<Catelog2Vo>> catalogJsonFromDb = getDataFromDb();
return catalogJsonFromDb;
}
System.out.println("缓存命中....直接返回....");
//转为我们指定的对象。
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
});
return result;
}3.修改内存溢出
<!--引入redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>3.本地锁
用synchronized新建一个本地锁
//从数据库查询并封装分类数据
public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithLocalLock() {
// //1、如果缓存中有就用缓存的
// Map<String, List<Catelog2Vo>> catalogJson = (Map<String, List<Catelog2Vo>>) cache.get("catalogJson");
// if(cache.get("catalogJson") == null) {
// //调用业务 xxxxx
// //返回数据又放入缓存
// cache.put("catalogJson",parent_cid);
// }
// return catalogJson;
//只要是同一把锁，就能锁住需要这个锁的所有线程
//1、synchronized (this)：SpringBoot所有的组件在容器中都是单例的。
//TODO 本地锁：synchronized，JUC（Lock），在分布式情况下，想要锁住所有，必须使用分布式锁
synchronized (this) {
//得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
return getDataFromDb();
}
}修改getCatalogJson调用getCatalogJsonFromDbWithLocalLock（本地锁）
//TODO 产生堆外内存溢出：OutOfDirectMemoryError
//1）、springboot2.0以后默认使用lettuce作为操作redis的客户端。它使用netty进行网络通信。
//2）、lettuce的bug导致netty堆外内存溢出 -Xmx300m；netty如果没有指定堆外内存，默认使用-Xmx300m
// 可以通过-Dio.netty.maxDirectMemory进行设置
//解决方案：不能使用-Dio.netty.maxDirectMemory只去调大堆外内存。
//1）、升级lettuce客户端。 2）、切换使用jedis
// redisTemplate：
// lettuce、jedis操作redis的底层客户端。Spring再次封装redisTemplate；
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
//给缓存中放json字符串，拿出的json字符串，还用逆转为能用的对象类型；【序列化与反序列化】
/**
* 1、空结果缓存：解决缓存穿透
* 2、设置过期时间（加随机值）：解决缓存雪崩
* 3、加锁：解决缓存击穿
*/
//1、加入缓存逻辑,缓存中存的数据是json字符串。
//JSON跨语言，跨平台兼容。
String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
if (StringUtils.isEmpty(catalogJSON)) {
//2、缓存中没有,查询数据库
//保证数据库查询完成以后，将数据放在redis中，这是一个原子操作。
System.out.println("缓存不命中....将要查询数据库...");
Map<String, List<Catelog2Vo>> catalogJsonFromDb = getCatalogJsonFromDbWithLocalLock();
return catalogJsonFromDb;
}
System.out.println("缓存命中....直接返回....");
//转为我们指定的对象。
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
});
return result;
}4.分布式锁
新建getCatalogJsonFromDbWithRedisLock
public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock() {
//1、占分布式锁。去redis占坑
String uuid = UUID.randomUUID().toString();
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
if (lock) {
System.out.println("获取分布式锁成功...");
//加锁成功... 执行业务
//2、设置过期时间，必须和加锁是同步的，原子的
//redisTemplate.expire("lock",30,TimeUnit.SECONDS);
Map<String, List<Catelog2Vo>> dataFromDb;
try {
dataFromDb = getDataFromDb();
} finally {
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
//删除锁
Long lock1 = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class)
, Arrays.asList("lock"), uuid);
}
//获取值对比+对比成功删除=原子操作 lua脚本解锁
// String lockValue = redisTemplate.opsForValue().get("lock");
// if(uuid.equals(lockValue)){
// //删除我自己的锁
// redisTemplate.delete("lock");//删除锁
// }
return dataFromDb;
} else {
//加锁失败...重试。synchronized ()
//休眠100ms重试
System.out.println("获取分布式锁失败...等待重试");
try {
Thread.sleep(200);
} catch (Exception e) {
}
return getCatalogJsonFromDbWithRedisLock();//自旋的方式
}
}修改getCatalogJson调用getCatalogJsonFromDbWithRedisLock（分布式锁）
//TODO 产生堆外内存溢出：OutOfDirectMemoryError
//1）、springboot2.0以后默认使用lettuce作为操作redis的客户端。它使用netty进行网络通信。
//2）、lettuce的bug导致netty堆外内存溢出 -Xmx300m；netty如果没有指定堆外内存，默认使用-Xmx300m
// 可以通过-Dio.netty.maxDirectMemory进行设置
//解决方案：不能使用-Dio.netty.maxDirectMemory只去调大堆外内存。
//1）、升级lettuce客户端。 2）、切换使用jedis
// redisTemplate：
// lettuce、jedis操作redis的底层客户端。Spring再次封装redisTemplate；
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson() {
//给缓存中放json字符串，拿出的json字符串，还用逆转为能用的对象类型；【序列化与反序列化】
/**
* 1、空结果缓存：解决缓存穿透
* 2、设置过期时间（加随机值）：解决缓存雪崩
* 3、加锁：解决缓存击穿
*/
//1、加入缓存逻辑,缓存中存的数据是json字符串。
//JSON跨语言，跨平台兼容。
String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
if (StringUtils.isEmpty(catalogJSON)) {
//2、缓存中没有,查询数据库
//保证数据库查询完成以后，将数据放在redis中，这是一个原子操作。
System.out.println("缓存不命中....将要查询数据库...");
Map<String, List<Catelog2Vo>> catalogJsonFromDb = getCatalogJsonFromDbWithRedisLock();
return catalogJsonFromDb;
}
System.out.println("缓存命中....直接返回....");
//转为我们指定的对象。
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catelog2Vo>>>() {
});
return result;
}
5.Ridesson分布式锁
用redisson作为所有分布式锁等功能的框架
1.引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.16.4</version>
</dependency>2.配置方法
https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95@Configuration
public class MyRedissonConfig {
/**
* 所有对redis的操作都通过RedissonClient对象
* @return
* @throws IOException
*/
@Bean(destroyMethod="shutdown")
public RedissonClient redisson() throws IOException {
//1.创建配置
Config config = new Config();
config.useSingleServer()
.setAddress("redis://101.43.79.94:6379");
//2.创建实例
return Redisson.create(config);
}
}
3.测试方法
1)测试加锁
@ResponseBody
@GetMapping("/hello")
public String hello(){
//1、获取一把锁，只要锁的名字一样，就是同一把锁
RLock lock = redisson.getLock("my-lock");
//2、加锁
lock.lock(); //阻塞式等待。默认加的锁都是30s时间。
//1）、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s。不用担心业务时间长，锁自动过期被删掉
//2）、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s以后自动删除。
// lock.lock(10,TimeUnit.SECONDS); //10秒自动解锁,自动解锁时间一定要大于业务的执行时间。
//问题：lock.lock(10,TimeUnit.SECONDS); 在锁时间到了以后，不会自动续期。
//1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是我们指定的时间
//2、如果我们未指定锁的超时时间，就使用30 * 1000【LockWatchdogTimeout看门狗的默认时间】;
// 只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10s都会自动再次续期，续成30s
// internalLockLeaseTime【看门狗时间】 / 3,10s
//最佳实战
//1）、lock.lock(30,TimeUnit.SECONDS);省掉了整个续期操作。手动解锁
try{
System.out.println("加锁成功，执行业务..."+Thread.currentThread().getId());
Thread.sleep(30000);
}catch (Exception e){
}finally {
//3、解锁 将设解锁代码没有运行，redisson会不会出现死锁
System.out.println("释放锁..."+Thread.currentThread().getId());
lock.unlock();
}
return "hello";
}2）测试读写锁
//保证一定能读到最新数据,修改期间，写锁是一个排他锁（互斥锁、独享锁）。读锁是一个共享锁
//写锁没释放读就必须等待
// 读 + 读： 相当于无锁，并发读，只会在redis中记录好，所有当前的读锁。他们都会同时加锁成功
// 写 + 读： 等待写锁释放
// 写 + 写： 阻塞方式
// 读 + 写： 有读锁。写也需要等待。
// 只要有写的存在，都必须等待
@GetMapping("/write")
@ResponseBody
public String writeValue(){
RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
String s = "";
RLock rLock = lock.writeLock();
try {
//1、改数据加写锁，读数据加读锁
rLock.lock();
System.out.println("写锁加锁成功..."+Thread.currentThread().getId());
s = UUID.randomUUID().toString();
Thread.sleep(30000);
redisTemplate.opsForValue().set("writeValue",s);
} catch (Exception e) {
e.printStackTrace();
} finally {
rLock.unlock();
System.out.println("写锁释放"+Thread.currentThread().getId());
}
return s;
}
@GetMapping("/read")
@ResponseBody
public String readValue(){
RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
// ReentrantReadWriteLock writeLock = new ReentrantReadWriteLock();
String s = "";
//加读锁
RLock rLock = lock.readLock();
rLock.lock();
try {
System.out.println("读锁加锁成功"+Thread.currentThread().getId());
s = redisTemplate.opsForValue().get("writeValue");
Thread.sleep(30000);
} catch (Exception e) {
e.printStackTrace();
} finally {
rLock.unlock();
System.out.println("读锁释放"+Thread.currentThread().getId());
}
return s;
}
3）信号量
/**
* 车库停车，
* 3车位
* 信号量也可以用作分布式限流；
*/
@GetMapping("/park")
@ResponseBody
public String park() throws InterruptedException {
RSemaphore park = redisson.getSemaphore("park");
// park.acquire();//获取一个信号，获取一个值,占一个车位
boolean b = park.tryAcquire();
if(b){
//执行业务
}else {
return "error";
}
return "ok=>"+b;
}
@GetMapping("/go")
@ResponseBody
public String go() throws InterruptedException {
RSemaphore park = redisson.getSemaphore("park");
park.release();//释放一个车位
//
// Semaphore semaphore = new Semaphore(5);
// semaphore.release();
//
// semaphore.acquire();
return "ok";
}
4)闭锁
/**
* 放假，锁门
* 1班没人了，2
* 5个班全部走完，我们可以锁大门
*/
@GetMapping("/lockDoor")
@ResponseBody
public String lockDoor() throws InterruptedException {
RCountDownLatch door = redisson.getCountDownLatch("door");
door.trySetCount(5);
door.await(); //等待闭锁都完成
return "放假了...";
}
@GetMapping("/gogogo/{id}")
public String gogogo(@PathVariable("id") Long id){
RCountDownLatch door = redisson.getCountDownLatch("door");
door.countDown();//计数减一；
// CountDownLatch
return id+"班的人都走了...";
}4.redisson整合
@Autowired
RedissonClient redisson;
/**
* 缓存里面的数据如何和数据库保持一致
* 缓存数据一致性
* 1）、双写模式
* 2）、失效模式
* @return
*/
public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedissonLock() {
//1、锁的名字。 锁的粒度，越细越快。
//锁的粒度：具体缓存的是某个数据，11-号商品； product-11-lock product-12-lock product-lock
RLock lock = redisson.getLock("CatalogJson-lock");
lock.lock();
Map<String, List<Catelog2Vo>> dataFromDb;
try {
dataFromDb = getDataFromDb();
} finally {
lock.unlock();
}
return dataFromDb;
}
6.SpringCache整合缓存开发
1.引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>2.配置缓存
spring.cache.type=redis3.测试使用缓存
1）、开启缓存功能
@EnableCaching2）、使用注解完成缓存功能
@Cacheable(value = {"category"},key = "#root.method.name",sync = true)3）、自定义缓存配置
将EnableCaching剪切到配置类上
@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class MyCacheConfig {
// @Autowired
// CacheProperties cacheProperties;
/**
* 配置文件中的东西没有用上；
*
* 1、原来和配置文件绑定的配置类是这样子的
* @ConfigurationProperties(prefix = "spring.cache")
* public class CacheProperties
*
* 2、要让他生效
* @EnableConfigurationProperties(CacheProperties.class)
*
* @return
*/
@Bean
RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
// config = config.entryTtl();
config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
CacheProperties.Redis redisProperties = cacheProperties.getRedis();
//将配置文件中的所有配置都生效
if (redisProperties.getTimeToLive() != null) {
config = config.entryTtl(redisProperties.getTimeToLive());
}
if (redisProperties.getKeyPrefix() != null) {
config = config.prefixKeysWith(redisProperties.getKeyPrefix());
}
if (!redisProperties.isCacheNullValues()) {
config = config.disableCachingNullValues();
}
if (!redisProperties.isUseKeyPrefix()) {
config = config.disableKeyPrefix();
}
return config;
}
}
修改Cache配置
spring.cache.type=redis
spring.cache.redis.time-to-live=3600000
spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=false
#空缓存，防缓存穿透
spring.cache.redis.cache-null-values=true版权声明：本文为qq_46396128原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。