Springboot-Mybatis-Redis结合（如若没有缓存 则从mysql中查）
springboot-mybatis-redis整合（使用RedisUtil）
文章目录
- springboot-mybatis-redis整合（使用RedisUtil）
- demo演示
-
- demo结构
- 首先加入redis的maven依赖
- 我这使用RedisUtil工具类来对redis进行操作（封装得比较完整）
- 数据库结构
- 利用mybatis-generator生成实体类和mapper映射文件（这里就不贴代码了 需要请看github）
- 写Service层
- 写serviceImpl层
- 编写控制层
- 有问题欢迎指正
- 闲谈：最近一周学redis 关于redis整合springboot mybatis的博客看得不少，花花绿绿的看了各种写法，故花了一天时间来做一个小demo 目的是验证redis与springboot mybatis结合着使用，方便日后项目中使用。
- demo已经上传到github上，需要的请直接去下载或克隆:https://github.com/zty200329/RedisUtil
- redis安装 以及shell使用我这就不一一累述了，CSDN，博客园一抓一大把，今天来说说redis整合进项目吧。
- 为什么要用redis呢？ 一旦mysql内数据量，sql语句变复杂 mybatis查询速度将会非常的慢，如果第一次查询时将查询出的数据存入redis（redis的查询速度远大于mysql，内存形数据库）则在redis数据过期前 查询速度将会增快。
demo演示
- 项目跑在8080端口
此时redis里没有任何数据。。
mysql 中有8条学生信息
第一次查询 由于redis中没有数据 故要从mysql中查询我们对比第一次和第二次的所需时间。。
我查询了两次 对比第一次和第二次的时间差距 原因就是第一次查询时 从mysql中查出数据的同时存入了redis 然后第二次直接从redis中进行读取 所以时间差距如此大
可以看到现在redis里就有数据了
## yml文件
spring:
datasource:
username: root
password: 123456
url: jdbc:mysql://127.0.0.1/redis_demo?useSSL=false&characterEncoding=utf-8
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 初始化大小，最小，最大
initial-size: 5
min-idle: 5
max-active: 50
# 获取连接等待超时的时间
max-wait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
time-between-eviction-runs-millis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
min-evictable-idle-time-millis: 300000
redis:
database: 0 # Redis数据库索引（默认为0）
host: 127.0.0.1 # Redis服务器地址
port: 6379 # Redis服务器连接端口
password: # Redis服务器连接密码（默认为空）
jedis:
pool:
max-active: 200 #连接池最大连接数（使用负值表示没有限制）
max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
max-idle: 10 # 连接池中的最大空闲连接
min-idle: 0 # 连接池中的最小空闲连接
timeout: 1000 # 连接超时时间（毫秒）
servlet:
multipart:
max-file-size: 100MB
max-request-size: 100MB
enabled: true
mybatis:
mapper-locations: classpath:/mappers/*.xml
type-aliases-package: com.redis.dao
demo结构
首先加入redis的maven依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
我这使用RedisUtil工具类来对redis进行操作（封装得比较完整）
package com.redis.redis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
/**
* @author: zty
* @date 2019/9/18 下午8:40
* @description:
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate redisTemplate;
public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
//=============================common============================
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key,long time){
try {
if(time>0){
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key){
return redisTemplate.getExpire(key,TimeUnit.SECONDS);
}
/**
* 判断key是否存在
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key){
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String ... key){
if(key!=null&&key.length>0){
if(key.length==1){
redisTemplate.delete(key[0]);
}else{
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
//============================String=============================
/**
* 普通缓存获取
* @param key 键
* @return 值
*/
public Object get(String key){
return key==null?null:redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key,Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key,Object value,long time){
try {
if(time>0){
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
}else{
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta){
if(delta<0){
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta){
if(delta<0){
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
//================================Map=================================
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key,String item){
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map<Object,Object> hmget(String key){
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String,Object> map){
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String,Object> map, long time){
try {
redisTemplate.opsForHash().putAll(key, map);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key,String item,Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key,String item,Object value,long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item){
redisTemplate.opsForHash().delete(key,item);
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item){
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item,double by){
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item,double by){
return redisTemplate.opsForHash().increment(key, item,-by);
}
//============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set<Object> sGet(String key){
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key,Object value){
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object...values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key,long time,Object...values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if(time>0) expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key){
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object ...values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key,long start, long end){
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key){
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key,long index){
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index,Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key,long count,Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
数据库结构
利用mybatis-generator生成实体类和mapper映射文件（这里就不贴代码了 需要请看github）
写Service层
package com.redis.service;
import com.redis.entity.Student;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author: zty
* @date 2019/9/19 上午10:14
* @description:
*/
public interface RedisService {
int deleteByPrimaryKey(Integer id);
int insert(Student record);
Student selectByPrimaryKey(Integer id);
List<Student> selectAll();
int updateByPrimaryKey(Student record);
Student getStudent(String num);
int delete(@Param("number") String num);
}
写serviceImpl层
package com.redis.service.Impl;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.redis.dao.StudentMapper;
import com.redis.entity.Student;
import com.redis.redis.RedisUtil;
import com.redis.service.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.lang.reflect.Type;
import java.util.List;
/**
* @author: zty
* @date 2019/9/19 上午10:15
* @description:
*/
@Service
@Slf4j
public class RedisServiceImpl implements RedisService {
@Autowired
private StudentMapper studentMapper;
@Autowired
private RedisUtil redisUtil;
@Autowired
private RedisTemplate redisTemplate;
@Override
public int deleteByPrimaryKey(Integer id) {
return 0;
}
@Override
public int insert(Student record) {
String key = "student_list";
int insert = studentMapper.insert(record);
if(insert > 0){
redisUtil.del(key);
}
return insert;
}
@Override
public Student selectByPrimaryKey(Integer id) {
return null;
}
@Override
public List<Student> selectAll() {
String key = "student_list";
Boolean hasKey = redisUtil.hasKey(key);
ValueOperations operations = redisTemplate.opsForValue();
if(hasKey){
String redisList = (String) redisUtil.get(key);
Type type = new TypeToken<List<Student>>() {
}.getType();
List<Student> list = new Gson().fromJson(redisList,type);
log.info("StudentServiceImpl.selectAll() : 从缓存取得数据，条数：" + list.size());
return list;
}
List<Student> list = studentMapper.selectAll();
String toJson = new Gson().toJson(list);
// 存在到缓存中
redisUtil.set(key,toJson,600);
return list;
}
/**
*更新学生信息逻辑
* 如果缓存存在 删除
* 如果缓存不存在 不操作
* @param record
* @return
*/
@Override
public int updateByPrimaryKey(Student record) {
String key = "student_" + record.getNumber();
Boolean hasKey = redisUtil.hasKey(key);
int update = studentMapper.updateByPrimaryKey(record);
if(update>0){
//缓存存在 删除
if(hasKey){
redisUtil.del(key);
log.info("StudentServiceImpl.update() : 从缓存中删除学生 >> " + record.toString());
}
}
return update;
}
/**
* 获取一位学生的逻辑
* 如果缓存存在 从缓存中获取学生信息
* 如果缓存不存在 从DB中获取学生信息 然后插入缓存
* @param num
* @return
*/
@Override
public Student getStudent(String num) {
//从缓存中取出学生信息
String key = "student_" + num;
Boolean hasKey = redisUtil.hasKey(key);
//缓存存在
if (hasKey){
String str = (String) redisUtil.get(key);
Student student = new Gson().fromJson(str,Student.class);
log.info("StudentServiceImpl.getStudent() : 从缓存取得数据 >> " + student.toString());
return student;
}
Student student = studentMapper.getStudent(num);
String str = new Gson().toJson(student);
//插入缓存
redisUtil.set(key,str,600);
log.info("StudentServiceImpl.getStudent() : 学生信息插入缓存 >> " + student.toString());
return student;
}
@Override
public int delete(String num) {
String key = "student_" + num;
Boolean hasKey = redisUtil.hasKey(key);
int delete = studentMapper.delete(num);
if( delete > 0 ){
//判断缓存是否存在 并删除
if(hasKey){
redisUtil.del(key);
log.info("StudentServiceImpl.update() : 从缓存中删除编号学生 >> " + num);
}
}
return delete;
}
}
编写控制层
package com.redis.controller;
import com.google.gson.Gson;
import com.redis.entity.Student;
import com.redis.redis.RedisUtil;
import com.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* @author: zty
* @date 2019/9/18 下午8:59
* @description:
*/
@RestController
@RequestMapping("/redis")
public class RedisController {
@Autowired
private RedisUtil redisUtil;
@Autowired
private RedisService redisService;
@GetMapping( path = "/getList")
public List<Student> getList(){
List<Student> students = redisService.selectAll();
return students;
}
/**
* 根据学号查找学生
* @param numberCode
* @return
*/
@GetMapping("/getStudent")
public String getStu(@RequestParam("number") String numberCode){
Student students = redisService.getStudent(numberCode);
String str = new Gson().toJson(students);
return str;
}
@PostMapping(path = "/insert")
public String insert(@RequestParam Student student){
int insert = redisService.insert(student);
String msg = "";
if( insert > 0 ){
msg = "{\"msg\":\"新增成功\",\"flag\":true}";
}else {
msg = "{\"msg\":\"新增失败\",\"flag\":false}";
}
return msg;
}
@GetMapping(path = "/delete")
public String delete(@RequestParam("numberCode") String numberCode){
int delete = redisService.delete(numberCode);
String msg = "";
if( delete > 0 ){
msg = "{\"msg\":\"删除成功！！\",\"flag\":true}";
}else {
msg = "{\"msg\":\"删除失败！！\",\"flag\":false}";
}
return msg;
}
@PostMapping(path = "/update")
public String update(@RequestParam Student student){
int update = redisService.updateByPrimaryKey(student);
String msg = "";
if( update > 0 ){
msg = "{\"msg\":\"更新成功！！！\",\"flag\":true}";
}else {
msg = "{\"msg\":\"更新失败！！！\",\"flag\":false}";
}
return msg;
}
}