基于Redis的项目业务分析及实践
分布式id
业务描述
在分布式系统中，数据量将越来越大时，就需要对数据进行分表操作,但是,分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID，生成出来的ID也可以叫做 分布式ID，这里我们借助redis实现一个简易的分布式id进行实现,当然还有一些第三方的系统,可以帮你生成这样的id,可以自己进行拓展学习.
关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
/**
* 需求:生成一个分布递增的id
* 多张表基于这个方法中生成的id作为主键id值(分布式环境不会采用数据库
* 表中自带的自增策略-auto_increment)
*/
public class IdGeneratorDemo01 {
public static Long getId(){
Jedis jedis=new Jedis("192.168.126.130",6379);
//jedis.auth("123456");//假如redis设置了密码,连接redis时需要指定密码
Long id = jedis.incr("id");
jedis.close();
return id;
}
//自己创建线程执行任务
static void execute01(){
for(int i=0;i<10;i++) {
new Thread(){
@Override
public void run() {
String tName=Thread.currentThread().getName();
System.out.println(tName+"->"+
IdGeneratorDemo01.getId());
}
}.start();
}
}
//基于线程池执行任务
static void execute02(){
//构建一个最多只有3个线程的线程池
ExecutorService es=
Executors.newFixedThreadPool(3);
for(int i=1;i<=10;i++){
//从池中取线程执行任务
es.execute(new Runnable() {//这个任务会存储到阻塞式任务队列中
@Override
public void run() {
System.out.println(Thread.currentThread().getName()
+"->"+getId());
}
});
}
}
public static void main(String[] args) {
//execute01();
execute02();
}
}
单点登陆(SSO)
业务描述
在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助redis存储用户的认证信息,例如:
关键代码实现
package com.jt.redis;
import redis.clients.jedis.Jedis;
import java.util.UUID;
/**
* 基于redis的单点登录设计及实现
* 1)用户登录成功以后将登录状态等信息存储到redis
* 2)用户携带token去访问资源,资源服务器要基于token从redis查询用户信息
*/
public class SSODemo01 {
/**
* 执行登录认证,将来这样的业务要写到认证服务器
* @param username
* @param password
*/
static String doLogin(String username,String password){
//1.检验数据的合法性(判定用户名,密码是否为空,密码的长度,是否有数字字母特殊符号构成)
if(username==null||"".equals(username))
throw new IllegalArgumentException("用户不能为空");
//2.基于用户名查询用户信息,并判定密码是否正确
if(!"jack".equals(username))
throw new RuntimeException("此用户不存在");
if(!"123456".equals(password))
throw new RuntimeException("密码不正确");
//3.用户存在且密码正确,将用户信息写入到redis
Jedis jedis=new Jedis("192.168.126.128", 6379);
String token= UUID.randomUUID().toString();
jedis.hset(token, "username", username);
jedis.hset(token, "permission", "sys:resource:create");
jedis.expire(token, 10);//设置key的有效时间
jedis.close();
//4.将token返回给客户端(将来使用response对象响应到客户端).
return token;
}
static String token;
/**
* 演示资源访问过程
* 1)允许匿名访问(无需登录)
* 2)登录后访问(认证通过了)
* 3)登录后必须有权限才可以访问
*/
static Object doGetResource(String token){
//1.校验token是否为空
if(token==null)
throw new IllegalArgumentException("请先登录");
//2.基于token查询redis数据,假如有对应数据说明用户登录了
Jedis jedis=new Jedis("192.168.126.128", 6379);
String username=jedis.hget(token, "username");
if(username==null)
throw new RuntimeException("登录超时,请重新登录");
String permission=jedis.hget(token, "permission");
jedis.close();
//3.检查用户是否有访问资源的权限,假如有则允许访问
if(!"sys:resource:create".equals(permission))
throw new RuntimeException("你没有权限访问这个资源");
//4.返回要访问的资源.
return "your resource";
}
public static void main(String[] args) {
//1.登录操作(用户身份认证)
token=doLogin("jack", "123456");
System.out.println(token);
//2.携带token访问资源服务器
Object result=doGetResource(token);
System.out.println(result);
}
}
简易秒杀队列
业务描述
在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列,例如:
关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
//秒杀队列演示
//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),
//因为写redis内存数据库要比写你的mysql数据库快很多倍
//算法:先进先出(FIFO)-体现公平性
public class SecondKillDemo01 {
//商品抢购首先是入队
static void enque(String msg){//入队
Jedis jedis=new Jedis("192.168.126.130",6379);
jedis.auth("123456");//没有认证不需要写这个语句
jedis.lpush("queue",msg);
jedis.close();
}
//底层异步出队(基于这个消息,生成订单,扣减库存,...)
static String deque(){//出队
Jedis jedis=new Jedis("192.168.126.130",6379);
jedis.auth("123456");//没有认证不需要写这个语句
String result=jedis.rpop("queue");
jedis.close();
return result;
}
public static void main(String[] args){
//1.多次抢购(模拟在界面上多次点击操作)
new Thread(){
@Override
public void run() {
for(int i=1;i<=10;i++){//模拟页面上按钮点击
enque(String.valueOf(i));
try{Thread.sleep(100);}catch(Exception e){}
}
}
}.start();
//2.从队列取内容(模拟后台从队列取数据)
new Thread(){
@Override
public void run() {
for(;;){
String msg=deque();
if(msg==null)continue;
System.out.print(msg);
}
}
}.start();
}
}
简易投票系统
业务描述
在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统,例如:
关键代码实现
package com.jt.redis;
import redis.clients.jedis.Jedis;
import java.util.Set;
/**
* 基于某个活动的简易投票系统设计
* 1)投票数据存储到redis (key为活动id,多个用户id的集合)
* 2)同一个用户不能执行多次投票
* 3)具体业务操作(投票,获取总票数,获取哪些人参与了投票)
*/
public class VoteDemo01 {
/**
* 获取哪些人执行了这个活动的投票
* @param activityId
* @return
*/
static Set<String> doGetMembers(String activityId){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.128", 6379);
//2.获取当前活动的总票数
Set<String> smembers = jedis.smembers(activityId);
//3.释放资源
jedis.close();
return smembers;
}
/**
* 获取指定活动的投票总数
* @param activityId
* @return
*/
static Long doCount(String activityId){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.128", 6379);
//2.获取当前活动的总票数
Long count=jedis.scard(activityId);
//3.释放资源
jedis.close();
return count;
}
/**
* 执行投票操作
* @param activityId
* @param userId
*/
static void doVote(String activityId,String userId){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.128", 6379);
//2.执行投票
//2.1检查是否投过票
Boolean flag = jedis.sismember(activityId, userId);
//2.2执行投票或取消投票
if(flag){
//假如已经投过票,再投票就取消投票
jedis.srem(activityId, userId);
}else{
//没有投过票则执行投票
jedis.sadd(activityId, userId);
}
//3.释放资源
jedis.close();
}
public static void main(String[] args) {
String activityId="101";
String userId1="1";
String userId2="2";
String userId3="3";
//执行投票动作
doVote(activityId, userId1);
doVote(activityId, userId2);
doVote(activityId, userId3);
//获取投票的总票数
Long aLong = doCount(activityId);
System.out.println(aLong);
//获取参与投票的成员
Set<String> members= doGetMembers(activityId);
System.out.println(members);
}
}
简易购物车系统
业务描述
简易购物车业务设计如图所示:
基础指令操作,例如:
1)向购物车添加商品
hset cart:101 2001 1
hset cart:101 2002 1
hset cart:101 2003 2
2)查看购物车商品
hgetall cart:101
3)删除购物车商品
hdel cart:101 2003
4)改变购物车某个商品的购买数量
hincrby cart:101 2002 2
关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.Map;
/**
* 作业:基于redis存储商品购物车信息
*/
public class CartDemo01 {
public static void addCart(Long userId,Long productId,int num){
//1.建立redis链接
Jedis jedis=new Jedis("192.168.126.130",6379);
jedis.auth("123456");
//2.向购物车添加商品
//hincrBy这个函数在key不存在时会自动创建key
jedis.hincrBy("cart:" + userId, String.valueOf(productId),num);
//3.释放redis链接
jedis.close();
}
//查看我的购物车
public static Map<String, String> listCart(Long userId){
//1.建立redis链接
Jedis jedis=new Jedis("192.168.126.130",6379);
jedis.auth("123456");
//2.查看购物车商品
Map<String, String> map = jedis.hgetAll("cart:" + userId);
//3.释放redis链接
jedis.close();
return map;
}
public static void main(String[] args) {
//1.向购物车添加商品
addCart(101L,201L,1);
addCart(101L,202L,1);
addCart(101L,203L,2);
//2.查看购物车商品
Map<String, String> map = listCart(101L);
System.out.println(map);
}
}
SpringBoot工程中Redis与Aop技术的整合
业务描述
基于AOP与Redis技术实现mysql,redis数据库中数据操作.
项目准备工作
第一步:打开redis-template工程,添加访问MySql数据库的依赖(两个)
<!--mysql依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--mybatis plus (简化mybatis操作)-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.2</version>
</dependency>
第二步:修改sca-template工程的配置文件,添加连接mysql数据库的配置
spring:
datasource:
url: jdbc:mysql:///jt-sso?serverTimezone=Asia/Shanghai&characterEncoding=utf8
username: root
password: root
Pojo逻辑对象定义
定义一个Menu对象,用户封装tb_menus表中的数据,例如:
package com.jt.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import org.springframework.data.annotation.Id;
import java.io.Serializable;
@TableName(value = "tb_menus")
public class Menu implements Serializable {
private static final long serialVersionUID = -577747732166248365L;
@TableId(type = IdType.AUTO)
private Long id;
private String name;
private String permission;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPermission() {
return permission;
}
public void setPermission(String permission) {
this.permission = permission;
}
@Override
public String toString() {
return "Menu{" +
"id=" + id +
", name='" + name + '\'' +
", permission='" + permission + '\'' +
'}';
}
}
Dao逻辑对象设计及实现
创建用于操作数据库中tb_menus表中数据的Mapper对象,例如:
package com.jt.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.Menu;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
}
Service逻辑对象设计及实现
第一步:定义用于处理菜单业务的业务接口,例如:
package com.jt.service;
import com.jt.pojo.Menu;
import java.io.Serializable;
public interface MenuService {
/**
* 基于id查找菜单对象,先查redis,redis没有再查数据库
* @param id
* @return
*/
Menu selectById(Long id);
/**
* 向表中写入一条菜单信息,与此同时也要向redis写入一样的数据
* @param menu
* @return
*/
Menu insertMenu(Menu menu);
/**
* 更新表中数据,与此同时也要更新redis中的数据
* @param menu
* @return
*/
Menu updateMenu(Menu menu);
//.....
}
第二步:定义用于处理菜单业务的业务接口实现类,
在这个实现类中自己基于RedisTemplate对象操作Redis缓存,例如:
package com.jt.service;
import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.Duration;
@Service
public class MenuServiceImpl implements MenuService{
//注入方案1
//@Autowired
//private RedisTemplate redisTemplate;
//@Autowired
//private MenuMapper menuMapper;
private static final Logger log=
LoggerFactory.getLogger(MenuServiceImpl.class);
//注入方案2
private MenuMapper menuMapper;
private ValueOperations valueOperations;
public MenuServiceImpl(MenuMapper menuMapper,
RedisTemplate redisTemplate) {
this.menuMapper = menuMapper;
this.valueOperations = redisTemplate.opsForValue();
}
private static final String KEY_PREFIX="menu:";
@Override
public Menu selectById(Long id) {
//1.从redis获取菜单信息,有则直接返回
//ValueOperations valueOperations = redisTemplate.opsForValue();
Object obj = valueOperations.get(KEY_PREFIX + id);
if(obj!=null){
log.info("Data from Redis Cache");
return (Menu)obj;
}
log.info("Data from MySQL");
//2.从mysql数据库中查询菜单信息
Menu menu=menuMapper.selectById(id);
//3.将数据中查询到的菜单信息存储到redis
valueOperations.set(KEY_PREFIX+id,
menu,
Duration.ofSeconds(60*60));
//4.返回菜单对象
return menu;
}
@Override
public Menu insertMenu(Menu menu) {
//1.保存到关系数据
log.info("insert.before.menu={}",menu);
menuMapper.insert(menu);
log.info("insert.after.menu={}",menu);
//2.将数据保存到缓存
//ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set(KEY_PREFIX+menu.getId(),
menu, Duration.ofSeconds(60*60));
return menu;
}
@Override
public Menu updateMenu(Menu menu) {
//1.更新mysql数据
menuMapper.updateById(menu);
//2.更新缓存数据
//ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set(KEY_PREFIX+menu.getId(),
menu, Duration.ofSeconds(60*60));
return menu;
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
第三步:定义用于处理菜单业务的业务接口实现类,基于AOP方式操作redis缓存,比较
与第二步写的Redis操作方式的不同,例如:
package com.jt.service;
import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class DefaultMenuService implements MenuService{
@Autowired
private MenuMapper menuMapper;
/**
* 由此注解描述的方法为切入点方法,此方法执行时,底层会通过AOP机制
* 先从缓存取数据,缓存有则直接返回,缓存没有则查数据,最后将查询的数据
* 还会向redis存储一份
* @param id
* @return
*/
@Cacheable(value = "menuCache",key="#id")
@Override
public Menu selectById(Long id) {
return menuMapper.selectById(id);
}
/**
* CachePut注解的意思是更新缓存
* @param menu
* @return
*/
@CachePut(value = "menuCache",key="#menu.id")
@Override
public Menu insertMenu(Menu menu) {
menuMapper.insert(menu);
return menu;
}
@CachePut(value = "menuCache",key="#menu.id")
@Override
public Menu updateMenu(Menu menu) {
menuMapper.updateById(menu);
return menu;
}
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546
说明,启动AOP方式的缓存应用,需要在启动类上添加@EnableCaching注解:
第四步:定义单元测试类,基于单元测试类测试缓存应用.例如:
package com.jt;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
@SpringBootTest
public class MenuServiceTests {
@Autowired
@Qualifier("defaultMenuService")
//@Resource(name="defaultMenuService")
private MenuService menuService;
@Test
void testSelectById(){
Menu menu = menuService.selectById(1L);
System.out.println(menu);
}
@Test
void testUpdateMenu(){
Menu menu = menuService.selectById(1L);
menu.setName("select res");
menuService.updateMenu(menu);
}
@Test
void testInertMenu(){
Menu menu = new Menu();
menu.setName("insert res");
menu.setPermission("sys:res:insert");
menuService.insertMenu(menu);
}
}
123456789101112131415161718192021222324252627282930313233343536
第五步:改变AOP方式中redis数据存储时的序列化方式(假如业务上需要).其实现上要借助
CacheManager对象,例如:
package com.jt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
/**
* 重构CacheManager对象,其目的是改变AOP方式应用redis的序列化和反序列化的方式.
*/
@Configuration
public class CacheManagerConfig {
/**
* 重构CacheManager对象
* @return
*/
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
//定义RedisCache配置
RedisCacheConfiguration cacheConfig=
RedisCacheConfiguration.defaultCacheConfig()
//定义key的序列化方式
.serializeKeysWith(
RedisSerializationContext.
SerializationPair.fromSerializer(RedisSerializer.string()))
//定义value的序列化方式
.serializeValuesWith(
RedisSerializationContext.SerializationPair
.fromSerializer(RedisSerializer.json()));
return RedisCacheManager.builder(redisConnectionFactory)
.cacheDefaults(cacheConfig)
.build();//建造者模式(复杂对象的创建,建议使用这种方式,封装了对象的创建细节)
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142
写好这个对象后,可以再次基于MenuService中的方法进行单元测试,检测redis数据的存储.
Controller逻辑对象设计及实现
第一步:定义Controller处理,处理客户端对菜单数据的请求操作,例如:
package com.jt.controller;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/menu")
public class MenuController{
@Autowired
@Qualifier("defaultMenuService")
private MenuService menuService;
@GetMapping("/{id}")
public Menu doSelectById(@PathVariable("id") Long id){
return menuService.selectById(id);
}
@PutMapping
public String doUpdate(@RequestBody Menu menu){
menuService.updateMenu(menu);
return "update ok";
}
@PostMapping
public String doInsert(@RequestBody Menu menu){
menuService.insertMenu(menu);
return "insert ok";
}
}
12345678910111213141516171819202122232425262728
第二步:打开postman或基于idea中的http client工具进行访问测试.检测redis数据存储与更新
总结（Summary）
常见问题分析
- 基于redis存储用户状态时，你使用的数据类型是什么？(hash类型)
- 通过redis存储登录状态，你觉得有什么弊端？(检查用户登录状态需要查询redis)
- 基于redis实现某个活动的投票系统，你使用的数据类型是什么？(Set类型)
- 在我们的业务对象中如何使用redis？(注入RedisTemplate或其子类，AOP方式)
常见Bug分析
- 依赖注入异常？(检查对象是否交给了Spring管理，一个接口有多个实现时如何实现对象的注入)
- 启动AOP方式的缓存实现，在启动类或配置上类没有加@EnableCaching注解
本文由 liyunfei 创作，采用 知识共享署名4.0
国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: Jun 29,2022