springboot引入redis的使用

已于 2022-06-09 14:58:22 修改
阅读量1.7k 收藏 5
点赞数
分类专栏： 项目搭建 文章标签： redis spring boot java
于 2022-06-08 16:52:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huyujieer/article/details/125159743
版权

首先，pom文件新增依赖

<!--redis-->
  <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
<!--Slf4j-->
  <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.20</version>
  </dependency>

yml文件新增配置

redis:
  database: 0
  host: 127.0.0.1
  password:
  port: 6379
  timeout: 5000
  ssl: false

新增启动文件

@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        // 只需要run一下，就能发布一个springboot应用
        // 相当于之前将web工程发布到tomcat服务器，只是在springboot中集成了tomcat插件
        SpringApplication.run(RedisApplication.class, args);
    }
}

目录结构如图：

新增工具类文件：

@Service
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     *
     * @param key   key
     * @param value value
     * @return
     */
    public Boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置失效时间
     *
     * @param key        key
     * @param value      value
     * @param expireTime expireTime
     * @param timeUnit   timeUnit
     * @return
     */
    public Boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(keys);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }

 controller：

@RestController
@RequestMapping("/redis")
@Slf4j
public class TestController {
    @Autowired
    private RedisUtil redisUtil;

    @GetMapping("/set")
    public Boolean setKey(@RequestParam("key") String key, @RequestParam("value") Object value) {
        try {
            redisUtil.set(key, value);
        } catch (Exception e) {
            log.error("redis加入失败:{}", e.getStackTrace());
            return false;
        }
        return true;
    }

    @GetMapping("/get")
    public Object getKey(@RequestParam("key") String key) {
        try {
            return redisUtil.get(key);
        } catch (Exception e) {
            log.error("redis获取失败:{}", e.getStackTrace());
            return false;
        }
    }

}

能成功插入本地redis数据

 启动项目前，先启动本地redis.

这种方式容易有乱码，如上图

对于redis操作，springboot进行了很好的封装，那就是spring data redis。提供了一个高度封装的RedisTemplate类来进行一系列redis操作，连接池自动管理；同时将事务封装操作，交由容器进行处理.。

从图上能看出，出现乱码，因为，引用默认的RedisTemplate，它的默认序列化方式是JDK，而这种方式可读性差。

为了解决以上问题，需进行更改默认序列化：

有两种方式，一种是自定义RedisTemplate类，另一种使用 String RedisTemplate 进行序列化

先讲第二种： String RedisTemplate是spring自带的，直接引用

@Autowired
    private StringRedisTemplate stringRedisTemplate;

spring只限于字符串结构，不建议使用。

再讲自定义redisTemplate类，可以更换序列化方式：

①JdkSerializationRedisSerializer。默认方式，无需变更

直接引入即可

@Autowired
    private RedisTemplate redisTemplate;

自定义是更改为非JDK序列化，这里有以下几种选择：

①Jackson

②faskjson

③genericFastJson

其实还有一种是StringRedisSerializer，但是，我们直接引入StringRedisTemplate就解决了，无需自定义，所以这种方式多此一举，可以不讨论，但是key的赋值方式是用了string方式。

目录结构如图：

工具类依旧不动，自动注入redisTemplate

RedisConfig新增文件，代码如下：

这一步会在启动时，重写redisTemplate，所以叫自定义

package com.hyj.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
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.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
@Slf4j
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 objectMapper = new ObjectMapper();
//        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

//        //faskjskn方式序列化
//        FastJson2JsonRedisSerializer fastJson2JsonRedisSerializer = new FastJson2JsonRedisSerializer(Object.class);
//        ObjectMapper objectMapper = new ObjectMapper();
//        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//        fastJson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //String方式的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        GenericFastJsonRedisSerializer jackson2JsonRedisSerializer = new GenericFastJsonRedisSerializer();


        //------设置各模板的序列化方式------
        //设置key的序列化方式为string（不设置的话会乱码）
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        //设置value的序列化方式为json
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;
    }
}

每一种方式的变更如图：

FastJson2JsonRedisSerializer需要新增文件，内容如下：
package com.hyj.config;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;

import java.nio.charset.Charset;

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {

    private ObjectMapper objectMapper = new ObjectMapper();
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        ParserConfig.getGlobalInstance().addAccept("com.openailab.oascloud");

    }

    public FastJson2JsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz);
    }

    public void setObjectMapper(ObjectMapper objectMapper) {
        Assert.notNull(objectMapper, "'objectMapper' must not be null");
        this.objectMapper = objectMapper;
    }

    protected JavaType getJavaType(Class<?> clazz) {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

 至此，四种方式的序列化讲解完毕。

实际运行，

①Jackson序列化，list类型的数据如图：

读取：Jackson2JsonRedisSerializer报错

②FastJson2JsonRedisSerializer

 读取：

 ③GenericFastJson

下面开始数据读取：

GenericFastJson：

综上所述：推荐FastJson和genericFastJson吧，Jackson肯定是不咋推荐的，反序列化报错

 

 

原文出处：Redis之RedisTemplate配置方式(序列和反序列化)_Redis_服务器之家

大可爱_01
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot集成Redis
02-26
在本项目中，我们将探讨如何在SpringBoot应用中配置和使用Redis，以及如何利用Redis实现登录缓存功能。 首先，集成SpringBoot与Redis的关键在于添加依赖。在`pom.xml`或`build.gradle`文件中，我们需要引入Spring ...
SpringBoot中引入Redis
zhaoxinyang2000的博客
06-09 3417
SpringBoot中引入Redis
SpringBoot 引入 Redis
qq_45691577的博客
03-05 595
【代码】SpringBoot 引入 Redis。
springboot使用Redis
最新发布
yxixiOvo的博客
05-28 1090
这里选择在linux安装redis，因为Windows的redis版本比较低，并且后面学习学习部署等也会用到linux，所以建议安装一个虚拟机。别急还有反转 还有另一个大佬因为觉得很麻烦但是又不想掏钱 就写了一个脚本只要上面的大佬一更新，就自动更新 主打一个自己动手丰衣足食。4.因为前面允许了任何地址都可以访问，这样就不安全了，所以我们需要开启一个密码。解压到当前目录 注意我是进入了当前文件的 所以可以直接就解压。因为redis是由C语言编写的，所以需要由cgg的环境。
springboot使用redis
weixin_73310020的博客
04-26 5137
默认有三种方式连接redis.第一种:jedis—传统的项目–ssm第二种:lettuce:---->刚出现没有多久就被springboot整合进来。第三种:springboot连接redis。
SpringBoot项目中使用redis
qq_39176307的博客
05-10 6181
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、引入redis依赖二、配置application.properties三、编写配置类1、操作string2、操作list3、操作hash4、操作set5、操作zset完整代码总结 前言 简单介绍一下，springboot项目中如何使用redis。 一、引入redis依赖 <!-- redis依赖包 --> <dependency> <groupId>org.springframew.
SpringBoot引入Redis
qq_58024411的博客
08-17 235
简单明了的springboot里面引入redis的方式自留，springboot整合本地redis。
springBoot集成redis
03-03
首先，为了在Spring Boot项目中引入Redis，我们需要在`pom.xml`文件中添加Spring Data Redis依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 接下来，配置...
springboot与redis整合
10-26
- **添加依赖**：在SpringBoot项目中，首先需要在`pom.xml`或`build.gradle`文件中引入Redis的依赖，通常使用`spring-boot-starter-data-redis`起步依赖。 - **配置Redis**：在`application.properties`或`...
springboot_redis
04-03
1. **依赖添加**：首先，我们需要在Spring Boot项目的`pom.xml`或`build.gradle`文件中引入Redis相关的依赖。Spring Boot提供了自动配置支持，所以只需要添加`spring-boot-starter-data-redis`依赖即可。 ```xml <!...
springboot整合redis集群零配置
07-28
在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、端口等信息。在Spring Boot 2.1及以上版本中，我们可以利用`...
SpringBoot项目中引入Redis
weixin_46374887的博客
07-06 4828
上一篇我们搭建了一个SpringBoot项目，这一节将介绍如何引入redis。 2.添加连接配置 3.测试连接 编写一个简单的测试接口 用postman测试 上面步骤我们采用了RedisTemplate类来操作Redis，该类操作其它类型Redis数据的方法如下 为了更简便操作Redis，我们一般重新封装RedisTemplate类。 5.测试 编写测试接口 postman测试...
Java随笔 | Springboot项目中引入并使用redis（步骤）
野生猿林仔的博客
01-30 2403
在Springboot项目中使用Redis需先确保服务器（或主机）已安装Redis并开启端口。在业务层中使用Redis有两种装配方式，两者任选其一即可。
springboot引入redis
weixin_67283973的博客
02-03 1204
redis
Redis在SpringBoot中的简单应用
jingjiaohuan的博客
10-28 5711
本文作为作者学习的日志，仅供学习使用
springboot项目使用Redis
d_liangzai的博客
06-28 1008
Redis的主要作用就是缓存数据，通常，会将关系型数据库（例如MySQL等）中的数据读取出来，写入到Redis中，后续，当需要获取数据时，将优先从Redis中读取，而不是从关系型数据库中读取。(当然也可以自定义，省省吧，没必要，一个方法而已)当服务器端启动时，就读取MySQL数据库，并将相关数据写入到Redis中，使得“启动完成时，Redis中就已经存入了需要缓存的数据”，这种做法称之为“缓存预热”。第一步，既然是对redis的操作，自然要先写对redis的操作，也就是redis接口和实现类，以方便调用。
【项目搭建三】SpringBoot引入redis
herogus的博客
01-20 777
springboot引入redis，使用Spring Data Redis访问和操作redis，使用lettuce或者jedis作为连接池，使用fastjson2作为序列化方式。
SpringBoot整合Redis
2301_78008478的博客
06-11 2378
但是，每次这样的写入都会特别的繁琐，我们定义一个全局的 Redis 的配置类，以后就无需每次使用都进行序列化器的设置了。上面的代码虽然完成了对哈希的操作，但是略显繁琐，类似上面的操作我们实际中并不会去逐个的进行 put 操作，更多的应该是将一个实体类存储到 Redis 的哈希类型中。可以看到，在键的前面仍然有一些“奇怪”的字符，这些奇怪的字符就是前面看到的那些 16 进制字符。有了 Redis 的依赖之后，我们就可以在项目中很容易的使用 Redis 的 API 来对 Redis 进行操作了。
spring boot-引入Redis并封装redistemplate操作工具类
西京刀客
03-28 1760
springboot引入Redis及其使用案例

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值