【Redis学习 | 第3篇】在Java中操作Redis

文章目录

- [1. 在Java中操作Redis](#1. 在Java中操作Redis)
- - [1.1 介绍](#1.1 介绍)
  - [1.2 Jedis](#1.2 Jedis)
  - [1.3 Spring Data Redis](#1.3 Spring Data Redis)

1. 在Java中操作Redis

1.1 介绍

Redis的Java客户端很多，官方推荐的有三种：
- Jedis
- Lettuce
- Redisson
Spring对 Redis客户端进行了整合，提供了Spring Data Redis ，在Spring Boot项目中还提供了对应的Starter，即spring-boot-starter-data-redis

1.2 Jedis

Jedis的maven坐标：

xml 复制代码

<dependency>
    <groupld>redis.clients</groupld>			  		
    <artifactld>jedis</artifactld>			    	 	 
    <version>2.8.0</version>
</dependency>

使用Jedis操作Redis的步骤：

获取连接

java 复制代码

Jedis jedis = new Jedis("localhost", 6379);

执行操作

java 复制代码

jedis.set("username", "hauhua");

String username = jedis.get("username");
System.out.println(username);

关闭连接
java 复制代码
```
jedis.close();
```

1.3 Spring Data Redis

在Spring Boot项目中，可以使用Spring Data Redis来简化Redis操作，maven坐标：

xml 复制代码

<dependency>
	<groupld>org.springframework.boot</groupld>
	<artifactld>spring-boot-starter-data-redis</artifactld>
</dependency>

因为是SpringBoot项目，需要提供启动类

java 复制代码

@SpringBootApplication
public class App {

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

配置yaml文件

yaml 复制代码

spring:
  application:
    name: demo-springdataredis
  #Redis相关配置
  redis:
    host: localhost
    port: 6379
    #password: 123456
    database: 0 #操作的是第0个数据库
    jedis:
      #Redis连接池配置
      pool:
        max-active: 8  #最大连接数（负值表示没有限制）
        max-wait: -1ms #最大阻塞等待时间（负值表示没有限制）
        max-idle: 8    #连接池中的最大空闲连接
        min-idle: 0    #连接池中的最小空闲连接

Redis配置类（对key和value进行序列化和反序列化）

java 复制代码

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory); // 设置连接工厂
        template.setKeySerializer(new StringRedisSerializer()); // 设置键的序列化器
        template.setHashKeySerializer(new StringRedisSerializer()); // 设置hash键的序列化器

        template.setValueSerializer(new StringRedisSerializer()); // 设置值的序列化器
        return template;
    }
}

Spring Data Redis中提供了一个高度封装的类：RedisTemplate ，针对jedis客户端中大量api进行了归类封装，将同一类型操作 封装为operation接口，具体分类如下：

ValueOperations: 简单K-V操作
SetOperations: set类型数据操作
zSetOperations: zset类型数据操作
HashOperations:针对map类型的数据操作 
Listoperations:针对list类型的数据操作

java 复制代码

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringDataRedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作String类型数据
     */
    @Test
    public void testString() {
        redisTemplate.opsForValue().set("city", "shanghai");

        String city = (String) redisTemplate.opsForValue().get("city");
        System.out.println(city);
    }

    /**
     * 操作hash类型数据
     */
    @Test
    public void testHash() {
        //存值
        redisTemplate.opsForHash().put("user", "name", "hky");
        redisTemplate.opsForHash().put("user", "age", "24");
        redisTemplate.opsForHash().put("user", "gender", "male");

        //取值
        String name = (String) redisTemplate.opsForHash().get("user", "name");
        String age = (String) redisTemplate.opsForHash().get("user", "age");
        System.out.println(name + " " + age);
        System.out.println();

        //获得hash结构中所有的key
        Set keys = redisTemplate.opsForHash().keys("user");
        for (Object key :
                keys) {
            System.out.println(key);
        }
        System.out.println();

        //获得hash结构中所有的value
        List values = redisTemplate.opsForHash().values("user");
        for (Object value :
                values) {
            System.out.println(value);
        }

    }

    /**
     * 操作list类型数据
     */
    @Test
    public void testList() {
        ListOperations listOperations = redisTemplate.opsForList();

        //存值
        listOperations.leftPush("mylist", "apple");
        listOperations.leftPushAll("mylist", "banana", "orange");
        listOperations.leftPush("mylist", "banana");

        //取值
        List<String> list = listOperations.range("mylist", 0, -1);
        for (String fruit :
                list) {
            System.out.println(fruit);
        }

        //获得列表长度
        Long length = listOperations.size("mylist");
        int size = length.intValue();
        for (int i = 0; i < size; i++) {
            //出队列
            Object element = listOperations.rightPop("mylist");
            System.out.println(element);
        }
    }

    /**
     * 操作set类型数据
     */
    @Test
    public void testSet() {
        SetOperations setOperations = redisTemplate.opsForSet();

        //存值
        setOperations.add("myset", "a", "b", "c", "d", "e");

        //取值
        Set<String> set = setOperations.members("myset");
        for (String element :
                set) {
            System.out.println(element);
        }

        //删除成员
        setOperations.remove("myset", "a", "b");

        set = setOperations.members("myset");
        for (String element :
                set) {
            System.out.println(element);
        }
    }

    /**
     * 操作zset类型数据
     */
    @Test
    public void testZset() {
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //存值
        zSetOperations.add("myzset", "a", 1);
        zSetOperations.add("myzset", "b", 2);
        zSetOperations.add("myzset", "c", 3);
        zSetOperations.add("myzset", "a", 4);

        //取值
        Set myzset = zSetOperations.range("myzset", 0, -1);

        for (Object element :
                myzset) {
            System.out.println(element);
        }

        //修改分数
        zSetOperations.incrementScore("myzset", "b", 10);

        //删除成员
        zSetOperations.remove("myzset", "a", "b");
        myzset = zSetOperations.range("myzset", 0, -1);

        for (Object element :
                myzset) {
            System.out.println(element);
        }

    }

    /**
     * 通用操作，针对不同的数据类型都可以操作
     */
    @Test
    public void testCommon() {
        //获取Redis中所有的key
        Set keys = redisTemplate.keys("*");
        for (Object key :
                keys) {
            System.out.println(key);
        }

        //判断某个key是否存在
        boolean exists = redisTemplate.hasKey("it");
        System.out.println(exists);

        //删除某个key
        redisTemplate.delete("myZset");

        //判断某个key对应的value的数据类型
        DataType type = redisTemplate.type("myset");
        System.out.println(type);
    }

}