精华内容
下载资源
问答
  • springboot 整合redis 操作

    万次阅读 2019-06-05 15:59:55
    springboot 整合redis 操作修改xml配置文件 pom.xml修改配置文件application.yml 文件增加RedisConfig.java配置类创建RedisUtils.java工具类 修改xml配置文件 pom.xml 在pom.xml文件中新增maven依赖如图 <!--...

    修改xml配置文件 pom.xml

    在pom.xml文件中新增maven依赖如图

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

    修改配置文件application.yml 文件


    具体配置内容如下:

    spring:
      #redis配置信息
      redis:
        #redis 服务器地址
        hostName: redis.confedu.com
        #redis端口
        port: 6379
        #redis 密码
        password: 123456
        #客户端超时时间单位是毫秒 默认是2000
        timeout: 5000
        #最大空闲数
        maxIdle: 20
        #连接池的最大数据库连接数
        maxActive: -1
        #控制一个pool可分配多少个jedis实例,用来替换上面的maxActive
        maxTotal: 100
        #最大建立连接等待时间。如果超过此时间将接到异常
        maxWaitMillis: 100
        #连接的最小空闲时间
        minEvictableIdleTimeMillis: 864000000
        #每次释放连接的最大数目
        numTestsPerEvictionRun: 10
        #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程
        timeBetweenEvictionRunsMillis: 300000
        #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
        testOnBorrow: true
        #在空闲时检查有效性
        testWhileIdle: false
        #数据库
        database: 0
    

    增加RedisConfig.java配置类

    package com.example.framework.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    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.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    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 redis.clients.jedis.JedisPoolConfig;
    
    import java.nio.charset.Charset;
    
    /**
     * redis 配置类
     * @author: example
     * @create: 2019/5/31
     */
    @Configuration
    public class RedisConfig {
    
        @Autowired
        private MyStringSerializer myStringSerializer;
    
        @Value("${spring.redis.hostName}")
        private String hostName;
    
        @Value("${spring.redis.port}")
        private Integer port;
    
        @Value("${spring.redis.password}")
        private String password;
    
        @Value("${spring.redis.timeout}")
        private Integer timeout;
    
        @Value("${spring.redis.maxIdle}")
        private Integer maxIdle;
    
        @Value("${spring.redis.maxActive}")
        private String maxActive;
    
        @Value("${spring.redis.maxTotal}")
        private Integer maxTotal;
    
        @Value("${spring.redis.maxWaitMillis}")
        private Long maxWaitMillis;
    
        @Value("${spring.redis.minEvictableIdleTimeMillis}")
        private Long minEvictableIdleTimeMillis;
    
        @Value("${spring.redis.numTestsPerEvictionRun}")
        private Integer numTestsPerEvictionRun;
    
        @Value("${spring.redis.timeBetweenEvictionRunsMillis}")
        private Long timeBetweenEvictionRunsMillis;
    
        @Value("${spring.redis.testOnBorrow}")
        private boolean testOnBorrow;
    
        @Value("${spring.redis.testWhileIdle}")
        private boolean testWhileIdle;
    
        @Value("${spring.redis.database}")
        private Integer database;
    
        /**
         * JedisPoolConfig 连接池
         * @return
         */
        @Bean
        public JedisPoolConfig jedisPoolConfig() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            // 最大空闲数
            jedisPoolConfig.setMaxIdle(maxIdle);
            // 连接池的最大数据库连接数
            jedisPoolConfig.setMaxTotal(maxTotal);
            // 最大建立连接等待时间
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
            // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
            jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
            jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
            // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
            jedisPoolConfig.setTestOnBorrow(testOnBorrow);
            // 在空闲时检查有效性, 默认false
            jedisPoolConfig.setTestWhileIdle(testWhileIdle);
            return jedisPoolConfig;
        }
    
        /**
         * jedis连接工厂
         * @param jedisPoolConfig
         * @return
         */
        @Bean
        public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            //设置redis服务器的host或者ip地址
            redisStandaloneConfiguration.setHostName(hostName);
            redisStandaloneConfiguration.setPort(port);
            redisStandaloneConfiguration.setPassword(password);
            redisStandaloneConfiguration.setDatabase(database);
            //获得默认的连接池构造
            //这里需要注意的是,edisConnectionFactoryJ对于Standalone模式的没有(RedisStandaloneConfiguration,JedisPoolConfig)的构造函数,对此
            //我们用JedisClientConfiguration接口的builder方法实例化一个构造器,还得类型转换
            JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcf = (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
            //修改我们的连接池配置
            jpcf.poolConfig(jedisPoolConfig);
            //通过构造器来构造jedis客户端配置
            JedisClientConfiguration jedisClientConfiguration = jpcf.build();
            return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
        }
    
        @Bean
        public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory){
            return RedisCacheManager.create(connectionFactory);
        }
    
        /**
         * 实例化 RedisTemplate
         * @param redisConnectionFactory
         * @return
         */
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            // 使用Jackson2JsonRedisSerialize 替换默认序列化
            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);
    
            //设置value的序列化规则和 key的序列化规则
            RedisSerializer stringSerializer = new StringRedisSerializer(Charset.forName("UTF8"));
            redisTemplate.setKeySerializer(stringSerializer );
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(stringSerializer );
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
    }
    
    

    创建RedisUtils.java工具类

    package com.example.framework.util;
    
    import com.example.common.utils.spring.SpringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * redis 工具类
     * @author: example
     * @create: 2019/5/31
     */
    public class RedisUtils {
        /**
         * 日志对象
         */
        private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);
    
        /**
         * The constant RUN_MESSAGE.
         */
        private static RedisTemplate redisTemplate = SpringUtils.getBean("redisTemplate");
        /**
         * 指定缓存失效时间
         * @param key 键
         * @param time 时间(秒)
         * @return
         */
        public static boolean expire(String key,long time){
            try {
                if(time>0){
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils expire(String key,long time) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public static long getExpire(String key){
            return redisTemplate.getExpire(key,TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public static boolean hasKey(String key){
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                logger.error("RedisUtils hasKey(String key) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public static void del(String ... key){
            if(key!=null&&key.length>0){
                if(key.length==1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public static Object get(String key){
            return key==null?null:redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         * @param key 键
         * @param value 值
         * @return true成功 false失败
         */
        public static boolean set(String key,Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils set(String key,Object value) failure."+e.getMessage());
                return false;
            }
    
        }
    
        /**
         * 普通缓存放入并设置时间
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public static 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) {
                logger.error("RedisUtils set(String key,Object value,long time) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 递增
         * @param key 键
         * @param  delta
         * @return
         */
        public static 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 static long decr(String key, long delta){
            if(delta<0){
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        /**
         * HashGet
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public static Object hget(String key,String item){
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         * @param key 键
         * @return 对应的多个键值
         */
        public static Map<Object,Object> hmget(String key){
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public static boolean hmset(String key, Map<String,Object> map){
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils hmset(String key, Map<String,Object> map) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         * @param key 键
         * @param map 对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public static 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) {
                logger.error("RedisUtils hmset(String key, Map<String,Object> map, long time) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @return true 成功 false失败
         */
        public static boolean hset(String key,String item,Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils hset(String key,String item,Object value) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public static 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) {
                logger.error("RedisUtils hset(String key,String item,Object value,long time) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         * @param key 键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public static void hdel(String key, Object... item){
            redisTemplate.opsForHash().delete(key,item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public static boolean hHasKey(String key, String item){
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         * @param key 键
         * @param item 项
         * @param by 要增加几(大于0)
         * @return
         */
        public static 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 static double hdecr(String key, String item,double by){
            return redisTemplate.opsForHash().increment(key, item,-by);
        }
    
        /**
         * 根据key获取Set中的所有值
         * @param key 键
         * @return
         */
        public static Set<Object> sGet(String key){
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                logger.error("RedisUtils sGet(String key) failure."+e.getMessage());
                return null;
            }
        }
    
        /**
         * 根据value从一个set中查询,是否存在
         * @param key 键
         * @param value 值
         * @return true 存在 false不存在
         */
        public static boolean sHasKey(String key,Object value){
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                logger.error("RedisUtils sHasKey(String key,Object value) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         * @param key 键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public static long sSet(String key, Object...values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                logger.error("RedisUtils sSet(String key, Object...values) failure."+e.getMessage());
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         * @param key 键
         * @param time 时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public static  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) {
                logger.error("RedisUtils sSetAndTime(String key,long time,Object...values) failure."+e.getMessage());
                return 0;
            }
        }
    
        /**
         * 获取set缓存的长度
         * @param key 键
         * @return
         */
        public static  long sGetSetSize(String key){
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                logger.error("RedisUtils sGetSetSize(String key) failure."+e.getMessage());
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         * @param key 键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public static  long setRemove(String key, Object ...values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                logger.error("RedisUtils setRemove(String key, Object ...values) failure."+e.getMessage());
                return 0;
            }
        }
    
        /**
         * 获取list缓存的内容
         * @param key 键
         * @param start 开始
         * @param end 结束  0 到 -1代表所有值
         * @return
         */
        public static  List<Object> lGet(String key, long start, long end){
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                logger.error("RedisUtils lGet(String key, long start, long end) failure."+e.getMessage());
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         * @param key 键
         * @return
         */
        public static  long lGetListSize(String key){
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                logger.error("RedisUtils lGetListSize(String key) failure."+e.getMessage());
                return 0;
            }
        }
    
        /**
         * 通过索引 获取list中的值
         * @param key 键
         * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @return
         */
        public static  Object lGetIndex(String key,long index){
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                logger.error("RedisUtils lGetIndex(String key,long index) failure."+e.getMessage());
                return null;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public static  boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils lSet(String key, Object value) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public static  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) {
                logger.error("RedisUtils lSet(String key, Object value, long time) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public static  boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils lSet(String key, List<Object> value) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public static  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) {
                logger.error("RedisUtils lSet(String key, List<Object> value, long time) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 根据索引修改list中的某条数据
         * @param key 键
         * @param index 索引
         * @param value 值
         * @return
         */
        public static  boolean lUpdateIndex(String key, long index,Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                logger.error("RedisUtils lUpdateIndex(String key, long index,Object value) failure."+e.getMessage());
                return false;
            }
        }
    
        /**
         * 移除N个值为value
         * @param key 键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        public static long lRemove(String key,long count,Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
                logger.error("RedisUtils lRemove(String key,long count,Object value) failure."+e.getMessage());
                return 0;
            }
        }
    
    
    
    }
    
    

    注:欢迎指正

    展开全文
  • redis操作命令

    千次阅读 2016-04-20 16:14:06
    redis操作命令 一、KEYS/RENAME/DEL/EXISTS/MOVE/RENAMENX: #在Shell命令行下启动Redis客户端工具。 /> redis-cli #清空当前选择的数据库,以便于对后面示例的理解。 redis 127.0.0.1:6379> flushdb OK #添加...

    redis操作命令
    一、KEYS/RENAME/DEL/EXISTS/MOVE/RENAMENX:

     #在Shell命令行下启动Redis客户端工具。
        /> redis-cli
     #清空当前选择的数据库,以便于对后面示例的理解。
        redis 127.0.0.1:6379> flushdb
        OK
     #添加String类型的模拟数据。
        redis 127.0.0.1:6379> set mykey 2
        OK
        redis 127.0.0.1:6379> set mykey2 "hello"
        OK
     #添加Set类型的模拟数据。
        redis 127.0.0.1:6379> sadd mysetkey 1 2 3
        (integer) 3
     #添加Hash类型的模拟数据。
        redis 127.0.0.1:6379> hset mmtest username "stephen"
        (integer) 1
     #根据参数中的模式,获取当前数据库中符合该模式的所有key,从输出可以看出,该命令在执行时并不区分与Key关联的Value类型。
        redis 127.0.0.1:6379> keys my*
        1) "mysetkey"
        2) "mykey"
        3) "mykey2"
     #删除了两个Keys。
        redis 127.0.0.1:6379> del mykey mykey2
        (integer) 2
     #查看一下刚刚删除的Key是否还存在,从返回结果看,mykey确实已经删除了。
        redis 127.0.0.1:6379> exists mykey
        (integer) 0
     #查看一下没有删除的Key,以和上面的命令结果进行比较。
        redis 127.0.0.1:6379> exists mysetkey
        (integer) 1
     #将当前数据库中的mysetkey键移入到ID为1的数据库中,从结果可以看出已经移动成功。
        redis 127.0.0.1:6379> move mysetkey 1
        (integer) 1
     #打开ID为1的数据库。
        redis 127.0.0.1:6379> select 1
        OK
     #查看一下刚刚移动过来的Key是否存在,从返回结果看已经存在了。
        redis 127.0.0.1:6379[1]> exists mysetkey
        (integer) 1
     #在重新打开ID为0的缺省数据库。
        redis 127.0.0.1:6379[1]> select 0
        OK
     #查看一下刚刚移走的Key是否已经不存在,从返回结果看已经移走。
        redis 127.0.0.1:6379> exists mysetkey
        (integer) 0
     #准备新的测试数据。    
        redis 127.0.0.1:6379> set mykey "hello"
        OK
     #将mykey改名为mykey1
        redis 127.0.0.1:6379> rename mykey mykey1
        OK
     #由于mykey已经被重新命名,再次获取将返回nil。
        redis 127.0.0.1:6379> get mykey
        (nil)
     #通过新的键名获取。
        redis 127.0.0.1:6379> get mykey1
        "hello"
     #由于mykey已经不存在了,所以返回错误信息。
        redis 127.0.0.1:6379> rename mykey mykey1
        (error) ERR no such key
     #为renamenx准备测试key
        redis 127.0.0.1:6379> set oldkey "hello"
        OK
        redis 127.0.0.1:6379> set newkey "world"
        OK
     #由于newkey已经存在,因此该命令未能成功执行。
        redis 127.0.0.1:6379> renamenx oldkey newkey
        (integer) 0
     #查看newkey的值,发现它也没有被renamenx覆盖。
        redis 127.0.0.1:6379> get newkey
        "world"

    二、PERSIST/EXPIRE/EXPIREAT/TTL:

     #为后面的示例准备的测试数据。
        redis 127.0.0.1:6379> set mykey "hello"
        OK
     #将该键的超时设置为100秒。
        redis 127.0.0.1:6379> expire mykey 100
        (integer) 1
     #通过ttl命令查看一下还剩下多少秒。
        redis 127.0.0.1:6379> ttl mykey
        (integer) 97
     #立刻执行persist命令,该存在超时的键变成持久化的键,即将该Key的超时去掉。
        redis 127.0.0.1:6379> persist mykey
        (integer) 1
     #ttl的返回值告诉我们,该键已经没有超时了。
        redis 127.0.0.1:6379> ttl mykey
        (integer) -1
     #为后面的expire命令准备数据。
        redis 127.0.0.1:6379> del mykey
        (integer) 1
        redis 127.0.0.1:6379> set mykey "hello"
        OK
     #设置该键的超时被100秒。
        redis 127.0.0.1:6379> expire mykey 100
        (integer) 1
     #用ttl命令看一下当前还剩下多少秒,从结果中可以看出还剩下96秒。
        redis 127.0.0.1:6379> ttl mykey
        (integer) 96
     #重新更新该键的超时时间为20秒,从返回值可以看出该命令执行成功。
        redis 127.0.0.1:6379> expire mykey 20
        (integer) 1
     #再用ttl确认一下,从结果中可以看出果然被更新了。
        redis 127.0.0.1:6379> ttl mykey
        (integer) 17
     #立刻更新该键的值,以使其超时无效。
        redis 127.0.0.1:6379> set mykey "world"
        OK
     #从ttl的结果可以看出,在上一条修改该键的命令执行后,该键的超时也无效了。
        redis 127.0.0.1:6379> ttl mykey
        (integer) -1

    三、TYPE/RANDOMKEY/SORT:

     #由于mm键在数据库中不存在,因此该命令返回none。
        redis 127.0.0.1:6379> type mm
        none
     #mykey的值是字符串类型,因此返回string。
        redis 127.0.0.1:6379> type mykey
        string
     #准备一个值是set类型的键。
        redis 127.0.0.1:6379> sadd mysetkey 1 2
        (integer) 2
     #mysetkey的键是set,因此返回字符串set。
        redis 127.0.0.1:6379> type mysetkey
        set
     #返回数据库中的任意键。
        redis 127.0.0.1:6379> randomkey
        "oldkey"
     #清空当前打开的数据库。
        redis 127.0.0.1:6379> flushdb
        OK
     #由于没有数据了,因此返回nil。
        redis 127.0.0.1:6379> randomkey
        (nil)

     本文来自鹿伟伟博客专栏。转载请注明出处:http://blog.csdn.net/lu_wei_wei

    展开全文
  • Redis操作哈希结构数据

    千次阅读 2018-01-17 08:23:54
    今天带来的是Redis操作的第二部分:Redis操作Hash。总体上来讲与操作字符串的方式基本相同。hash类似于java中的map,存储的基本上都是String类型的key和value的键值对,在内存足够大的情况下,一个hash结构可以存储2...

      今天带来的是Redis操作的第二部分:Redis操作Hash。总体上来讲与操作字符串的方式基本相同。hash类似于java中的map,存储的基本上都是String类型的key和value的键值对,在内存足够大的情况下,一个hash结构可以存储2的32次方-1个键值对。但是需要注意的是,由于 redis是一个内存数据库, 所有数据基本上都存在于内存当中, 会定时以追加或者快照的方式刷新到硬盘中。所以当我们读取大量数据的时候,我们要考虑到对JVM内存的影响。
    同时在接下来我们的操作中我们会看到,Redis对hash 的操作与对字符串的操作相比,都会多一个hash名作为参数,这是需要注意的。

    Redis存hash数据

    添加整个Hash

       @RequestMapping("hmset")
        @ResponseBody
        public Map<String,Object> hmset(){
            Map<String,Object> map = new HashMap<>();
            map.put("f1","value1");
            map.put("f2","value2");
            stringRedisTemplate.opsForHash().putAll("hash",map);
            return  map;
        }

    由于此时我们存取的都是String类型的数据,所以我使用的依然是。StringRedisTemplete,上述操作完成后在可视化工具中可见
    这里写图片描述

    向已经存在的hash结构中添加或修改数据

        @RequestMapping("hset")
        @ResponseBody
        public Map<String,Object> hset(){
            Map<String,Object> map = new HashMap<>();
            stringRedisTemplate.opsForHash().put("hash","f1","new value1");
            return  map;
        }

    这里写图片描述

    可以看到数据已经被修改

    为hash添加数据

        @RequestMapping("hsetnx")
        @ResponseBody
        public void hsetnx(){
            Boolean success =  stringRedisTemplate.opsForHash().putIfAbsent("hash","f5","9");
            System.out.println(success);
        }

    putIfAbsent表示如果已经存在对应的key则不会添加,没有对应的key则添加,如图
    这里写图片描述

    判断Hash结构中是否有输入的key

        @RequestMapping("hexsit")
        @ResponseBody
        public void hexsit(){
          Boolean exsit =  stringRedisTemplate.opsForHash().hasKey("hash","f3");
          System.out.println(exsit);
        }

    根据我们插入的数据,最后控制台输出了false

    获取hash中的所有键值对

        @RequestMapping("hgetall")
        @ResponseBody
        public Map<Object,Object> hgetall(){
           Map<Object,Object> map=  stringRedisTemplate.opsForHash().entries("hash");
            return  map;
        }

    结果可见如图这里写图片描述

    hash实现加法

       @RequestMapping("hincrby")
        @ResponseBody
        public void hincrby(){
            stringRedisTemplate.opsForHash().put("hash","f4","8");
             Long f4 =    stringRedisTemplate.opsForHash().increment("hash","f4",6);
             System.out.println(f4);
        }

    这里写图片描述

    hash实现获取所有key的值

        @RequestMapping("hvals")
        @ResponseBody
        public void hvals(){
            List<Object> list = stringRedisTemplate.opsForHash().values("hash");
            for (int i =0;i<list.size();i++){
                System.out.println(list.get(i));
            }
        }

    可见控制台输出
    这里写图片描述

    hash实现 删除元素

        @RequestMapping("hdel")
        @ResponseBody
        public void hdel(){
            //返回真实删除的个数
            Long count =  stringRedisTemplate.opsForHash().delete("hash","f2","f3");
            System.out.println(count);//此处返回1
        }

    此时数据库中不存在f3,控制台中输出了1.

    展开全文
  • c#使用servicestack.redis操作redis

    千次阅读 2014-03-21 16:47:37
    在c#中使用servicestack.redis操作redis


    第一步:添加dll引用:

    using ServiceStack.Common.Extensions;
    using ServiceStack.Redis;
    using ServiceStack.Redis.Generic;
    using ServiceStack.Text;
    using ServiceStack.Redis.Support;


    第二步:声明一个客户端对象:

    protected RedisClient Redis = new RedisClient("127.0.0.1", 6379);//redis服务IP和端口


    以下为具体的一些操作


    一 .基本KEY/VALUE键值对操作:
        1. 添加/获取: 

     List<string> storeMembers = new List<string>();
     storeMembers.ForEach(x => Redis.AddItemToList("test", x));

        注:也可直接使用AddRangeToList方法将一组数据装入如:

          Redis.AddRangeToList("testt", storeMembers);


        2. 获取数据

      var members = Redis.GetAllItemsFromList("test");
      members.ForEach(s => Response.Write("<br/>test :" + s));

      
        3. 获取指定索引位置数据 

      var item = Redis.GetItemFromList("test", 2);
      
        4. 移除:

      var list = Redis.Lists["test"];
      list.Clear();//清空
      list.Remove("two");//移除指定键值
      list.RemoveAt(2);//移除指定索引位置数据

     

    二.存储对象:

        public class UserInfo
        {
            public long Id { set; get; }
            public string UserName { get; set; }
            public int Age { get; set; }
        }

      
        1.通常方式(底层使用json序列化):

      Redis.Set<UserInfo>("userinfo", new UserInfo() { UserName = "李四", Age = 45 });
      UserInfo userinfo = Redis.Get<UserInfo>("userinfo");

      
        注:当然上面方式也适合于基本类型,如:

        Redis.Set<int>("my_age", 12);//或Redis.Set("my_age", 12);
        int age = Redis.Get<int>("my_age");

        
        2.object序列化方式存储: 

      var ser = new ObjectSerializer();    //位于namespace ServiceStack.Redis.Support;
      bool result = Redis.Set<byte[]>("userinfo", ser.Serialize(new UserInfo() { UserName = "张三", Age = 12 }));
      UserInfo userinfo = ser.Deserialize(Redis.Get<byte[]>("userinfo")) as UserInfo;
      //也支持列表
      Redis.Set<byte[]>("userinfolist_serialize", ser.Serialize(userinfoList));
      List<UserInfo> userList = ser.Deserialize(Redis.Get<byte[]>("userinfolist_serialize")) as List<UserInfo>;

     

        需要说明的是在测试过程中发现JSON序列化的效率要比object序列化高一些。
      
    三.存储表格对象,比如: 

      using (var redisUsers = Redis.GetTypedClient<UserInfo>())
      {
          redisUsers.Store(new UserInfo { Id = redisUsers.GetNextSequence(), UserName = "test1", Age = 22 });
          redisUsers.Store(new UserInfo { Id = redisUsers.GetNextSequence(), UserName = "test2", Age = 23 });

          var allUsers = redisUsers.GetAll();//就像操作ado对象一样,可以进行CRUD等操作
          allUsers.ForEach(s => Response.Write("<br/>user :" + s.UserName + " age:" + s.Age));
      }

     

          
    四.使用客户端链接池模式提升链接速度: 

      public static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
      {
           //支持读写分离,均衡负载
           return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
           {
               MaxWritePoolSize = 5,//“写”链接池链接数
               MaxReadPoolSize = 5,//“写”链接池链接数
               AutoStart = true,
           });          
      }


      
         声明链接池对象(这里只使用一个redis服务端):

      PooledRedisClientManager prcm = CreateManager(new string[] { "127.0.0.1:6379" }, new string[] { "127.0.0.1:6379" });
     
      List<UserInfo> userinfoList = new List<UserInfo>();
      userinfoList.Add(new UserInfo() { UserName = "pool_daizhj", Age = 1 });
      userinfoList.Add(new UserInfo() { UserName = "pool_daizhj1", Age = 2 });
              
        从池中获取一个链接:


      using (IRedisClient Redis = prcm.GetClient())
      {              
           Redis.Set("userinfolist", userinfoList);
           List<UserInfo> userList = Redis.Get<List<UserInfo>>("userinfolist");
      }

     

    注:
    如只想使用长链接而不是链接池的话,可以直接将下面对象用static方式声明即可:  
    protected static RedisClient Redis = new RedisClient("127.0.0.1", 6379); 
    这样在redis服务端显示只有一个客户链接


    展开全文
  • 采用spring-data-redis 操作redis 单机和集群的例子
  • 在之前的博客《 EasyDarwin幼教云视频平台在幼教...随着幼儿园平台用户和接入幼儿园的数量不断增加,EasyCMS的redis操作也越来越频繁,我们在运维中发现EasyCMS的cpu占用非常高,通过线程分析,发现大家都在等待一个r
  • TP框架里怎么扩展redis操作?通过扩展redis类?操作redis就像操作mysql数据库一样
  • Python——redis操作手册

    千次阅读 2018-01-18 17:25:40
    Redis操作手册 一、Redis简介 1.概述 Redis是一个开源(BSD许可),内存存储的数据结构服务器,可用作数据库,高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合,位图,hyperloglogs等数据...
  • Spring-Data-Redis项目(简称SDR)对Redis的Key-Value数据存储操作提供了更高层次的抽象,类似于Spring Framework对JDBC支持一样。 项目主页:http://projects.spring.io/spring-data-redis/ 项目文档:...
  • spring data redis 操作redis

    千次阅读 2015-12-14 09:52:56
    这篇文章主要说spring data redis 集成jedis操作 redis中的数据。
  • redis队列使用基于python的redis操作

    千次阅读 2018-09-27 15:13:05
    本文重点标题redis-python简单交互python直接连接redis,并进行简单设置操作python通过连接池连接redis,并进行简单设置操作redis队列操作redis-MQlpush, lrangerpoprpush,lpop小结 redis-python简单交互 关于...
  • Laravel Redis操作大全

    千次阅读 2020-09-30 23:56:43
    1,普通得set/get操作,set操作,如果键名存在,则会覆盖原有得值 $redis = app("redis.connection"); $redis->set('library' , 'phpredis');//存储key为library ,值phpredis得记录 $redis->get("library...
  • PHP redis操作类 个人总结

    千次阅读 2014-07-18 17:43:41
    PHP redis操作类 个人总结
  • Redis操作list

    千次阅读 2017-06-16 16:09:32
    思来想去感觉redis中的list没什么好写的,如果单写几个命令的操作过于乏味,所以本篇最后我会根据redis中list数据类型的特殊属性,同时对比成熟的消息队列产品rabbitmq,使用redis实现一个消息队列。  为啦让本...
  • redis操作记录

    千次阅读 2016-12-15 19:28:38
    关于redis的使用配置: 1.window下: 下载redis的压缩包,解压后运行redis-server.exe文件就可以启动redis的服务了。redis默认是没有密码的, 在实际项目的使用中是需要配置密码的,配置密码可以在redisredis....
  • 使用Spring-data进行Redis操作

    千次阅读 2016-08-22 20:43:24
    使用Spring-data进行Redis操作 Redis相信大家都听说过,它是一个开源的key-value缓存数据库,有很多Java的客户端支持,比较有名的有Jedis,JRedis等(见这里)。当然我们可以使用客户端的原生代码实现redis...
  • Redis操作string

    千次阅读 2017-06-16 16:07:51
    Redis还支持对这些数据类型做更多的服务端操作,从而也能减少网路的IO次数与数据体积,这里也比Memcached要方便与高效,只针对这一点啊,想喷的左上角群喷。上篇吹牛逼20分钟教你做memcached大神 Redis主要支持的...
  • shell脚本redis操作--遍历key保存value

    千次阅读 2018-10-16 11:24:25
    shell脚本redis操作–遍历key保存value shell脚本redis操作 脚本分2部,redis查询出所需要的key,然后遍历key查询出所有的value追加到文件中; (**想法:**本来是要循环遍历满足条件key的结果集的,但是失败了,...
  • redis 操作记录

    2015-09-18 16:10:02
    wget http://download.redis.io/releases/redis-3.0.4.tar.gz //下载redis tar -zxf redis-3.0.4.tar.gz //解压 make --PREFIX="usr/local/redis" install //安装到指定目录 redis-server --daemonize yes --...
  • Redis操作hash数据

    千次阅读 2019-02-16 12:57:04
    Redis数据结构及操作string数据 在 Redis 中,hash 数据也是很常用的一种值类型。 hash 类型的值可用于存储对象,对象的结构为属性、值(也属于 key-value 类型),ad其中值的类型也必须是 strin...
  • Redis操作记录

    千次阅读 2014-09-09 11:02:29
    贴一些redis的基本操作,方便查阅。
  • redis操作token

    千次阅读 2017-04-02 08:36:10
    创建一个常量TOKEN_LIST_NAME="tokenList" 创建一个常量TOKEN_STRING_...1、从redis中通过TOKEN_LIST_NAME获得Object对象(这个对象是一个ArrayList集合) 2、判断这个obj是否为空,不为空直接强转obj为ArrayList对象
  • laravel redis 操作命令集

    万次阅读 2018-06-27 10:39:05
    简介 Redis模块负责与Redis数据库交互,并提供Redis的相关API支持;...redis服务提供Illuminate\Redis\RedisManager对象,负责与Redis打交道的这部分管理工作; 配置项 以下是笔者的示例;default是默认的R...
  • Golang的Redis操作

    千次阅读 2017-08-09 14:07:35
    背景本篇博客主要讲解在kubernetes集群中,如何使用go语言对Redis进行操作。 在此之前要有此基础: 1. 安装并会使用go语言 2. 配置好了kubernetes 3. 在kubernetes中配置好了redis service连接使用go连接Redis...
  • python redis 操作dict

    千次阅读 2018-11-07 20:10:42
      #coding=utf-8 import time import numpy as np import redis ...pool = redis.ConnectionPool(host='localhost', port=6379, db=0) red = redis.StrictRedis(connection_pool=pool) for i in rang...
  • python操作redis操作方法实例

    千次阅读 2017-12-19 15:33:42
    转载自:...连接数据库 StrictRedis ``` from redis import StrictRedis 使用默认方式连接到数据库 redis = StrictRedis(host='localhost', port=6379, db=0) 使用url方式连接到数据库 redis = ...
  • linux redis操作小记

    千次阅读 2017-07-21 10:29:59
    [root@pc ~] ps -ef | grep redis [root@pc ~] ll /etc/redis [root@pc ~] ll/etc/redis.conf [root@pc ~] service stop redis [root@pc ~] ps -ef | grep redis [root@pc

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,226
精华内容 24,090
关键字:

redis操作

redis 订阅