1. 简介

Redis是一个基于内存的数据结构存储系统，它可以用作数据库或者缓存。它支持多种类型的数据
结构，这些数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和
Zset（有序集合）。

配置连接工厂 -> 配置模板 -> 使用接口

SpringDataRedis 提供的连接工厂：

  1. JedisConnectionFactory
  2. JredisConnectionFactory
  3. LettuceConnectionFactory
  4. SrpConnectionFactory

与其他的Spring Data项目类似，Spring Data Redis以模板的形式提供了较高等级的数据访问方案。实际上，Spring Data Redis提供了两个模板：

  • RedisTemplate
  • StringRedisTemplate


SpringData Redis的作用是通过一段简单的配置即可访问redis服务，它的底层是对java提供的
redis开发包(比如jedis等)进行了高度封装，主要提供了如下功能：

  • 连接池自动管理，提供了一个高度封装的RedisTemplate类,基于这个类的对象可以对redis进行各
    种操作
  • 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
    • ValueOperations：简单字符串类型数据操作
    • SetOperations：set类型数据操作
    • ZSetOperations：zset类型数据操作
    • HashOperations：map类型的数据操作
    • ListOperations：list类型的数据操作

RedisTemplate的很多功能是以子API的形式提供的，它们区分了单个值和集合值的场景
image.png

2. 入门案例

2.1 引入坐标

pom.xml 文件中引入

  1. <dependency>
  2.   <groupId>org.springframework.data</groupId>
  3.   <artifactId>spring-data-redis</artifactId>
  4. </dependency>
  5. <dependency>
  6.   <groupId>redis.clients</groupId>
  7.   <artifactId>jedis</artifactId>
  8. </dependency>

2.2 配置文件（注解方式）

tips:

  • JedisConnectionFactory 要配置 RedisStandaloneConfiguration 对象和 JedisClientConfiguration

image.png

RedisConfig.java

  1. @Configuration
  2. public class RedisConfig {
  4.     @Value("${spring.redis.host}")
  5.     private String host;
  6.     @Value("${spring.redis.port}")
  7.     private int port;
  8.     @Value("${spring.redis.password}")
  9.     private String password;
  11.     @Bean
  12.     public JedisPoolConfig jedisPoolConfig() {
  13.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  14.         // 最大空闲数
  15.         jedisPoolConfig.setMaxIdle(300);
  16.         // 在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的
  17.         jedisPoolConfig.setTestOnBorrow(false);
  18.         return jedisPoolConfig;
  19.     }
  21.     @Bean
  22.     public RedisStandaloneConfiguration redisStandaloneConfiguration() {
  23.         RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
  24.         configuration.setHostName(host);
  25.         configuration.setPassword(password);
  26.         configuration.setPort(port);
  27.         return configuration;
  28.     }
  30.     @Bean
  31.     public JedisClientConfiguration clientConfiguration() {
  32.         JedisClientConfiguration.JedisClientConfigurationBuilder builder = JedisClientConfiguration.builder();
  33.         return builder.usePooling()
  34.                 .poolConfig(jedisPoolConfig())
  35.                 .build();
  36.     }
  38.     @Bean
  39.     public JedisConnectionFactory jedisConnectionFactory() {
  40.         return new JedisConnectionFactory(redisStandaloneConfiguration(), clientConfiguration());
  41.     }
  43.     @Bean
  44.     public RedisTemplate redisTemplate() {
  45.         // 注意这里使用的是StringRedisTempalte
  46.         StringRedisTemplate template = new StringRedisTemplate(jedisConnectionFactory());
  47.         GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  48.         // 设置值的序列化器
  49.         template.setValueSerializer(jackson2JsonRedisSerializer);
  50.         return template;
  51.     }
  52. }

application.yml

  1. spring:
  2.   redis:
  3.     port: 6379
  4.     password: qazwsx123!@#
  5.     host: 1.117.30.61

2.3 常见操作

在Redis中有五种常见类型,SpringData Redis对每一种数据类型都提供了一个xxxOperations的API,他们
分别是:

  • ValueOperations valueOps;
  • ListOperations listOps;
  • SetOperations setOps;
  • ZSetOperations zSetOps;
  • HashOperations hashOps;

2.3.1 ValueOperations

  1. @SpringBootTest
  2. public class RedisStringTest {
  4.     @Autowired
  5.     private RedisTemplate redisTemplate;
  7.     ValueOperations<String, String> operations = null;
  9.     @Before
  10.     public void init() {
  11.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  12.         redisTemplate.setValueSerializer(new StringRedisSerializer());
  14.         operations = redisTemplate.opsForValue();
  15.     }
  18.     @Test
  19.     public void testSet() {
  20.         //向数据库中保存name--heima
  21.         //operations.set("name","heima");
  23.         //相关数据库保存name1--heima1  有效时间为10s
  24.         //operations.set("name1", "heima1", 10, TimeUnit.SECONDS);
  26.         //替换 heima    --->   heXXa   offset 索引位置是从0开始
  27.         //operations.set("name", "XX", 2);
  29.         //当key不存在的时候,执行保存操作;当key存在的时候,什么都不做
  30.         //operations.setIfAbsent("name1","heima");
  32.         //批量保存
  33. //        Map map = new HashMap();
  34. //        map.put("name2", "heima2");
  35. //        map.put("name3", "heima3");
  36. //        map.put("name4", "heima4");
  37. //
  38. //        operations.multiSet(map);
  41.         //追加 当key存在时,会执行追加操作;当key不存在时,会执行保存操作
  42.         operations.append("name5", "Heima");
  44.     }
  46.     @Test
  47.     public void testGet() {
  48.         //根据key获取value
  49. /*        String value = operations.get("name");
  50.         System.out.println(value);//heXXaHeima*/
  52.         //首先根据key获取value,然后再根据value进行截取,从start位置截取到end位置[包含start和end]
  53. /*        String value2 = operations.get("name", 5, 7);
  54.         System.out.println(value2);//heXXaHeima-->Hei*/
  56.         //批量获取
  57. //        List<String> keys = new ArrayList<>();
  58. //        keys.add("name2");
  59. //        keys.add("name3");
  60. //        keys.add("name4");
  61. //        List<String> values = operations.multiGet(keys);
  62. //        for (String s : values) {
  63. //            System.out.println(s);
  64. //        }
  66.         //根据key获取value的长度
  67.         Long size = operations.size("name");
  68.         System.out.println(size);
  70.     }
  72.     //自增
  73.     @Test
  74.     public void testIncrement() {
  75.         operations.set("age", "18");
  76.         operations.increment("age");//自增1--->19
  77.         System.out.println(operations.get("age"));
  78.         operations.increment("age", 5);//自增5
  79.         System.out.println(operations.get("age"));//---->24
  81.         //自减
  82.         //operations.decrement("age")
  84.     }
  86.     //删除
  87.     @Test
  88.     public void testDelete() {
  89.         //单个删除
  90.         redisTemplate.delete("name");
  92.         List<String> keys = new ArrayList<>();
  93.         keys.add("name2");
  94.         keys.add("name3");
  95.         keys.add("name4");
  97.         //批量删除
  98.         redisTemplate.delete(keys);
  99.     }
  100. }

2.3.2 ListOperations

  1. public class RedisListTest {
  3.     @Autowired
  4.     private RedisTemplate redisTemplate;
  6.     ListOperations<String, String> operations = null;
  8.     @Before
  9.     public void init() {
  10.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  11.         redisTemplate.setValueSerializer(new StringRedisSerializer());
  13.         operations = redisTemplate.opsForList();
  14.     }
  16.     //增加
  17.     @Test
  18.     public void testAdd() {
  19.         //从左边添加一个元素
  20.         operations.leftPush("students", "zhangsan");
  21.         //从左边添加多个元素
  22.         operations.leftPushAll("students", "lisi", "wangwu", "zhaoliu");
  25.         //从右边添加一个元素
  26.         operations.rightPush("students", "zhangsan1");
  27.         //从右边添加多个元素
  28.         operations.rightPushAll("students", "lisi", "wangwu", "zhaoliu");
  29.     }
  31.     //查询
  32.     @Test
  33.     public void testFind() {
  34.         //根据key和索引进行查询
  35.         //0和正数代表从左边开始    0  1  2
  36.         //负数代表从右边开始       -1   -2  -3
  37.         String student = operations.index("students", 1);
  38.         System.out.println(student);
  40.         String student1 = operations.index("students", -2);
  41.         System.out.println(student1);
  43.         //范围查询
  44.         //根据key  [start,end]  包括首尾
  45.         List<String> students = operations.range("students", 0, 2);
  46.         for (String s : students) {
  47.             System.out.println(s);
  48.         }
  49.     }
  51.     //删除
  52.     @Test
  53.     public void testRemove(){
  54.         //从左边删除第一个元素
  55.         //String s = operations.leftPop("students");
  57.         //从右边删除第一个元素
  58.         //operations.rightPop("students");
  61.         // count > 0：删除左边起第几个等于指定值的元素
  62.         // count < 0：删除右边起第几个等于指定值的元素
  63.         // count = 0：删除所有等于value的元素。
  64.         //删除左边起第二个wangwu
  65.         operations.remove("students",2,"wangwu");
  66.     }
  67. }

2.3.3 SetOperations

  1. public class RedisSetTest {
  3.     @Autowired
  4.     private RedisTemplate redisTemplate;
  6.     SetOperations<String, String> operations = null;
  8.     @Before
  9.     public void init() {
  10.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  11.         redisTemplate.setValueSerializer(new StringRedisSerializer());
  13.         operations = redisTemplate.opsForSet();
  14.     }
  16.     //增加
  17.     @Test
  18.     public void testAdd() {
  19.         operations.add("students","zhangsan","lisi","wangwu","zhangsan");
  20.     }
  22.     //查询
  23.     @Test
  24.     public void testFind() {
  25.         //查询所有元素
  26. /*        Set<String> students = operations.members("students");
  27.         for (String student : students) {
  28.             System.out.println(student);
  29.         }*/
  31.         //随机获取一个元素
  32. /*        String student = operations.randomMember("students");
  33.         System.out.println(student);*/
  35.         //随机多个元素[可能会重复]
  36.         List<String> stus = operations.randomMembers("students", 2);
  37.         for (String stu : stus) {
  38.             System.out.println(stu);
  39.         }
  41.     }
  43.     //删除
  44.     @Test
  45.     public void testRemove() {
  46.         //移除元素,并返回移除成功个数
  47.         Long count = operations.remove("students", "zhangsan", "wangwu","sunliu");
  48.         System.out.println(count);
  50.         //随机移除指定集合中的多少个元素
  51.         List<String> students = operations.pop("students", 2);
  52.         for (String student : students) {
  53.             System.out.println(student);
  54.         }
  55.     }
  57.     //多集合操作
  58.     @Test
  59.     public void testMoreSet(){
  60.         operations.add("names1", "zhangsan", "li", "wangwu");
  61.         operations.add("names2", "zhangsan", "li", "zhaoliu");
  63.         //取交集
  64. /*        Set<String> sets1 = operations.intersect("names1", "names2");
  65.         for (String s : sets1) {
  66.             System.out.println(s);
  67.         }*/
  69.         //取并集
  70. /*        Set<String> sets2 = operations.union("names1", "names2");
  71.         for (String s : sets2) {
  72.             System.out.println(s);
  73.         }*/
  75.         //取差集[第一个集合中存在,但是在第二个集合中不存在的元素]
  76.         Set<String> sets3 = operations.difference("names2", "names1");
  77.         for (String s : sets3) {
  78.             System.out.println(s);
  79.         }
  80.     }
  81. }

2.3.4 ZSetOperations

  1. public class RedisZSetTest {
  3.     @Autowired
  4.     private RedisTemplate redisTemplate;
  6.     ZSetOperations<String, String> operations = null;
  8.     @Before
  9.     public void init() {
  10.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  11.         redisTemplate.setValueSerializer(new StringRedisSerializer());
  13.         operations = redisTemplate.opsForZSet();
  14.     }
  16.     //增加
  17.     @Test
  18.     public void testAdd() {
  19.         operations.add("students", "zhangsan", 100);
  20.         operations.add("students", "lisi", 60);
  21.         operations.add("students", "wangwu", 80);
  22.     }
  24.     //分数的增减
  25.     @Test
  26.     public void testScore() {
  27.         //incrementScore 可以用来增减分数  增加就用正数    减少用负数
  28.         //增加分数
  29.         operations.incrementScore("students", "wangwu", 30);
  30.         //减少分数
  31.         operations.incrementScore("students", "wangwu", -70);
  32.     }
  34.     //查询一个元素的信息
  35.     @Test
  36.     public void testFindOne() {
  37.         //查询一个元素的分数
  38.         Double score = operations.score("students", "wangwu");
  39.         System.out.println(score);
  41.         //查询一个元素在集合中的排名   排名从0开始
  42.         Long rank = operations.rank("students", "zhangsan");
  43.         System.out.println(rank);
  44.     }
  46.     //根据一个区间获得一个列表
  47.     @Test
  48.     public void testFindList() {
  49.         //根据排名区间来获取元素列表
  50.         Set<String> students = operations.range("students", 0, 2);
  51.         for (String student : students) {
  52.             System.out.println(student);
  53.         }
  54.         System.out.println("=============");
  55.         Set<ZSetOperations.TypedTuple<String>> set = operations.rangeWithScores("students", 0, 2);
  56.         for (ZSetOperations.TypedTuple<String> tuple : set) {
  57.             System.out.println(tuple.getValue() + "同学,得了" + tuple.getScore() + "分");
  58.         }
  59.         System.out.println("---------------------------------");
  62.         //根据分数区间来获取列表
  63.         Set<String> students2 = operations.rangeByScore("students", 60, 90);
  64.         for (String student : students2) {
  65.             System.out.println(student);
  66.         }
  67.         System.out.println("=============");
  68.         Set<ZSetOperations.TypedTuple<String>> set2 = operations.rangeByScoreWithScores("students", 60, 90);
  69.         for (ZSetOperations.TypedTuple<String> tuple : set2) {
  70.             System.out.println(tuple.getValue() + "同学,得了" + tuple.getScore() + "分");
  71.         }
  72.     }
  74.     //统计
  75.     @Test
  76.     public void testCount() {
  77.         //统计一个集合中元素
  78.         Long zCard = operations.zCard("students");
  79.         System.out.println(zCard);
  81.         //根据一个分数区间统计元素数量
  82.         Long count = operations.count("students", 50, 100);
  83.         System.out.println(count);
  84.     }
  87.     //删除
  88.     @Test
  89.     public void testRemove() {
  90.         //根据key-value删除  value允许传入多个
  91.         //operations.remove("students","zhangsan","lisi");
  93.         //根据排名区间删除
  94.         //operations.removeRange("students", 0, 1);
  96.         //根据分数区间删除
  97.         operations.removeRangeByScore("students", 70, 100);
  98.     }
  99. }

2.3.5 HashOperations

  1. public class RedisHashTest {
  3.     @Autowired
  4.     private RedisTemplate redisTemplate;
  6.     HashOperations<String, String, Article> operations = null;
  8.     @Before
  9.     public void init() {
  10.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  11.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  12.         redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
  14.         operations = redisTemplate.opsForHash();
  15.     }
  17.     //保存
  18.     @Test
  19.     public void testPut() {
  20.         Article article = new Article();
  21.         article.setTitle("黑马");
  22.         article.setAuthor("黑马程序员");
  23.         article.setCreateTime(new Date());
  25.         operations.put("article", "3", article);
  26.     }
  29.     //获取
  30.     @Test
  31.     public void testGet() {
  32.         //判断hashkey是否存在
  33.         Boolean flag = operations.hasKey("article", "3");
  34.         System.out.println(flag);
  36.         //根据key和hashkay获取操作
  37.         Article article = operations.get("article", "2");
  38.         System.out.println(article);
  41.         //根据key获取所有的hashkey
  42.         Set<String> set = operations.keys("article");
  43.         for (String s : set) {
  44.             System.out.println(s);
  45.         }
  47.         List<Article> articles = operations.values("article");
  48.         for (Article art : articles) {
  49.             System.out.println(art);
  50.         }
  52.         Map<String, Article> map = operations.entries("article");
  53.         for (Map.Entry<String, Article> entry : map.entrySet()) {
  54.             System.out.println(entry.getKey() + ":" + entry.getValue());
  55.         }
  56.     }
  58.     //删除
  59.     @Test
  60.     public void testDelete() {
  61.         //当hash中的数据全部被删除后,整个hash就没了
  62.         operations.delete("article", "2", "3");
  63.     }
  64. }

参考

  1. Redis学习之Spring-data-redis使用