精华内容
下载资源
问答
  • Redis SpringBoot配置

    2020-11-19 16:01:11
    dependency> 配置文件 #配置redis #服务器redis 地址 spring.redis.host=127.0.0.1 #redis 端口 spring.redis.port=6379 #redis 密码 spring.redis.password=123456 #redis连接池配置 # 连接池最大连接数(使用负值...

    pom文件

    <!--redis-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--redis连接池-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    

    配置文件

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

    创建配置类

    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.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.io.Serializable;
    
    /**
     * @author Xkuna
     * @date 2020/11/19 14:05.
     */
    //配置类专属注解 并且完成自动注入
    @Configuration
    public class RedisConfig {
        @Bean
        //配置redisTemplate
        // 默认情况下的模板只能支持 RedisTemplate<String,String>,
        // 只能存入字符串,很多时候,我们需要自定义 RedisTemplate ,设置序列化器
        public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
            RedisTemplate<String,Object> template = new RedisTemplate <>();
            template.setConnectionFactory(factory);
    
            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);
    
            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;
        }
    
    }
    
    
    展开全文
  • Springboot+Redis配置

    2020-05-31 11:04:59
    Springboot+Redis配置类 Step 1 -> 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </...

    Springboot+Redis配置类

    Step 1 -> 添加依赖

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

    Step 2 -> 添加配置类

    package com.guanqi.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    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.RedisOperations;
    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;
    
    @Configuration
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    public class RedisConfig {
    
        @Bean
        @ConditionalOnMissingBean(name = "redisTemplate")
        public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
            //初始化一个redis模板
            RedisTemplate<Object,Object> template = new RedisTemplate<>();
            //使用fastjson实现对于对象得序列化
            Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(om);
    
            //设置“值”的序列化方式
            template.setValueSerializer(serializer);
            //设置“hash”类型数据的序列化方式
            template.setHashValueSerializer(serializer);
            //设置“key"的序列化方式
            template.setKeySerializer(new StringRedisSerializer());
            //设置“hash的key”的序列化方式
            template.setHashKeySerializer(new StringRedisSerializer());
            //设置redis模板的工厂对象
            template.setConnectionFactory(redisConnectionFactory);
    
    
            return template;
        }
    
        @Bean
        @ConditionalOnMissingBean(StringRedisTemplate.class)
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory){
    
            StringRedisTemplate template = new StringRedisTemplate();
    
            template.setConnectionFactory(redisConnectionFactory);
    
            return template;
        }
    
    
    }
    
    

    Step 3 -> 添加工具类

    package com.guanqi.util;
    
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import javax.annotation.Resource;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    
    @Component
    public class RedisUtil {
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
        public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
    
        /**
         * 指定缓存的失效时间
         *
         * @param key  redis中的key
         * @param time 设置过期时间类型为 秒
         * @return 该key对应的值是否失效 true为没有失效;false为失效
         */
        public boolean setExpire(String key, long time) {
            try {
                if (time > 0) {
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key拿到key的失效时间
         *
         * @param key
         * @return 失效时间  秒  就是距离过期时间有多少秒
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /**
         * 判断Key是否在redis中存在
         *
         * @param key 是
         * @return true存在,否则false
         */
        public boolean hasKey(String key) {
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 删除缓存中所有的keys的值
         *
         * @param keys 可变长度的参数,可以是0个,1个和多个key进行删除
         */
        public void delete(String... keys) {
            if (keys != null && keys.length > 0) {
                if (keys.length == 1) {
                    redisTemplate.delete(keys[0]);
                }
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(keys));
            }
        }
    
    
        //String类型/
    
        /**
         * 获取String类型的key对应的值
         *
         * @param key String类型redis数据的key
         * @return 该key对应的String的value值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 在redis服务器中是设置String类型的值
         *
         * @param key   String 类型的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;
            }
        }
    
        /**
         * 在redis服务器中设置String类型的值,并设置失效时间
         * @param key String 类型的key
         * @param value 值
         * @param time 失效时间 秒
         * @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;
            }
        }
    
    
        /**
         * list集合
         * @param key
         * @param values
         * @return
         */
        public boolean listRightPush(String key, Object... values){
            Long pushAll = redisTemplate.opsForList().rightPushAll(key, values);
            if (pushAll > 0 ){
                return true;
            }
    
            return false;
        }
    
        /**
         * redis集合的获取
         * @param key
         * @return
         */
        public List<?> rangeList(String key){
            List<Object> list = redisTemplate.opsForList().range(key, 0, -1);
            return list;
        }
    
    
    
    
    
        /**
         * hash类型数据的存储
         * @param key hash 类型值的key
         * @param map 键值对
         * @return
         */
        public boolean hmset(String key, Map<String,Object> map){
            try {
                redisTemplate.opsForHash().putAll(key,map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * hash 类型数据存储
         * @param key hash类型的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){
                    setExpire(key,time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
    
        /**
         * 设置hash中指定key下的field的值为value
         * @param key  hash 的key建
         * @param field hash中的field域
         * @param value 给hash中的field设置的值
         * @return true设置成功,否则false
         */
        public boolean hset(String key,String field, Object value){
            try {
                redisTemplate.opsForHash().put(key,field,value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 设置hash中指定key下field的值为value并设置失效时间
         * @param key hash的key
         * @param field hash的fieid
         * @param value 给hash中的key下的fieid 设置的值
         * @param time 失效时间
         * @return true设置成功 否则false
         */
        public boolean hset(String key,String field,Object value, long time){
            try {
                redisTemplate.opsForHash().put(key,field,value);
                if (time > 0){
                    setExpire(key,time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 获取hash类型数据的key对应的整个map对象
         * @param key hash 中的Key
         * @param field key对应的hash对象
         * @return 该hash key 对应的hash对应
         */
        public Object hget(String key,String field){
            return redisTemplate.opsForHash().get(key,field);
        }
    
    
        /**
         * 获取hash类型数据的key对应的整个map对象
         * @param key hash 中的key
         * @return 该hash key对应的hash对象
         */
        public Map<Object,Object> hmget(String key){
            return redisTemplate.opsForHash().entries(key);
        }
    
    
    }
    
    

    Step 4 -> 自己注入RedisUtil 使用即可

    展开全文
  • SpringbootRedis

    2018-06-15 17:50:56
    springboot整合redis,并且封装好的一套api,下载配置好即可使用
  • springboot以及springmvc在properties配置redis的区别springmvcspringboot springmvc #redis的服务器地址 redis.host=127.0.0.1 #redis的服务端口 redis.port=6379 #密码(默认空) redis.password= #链接数据库...

    springboot以及springmvc在properties配置redis的区别

    springmvc

    #redis的服务器地址
    redis.host=127.0.0.1
    #redis的服务端口
    redis.port=6379
    #密码(默认空)
    redis.password=
    #链接数据库(默认为0)
    redis.default.db=0
    #连接超时时间(毫秒)
    redis.timeout=100000
    #最大连接数
    redis.maxActive=300
    #最大空闲数
    redis.maxIdle=100
    #最大建立连接等待时间
    redis.maxWaitMillis=1000
    

    springboot

    springboot相对于springmvc有了一些改变

    # Redis数据库索引(默认为0)
    spring.redis.database=0
    # Redis服务器地址
    spring.redis.host=localhost
    # Redis服务器连接端口
    spring.redis.port=6379
    # Redis服务器连接密码(默认为空)
    spring.redis.password=
    # 连接池最大连接数(使用负值表示没有限制)
    spring.redis.jedis.pool.max-active=8
    # 连接池最大阻塞等待时间(使用负值表示没有限制)
    spring.redis.jedis.pool.max-wait=-1
    # 连接池中的最大空闲连接
    spring.redis.jedis.pool.max-idle=8
    # 连接池中的最小空闲连接
    spring.redis.jedis.pool.min-idle=0
    # 连接超时时间(毫秒)
    spring.redis.timeout=5000
    
    展开全文
  • springboot配置Redis主从服务

    万次阅读 2017-09-25 19:55:06
    今天学了一下springboot配置redis的主从服务器。根据一主二从三哨兵的原则来搭建一个分布式的缓存服务。主要还是针对redis的一些配置。下面与大家分享一下! 附上对redis的官方介绍 ...要想通过springboot搭建redis...

    今天学了一下springboot配置redis的主从服务器。根据一主二从三哨兵的原则来搭建一个分布式的缓存服务。主要还是针对redis的一些配置。下面与大家分享一下!
    附上对redis的官方介绍
    http://redis.majunwei.com/topics/sentinel.html
    要想通过springboot搭建redis主从服务,就要先使用redis配置一个主从服务。

    测试redis的主从配置

    • 主服务器用于数据的读写,当发生写入操作时,主服务器会自动将数据同步给从服务器。
    • 从服务器只负责读取,不能写入。如果主服务器宕机,哨兵(sentinel)会在从服务器中选举产生一个主服务器。此时该服务器具有读写权限。
      下面我们分步骤来配置主从服务器,依照一主二从三哨兵的原则,我们需要三个redis实例,分别配置如下信息

    redis实例

    文件夹名称如下

    redis_master_s
    redis_slaver1_s
    redis_slaver2_s

    redis.conf文件

    master的redis.conf文件(其余是默认设置)

    port 6379
    daemonize yes
    # 这个文件夹要改成自己的目录
    dir "/Users/vobile_lzl/redis_master_s"

    slaver1的redis.conf文件

    port 6378
    # 主服务器端口为6379
    slaveof 127.0.0.1 6379
    dir "/Users/vobile_lzl/redis_slaver1_s"

    slaver2的redis.conf文件

    port 6377
    # 主服务器端口为6379
    slaveof 127.0.0.1 6379
    dir "/Users/vobile_lzl/redis_slaver2_s"

    这个主从服务器就配置好了。
    启动服务(命令大致如此)

    ./redis-server redis.conf

    测试一下主从复制的功能
    1. 主服务器写入,从服务器可以读取到
    2. 从服务器不能写入

    注意端口,6379表示主服务器,6377、6378是从服务器

    127.0.0.1:6379> set name lzl
    OK
    127.0.0.1:6377> get name
    "lzl"
    127.0.0.1:6378> get name
    "lzl"
    # 从服务器不能写入
    127.0.0.1:6378> set name lzl
    (error) READONLY You can't write against a read only slave.
    127.0.0.1:6377> set nam fdk
    (error) READONLY You can't write against a read only slave.

    sentinel.conf文件

    sentinel是哨兵,用于监视主从服务器的运行状况,如果主服务器挂掉,会在从服务器中选举一个作为主服务器。
    配置文件如下
    master的sentinel.conf

    port 26379
    # 初次配置时的状态,这个sentinel会自动更新
    sentinel monitor mymaster 127.0.0.1 6379 2
    daemonize yes
    logfile "./sentinel_log.log"

    slaver1的sentinel.conf

    port 26378
    # 初次配置时的状态,这个sentinel会自动更新
    sentinel monitor mymaster 127.0.0.1 6379 2
    daemonize yes
    logfile "./sentinel_log.log"

    slaver2的sentinel.conf

    port 26377
    # 初次配置时的状态,这个sentinel会自动更新
    sentinel monitor mymaster 127.0.0.1 6379 2
    daemonize yes
    logfile "./sentinel_log.log"

    再次启动redis所有的服务端

    ./redis-server redis.conf
    ./redis-server sentinel.conf --sentinel

    分别开启redis的客户端

    ./redis-cli
    ./redis-cli -h 127.0.0.1 -p 6378
    ./redis-cli -h 127.0.0.1 -p 6377

    使用一下命令查看三个redis服务的状态

    info replication

    master
    role:master

    127.0.0.1:6379> info replication
    # Replication
    role:master
    connected_slaves:2
    slave0:ip=127.0.0.1,port=6378,state=online,offset=4102,lag=1
    slave1:ip=127.0.0.1,port=6377,state=online,offset=4102,lag=1
    master_repl_offset:4102
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:2
    repl_backlog_histlen:4101

    slaver1

    127.0.0.1:6378> info replication
    # Replication
    role:slave
    master_host:127.0.0.1
    master_port:6379
    master_link_status:up
    master_last_io_seconds_ago:0
    master_sync_in_progress:0
    slave_repl_offset:15931
    slave_priority:100
    slave_read_only:1
    connected_slaves:0
    master_repl_offset:0
    repl_backlog_active:0
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:0
    repl_backlog_histlen:0

    slaver2

    127.0.0.1:6377> info replication
    # Replication
    role:slave
    master_host:127.0.0.1
    master_port:6379
    master_link_status:up
    master_last_io_seconds_ago:1
    master_sync_in_progress:0
    slave_repl_offset:21629
    slave_priority:100
    slave_read_only:1
    connected_slaves:0
    master_repl_offset:0
    repl_backlog_active:0
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:0
    repl_backlog_histlen:0

    将master服务杀死

    vobile-lzldeMacBook-Pro:~ vobile_lzl$ ps -ef | grep redis
      501 13258     1   0  9:52下午 ??         0:00.37 ./redis-server *:6379 
    
      kill -9 13258

    再次查看master的状态
    说明master已经宕机

    127.0.0.1:6379> info replication
    Could not connect to Redis at 127.0.0.1:6379: Connection refused

    再观察一段时间,6377的从服务器成为主服务器

    127.0.0.1:6377> info replication
    # Replication
    role:master
    connected_slaves:0
    master_repl_offset:0
    repl_backlog_active:0
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:0
    repl_backlog_histlen:0

    恢复主服务器,并设置为master

    // TODO

    springboot中配置主从redis

    依旧接着上个项目的内容进行设置。
    不清楚内容的可以查看
    http://blog.csdn.net/u011521890/article/details/78070773
    或者github上面的内容
    https://github.com/hpulzl/book_recommend

    application.properties文件

    新增node配置

    // 主从配置
    // name of Redis server  哨兵监听的Redis server的名称
    spring.redis.sentinel.master=mymaster
    // comma-separated list of host:port pairs  哨兵的配置列表
    spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26378,127.0.0.1:26377

    RedisCacheConfig配置

    新增RedisSentinelConfiguration代码

     /**
         * redis哨兵配置
         * @return
         */
        @Bean
        public RedisSentinelConfiguration redisSentinelConfiguration(){
            RedisSentinelConfiguration configuration = new RedisSentinelConfiguration();
            String[] host = redisNodes.split(",");
            for(String redisHost : host){
                String[] item = redisHost.split(":");
                String ip = item[0];
                String port = item[1];
                configuration.addSentinel(new RedisNode(ip, Integer.parseInt(port)));
            }
            configuration.setMaster(master);
            return configuration;
        }
    
    /**
         * 连接redis的工厂类
         *
         * @return
         */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory() {
        //构造方法中注入RedisSentinelConfiguration对象
            JedisConnectionFactory factory = new JedisConnectionFactory(redisSentinelConfiguration());
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout);
            factory.setPassword(password);
            factory.setDatabase(database);
            return factory;
        }

    以上就是redis的主从配置。十分简单!
    接下来就要验证一把在springboot中是否配置成功!
    验证思路
    * 写一个controller方法,用来往redis中新增数据
    * 此时关闭redis主服务器,再次调用contoller方法、
    * 如果接口依旧可以写入信息,说明配置成功。此时查看redis的其他从服务器,会发现有一个从服务器变成了主服务器。
    测试代码:

    @RestController
    @RequestMapping("sample")
    public class SampleController {
    
        @Autowired
        private UseRedisDao useRedisDao;
    
        @RequestMapping("hi")
        public String sayHello(String key,String value){
            useRedisDao.setValue(key,value);
            return useRedisDao.getValue(key);
        }
    }

    先查看redis主服务器发现,6377是master服务器

    127.0.0.1:6377> info replication
    # Replication
    role:master
    connected_slaves:2
    slave0:ip=127.0.0.1,port=6378,state=online,offset=378547,lag=1
    slave1:ip=127.0.0.1,port=6379,state=online,offset=378547,lag=1
    master_repl_offset:378682
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:2
    repl_backlog_histlen:378681

    调用本地服务
    http://localhost:8080/sample/hi?key=code&value=good
    从redis中查询写入信息

    127.0.0.1:6379> keys *
    1) "code"
    2) "name"
    127.0.0.1:6379> get code 
    "\"good\""

    我们看到三个redis服务都存在这样的信息
    这里写图片描述
    这时kill掉6377的进程

    vobile-lzldeMacBook-Pro:redis_slaver2_s vobile_lzl$ ./redis-cli -p 6377 shutdown
    vobile-lzldeMacBook-Pro:redis_slaver2_s vobile_lzl$ ./redis-cli -p 6377
    Could not connect to Redis at 127.0.0.1:6377: Connection refused

    再次请求服务器
    http://localhost:8080/sample/hi?key=today&value=iscoding
    我们发现数据照样写入了redis中

    127.0.0.1:6378> keys *
    1) "code"
    2) "name"
    3) "today"
    
    127.0.0.1:6379> keys *
    1) "code"
    2) "name"
    3) "today"

    此时看到6379变成了master

    127.0.0.1:6379> info replication
    # Replication
    role:master
    connected_slaves:1
    slave0:ip=127.0.0.1,port=6378,state=online,offset=32419,lag=1
    master_repl_offset:32419
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:2
    repl_backlog_histlen:32418

    以上就是配置的过程,如有疑问可以参看github
    https://github.com/hpulzl/book_recommend

    展开全文
  • 相信很多的码友在接触springboot时,不知道怎么去配置一些项目中需要的配置,比如数据源,tomcat调优,端口等等,下面我就给大家奉献出一些项目中常用的配置信息。如何偏差的地址欢迎大家来指正。配置文件比较多,...
  • 配置文件 如果redis设置了密码,一定要写 spring: application: name: redis-server database: 1 # Redis服务器数据库 host: 127.0.0.1 # Redis服务器地址 port: 6379 # Redis服务器连接端口 timeout: 6000...
  • //通过Spring提供的RedisCacheConfiguration类,构造一个自己的redis配置类,从该配置类中可以设置一些初始化的缓存命名空间 // 及对应的默认过期时间等属性,再利用RedisCacheManager中的builder.build()的方式...
  • spring boot + redis 配置

    千次阅读 2018-08-07 17:44:02
    2.配置文件application.yml中redis的配置信息 redis: host: 127.0.0.1 port: 6379 #连接超时时间(毫秒) timeout: 2000 pool: #最大连接数(负数表示没有限制) max-active: 100 #最大空闲连接 max-idle:...
  • SpringBoot配置Redis序列化

    千次阅读 2019-05-30 21:12:39
    SpringBoot默认使用jdkSerialize方式对存入redis中的内容进行序列化,比如你要存入的key是"hello",而存入redis之后key成了\xo\12\xxx\hello这种类型的值,这显然不能用,因此我们需要自己配置redisTemplate,以下是...
  • springboot 整合redis配置文件

    万次阅读 2018-05-10 14:59:03
    redis配置 ,properties文件 spring.redis.hostName: 192.168.174.128 spring.redis.port: 6379 spring.redis.password: xuan123456 spring.redis.database: 2 #默认使用db0 spring.redis.timeout: 0 spring....
  • SpringBoot高级篇Redis之基本配置

    万次阅读 2018-10-30 08:44:47
    redis配置,默认,非默认,集群,多实例,连接池参数等 redis读写操作,RedisTemplate的基本使用姿势 几种序列化方式对比 本篇博文为redis系列的开篇,将介绍最基本的配置 I. redis基本配置 ...
  • http://blog.didispace.com/springbootredis/?utm_source=tuicool&utm_medium=referral 手动集成 Redis pom.xml  xsi:schemaLocation=...
  • 多sentinel配置的时候,sentinel之间也会自动监控 当主从模式配置密码时,sentinel也会同步将配置信息修改到配置文件中,不需要担心 一个sentinel或sentinel集群可以管理多个主从Redis,多个sentinel也可以监控同一...
  • Springboot整合Redis集群,零配置方式;另外用AOP实现了操作缓存的三套自定义注解,有兴趣的小伙伴可以试试看.
  • SpringBoot Redis 哨兵配置(一主两从三哨兵 )配置 背景 Redis 哨兵模式作为Redis 的一种高可用方案,实现了主从复制、监控,故障转移等工作,在一定程度上保证了Redis的高可用,避免了因Redis服务宕机导致缓存服务不...
  • 2、修改配置文件,实现哨兵模式 #redis配置 redis: # Redis服务器连接密码 password: alone: # Redis服务器连接地址 host: 127.0.0.1 # Redis服务器连接端口 port: 6379 pool: max-active: 50 max-wait: ...
  • springboot2.0 + redis集群配置

    千次阅读 2019-08-30 23:50:53
    使用springboot集成的redis包,实现了自动配置,不需要再单独实现redis的配置了。 <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis 2、application.yml配置 spring: ...
  • 首先代码里只用到了单机版的redis,但因为后续数据量的问题改成了集群版,这里记录集群版的基本配置,如果有不对的地方欢迎评论留言指正哈~ 文章目录 一、application.properties配置文件内容 二、RedisConfig配置...
  • 如果在classpath下存在Redis并且Redis已经配置好了,此时默认就会使用RedisCacheManager作为缓存提供者。 1. 创建项目,添加缓存依赖: <dependencies> <dependency> <groupId>org.spring...
  • 文章目录一、介绍pom依赖yml配置文件二、用法 一、介绍 SpringDataRedis。 它底层封装了Jedis,JRedis等常用api。 pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <...
  • SpringBoot配置redis集群(Jedis and lettuce)

    千次阅读 2020-12-05 17:40:35
    SpringBoot2.x版本配置redis集群(Jedis and lettuce) 在SpringBoot1.x版本中,springboot默认使用集成jedis,在SpringBoot2.x版本中,SpringBoot默认集成lettuce。 Jedis vs Lettuce 1. Jedis使用直连方式连接Redis ...
  • springboot项目中使用redis是很常见的业务场景,今天我们分享一下boot项目中,redis的连接配置、序列化等。 1、引入jar <parent> <groupId>org.springframework.boot</groupId> <...
  • server: port: 1015 spring: redis: #SINGLE: 单机 CLUSTER:集群 SENTINEL: 哨兵 redis-model: ${REDIS_MODEL:CLUSTER} //可配置 //用于单机 host: ${REDIS_HOST} database: ${REDIS_DATABASE} password: ${REDIS...
  • redis哨兵模式的配置及在springboot中使用 一、从0搭建redis哨兵模式 1、下载redis http://download.redis.io/releases/ 这里使用的6.0.4版本 下载后上传到服务器中 这里准备三台服务器:192.168.200.135(主) 192....
  • 一、加入maven配置 &lt;!-- 整合redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-...
  • pom.xml添加依赖包: <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ...redis单机版和集群版的application.properties文件...《springBoot学习篇》(3)Windows下配置Redis集群
  • springBootRedis-master

    2020-04-08 11:07:07
    /** * @author janti * reids 相关bean的配置 */ @Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { /** * 选择redis作为默认缓存工具 * @param redisTemplate * @...
  • pool2 在 application.yml文件中配置如下内容,由于Spring Boot2.x 的改动,连接池相关配置需要通过spring.redis.lettuce.pool进行配置 spring: redis: host: 127.0.0.1 # IP port: 6379 # 端口号 password: 123456 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 521
精华内容 208
关键字:

springbootredis配置

redis 订阅
spring 订阅