项目缓存优化 -- 手把手教你做ssm+springboot入门后端项目黑马程序员瑞吉外卖（九）

女爷i 2023-10-13 20:01 12阅读 0赞

### 文章目录 ###

*  前言
 *  一、环境搭建
 *   *  1. 问题说明
     *  2. 推送代码到远程仓库
     *  3. maven坐标
     *  4. 配置文件
     *  5. 配置类
 *  二、缓存短信验证码
 *   *  1. 实现思路
     *  2. 代码改造
     *  3. 功能测试
 *  三、缓存菜品数据
 *   *  1. 实现思路
     *  2. 代码改造
     *  3. 功能测试
 *  四、缓存套餐数据
 *   *  1. 实现思路
     *  2. 代码改造
     *  3. 功能测试
 *  五、提交代码到git仓库
 *  总结

--------------------

# 前言 #

为了巩固所学的知识，作者尝试着开始发布一些学习笔记类的博客，方便日后回顾。当然，如果能帮到一些萌新进行新技术的学习那也是极好的。作者菜菜一枚，文章中如果有记录错误，欢迎读者朋友们批评指正。  
（博客的参考源码可以在我主页的资源里找到，如果在学习的过程中有什么疑问欢迎大家在评论区向我提出）

# 一、环境搭建 #

## 1. 问题说明 ##

> 用户数量多，系统访问量大频繁访问数据库，系统性能下降，用户体验差

![在这里插入图片描述][f4660cc9a845485f9115811828dbedbd.png]

## 2. 推送代码到远程仓库 ##

**1. 代码提交**

*  创建.gitignore文件,过滤非git管理的文件，并放置到与pom.xml同级的目录下

.git
    logs
    rebel.xml
    target/
    !.mvn/wrapper/maven-wrapper.jar
    log.path_IS_UNDEFINED
    .DS_Store
    offline_user.md
    
    ### STS ###
    .apt_generated
    .classpath
    .factorypath
    .project
    .settings
    .springBeans
    
    ### IntelliJ IDEA ###
    .idea
    *.iws
    *.iml
    *.ipr
    
    ### NetBeans ###
    nbproject/private/
    build/
    nbbuild/
    dist/
    nbdist/
    .nb-gradle/
    generatorConfig.xml
    
    ### nacos ###
    third-party/nacos/derby.log
    third-party/nacos/data/
    third-party/nacos/work/
    
    file/

*  提交文件操远程仓库并刷新  
    ![在这里插入图片描述][9ea2f5c5d8624440b663414604b530c3.png]

**2. 创建分支v1.0 并在码云切换分支，缓存优化在分支v1.0完成**

![在这里插入图片描述][ae9f5985e7274c6eacb53c387c22d68c.png]

## 3. maven坐标 ##

**1. 在项目的pom.xm1文件中导入spring data redis的maven坐标**

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

## 4. 配置文件 ##

> 在项目的application.yml中的spring字段加入redis相关配置

redis:
        host: 127.0.0.1
        port: 6379
        password: 123456
        database: 0

## 5. 配置类 ##

> 在项目中加入配置类RedisConfig

@Configuration
    public class RedisConfig extends CachingConfigurerSupport {
        
        @Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
            //默认的Key序列化器为：JdkSerializationRedisSerializer
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setConnectionFactory(connectionFactory);
            return redisTemplate;
        }
    }

# 二、缓存短信验证码 #

## 1. 实现思路 ##

前面我们已经实现了移动端手机验证码登录，随机生成的验证码我们是保存在HttpSession中的现在需要改造为将验证码缓存在Redis中，具体的实现思路如下

> 1.  在服务端UserController中注入RedisTemplate对象，用于操作Redis
> 2.  在服务端UserController的sendMsg方法中，将随机生成的验证码缓存到Redis中，并设置有效期为5分钟
> 3.  在服务端UserController的lodin方法中，从Redis中获取缓存的验证码，如果登录成功则删除Redis中的验证码

## 2. 代码改造 ##

*  改造UserController

@RestController
    @RequestMapping("/user")
    @Slf4j
    public class UserController {
        
    
        @Autowired
        private UserService userService;
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * 发送手机短信验证码
         * @param user
         * @return
         */
        @PostMapping("/sendMsg")
        public R<String> sendMsg(@RequestBody User user, HttpSession session){
        
            //获取手机号
            String phone = user.getPhone();
    
            if(StringUtils.isNotEmpty(phone)){
        
                //生成随机的4位验证码
                String code = ValidateCodeUtils.generateValidateCode(4).toString();
                log.info("code={}",code);
    
                //调用阿里云提供的短信服务API完成发送短信
                //SMSUtils.sendMessage("瑞吉外卖","",phone,code);
    
                //需要将生成的验证码保存到Session
                //session.setAttribute(phone,code);
    
                //将生成的验证码缓存到Redis中，并且设置有效期为5分钟
                redisTemplate.opsForValue().set(phone,code,5,TimeUnit.MINUTES);
    
                return R.success("手机验证码短信发送成功");
            }
    
            return R.error("短信发送失败");
        }
    
        /**
         * 移动端用户登录
         * @param map
         * @param session
         * @return
         */
        @PostMapping("/login")
        public R<User> login(@RequestBody Map map, HttpSession session){
        
            log.info(map.toString());
    
            //获取手机号
            String phone = map.get("phone").toString();
    
            //获取验证码
            String code = map.get("code").toString();
    
            //从Session中获取保存的验证码
            //Object codeInSession = session.getAttribute(phone);
    
            //从Redis中获取缓存的验证码
            Object codeInSession = redisTemplate.opsForValue().get(phone);
    
            //进行验证码的比对（页面提交的验证码和Session中保存的验证码比对）
            if(codeInSession != null && codeInSession.equals(code)){
        
                //如果能够比对成功，说明登录成功
    
                LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(User::getPhone,phone);
    
                User user = userService.getOne(queryWrapper);
                if(user == null){
        
                    //判断当前手机号对应的用户是否为新用户，如果是新用户就自动完成注册
                    user = new User();
                    user.setPhone(phone);
                    user.setStatus(1);
                    userService.save(user);
                }
                session.setAttribute("user",user.getId());
    
                //如果用户登录成功，删除Redis中缓存的验证码
                redisTemplate.delete(phone);
    
                return R.success(user);
            }
            return R.error("登录失败");
        }
    
    }

## 3. 功能测试 ##

![在这里插入图片描述][6c054eabb36c456cbc18ff7f28381b37.png]

# 三、缓存菜品数据 #

## 1. 实现思路 ##

前面我们已经实现了移动端菜品查看功能，对应的服务端方法为DishController的list方法，此方法会根据前端提交的查询条件进行数据库查询操作。在高并发的情况下，频繁查询数据库会导致系统性能下降，服务端响应时间增长。现在需要对此方法进行缓存优化，提高系统的性能。具体的实现思路如下:

> 1.  改造DishController的list方法，先从Redis中获取菜品数据，如果有则直接返回，无需查询数据库;如果没有则查询数据库，并将查询到的菜品数据放入Redis。
> 2.  改造DishController的save和update方法，加入清理缓存的逻辑
> 3.  注意事项 ：在使用缓存过程中，要注意保证数据库中的数据和缓存中的数据一致，如果数据库中的数据发生变化，需要及时清理缓存数据。

## 2. 代码改造 ##

*  改造DishController

/**
     * 菜品管理
     */
    @RestController
    @RequestMapping("/dish")
    @Slf4j
    public class DishController {
        
        @Autowired
        private DishService dishService;
    
        @Autowired
        private DishFlavorService dishFlavorService;
    
        @Autowired
        private CategoryService categoryService;
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * 新增菜品
         * @param dishDto
         * @return
         */
        @PostMapping
        public R<String> save(@RequestBody DishDto dishDto){
        
            log.info(dishDto.toString());
    
            dishService.saveWithFlavor(dishDto);
    
            //清理所有菜品的缓存数据
            //Set keys = redisTemplate.keys("dish_*");
            //redisTemplate.delete(keys);
    
            //清理某个分类下面的菜品缓存数据
            String key = "dish_" + dishDto.getCategoryId() + "_1";
            redisTemplate.delete(key);
    
            return R.success("新增菜品成功");
        }
    
        /**
         * 菜品信息分页查询
         * @param page
         * @param pageSize
         * @param name
         * @return
         */
        @GetMapping("/page")
        public R<Page> page(int page,int pageSize,String name){
        
    
            //构造分页构造器对象
            Page<Dish> pageInfo = new Page<>(page,pageSize);
            Page<DishDto> dishDtoPage = new Page<>();
    
            //条件构造器
            LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
            //添加过滤条件
            queryWrapper.like(name != null,Dish::getName,name);
            //添加排序条件
            queryWrapper.orderByDesc(Dish::getUpdateTime);
    
            //执行分页查询
            dishService.page(pageInfo,queryWrapper);
    
            //对象拷贝
            BeanUtils.copyProperties(pageInfo,dishDtoPage,"records");
    
            List<Dish> records = pageInfo.getRecords();
    
            List<DishDto> list = records.stream().map((item) -> {
        
                DishDto dishDto = new DishDto();
    
                BeanUtils.copyProperties(item,dishDto);
    
                Long categoryId = item.getCategoryId();//分类id
                //根据id查询分类对象
                Category category = categoryService.getById(categoryId);
    
                if(category != null){
        
                    String categoryName = category.getName();
                    dishDto.setCategoryName(categoryName);
                }
                return dishDto;
            }).collect(Collectors.toList());
    
            dishDtoPage.setRecords(list);
    
            return R.success(dishDtoPage);
        }
    
        /**
         * 根据id查询菜品信息和对应的口味信息
         * @param id
         * @return
         */
        @GetMapping("/{id}")
        public R<DishDto> get(@PathVariable Long id){
        
    
            DishDto dishDto = dishService.getByIdWithFlavor(id);
    
            return R.success(dishDto);
        }
    
        /**
         * 修改菜品
         * @param dishDto
         * @return
         */
        @PutMapping
        public R<String> update(@RequestBody DishDto dishDto){
        
            log.info(dishDto.toString());
    
            dishService.updateWithFlavor(dishDto);
    
            //清理所有菜品的缓存数据
            //Set keys = redisTemplate.keys("dish_*");
            //redisTemplate.delete(keys);
    
            //清理某个分类下面的菜品缓存数据
            String key = "dish_" + dishDto.getCategoryId() + "_1";
            redisTemplate.delete(key);
    
            return R.success("修改菜品成功");
        }
    
        /**
         * 根据条件查询对应的菜品数据
         * @param dish
         * @return
         */
        /*@GetMapping("/list")
        public R<List<Dish>> list(Dish dish){
            //构造查询条件
            LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(dish.getCategoryId() != null ,Dish::getCategoryId,dish.getCategoryId());
            //添加条件，查询状态为1（起售状态）的菜品
            queryWrapper.eq(Dish::getStatus,1);
    
            //添加排序条件
            queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
    
            List<Dish> list = dishService.list(queryWrapper);
    
            return R.success(list);
        }*/
    
        @GetMapping("/list")
        public R<List<DishDto>> list(Dish dish){
        
            List<DishDto> dishDtoList = null;
    
            //动态构造key
            String key = "dish_" + dish.getCategoryId() + "_" + dish.getStatus();//dish_1397844391040167938_1
    
            //先从redis中获取缓存数据
            dishDtoList = (List<DishDto>) redisTemplate.opsForValue().get(key);
    
            if(dishDtoList != null){
        
                //如果存在，直接返回，无需查询数据库
                return R.success(dishDtoList);
            }
    
            //构造查询条件
            LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(dish.getCategoryId() != null ,Dish::getCategoryId,dish.getCategoryId());
            //添加条件，查询状态为1（起售状态）的菜品
            queryWrapper.eq(Dish::getStatus,1);
    
            //添加排序条件
            queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
    
            List<Dish> list = dishService.list(queryWrapper);
    
            dishDtoList = list.stream().map((item) -> {
        
                DishDto dishDto = new DishDto();
    
                BeanUtils.copyProperties(item,dishDto);
    
                Long categoryId = item.getCategoryId();//分类id
                //根据id查询分类对象
                Category category = categoryService.getById(categoryId);
    
                if(category != null){
        
                    String categoryName = category.getName();
                    dishDto.setCategoryName(categoryName);
                }
    
                //当前菜品的id
                Long dishId = item.getId();
                LambdaQueryWrapper<DishFlavor> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(DishFlavor::getDishId,dishId);
                //SQL:select * from dish_flavor where dish_id = ?
                List<DishFlavor> dishFlavorList = dishFlavorService.list(lambdaQueryWrapper);
                dishDto.setFlavors(dishFlavorList);
                return dishDto;
            }).collect(Collectors.toList());
    
            //如果不存在，需要查询数据库，将查询到的菜品数据缓存到Redis
            redisTemplate.opsForValue().set(key,dishDtoList,60, TimeUnit.MINUTES);
    
            return R.success(dishDtoList);
        }
    
    }

## 3. 功能测试 ##

![在这里插入图片描述][dac38dc388b541bb9e1502d6ac76cea9.png]

# 四、缓存套餐数据 #

## 1. 实现思路 ##

前面我们已经实现了移动端套餐查看功能，对应的服务端方法为SetmealController的list方法，此方法会根据前端提交的查询条件进行数据库查询操作。在高并发的情况下，频繁查询数据库会导致系统性能下降，服务端响应时间增长。现在需要对此方法进行缓存优化，提高系统的性能。具体的实现思路如下:

> 1.  导入Spring Cache和Redis相关maven坐标
> 2.  在application.ym\[中配置缓存数据的过期时间
> 3.  在启动类上加入@EnableCaching注解，开启缓存注解功能
> 4.  在SetmealController的list方法上加入@Cacheable注解
> 5.  在SetmealController的save和delete方法上加入CacheEvict注解

## 2. 代码改造 ##

*  导入Spring Cache和Redis相关maven坐标

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

*  在application.ym\[中配置缓存数据的过期时间

spring:
      cache:
        redis:
          time-to-live: 1800000 #设置缓存数据的过期时间

*  在启动类上加入@EnableCaching注解，开启缓存注解功能

//...
    @EnableCaching //开启Spring Cache注解方式是缓存功能
    public class ReggieApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(ReggieApplication.class,args);
            log.info("项目启动成功...");
        }
    }

*  在SetmealController的list方法上加入@Cacheable注解

/**
         * 新增套餐
         * @param setmealDto
         * @return
         */
        @PostMapping
        @CacheEvict(value = "setmealCache",allEntries = true)
        public R<String> save(@RequestBody SetmealDto setmealDto){
        
            log.info("套餐信息：{}",setmealDto);
    
            setmealService.saveWithDish(setmealDto);
    
            return R.success("新增套餐成功");
        }

*  在SetmealController的save和delete方法上加入CacheEvict注解

/**
         * 删除套餐
         * @param ids
         * @return
         */
        @DeleteMapping
        @CacheEvict(value = "setmealCache",allEntries = true)
        public R<String> delete(@RequestParam List<Long> ids){
        
            log.info("ids:{}",ids);
    
            setmealService.removeWithDish(ids);
    
            return R.success("套餐数据删除成功");
        }

*  R实现序列化接口

/**
     * 通用返回结果，服务端响应的数据最终都会封装成此对象
     * @param <T>
     */
    @Data
    public class R<T> implements Serializable{
        
    
        private Integer code; //编码：1成功，0和其它数字为失败
    
        private String msg; //错误信息
    
        private T data; //数据
    
        private Map map = new HashMap(); //动态数据
    
        public static <T> R<T> success(T object) {
        
            R<T> r = new R<T>();
            r.data = object;
            r.code = 1;
            return r;
        }
    
        public static <T> R<T> error(String msg) {
        
            R r = new R();
            r.msg = msg;
            r.code = 0;
            return r;
        }
    
        public R<T> add(String key, Object value) {
        
            this.map.put(key, value);
            return this;
        }
    
    }

## 3. 功能测试 ##

![在这里插入图片描述][b667f830bdc1479ab0bf5de755d80932.png]

# 五、提交代码到git仓库 #

![在这里插入图片描述][87a8ed78c7c8468385e2307c7414244e.png]

# 总结 #

欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下。  
（博客的参考源码可以在我主页的资源里找到，如果在学习的过程中有什么疑问欢迎大家在评论区向我提出）

[f4660cc9a845485f9115811828dbedbd.png]: https://img-blog.csdnimg.cn/f4660cc9a845485f9115811828dbedbd.png
[9ea2f5c5d8624440b663414604b530c3.png]: https://img-blog.csdnimg.cn/9ea2f5c5d8624440b663414604b530c3.png
[ae9f5985e7274c6eacb53c387c22d68c.png]: https://img-blog.csdnimg.cn/ae9f5985e7274c6eacb53c387c22d68c.png
[6c054eabb36c456cbc18ff7f28381b37.png]: https://img-blog.csdnimg.cn/6c054eabb36c456cbc18ff7f28381b37.png
[dac38dc388b541bb9e1502d6ac76cea9.png]: https://img-blog.csdnimg.cn/dac38dc388b541bb9e1502d6ac76cea9.png
[b667f830bdc1479ab0bf5de755d80932.png]: https://img-blog.csdnimg.cn/b667f830bdc1479ab0bf5de755d80932.png
[87a8ed78c7c8468385e2307c7414244e.png]: https://img-blog.csdnimg.cn/87a8ed78c7c8468385e2307c7414244e.png