Redis | 在Java中操作Redis_redis在java项目中yml配置

• ① 在pom.xml文件导入 Spring Data Redis 的Maven依赖。
• ② 配置Redis数据源。
• ③ 编写配置类，通过创建RedisTemplate对象。
• ④ 通过RedisTemplate对象操作Redis。

第一步: pom.xml文件中导入maven依赖

	<!--  Spring-data-redis的依赖  -->  
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>
1
2
3
4
5

第二步: 在application.yml配置文件中 配置Redis数据源

• 配置Redis数据源类似于配置Mysql数据源。通过Redis数据源能连接到数据库。(注意 : 可在 spring: 这个配置项下进行配置。)

•   redis:  
      host: localhost
      port: 6379
      password: 123456
      database: 10    
     #一般不直接在配置文件中写明确的数据
  1
  2
  3
  4
  5
  6

• 配置项的功能介绍：

  host: 表示当前要连接的redis服务的IP地址。
  port: 表示端口号，默认的端口号为6379。
  password: 密码。
  database: 数据库。Redis服务启动之后默认情况下，其在redis服务中会创建好16个库(DB0-DB15)。每个数据库之间的数据是完全隔离的。（如果不配置时Redis默认使用的是DB0）	  
  1
  2
  3
  4

第三步: 编写RedisConfiguration配置类，创建RedisTemplate对象

@Configuration
@Slf4j //记录日志
public class RedisConfiguration {
    /**
     * RedisTemplate : Redis模板对象
     * @param redisConnectionFactory redis连接工厂对象
     * @return
     */
    @Bean //将该方法返回值的"对象:RedisTemplate"存入到bean容器中，交给Spring容器管理
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建Redis模板对象...");
        // RedisTemplate是Spring Data Redis的一个核心组件，用于在Java中与Redis进行交互
        RedisTemplate redisTemplate = new RedisTemplate;
        // 设置Redis的连接工厂对象 (关联RedisConnectionFactory对象)
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置redis key的序列化器
        //设定为: "符串Redis序列化器"
        redisTemplate.setKeySerializer(new StringRedisSerializer()); 
        return redisTemplate;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

第四步: 通过RedisTemplate对象操作Redis / Redis中的数据

4.1 操作“字符串String类型”数据

//用于测试Spring Boot应用程序的注解
@SpringBootTest
public class SpringDataRedisTest { //SpringDataRedis测试类

    //注入RedisTemplate对象
    @Autowired
    private RedisTemplate redisTemplate;

       /**
     * 操作String字符串类型的数据
     */
    @Test
    public void testString() {
          /*
            操作字符串的命令:
            set   : 插入字符串
            get   : 获得字符串
            setex : 插入字符串的同时,可以设置该字符串的“有效期”
            setnx : 当设置的key不存在时，才插入字符串
          */
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //向Redis中设置字符串
        valueOperations.set("city","北京");
        
        //获取字符串
        String city = (String) valueOperations.get("city");
        
        //设置有特定“有效期”的字符串
        valueOperations.set("code","123456",3, TimeUnit.MINUTES); //有效期三分钟
        
        //当设置的key不存在时，才插入字符串
        valueOperations.setIfAbsent("lock", 1);
        valueOperations.setIfAbsent("lock", 2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

4.2 操作“哈希hash类型的数据”

//用于测试Spring Boot应用程序的注解，
@SpringBootTest
public class SpringDataRedisTest { //SpringDataRedis测试类

    //注入RedisTemplate对象
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作哈希hash类型的数据
     */
    @Test
    public void testHash() {
        /*
          hset  : 将哈希表key中的字段field的值设定为value
          hget  : 获取存储在哈希表中指定字段的值
          hdel  : 删除存储在哈希表中的指定字段
          hkeys : 获取key对应的“哈希表中所有字段”
          hvals : 获取key对应的”哈希表中所有值“
         */
        HashOperations hashOperations = redisTemplate.opsForHash();
        //存储hash类型数据
        hashOperations.put("100", "name", "tom");
        hashOperations.put("100", "age", "20");

        //获取hash类型数据
        String name = (String) hashOperations.get("100", "name");
        System.out.println(name);

        //获取key对应的“哈希表中所有字段”
        Set keys = hashOperations.keys("100");
        System.out.println(keys);

        //获取key对应的”哈希表中所有值“
        List values = hashOperations.values("100");
        System.out.println(values);

        //删除数据
        hashOperations.delete("100", "age");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

4.3 操作“列表list类型的数据”

@SpringBootTest
public class SpringDataRedisTest { //SpringDataRedis测试类

    //注入RedisTemplate对象
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作列表list类型的数据
     */
    @Test
    public void testList() {
           /*
              lpush  : 将一个或多个值插入到列表头部(列表左边)
              rpush  : 将一个或多个值插入到列表尾部(列表右边)
              lrange : 获取指定范围内的元素
              lpop   : 移除并获取列表第一个元素
              rpop   : 移除并获取列表最后一个元素
              llen   : 获取列表长度
            */
        ListOperations listOperations = redisTemplate.opsForList();
        //从列表头部插入一个数据
        listOperations.leftPush("mylist", "a");
        //从列表头部插入多个数据
        listOperations.leftPushAll("mylist", "b", "c", "d");

        //查询列表中指定范围的数据
        List mylist = listOperations.range("mylist", 0, -1); //查询整个列表所有的元素

        //移除并获取列表最后一个元素
        String mylist1 = (String) listOperations.rightPop("mylist");

        //获得列表长度 (获得列表中元素个数)
        Long size = listOperations.size("mylist");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

4.4 操作“集合set类型的数据”

//用于测试Spring Boot应用程序的注解，
@SpringBootTest
public class SpringDataRedisTest { //SpringDataRedis测试类

    //注入RedisTemplate对象
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     *  操作集合类型的数据
     */
    @Test
    public void testset() {
        /*
          sadd     : 向集合中添加一个或多个成员
          smembers : 返回(指定key对应)的集合中的所有成员
          scard    : 返回(指定key对应)的集合中的成员数
          sinter   : 返回给定所有集合的交集
          sunion   : 返回所有给定集合的并集
          srem     : 删除集合中一个或多个成员
         */
        SetOperations setOperations = redisTemplate.opsForSet();

        //向指定集合中插入元素
        setOperations.add("set1", "a", "b", "c", "d");
        setOperations.add("set2", "a", "b", "x", "y");

        //返回(指定key对应)的集合中的成员数
        Long size = setOperations.size("set1");//获得 set1 这个key对应的集合中的所有的元素
        System.out.println(size);

        //返回给定集合的交集
        Set intersect = setOperations.intersect("set1", "set2");
        System.out.println(intersect);

        //返回所有给定集合的并集
        Set union = setOperations.union("set1", "set2");

        //删除集合中一个或多个成员
        setOperations.remove("set1", "a", "b");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

4.5 操作“有序集合set类型的数据”

//用于测试Spring Boot应用程序的注解，
@SpringBootTest
public class SpringDataRedisTest { //SpringDataRedis测试类

    //注入RedisTemplate对象
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     *  操作“有序集合类型的数据”
     */
     
    @Test
    public void Zset() {
        /*
           zadd    : 向有序集合中插入一个或多个成员
           zrange  : 通过索引区间返回有序集合中指定区间内的成员
           zincrby : 有序集合中对指定成员的分数加上增量 increment
           zrem    : 移除有序集合中的一个或多个成员
         */
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //向有序集合中添加元素
        //三个key一样，表明数据在同一个集合中
        zSetOperations.add("zset1", "a", 10);
        zSetOperations.add("zset1", "b", 12);
        zSetOperations.add("zset1", "c", 9);

        //查询有序列表中指定区间的数据
        zSetOperations.range("zset1", 0, -1);

        //为集合中元素增加值
        zSetOperations.incrementScore("zset1", "c", 10);

        //移除结合中元素
        zSetOperations.remove("zset1", "a", "b");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

4.6 通用命令“操作数据”

//用于测试Spring Boot应用程序的注解，
@SpringBootTest
public class SpringDataRedisTest { //SpringDataRedis测试类

    //注入RedisTemplate对象
    @Autowired
    private RedisTemplate redisTemplate;  
  
  /**
     * 通用命令操作
     */
    public void testComon() {
        /*
          keys   : 查找符合给定模式的key
          exists : 检查给定key是否存在
          type   : 返回key所存储的值的类型
          del    : 该命令用于在key存在时删除key
         */

        //获得所有的key
        Set keys = redisTemplate.keys("*");

        //检查给定的key是否存在
        Boolean name = redisTemplate.hasKey("name");
        Boolean set1 = redisTemplate.hasKey("set1");

        //返回key所存储的值的类型
        for (Object key : keys) {
            DataType type = redisTemplate.type(key);
        }

        //删除指定的key
        redisTemplate.delete("mylist");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36