Spring Boot 实战：集成 Redis

分手后的思念是犯贱 2022-02-04 06:45 251阅读 0赞

**我们上篇文章写的是 Boot 的入门篇，集成了 MyBatis，所以这一章，就不在介绍 Boot 的详细使用了如果有不了解的朋友可以去看博主的上一篇文章：**[https://blog.csdn.net/qq\_36537546/article/details/89842305][https_blog.csdn.net_qq_36537546_article_details_89842305]

**不说废话了，直接进入正题，首先介绍一下什么是 Redis ??**

redis 是一个开源的使用 ANSI [C语言][C]编写、支持网络、可基于内存亦可持久化的日志型、Key-Value [数据库][Link 1] 和 Memcached 类似，它支持存储的 value 类型相对更多，包括 String(字符串)、List([链表][Link 2])、Set(集合)、Zset(Sorted set --有序集合) 和 Hash（哈希类型），这些数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的，在此基础上，redis 支持各种不同方式的排序。与 memcached 一样，为了保证效率，数据都是缓存在内存中，区别的是 redis 会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了 master-slave (主从)同步，redis 的出现，很大程度补偿了 memcached 这类 key/value 存储的不足，在部分场合可以对关系数据库起到很好的补充作用，它提供了 Java，C/C++，C\#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang 等客户端，使用很方便，redis 支持主从同步，数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得 redis 可执行单层树复制，存盘可以有意无意的对数据进行写操作，由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录，同步对读取操作的可扩展性和数据冗余很有帮助。

**为什么要用 redis ??**

在单机时代，存储只用一台机器装 mysql，如果每次存储成千上万条数据，这样很会导致 mysql 的性能很差，存储以及读取速度很慢，然后就演变成 缓存+mysql+垂直拆分 的方式，cache 作为中间缓存，将所有的数据先保存到缓存中，然后再存入mysql中，减小数据库压力，提高效率，但是当数据再次增加到又一个量级，上面的方式也不能满足需求，由于数据库的写入压力增加，缓存只能缓解数据库的读取压力，读写集中在一个数据库上让数据库不堪重负，大部分网站开始使用主从复制技术来达到读写分离，以提高读写性能和读库的可扩展性

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTM3NTQ2_size_16_color_FFFFFF_t_70][]

**为什么要选择 redis??**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTM3NTQ2_size_16_color_FFFFFF_t_70 1][]

\--------------------------------------------------- 关于 Redis 介绍到此结束 ------------------------------------------------------

**首先配置 pom.xml 文件**

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

**然后配置 application.properties **

### Redis 缓存配置
    ### 默认 redis 数据库为 db 0
    spring.redis.database=0
    ### 服务器地址 127.0.0.1
    spring.redis.host=127.0.0.1
    ### 链接端口，默认6379
    spring.redis.port=6379
    ### redis 默认密码为空
    spring.redis.password=

**依次配置 redis 的配置文件 **

**redis.properties **

redis.hostName=127.0.0.1
    redis.port=6379
    redis.password=
    redis.timeout=10000
              
    redis.maxIdle=300
    redis.maxTotal=1000
    redis.maxWaitMillis=1000
    redis.minEvictableIdleTimeMillis=300000
    redis.numTestsPerEvictionRun=1024
    redis.timeBetweenEvictionRunsMillis=30000
    redis.testOnBorrow=true
    redis.testWhileIdle=true

**JedisUtil**

package org.cs.redis.redis;
    
    import com.alibaba.druid.util.StringUtils;
    import org.apache.log4j.Logger;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * @title: JedisUtil
     * @auther: linluochen
     * @date: 2019/5/7 9:39
     */
    public class JedisUtil {
    
    	protected static ReentrantLock lockPool = new ReentrantLock();  
        protected static ReentrantLock lockJedis = new ReentrantLock();  
      
        protected static Logger logger = Logger.getLogger(JedisUtil.class);
    
        //Redis服务器IP  
        private static String ADDR_ARRAY = "127.0.0.1";
      
        //Redis的端口号  
        private static int PORT = 6379;  
      
        //访问密码  
        private static String AUTH = "";
        //可用连接实例的最大数目，默认值为8；  
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。  
        private static int MAX_ACTIVE = 300;  
      
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。  
        private static int MAX_IDLE = 8;  
      
        //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；  
        private static int MAX_WAIT = 3000;  
      
        //超时时间  
        private static int TIMEOUT = 10000;  
      
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；  
        private static boolean TEST_ON_BORROW = true;  
        private static boolean TEST_WhileIdle = true;  
        private static JedisPool jedisPool = null;  
      
        /** 
         * redis过期时间,以秒为单位 
         */  
        public final static int EXRP_HOUR = 60 * 60;            //一小时  
        public final static int EXRP_DAY = 60 * 60 * 24;        //一天  
        public final static int EXRP_MONTH = 60 * 60 * 24 * 30; //一个月  
      
        /** 
         * 初始化Redis连接池 
         */  
        private static void initialPool() {  
            try {  
                JedisPoolConfig config = new JedisPoolConfig();  
                config.setMaxTotal(MAX_ACTIVE);  
                config.setMaxIdle(MAX_IDLE);  
                config.setMaxWaitMillis(MAX_WAIT);  
                config.setTestOnBorrow(TEST_ON_BORROW);  
                config.setTestWhileIdle(TEST_WhileIdle);
                jedisPool = new JedisPool(config, ADDR_ARRAY.split(",")[0], PORT, TIMEOUT, AUTH,0);  
            } catch (Exception e) {  
                logger.error("First create JedisPool error : " + e);  
                try {  
                    //如果第一个IP异常，则访问第二个IP  
                    JedisPoolConfig config = new JedisPoolConfig();  
                    config.setMaxTotal(MAX_ACTIVE);  
                    config.setMaxIdle(MAX_IDLE);  
                    config.setMaxWaitMillis(MAX_WAIT);  
                    config.setTestOnBorrow(TEST_ON_BORROW);  
                    config.setTestWhileIdle(TEST_WhileIdle);
                    jedisPool = new JedisPool(config, ADDR_ARRAY.split(",")[1], PORT, TIMEOUT, AUTH,0);  
                } catch (Exception e2) {  
                    logger.error("Second create JedisPool error : " + e2);  
                }  
            }  
        }  
      
        /** 
         * 在多线程环境同步初始化 
         */  
        private static void poolInit() {  
            lockPool.lock();  
            try {  
                if (jedisPool == null) {  
                    initialPool();  
                }  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                lockPool.unlock();  
            }  
        }  
      
        public static Jedis getJedis() {  
            lockJedis.lock();  
            if (jedisPool == null) {  
                poolInit();  
            }  
            Jedis jedis = null;  
            try {  
                if (jedisPool != null) {  
                    jedis = jedisPool.getResource();  
                }  
            } catch (Exception e) {  
                logger.error("Get jedis error : " + e);  
            } finally {  
                returnResource(jedis);  
                lockJedis.unlock();  
            }  
            return jedis;  
        }  
      
        /** 
         * 释放jedis资源 
         * 
         * @param jedis 
         */  
        public static void returnResource(final Jedis jedis) {  
            if (jedis != null && jedisPool != null) {  
                jedisPool.returnResource(jedis);  
            }  
        }  
      
        /** 
         * 设置 String 
         * 
         * @param key 
         * @param value 
         */  
        public synchronized static void setString(String key, String value) {  
            try {  
                value = StringUtils.isEmpty(value) ? "" : value;
                getJedis().set(key, value);  
            } catch (Exception e) {  
                logger.error("Set key error : " + e);  
            }  
        }  
      
        /** 
         * 设置 过期时间 
         * 
         * @param key 
         * @param seconds 以秒为单位 
         * @param value 
         */  
        public synchronized static void setString(String key, int seconds, String value) {  
            try {  
                value = StringUtils.isEmpty(value) ? "" : value;
                getJedis().setex(key, seconds, value);  
            } catch (Exception e) {  
                logger.error("Set keyex error : " + e);  
            }  
        }  
        
        /** 
         * 删除
         * 
         * @param key
         */  
        public synchronized static void delString(String key) {  
            try {  
                if(!StringUtils.isEmpty(key)) {
                	getJedis().del(key);
                }
            } catch (Exception e) {  
                logger.error("Set key error : " + e);  
            }  
        }  
      
        /** 
         * 获取String值 
         * 
         * @param key 
         * @return value 
         */  
        public synchronized static String getString(String key) {  
            if (getJedis() == null || !getJedis().exists(key)) {  
                return null;  
            }  
            return getJedis().get(key);  
        }
    }

**RedisConfig**

package org.cs.redis.redis;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.RedisPassword;
    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.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import redis.clients.jedis.JedisPoolConfig;
    
    @Configuration
    @PropertySource("classpath:config/redis.properties")
    public class RedisConfig {
    
    	@Value("${redis.hostName}")
    	private String hostName;
    
    	@Value("${redis.port}")
    	private Integer port;
    
    	@Value("${redis.password}")
    	private String password;
    
    	@Value("${redis.timeout}")
    	private Integer timeout;
    
    	@Value("${redis.maxIdle}")
    	private Integer maxIdle;
    	
    	@Value("${redis.maxTotal}")
    	private Integer maxTotal;
    	
    	@Value("${redis.maxWaitMillis}")
    	private Integer maxWaitMillis;
    	
    	@Value("${redis.minEvictableIdleTimeMillis}")
    	private Integer minEvictableIdleTimeMillis;
    	
    	@Value("${redis.numTestsPerEvictionRun}")
    	private Integer numTestsPerEvictionRun;
    	
    	@Value("${redis.timeBetweenEvictionRunsMillis}")
    	private long timeBetweenEvictionRunsMillis;
    	
    	@Value("${redis.testOnBorrow}")
    	private boolean testOnBorrow;
    	
    	@Value("${redis.testWhileIdle}")
    	private boolean testWhileIdle;
    	
    		
    	/*@Value("${spring.redis.cluster.nodes}")
    	private String clusterNodes; */
    	
    	/*@Value("${spring.redis.cluster.max-redirects}")
    	private Integer mmaxRedirectsac;*/
    		
    	/**
    	 * 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;
    	}
    	
    	/**
    	 * 单机版配置
    	* @Title: JedisConnectionFactory 
    	* @param @param jedisPoolConfig
    	* @param @return
    	* @return JedisConnectionFactory
    	* @autor Alex
    	* @date 2019年3月18日
    	* @throws
    	 */
    	@Bean
    	public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
    		//单机版jedis
            RedisStandaloneConfiguration redisStandaloneConfiguration =
                    new RedisStandaloneConfiguration();
            //设置redis服务器的host或者ip地址
            redisStandaloneConfiguration.setHostName(hostName);
            //设置默认使用的数据库
            redisStandaloneConfiguration.setDatabase(0);
            //设置密码
            redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
            //设置redis的服务的端口号
            redisStandaloneConfiguration.setPort(port);
            //获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢)
            JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
                    (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
            //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）
            jpcb.poolConfig(jedisPoolConfig);
            //通过构造器来构造jedis客户端配置
            JedisClientConfiguration jedisClientConfiguration = jpcb.build();
            //单机配置 + 客户端配置 = jedis连接工厂
            return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
    
    		/*RedisStandaloneConfiguration redisStandaloneConfiguration=new RedisStandaloneConfiguration();
    		redisStandaloneConfiguration.setHostName(hostName);
    		redisStandaloneConfiguration.setPort(port);
    		redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
    		redisStandaloneConfiguration.setDatabase(0);
    		return new JedisConnectionFactory(redisStandaloneConfiguration);*/
    		//return JedisConnectionFactory;
    	}
    
    	/**
    	 * 实例化 RedisTemplate 对象
    	 *
    	 * @return
    	 */
    	@Bean
    	public RedisTemplate<String, Object> functionDomainRedisTemplate() {
    		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    		initDomainRedisTemplate(redisTemplate, JedisConnectionFactory(jedisPoolConfig()));
    		return redisTemplate;
    	}
    	/**
    	 * 设置数据存入 redis 的序列化方式,并开启事务
    	 * @autor Alex
    	 * @param redisTemplate
    	 * @param factory
    	 */
    	private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
    		//如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！  
    		redisTemplate.setKeySerializer(new StringRedisSerializer());
    		redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    		redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    		redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    		// 开启事务
    		redisTemplate.setEnableTransactionSupport(true);
    		redisTemplate.setConnectionFactory(factory);
    		redisTemplate.afterPropertiesSet();
    	}
    	/**
    	 * 注入redisUtil
    	* @Title: redisUtil 
    	* @param @param redisTemplate
    	* @param @return
    	* @return RedisUtil
    	* @autor Alex
    	* @date 2018年8月17日
    	* @throws
    	 */
    	@Bean(name = "redisUtil")
    	public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
    		RedisUtil redisUtil = new RedisUtil();
    		redisUtil.setRedisTemplate(redisTemplate);
    		return redisUtil;
    	}
    }

**RedisUtil**

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

**配置完成后测试调用：**

package com.cs.redis;
    
    import com.cs.redis.config.RedisUtil;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class RedisApplicationTests {
    
        @Autowired
        RedisUtil redisUtil;
    
        @Test
        public void contextLoads() {
        }
    
        @Test
        public void RedisTest(){
            Map<String,Object> map = new HashMap<String, Object>();
            String luochen = "linluochen"; // 定义它 Key 的名称
            String search = "小洛儿"; // 定义它的 Value
            redisUtil.set(luochen,search); // 放进 redis 里
            String redis = (String) redisUtil.get(luochen); //取出值的时候直接去 Key 的名字就可以了，因为取出的值是object类型的所以需要给他强制转换一下
            System.out.println("结果为："+redis); //输出结果
            /*List<String> list = (List<String>) redisUtil.get(luochen);
            if(StringUtils.isNotBlank(search)) {
                if(list != null) {
                    list.add(0,search);
                    redisUtil.set(luochen, list,60L*60*24*30);
                    map.put("historical",list.size()<=6?list:list.subList(0, 6));
                }else {
                    List<String> searchList = new ArrayList<String>();
                    searchList.add(search);
                    redisUtil.set(luochen, searchList,60L*60*24*30);
                    map.put("historical",searchList);
                }
                System.out.println("执行成功 ！！！！"+map); // 打印值
            }else {
                map.put("historical",list.size()<=6?list:list.subList(0, 6));
            }*/
        }
    
    }

**调用结果为：**

![20190507104508272.png][]

**示例地址：[https://download.csdn.net/download/qq\_36537546/11163687][https_download.csdn.net_download_qq_36537546_11163687]**

[https_blog.csdn.net_qq_36537546_article_details_89842305]: https://blog.csdn.net/qq_36537546/article/details/89842305
[C]: https://baike.baidu.com/item/C%E8%AF%AD%E8%A8%80
[Link 1]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%BA%93/103728
[Link 2]: https://baike.baidu.com/item/%E9%93%BE%E8%A1%A8
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTM3NTQ2_size_16_color_FFFFFF_t_70]: /images/20220204/014d1f8a9c7b45bea50af3e9ad1a3a8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTM3NTQ2_size_16_color_FFFFFF_t_70 1]: /images/20220204/6ecaac091f9a459b9994034cab6e1c5c.png
[20190507104508272.png]: /images/20220204/810a0c69364b47a096272a5db0bcf10c.png
[https_download.csdn.net_download_qq_36537546_11163687]: https://download.csdn.net/download/qq_36537546/11163687