redis

redisSpringBoot/src/main/java/org/example/Article.java

@@ -0,0 +1,47 @@
+package org.example;
+
+import java.io.Serializable;
+import java.util.Date;
+import javax.xml.crypto.Data;
+
+public class Article implements Serializable {
+    private String author;
+    private Data createTime;
+    private String title;
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+
+    public Data getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(Data createTime) {
+        this.createTime = createTime;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    @Override
+    public String toString() {
+        return "Article{" +
+                "author='" + author + '\'' +
+                ", createTime=" + createTime +
+                ", title='" + title + '\'' +
+                '}';
+    }
+
+    public void setCreateTime(Date date) {
+    }
+}

redisSpringBoot/src/main/java/org/example/Main.java

@@ -0,0 +1,11 @@
+package org.example;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Main {
+    public static void main(String[] args){
+        SpringApplication.run(Main.class, args);
+    }
+}

redisSpringBoot/src/main/java/org/example/RedisConfig.java

@@ -0,0 +1,56 @@
+package org.example;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.cache.CacheManager;
+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.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.cache.RedisCacheWriter;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
+
+@Configuration
+@EnableCaching
+public class RedisConfig extends CachingConfigurerSupport {
+    private static final StringRedisSerializer STRING_SERIALIZER = new StringRedisSerializer();
+    private static final GenericJackson2JsonRedisSerializer JACKSON__SERIALIZER = new GenericJackson2JsonRedisSerializer();
+
+    @Bean
+    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
+        //设置缓存过期时间
+        RedisCacheConfiguration redisCacheCfg=RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofHours(1))
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(STRING_SERIALIZER))
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(JACKSON__SERIALIZER));
+        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
+                .cacheDefaults(redisCacheCfg)
+                .build();
+    }
+
+    @Bean
+    @ConditionalOnMissingBean(name = "redisTemplate")
+    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
+        // 配置redisTemplate
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(factory);
+        // key序列化
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        // value序列化
+        redisTemplate.setValueSerializer(JACKSON__SERIALIZER);
+        // Hash key序列化
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        // Hash value序列化
+        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
+}

redisSpringBoot/src/main/resources/application.properties

@@ -0,0 +1,5 @@
+spring.application.name=springboot_redis
+server.port=8080
+#??Redis?redis?host?????????IP?????6379
+spring.redis.host=127.0.0.1
+spring.redis.port=6379

redisSpringBoot/src/test/java/HashTest.java

@@ -0,0 +1,72 @@
+import org.example.Article;
+import org.example.Main;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@SpringBootTest(classes = Main.class)
+public class HashTest {
+    @Autowired
+    private RedisTemplate redisTemplate;
+
+    @Test
+    public void testPut(){
+//        redisTemplate.setKeySerializer(new StringRedisSerializer());
+//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
+        Article article = new Article();
+        article.setTitle("title");
+        article.setCreateTime(new Date());
+        article.setAuthor("lixiang");
+
+        redisTemplate.opsForHash().put("article","1",article);
+        System.out.println((Article) redisTemplate.opsForHash().get("article","1"));
+    }
+
+    @Test
+    public void testGet(){
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
+        // 判断hashkey是否存在
+        Boolean article = redisTemplate.opsForHash().hasKey("article", "2");
+        System.out.println(article);
+
+        //根据key和hashkey获取操作
+        Article article1 = (Article) redisTemplate.opsForHash().get("article", "2");
+        System.out.println(article1);
+
+
+        //根据key获取所有的hashkey
+        Set<String> set = redisTemplate.opsForHash().keys("article");
+        for (Object s : set) {
+            System.out.println(s);
+        }
+
+
+        List<Article> articles = redisTemplate.opsForHash().values("article");
+        for (Article art : articles) {
+            System.out.println(art);
+        }
+
+        Map<String,Article> map = redisTemplate.opsForHash().entries("article");
+        for (Map.Entry<String, Article> entry : map.entrySet()) {
+            System.out.println(entry.getKey()+":"+entry.getValue());
+        }
+    }
+
+    //删除
+    @Test
+    public void testDelete(){
+        //当hash中的数据全被删除后，整个hash就没了
+        redisTemplate.opsForHash().delete("article","1","2");
+    }
+}

redisSpringBoot/src/test/java/ListTest.java

@@ -0,0 +1,65 @@
+import org.example.Main;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import java.util.List;
+import java.util.Set;
+
+@SpringBootTest(classes = Main.class)
+public class ListTest {
+    @Autowired
+    private RedisTemplate<String,String> redisTemplate;
+
+    //增加
+    @Test
+    public void testAdd(){
+        //从左边添加一个元素
+        redisTemplate.opsForList().leftPush("students","zhangshan");
+        //从左边添加多个元素 不能添加多个？
+        redisTemplate.opsForList().leftPush("students","lishi","wangwu");
+
+        //从右边添加一个元素
+        redisTemplate.opsForList().rightPush("students","zhangshan1");
+        //从右边添加多个元素 不能添加多个？
+        redisTemplate.opsForList().rightPush("students","lishi1","wangwu1");
+
+        System.out.println(redisTemplate.opsForList().range("students", 0, -1));
+    }
+
+    @Test
+    public void testFind(){
+        //根据key和元素索引进行查询
+        //0和正数代表从左边开始
+        //负数代表从右边开始
+        String students = redisTemplate.opsForList().index("students", 1);
+        System.out.println(students);
+
+        String students1 = redisTemplate.opsForList().index("students", -1);
+        System.out.println(students1);
+
+        //范围查询
+        //根据key 【start,end】 包括首尾
+        List<String> students2 = redisTemplate.opsForList().range("students", 0, 2);
+        for (String s : students2) {
+            System.out.println(s);
+        }
+    }
+    //删除
+    @Test
+    public void testRemove(){
+        //从左边删除第一个元素
+        String s = redisTemplate.opsForList().leftPop("students");
+        //从右边删除第一个元素
+        String s1 = redisTemplate.opsForList().rightPop("students");
+
+        //count > 0; 删除左边起第几个等于指定值的元素
+        //count < 0; 删除右边起第几个等于指定值的元素
+        //count = 0; 删除所有等于value的元素
+        //删除左边起第二个wangwu
+        redisTemplate.opsForList().remove("students",0,"zhangshan1");
+        redisTemplate.opsForList().remove("students",0,"zhangshan");
+        System.out.println(redisTemplate.opsForList().range("students", 0, -1));
+    }
+}

redisSpringBoot/src/test/java/SetTest.java

@@ -0,0 +1,78 @@
+import org.example.Main;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import java.util.List;
+import java.util.Set;
+
+@SpringBootTest(classes = Main.class)
+public class SetTest {
+    @Autowired
+    private RedisTemplate<String,String> redisTemplate;
+
+    //增加
+    @Test
+    public void testAdd(){
+        redisTemplate.opsForSet().add("Students","zhangsan","lishi","wangwu","Zhangsan");
+    }
+
+    //查询
+    @Test
+    public void testFind(){
+        //查询所有元素
+        Set<String> students = redisTemplate.opsForSet().members("Students");
+        for (String student : students) {
+            System.out.println(student);
+        }
+
+        //随机获取一个元素
+        String students1 = redisTemplate.opsForSet().randomMember("Students");
+        System.out.println(students1);
+
+        //随机获取多个元素【可能会重复】
+        List<String> list = redisTemplate.opsForSet().randomMembers("Students", 2);
+        for (String s : list) {
+            System.out.println(s);
+        }
+    }
+
+    //删除
+    @Test
+    public void testRemove(){
+        //移除元素，并返回移除成功个数
+        Long remove = redisTemplate.opsForSet().remove("Students", "zhangsan", "wangwu");
+        System.out.println(remove);
+
+        //随机移除指定集合中的多少个元素
+        List<String> students = redisTemplate.opsForSet().pop("Students", 2);
+        for (String student : students) {
+            System.out.println(student);
+        }
+    }
+
+    //多集合操作
+    @Test
+    public void testMoreSet(){
+        redisTemplate.opsForSet().add("names1","zhangsan","li","wangwu");
+        redisTemplate.opsForSet().add("names2","zhangsan","li","zhaoliu");
+
+        //取交集
+        Set<String> intersect = redisTemplate.opsForSet().intersect("names1", "names2");
+        for (String s : intersect) {
+            System.out.println(s);
+        }
+        //取并集
+        Set<String> union = redisTemplate.opsForSet().union("names1", "names2");
+        for (String s : union) {
+            System.out.println(s);
+        }
+        //取差集[第一个集合中存在，但第二个集合中不存在的元素]
+        Set<String> difference = redisTemplate.opsForSet().difference("names2", "names1");
+        for (String s : difference) {
+            System.out.println(s);
+        }
+
+    }
+}

redisSpringBoot/src/test/java/StringTest.java

@@ -0,0 +1,106 @@
+import org.example.Main;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@SpringBootTest(classes = Main.class)
+class StringTest {
+
+    @Autowired
+    private RedisTemplate<String,String> redisTemplate;
+
+    @Test
+    public void testSet(){
+        //向数据库中保存 name heima
+        redisTemplate.opsForValue().set("name","heima");
+
+        //相关数据保存 name1 heima1  有效时间为10s
+        redisTemplate.opsForValue().set("name1","heima1",10, TimeUnit.SECONDS);
+
+        //替换 heima        heXXa  offset 索引位置是从0开始
+        redisTemplate.opsForValue().set("name","XX",2);
+
+        //当key不存在的时候，执行保存操作；当key存在时，什么都不做
+        redisTemplate.opsForValue().setIfAbsent("name","heima");
+
+        //批量保存
+        Map<String,String> map = new HashMap<>();
+        map.put("name2","heima2");
+        map.put("name3","heima3");
+        map.put("name3","heima3");
+
+        redisTemplate.opsForValue().multiSet(map);
+
+        //追加 当key存在时，会执行追加操作；当key不存在时，会执行保存操作
+        redisTemplate.opsForValue().append("name5","heima");
+        System.out.println(redisTemplate.opsForValue().get("name"));
+        System.out.println(redisTemplate.opsForValue().get("name1"));
+        System.out.println(redisTemplate.opsForValue().get("name2"));
+        System.out.println(redisTemplate.opsForValue().get("name3"));
+        System.out.println(redisTemplate.opsForValue().get("name5"));
+    }
+
+
+    @Test
+    public void testGet(){
+        //根据key获取value
+        String value = redisTemplate.opsForValue().get("name");
+        System.out.println(value);
+
+        //首先根据key获取value，然后再根据value进行截取。从start位置截取到end位置【包含start和end】
+        String name = redisTemplate.opsForValue().get("name", 5, 7);
+        System.out.println(name);
+
+        //批量获取
+        List<String> keys = new ArrayList<>();
+        keys.add("name2");
+        keys.add("name3");
+        keys.add("name4");
+        List<String> values = redisTemplate.opsForValue().multiGet(keys);
+        for (String s : values) {
+            System.out.println(s);
+        }
+
+        //根据key获取value的长度
+        Long size = redisTemplate.opsForValue().size("name");
+        System.out.println(size);
+    }
+
+
+    @Test
+    public void testIncrement(){
+        redisTemplate.opsForValue().set("age","18");
+//        自增1
+        redisTemplate.opsForValue().increment("age");
+        System.out.println(redisTemplate.opsForValue().get("age"));
+//        自增6
+        redisTemplate.opsForValue().increment("age",6);
+        System.out.println(redisTemplate.opsForValue().get("age"));
+
+//        自减
+        redisTemplate.opsForValue().decrement("age");
+        System.out.println(redisTemplate.opsForValue().get("age"));
+    }
+
+    //删除
+    @Test
+    public void testDelete(){
+//        单个删除
+        redisTemplate.delete("name");
+
+        List<String> list = new ArrayList<>();
+        list.add("name2");
+        list.add("name3");
+        list.add("name4");
+//        批量删除
+        redisTemplate.delete(list);
+        System.out.println(redisTemplate.opsForValue().multiGet(list));
+    }
+}

redisSpringBoot/src/test/java/ZSetTest.java

@@ -0,0 +1,99 @@
+import org.example.Main;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ZSetOperations;
+
+import java.util.Set;
+
+@SpringBootTest(classes = Main.class)
+public class ZSetTest {
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Test
+    public void testAdd(){
+        redisTemplate.opsForZSet().add("student","wangwu",60);
+        redisTemplate.opsForZSet().add("student","lishi",100);
+        redisTemplate.opsForZSet().add("student","zhangshan",90);
+    }
+
+    //    分数的增减
+    @Test
+    public void testScore(){
+        // 增加分数
+        redisTemplate.opsForZSet().incrementScore("student","wangwu",30);
+
+        // 减少分数
+        redisTemplate.opsForZSet().incrementScore("student","wangwu",-50);
+    }
+
+    // 查询一个元素的信息
+    @Test
+    public void testFindOne(){
+        //查询一个元素的分数
+        Double score = redisTemplate.opsForZSet().score("student", "wangwu");
+        System.out.println(redisTemplate.opsForZSet().rank("student", "wangwu"));
+        System.out.println(score);
+
+        //查询一个元素在集合中的排名  排名从0开始
+        Long rank = redisTemplate.opsForZSet().rank("student", "zhangshan");
+        System.out.println(rank);
+
+    }
+
+    //根据区间获取列表
+    @Test
+    public void testFindList(){
+        //根据排名区间获取元素列表
+        Set<String> students = redisTemplate.opsForZSet().range("student",0,2);
+        for (String student : students) {
+            System.out.println(student);
+        }
+
+        System.out.println("-------------");
+        Set<ZSetOperations.TypedTuple<String>> student = redisTemplate.opsForZSet().rangeWithScores("student", 0, 2);
+        for (ZSetOperations.TypedTuple<String> stringTypedTuple : student) {
+            System.out.println(stringTypedTuple.getValue()+"同学，得了"+stringTypedTuple.getScore()+"分");
+        }
+        System.out.println("-----------------------------");
+        //根据排名区间获取元素列表
+        Set<String> students1 = redisTemplate.opsForZSet().rangeByScore("student",50,100);
+        for (String student1 : students1) {
+            System.out.println(student1);
+        }
+
+        System.out.println("-------------");
+        Set<ZSetOperations.TypedTuple<String>> student1 = redisTemplate.opsForZSet().rangeByScoreWithScores("student", 50, 100);
+        for (ZSetOperations.TypedTuple<String> stringTypedTuple : student1) {
+            System.out.println(stringTypedTuple.getValue()+"同学，得了"+stringTypedTuple.getScore()+"分");
+        }
+    }
+
+
+    //统计
+    @Test
+    public void testCount(){
+        //统计一个集合中元素
+        Long student = redisTemplate.opsForZSet().zCard("student");
+        System.out.println(student);
+
+        //根据一个分数区间统计元素数量
+        Long count = redisTemplate.opsForZSet().count("student", 50, 100);
+        System.out.println(count);
+    }
+
+    //删除
+    @Test
+    public void testRemove(){
+        //根据key-value删除 value允许传入多个
+        redisTemplate.opsForZSet().remove("student","zhangsan","lisi");
+
+        //根据排名区间删除
+        redisTemplate.opsForZSet().removeRange("student",0,1);
+
+        //根据分数区间删除
+        redisTemplate.opsForZSet().removeRangeByScore("student",70,90);
+    }
+}