Redis 学习笔记2（Java 操作Redis）

2023-02-27 07:35:55

Jedis 简介

Jedis 是 Java 操作 Redis 的驱动架包。在使用前需要先下载好驱动架包jedis.jar

  1. 首先你需要下载驱动包 下载 jedis.jar，确保下载好驱动包。
  2. 在 classpath 中包含该驱动包。

连接到 redis 服务

/** 连接 Redis 数据库 */
@Test
public void ConnectionRedisTest() {
    // 获取连接
    Jedis jedis = new Jedis("127.0.0.1", 6379);
    System.out.println("连接成功");
    // 查看服务是否运行
    System.out.println("服务正在运行: " + jedis.ping());
    // 关闭连接
    jedis.close();
}

输出：

连接成功
服务正在运行: PONG

Jedis 操作 Redis 中的各种数据结构

String（字符串）

/** 操作 Redis String 类型的数据 */
@Test
public void OperateStringTest() throws InterruptedException {
    // 获取连接：空参，默认为 "127.0.0.1", 6379
    Jedis jedis = new Jedis();
    // 存储 String 类型的数据
    jedis.set("username", "LeeHua");
    // 获取存储的 String 数据
    System.out.println(jedis.get("username"));
    // 使用 setex() 方法存储数据，可以指定过期时间 ---- key, value
    // 将 checkCode: AbCd 键值对存入 Redis，10秒后删除
    jedis.setex("checkCode", 10, "AbCd");
    System.out.println(jedis.get("checkCode"));
    // 程序停顿10秒
    Thread.sleep(10000);
    System.out.println("停顿10秒后，再获取 checkCode：" + jedis.get("checkCode"));
    // 删除 username
    jedis.del("username");
    // 关闭连接
    jedis.close();
}

输出：

LeeHua
AbCd
停顿10秒后，再获取 checkCode：null

Hash (哈希)

/** 操作 Redis Hash 类型的数据 */
@Test
public void OperateHashTest() throws InterruptedException {
    // 获取连接：空参，默认为 "127.0.0.1", 6379
    Jedis jedis = new Jedis();
    // 存储 hash
    jedis.hset("user", "name", "LeeHua");
    jedis.hset("user", "age", "21");
    jedis.hset("user", "gender", "male");
    // 获取hash中的一个数据
    System.out.println(jedis.hget("user", "name"));
    System.out.println(jedis.hget("user", "age"));
    System.out.println(jedis.hget("user", "gender"));
    // 获取hash中所有map数据
    Map<String, String> userMap = jedis.hgetAll("user");
    Set<String> users = userMap.keySet();
    Iterator<String> userIterator = users.iterator();
    while (userIterator.hasNext()) {
        String key = userIterator.next();
        String value = userMap.get(key);
        System.out.println(key + ": " + value);
    }
    // 删除 user 中的某个 key: value
    jedis.hdel("user", "name");
    jedis.hdel("user", "age");
    jedis.hdel("user", "gender");
    // 关闭连接
    jedis.close();
}

输出：

LeeHua
21
male
gender: male
name: LeeHua
age: 21

List（列表）

/** 操作 Redis List 类型的数据 */
@Test
public void OperateListTest() {
    // 获取连接：空参，默认为 "127.0.0.1", 6379
    Jedis jedis = new Jedis();
    // 从 List 的左边存入数据
    jedis.lpush("testList", "1", "2", "3");
    // 从 List 的右边存入数据
    jedis.rpush("testList", "A", "B", "C");
    // 获取 List（列表） 数据
    System.out.println(jedis.lrange("testList", 0, 5));
    // 删除 List（列表） 数据
    // 从左边开始删除
    String leftFirst = jedis.lpop("testList");
    String leftSecond = jedis.lpop("testList");
    String leftThird = jedis.lpop("testList");
    // 从右边开始删除
    String rightFirst = jedis.rpop("testList");
    String rightSecond = jedis.rpop("testList");
    String rightThird = jedis.rpop("testList");
    System.out.println("左边开始删除：" + leftFirst + "、" + leftSecond + "、" + leftThird);
    System.out.println("右边开始删除：" + rightFirst + "、" + rightSecond + "、" + rightThird);
    // 关闭连接
    jedis.close();
}

输出：

[3, 2, 1, A, B, C]
左边开始删除：3、2、1
右边开始删除：C、B、A

Set（无序集合）

/** 操作 Redis Set 类型的数据 */
@Test
public void OperateSetTest() {
    // 获取连接：空参，默认为 "127.0.0.1", 6379
    Jedis jedis = new Jedis();
    // 存储数据（存储的数据是没顺序的）
    jedis.sadd("BigData",
            "HDFS", "MapReduce", "Spark", "Storm");
    // 获取数据
    Set<String> bigData = jedis.smembers("BigData");
    System.out.println(Arrays.toString(bigData.toArray()));
    // 删除数据
    jedis.srem("BigData", "HDFS", "MapReduce", "Spark", "Storm");
    // 关闭连接
    jedis.close();
}

输出（无序的）：

[Storm, HDFS, Spark, MapReduce]

Zset（有序集合）

/** 操作 Redis Set 类型的数据 */
@Test
public void OperateSortSetTest() {
    // 获取连接：空参，默认为 "127.0.0.1", 6379
    Jedis jedis = new Jedis();
    // 存储数据（存储的数据是有顺序的，按照 score 进行排序的）
    jedis.zadd("BigData", 10, "HDFS");
    jedis.zadd("BigData", 20, "MapReduce");
    jedis.zadd("BigData", 30, "Spark");
    jedis.zadd("BigData", 1, "Storm");
    // 获取数据
    Set<String> bigData = jedis.zrange("BigData", 0, 3);
    System.out.println(Arrays.toString(bigData.toArray()));
    // 删除数据
    jedis.zrem("BigData", "HDFS", "MapReduce", "Spark", "Storm");
    // 关闭连接
    jedis.close();
}

输出：

[Storm, HDFS, MapReduce, Spark]

Jedis 连接池

Jedis 连接池的使用

@Test
public void JedisPoolTest() {
    // 创建Jedis连接池对象
    JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);
    // 从 Jedis 连接池中获取 Redis 连接对象
    Jedis jedis = jedisPool.getResource();
    System.out.println("服务正在运行: " + jedis.ping());
    // 将 Redis 连接对象归还到 Jedis 连接池
    jedis.close();
}

输出：

服务正在运行: PONG

Jedis 连接池工具类

  • 配置文件：jedis.properties

    # redis服务器的IP
host=127.0.0.1
# redis服务器的端口
port=6379
# 最大活动对象数
maxTotal=50
# 最大能够保持 idel 状态的对象数
maxIdle=10

  • 数据库连接池：JedisPoolUtils.java

    import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class JedisPoolUtils {
    private static JedisPool jedisPool;

    // 读取配置文件
    static {
        // 获取类加载器
        ClassLoader classLoader = JedisPoolUtils.class.getClassLoader();
        // 获取加载配置文件的对象
        Properties properties = new Properties();
        // 获取 jedis.properties 配置文件资源输入流
        InputStream jedisProperties = classLoader.getResourceAsStream("jedis.properties");
        // 加载配置文件
        try {
            properties.load(jedisProperties);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 将加载的配置文件数据，设置到 JedisPoolConfig 中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));

        // 初始化jedis连接池对象
        jedisPool = new JedisPool(
                config,
                properties.getProperty("host"),
                Integer.parseInt(properties.getProperty("port"))
        );
    }

    /** 获取连接的方法 */
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
}

  • 测试连接池

    /** 测试 JedisPoolUtils */
@Test
public void JedisPoolUtilsTest() {
    // 获取 Jedis 连接对象
    Jedis jedis = JedisPoolUtils.getJedis();
    System.out.println("连接成功");
    // 查看服务是否运行
    System.out.println("服务正在运行: " + jedis.ping());
    // 将 Redis 连接对象归还到 Jedis 连接池
    jedis.close();
}

    输出：

    连接成功
服务正在运行: PONG

参考文献

  1. Redis 教程| 菜鸟教程
上一篇：Redis:存储对象的两种方式(序列化和json字符串)


下一篇：Redis的基本使用