Springboot集成Redis(Jedis+RedisTemplate)

最新推荐文章于 2024-06-23 17:28:51 发布
最新推荐文章于 2024-06-23 17:28:51 发布
阅读量1k 收藏 2
点赞数
分类专栏： web 文章标签： java spring boot redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45453266/article/details/104712678
版权

talk is cheap,show you my code

源码:springboot-redis-crud

方法一:使用jedis(Jedis是Redis官方推荐的面向Java的操作Redis的客户端,详细文档可见jedis文档)

0.当然，首先你要先安装redis数据库,不会安装的自行百度(ubuntu:apt-get install redis-server)

1.创建Springboot项目

2.在pom文件中导入jedis和fastjason的依赖(因为redis存储的方式为二进制存储，所以使用fastjson进行序列化)

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.50</version>
        </dependency>

3.在application.properties中配置redis相关参数

#redis
redis.host=127.0.0.1
redis.port=6379
redis.password=#你自己的数据库密码，默认为空
redis.timeout=2000
redis.poolMaxTotal=10
redis.poolMaxIdle=10
reids.poolMaxWait=3
redis.db=0

4.创建redis包，在包下新建RedisConfig类

package com.wantao.jedis.redis;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
 * Redis的配置类
 */
@Component
@ConfigurationProperties(prefix = "redis")
@Data
public class RedisConfig {
    private String host;
    private int port;
    private String password;
    private int timeout;
    private int poolMaxTotal;
    private int poolMaxIdle;
    private int poolMaxWait;
    private int db;
}

5.在包下新建RedisPoolFactory类,用来获取JedisPool对象，进而通过jedisPool.getResource()方法获得Jedis对象

package com.wantao.jedis.redis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
 *创建RedisPool对象
 */
@Component
public class RedisPoolFactory {
    @Autowired
    private RedisConfig redisConfig;
    @Bean
    public JedisPool getJedisPool(){
        JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
        jedisPoolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait());
        jedisPoolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
        JedisPool jp=new JedisPool(jedisPoolConfig,redisConfig.getHost(),redisConfig.getPort(),
                redisConfig.getTimeout(),redisConfig.getPassword(),redisConfig.getDb());
        return jp;
    }
}

6.在包下新建RedisService类，通过Jedis操纵Redis

package com.wantao.jedis.redis;
import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
 * 通过Jedis操作Redis
 */
@Service
public class RedisService {
    @Autowired
    JedisPool jedisPool;
   /**
     * 获取对象
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(String key, Class<T> clazz) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = jedis.get(key);
            T t = stringToBean(str, clazz);
            return t;
        }finally {
            closeJedis(jedis);
        }
    }
  /**
     * 设置对象
     * @param key
     * @param value
     * @param <T>
     * @return
     */
    public <T> boolean set(String key,T value){
        Jedis jedis=null;
        try {
            jedis=jedisPool.getResource();
            String str=beanToString(value);
            if (str==null||str.length()<=0){
                return false;
            }
            jedis.set(key,str);
            return true;
        }finally {
            closeJedis(jedis);
        }
    }
  /**
     * 删除
     * @param key
     * @return
     */
    public boolean delete(String key){
        Jedis jedis=null;
        try{
            jedis=jedisPool.getResource();
            long ret=jedis.del(key);
            return ret>0;
        }finally {
            closeJedis(jedis);
        }
    }
 /**
     * 判断key是否存在
     * @param key
     * @param <T>
     * @return
     */
    public <T> boolean exists(String key){
        Jedis jedis=null;
        try{
            jedis=jedisPool.getResource();
            return jedis.exists(key);
        }finally {
            closeJedis(jedis);
        }
    }
  /**
     * 增加值
     * @param key
     * @param <T>
     * @return
     */
    public<T> Long incr(String key){
        Jedis jedis=null;
        try{
            jedis=jedisPool.getResource();
            return jedis.incr(key);
        }finally {
            closeJedis(jedis);
        }
    }
    /**
     * 减少值
     * @param key
     * @param <T>
     * @return
     */
    public<T> Long decr(String key){
        Jedis jedis=null;
        try{
            jedis=jedisPool.getResource();
            return jedis.decr(key);
        }finally {
            closeJedis(jedis);
        }
    }
 /**
     * 关闭jedis
     * @param jedis
     */
    private void closeJedis(Jedis jedis) {//用完记得要关闭
        if (jedis != null) {
            jedis.close();
        }
    }
  /**
     * 将String转换为其他对象
     *
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    private <T> T stringToBean(String str, Class<T> clazz) {
        if (str == null || str.length() <= 0 || clazz == null) {
            return null;
        }
        if (clazz == int.class || clazz == Integer.class) {
            return (T) Integer.valueOf(str);
        } else if (clazz == String.class) {
            return (T) str;
        } else if (clazz == long.class || clazz == Long.class) {
            return (T) Long.valueOf(str);
        } else {
            return JSON.toJavaObject(JSON.parseObject(str), clazz);
        }
    }
 /**
     * 将其他对象转换为String
     * @param value
     * @param <T>
     * @return
     */
    private <T> String beanToString(T value) {
        if (value == null) {
            return null;
        }
        Class<?> clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class) {
            return "" + value;
        } else if (clazz == String.class) {
            return (String) value;
        } else if (clazz == long.class || clazz == Long.class) {
            return "" + value;
        } else {
            return JSON.toJSONString(value);
        }
    }
}

7.建立result包,新建Result类,将返回的json封装，更好的展示

package com.wantao.jedis.result;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.HashMap;
import java.util.Map;
/**
 * 返回的Json数据封装
 */
@Data
@NoArgsConstructor
public class Result{
    private Integer code;
    private String msg;
    private Map<String, Object> data = new HashMap<String, Object>();
    /**
     * 成功时调用
     * 默认状态码:200
     */
    public static Result success() {
        Result result = new Result();
        result.setCode(200);
        result.setMsg("处理成功");
        return result;
    }
    /**
     * 失败时调用
     * 默认状态码:500
     */
    public static Result error() {
        Result result = new Result();
        result.setCode(500);
        result.setMsg("处理失败");
        return result;
    }
    /**
     * 设置数据
     * @param key
     * @param value
     * @return
     */
    public Result add(String key,Object value){
        this.data.put(key,value);
        return this;
    }
}

8.创建controller包，新建JedisController类(这里就只调用get,set方法进行测试)

package com.wantao.jedis.controller;
import com.wantao.jedis.redis.RedisService;
import com.wantao.jedis.result.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class JedisController {
    @Autowired
    private RedisService redisService;
    @GetMapping("/set")
    @ResponseBody
    public Result set(){
        redisService.set("girlfriend","sakura");
       return Result.success();
    }
   @GetMapping("/get")
    @ResponseBody
    public Result get(){
        String str=redisService.get("girlfriend",String.class);
        return Result.success().add("girlfriend",str);
    }
}

结果截图:
set:
set
get:
get
查看redis数据库，看是否将数据插入:
在这里插入图片描述
方法二:使用RedisTemplate
(RedisTemplate是SpringDataRedis中对JedisApi的高度封装。
SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache)

1.创建springboot项目

2.在pom文件中导入spring-boot-starter-data-redis依赖

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

3.在application.properties中配置redis相关的属性

#redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=#你自己的redis密码，默认为空
spring.redis.timeout=2000
spring.redis.jedis.pool.max-active=10
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-wait=3
spring.redis.database=0

4创建redis包,新建RedisUtil类，用来创建RedisTemplate或者StringRedisTemplate对象(RedisTemplate和StringRedisTemplate的区别)

package com.wantao.redistemplate.redis;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * StringRedisTemplate与RedisTemplate区别点
 * 两者的关系是StringRedisTemplate继承RedisTemplate。
 *
 * 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
 *
 * 其实他们两者之间的区别主要在于他们使用的序列化类:
 * 　　　　RedisTemplate使用的是JdkSerializationRedisSerializer    存入数据会将数据先序列化成字节数组然后在存入Redis数据库。
 *
 * 　　 　  StringRedisTemplate使用的是StringRedisSerializer
 *
 * 使用时注意事项：
 * 　　　当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可。
 * 　　　但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。
 */
@Configuration
public class RedisUtil {
    //两种reidsTemplate根据场景自由选择
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }
}

5.建立result包,新建Result类,将返回的json封装，更好的展示

package com.wantao.redistemplate.result;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.HashMap;
import java.util.Map;
/**
 * 返回的Json数据封装
 */
@Data
@NoArgsConstructor
public class Result {
    private Integer code;
    private String msg;
    private Map<String, Object> data = new HashMap<String, Object>();
    /**
     * 成功时调用
     * 默认状态码:200
     */
    public static Result success() {
        Result result = new Result();
        result.setCode(200);
        result.setMsg("处理成功");
        return result;
    }
    /**
     * 失败时调用
     * 默认状态码:500
     */
    public static Result error() {
        Result result = new Result();
        result.setCode(500);
        result.setMsg("处理失败");
        return result;
    }
    /**
     * 设置数据
     * @param key
     * @param value
     * @return
     */
    public Result add(String key,Object value){
        this.data.put(key,value);
        return this;
    }
}

6.创建controller包，新建redisTemplateController，进行get，set方法测试

package com.wantao.redistemplate.controller;
import com.wantao.redistemplate.redis.RedisService;
import com.wantao.redistemplate.result.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class redisTemplateController {
    @Autowired
    private RedisService redisService;
    @GetMapping("/set")
    @ResponseBody
    public Result set(){
        redisService.set("boyfriend","selenium");
       return Result.success();
    }
    @GetMapping("/get")
    @ResponseBody
    public Result get(){
        String str=redisService.get("boyfriend");
        return Result.success().add("boyfriend",str);
    }
}

测试截图:

set:
在这里插入图片描述

get:
在这里插入图片描述
在redis中查看:
在这里插入图片描述

源码:springboot-redis-crud

Selenium399
关注
专栏目录
SpringBoot第42讲：SpringBoot集成Redis - 基于RedisTemplate+Lettuce数据操作
Jet_qi的博客
08-19 242
在SpringBoot 2.x版本中Redis默认客户端是Lettuce，本文是SpringBoot第42讲，主要介绍SpringBoot 和默认的 Lettuce 是一个可伸缩线程安全的 Redis 客户端。多个线程可以共享同一个 RedisConnection。它利用优秀 netty NIO 框架来高效地管理多个连接。Github官网支持 同步、异步、响应式 的方式支持 Redis Sentinel支持 Redis Cluster支持 SSL 和 Unix Domain Socket 连接支持
SpringBoot第41讲：SpringBoot集成Redis - 基于RedisTemplate+Jedis的数据操作
Jet_qi的博客
08-18 211
Redis是最常用的KV数据库，Spring 通过模板方式（RedisTemplate）提供了对Redis的数据查询和操作功能。本文是SpringBoot第41讲，主要介绍基于RedisTemplate + Jedis方式对Redis进行查询和操作的案例。Jedis是Redis的Java客户端，在 SpringBoot 1.x 版本中也是默认的客户端。在 SpringBoot 2.x 版本中默认客户端是Luttuce。
springboot2.2 集成redis哨兵
scanklm的专栏
06-29 950
springboot版本2.2.0.RELEASE jedis版本 3.1.0 一、pom依赖： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.1.0</version> </dependency> <dependency> ...
SpringBoot+Jedis+RedisTemplate
qq_24407053的博客
12-06 974
那jedis就是集成了redis的一些命令操作，封装了redis的java客户端。提供了连接池管理。一般不直接使用jedis，而是在其上在封装一层，作为业务的使用。 在Spring和SpringBoot中，内置封装了RedisTemplate和StringRedisTemplate。 两者配置不同，见个人项目seckill redis: host: 127.0.0.1 timeo...
springboot 整合redis
最新发布
qq_45906101的博客
06-23 1020
如果一个主机宕机，虽然再服务器redis上已经从机上机了，故障迁移成功，但是java服务器。如果在redis中 要显示中文 可以在后边加上–raw 如果还不是中文 可以先输入。springboot3 整合swagger2和3时都会报错，可以看上边博客。springboot可以整合的，lettuce其实就被整合到了这个包里。如果我们想要是我们存储的 可以使用。可以在这里直接进行http请求。并不是我们存储的ord+序号。之后我们进入swagger。并没有检测到最新的消息。
Springboot使用RedisTemplate优雅地操作redis
Java知音
06-14 2459
点击上方“Java知音”，选择“置顶公众号”技术文章第一时间送达！作者：Janticnblogs.com/superfj/p/9232482.html技术经验交流：点击入...
Redis:Jedis的封装类：RedisTemplate在Springboot中的使用
fenghuoliuxing990124的博客
12-19 796
sdfdsaf
Springboot 使用 Jedis、RedisTemplate 整合 Redis 实现并发锁
weixin_44605704的博客
07-19 3499
代码实现 1、maven依赖pom.xml <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data...
SpringBoot集成Redis
02-26
SpringBoot集成Redis是一个常见的开发需求，它使得应用可以利用Redis的高性能、内存存储特性进行数据缓存和快速访问。在本项目中，我们将探讨如何在SpringBoot应用中配置和使用Redis，以及如何利用Redis实现登录缓存...
Springboot+redis+mybatisplus实例
03-07
Spring Boot提供`RedisTemplate`和`StringRedisTemplate`用于操作Redis，也可以使用` lettuce`或`Jedis`客户端库。此外，Spring Session可以利用Redis来实现会话共享，提高分布式应用的用户体验。 **Spring Boot...
Springboot集成Redis
12-21
SpringBoot集成Redis提供了便捷的方式，通过简单的配置和`RedisTemplate`，开发者可以轻松地实现数据缓存和快速读写。在实际应用中，根据业务需求，合理利用Redis的特性，可以显著提升系统的响应速度和并发能力。...
SpringBoot整合Redis——两种方式（Jedis、RedisTemplate）
linchaoyang_的博客
05-18 1万+
前言 redis是一种nosql数据库，以<key，value>的形式存储数据，其速度相比于MySQL之类的数据库，相当于内存读写与硬盘读写的差别，所以常常用作缓存。接下来就分别看看在springboot项目中如何使用redis 本篇基于SpringBoot + Redis实现数据缓存以及分库存储，首先我们要知道，SpringBoot整合Redis有两种方式，分别是Jedis和RedisTemplate，这两者有何区别？ Jedis是Redis官方推荐的面向Java的操作Redis的客户端
python使用redis_Python使用redis介绍
weixin_39791225的博客
11-20 117
一、Redis的介绍redis是业界主流的key-value nosql 数据库之一。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此...
springboot自定义RedisTemplate并使用jedis配置连接池
weixin_45630446的博客
05-13 8784
springboot自定义RedisTemplate并使用jedis配置连接池 使用Jedis线程池可以不需要创建新的Jedis对象连接Redis，可以大大减少对于创建和回收Redis连接的开销 @Primary： 当出现相同名字的bean是，优先使用使用了 @Primary 注解的bean 下面开始使用： 1、第一步我们需要导入相应的jar包 <!-- redis--> <dependency> <groupId>o
spring boot使用Jedis整合Redis
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
02-11 760
实际项目开发中，我们会先从redis中获取指定数据，如果redis中没有该数据，那么我们再从mysql数据库中取出该数据。并且为了下次能直接从redis中取出该数据，需要将从mysql中取出的数据添加到redis中。由于前面我指定了string作为redis的存储结构，所以需要将从mysql中取出的数据通过json解析工具解析成string，然后再添加进redis中。
SpringBoot集成redis的JedisCluster和RedisTemplate 实现redis的消息队列消费者-生产者模式，订阅者发布者模式
热门推荐
CNZYYH的博客
01-03 1万+
一般来说，消息队列有两种场景，一种是发布者订阅者模式，一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。 定义： 生产者消费者模式 ：生产者生产消息放到队列里，多个消费者同时监听队列，谁先抢到消息谁就会从队列中取走消息；即对于每个消息只能被最多一个消费者拥有。 发布者订阅者模式：发布者生产消息放到队列里，多个监听队列的消费者都会收到同一份消息；即正常情况下每个消费者收到的消息...
Spring集成Redis的两种方式Jedis和RedisTemplate
kagurawill的博客
05-06 5070
Redis一种非关系型（K-V）数据库，也习惯称为Redis缓存，类似memcached，但相对与memcached又有着以下优点： Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 Redis支持数据的备份，即master-slave模式的数据备份。 Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 ...
SpringBoot+redis RedisTemplate/jedis 配置多个数据源 灵活切库 选择库
weixin_45220510的博客
06-26 3744
SpringBoot+redis RedisTemplate/jedis 配置多个数据源 灵活切库 选择库 1.加入依赖并在在yml 文件里面加入配置spring:redis:host: urlport: 6379pool:database:db10: 10db4: 4我这里选择redis的 10号库和4号库，如果不同 请自行添加 db0:0 比如再添加一个0号库使用2.添加配置文件/***/@Bean// 配置redis连接池// 构建工厂对象.build();// 设置使用的redis数据库。
SpringBoot系列教程之RedisTemplate Jedis配置说明文档
weixin_33939843的博客
12-28 810
更多Spring文章，欢迎点击 一灰灰Blog-Spring专题 SpringBoot2之后，默认采用Lettuce作为redis的连接客户端，当然我们还是可以强制捡回来，使用我们熟悉的Jedis的，本篇简单介绍下使用Jedis的相关配置 原文链接: 181101-SpringBoot高级篇Redis之Jedis配置 I. 基本配置 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Selenium399

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

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

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

打赏作者

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

抵扣说明：

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

余额充值