SpringBoot整合Redis实现一套CRUD的简单缓存

最新推荐文章于 2024-02-28 10:25:21 发布
最新推荐文章于 2024-02-28 10:25:21 发布
阅读量1k 收藏 2
点赞数 2
分类专栏： Redis 文章标签： SpringBoot整合Redis Redis缓存机制 解决Redis缓存乱码问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44530530/article/details/91410130
版权

先附上pom.xml依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zhaolei</groupId>
    <artifactId>springboot-cache-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-cache-redis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

yml配置

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/redisdemo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
  redis:
    #redis 服务器地址
    host: 192.168.88.130
    #端口号
    port: 6379
    #Redis数据库索引（默认为0）
    database: 0
    # Redis服务器连接密码（默认为空）
    password:
mybatis:
  #  为实体类起别名
  type-aliases-package: com.zhaolei.students.pojo
  #  扫描类路径下的所有xml
  mapper-locations: classpath:mapper/*.xml
  configuration:
    #    none不自动匹配  FULL全部匹配  PARTIAL默认值-
    auto-mapping-behavior: full
    #    开启驼峰命名
    map-underscore-to-camel-case: true
logging:
  level:
    com.zhaolei.springbootcacheredis.mapper: debug

mapper层

package com.zhaolei.springbootcacheredis.mapper;

import com.zhaolei.springbootcacheredis.pojo.Student;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * @author 15579
 * 2019/6/10 20:22
 * 文件说明：
 */
public interface StudentMapper {
    /**
     * 查询所有记录
     * @return
     */
    @Select("select * from  student")
    List<Student> findAll();

    /**
     * 根据编号查询记录
     * @param id
     * @return
     */
    @Select("select * from student where id=#{id}")
    Student findById(Integer id);

    /**
     * 新增记录
     * @param student
     * @return
     */
    @Insert("INSERT INTO `jpademo`.`student`(`name`, `sex`, `gradeId`) VALUES (#{name},#{sex},#{gradeId})")
    int addStudent(Student student);

    /**
     * 修改记录
     * @param student
     * @return
     */
    @Update("UPDATE `jpademo`.`student` SET `name` = #{name}, `sex` = #{sex}, `gradeId` =#{gradeId} WHERE `id` = #{id}")
    int updateStudent(Student student);

    /**
     * 删除记录
     * @param id
     * @return
     */
    @Delete("DELETE FROM student where id=#{id}")
    int deleteStudent(Integer id);
}

pojo 实体类

/*
 * Welcome to use the TableGo Tools.
 * 
 * http://vipbooks.iteye.com
 * http://blog.csdn.net/vipbooks
 * http://www.cnblogs.com/vipbooks
 * 
 * Author:bianj
 * Email:edinsker@163.com
 * Version:5.8.8
 */

package com.zhaolei.springbootcacheredis.pojo;

/**
 * student
 * 
 * @author zhaolei
 * @version 1.0.0 2019-06-10
 */
public class Student implements java.io.Serializable {
    /** 版本号 */
    private static final long serialVersionUID = -6087187925653606230L;

    /** id */
    private Integer id;

    /** name */
    private String name;

    /** sex */
    private String sex;

    /** gradeId */
    private Integer gradeId;

    /**
     * 获取id
     * 
     * @return id
     */
    public Integer getId() {
        return this.id;
    }

    /**
     * 设置id
     * 
     * @param id
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * 获取name
     * 
     * @return name
     */
    public String getName() {
        return this.name;
    }

    /**
     * 设置name
     * 
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取sex
     * 
     * @return sex
     */
    public String getSex() {
        return this.sex;
    }

    /**
     * 设置sex
     * 
     * @param sex
     */
    public void setSex(String sex) {
        this.sex = sex;
    }

    /**
     * 获取gradeId
     * 
     * @return gradeId
     */
    public Integer getGradeId() {
        return this.gradeId;
    }

    /**
     * 设置gradeId
     * 
     * @param gradeId
     */
    public void setGradeId(Integer gradeId) {
        this.gradeId = gradeId;
    }
}

service层

package com.zhaolei.springbootcacheredis.service;

import com.zhaolei.springbootcacheredis.pojo.Student;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

/**
 * @author 15579
 * 2019/6/10 20:22
 * 文件说明：
 */
public interface StudentService {
    /**
     * 新增记录
     * @return
     */
    List<Student> findAll();

    /**
     * 根据编号查询记录
     * @param id
     * @return
     */
    Student findById(Integer id);

    /**
     * 新增记录
     * @param student
     * @return
     */
    Student addStudent(Student student);

    /**
     * 修改记录
     * @param student
     * @return
     */
    Student updateStudent(Student student);

    /**
     * 删除记录
     * @param id
     * @return
     */
    void deleteStudent(Integer id);
}

impl层（redis缓存主要是在这里实现）

package com.zhaolei.springbootcacheredis.service.impl;

import com.zhaolei.springbootcacheredis.mapper.StudentMapper;
import com.zhaolei.springbootcacheredis.pojo.Student;
import com.zhaolei.springbootcacheredis.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author 15579
 * 2019/6/10 20:22
 * 文件说明：
 */
@Service
public class StudentServiceImpl  implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 新增记录
     * @return
     */
    @Override
    public List<Student> findAll() {
        String key="students";
        /**
         *         redisTemplate.opsForValue();//操作字符串
         *         redisTemplate.opsForHash();//操作hash
         *         redisTemplate.opsForList();//操作list
         *         redisTemplate.opsForSet(); //操作set
         *         redisTemplate.opsForZSet();//操作有序set
         */
        ListOperations<String,Student> listOperations = redisTemplate.opsForList();     //操作list的对象
        //判断redis中是否含有指定的key
        if(redisTemplate.hasKey(key)){
            // 0  -1 查询所有
            return listOperations.range(key,0,-1);
        }else {
            //无此key则向redis中存储
            List<Student> studentList = studentMapper.findAll();
            listOperations.leftPushAll(key,studentList);
            return studentList;
        }
    }
    /**
     * 根据编号查询记录
     * @param id
     * @return
     */
    @Override
    public Student findById(Integer id) {
        String key="student_"+id;//生成唯一key
        ValueOperations<String,Student> operations = redisTemplate.opsForValue();
        //判断redis中是否有此key
        if(redisTemplate.hasKey(key)){
            Student student = operations.get(key); //获取key值
            return student;
        }else{
            //无此key则向redis中存储
            Student student=studentMapper.findById(id);
            operations.set(key,student);    //存储
            return student;
        }
    }

    /**
     * 新增记录
     * @param student
     * @return
     */
    @Override
    public Student addStudent(Student student) {
        studentMapper.addStudent(student);
        //新增成功之后需要刷新redis缓存中的数据
        String key="students";
        ListOperations listOperations = redisTemplate.opsForList();//操作list的对象
        List<Student> studentList = studentMapper.findAll();
        //如果redis中存在此key值则需要清除
        if(redisTemplate.hasKey(key)){
            redisTemplate.delete(key);
        }
        //向redis中存储新的查询结果
        listOperations.rightPushAll(key,studentList);
        return student;
    }
    /**
     * 修改记录
     * @param student
     * @return
     */
    @Override
    @Transactional
    public Student updateStudent(Student student) {
        String key="student_"+student.getId();//生成唯一key
        studentMapper.updateStudent(student);
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //修改redis中数据的值 不存在key值则会自动添加
        valueOperations.set(key,student);
        return student;
    }


    /**
     * 删除记录
     * @param id
     * @return
     */
    @Override
    public void deleteStudent(Integer id) {
        String key="student_"+id;   //生成唯一key
        int ss= studentMapper.deleteStudent(id);
        System.out.println(ss);
        //判断redis中是否包含此key值
        if(redisTemplate.hasKey(key)){
        //有则从redis中删除
          redisTemplate.delete(key);
        }
    }
}

注意：
redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet(); //操作set
redisTemplate.opsForZSet();//操作有序set

controller层

package com.zhaolei.springbootcacheredis.controller;

import com.zhaolei.springbootcacheredis.pojo.Student;
import com.zhaolei.springbootcacheredis.service.StudentService;
import org.apache.ibatis.annotations.Delete;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author 15579
 * 2019/6/10 21:00
 * 文件说明：
 */
@RestController
public class StudentController {
    @Autowired
    private StudentService studentService;

    //查询所有
    @GetMapping("/students")
    public Object findAll(){
       return  studentService.findAll();
    }

    //根据编号查询
    @GetMapping("/findById/{id}")
    public Object findById(@PathVariable("id") Integer id){
        return  studentService.findById(id);
    }

    //新增
    @PostMapping("/students")
    public Object addStudent(Student student){
        return studentService.addStudent(student);
    }


    //修改
    @PutMapping("/students")
    public Object updateStudent(Student student){
        return studentService.updateStudent(student);
    }

    //删除
   @DeleteMapping("/students/{id}")
    public Object deleteStudent(@PathVariable("id") Integer id){
        try {
            studentService.deleteStudent(id);
            return  1;
        }catch (Exception e){
            return 0;
        }
   }
}

然后运行项目测试方式为第一次查询之后存入缓存中然后在执行查询观察控制台是否打印sql语句
没有打印就是缓存成功了！
然后去我们的远程连接工具查看缓存数据会发现如下乱码情况：
在这里插入图片描述
出现这种情况是因为redis自带的序列化配置问题，所以我们还需要在SpringBoot项目中添加一个配置类或者在项目的主入口添加一个@Bean元素修改Redis默认的序列化配置代码如下：

package com.zhaolei.springbootcacheredis.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.net.UnknownHostException;

/**
 * @author 15579
 * 2019/6/10 21:48
 * 文件说明：
 */
//修改redis默认的序列化配置
@Configuration
public class RedisConfig {
    //覆盖默认的自动配置
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {

        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //修改默认的序列化规则
        //1.创建序列化规则对象
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
        //2.更改默认的序列化规则
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        return template;
    }
}

删除出现乱码的缓存数据在运行项目发现乱码问题完美解决！
最后附上几个学习redis几个比较好的学习网址
菜鸟教程：https://www.runoob.com/redis/redis-tutorial.html

几个好的博客网址：

springboot整合redis做缓存：https://blog.csdn.net/zhangcongyi420/article/details/82686702

SpringBoot+MyBatis+Mysql+redis：https://blog.csdn.net/qq_34350964/article/details/82415096

Springboot使用redis实现简单crud：https://blog.csdn.net/qq_38522268/article/details/87607482

Spring Boot 整合 Redis 实现缓存操作：https://www.cnblogs.com/Alandre/p/6713769.html

此为咸鱼
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SpringBoot+JPA+MySQL+Swagger+Redis实现CRUD
04-04
通过SpringBoot+JPA+MySQL+Swagger+Redis实现CRUD，对数据库进行增删改查，分页查找的接口文档
SpringBoot整合Redis使用Restful风格实现CRUD功能
weixin_33834075的博客
05-08 241
前言 本篇文章主要介绍的是SpringBoot整合Redis，使用Restful风格实现的CRUD功能。 Redis 介绍 Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 Redis 与其他 key - value缓存产品有以下三个特点： Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。 Redis不仅仅支持简单...
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 1496
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
springboot整合redis————crud操作
weixin_45386898的博客
04-10 323
1、导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId&g
Spring Boot 整合Redis教程，CRUD超详细，附源码！
qq_41645986的博客
06-08 567
一、环境需求：jdk1.8，电脑上安装好redis，linux和windows都可以，postman测试用，这里不附上安装教程了。 二、创建Springboot项目 可以创建空项目，直接下一步下一步即可 引入pom.xml依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web&l
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
SpringBoot整合Redis大全
04-20
包含springBoot对redis操作的方法，包括测试，测试在test包里
基于springboot和redis实现单点登录
08-25
主要为大家详细介绍了基于springboot和redis实现单点登录，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
案例实战-SpringBoot整合Redis实现缓存分页数据查询
06-19
【案例实战】SpringBoot整合Redis实现缓存分页数据查询源码包
springboot+dubbo+redis+RabbitMQ 项目实例
04-02
springboot、dubbo、zookeeper、redis、MQ、mybatis、druid、swagger 项目实例
Springboot使用redis实现简单crud
qq_38522268的博客
02-18 661
1.添加依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt; 2.配置application.yml...
Spring Boot整合Redis之CURD
mojiezhao的博客
02-09 358
1.在IDEA中创建MAVEN工程 2.在pom.xml中引入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ver...
SpringBoot使用SpringCache并整合Redis的CRUD
lhc0512的博客
07-19 495
使用docker安装redis docker pull redis docker run -d -p 6379:6379 --name redis01 镜像ID 在pom.xml中引入依赖,引入SpringCache和Redis &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&...
SpringBoot整合Redis（基本CRUD操作）【上】
小异常的博客
07-10 991
Redis 是目前比较流行的缓存数据库，它支持 key-value 的存储形式，底层使用 C 语言编写。有关 Redis 的知识我以前整理过一套笔记，敢兴趣的朋友可以参考：《Redis学习笔记》 本篇博客主要介绍如何使用 Spring Boot 整合 Redis 实现基本的 CRUD 操作。下一篇博客将介绍使用 Spring Boot 操作 Redis 的五种数据类型。 本篇博客借助 Postman 小工具来演示效果。
SpringBoot 学习案例（crud、redis、mybatis plus、jpa）
FBB360JAVA的博客
12-27 842
SpringBoot学习案例 本机环境： idea 2018 年12月版本 springboot 是 2.2.2 版本 mysql 8.x 版本 sdk 1.8.x 版本（即jdk） maven 3.6.0 版本 1、入门案例之增删改查 1.1 资料来源 BootStrap 官网、B站上的《尚硅谷 SpringBoot 视频》（视频资料是 2018 年的，这个想看的同学可以去搜一下，应该是...
chromedriver-linux64-V124.0.6367.91 稳定版
04-30
chromedriver-linux64-V124.0.6367.91稳定版
基于yolov7 加入 depth回归
最新发布
04-30
在官方的基础上改了检测头、导出onnx（适配tensorrt pro 项目）、测试demo等代码。 能够使用清华V2X数据集进行训练和测试。 https://www.bilibili.com/video/BV1Wd4y1G78M/?vd_source=0223c707743ff3013adaeff54aee3506 数据集来源：https://thudair.baai.ac.cn/index 基于Yolov7 tiny，加入了距离回归 模型没收敛完，随便试了下，所以预测有抖动 使用TRT加速，在AGX Xavier上推理大约4ms V2X使用tools/convertlabel2yolo.ipynb 进行数据集转换
springboot整合redis实现缓存
04-07
好的，关于springboot整合redis实现缓存，我可以为您提供一些帮助。首先，您需要在pom.xml中添加redis依赖项，然后在application.properties中配置redis连接信息。接下来，您可以使用Spring Boot的注解来实现缓存...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值