缓存:cache
public Result queryById(Long id) {//根据id在redis中查询数据String s = redisTemplate.opsForValue().get(CACHE_SHOP_KEY +id);//判断是否存在if (!StrUtil.isBlank(s)) {//将字符串转为bean//存在,直接返回Shop shop = JSONUtil.toBean(s, Shop.class);return Result.ok(shop);}//不存在,查询数据库Shop shop = getById(id);if (shop==null){//不存在,返回404return Result.fail("店铺不存在");}//数据库中是否存在,存在则写入缓存,并返回redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop));return Result.ok(shop);}
JSONUtil.toBean(s, Shop.class);
JSONUtil.toJsonStr(shop);
缓存更新策略:
先删除数据库后删除缓存的线程安全可能性低。
缓存穿透:
1.查询店铺在数据库和redis中都不存在时,写入空值到redis中
2.查询数据为空值时,直接返回不要查询数据库。
public Result queryById(Long id) {//根据id在redis中查询数据String s = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY +id);//判断是否存在if (!StrUtil.isBlank(s)) {//将字符串转为bean//存在,直接返回Shop shop = JSONUtil.toBean(s, Shop.class);return Result.ok(shop);}//判断是否店铺是否存在,缓存中的空数据 if (s!=null){//返回空值return Result.fail("店铺信息不存在");}//不存在,查询数据库Shop shop = getById(id);if (shop==null){//不存在,返回404//缓存空值到数据库中stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,"",CACHE_NULL_TTL, TimeUnit.MINUTES);return Result.fail("店铺不存在");}//数据库中是否存在,存在则写入缓存,并返回stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);return Result.ok(shop); } |
互斥锁解决缓存击穿:
使用redis中的setnx实现互斥锁,如果key不存在则创建,存在则无法创建。
//使用redis中的setnx实现互斥锁。private boolean tryLock(String key){Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);//潜在的NullReferenceException,如果装箱的对象是null,那么在拆箱时可能会抛出NullReferenceExceptionreturn BooleanUtil.isTrue(flag);}private void unLock(String key){stringRedisTemplate.delete(key);}
拆箱和装箱操作可能会产生的问题:
1.性能开销:装箱和拆箱涉及内存分配和复制,这会增加额外的性能开销。
2.类型安全丢失:装箱操作会将值类型包装在一个对象中,这样原本在栈上的值类型数据现在位于堆中,可能导致类型安全检查丢失。
3.垃圾回收压力:装箱操作会创建新的对象实例,这可能增加垃圾回收器的压力,尤其是在频繁进行装箱和拆箱操作的情况下。
4.潜在的NullReferenceException,如果装箱的对象是null,那么在拆箱时可能会抛出NullReferenceException异常。
/*** 互斥锁解决缓存击穿* @param id* @return*/private Shop queryWithMutex(Long id){//根据id在redis中查询数据String s = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY +id);//判断是否存在if (!StrUtil.isBlank(s)) {//将字符串转为bean//存在,直接返回Shop shop = JSONUtil.toBean(s, Shop.class);return shop;}//判断是否店铺是否存在if (s!=null){//返回空值return null;}//缓存重建//尝试获取互斥锁String lockKey= LOCK_SHOP_KEY+id;Shop shop = null;try {boolean isLock = tryLock(lockKey);//判断是否获取锁成功if (!isLock){//获取锁失败,休眠一会重试Thread.sleep(10);return queryWithMutex(id);}//获取锁成功,再次查询缓存中是否存在数据,如果存在,则不需要缓存重建s = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY +id);//判断是否存在if (!StrUtil.isBlank(s)) {//将字符串转为bean//存在,直接返回shop = JSONUtil.toBean(s, Shop.class);unLock(lockKey);return shop;}//判断是否店铺是否存在if (s!=null){//返回空值return null;}//缓存中还是没有数据,查询数据库//不存在,查询数据库shop = getById(id);if (shop==null){//不存在,返回404//缓存空值到数据库中stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,"",CACHE_NULL_TTL, TimeUnit.MINUTES);return null;}//数据库中是否存在,存在则写入缓存,并返回stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);} catch (InterruptedException e) {throw new RuntimeException(e);} finally {//释放锁unLock(lockKey);}return shop;}
逻辑过期解决缓存击穿:
创建一个redisData类,维护不同对象的过期时间:
@Data public class RedisData {private LocalDateTime expireTime;private Object data; }
/*** 缓存预热将店铺数据存入redis中并且设置逻辑过期时间**/private void save2Redis(Long id,Long expireSeconds){//查询店铺信息Shop shop = getById(id);//封装RedisDataRedisData redisData=new RedisData();redisData.setData(shop);redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));//保存数据到redis中stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));}
private Shop queryWithLogicExpire(Long id){//根据id在redis中查询数据String s = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY +id);//判断是否存在if (StrUtil.isBlank(s)) {//缓存未命中不存在,直接返回nullreturn null;}//缓存命中,判断缓存是否过期RedisData redisData = JSONUtil.toBean(s, RedisData.class);JSONObject data = (JSONObject) redisData.getData();Shop shop = JSONUtil.toBean(data, Shop.class);LocalDateTime expireTime = redisData.getExpireTime();if (expireTime.isAfter(LocalDateTime.now())){//未过期return shop;}//过期,尝试获取互斥锁String lockKey= LOCK_SHOP_KEY+id;boolean isLock = tryLock(lockKey);if (isLock){//TODO 获取互斥锁成功,重新查询缓存是否过期,如果未过期,不用再缓存重建,如果过期,则重建缓存CACHE_REBUILD_EXECUTOR.submit(()->{try {save2Redis(id,20L);} catch (Exception e) {e.printStackTrace();} finally {unLock(lockKey);}});}//获取互斥锁失败,返回过期店铺信息return shop;}
封装Redis缓存工具类,包含四个方法:
@Component
@Slf4j
public class CacheClient {private final StringRedisTemplate stringRedisTemplate;
// 基于构造函数注入,不太使用,不太理解public CacheClient(StringRedisTemplate stringRedisTemplate) {this.stringRedisTemplate = stringRedisTemplate;}
//缓存数据到redis中,并设置过期时间public void set(String key, Object value, Long time, TimeUnit unit){stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);}
//缓存数据到redis中,设置逻辑过期时间public void setLogicExpire(String key, Object value, Long time, TimeUnit unit){//设置逻辑过期RedisData redisData=new RedisData();redisData.setData(value);redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));//写入redis中stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData),time,unit);}
//缓存穿透解决方案,public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit){String key=keyPrefix+id;//根据id在redis中查询数据String json = stringRedisTemplate.opsForValue().get(key);//判断是否存在if (!StrUtil.isBlank(json)) {//将字符串转为bean//存在,直接返回R r= JSONUtil.toBean(json, type);return r;}//判断是否店铺是否存在if (json!=null){//返回空值return null;}//不存在,查询数据库R r = dbFallback.apply(id);if (r==null){//不存在,返回404//缓存空值到数据库中stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);return null;}//数据库中是否存在,存在则写入缓存,并返回this.set(key,r,time,unit);return r;}
//缓存击穿解决方案:逻辑过期private static final ExecutorService CACHE_REBUILD_EXECUTOR= Executors.newFixedThreadPool(10);/*** 使用逻辑过期解决缓存击穿* @param id* @return*/public <R,ID> R queryWithLogicExpire(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit){//根据id在redis中查询数据String key=keyPrefix+id;String json = stringRedisTemplate.opsForValue().get(key);//判断是否存在if (StrUtil.isBlank(json)) {//缓存未命中不存在,直接返回nullreturn null;}//缓存命中,判断缓存是否过期RedisData redisData = JSONUtil.toBean(json, RedisData.class);JSONObject data = (JSONObject) redisData.getData();R r=JSONUtil.toBean(data, type);LocalDateTime expireTime = redisData.getExpireTime();if (expireTime.isAfter(LocalDateTime.now())){//未过期return r;}//过期,尝试获取互斥锁String lockKey= LOCK_SHOP_KEY+id;boolean isLock = tryLock(lockKey);if (isLock){//TODO 获取互斥锁成功,重新查询缓存是否过期,如果未过期,不用再缓存重建,如果过期,则重建缓存CACHE_REBUILD_EXECUTOR.submit(()->{try {//重建缓存//查询数据库R r1= dbFallback.apply(id);//缓存数据this.setLogicExpire(key,r1,time,unit);} catch (Exception e) {e.printStackTrace();} finally {unLock(lockKey);}});}//获取互斥锁失败,返回过期店铺信息return r;}//使用redis中的setnx实现互斥锁。private boolean tryLock(String key){Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);//潜在的NullReferenceException,如果装箱的对象是null,那么在拆箱时可能会抛出NullReferenceExceptionreturn BooleanUtil.isTrue(flag);}private void unLock(String key){stringRedisTemplate.delete(key);}
}
总结:
Spring中bean的注入方式:
在Spring框架中,注入Bean(对象)的方式有多种,以下是一些常见的方法:
1. 构造器注入(Constructor Injection):
通过构造器注入依赖,可以确保在创建对象时,它所依赖的其他对象也被创建。
```
public class ExampleBean {
private final AnotherBean anotherBean;
@Autowired
public ExampleBean(AnotherBean anotherBean) {
this.anotherBean = anotherBean;
}
}
```
2. Setter方法注入(Setter Injection):
通过setter方法注入依赖,可以在对象创建后,再设置依赖的对象。
```java
public class ExampleBean {
private AnotherBean anotherBean;
@Autowired
public void setAnotherBean(AnotherBean anotherBean) {
this.anotherBean = anotherBean;
}
}
```
3. 字段注入(Field Injection):
通过字段注入依赖,直接在字段上使用`@Autowired`注解。
```java
public class ExampleBean {
@Autowired
private AnotherBean anotherBean;
}
```
4. 方法参数注入(Method Parameter Injection):
在方法参数上使用`@Autowired`注解,Spring会注入对应的依赖。
```java
public class ExampleBean {
public void doSomething(@Autowired AnotherBean anotherBean) {
// ...
}
}
```
5. 接口注入(Interface Injection):
通过定义一个接口来标记需要注入的Bean。
```java
public interface InjectedInterface {
void injectDependency(AnotherBean anotherBean);
}
public class ExampleBean implements InjectedInterface {
private AnotherBean anotherBean;
@Override
public void injectDependency(AnotherBean anotherBean) {
this.anotherBean = anotherBean;
}
}
```
6. 基于注解的注入(Annotation-based Injection):
使用`@Autowired`、`@Resource`、`@Inject`等注解来标记需要注入的依赖。
```java
public class ExampleBean {
@Autowired
private AnotherBean anotherBean;
}
```
7. 自动装配(Autowiring):
Spring可以自动装配依赖,无需显式注入。
```java
public class ExampleBean {
@Autowired
private AnotherBean anotherBean;
}
```
8. 基于Java配置的注入:
使用`@Configuration`和`@Bean`注解来定义和注入Bean。
```java
@Configuration
public class AppConfig {
@Bean
public ExampleBean exampleBean() {
return new ExampleBean(anotherBean());
}
@Bean
public AnotherBean anotherBean() {
return new AnotherBean();
}
}
```
选择哪种注入方式取决于你的具体需求和设计偏好。构造器注入和setter注入是最常用的方式,因为它们可以保证依赖的完整性和初始化的一致性。而字段注入和基于注解的注