redis操作

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依赖如图 <!--...


springboot 整合redis 操作
修改xml配置文件 pom.xml
修改配置文件application.yml 文件
增加RedisConfig.java配置类
创建RedisUtils.java工具类

修改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;
        }
    }



}


注：欢迎指正

收起

展开全文

springboot

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.

收起

展开全文

哈希 hash nosql

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 单机版和集群
万次阅读 2016-08-23 18:03:11
采用spring-data-redis 操作redis 单机和集群的例子
收起
java
EasyCMS在幼儿园视频直播项目实战中以redis操作池的方式应对高并发的redis操作问题
千次阅读 2017-05-29 18:28:00
在之前的博客《 EasyDarwin幼教云视频平台在幼教...随着幼儿园平台用户和接入幼儿园的数量不断增加，EasyCMS的redis操作也越来越频繁，我们在运维中发现EasyCMS的cpu占用非常高，通过线程分析，发现大家都在等待一个r
收起
EasyDarwin EasyCMS
TP框架里怎么扩展redis操作
2015-07-20 07:28:07
TP框架里怎么扩展redis操作？通过扩展redis类？操作redis就像操作mysql数据库一样
收起
php
Python——redis操作手册
千次阅读 2018-01-18 17:25:40
Redis操作手册一、Redis简介 1.概述 Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据...
收起
使用Spring Data Redis操作Redis（一）很全面
万次阅读 2016-05-24 22:16:51
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中的数据。
收起
jedis
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默认是没有密码的，在实际项目的使用中是需要配置密码的，配置密码可以在redis 的redis....
收起
使用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的结果集的，但是失败了，...
收起
shell shell keys value
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
Redis操作记录
千次阅读 2014-09-09 11:02:29
贴一些redis的基本操作，方便查阅。
收起
缓存 linux
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...
收起
集群 golang
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
收起

springboot 整合redis 操作

springboot 整合redis 操作

修改xml配置文件 pom.xml

修改配置文件application.yml 文件

增加RedisConfig.java配置类

创建RedisUtils.java工具类

redis操作命令

Redis操作哈希结构数据

Redis存hash数据

添加整个Hash

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

为hash添加数据

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

获取hash中的所有键值对

hash实现加法

hash实现获取所有key的值

hash实现 删除元素

c#使用servicestack.redis操作redis

spring data redis 操作redis 单机版和集群

EasyCMS在幼儿园视频直播项目实战中以redis操作池的方式应对高并发的redis操作问题

TP框架里怎么扩展redis操作

Python——redis操作手册

使用Spring Data Redis操作Redis（一） 很全面

spring data redis 操作redis

redis队列使用基于python的redis操作

Laravel Redis操作大全

PHP redis操作类 个人总结

Redis操作list

redis操作记录

使用Spring-data进行Redis操作

Redis操作string

shell脚本redis操作--遍历key保存value

redis 操作记录

Redis操作hash数据

Redis操作记录

redis操作token

laravel redis 操作命令集

Golang的Redis操作

python redis 操作dict

python操作redis操作方法实例

linux redis操作小记

redis操作

不平衡样本的分类实践---Credit-Card-Fraud-Detection

CentOS 命令行模式图形界面模式切换

佳能打印机G2800不需要软件的清零方法.txt

[蓝桥杯] 填算式 python解法

Galera 高可用 MySQL 集群（PXC v5.6 + Ngin

Windows系统管理

零基础一小时极简以太坊智能合约开发环境搭建并开发部署

【考研初试】安徽建筑大学703艺术设计理论考研真题库资料

零基础极简以太坊智能合约开发环境搭建并开发部署

Java中的注解

MaxScale 实现 MySQL 读写分离与负载均衡

access应用的3个开发实例

U盘量产软件.zip

金三银四：2021阿里巴巴天猫-春招来袭

Mycat 实现 MySQL的分库分表、读写分离、主从切换

联想EXCEL培训资料.ppt

各种格式测试视频(.avi.wmv.mkv.mp4.mov.rm)

MHA 高可用 MySQL 架构与 Altas 读写分离

139网站可用性测试报告.pdf

Sandwich Transformers 架构

hash实现删除元素

使用Spring Data Redis操作Redis（一）很全面

PHP redis操作类个人总结