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

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 教程| 菜鸟教程