Redis Java API操作

1、普通maven工程方式

Redis不仅可以通过命令行进行操作，也可以通过JavaAPI操作，通过使用Java API来对Redis数据库中的各种数据类型操作

导入POM依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.liming</groupId>
    <artifactId>JavaRedis305</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <!--    <verbal>true</verbal>-->
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

连接以及关闭redis客户端

因为后续测试都需要用到Redis连接，所以，我们先创建一个JedisPool用于获取Redis连接。此处，我们基于TestNG来测试各类的API。使用@BeforeTest在执行测试用例前，创建Redis连接池。使用@AfterTest在执行测试用例后，关闭连接池。

实现步骤：

1、创建JedisPoolConfig配置对象，指定最大空闲连接为10个、最大等待时间为3000毫秒、最大连接数为50、最小空闲连接5个

2、创建JedisPool

3、使用@Test注解，编写测试用例，查看Redis中所有的key

（a）从Redis连接池获取Redis连接

（b）调用keys方法获取所有的key

（c）遍历打印所有key

package com.liming.redis;

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.Set;

/**
 * @author 黎明
 * @date 2023/5/16 18:40
 * @version 1.0
 */
public class RedisTest {

    private JedisPool jedisPool;

    @BeforeTest
    public void testBefore(){
        // JedisPoolConfig配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        // 指定最大空闲连接为10个
        config.setMaxIdle(10);
        // 最小空闲连接5个
        config.setMinIdle(5);
        // 最大等待时间为3000毫秒
        config.setMaxWaitMillis(3000);
        // 最大连接数为50
        config.setMaxTotal(50);

        jedisPool = new JedisPool(config, "192.168.11.130", 6379);
    }

    @Test
    public void testKeys(){
        // 从Redis连接池获取Redis连接
        Jedis jedis = jedisPool.getResource();
        // 调用keys方法获取所有的key
        Set<String> keys = jedis.keys("*");
        // 遍历得到所有key
        for (String key : keys) {
            System.out.println(key);
        }
    }

    @AfterTest
    public void testAfter(){
        // 关闭连接池
        jedisPool.close();
    }
}

运行结果：

在这里插入图片描述

操作string类型数据

1、添加一个string类型数据，key为pv，用于保存pv的值，初始值为0
2、查询该key对应的数据
3、修改pv为1000
4、实现整形数据原子自增操作 +1
5、实现整形该数据原子自增操作 +1000

@Test
public void testString(){
    // 获取Jedis连接
    Jedis jedis = jedisPool.getResource();
    // 1、添加一个string类型数据，key为pv，用于保存pv的值，初始值为0
    jedis.set("pv","0");
    // 2、查询该key对应的数据
    String pv = jedis.get("pv");
    System.out.println("pv1:"+pv);
    // 3、修改pv为1000
    jedis.set("pv","1000");
    System.out.println("pv2:"+jedis.get("pv"));
    // 4、实现整形数据原子自增操作+1
    jedis.incr("pv");
    System.out.println("pv3:"+jedis.get("pv"));
    // 5、实现整形该数据原子自增操作+1000
    jedis.incrBy("pv",1000);
    System.out.println("pv4:"+jedis.get("pv"));

    // 将Jedis对象放回到连接池
    jedis.close();
}

运行结果：

在这里插入图片描述

操作hash列表类型数据

1、往Hash结构中添加以下商品库存

iphone11 => 10000
macbookpro => 9000

2、获取Hash中所有的商品
3、新增3000个macbookpro库存
4、删除整个Hash的数据

 @Test
public void testHash() {
    // 1、从池子里拿一个连接
    Jedis jedis = jedisPool.getResource();
    // 2、往Hash结构中添加以下商品库存 goods
    // iphone14 => 10000
    // macbookpro => 9000
    jedis.hset("goods","iphone14","10000");
    jedis.hset("goods","macbookpro","20000");
    // 3、获取Hash中所有的商品
    Set<String> goods = jedis.hkeys("goods");
    for (String good : goods) {
        System.out.println(good);
    }
    // 4、新增3000个macbookpro库存
    jedis.hincrBy("goods","macbookpro",3000);
    System.out.println(jedis.hget("goods","macbookpro"));

    // 5、删除整个Hash的数据
    jedis.del("goods");

    // 将Jedis对象放回到连接池
    jedis.close();
}

在这里插入图片描述

操作list类型数据

1、向list的左边插入以下三个手机号码：18511310002、18912301233、18123123314
2、从右边移除一个手机号码
3、获取list所有的值

@Test
public void testList(){
    // 获取Jedis连接
    Jedis jedis = jedisPool.getResource();
    // 1、向list的左边插入以下三个手机号码：18511310001、18912301231、18123123312
    jedis.lpush("tel_list","18511310001","18912301231","18123123312");
    // 2、从右边移除一个手机号码
    jedis.rpop("tel_list");
    // 3、获取所有的值
    List<String> telList = jedis.lrange("tel_list", 0, -1);
    for (String tel : telList) {
        System.out.println(tel);
    }

    // 释放资源
    jedis.close();
}

在这里插入图片描述

操作set类型的数据

使用set来保存uv值，为了方便计算，将用户名保存到uv中。

往一个set中添加页面 page1 的uv，用户user1访问一次该页面
user2访问一次该页面
user1再次访问一次该页面
最后获取 page1的uv值

 @Test
public void testSet(){
    // 获取Jedis连接
    Jedis jedis = jedisPool.getResource();
    // 1、往一个set中添加页面 page1 的uv，用户user1访问一次该页面
    jedis.sadd("uv","user1");
    // 2、user2访问一次该页面
    jedis.sadd("uv","user2");
    // 3、user1再次访问一次该页面
    jedis.sadd("uv","user1");
    // 4、最后获取 page1的uv值
    System.out.println("uv:"+jedis.scard("uv"));

    // 释放资源
    jedis.close();
}

在这里插入图片描述

2、SpringBoot方式

创建SpringBoot工程

在这里插入图片描述

选择对应的依赖

在这里插入图片描述

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.liming</groupId>
    <artifactId>redis_boot</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

spring:
  redis:
    host: 192.168.11.130
    port: 6379

测试类

package com.liming;

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;
/**
 * @author 黎明
 * @date 2023/5/16 20:24
 * @version 1.0
 */
@SpringBootTest
class RedisBootApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate; // 模板帮我们建连接、关连接

    @Test
    void contextLoads() {
        // 两套api
        redisTemplate.opsForValue().set("a","b");
        redisTemplate.opsForHash().put("map","username","liming");
        System.out.println("a:"+redisTemplate.opsForValue().get("a"));
        System.out.println("map->username:"+redisTemplate.opsForHash().get("map","username"));

        redisTemplate.boundValueOps("c").set("d");
        redisTemplate.boundHashOps("map1").put("username","liming");
        System.out.println("c:"+redisTemplate.boundValueOps("c").get());
        System.out.println("map1->username:"+redisTemplate.boundHashOps("map1").get("username"));
    }

}