springboot_04,集成redis问题总结

矫情吗；* 2022-05-29 12:27 213阅读 0赞

今天准备结合一下redis，有常用功能就行，结果烦了一天！

在网上找了很久，发现都写了很多代码，看着没思路，后来硬着头皮试试，一会这块不对，一会儿那块有问题，还写了一堆代码，后来无意中看到springboot 2.0了，看着简单，自己就去试了，还是不行，找不到redisConnection。就去看官网文档，全是英文，没办法，只能拿有道去翻译，出来了各种笑话，最后看到了一篇翻译好的，在就结合其他高手的代码，才发现自己的问题！springboot2.0（我没有看其他版本）做缓存的时候，默认的是io.lettuce:lettuce-core，而不是我们平常用的jedis,我将这个排除后，没有手动加上jedis依赖导致一直报错，我还以为它都有效，自己用哪个就有哪个，不需要手动加，我错了，还好，困扰一天的问题解决了，没有想到最后居然是没有引用jar，具体代码如下：

1.先加依赖

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    			<exclusions>
    				<exclusion>
    					<artifactId>lettuce-core</artifactId>
    					<groupId>io.lettuce</groupId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    		</dependency>

2.添加其他代码

@RestController
    public class TestController {
        @Autowired
        private StringRedisUtil templateUtil;
    
        @RequestMapping("/setValue")
        public String setValue(){
            if(!templateUtil.hasKey("lbb2")){
                templateUtil.set("lbb2","我是lbb2");
                return "使用redis缓存保存数据成功";
            }else{
                templateUtil.del("lbb");
                return "key已存在";
            }
        }
    
        @RequestMapping("/getValue")
        public String getValue(){
    
            if(!templateUtil.hasKey("lbb2")){
                return "key:lbb2"+"不存在";
            }else{
                String lbb2 = templateUtil.get("lbb2");
                return "获取到缓存中的数据：lbb2="+lbb2;
            }
        }
    
        @RequestMapping("/setValueMap")
        public String setValueMap(){
            if(!templateUtil.hasKey("lbbmap")){
                Map<String,Object> map=new HashMap<String,Object>();
                map.put("1","1");
                map.put("2","2");
                templateUtil.hmset("lbbmap",map);
                return "使用redis缓存保存数据成功";
            }else{
                templateUtil.del("lbbmap");
                return "key已存在";
            }
        }
        @RequestMapping("/getValueMap")
        public String getValueMap(){
            if(!templateUtil.hasKey("lbbmap")){
                return "key不存在，请先保存数据";
            }else{
                //根据key获取缓存中的val
                Map<Object, Object> lbbmap1 = templateUtil.hmget("lbbmap");
                return "获取到缓存中的数据：lbbmap="+lbbmap1;
            }
        }

3.redis的序列化

package com.redis;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.listener.PatternTopic;
    import org.springframework.data.redis.listener.RedisMessageListenerContainer;
    import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
    
    import java.util.concurrent.CountDownLatch;
    
    /**
     * Created by zpx on 2018/3/23.
     */
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport {
    
        @Autowired
        public  RedisConnectionFactory redisConnectionFactory;
    
    
        @Bean
        RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                                MessageListenerAdapter listenerAdapter) {
            RedisConnection connection = redisConnectionFactory.getConnection();
            RedisMessageListenerContainer container = new RedisMessageListenerContainer();
            container.setConnectionFactory(connectionFactory);
            container.addMessageListener(listenerAdapter, new PatternTopic("chat"));
    
            return container;
        }
    
        @Bean
        MessageListenerAdapter listenerAdapter(Receiver receiver) {
            return new MessageListenerAdapter(receiver, "receiveMessage");
        }
    
        @Bean
        Receiver receiver(CountDownLatch latch) {
            return new Receiver(latch);
        }
    
        @Bean
        CountDownLatch latch() {
            return new CountDownLatch(1);
        }
    
        @Bean
        StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
            return new StringRedisTemplate(connectionFactory);
        }
    
        public class Receiver {
    
    
            private CountDownLatch latch;
    
            @Autowired
            public Receiver(CountDownLatch latch) {
                this.latch = latch;
            }
    
            public void receiveMessage(String message) {
                latch.countDown();
            }
        }
    }

4.将常用的redis操作整理了一下

package com.redis;
    
    
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Repository;
    import org.springframework.util.CollectionUtils;
    
    
    /**
     * 
     * @author
     * 基于spring和redis的redisTemplate工具类
     * 针对所有的hash 都是以h开头的方法
     * 针对所有的Set 都是以s开头的方法                    不含通用方法
     * 针对所有的List 都是以l开头的方法
     */
    @Repository
    public class StringRedisUtil {
    
    
    	@Autowired
    	private StringRedisTemplate stringRedisTemplate;
    	//=============================common============================
    	/**
    	 * 指定缓存失效时间
    	 * @param key 键
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean expire(String key,long time){
    		try {
    			if(time>0){
    				stringRedisTemplate.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 stringRedisTemplate.getExpire(key,TimeUnit.SECONDS);
    	}
    	
    	/**
    	 * 判断key是否存在
    	 * @param key 键
    	 * @return true 存在 false不存在
    	 */
    	public boolean exists(String key){
    		try {
    			return stringRedisTemplate.hasKey(key);
    		} catch (Exception e) {
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 删除缓存
    	 * @param key 可以传一个值 或多个
    	 */
    	@SuppressWarnings("unchecked")
    	public void del(String ... key){
    		if(key!=null&&key.length>0){
    			if(key.length==1){
    				stringRedisTemplate.delete(key[0]);
    			}else{
    				stringRedisTemplate.delete(CollectionUtils.arrayToList(key));
    			}
    		}
    	}
    	
    	//============================String=============================
    	/**
    	 * 普通缓存获取
    	 * @param key 键
    	 * @return 值
    	 */
    	public String get(String key){
    		System.err.println(key);
    		return key==null?null:stringRedisTemplate.opsForValue().get(key);
    	}
    	
    	/**
    	 * 普通缓存放入
    	 * @param key 键
    	 * @param value 值
    	 * @return true成功 false失败
    	 */
    	public boolean set(String key,String value) {
    		 try {
    			 stringRedisTemplate.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,String value,long time){
    		try {
    			if(time>0){
    				stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    			}else{
    				set(key, value);
    			}
    			return true;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 递增 1
    	 * @param key 键
    	 * @return
    	 */
    	public long incr(String key){  
    		return stringRedisTemplate.opsForValue().increment(key, 1);
    	}
    	
    	/**
    	 * 递增
    	 * @param key 键
    	 * @return
    	 */
    	public long incr(String key, long delta){  
    		if(delta<0){
    			throw new RuntimeException("递增因子必须大于0");
    		}
    		return stringRedisTemplate.opsForValue().increment(key, delta);
        }
    	
    	/**
    	 * 递减
    	 * @param key 键
    	 * @return
    	 */
    	public long decr(String key, long delta){  
    		if(delta<0){
    			throw new RuntimeException("递减因子必须大于0");
    		}
            return stringRedisTemplate.opsForValue().increment(key, -delta);
        }  
    	
    	//================================Map=================================
    	/**
    	 * HashGet
    	 * @param key 键 不能为null
    	 * @param item 项 不能为null
    	 * @return 值
    	 */
    	public Object hget(String key,String item){
    		return stringRedisTemplate.opsForHash().get(key, item);
    	}
    	
    	/**
    	 * 获取hashKey对应的所有键值
    	 * @param key 键
    	 * @return 对应的多个键值
    	 */
    	public Map<Object,Object> hmget(String key){
    		return stringRedisTemplate.opsForHash().entries(key);
    	}
    	
    	/**
    	 * HashSet
    	 * @param key 键
    	 * @param map 对应多个键值
    	 * @return true 成功 false 失败
    	 */
    	public boolean hmset(String key, Map<String,Object> map){  
            try {
    			stringRedisTemplate.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 {
    			stringRedisTemplate.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 {
    			 stringRedisTemplate.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 {
    			 stringRedisTemplate.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){
    		stringRedisTemplate.opsForHash().delete(key,item);
        } 
        
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item){
    		return stringRedisTemplate.opsForHash().hasKey(key, item);
        } 
    	
    	/**
    	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    	 * @param key 键
    	 * @param item 项
    	 * @param by 要增加几(大于0)
    	 * @return
    	 */
    	public double hincr(String key, String item,double by){  
            return stringRedisTemplate.opsForHash().increment(key, item, by);
        }
    	
    	/**
    	 * hash递减
    	 * @param key 键
    	 * @param item 项
    	 * @param by 要减少记(小于0)
    	 * @return
    	 */
    	public double hdecr(String key, String item,double by){  
            return stringRedisTemplate.opsForHash().increment(key, item,-by);
        }  
    	
    	//============================set=============================
    	/**
    	 * 根据key获取Set中的所有值
    	 * @param key 键
    	 * @return
    	 */
    	public Set<String> sGet(String key){
    		try {
    			return stringRedisTemplate.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 stringRedisTemplate.opsForSet().isMember(key, value);
    		} catch (Exception e) {
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 将数据放入set缓存
    	 * @param key 键
    	 * @param values 值 可以是多个
    	 * @return 成功个数
    	 */
    	public long sSet(String key, String...values) {
            try {
                return stringRedisTemplate.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,String...values) {
            try {
            	Long count = stringRedisTemplate.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 stringRedisTemplate.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 = stringRedisTemplate.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<String> lGet(String key,long start, long end){
    		try {
    			return stringRedisTemplate.opsForList().range(key, start, end);
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * 获取list缓存的长度
    	 * @param key 键
    	 * @return
    	 */
    	public long lGetListSize(String key){
    		try {
    			return stringRedisTemplate.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 stringRedisTemplate.opsForList().index(key, index);
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @return
    	 */
    	public boolean lSet(String key, String value) {
            try {
    			stringRedisTemplate.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, String value, long time) {
            try {
    			stringRedisTemplate.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<String> value) {
    	    try {
    			stringRedisTemplate.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<String> value, long time) {
    	    try {
    			stringRedisTemplate.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,String value) {
    	    try {
    			stringRedisTemplate.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 = stringRedisTemplate.opsForList().remove(key, count, value);
    			return remove;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return 0;
    		}
    	}
    
    	/**
    	 * 是否存在key
    	 * @param key
    	 * @return
    	 */
    	public Boolean hasKey(String key) {
    		try {
    			Boolean aBoolean = stringRedisTemplate.hasKey(key);
    			return aBoolean;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    }

完结！

之前看了其他博主的文章，本来想在这复制地址，最后没有找到，不管怎么样，小弟谢谢各位大神了！