Redis Java API操作

1、普通maven工程方式

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

导入POM依赖

<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.0modelVersion>

    <groupId>com.liminggroupId>
    <artifactId>JavaRedis305artifactId>
    <version>1.0-SNAPSHOTversion>

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

    <dependencies>
        <dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>2.9.0version>
        dependency>
        <dependency>
            <groupId>org.testnggroupId>
            <artifactId>testngartifactId>
            <version>6.14.3version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13.2version>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.0version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                    <encoding>UTF-8encoding>
                    
                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

<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.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.6.5version>
        <relativePath/> 
    parent>

    <groupId>com.liminggroupId>
    <artifactId>redis_bootartifactId>
    <version>0.0.1-SNAPSHOTversion>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            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"));
    }

}

运行结果：