Spring-Boot整合Redis

已于 2023-08-31 13:45:59 修改
阅读量53 收藏
点赞数
文章标签： redis 数据库 缓存
于 2023-08-24 13:59:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwdxyc/article/details/132432735
版权

概要

Redis是一个使用ANSI C编写的开源、支持网络、基于内存、分布式、可选持久性的键值对存储数据库，SpringBoot是一个快速开发框架。还使用了hutool java工具库

1. 添加Redis依赖

添加的pom.xml文件中，这里无需指定版本

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

2. 添加RedisUtils工具类

以下配置，您可能可以修修改改才能使用了，当然不报错您也可以不修改。

package com.cn.transfer.common.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 判断 key 是否存在
     *
     * @param key 键
     * @return 如果存在 key 则返回 true，否则返回 false
     */
    public Boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }


    /**
     * 获取 Key 的类型
     *
     * @param key 键
     */
    public String type(String key) {
        DataType dataType = redisTemplate.type(key);
        assert dataType != null;
        return dataType.code();
    }

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return 30
     */
    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;
        }
    }

    /**
     * 删除 key
     *
     * @param key 键
     */
    public Long delete(String... key) {
        if (key == null || key.length < 1) {
            return 0L;
        }
        return redisTemplate.delete(Arrays.asList(key));
    }

    /**
     * 获取所有的keys
     *
     * @return
     */
    public Set<String> keys() {

        return redisTemplate.keys("*");
    }

    /**
     * 获取所有的keys得所有的值
     *
     * @param keys
     * @return
     */
    public HashMap<Object, Object> getKeysValue(String keys) {

        Set<String> keys1 = redisTemplate.keys("*");

        HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
        for (String s : keys1) {
            Object o = redisTemplate.opsForValue().get(keys + s);
            System.out.println("o=" + o);
            hashMap.put(keys1, o);
        }
        return hashMap;
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                plDel(key);
            }
        }
    }
    public void plDel(String... keys) {
        if (keys != null && keys.length > 0) {
            List<String> keyList = Arrays.asList(keys);
            redisTemplate.delete(keyList);
        }
    }


    // ============================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 274
     */
    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 285
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return 295
     */
    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   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> getList(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 {
            return redisTemplate.opsForList().remove(key, count, value);

        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }

    }

}


/**
 * Redis 配置
 */
@Slf4j
@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;

    }
}

3. 简单的使用redis

 首先要在使用的类中注册

 @Autowired
 private RedisUtil redisUtil;

key的命名规范

  1. 把 [业务模块] 作为前缀，通过 [冒号]分隔，在加上 [具体业务名]，也就是「业务名:表名:id」
  2. Redis key一定要设置过期时间。要跟自己的业务场景，需要对key设置合理的过期时间
  3. 不bigkey(防止网络拥塞、慢查询)

  这是普通的新增String类型

redisUtil.set("销售:add:2","这是一个值，通过key能找到这个值");

  获取一个key的值

redisUtil.get("销售:add:2");

其余方法自行研究

用hutol解析Redis的值

// 把redis里面的字符串json字符串解析成对象
String str = ""   // 这里是一个从redis里面取出来的json字符串
JSONObject jsonObject = JSONUtil.parseObj(reult);
TokenMessage value = JSONUtil.toBean(jsonObject.getStr("value"), TokenMessage.class);

4. linux安装Redis

 要从 Redis 下载站点获取最新稳定版 Redis 的源文件，请运行：

wget https://download.redis.io/redis-stable.tar.gz

要编译 Redis，首先使用压缩包，切换到根目录，然后运行：make

tar -xzvf redis-stable.tar.gz
cd redis-stable
make

 如果编译成功，您将在目录中找到多个 Redis 二进制文件，包括：src

  • redis-server：Redis 服务器本身
  • redis-cli 是与 Redis 通信的命令行界面实用程序。

安装这些二进制文件

make install

启动 Redis

# 启动
systemctl start redis 
redis-server

# 查看状态
systemctl status redis

# 停止
systemctl stop redis

# 重启
systemctl restart redis

要停止 Redis，请输入 。Ctrl-C

查看Redis是否启动端口

ps -ef|grep redis

5. 在Linux上操作Redis

# 进入客户端
redis-cli

# 成功连接并且进入客户端
127.0.0.1:6379> 

# 添加数据
127.0.0.1:6379> set test-key test-value
OK

# 查询数据
127.0.0.1:6379> get test-key
"test-value"

# 查询全部key，生成环境慎用，会全表扫描key,导致内存堵塞
127.0.0.1:6379> keys *
"test-value"

# 删除数据
127.0.0.1:6379> del test-key
(integer) 1

# 退出客户端
127.0.0.1:6379> exit

开启远程连接(不建议开启远程，易被攻击)

# 进入并编辑redsi.conf文件
vim /etc/redis.conf

# 找到bind 127.0.0.1 将其注释（#）或修改为 bind 0.0.0.0
bind 0.0.0.0

# 为了安全，我们需要开启密码保护
# 找到 # requirepass xxx ，默认是被注释的，将注释符号去掉，并添加自己的密码
requirepass 123456

# 按 esc 键，并输入 :wq 保存

# 重启，让配置生效
systemctl restart redis

在服务器商的控制台-服务器-安全组-开发6379端口，不然无法远程登录

6. 使用hutool和Redis遇到的问题

错误内容： 

No serializer found for class cn.hutool.json.JSONNull and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: java.util.HashMap["result"]->cn.hutool.json.JSONObject["data"]->cn.hutool.json.JSONArray[0]->cn.hutool.json.JSONObject["deleter"])

解决方法:

加上序列化器

import cn.hutool.json.JSONNull;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.boot.jackson.JsonComponent;

import java.io.IOException;

/**
 * @author Administrator
 */
@JsonComponent
public class JsonNullSerializer extends JsonSerializer<JSONNull> {
    @Override
    public void serialize(JSONNull jsonNull, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeNull();
    }
}

熙攘的人海
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring-boot-整合redis
03-08
pdf详细步骤介绍spring-boot-整合redis如何实现 添加依赖：在项目的构建文件（如pom.xml）中加入spring-boot-starter-data-redis依赖，这是整合Redis的基础。 配置Redis连接：在application.properties或application...
Redis--7.spring-boot整合redis
qq_46492246的博客
07-27 646
1.简介 spring-data是和spring-boot齐名的项目，在spring-data中有jpa，jdbc，redis，mongodb等数据持久化方式，对于redis，springboot2.x开始将jedis替换成了lettuce。 jedis :采用的直连,多个线程操作的话,是不安全的,如果想要避免不安全的,使用jedis pool 连接池!BIO模式 lettuce :采用netty ,实例可以再多个线程中进行共享,不存在线程不安全的情况!减少线程数量，NIO模式 2.配置redis （
spring-boot整合redis
一叶知春秋
10-27 155
如果下载了项目还是无法使用，可以留言，我可以整理一份说明文档帮助大家快速掌握主流技术在工作中更快提升能力加薪加鸡腿。如果没有安装过Redis服务器，可以搜索我的博客有介绍如何安装单机redis和集群redis。 GITHUB:https://github.com/superRabbitMan/spring-boot-redis...
Spring Boot3整合Redis
最新发布
蒾酒的博客
02-07 6439
⛰️个人主页: 蒾酒🔥系列专栏：《spring boot实战》目录前置条件1.导依赖2.配置连接信息以及连接池参数3.配置序列化方式4.编写测试已经初始化好一个spring boot项目且版本为3X，项目可正常启动。作者版本为3.2.2初始化教程：新版idea(2023)创建spring boot3项目-CSDN博客https://blog.csdn.net/qq_62262918/article/details/135785412?spm=1001.2014.3001.5501pom.xml:
【SpringBoot】整合Redis（使用spring-boot-starter-data-redis）
qq_27579471的博客
08-03 8990
前言 Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。 Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server，多线程环境下非线
spring-boot整合redis（多数据源）
赶路人儿
04-29 2378
官网：https://spring.io/projects/spring-data-redis Spring Data Redis是Spring Data系列的一部分，可轻松配置并从Spring应用程序访问Redis，并支持low-level和hight-level的抽象接口。可以看到spring data下面共提供了如下技术方案： 市面上已经有 Redis、Redisson、Lettuce 等优秀的 Java Redis 工具库，为什么还要有 Spring Data Redis 呢？ 对于下层，
springboot整合spring-data-redis遇到的坑
08-30
使用springboot整合redis,使用默认的序列化配置,然后使用redis-client去查询时查询不到相应的key.问题出在哪，怎么解决呢？下面小编给大家带来了springboot整合spring-data-redis遇到的坑，需要的的朋友参考下吧
spring-boot-shiro-redis整合源码
08-03
spring-boot-shiro-redis 整合源码
spring-boot-redis.zip
07-20
spring-boot整合MySQL，mybatis，redis
spring-boot mybaits shiro redis整合
05-14
注解redis缓存数据，Spring-session和redis实现分布式session同步(建议按功能模块划分系统)。 6、日志 =========== logback打印日志，业务日志和调试日志分开打印。同时基于时间和文件大小分割日志文件。 9、...
Spring-Boot-Redis-Session：Spring Boot整合Redis与Session共享
02-13
Spring-Boot-Redis-Session Spring Boot整合Redis，详情请查看依赖Spring Boot依赖（创建项目时选择） Sprint Boot2.1.5.RELEASE由于spring-boot-starter-parent 2.1.5.RELEASE中的会话需要安全性支持，故此需要约会...
spring-boot-mybatis-redis.zip
08-13
简单的springboot项目，版本2.0.1，有统一返回，统一异常处理，单元测试，列表分页，整合了mybatis和redis（参考）
spring-boot mybaits spring security redis整合
05-14
注解redis缓存数据，Spring-session和redis实现分布式session同步(建议按功能模块划分系统)。 6、日志 =========== logback打印日志，业务日志和调试日志分开打印。同时基于时间和文件大小分割日志文件。 9、...
Spring boot 整合 redis
06-15
Spring boot 整合 redis 在redis 中填写配置信息，就可以测试存取值
Spring Boot 整合 Redis.docx
11-20
Spring Boot 整合 Redis
spring-boot+redis+mybatis.zip
07-30
springboot框架项目案例，整合redis，mybatis， pom文件已包含所有用到的依赖，直接更新maven即可。
spring-boot-api-project-seed:Spring Boot API Project Seed 是一个基于Spring Boot & MyBatis的种子项目，可作为权限脚手架项目，集成Shiro+Redis+JWT+MyBatis-Plus
05-14
简介Spring Boot API Project Seed 是一个基于Spring Boot & MyBatis的种子项目，用于快速构建中小型API、RESTful API项目，该种子项目已经有过多个真实项目的实践，稳定、简单、快速，使我们摆脱那些重复劳动，专注...
spring-boot-mybatis-redis:spring boot+mybatis+redis数据缓存整合
04-30
spring-boot-mybatis-redisspring boot+mybatis+redis数据缓存整合
为什么引入的spring-data-redis和spring-boot-starter-data-redis不一致
06-03
因为Spring Boot会对`spring-data-redis`进行封装和整合，所以在使用`spring-boot-starter-data-redis`时，可以不必关心`spring-data-redis`的具体版本，只需要关注`spring-boot-starter-data-redis`的版本即可。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值