精华内容
下载资源
问答
  • SpringBoot集成Redis

    2019-02-26 09:00:45
    此 demo 演示 SpringBoot 集成 Redis 操作数据库以及 Redis 做登录缓存
  • springBoot集成redis

    2018-03-03 16:02:44
    springBoot+mybatis+redis集成,不上代码要确保redis服务端已经运行
  • 主要介绍了浅谈SpringBoot集成Redis实现缓存处理(Spring AOP实现),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Springboot集成Redis

    2020-12-21 01:18:37
    文章目录引入pom依赖配置redis引入RedisTemplate模板对redis操作编写一个测试类乱码分析及解决 引入pom依赖 org.springframework.boot spring-boot-starter-data-redis 2.2.6.RELEASE 配置redis 端口和ip地址,...
  • 主要介绍了springBoot集成redis的key,value序列化的相关问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要为大家详细介绍了springboot集成redis实现简单秒杀系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Springboot中已经有实现好的jar包可以很方便的集成Redis,也可以自己来封装Jedis实现Redis,这里我们使用Jedis来封装,从而使我们的程序更具有灵活性 首先,我们需要安装Redis: redis下载 安装完成之后在控制台输入...
  • 这次写一下springbootredis的结合,这里使用的是redis集群模式(主从),主从环境的搭建,请参考redis集群搭建 搭建完redis集群环境后,开始springboot之旅 1、REDIS介绍 redis的介绍及应用场景参考 redis介绍 2、...
  • SpringBoot集成Redis-Demo

    2020-08-06 23:16:11
    原创不易,感谢支持!
  • SpringBoot集成redis

    万次阅读 多人点赞 2019-08-01 20:07:35
    今天,日月在这里教大家如何使用springBoot集成redis,说实话比较简单,网上也有大把的教程。先套用一下网上的简介。 定义 REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。 ...

    今天,日月在这里教大家如何使用springBoot集成redis,说实话比较简单,网上也有大把的教程。先套用一下网上的简介。
    定义

    REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
    Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。
    它通常被称为数据结构服务器,因为值(value)可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
    reids的优点

    以下是Redis的一些优点。

    异常快 - Redis非常快,每秒可执行大约110000次的设置(SET)操作,每秒大约可执行81000次的读取/获取(GET)操作。
    支持丰富的数据类型 - Redis支持开发人员常用的大多数数据类型,例如列表,集合,排序集和散列等等。这使得Redis很容易被用来解决各种问题,因为我们知道哪些问题可以更好使用地哪些数据类型来处理解决。
    操作具有原子性 - 所有Redis操作都是原子操作,这确保如果两个客户端并发访问,Redis服务器能接收更新的值。
    多实用工具 - Redis是一个多实用工具,可用于多种用例,如:缓存,消息队列(Redis本地支持发布/订阅),应用程序中的任何短期数据,例如,web应用程序中的会话,网页命中计数等。

    Redis 安装

    Window 下安装
    下载地址:https://github.com/MSOpenTech/redis/releases。
    Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择,这里我们下载 Redis-x64-xxx.zip压缩包到 C 盘,解压后,将文件夹重新命名为 redis。

    打开一个 cmd 窗口 使用cd命令切换目录到 C:\redis
    运行 redis-server.exe redis.windows.conf
    如果想方便的话,可以把 redis 的路径加到系统的环境变量里,这样就省得再输路径了,后面的那个 redis.windows.conf 可以省略,如果省略,会启用默认的。输入之后,会显示如下界面:
    在这里插入图片描述

    集成redis

    我们还是延用上一章的项目:Springboot集成springcloud-config实现dataSource热部署

    1、添加依赖

    <!--集成redis-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-redis</artifactId>
        <version>1.4.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.3</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    

    2、在配置中心里添加redis配置

    spring.redis.host=127.0.0.1
    #Redis服务器连接端口
    spring.redis.port=6379
    #Redis服务器连接密码(默认为空)
    spring.redis.password=
    #连接池最大连接数(使用负值表示没有限制)
    spring.redis.pool.max-active=8
    #连接池最大阻塞等待时间(使用负值表示没有限制)
    spring.redis.pool.max-wait=-1
    #连接池中的最大空闲连接
    spring.redis.pool.max-idle=8
    #连接池中的最小空闲连接
    spring.redis.pool.min-idle=0
    #连接超时时间(毫秒)
    spring.redis.timeout=30000
    

    3、配置类RedisConfig

    import java.lang.reflect.Method;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import com.fasterxml.jackson.annotation.PropertyAccessor; 
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.databind.ObjectMapper;
    @Configuration
    @EnableCaching
    @RefreshScope
    public class RedisConfig extends CachingConfigurerSupport{
        @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.pool.max-active}")
        private int maxActive;
        @Value("${spring.redis.pool.max-wait}")
        private int maxWait;
        @Value("${spring.redis.pool.max-idle}")
        private int maxIdle;
        @Value("${spring.redis.pool.min-idle}")
        private int minIdle;
        
        @RefreshScope
        @Bean
        public KeyGenerator wiselyKeyGenerator(){
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
        
        @RefreshScope
        @Bean
        public JedisConnectionFactory redisConnectionFactory() {
            JedisConnectionFactory factory = new JedisConnectionFactory();
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout); //设置连接超时时间
            factory.setPassword(password);
            factory.getPoolConfig().setMaxIdle(maxIdle);
            factory.getPoolConfig().setMinIdle(minIdle);
            factory.getPoolConfig().setMaxTotal(maxActive);
            factory.getPoolConfig().setMaxWaitMillis(maxWait);
            return factory;
        }
        
        @RefreshScope
        @Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate) {
            RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
            // Number of seconds before expiration. Defaults to unlimited (0)
            cacheManager.setDefaultExpiration(10); //设置key-value超时时间
            return cacheManager;
        }
        
        @RefreshScope
        @Bean
        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
            StringRedisTemplate template = new StringRedisTemplate(factory);
            setSerializer(template); //设置序列化工具,这样ReportBean不需要实现Serializable接口
            template.afterPropertiesSet();
            return template;
        }
        
        @RefreshScope
        private void setSerializer(StringRedisTemplate template) {
            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);
            template.setValueSerializer(jackson2JsonRedisSerializer);
        }
    }
    

    4、RedisUtils类

    import java.io.Serializable;
    import java.util.List;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.HashOperations;
    import org.springframework.data.redis.core.ListOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.SetOperations;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.data.redis.core.ZSetOperations;
    import org.springframework.stereotype.Service;
    @Service
    public class RedisUtils {
        @Autowired
        private RedisTemplate redisTemplate;
        /**
         * 写入缓存
         * @param key
         * @param 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
         * @param value
         * @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
         */
        public void remove(final String... keys) {
            for (String key : keys) {
                remove(key);
            }
        }
        /**
         * 批量删除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);
        }
    

    5、测试,修改controller

    import java.util.concurrent.TimeUnit;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import com.chenqi.springboot.redis.RedisUtils;
    import com.chenqi.springboot.service.TestService;
    @RestController
    public class SpringBootController {
        
        public static final Logger log = LoggerFactory.getLogger(SpringBootController.class);
        
        @Autowired
        TestService testService;
        
        @Autowired
        private RedisUtils redisUtils;
        @RequestMapping(value = "/hello/{id}")
        public String hello(@PathVariable(value = "id") String id){
            //查询缓存中是否存在
            boolean hasKey = redisUtils.exists(id);
            String str = "";
            if(hasKey){
                //获取缓存
                Object object =  redisUtils.get(id);
                log.info("从缓存获取的数据"+ object);
                str = object.toString();
            }else{
                //从数据库中获取信息
                log.info("从数据库中获取数据");
                str = testService.test();
                //数据插入缓存(set中的参数含义:key值,user对象,缓存存在时间10(long类型),时间单位)
                redisUtils.set(id,str,10L,TimeUnit.MINUTES);
                log.info("数据插入缓存" + str);
            }
            return str;
        }
    }
    

    启动项目,第一次访问:http://localhost:8002/hello/111
    在这里插入图片描述
    在这里插入图片描述
    通过控制台输出,我们可以看到是从数据库中获取的数据,并且存入了redis缓存中。

    我们再次刷新浏览器
    在这里插入图片描述
    可以看到,第二次是从缓存中读取的,我们试试不断刷新浏览器
    在这里插入图片描述
    可以看到,之后都是从缓存中获取的。

    到此我们的redis就配置好了。

    SpringBoot集成Redis-demo下载
    急需demo的兄弟就自行下载吧,不急可以留言邮箱,一般48小时内会发。

    关联文章

    Redis指定db存储
    Redis 管理工具 TreeNMS

    展开全文
  • springboot集成redis集群,redis安装包配置,参考文章:https://blog.csdn.net/zhizhuodewo6/article/details/82316164
  • springboot集成redis

    2021-07-20 14:28:07
    spring 集成redis很简单, 只需要添加一个依赖就可以了 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &...

    spring 集成redis很简单, 只需要添加一个依赖就可以了

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

    这是spring-boot专门为redis准备的依赖包, maven项目中只要添加它就可以了, 它会自动下载其它的依赖包

    然后就是要为redis进行配置
    在application.properties 文件中进行配置

    spring.redis.host=127.0.0.1
    spring.redis.password=
    spring.redis.port=6379
    

    上面配置好了就可以使用了

        @Autowired
        private StringRedisTemplate redisTemplate;
    
        @RequestMapping(value="/redis")
        @ResponseBody
        public Object testRedis(){
    
            redisTemplate.opsForValue().set("huang","huangjunhui");
            return "OK";
        }
    }
    

    StringRedisTemplate 当我们引入Redis之后, springboot在创建时就会新建一个 StringRedisTemplate 在java Bean中, 我们只需要 使用 Autowired 或者 Resource 注解,自动注入就可以了

    在这里插入图片描述

    展开全文
  • 最近学习springboot吧自己工作中需要用到的工具都做了集成例子。其中包括mybatis,cfx的webservice,定时器quartz,消息队列kafka以及redis其中redis包含了三种连接方式(单机模式,集群cluster,哨兵模式),给大家...
  • springboot集成Redis,以及测试类。包含了集成代码以及测试类代码。测试类中包含了redis五种数据类型的增删改查方法。
  • 主要介绍了SpringBoot利用redis集成消息队列的方法,需要的朋友可以参考下
  • springboot集成 redis 的配置 redis的优点就不多说了,大家都懂。下面直接进入实战。 1、集成的时候首先先导入jar包 <!-- spring boot redis缓存引入 --> <dependency> <groupId>org.spring...

    springboot集成 redis 的配置

    redis的优点就不多说了,大家都懂。下面直接进入实战。

    1、集成的时候首先先导入jar包

    <!-- spring boot redis缓存引入 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- 缓存连接池-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    <!-- redis 存储 json序列化 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jsr310</artifactId>
    </dependency>
    

    2、配置文件中进行设置

    #spring: 
      redis:
        host: #写自己的链接地址
        port: 6379
        database: 0
        password: 123456 #默认为空
        timeout: 3000ms #最大等待时间,超时则抛出异常,否则请求一直等待
        lettuce:
          pool:
            max-active: 20  #最大连接数,负值表示没有限制,默认8
            max-wait: -1    #最大阻塞等待时间,负值表示没限制,默认-1
            max-idle: 8     #最大空闲连接,默认8
            min-idle: 0     #最小空闲连接,默认0
    

    3、编写配置类

    因为在序列化存储的时候,spring默认会使用JDK的序列化进行存储,存储的都是以二进制存储,我们读取数据不太方便。并且在存储日期(LocalDateTime)类型的时候,也会进行一个序列化,对于反序列化来说不太友好(反序列会可能会失败),所以我们进行如下配置。

    public class RedisConfig {
    
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            //设置连接池工厂
            redisTemplate.setConnectionFactory(redisConnectionFactory);
    
            //首先解决key的序列化方式
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            redisTemplate.setKeySerializer(stringRedisSerializer);
    
            //解决value的序列化方式
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
    
            //序列化时将类的数据类型存入json,以便反序列化的时候转换成正确的类型
            ObjectMapper objectMapper = new ObjectMapper();
            //objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            //将当前对象的数据类型也存入序列化的结果字符串中,便于反序列化的时候可以知道是转成哪个对象!!!
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            // 解决jackson2无法反序列化LocalDateTime的问题
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            objectMapper.registerModule(new JavaTimeModule());
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            return redisTemplate;
        }
    

    4、进行测试

    @SpringBootTest
    @RunWith(SpringRunner.class)
    public class RedisTemplateTests {
        @Resource
        private RedisTemplate redisTemplate;
    	//这个是我自己写的一个mapper,大家可以换成自己写的类
        @Resource
        private DictMapper dictMapper;
    
    	//存值
        @Test
        public void saveDict(){
            Dict dict = dictMapper.selectById(1);
    
            System.out.println(dict);
            //以字符串的形式存在 redis 中  设置有效时间是 5 分钟。TimeUnit.MINUTES是分钟的意思
            redisTemplate.opsForValue().set("dict11",dict, 5, TimeUnit.MINUTES);
        }
        
        //取值
     	@Test
        public void getDict(){
            
            Dict dict = (Dict) redisTemplate.opsForValue().get("dict11");
            System.out.println(dict);
        }
    
    }
    
    

    5、测试结果

    在这里插入图片描述

    刚入住csdn,有不足的地方请大家指正。

    展开全文
  • 主要介绍了SpringBoot结合Redis哨兵模式的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • springboot集成redis 1、 导包 <!--springboot中的redis依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</...

    springboot集成redis

    1、 导包

    <!--springboot中的redis依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- lettuce pool 缓存连接池-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    

    2、 在RedisAutoConfiguration中找到对应的RedisProperties配置,在yml中配置基本配置

    spring:
      redis:
        host: xxxxxx 自己的ip
        port: 6379
        lettuce:
          pool:
            max-active: 8
            max-wait: -1
            max-idle: 8
            min-idle: 0
    

    3、从RedisAutoConfiguration中看到默认配置了两个bean RedisTemplate,StringRedisTemplate 而且是基于lettuce是redis-cli客户端

    获取redisTemplate进行测试即可

    在这里插入图片描述

    从这里看是测试成功的。但是我们从服务器上看对应的key,却是这个样子
    在这里插入图片描述
    怎么办?

    原因: 大概是lettuce客户端连接redis服务器采用的是byte数组,因此会将对象先转化为byte数组,而转换方法是使用JdkSerializationRedisSerializer 的convert方法转换,因此需要替换到默认的redisSerializaer
    在这里插入图片描述

    具体分析网址

    4、 配置redisConfig
    解决

    ​ 自己配置redisConfig,不使用默认的

    @Configuration
    @EnableCaching
    public class RedisConfig {
        /**
         * 配置自定义redisTemplate
         * @return
         */
        @Bean
        RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            // 设置值(value)的序列化采用Jackson2JsonRedisSerializer。
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            // 设置键(key)的序列化采用StringRedisSerializer。
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }
    

    idea 客户端再次运行结果:

    在这里插入图片描述

    服务器 客户端运行结果:( 注意:中文内容还是会乱码)

    在这里插入图片描述

    展开全文
  • SpringBoot集成Redis集群

    2021-09-28 09:17:12
    SpringBoot集成Redis集群
  • 主要介绍了SpringBoot整合Redis正确的实现分布式锁的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 2、配置redis81.conf (其余82、83和这个配置一样)3、启动好三台机器3.1 选举Leader四、配置哨兵模式4.1 新建sentinel.conf4.2 启动哨兵4.3 查看进程是否都正常4.4 自动选举Leader五、SpringBoot集成Redis哨兵5.1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,505
精华内容 11,402
关键字:

springboot集成redis

redis 订阅
spring 订阅