redis在Springboot的使用场景
1.作为缓存
1.为什么使用缓存？
减少数据库的访问频率。 提高数据的访问率。
2.什么样的数据适合放入缓存？
1.热点数据。 2. 修改频率比较低。3.安全系数低的。
使用缓存的步骤：
1.搭建一个springboot+mybatisplus工程
2.导入相关依赖（redis）
3.配置redis
4.编写核心业务代码service：
package com.zb.service;
import com.zb.dao.DeptDao;
import com.zb.entity.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @Author 周波
* @Date 2021/4/25 20:07
* @Version 1.0
*/
@Service
public class DeptService {
@Resource
private DeptDao deptDao;
@Autowired
private RedisTemplate redisTemplate;
public Dept findById(Integer deptId){
//1.从缓存中查询该数据
Object o = redisTemplate.opsForValue().get("findById::" + deptId);
if(o!=null){//表示从缓存中获取该数据
return (Dept) o;
}
Dept dept = deptDao.selectById(deptId);
redisTemplate.opsForValue().set("findById::"+deptId,dept);//把查询的结果放入缓存
return dept;
}
//数据库和缓存同步问题！
public int delete(Integer deptId){
redisTemplate.delete("findById::"+deptId);//删除缓存
int i = deptDao.deleteById(deptId);
return i;
}
public int update(Dept dept){
redisTemplate.delete("findById::"+dept.getDeptId());//删除缓存
int i = deptDao.updateById(dept);
redisTemplate.opsForValue().set("findById::"+dept.getDeptId(),dept);
return i;
}
}
上面的代码我们可以看出，缓存需要自己手动进行删除或者查询以及很多非业务代码在service层，这样不满足业务层的规范，所以我们可以进行改动：
1.使用AOP解决（基于jdk动态代理）
Jdk为RealSubject对象创建动态代理对象，主要做了以下工作：
1） 获取RealSubject上的所有接口列表。
2） 确定要生成的动态代理类的类名，默认为com.sun.proxy.$ProxyXXX
3） 根据需要实现接口信息，在代码中动态创建该Proxy的字节码
4） 将对应的字节码转换为对应的class对象
5） 创建InvocationHandler实例，用来处理Proxy所有方法调用
6） Proxy的class对象以创建的handler对象为参，实例化Proxy对象
Jdk通过java.lang.reflect.Proxy来支持动态代理，一般情况下，使用方法newProxyInstanceof来创建Proxy类，而对于InvocationHandler，需要实现它的invoke方法，在调用代理对象中的每一个方法时，在代码内部，都是直接调用了InvocationHandler的invoke方法，而invoke方法根据代理类传递给自己的method参数来区分是什么方法。
2.基于spring的缓存注解
springboot启动类上：
package com.zb;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@MapperScan(basePackages = "com.zb.dao")
@EnableCaching //开启缓存的注解
public class SpringbootRedis02Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootRedis02Application.class, args);
}
}
service的代码：
package com.zb.service;
import com.zb.dao.DeptDao;
import com.zb.entity.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @Author 周波
* @Date 2021/4/25 20:20
* @Version 1.0
*/
@Service
public class DeptService {
@Resource
private DeptDao deptDao;
//该注解作用:会先查询缓存，如果缓存存在，则不会执行代码块。 如果缓存中不存在则执行该方法，并把该方法的返回值存放到redis中
@Cacheable(cacheNames = "findById",key = "#deptId") //缓存的key值 为findById
public Dept findById(Integer deptId){
System.out.println("========");
Dept dept = deptDao.selectById(deptId);
return dept;
}
//数据库和缓存同步问题！
// beforeInvocation：是否在方法执行前就清空，缺省为 false，
// 如果指定为 true，则在方法还没有执行的时候就清空缓存。缺省情况下，如果方法执行抛出异常，则不会清空缓存。
@CacheEvict(cacheNames = "findById",key = "#deptId")
public int delete(Integer deptId){
int i = deptDao.deleteById(deptId);
return i;
}
//这个注解是必须执行方法体，而且会把方法体执行的结果放入到缓存中。 如果发生异常则不操作缓存。
@CachePut(cacheNames = "findById",key = "#dept.deptId")
public Dept update(Dept dept){
int i = deptDao.updateById(dept);
return dept;
}
}
2.分布式锁
分布式锁使用场景：
package com.zb.distributedlock.service;
import com.zb.distributedlock.dao.StockDao;
import com.zb.distributedlock.entity.Stock;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @Author 周波
* @Date 2021/4/26 10:30
*/
@Service
public class StockService02 {
@Resource
private StockDao stockDao;
public String decrStock(Integer productId) {//synchronized () 同步方法 同步代码块
//查询对应的id的库存
synchronized (this) {
Stock stock = stockDao.selectById(productId);
if (stock.getNum() > 0) {
//根据id修改库存
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock);
System.out.println("库存剩余:" + (stock.getNum()));
return "库存减少成功";
} else {
return "库存不足";
}
}
}
}
以上这种锁并不适合分布式项目
于是，使用redis解决分布式锁的问题
修改业务代码：
package com.zb.distributedlock.service;
import com.zb.distributedlock.dao.StockDao;
import com.zb.distributedlock.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
/**
* @Author 周波
* @Date 2021/4/26 10:30
*/
@Service
public class StockService {
@Resource
private StockDao stockDao;
@Autowired
private StringRedisTemplate redisTemplate;
public String decrStock(Integer productId) {//synchronized () 同步方法 同步代码块
Boolean flag = redisTemplate.opsForValue().setIfAbsent("product::" + productId, "curry",30, TimeUnit.SECONDS);
//查询对应的id的库存
if(flag) {//获取锁了
try {
Stock stock = stockDao.selectById(productId);
if (stock.getNum() > 0) {
//根据id修改库存
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock); //异常发生
// int c=10/0;
System.out.println("库存剩余:" + (stock.getNum()));
return "库存减少成功";
} else {
return "库存不足";
}
}catch (Exception e){
throw new RuntimeException(e.getMessage());
}
finally {
redisTemplate.delete("product::" + productId);//释放锁资源 一定再finally
}
}else{
System.out.println("服务器正忙");
return "服务器正忙";
}
}
}
解决分布式锁问题，需要导入Redisson依赖：
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.13.4</version>
</dependency>
配置redisconfig 配置文件
@Configuration
public class RedisConfig {
@Bean
public RedissonClient redissonClient(){
Config config = new Config();
config.useSingleServer().setAddress("redis://192.168.31.24:6379");
config.useSingleServer().setPassword("xxxxxx");
RedissonClient redissonClient = Redisson.create(config);
return redissonClient;
}
}
package com.zb.distributedlock.service;
import com.zb.distributedlock.dao.StockDao;
import com.zb.distributedlock.entity.Stock;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
@Service
public class StockService {
@Resource
private StockDao stockDao;
@Autowired
private RedissonClient redisson;
public String decrStock(Integer productId) {//synchronized () 同步方法 同步代码块
RLock lock = redisson.getLock("product::" + productId);//获取锁对象
try {
lock.tryLock(60,20,TimeUnit.SECONDS); //自己别设置时间。
Stock stock = stockDao.selectById(productId);
if (stock.getNum() > 0) {
//根据id修改库存
stock.setNum(stock.getNum() - 1);
stockDao.updateById(stock); //异常发生
// int c=10/0;
// Thread.sleep(35000);
System.out.println("库存剩余:" + (stock.getNum()));
return "库存减少成功";
} else {
return "库存不足";
}
}catch (Exception e){
throw new RuntimeException(e.getMessage());
}
finally {
lock.unlock();
}
}
}
3.点赞量、排行榜、转发量的应用
什么是计数器，如电商网站商品的浏览量、视频网站视频的播放数等。为了保证数据实时效，每次浏览都得给+1，并发量高时如果每次都请求数据库操作无疑是种挑战和压力。Redis提供的incr命令来实现计数器功能，内存操作，性能非常好，非常适用于这些计数场景 。
关系型数据库在排行榜方面查询速度普遍偏慢，所以可以借助redis的SortedSet进行热点数据的排序。 在奶茶活动中，我们需要展示各个部门的点赞排行榜， 所以我针对每个部门做了一个SortedSet,然后以用户的openid作为上面的username,以用户的点赞数作为上面的score, 然后针对每个用户做一个hash, 通过zrangebyscore就可以按照点赞数获取排行榜，然后再根据username获取用户的hash信息，这个当时在实际运用中性能体验也蛮不错的。
4.限时业务的运用
redis中可以使用expire命令设置一个键的生存时间，到时间后redis会删除它。利用这一特性可以运用在限时的优惠活动信息、手机验证码等业务场景。
2726
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
