springboot使用Redis作缓存使用入门

绝地灬酷狼 2022-08-31 11:16 217阅读 0赞

###  ###

*   *  1.依赖与数据库设置
     *  2.redis和session配置
     *  3.实体与controller层
     *  4.运行 测试
     *  5.附录：一些redis工具类

## 1.依赖与数据库设置 ##

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-pool2</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.session</groupId>
    			<artifactId>spring-session-data-redis</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>

spring.redis.database=0  
    
    spring.redis.host=localhost
    
    spring.redis.port=6379  
    
    spring.redis.password=123 #自己的密码
    
    spring.redis.lettuce.pool.max-active=8
    
    spring.redis.lettuce.pool.max-wait=-1
    
    spring.redis.lettuce.pool.max-idle=8
    
    spring.redis.lettuce.pool.min-idle=0

## 2.redis和session配置 ##

@Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport{ 
    	
    	@Bean
    	public KeyGenerator keyGenerator() { 
            return new KeyGenerator() { 
                @Override
                public Object generate(Object target, Method method, Object... params) { 
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) { 
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    }
    
    @Configuration
    @EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400*30)
    public class SessionConfig { 
    }

## 3.实体与controller层 ##

public class User implements Serializable { 
    
    	private static final long serialVersionUID = 1L;
    	private Long id;
    	private String userName;
    	private String password;
    	private String email;
    	private String nickname;
    	private String regTime;
    
    	public User() { 
    		super();
    	}
    	public User(String email, String nickname, String password, String userName, String regTime) { 
    		super();
    		this.email = email;
    		this.nickname = nickname;
    		this.password = password;
    		this.userName = userName;
    		this.regTime = regTime;
    	}
    
    	public Long getId() { 
    		return id;
    	}
    
    	public void setId(Long id) { 
    		this.id = id;
    	}
    
    	public String getUserName() { 
    		return userName;
    	}
    
    	public void setUserName(String userName) { 
    		this.userName = userName;
    	}
    
    	public String getPassword() { 
    		return password;
    	}
    
    	public void setPassword(String password) { 
    		this.password = password;
    	}
    
    	public String getEmail() { 
    		return email;
    	}
    
    	public void setEmail(String email) { 
    		this.email = email;
    	}
    
    	public String getNickname() { 
    		return nickname;
    	}
    
    	public void setNickname(String nickname) { 
    		this.nickname = nickname;
    	}
    
    	public String getRegTime() { 
    		return regTime;
    	}
    
    	public void setRegTime(String regTime) { 
    		this.regTime = regTime;
    	}
    
    	@Override
    	public String toString() { 
    		return "User{" +
    				"id=" + id +
    				", userName='" + userName + '\'' +
    				", password='" + password + '\'' +
    				", email='" + email + '\'' +
    				", nickname='" + nickname + '\'' +
    				", regTime='" + regTime + '\'' +
    				'}';
    	}
    }

@RestController
    public class UserController { 
    
        @RequestMapping("/getUser")
        @Cacheable(value="user-key")
        public User getUser() { 
            User user=new User("aa@126.com", "aa", "aa123456", "aa","123");
            System.out.println("测试缓存");
            return user;
        }
    
    
        @RequestMapping("/uid")
        String uid(HttpSession session) { 
            UUID uid = (UUID) session.getAttribute("uid");
            if (uid == null) { 
                uid = UUID.randomUUID();
            }
            session.setAttribute("uid", uid);
            return session.getId();
        }
    }

## 4.运行 测试 ##

@SpringBootApplication
    public class RedisApplication { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(RedisApplication.class, args);
    	}
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 2]  
同时也可以用专门的图形界面工具查看：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 3]

## 5.附录：一些redis工具类 ##

package com.neo.util;
    
    package com.kuang.utils;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    @Component
    public final class RedisUtil { 
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        // =============================common============================
        /** * 指定缓存失效时间 * @param key 键 * @param time 时间(秒) */
        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 可以传一个值 或多个 */
        @SuppressWarnings("unchecked")
        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 键 * @param delta 要增加几(大于0) */
        public long incr(String key, long delta) { 
            if (delta < 0) { 
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
    
        /** * 递减 * @param key 键 * @param delta 要减少几(小于0) */
        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 */
        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 对应多个键值 */
        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) */
        public double hincr(String key, String item, double by) { 
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
    
        /** * hash递减 * * @param key 键 * @param item 项 * @param by 要减少记(小于0) */
        public double hdecr(String key, String item, double by) { 
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
    
        // ============================set=============================
    
        /** * 根据key获取Set中的所有值 * @param key 键 */
        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 键 */
        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代表所有值 */
        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 键 */
        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倒数第二个元素，依次类推 */
        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 值 */
        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 时间(秒) */
        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;
            }
    
        }
    
    }

常用的redisconfig:

@Configuration
    public class RedisConfig { 
    
        //RedisTemplate序列化配置 -- > 注意要使用 @Qualifier("redisTemplate") 避免歧义（测试类中有使用案例）
        @Bean
        @SuppressWarnings("all")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { 
            // 我们为了自己开发方便，一般直接使用 <String, Object>
            RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
            template.setConnectionFactory(factory);
    
            // Json序列化配置
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            // String 的序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    
            // key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            // hash的key也采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);
            // value序列化方式采用jackson
            template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的value序列化方式采用jackson
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
    
            return template;
        }

jedis操作String类型：

package com.kuang;
    
    import redis.clients.jedis.Jedis;
    
    import java.util.concurrent.TimeUnit;
    
    
    //基本类型之String
    public class TestString02 { 
        public static void main(String[] args) { 
            Jedis jedis = new Jedis("127.0.0.1", 6379);
    
            jedis.flushDB();
            System.out.println("===========增加数据===========");
            System.out.println(jedis.set("key1","value1"));
            System.out.println(jedis.set("key2","value2"));
            System.out.println(jedis.set("key3", "value3"));
            System.out.println("删除键key2:"+jedis.del("key2"));
            System.out.println("获取键key2:"+jedis.get("key2"));
            System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
            System.out.println("获取key1的值："+jedis.get("key1"));
            System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
            System.out.println("key3的值："+jedis.get("key3"));
            System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
            System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
            System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));
            System.out.println("删除多个键值对："+jedis.del("key01","key02"));
            System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
    
            jedis.flushDB();
            System.out.println("===========新增键值对防止覆盖原先值==============");
            System.out.println(jedis.setnx("key1", "value1"));
            System.out.println(jedis.setnx("key2", "value2"));
            System.out.println(jedis.setnx("key2", "value2-new"));
            System.out.println(jedis.get("key1"));
            System.out.println(jedis.get("key2"));
    
            System.out.println("===========新增键值对并设置有效时间=============");
            System.out.println(jedis.setex("key3", 2, "value3"));
            System.out.println(jedis.get("key3"));
            try { 
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(jedis.get("key3"));
    
            System.out.println("===========获取原值，更新为新值==========");
            System.out.println(jedis.getSet("key2", "key2GetSet"));
            System.out.println(jedis.get("key2"));
    
            System.out.println("获得key2的值的字串："+jedis.getrange("key2", 2, 4));
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]: /images/20220829/0e73534622a048a282fc937238edd794.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]: /images/20220829/0ff187ede27843c99c7a8a2bc5c876eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 2]: /images/20220829/53bd2d81d7fc467999f0efd950a480fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 3]: /images/20220829/b3c2f503ff024afb88731dee940599ec.png