Java中操作Redis & SpringCache

已于 2024-02-03 14:31:00 修改
阅读量365 收藏 8
点赞数 8
文章标签： java redis
于 2024-01-06 22:59:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73505556/article/details/135433582
版权

目录

在java中操作Redis

SpringCache

在java中操作Redis

Controller

package com.zsh.controller.user;

@RestController("userDishController")
@RequestMapping("/user/dish")
@Slf4j
@Api(tags = "C端-菜品浏览接口")
public class DishController {

    @Autowired
    private DishService dishService;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 根据分类id查询菜品
     *
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询菜品")
    public Result<List<DishVO>> list(Integer categoryId) {
        // 查询
        List<DishVO> dishVO = dishService.findByCategoryId(categoryId);
        // 返回结果
        return Result.success(dishVO);
    }

}

ServiceImpl

package com.zsh.service.impl;

import java.util.List;
import java.util.Set;

@Service
public class DishServiceImpl implements DishService {

    @Autowired
    private DishMapper dishMapper;

    @Autowired
    private DishFlavorMapper dishFlavorMapper;

    @Autowired
    private SetmealDishMapper setmealDishMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 新增菜品
     * @param dishDTO
     */
    @Transactional
    @Override
    public void addDish(DishDTO dishDTO) {
        // 创建新增需要用到的对象
        Dish dish = new Dish();
        // 拷贝对象
        BeanUtils.copyProperties(dishDTO,dish);
        // 新增菜品
        dishMapper.addDish(dish);
        // 获取insert语句生成的主键值
        Long dishId = dish.getId();

        // 取出前台传过来的口味表数据
        List<DishFlavor> flavors = dishDTO.getFlavors();
        // 判断前端前台是否添加了口味表数据
        if(flavors != null && flavors.size() > 0){
            flavors.forEach(flavor -> {
                flavor.setDishId(dishId);
            });
        }
        // 新增口味
        dishFlavorMapper.addDishFlavor(flavors);

    }

    /**
     * 菜品分页查询
     * @param dishPageQueryDTO
     * @return
     */
    @Override
    public PageResult pageDish(DishPageQueryDTO dishPageQueryDTO) {
        // 开启分页查询
        PageHelper.startPage(dishPageQueryDTO.getPage(),dishPageQueryDTO.getPageSize());
        // 条件查询
        List<DishVO> list = dishMapper.pageDish(dishPageQueryDTO);
        // 获取分页结果
        Page page = (Page) list;
        // 封装结果
        PageResult pageResult = new PageResult(page.getTotal(),page.getResult());
        return pageResult;
    }

    /**
     * 根据id查询菜品
     * @param id
     * @return
     */
    @Override
    public DishVO findByIdDish(Integer id) {
        // 查询菜品
        Dish dish = dishMapper.findById(id);
        // 根据菜品id查询口味
        List<DishFlavor> flavors = dishFlavorMapper.findByDishId(id);
        // 封装返回结果
        DishVO dishVO = new DishVO();
        // 拷贝对象
        BeanUtils.copyProperties(dish,dishVO);
        // 给对象的属性赋值
        dishVO.setFlavors(flavors);
        // 返回结果
        return dishVO;
    }

    /**
     * 修改菜品
     * @param dishDTO
     */
    @Override
    @Transactional
    public void updateDish(DishDTO dishDTO) {
        // 创建修改需要用到的对象
        Dish dish = new Dish();
        // 拷贝对象
        BeanUtils.copyProperties(dishDTO,dish);
        // 修改菜品
        dishMapper.updateDish(dish);

        // 删除口味
        dishFlavorMapper.deleteByDishId(dishDTO.getId());
        // 取出修改后的口味数组
        List<DishFlavor> flavors = dishDTO.getFlavors();
        // 判断口味是否修改
        if(flavors != null && flavors.size()>0){
            // 遍历将id放数组
            flavors.forEach(flavor -> {
                flavor.setDishId(dishDTO.getId());
            });
            // 添加新的口味
            dishFlavorMapper.addDishFlavor(flavors);
        }
        //将所有的菜品缓存数据清理掉，所有以dish_开头的key
        cleanCache("dish_*");
    }

    /**
     * 批量删除菜品
     * @param ids
     */
    @Transactional
    @Override
    public void deleteDish(List<Integer> ids) {
        // 判断菜品是否起售，如果起售则不删除
        for (Integer id : ids) {
            // 根据id查询菜品
            Dish dish = dishMapper.findById(id);
            // 判断菜品是否起售
            if (dish.getStatus() == StatusConstant.ENABLE) {
                throw new DeletionNotAllowedException(MessageConstant.DISH_ON_SALE);
            }
        }

        // TODO这里要判断菜品是否被套餐关联，关联则不能删除
        List<Setmeal> list = setmealDishMapper.findByDishId(ids);
        if(list != null && list.size() > 0){
            throw new DeletionNotAllowedException(MessageConstant.DISH_BE_RELATED_BY_SETMEAL);
        }

        for (Integer id : ids) {
            // 删除菜品
            dishMapper.deleteById(id);
            // 删除口味
            dishFlavorMapper.deleteByDishId(Long.valueOf(id));
        }
        // 将所有的菜品缓存数据清理掉，所有以dish_开头的key
        cleanCache("dish_*");
    }

    /**
     * 菜品起售、停售
     * @param status
     * @param id
     */
    @Override
    public void okAndNo(Integer status, Integer id) {
        // 创建修改要用到的对象
        Dish dish = new Dish();
        // 设置状态
        dish.setStatus(status);
        // 设置id
        dish.setId(Long.valueOf(id));
        // 修改
        dishMapper.updateDish(dish);

        // 将所有的菜品缓存数据清理掉，所有以dish_开头的key
        cleanCache("dish_*");
    }

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
    @Override
    public List<DishVO> findByCategoryId(Integer categoryId) {
        // 构造redis中的key，规则dish_分类id
        String key = "dish_"+ categoryId;
        // 查询redis中是否存在菜品数据
        List<DishVO> redisList = (List<DishVO>) redisTemplate.opsForValue().get(key);
        // 判断redis数据库是否存在数据，存在则无序查询mysql
        if(redisList != null && redisList.size() > 0){
            return redisList;
        }

        // 查询MySQL数据库
        List<DishVO> list = dishMapper.findByCategoryId(categoryId);
        // 获取菜品id
        for (DishVO dish : list) {
            // 根据菜品id查询菜品口味
            List<DishFlavor> disFlavor = dishFlavorMapper.findByDishId(Math.toIntExact(dish.getId()));
            // 将口味放入对应的菜品
            dish.setFlavors(disFlavor);
        }

        // 如果redis数据库中没有查到数据，就把查到的数据保存到数据库
        redisTemplate.opsForValue().set(key,list);

        // 返回结果
        return list;
    }

    /**
     * 清理缓存数据
     * @param pattern
     */
    private void cleanCache(String pattern){
        Set keys = redisTemplate.keys(pattern);
        redisTemplate.delete(keys);
    }
}

SpringCache

Spring Cache 是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。

1、 导入Spring Cache和Redis相关maven坐标

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

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

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

package com.zsh;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement //开启注解方式的事务管理
@Slf4j
@EnableCaching
public class SkyApplication {
    public static void main(String[] args) {
        SpringApplication.run(SkyApplication.class, args);
        log.info("server started");
    }
}

3、在用户端接口SetmealController的 list 方法上加入@Cacheable注解

/**
 * 条件查询
 *
 * @param categoryId
 * @return
 */
@GetMapping("/list")
@ApiOperation("根据分类id查询套餐")
@Cacheable(cacheNames = "setmealCache",key = "#categoryId") //key: setmealCache::100
public Result<List<Setmeal>> list(Long categoryId) {
    Setmeal setmeal = new Setmeal();
    setmeal.setCategoryId(categoryId);
    setmeal.setStatus(StatusConstant.ENABLE);
    List<Setmeal> list = setmealService.list(setmeal);
    return Result.success(list);
}

4、在管理端接口SetmealController的 save、delete、update、startOrStop等方法上加入CacheEvict注解

/**
 * 新增套餐
 *
 * @param setmealDTO
 * @return
 */
@PostMapping
@ApiOperation("新增套餐")
@CacheEvict(cacheNames = "setmealCache",key = "#setmealDTO.categoryId")//key: setmealCache::100
public Result save(@RequestBody SetmealDTO setmealDTO) {
    setmealService.saveWithDish(setmealDTO);
    return Result.success();
}
/**
 * 批量删除套餐
 *
 * @param ids
 * @return
 */
@DeleteMapping
@ApiOperation("批量删除套餐")
@CacheEvict(cacheNames = "setmealCache",allEntries = true)
public Result delete(@RequestParam List<Long> ids) {
    setmealService.deleteBatch(ids);
    return Result.success();
}
/**
 * 修改套餐
 *
 * @param setmealDTO
 * @return
 */
@PutMapping
@ApiOperation("修改套餐")
@CacheEvict(cacheNames = "setmealCache",allEntries = true)
public Result update(@RequestBody SetmealDTO setmealDTO) {
    setmealService.update(setmealDTO);
    return Result.success();
}

/**
 * 套餐起售停售
 *
 * @param status
 * @param id
 * @return
 */
@PostMapping("/status/{status}")
@ApiOperation("套餐起售停售")
@CacheEvict(cacheNames = "setmealCache",allEntries = true)
public Result startOrStop(@PathVariable Integer status, Long id) {
    setmealService.startOrStop(status, id);
    return Result.success();
}
开朗觉觉
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring Cache手动清理Redis缓存
08-25
主要介绍了Spring Cache手动清理Redis缓存,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot & SpringCache & Redis 整合
Nikon404的博客
04-01 2404
SpringBoot &amp; SpringCache &amp; Redis 整合 单体项目,缓存技术 步骤 1.导入依赖 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="
在Java中操作Redis
qq_33449977的博客
05-20 1387
Spring 对Redis 客户端进行了整合，提供了Spring Date Redis ，在Spring Boot项目中还提供了对应的Starter，即spring-boot-starter-data-redis。ListOperations：针对list类型的数据操作。HashOperations：针对map类型的数据操作。ZSetOperations：zset 类型数据操作。SetOperations ：set 类型数据操作。默认操作的是0号数据库，也可以切换其他数据库。
在java中操作Redis
qq_39123467的博客
10-04 2245
在java中操作Redis
Spring Cache和redis结合使用
xushuai2333333的博客
09-02 1822
Spring Cache和redis结合使用
如何在Java中操作Redis
m0_51791413的博客
05-12 2421
这是因为Redis的Key必须是字符串类型，而Java中的对象类型需要进行序列化才能转化为字符串类型。因此，RedisTemplate使用默认的StringRedisSerializer对Key进行序列化，将Java对象转化为字符串类型作为Redis的Key。如果需要自定义Key的序列化方式，可以通过RedisTemplate的setKeySerializer方法设置Key的序列化器。Redisson是一个基于Redis的Java客户端，它提供了许多方便的功能和API来使用Redis。
Redis之Java中操作redis实践
weixin_55026035的博客
04-16 4789
Redis 客户端 概述 Redis 是一种C/S 架构的分布式缓存数据库，它有自带的命令行客户端，也有对应的Java或其它语言客户端，可以在这些客户端中通过一些API对redis进行读写操作。 准备工作 第一步：创建工程。 创建maven父工程，例如redis,并在此工程下创建两个子工程，一个为redis-jedis,一个为redis-template,例如： 第二步：添加父工程依赖 修改父工程pom.xml文件，添加编译配置 &lt;build&gt; &lt;plug
Redis 的 Java 客户端（Jedis、SpringDataRedis、SpringCache、Redisson）基本操作指南
墨鸦的博客
12-01 6315
Redis 的 Java 客户端（Jedis、SpringDataRedis、SpringCache、Redisson）基本操作指南
Spring Cache结合redis使用
weixin_43811057的博客
12-09 906
Spring Cache 整合 Redis 做缓存使用~ 快速上手~Spring源码解析-Spring Cache
Redis与SpringCache集成
禅与计算机程序设计艺术
01-21 885
1.背景介绍 1. 背景介绍 Redis 是一个开源的高性能键值存储系统，它支持数据的持久化，不仅仅支持简单的键值对类型的数据，还支持列表、集合、有序集合和哈希等数据类型。Redis 和 Spring Cache 集成可以帮助我们更高效地管理和访问缓存数据，提高应用程序的性能。 在本文中，我们将讨论 Redis 与 Spring Cache 集成的核心概念、算法原理、最佳实践、实际应用场景和...
3.3 Java中操作redis
蟑螂恶霸的博客
12-09 3387
1 准备工作 1.1 创建工程 创建maven父工程，例如03-redis,并在此工程下创建两个子工程，一个为sca-jedis,一个为sca-tempate,例如： 1.2 添加项目依赖 修改父工程pom.xml文件，添加编译配置 &lt;build&gt; &lt;plugins&gt; &lt;plugin&gt; &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;
rediscache.zip
11-21
Spring Boot整合Redis与Cache实现缓存Demo，实现Redis缓存。Redis是一个开源的内存NOSQL数据库，在web开发中主要被用于数据缓存。一般在高并发的情况下，web服务器接受访问时，直接从数据库加载是慢的，需要把常用...
springcache-redis:Spring缓存+spring数据redis+redis研究
07-10
参考com.mpos.lottery.te.merchant.dao.JpaDeviceDaoIntegrationTest中的评论
spring-boot-redis-cache
05-30
在这个项目中，我使用 Redis 与 Spring Boot 进行缓存。 当您发送任何请求获取所有客户或通过 id 获取客户时，如果 Redis 没有相关数据，您将等待 3 秒。 Maven 依赖项 &lt; groupId&gt;org.springframework.boot ...
spring-boot-redis.zip
07-20
spring-boot整合MySQL，mybatis，redis
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1199
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1074
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1114
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
springcache整合redis 菜鸡
05-17
没关系，我可以帮你简单介绍一下 Spring Cache 和 Redis 的整合。 Spring Cache 提供了一种在应用程序中缓存数据的机制，可以减少数据库访问次数，提高应用程序性能。而 Redis 是一种开源的内存数据存储系统，可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值