SpringBoot 整合Redis缓存，使用Docker做Redis容器

最新推荐文章于 2022-11-10 15:03:43 发布
最新推荐文章于 2022-11-10 15:03:43 发布
阅读量570 收藏 1
点赞数
分类专栏： SpringBoot 文章标签： SpringBoot 整合Redis缓存，使用Docker做
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvhaoguang0/article/details/86520144
版权

如果我的博客能够帮到大家能够点个赞，关注一下，以后还会更新更过JavaWeb的高级技术，大家的支持就是我继续更新的动力。谢谢咯。

        在日常得开发中，JavaWeb项目中经常需要使用缓存，加快系统得访问速度。有利于用户更好的用户体验。以下是SpringBoot整合Redis的案例，仅供参考。

一、环境搭建

  •  导入依赖
<!--引入缓存组件-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
  • 编写实体类 DepartMent.java 和 Employee.java
package com.nyist.cache.model;

import java.io.Serializable;

public class Department implements Serializable {
	
	private Integer id;
	private String departmentName;
	
	
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Department(Integer id, String departmentName) {
		super();
		this.id = id;
		this.departmentName = departmentName;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName + "]";
	}
}



package com.nyist.cache.model;

import java.io.Serializable;

public class Employee implements Serializable {
	
	private Integer id;
	private String lastName;
	private String email;
	private Integer gender; //性别 1男  0女
	private Integer dId;
	
	
	public Employee() {
		super();
	}

	
	public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dId = dId;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Integer getGender() {
		return gender;
	}
	public void setGender(Integer gender) {
		this.gender = gender;
	}
	public Integer getdId() {
		return dId;
	}
	public void setdId(Integer dId) {
		this.dId = dId;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
				+ dId + "]";
	}
}
  • 配置数据源
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/spring_cache?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    type: com.alibaba.druid.pool.DruidDataSource

    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,logback
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  #指定链接的Redis
  redis:
    host: 192.168.1.110


#mybatis 开启驼峰命名法
mybatis:
  configuration:
    map-underscore-to-camel-case: true

#设置日志等级
logging:
  level:
    com.nyist.cache.mapper: debug
#打开控制报告
#debug: true
  • 配置Mapper DepartmentMapper.java 和 EmployeeMapper.java
package com.nyist.cache.mapper;

import com.nyist.cache.model.Department;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface DepartmentMapper {

    @Select("select * from department where id=#{id}")
    Department getDeptById(Integer id);
}




package com.nyist.cache.mapper;

import com.nyist.cache.model.Employee;
import org.apache.ibatis.annotations.*;

@Mapper
public interface EmployeeMapper {

    @Select("select * from employee where  id = #{id}")
    public Employee getEmpById(Integer id);

    @Update("update employee set lastName = #{lastName},email=#{email},gender=#{gender} where id=#{id}")
    public void updateEmp(Employee employee);


    @Delete("delete from employee where id = #{id}")
    public void deleteEmp(Integer id);


    @Insert("insert into employee(lastName,email,gender,d_id) values(#{lastName},#{email},#{gender},#{d_id})")
    public void insertEmp(Employee employee);


    @Select("select * from employee where lastName = #{lastName}")
    Employee getEmpByLastName(String lastName);
}
  • config配置 MyRedisConfiguration.java
package com.nyist.cache.comfig;

import com.nyist.cache.model.Employee;
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;

//开启自定义序列化
@Configuration
public class MyRedisConfiguration {

    @Bean   //加入到容器中去
    public RedisTemplate<Object, Employee> empredisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Employee> redisTemplate = new RedisTemplate<Object, Employee>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //转换为json 保存到redis数据库中
        Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        redisTemplate.setDefaultSerializer(serializer);
        return redisTemplate;
    }

}
  • servic层 DeptService.java 和 EmployeeService.java
package com.nyist.cache.service;

import com.nyist.cache.mapper.EmployeeMapper;
import com.nyist.cache.model.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;

//用于抽取公共配置
@CacheConfig(cacheNames = "emp")
@Service
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    /**
     * 将方法的运行结果进行缓存,以后再要使用相同的数据,直接从缓存中拿,不调用方法。
     * CacheManager 管理多个缓存Cache组件,对缓存的真正CRUD操作在Cache 组件中,每一个缓存组件有一个唯一一个名字
     * 几个属性:
     *      cacheNames/valye:指定缓存组件的名字
     *      key:缓存数据时的key,可以用它来指定。  默认使用方法参数的值 1-方法的返回值
     *          可以编写SPEL 表达式 #id;参数id的值, #a0 #p0 #root.args[0]
     *
     *      keyGenerator:key 得生成器,可以自己指定key的生成器的组件ID
     *          key/keyGenerator:二选一
     *      cacheManager:指定缓存管理器,或者cacheResolver指定获取缓存解析器。
     *      condition:符合条件的情况下才缓存。
     *      unless:是否缓存,当unless指定的条件为true,方法的返回值不会被缓存,可以根据结果进行判断
     *      sync:是否使用异步模式
     * @param id
     * @return
     */
    /***
     * @Cacheable(condition="#id>0",cacheNames={"emp"})
     * //指定key getEmp(2)
     * @Cacheable(cacheNames = {"emp"},key="#root.methodName+'['+#id+']'")
     * @Cacheable(cacheNames = {"emp"},keyGenerator = "myKeyGenerator",condition = "#a0>1 and #root.methodName eq 'aaa'")
     *
     * @param id
     * @return
     */
    @Cacheable(cacheNames = {"emp"},key = "#id")/*,keyGenerator = "myKeyGenerator",condition = "#a0>1",unless = "#p0==2")*/
    public Employee getEmp(Integer id){
        System.out.println("查询:"+id);
        Employee empById = employeeMapper.getEmpById(id);
        return empById;
    }


    //更新的调用
    @CachePut(key = "#employee.id",value = "emp")
    public Employee updateEmp(Employee employee){
        employeeMapper.updateEmp(employee);
        return  employee;
    }

    //allEntries默认为fale 若改为true 则删除缓存的时候 会全部和删除
    //beforeInvocation 是否在方法之前调用,默认为false,当等于true的时候 即为在方法之前调用
    //删除  清空缓存
    @CacheEvict(cacheNames = "emp",key = "#id")
    public void deleteEmp(Integer id){
        System.out.println("DeleteId:"+id);
        employeeMapper.deleteEmp(id);
    }

    //定义复杂缓存规则
    /***
     * 1.使用 lastName查询数据库将查询的结果放入缓存中
     * 2.在使用 id 和 email 查询 同样可以查询到 不需要发送SQL查询数据库,只查询缓存就可以查询到数据
     * 3.所以配置的Caching 正确
     * @param lastName
     * @return
     */
    @Caching(
            cacheable = {
                //根据 lastName查询缓存 如果缓存中没有这条数据记录,将其放入缓存中
                @Cacheable(cacheNames="emp",key = "#lastName")
            },
            put = {
                //可以根据id 和 邮箱更新缓存
                @CachePut(cacheNames = "emp",key = "#result.id"),
                @CachePut(cacheNames="emp",key = "#result.email")
            }
    )
    public Employee getEmoByLastName(String lastName){
        Employee employee = employeeMapper.getEmpByLastName(lastName);
        return employee;
    }
}







package com.nyist.cache.service;

import com.nyist.cache.mapper.DepartmentMapper;
import com.nyist.cache.model.Department;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.stereotype.Service;

//使用缓存管理器
@CacheConfig(cacheManager = "redisCacheManager")
@Service
public class DeptService {
    @Autowired
    DepartmentMapper departmentMapper;

    @Autowired
    RedisCacheManager redisCacheManager;

    //默认key 为Id
    @Cacheable(cacheNames = "dept")
    public Department getDept(Integer id){
        System.out.println("查询部门:"+id);
        Department department = departmentMapper.getDeptById(id);

        return department;
    }

    //编码方式  用来缓存数据
    public Department getDeptById(Integer id){
        //使用编码的方式 来缓存数据
        Department department = null;
        Cache dept = redisCacheManager.getCache("dept");
        department = departmentMapper.getDeptById(id);
        //获取某个缓存
        dept.put("dept:1",department);
        return department;
    }
}
  • controller DeptController 和 EmployeeController
package com.nyist.cache.controller;

import com.nyist.cache.model.Department;
import com.nyist.cache.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DeptController {

    @Autowired
    DeptService deptService;

    //缓存的数据能够保存到Redis
    //第二次从缓存中查询不能够被反序列化
    @GetMapping("/dept/{id}")
    public Department getDeptById(@PathVariable("id") Integer id){
        Department dept = deptService.getDept(id);
        return dept;
    }

    @GetMapping("/getDeptById/{id}")
    public Department getDept(@PathVariable("id") Integer id){
        Department department = deptService.getDeptById(id);
        return department;
    }
}








package com.nyist.cache.controller;

import com.nyist.cache.model.Employee;
import com.nyist.cache.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    @GetMapping("/emp/{id}")
    public Employee getEmp(@PathVariable("id") Integer id){
        Employee emp = employeeService.getEmp(id);
        return emp;
    }


    @GetMapping("/emp")
    public Employee update(Employee employee){
        System.out.println("employee:"+employee);
        Employee employee1 = employeeService.updateEmp(employee);
        return employee1;
    }

    @GetMapping("/demp/{id}")
    public void deleteEmp(@PathVariable("id") Integer id){
        System.out.println("deleteEmp:"+id);
        employeeService.deleteEmp(id);
        System.out.println("删除成功!!!");
    }

    @GetMapping("/getEmpByLastName/{lastName}")
    public Employee getEmpByLastName(@PathVariable("lastName") String lastName){
        Employee emoByLastName = employeeService.getEmoByLastName(lastName);
        return emoByLastName;
    }
}
  • 测试类
package com.nyist.cache;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.nyist.cache.mapper.EmployeeMapper;
import com.nyist.cache.model.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.jackson.JsonObjectDeserializer;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Springboot01CacheApplicationTests {

    @Autowired
    EmployeeMapper employeeMapper;

    //操作k-v都是字符串
    @Autowired
    StringRedisTemplate stringRedisTemplate;

    //操作k-v都是对象
    @Autowired
    RedisTemplate redisTemplate;

    @Autowired
    RedisTemplate<Object,Employee> empredisTemplate;
    /***
     * String(字符串)、List(列表)、Set(集合)、Hash(散列)、ZSet(有序集合)
     stringRedisTemplate.opsForValue(); 操作字符串
     stringRedisTemplate.opsForList();  操作列表的
     stringRedisTemplate.opsForSet();   操作集合的
     stringRedisTemplate.opsForHash();  操作散列的
     stringRedisTemplate.opsForZSet();  操作有序集合的
     *
     */
    @Test
    public void testRedis(){
        //给redis中保存了一个数据
       // stringRedisTemplate.opsForValue().append("msg","hello");
        String msg = stringRedisTemplate.opsForValue().get("msg");
        System.out.println(msg);
        System.out.println("\n*****************操列表*******************\n");
        stringRedisTemplate.opsForList().leftPush("myList","1");
        stringRedisTemplate.opsForList().leftPush("myList","2");
    }

    //测试保存对象
    @Test
    public void save(){
        //默认如果保存对象,使用jdk序列化机制,序列化后的数据保存在redis中。
        //redisTemplate.opsForValue().set("emp01",empById);
        //1.将数据库以json的格式保存
            //(1)将自己的对象转换为json
            //(2)redisTemplats默认的序列化规则;改变默认的序列化规则
        Employee empById = employeeMapper.getEmpById(3);
//        redisTemplate.opsForValue().set("emp01",empById);
//        JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(empById));
//        redisTemplate.opsForValue().set("emp02",jsonObject.toJSONString());
        empredisTemplate.opsForValue().set("emp04",empById);
    }

    @Test
    public void contextLoads() {
        Employee empById = employeeMapper.getEmpById(1);
        System.out.println(empById);
    }

}
  • 使用Docker做Redis容器
  1. 在中央仓库查找redis  docker search redis
  2. 从中央仓库下载到本地   docker pull redis
  3. 下载好本地镜像 开始制作容器   docker run -d -p 6379:6379 --name myRedis [tag名称]
  4. 查看启动的Redis     docker ps 
  • 使用Redis Desktop Manager 连接虚拟机中的Docker容器中启动的Redis容器

 

项目结构图:

 

源码下载：下载

浅瞳夜未
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker(八)Redis实现缓存功能
xopqaaa的博客
09-16 507
更新identidock.py from flask import Flask, Response, request import requests from flask import Flask, Response, request import requests import hashlib import redis app = Flask(__name__) cache = redis....
spring boot中引入redis（redis来自docker）
xxx
12-18 489
不迈出实践永远都不会知道结果
Springboot整合DockerRedis集群
曾经蜡笔没有小新
06-04 2599
使用Docker搭建Redis集群 创建redis配置文件 cd /home mkdir redis-cluster vi redis-cluster.tmpl port ${PORT} protected-mode no cluster-enabled yes cluster-config-file nodes.conf cluster-node-timeout 5000 cluster-...
Docker 部署 SpringBoot 项目整合 Redis 镜像做访问计数Demo
weixin_33920401的博客
01-11 192
Docker 部署SpringBoot项目整合 Redis 镜像做访问计数Demo 最终效果如下 大概就几个步骤 1.安装 Docker CE 2.运行 Redis 镜像 3.Java 环境准备 4.项目准备 5.编写 Dockerfile 6.发布项目 7.测试服务 环境准备 系统：Ubuntu 17.04 x64 Docker 17.12.0-ce IP:45.32.31.101 一...
SpringBoot_redis使用实战(一)_docker环境
Myron_007的博客
02-10 1901
从实战docker安装redis, 到springboot项目中redis的综合使用.由浅入深
Springboot以Repository方式整合Redis的方法
08-19
在Springboot中，使用Repository方式整合Redis可以简化数据访问层的开发，提高开发效率。 知识点4：整合Redis的步骤 要整合Redis，需要按照以下步骤进行： 1. 安装Redis数据库，可以使用Docker来安装Redis。 2. ...
docker-compose redis主从哨兵 redis多节点高可用 redis集群高可用
04-12
通过以上步骤，我们就可以使用Docker Compose成功部署一套包含主从复制、哨兵监控和集群高可用性的Redis系统。这个方案不仅简化了运维工作，也提升了系统的稳定性和数据安全性。在实际操作中，务必根据业务需求调整...
springboot + dockerclient +redis +esclient
01-10
标题 "springboot + dockerclient +redis +esclient" 描述了一种基于Spring Boot的应用场景，该应用集成了Docker客户端、Redis和Elasticsearch（ES）客户端，实现了数据计算、日志管理和任务队列功能。这里我们将...
GitLab使用外部提供的Redis缓存数据库的方法详解
10-14
本教程将详细解释如何配置GitLab以使用外部Redis缓存数据库。 首先，我们需要确保有一个可用的Redis实例。在本示例中，我们使用的是Redis 5.0.9的Docker容器。以下是如何设置Redis服务的步骤： 1. 创建一个名为`...
springboot中使用redis的方法代码详解
10-16
首先，为了安装Redis，我们可以利用Docker容器化技术。创建一个`docker-compose.yml`文件，配置如下： ```yaml version: "2" services: redis: container_name: redis image: redis:3.2.10 ports: - "6379:...
Docker 安装 Redis + Spring Boot 整合 Redis
星云的博客
06-11 4314
Docker安装Redis 一、启动docker容器 systemctl start docker 二、拉取redis镜像 docker pull redis 三、端口映射 docker run --name redis -p 6379:6379 -d redis 四、启动redis docker start redis 五、查询ip ip addr 六、连接redis Spring...
spring boot 项目部署在Docker中调用redis出现的奇怪问题
weixin_30469895的博客
12-14 541
Whitelabel Error Page This application has no explicit mapping for /error, so you are seeing this as a fallback. Wed Dec 14 09:43:13 UTC 2016 There was an unexpected error (type=Internal Server Err...
CentOS7中使用Docker部署SpringBoot+Redis项目
我的博客
05-11 8745
前言 使用 Docker 部署应用的方式有多种，如每个应用单独部署再连接容器，如 docker-compose... 本博客是单独部署的每一个容器。 本篇博客的操作有： ① 在本地创建一个 SpringBoot 项目；配置 Dockerfile ② 把 SpringBoot 项目传输到服务器；打包成 Docker 镜像 ③ 拉取官方 Redis 镜像；配置 Redi...
Redis工具类
chenyuanju的博客
10-10 458
  import java.util.Collection; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.TimeUnit; import org....
SpringBoot --- 使用 docker 安装使用 Redis 缓存 存储数据
m0_50888347的博客
11-10 838
springboot ----- docker 方式 添加 Redis 缓存 , 存储数据 , 阿里云镜像
Docker下redis与springboot三部曲之三：springboot下访问redis哨兵
程序员欣宸的博客
01-13 4929
在《 Docker下redis与springboot三部曲之二：安装redis主从和哨兵》一文中，我们在docker下搭建了redis主从和哨兵，本章我们开发一个基于springboot的web工程，体验springboot下如何使用redis高可用服务； 原文地址：http://blog.csdn.net/boling_cavalry/article/details/79041129 实
Docker安装Redis 7.x、SpringBoot整合Redis（单机模式）
hkl_Forever的博客
09-04 1327
redis-server /etc/redis/redis.conf：以容器内的配置文件方式启动redis服务，最终找到的是宿主机挂载的配置文件。-v：分别对应挂载的配置文件和数据存储目录，冒号左边是宿主机目录、右边是容器内目录，最终找到的是宿主机目录中的内容。3、本人的配置和数据存储目录统一放在 //devtools/redis 目录下的 conf、data目录下。1、因为需要redis的配置文件，这里最好去redis的官方去下载一个redis使用里面的配置文件即可。
springboot连接基于docker搭建的redis集群
xxx
12-21 3194
祝愿明天考研的同学都能考上 环境：win10 /Docker for windows/docker redis集群 由于redis集群每次重新cluster nodes会更新spring boot配置的spring.redis.cluster.nodes。docker容器与本地宿主机不在同一个网段下面，更新会导致nodes不可达，所以需要在路由表里面加一个路由。 参见：http://www.cnb...
如何将SpringBoot+redis项目的jar包使用Docker容器部署到Linux服务器上
the_bud的博客
04-21 1175
部署前准备： 1、 已经安装了Docker的Linux服务器 2、 实时组件项目的jar包（举例使用test-project.jar） 3、 可以运行jar包的环境 一、 运行Redis镜像 1、运行镜像 执行：docker run –name redis-6379 -p 6379:6379 –d –restart=always redis 注：-d –restart=always：开机自启动 ...
docker springboot redis
最新发布
07-28
- *3* [[springboot]使用docker安装redis实验环境](https://blog.csdn.net/hanxiaotongtong/article/details/122893288)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值