springboot2.1.3 + redisTemplate 操作 redis 3.0.5

近期在整合springboot + redis 的功能，本来想用原生的jedit api，最后想想有点 low，搜了一把，boot已经提供给我们操作的方法，那就是

使用 redisTemplate 或 StringRedisTemplate， 两者是有区别的，可以看下面的说明

1. 两者的关系是StringRedisTemplate继承RedisTemplate。

2. 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。

3. SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。

StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。

RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。

引自： https://blog.csdn.net/yifanSJ/article/details/79513179

好了，有关概念的解释不在此处详细说明，这里只是记录如何快速搭建和实现操作redis，先看下我的工程结构，如图：

引入相关jar包，pom.xml如下：

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.1</version><!--$NO-MVN-MAN-VER$-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.8</version><!--$NO-MVN-MAN-VER$-->
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.8</version><!--$NO-MVN-MAN-VER$-->
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version><!--$NO-MVN-MAN-VER$-->
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.2</version><!--$NO-MVN-MAN-VER$-->
        </dependency>

    </dependencies>

配置Redis参数 application.properties：

# 配置redis参数
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器连接密码（默认为空）
spring.redis.password=
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# 连接超时时间，单位（毫秒）
spring.redis.timeout=5000
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=200
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0
# 集群
#spring.redis.cluster.nodes=192.168.211.134:7000,192.168.211.134:7001,192.168.211.134:7002
#spring.redis.cluster.max-redirects=6

创建RedisConfiguration类：

package com.szl.demo.common.util;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.*;

@EnableCaching
@Configuration
public class RedisConfiguration extends CachingConfigurerSupport {

    /**
     * @param connectionFactory
     * @return
     * @desc redis模板，存储关键字是字符串，
     *       值jackson2JsonRedisSerializer是序列化后的值
     */
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(connectionFactory);

        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
                                new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        RedisSerializer redisSerializer = new StringRedisSerializer();
        // key
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        // value
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

DTO 类：

package com.szl.demo.common.dto;

import java.io.Serializable;
import lombok.Data;

@Data
public class UserDto implements Serializable {
    private static final long serialVersionUID = -8858511759866491158L;

    private String userName;
    private Integer userAge;

}

UserService接口：

package com.szl.demo.service;

import com.szl.demo.common.dto.UserDto;

public interface UserService {

    /**
     * @param userDto
     * @desc 将字符串保存到redis中
     */
    public void saveUserInfoToRedis();

    /**
     * @param key
     * @return
     * @desc 从redis中读取字符串
     */
    public String getUserInfoFromRedis(String key);

    /**
     * @param userDto
     * @desc 将对象保存到redis中
     */
    public void saveUserObject(UserDto userDto);

    /**
     * @param userName
     * @return
     * @desc 从redis中获取对象
     */
    public UserDto findUserObject(String userName);

}

UserServiceImpl实现接口：

package com.szl.demo.service.impl;

import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.szl.demo.common.dto.UserDto;
import com.szl.demo.service.UserService;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * @param userDto
     * @desc 将字符串保存到redis中
     */
    public void saveUserInfoToRedis() {
        // 判断redis中是否存在key
        boolean isExist = redisTemplate.hasKey("demo哈哈");
        if (!isExist) {
            // 保存key，有效期为30秒
            redisTemplate.opsForValue().set("demo哈哈", "abc123", 60, TimeUnit.SECONDS);
        } else {
            // 删除key
            redisTemplate.delete("demo哈哈");
        }
    }

    /**
     * @param key
     * @return
     * @desc 从redis中读取字符串
     */
    public String getUserInfoFromRedis(String key) {
        String val = (String)redisTemplate.opsForValue().get(key);
        return val;
    }

    /**
     * @param userDto
     * @desc 将对象保存到redis中
     */
    public void saveUserObject(UserDto userDto) {
        // 判断redis中是否存在key
        boolean isExist = redisTemplate.hasKey(userDto.getUserName());
        if (!isExist) {
            // 保存key，有效期为30秒
            redisTemplate.opsForValue().set(userDto.getUserName(), userDto, 60, TimeUnit.SECONDS);
        } else {
            // 删除key
            redisTemplate.delete(userDto.getUserName());
        }
    }

    /**
     * @param userName
     * @return
     * @desc 从redis中获取对象
     */
    public UserDto findUserObject(String userName) {
        UserDto userDto = (UserDto) redisTemplate.opsForValue().get(userName);
        return userDto;
    }

}

Controller类：

package com.szl.demo.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import com.szl.demo.common.dto.UserDto;
import com.szl.demo.service.UserService;

@Controller
public class DemoController {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "/saveUser", method = RequestMethod.POST)
    public void saveUser(HttpServletRequest request, HttpServletResponse response, ModelMap model) {
        userService.saveUserInfoToRedis();
    }

    @RequestMapping(value = "/getUserInfo", method = RequestMethod.GET)
    public void getUserInfo(HttpServletRequest request, HttpServletResponse response,
            @RequestParam(value = "key", required = false) String key) {
        String msg = userService.getUserInfoFromRedis(key);
        System.out.println(msg);
    }

    @RequestMapping(value = "/saveUserObject", method = RequestMethod.POST)
    public void saveUserObject(HttpServletRequest request, HttpServletResponse response) {
        UserDto dto = new UserDto();
        dto.setUserName("Jimmy Shan");
        dto.setUserAge(21);
        userService.saveUserObject(dto);
    }

    @RequestMapping(value = "/getUserObject", method = RequestMethod.GET)
    public void getUserObject(HttpServletRequest request, HttpServletResponse response,
            @RequestParam(value = "key", required = false) String key) {
        UserDto dto = userService.findUserObject(key);
        System.out.println("姓名： " + dto.getUserName() + ", 年龄： " + dto.getUserAge());
    }

}

至此，我们就跑起来看效果了，以上是本人经过测试并通过的代码和配置，另外需要说明一点，redis服务器本人使用3.0.5， 之前在使用2.4.5的时候，总是连接死锁（win环境），折腾了许久，

最后还是更新高版本解决问题。

如有朋友参考本人的笔记，有问题可以留言，转载请注明原著，谢谢。

原文地址：https://www.cnblogs.com/jimmyshan-study/p/11007101.html

时间： 2024-11-08 21:15:14

springboot2.1.3 + redisTemplate 操作 redis 3.0.5的相关文章

Spring中使用RedisTemplate操作Redis（spring-data-redis）

Redis 数据结构简介 Redis可以存储键与5种不同数据结构类型之间的映射,这5种数据结构类型分别为String(字符串).List(列表).Set(集合).Hash(散列)和 Zset(有序集合). 下面来对这5种数据结构类型作简单的介绍: 结构类型 结构存储的值 结构的读写能力 String 可以是字符串.整数或者浮点数 对整个字符串或者字符串的其中一部分执行操作:对象和浮点数执行自增(increment)或者自减(decrement) List 一个链表,链表上的每个节点都包含了一个字

RedisTemplate操作Redis数据结构-字符串类型

SpringBoot中使用RedisTemplate执行Redis基本命令 在application.properties或application.yml文件中配置Redis spring: redis: host: 127.0.0.1 port: 6379 编写代码 package com.heaven.redis; import lombok.extern.slf4j.Slf4j; import org.junit.jupiter.api.Test; import org.junit.run

RedisTemplate操作Redis（spring-data-redis）

参看博客:https://www.cnblogs.com/songanwei/p/9274348.html 使用文档:StringRedisTemplate+RedisTemplate使用说明 原文地址:https://www.cnblogs.com/2019wxw/p/11700797.html

使用Spring Data Redis操作Redis（一）

Spring-Data-Redis项目(简称SDR)对Redis的Key-Value数据存储操作提供了更高层次的抽象,类似于Spring Framework对JDBC支持一样. 项目主页:http://projects.spring.io/spring-data-redis/ 项目文档:http://docs.spring.io/spring-data/redis/docs/1.5.0.RELEASE/reference/html/ 本文主要介绍Spring Data Redis的实际使用. 1

Java Spring mvc 操作 Redis 及 Redis 集群

本文原创,转载请注明:http://www.cnblogs.com/fengzheng/p/5941953.html 关于 Redis 集群搭建可以参考我的另一篇文章 Redis集群搭建与简单使用 Redis 是什么,能做什么 Redis 是一个开源(BSD许可),内存存储的数据结构服务器,可用作数据库,高速缓存和消息队列代理.它支持字符串.哈希表.列表.集合.有序集合,位图,hyperloglogs等数据类型.内置复制.Lua脚本.LRU收回.事务以及不同级别磁盘持久化功能,同时通过Redis

使用Spring Data Redis操作Redis（集群版）

继上一篇文章http://www.cnblogs.com/EasonJim/p/7804545.html使用Spring Data Redis操作Redis用的是单机版,如果是集群版的集成其实差别不大.主要思路如下: 1.先建立连接工厂,这个连接工厂是用来设置IP,端口,账号密码等.(在这一步时,传递一个集群的地址列表,不再是单独一个去指定) 2.通过连接工厂建立Session. 3.然后在代码上注入Session进行使用. 简要实现步骤,操作的方法和单机版的类似: 一.使用spring-dat

使用Spring Data Redis操作Redis（单机版）

Jedis是一款Java连接Redis的客户端,Spring基于Jedis进行了封装,提供了简洁的操作Redis的方法.那就是Spring Data Redis.其实后来研究发现,Spring Data Redis集成不止Jedits这一款,还有很多款,这些都可以通过注入连接工厂来去指定. 要使用Spring Data Redis需要做如下步骤的操作思路: 1.先建立连接工厂,这个连接工厂是用来设置IP,端口,账号密码等. 2.通过连接工厂建立Session. 3.然后在代码上注入Session

redis（Springboot中封装整合redis,java程序如何操作redis的5种基本数据类型）

平常测试redis操作命令,可能用的是cmd窗口 操作redis,记录一下 java程序操作reids, 操作redis的方法 可以用Jedis ,在springboot 提供了两种 方法操作 RedisTemplate 和StringRedisTemplate 两种方法的区别 可参考:https://blog.csdn.net/yifanSJ/article/details/79513179 当然 springboot 中也可以使用Jedis ,本次记录的是 如何使用RedisTemplate

Springboot2.x集成单节点Redis

Springboot2.x集成单节点Redis 说明 在Springboot 1.x版本中,默认使用Jedis客户端来操作Redis,而在Springboot 2.x 版本中,默认使用Lettuce客户端来操作Redis.Springboot 提供了RedisTemplate来统一封装了对Redis操作,开发者只需要使用RedisTemplate 就可以实现,而不用关心具体的操作实现. 准备条件 pom.xml中引入相关jar <!-- 集成Redis --> <dependency&g