SpringBoot-09-Redis

最新推荐文章于 2023-11-30 16:11:04 发布
最新推荐文章于 2023-11-30 16:11:04 发布
阅读量289 收藏
点赞数
文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43125502/article/details/106146912
版权

1.导入相关依赖(lettuce版本)

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

springboot2.0之后默认使用的不再是jedis而是lettuce了！

2.redi配置文件

# Redis数据库索引（默认为0）
spring.redis.database=0 
# Redis服务器地址
spring.redis.host=121.***.**.***
# Redis服务器连接端口
spring.redis.port=6379 
# Redis服务器连接密码（默认为空）
spring.redis.password=***

注意事项：

  • 如果你的redis在你的服务器上，那么host就为你的服务器地址
  • 如果你设置了redis的密码，那么password也需要设置
  • 想要本地使用服务器上的redis还需要以下四个配置
    • 打开你的redis配置文件 vim redis.config
    • bind 127.0.0.1 将这句注视掉（他指定了唯一访问端口，默认是本机。注释掉之后意味着可以远程访问）
    • protected-mode no 把yes改成no （允许外网访问）
    • daemonize yes 把no改成yes （后台运行）
    • firewall-cmd --zone=public --add-port=6379/tcp --permanent （开启防火墙端口，记得重启防火墙firewall-cmd --reload才会生效）

3.简单源码分析

在autoConfig里面找到redis的配置类

public class RedisAutoConfiguration {

	@Bean
//这个注释的意思是如果自己没有定义redisTemplate的类，那么就使用默认的
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}

可以看到配置类里面提供了两个Template，可以方便我们快速使用。由于redis是string类型的数据库，因此StringRedisTemplate使用更多一些。
实例化之后有很多自带的方法，能够非常方便的进行操作。

4.在test中进行简单测试

@SpringBootTest
class Springboot11RedisApplicationTests {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Test
    void contextLoads() {
        stringRedisTemplate.opsForValue().set("name","lucius");
        System.out.println(stringRedisTemplate.opsForValue().get("name"));
    }
}

此时在服务器中进行查询，也能够争取查询到相关数据。
说明：
如果使用的是RedisTemplate，那么我们在服务器上查询的结果往往是\xac\xed\x00\x05t\x00\这种情况，原因是什么呢？
RedisTemplate模板类在操作redis时默认使用存取序列化的方式为org.springframework.data.redis.serializer.JdkSerializationRedisSerializer来进行序列化。
StringRedisTemplate模板类在操作redis时默认使用存取序列化的方式为org.springframework.data.redis.serializer.StringRedisSerializer 会自动去掉\xac\xed\x00\x05t\x00前缀
解决这种问题的方法有两种：

  • 直接使用StringRedisTemplate
  • 修改RedisTemplate的序列化方式,或者自定义RedisTemplate

在实际应用场景中我们都会自定义一个RedisTemplate和Redis工具类，从而避免了使用原生API进行操作
自定义一个redis的配置类，在里面定义我们的RedisTemplate

@Configuration
public class redisConfig {
    /**
     * 由于原生的redis自动装配，在存储key和value时，没有设置序列化方式，故自己创建redisTemplate实例
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //为了开发方便，一般都是直接使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        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;
    }

}

自定工具类，避免复杂的API操作

/**
 * Copyright (C), Lucius
 * FileName: RedisUtil
 * Author:
 * Date:     2020/5/16 15:51
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package com.lucius.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author zhaoYang
 * @Title: springboot-mybatis-redis
 * @Package com.spring.common
 * @date 2018/7/6 16:04
 * 基于spring和redis的redisTemplate工具类
 * 针对所有的hash 都是以h开头的方法
 * 针对所有的Set 都是以s开头的方法                    不含通用方法
 */
@Component
public class RedisUtil {
    // 这个是关键↓↓↓
    @Autowired
    private RedisTemplate redisTemplate;

    //=============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    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代表为永久有效 失效时间为负数，说明该主键未设置失效时间（失效时间默认为-1）
     */
    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;
        }
    }

    /**
     * 递增 此时value值必须为int类型 否则报错
     * @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
     */
    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
     */
    public double hDecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

    //============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    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 键
     * @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 {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

}

补充jedis操作

导入依赖

<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

yaml配置

#redis
  redis:
    host: 
    port: 6379
    password: 
    database: 0
    jedis:
      pool:
        #连接池最大连接数
        max-active: 1000
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 500
        # 连接池中的最大空闲连接
        max-idle: 500

    timeout: 10

redis配置类

@Configuration
@AllArgsConstructor
@NoArgsConstructor
@Data
public class redisConfig {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.jedis.pool.max-active}")
    private int poolMaxTotal;
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int poolMaxldle;
    @Value("${spring.redis.jedis.pool.max-wait}")
    private int poolMaxWait;


    /**
     * 将redis连接池注入spring容器
     *
     * @return
     */
    @Bean
    public JedisPool JedisPoolFactory() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(poolMaxldle);
        config.setMaxTotal(poolMaxTotal);
        //系统默认的是毫秒，配置文件中设置的是秒，在此进行一个转换
        config.setMaxWaitMillis(poolMaxWait * 1000);
        JedisPool jedisPool = new JedisPool(config, host, port, timeout * 1000, password, 0);
        return jedisPool;
    }
}

我们需要注意的是，与lettuce不一样的是，使用jedis的话为了保证线程安全我们需要自定义一个JedisPool，并设置相关的参数，所有的连接都是从连接池中获得的。

Lettuce 和 jedis 的都是连接 Redis Server的客户端

  • Jedis 在实现上是直连 redis server，多线程环境下非线程安全，除非使用连接池，为每个 redis实例增加 物理连接。
  • Lettuce 是 一种可伸缩，线程安全，完全非阻塞的Redis客户端，多个线程可以共享一个RedisConnection,它利用Netty NIO 框架来高效地管理多个连接，从而提供了异步和同步数据访问方式，用于构建非阻塞的反应性应用程序。

最后自定义工具类进行测试 同上

Lucius_Keep_Going!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis：Cannot assign requested address的解决办法
CC的博客
06-25 6809
开发压测时说应用连接redis有redisCannot assignrequestedaddress的报错，从网上查了一些资料，都说是修改linux的这三个内核参数 sysctl -w net.ipv4.tcp_timestamps=1 sysctl -w net.ipv4.tcp_tw_recycle=1 echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse 执...
org.springframework.data.redis.serializer.JdkSerializationRedisSerializer序列化工具
zsg88的专栏
05-28 5014
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer; /** * 序列化工具类 */ public class SerializerUtil { private static final JdkSerializationRedisSerializer jdkSerializ
org.springframework.data.redis.serializer.SerializationException: Cannot serialize（解决redis存入对象序列化）
冰夜翎博客
04-04 5495
【代码】org.springframework.data.redis.serializer.SerializationException: Cannot serialize（解决redis存入对象序列化）
Redis序列化和反序列化失败： org.springframework.data.redis.serializer.SerializationExceptionng
最新发布
qq_47932288的博客
11-30 1810
redis序列化和反序列化失败，因为RedisTemplate默认的序列化方式是用org.springframework.data.redis.serializer.JdkSerializationRedisSerializer这个类来做序列化，而Redis有自己的序列化方式，所以冲突了报出了上面的序列化异常的信息。设置redis key和value的序列化器，采用自定义的序列化器，就可以正常的插入序列化后的值和将缓存的值反序列化为java对象。
redis反序列化异常:org.springframework.data.redis.serializer.SerializationException
myroncham的博客
12-19 1万+
1、日志如下 org.springframework.data.redis.serializer.SerializationException: Cannot deserialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to d...
springboot-shiro-redis
02-04
标题“springboot-shiro-redis”表明我们正在讨论一个基于Spring Boot的应用程序，该应用程序集成了Apache Shiro安全框架，并利用Redis作为缓存层。这是一个常见的架构选择，因为Spring Boot简化了开发流程，Shiro...
springboot-redis事务
11-23
在IT行业中，SpringBoot框架与Redis的集成是常见的应用场景，特别是在处理高并发、高性能的数据存储和缓存需求时。本文将深入探讨“SpringBoot-Redis事务”这一主题，旨在帮助开发者理解如何在SpringBoot项目中利用...
springboot-webflux-redis
07-03
《SpringBoot结合WebFlux与Redis构建高效缓存系统》 在现代Web开发中，SpringBoot框架因其便捷的配置和强大的功能，已经成为许多开发者的选择。而Spring WebFlux作为Spring Framework的一部分，引入了响应式编程...
springboot-redis-demo
09-10
下面我们将详细探讨SpringBoot如何与Redis进行整合，并分析项目"springboot-redis-demo"中可能包含的关键知识点。 1. **添加依赖**： 在SpringBoot项目中，我们首先需要在`pom.xml`或`build.gradle`文件中添加...
SpringBoot-redis
11-20
接下来，我们将详细探讨如何在SpringBoot应用中整合Redis，以及如何操作Redis中的各种数据类型。 首先，集成SpringBoot和Redis需要在项目中引入相应的依赖。在`pom.xml`或`build.gradle`文件中添加Spring Data ...
org.springframework.data.redis.serializer.SerializationException: Cannot serialize； nested exception
y19980522的博客
06-29 1640
org.springframework.data.redis.serializer.SerializationException: Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to serialize object using DefaultSerializer; nested exception is java.l
springboot集成redis时报错：org.springframework.data.redis.serializer.SerializationExceptionng
热门推荐
慌途L
11-29 5万+
springboot项目使用redis报错： org.springframework.data.redis.serializer.SerializationException: Cannot deserialize; nested exception is org.springframework.core.serializer.support.SerializationFailedExcept...
SpringBoot 2 快速集成 Jedis客户端（自动配置版）
程序员小奎的博客
06-22 6082
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency>
Python转义字符
hard work
08-26 4829
转义字符 描述 \(在行尾时) 续行符 \\ 反斜杠符号 \' 单引号 \" 双引号 \a 响铃 \b 退格(Backspace) \e 转义 \000 空 \n 换行 \v 纵向制表符
spring boot 项目中redis 序列化异常：org.springframework.data.redis.serializer.SerializationException
Brave Soul Blog
06-13 6828
spring boot 项目中redis 序列化异常 当配置好redis配置时候，进行测试redis查询缓存，以下是注解配置下的缓存设置代码：java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type @Cacheable(v...
Spring Boot2.X 使用Lettuce连接Redis
hancc_824的博客
05-15 281
前言 Spring Boot2.x 不再使用Jedis，换成了Lettuce。Lettuce是基于 Netty 实现的，所以性能更好。 1.pom文件 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis-reactive</artifactId> </dep
算法分析实验报告02
Poem_wine_Puber的博客
06-01 955
利用递归设计算法计算第20个斐波那契数 算法分析： 斐波那契数列：第1,2两个数为1,1.从第3个数开始,该数是其前面两个数之和。 /* 利用递归设计算法计算第20个斐波那契数。 */ #include <iostream> using namespace std; int Fibonacci(int n) { if (n == 1 || n ==2) return 1; else return Fibonacci(n-1)+Fibonacci(n-2); } int main
Qt Creator git branch 创建分支/分支切换 git push --set-upstream origin mybranch
lxj362343的博客
06-23 2110
（1）创建分支 首先你要创建自己的分支 填上分支名称，点ok关闭。 然后编辑你的代码，并提交。 提交分支时提示如下错误 The command "D:\xxxx\Git\bin\git.exe" terminated with exit code 128. 10:31 Executing in D:\git\xxxxxxx: D:\xxxx\Git\bin\git.exe push fatal: The current branch mybranch has no upstream b
error C2589: “(”: “::”右边的非法标记；error C2059: 语法错误 : “::”
jacke121的专栏
10-29 2850
error C2589: “(”: “::”右边的非法标记；error C2059: 语法错误 : “::”
帮我写一个经典的Springboot-Redis的使用案例
03-11
好的，我可以为您提供一个经典的Springboot-Redis的使用案例。在Springboot中，我们可以通过引入spring-boot-starter-data-redis依赖来使用Redis。下面是一个简单的示例代码： 1.在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 2.在application.properties文件中添加以下配置： ``` spring.redis.host=localhost spring.redis.port=6379 ``` 3.在代码中注入RedisTemplate对象，并使用它来操作Redis： ``` @Autowired private RedisTemplate<String, Object> redisTemplate; public void set(String key, Object value) { redisTemplate.opsForValue().set(key, value); } public Object get(String key) { return redisTemplate.opsForValue().get(key); } ``` 以上就是一个简单的Springboot-Redis的使用案例，您可以根据自己的需求进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值