SpringBoot集成Redis

最新推荐文章于 2024-03-17 23:57:01 发布
最新推荐文章于 2024-03-17 23:57:01 发布
阅读量1.8k 收藏 49
点赞数 19
分类专栏： redis Spring Boot 文章标签： redis spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzy410992/article/details/116129636
版权

原理分析

首先，先查看Redis相关的配置类：
在这里插入图片描述
shift+shift进行搜索，查看RedisAutoConfiguration类：
在这里插入图片描述

在我们查看redis的配置类RedisAutoConfiguration时，可以看到RedisAutoConfiguation中封装了两个Bean：
在这里插入图片描述

接下来查看redis所对应的自动配置类：RedisProperties，该类对应一个properties配置文件，当然我们也可以在application中进行配置：
在这里插入图片描述

在SpringBoot操作数据是封装在Spring-data中的，jpa、jdbc、mongodb、redis，而在SpringBoot2.x以后与原来使用的jedis被替换成来看lettuce，底层已经不使用jedis了

  • jedis： 采用的直连，多个线程操作的话，不安全，要提高安全性要使用jedis pool连接池
  • lettuce： 采用netty，高性能网络框架，异步请求，实例在多线程中可以共享，不存在线程不安全的情况，dubbo底层也是用netty，可以减少线程数量，更像NIO模式

整合实现

导入依赖pom.xml：

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

编写配置文件applacation.yml：

spring:
    redis:
      host: 127.0.0.1 # Redis服务器地址
      port: 6379      # Redis服务器连接端口
      password:    # Redis服务器连接密码（默认为空）
      database: 0  # Redis数据库索引（默认为0）
      jedis:
        pool:
          max-active: 8   # 连接池最大连接数（使用负值表示没有限制）
          max-wait: -1ms  # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-idle: 500   # 连接池中的最大空闲连接
          min-idle: 0      # 连接池中的最小空闲连接
      lettuce:
        shutdown-timeout: 0ms
      timeout: 1000 # 连接超时时间（毫秒）

测试：

@SpringBootTest
public class SpringbootRedisTest {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("key1","value1");
        redisTemplate.opsForValue().set("key2","张三");
        System.out.println("key1="+redisTemplate.opsForValue().get("key1"));
        System.out.println("key2="+redisTemplate.opsForValue().get("key2"));
    }

}

运行结果：
在这里插入图片描述

查看RedisTemplate类：
在这里插入图片描述

测试代码：

@Test
public void test() throws JsonProcessingException {
    //真实开发一般有使用json传递对象
    User user =new User();
    user.setName("龙源");
    user.setAge(10);
    String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user",jsonUser);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

//新建一个User类
@Component
public class User implements Serializable {//需要序列化Serializable
    private String name;
    private int age;
    
    /**
     * Get，Set，toString
     **/
}

运行结果：
在这里插入图片描述
在客户端进行查看：发现user对象前面有转义字符
在这里插入图片描述

序列化

编写配置类，自定义RedisTemplate，修改默认的序列化方式：

@Configuration
public class RedisConfig {

  @Bean
  @SuppressWarnings("all")
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
      //为了方便开发，使用<String,Object>
      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
      template.setConnectionFactory(factory);
      
      //Json序列化配置
      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);
      
      //String的序列化
      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;
  }

}

再次测试：

//为了方便识别可以修改：RedisTemplate
@Autowired
//private RedisTemplate redisTemplate;
private RedisTemplate<String,Object> redisTemplate;

@Test
public void test() throws JsonProcessingException {
    //真实开发一般有使用json传递对象
    User user =new User();
    user.setName("龙源");
    user.setAge(10);
    String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user",jsonUser);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

运行结果：
在这里插入图片描述

自定义工具类：

在真实开发中，一般不会使用原生的API而是使用自己封装的工具类RedisUtil

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    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)
     */
    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)
     */
    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
     */
    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 对应多个键值
     */
    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)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    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 键
     */
    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代表所有值
     */
    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 键
     */
    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倒数第二个元素，依次类推
     */
    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 值
     */
    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  时间(秒)
     */
    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;
        }
    }

}
龙源lll
关注
  • 19
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
spring boot + redis4.0.2 详细案例
jamesi987的博客
11-19 837
本文大纲        1.从无到有。在centos7 中安装redis4.0        2.spring boot 配置 redis 案例 一：在centos7 中安装redis4.0        1.安装 oracle vm virtualBox 虚拟机。            下载地址：http://download.virtualbox.org/virtualbo
04.SpringBoot整合Redis
Lionel_SSL的博客
09-25 301
【代码】03.Jedis使用。
Spring Boot集成Redis
最新发布
2201_75571478的博客
03-17 820
如果你需要存储复杂的对象，并且不介意数据在Redis中以二进制形式存储，那么RedisTemplate可能更适合你。在 Spring Boot 应用程序中，配置 Redis 连接工厂通常很简单，因为 Spring Boot 提供了自动配置的功能，可以自动检测并配置 Redis 连接工厂。如果你使用 Lettuce，配置将略有不同，因为 Lettuce 使用不同的连接池和配置方式。StringRedisTemplate是专门为字符串数据设计的模板类，可见性强，易于维护，主要用于大部分以字符串存储的数据。
SpringBoot学习笔记十一：springBoot整合redis4.x
公子&小白的博客
01-08 463
1. SpringBoot学习笔记十一：springBoot整合redis4.x 文章目录1. SpringBoot学习笔记十一：springBoot整合redis4.x1.1. 配置Redis4.x1.2. redis的其他操作技巧1.3. SpringBoot测试项目中的redis 1.1. 配置Redis4.x 引入依赖 <!-- https://mvnrepository.com...
redis-04：jedis与SpringBoot整合
weize_hh的博客
02-07 101
使用Java来操作Redis，Jedis是Redis官方推荐使用的Java连接redis的客户端。 1.导入依赖 2.启动redis服务，测试连接 public class TestPing { //测试 redis连接 public static void main(String[] args) { Jedis jedis = new Jedis("127.0.0.1",6379); System.out.println( jedis.pin
springboot整合jedis
super的博客
03-05 1万+
在开始整合之间先来回答三个问题 1、什么是jedis 2、它解决了什么问题 3、如何使用 基本上所有的技术都可以用这三问快速入门 答1： jedis集成了redis的一些命令操作，封装了redis的java客户端。提供了连接池管理。 答2：jedis提供了更为方便的redis操作，类别mybatis、hibernate等框架合数据库直接的关系 答3 : 本文的主题，我们通过sprin...
springBoot集成redis
03-03
springBoot+mybatis+redis集成，不上代码要确保redis服务端已经运行
Springboot集成Redis
12-21
文章目录引入pom依赖配置redis引入RedisTemplate模板对redis操作编写一个测试类乱码分析及解决 引入pom依赖 org.springframework.boot spring-boot-starter-data-redis 2.2.6.RELEASE 配置redis 端口和ip地址,...
springBoot集成Redis源码
11-27
springBoot集成Redis源码,springBoot集成Redis源码,springBoot集成Redis源码
SpringBoot整合Redis
tiantiantbtb的博客
06-16 769
SpringBoot操作数据都封装在Spring-data里面 比如jpa(java持久层API) jdbc mongodb redis等等SpringData是和SpringBoot齐名的一个项目访问spring官网:spring.io lookSpringData包含整合测试,新建项目 引入Spring web和redis依赖 这里将SpringBoot版本改为 2.2.5.RELEASE 不为什么 怕出错 说明:在SpringBoot 2.x之后,原来使用的jedis被替换为lettuce
Spring Boot整合Redis
热门推荐
梁辰兴的博客
06-16 2万+
Redis是一个开源（BSD许可）的、内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件，并提供多种语言的API。Redis支持多种类型的数据结构，如 字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）与范围查询、bitmaps、 hyperloglogs 和 地理空间（geospatial）、索引半径查询。
spring整合redis和jedis客户端问题
qq_20650615的博客
10-11 268
在spring整合redis和jedis客户端中，jedis的版本会对我们的整合产生影响。 org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'redisTemplate'  这里的spring是4.2.4 ，原先使用的jedis是2.8.0.从而有了上面的报错问题；首先...
Spring-Data-Redis配置详解
12-30 5317
Spring Data Redis的配置网上一大堆，不同的资料可能方法略有出入。这里笔者就记录一下自己亲配的流程吧。 首先我项目中使用了Maven。 第一步，先加个repository： maven-central Maven Repository Switchboard http://repo1.maven.org/maven2 false
springboot整合redis
欢迎一起学习交流
06-28 9077
简单来说，不过与传统数据库不同的是，也就是它是内存数据库，所以读写速度非常快，因此 Redis 被广泛应用于缓存方向。另外，（在互联网API接口中，由于网络超时、手动刷新等经常导致客户端重复提交数据到服务端）比如说添加一次和添加多次结果是一样的，只会执行一次如何防止重复提交：用注解 + AOP。通过在自定义注解里定义一些相关的字段，比如过期时间即该时间内同一用户不能重复提交请求。然后把注解按需加在接口上，最后在拦截器里判断接口上是否有该接口，如果存在则拦截。
社区网站项目4.2 Spring整合Redis
xiaoshuzi666的博客
07-03 164
  引入依赖spring-boot-starter-data-redis。   配置Redis （1）配置数据库参数 （2）编写配置类，构造RedisTemplate   访问Redis （1）redisTemplate.opsForValue() （2）redisTemplate.opsForHash() （3）redisTemplate.opsForList() （4）redisTemplate.opsForSet() （5）redisTemplate.opsForSet() （6）redisTempl
Redis学习(四)之Springboot整合Redis
weixin_43636205的博客
08-25 270
redis学习
SpringBoot整合Jedis
wenkezhuangyuan的博客
08-06 1万+
我们在使用springboot搭建微服务的时候，在很多时候还是需要redis的高速缓存来缓存一些数据，存储一些高频率访问的数据，如果直接使用redis的话又比较麻烦，在这里，我们使用jedis来实现redis缓存来达到高效缓存的目的。 但是首先，我们需要了解一下什么是jedis，jidis是redis的客户端。以下介绍几种常用的redis客户端及其对比。 Jedis api 在线网址：http://tool.oschina.net/uploads/apidocs/redis/clients/jed.
springboot 集成 redis
08-12
- *1* *3* [SpringBoot集成redis](https://blog.csdn.net/qq_43512320/article/details/122684865)[target=&quot;_blank&quot; data-report-click={&quot;spm&quot;:&quot;1018.2226.3001.9630&quot;,&quot;extra&quot;:{&quot;utm_source&quot;:&quot;vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙源lll

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值