Redis实战：Redis在Java中的基本使用

本片将介绍 Redis 在 Java 中的基本使用

文章目录

• • • • 1、使用jedis操作redis
      • • 1.1、Jedis简介
        • 1.2、引入jedis的Maven依赖
        • 1.2、获取连接
        • 1.3、使用实例
        • 2、对于JedisPooled的使用
        • • 2.1、使用JedisPooled
          • 2.2、关于连接池
          • 3、SpringBoot下使用Redis
          • • 3.1、引入Maven依赖
            • 3.2、配置Redis连接
            • 3.3、创建RedisTemplate
            • 3.4、使用RedisTemplate

              ---

              1、使用jedis操作redis

              1.1、Jedis简介

              Jedis 是 Java 语言开发的 Redis 客户端工具包，用于 Java 语言与 Redis 数据进行交互。

              Jedis 在 github 官网地址：https://github.com/redis/jedis#readme

              Jedis 只是对 Redis 命令的封装，掌握 Redis 命令便可轻易上手 Jedis。

              Jedis 遵循 RESP 协议规范开发，具有良好的通用性与可读性。

              1.2、引入jedis的Maven依赖

                      
                      
                          redis.clients
                          jedis
                          4.4.3
                      
              

              1.2、获取连接

              对于许多应用程序，需要连接到 Redis 时。最好使用连接池。可以像这样实例化一个 Jedis 连接池:

              JedisPool pool = new JedisPool("localhost", 6379);
              

              对于 JedisPool 实例，可以使用 try-With-resources 块获得连接并运行 Redis 命令（这种方式无须自己手动 close）。

              try (Jedis jedis = pool.getResource()) {
              	// 运行单个 SET 命令
                jedis.set("clientName", "Jedis");
              }
              

              1.3、使用实例

              编写以下代码：

                  public static void main(String[] args) {
                      // Redis服务端IP和端口号
                      JedisPool pool = new JedisPool("127.0.0.1", 6379);
                      try (Jedis jedis = pool.getResource()) {
                          // 使用相关Redis的命令
                          // 选择第0个数据库进行操作
                          jedis.select(0);
                          // 向0号数据库写入,字符串数据
                          jedis.set("Java", "best");
                          jedis.set("PHP", "good");
                          // 查询是否写入
                          System.out.println(jedis.get("Java"));
                          System.out.println(jedis.get("PHP"));
                      }
                  }
              

              运行测试用例:

              

              Jedis 实例实现了大多数 Redis 命令，这些命令可以在 https://www.javadoc.io/doc/redis.clients/jedis/latest/redis/clients/jedis/Jedis.htmlApI 中查询命令对应的方法。

              

              ---

              2、对于JedisPooled的使用

              2.1、使用JedisPooled

              对每个命令使用 try-with-resources 块可能比较麻烦，因此我们可以考虑使用 JedisPooled。

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

              详细代码:

                  public static void main(String[] args) {
                      JedisPooled pool = new JedisPooled("127.0.0.1", 6379, null, null);
                      pool.set("Java", "best");
                      pool.set("PHP", "good");
                      System.out.println(pool.get("Java"));
                      System.out.println(pool.get("PHP"));
                  }
              

              运行效果:

              

              2.2、关于连接池

              使用链接池是官方推荐的使用方式，通过连接池可以更好的使用 Jedis 的，我们可以通过 GenericObjectPoolConfig 对连接池进行相关配置，GenericObjectPoolConfig API 文档：https://commons.apache.org/proper/commons-pool/apidocs/org/apache/commons/pool2/impl/GenericObjectPoolConfig.html

              通过 GenericObjectPoolConfig 对象对连接池进行配置，具体代码如下:

                  public static void main(String[] args) {
                      GenericObjectPoolConfig config = new JedisPoolConfig();
                      // 设置连接池中最多允许放100个Jedis对象
                      config.setMaxTotal(100);
                      // 设置连接池中最大允许空闲连接
                      config.setMaxIdle(100);
                      // 设置连接池中最小允许的连接数
                      config.setMinIdle(10);
                      // 借出连接的时候是否测试有效性,推荐false
                      config.setTestOnBorrow(false);
                      // 归还时是否测试,推荐false
                      config.setTestOnReturn(false);
                      // 创建时是否测试有效  开发的时候设置为false,实践运行的时候设置为true
                      config.setTestOnCreate(false);
                      // 当连接池内jedis无可用资源时,是否等待资源,true
                      config.setBlockWhenExhausted(true);
                      // 没有获取资源时最长等待1秒,1秒后没有还没有的话就报错
                      config.setMaxWaitMillis(1000);
                      JedisPool pool = new JedisPool(config, "127.0.0.1", 6379);
                      try (Jedis jedis = pool.getResource()) {
                          // 使用相关Redis的命令
                          // 选择第0个数据库进行操作
                          jedis.select(0);
                          // 向0号数据库写入,字符串数据
                          jedis.set("Java", "best");
                          jedis.set("PHP", "good");
                          // 查询是否写入
                          System.out.println(jedis.get("Java"));
                          System.out.println(jedis.get("PHP"));
                      }
                  }
              

              运行效果:

              

              ---

              3、SpringBoot下使用Redis

              3.1、引入Maven依赖

              首先，需要在 pom.xml 文件中添加 Redis 依赖：

              
                  org.springframework.boot
                  spring-boot-starter-data-redis
              
              

              这个依赖包含了 Spring Data Redis，以及 Jedis 和 Lettuce 这两种 Redis 客户端的实现。

              3.2、配置Redis连接

              在 SpringBoot 项目中，可以通过在 application.properties 或 application.yml 文件中配置 Redis 连接信息。以下是一个示例：

              spring:
                data:
                  redis:
                    timeout: 3000
                    database: 0
                    password: password
                    port: 6379
                    host: localhost
              

              其中，host 和 port 分别是 Redis 服务器的地址和端口号，password 是 Redis的密码（如果没有密码，可以不填），timeout 是 Redis 连接超时时间，jedis.pool 是连接池的相关设置。

              3.3、创建RedisTemplate

              使用 Spring Data Redis 操作 Redis，通常会使用 RedisTemplate 类。为了方便起见，我们可以创建一个工具类来管理 RedisTemplate 的创建和使用。以下是一个示例：

              import org.slf4j.Logger;
              import org.slf4j.LoggerFactory;
              import org.springframework.data.redis.core.RedisTemplate;
              import org.springframework.data.redis.core.ValueOperations;
              import org.springframework.stereotype.Component;
              import javax.annotation.Resource;
              import java.util.Set;
              import java.util.concurrent.TimeUnit;
              @Component
              public class RedisUtils {
                  /**
                   * 如果使用 @Autowired 注解完成自动装配 那么
                   * RedisTemplate要么不指定泛型,要么泛型 为 或者
                   * 如果你使用其他类型的 比如RedisTemplate
                   * 那么请使用 @Resource 注解
                   * */
                  @Resource
                  private RedisTemplate redisTemplate;
                  private Logger logger = LoggerFactory.getLogger(this.getClass());
                  /**
                   * 缓存value
                   *
                   * @param key -
                   * @param value -
                   * @param time -
                   * @return -
                   */
                  public boolean cacheValue(String key, Object value, long time) {
                      try {
                          ValueOperations valueOperations = redisTemplate.opsForValue();
                          valueOperations.set(key, value);
                          if (time > 0) {
                              // 如果有设置超时时间的话
                              redisTemplate.expire(key, time, TimeUnit.SECONDS);
                          }
                          return true;
                      } catch (Throwable e) {
                          logger.error("缓存[" + key + "]失败, value[" + value + "] " + e.getMessage());
                      }
                      return false;
                  }
                  /**
                   * 缓存value，没有设置超时时间
                   *
                   * @param key -
                   * @param value -
                   * @return -
                   */
                  public boolean cacheValue(String key, Object value) {
                      return cacheValue(key, value, -1);
                  }
                  /**
                   * 判断缓存是否存在
                   *
                   * @param key
                   * @return
                   */
                  public boolean containsKey(String key) {
                      try {
                          return redisTemplate.hasKey(key);
                      } catch (Throwable e) {
                          logger.error("判断缓存是否存在时失败key[" + key + "]", "err[" + e.getMessage() + "]");
                      }
                      return false;
                  }
                  /**
                   * 根据key，获取缓存
                   *
                   * @param key -
                   * @return -
                   */
                  public Object getValue(String key) {
                      try {
                          ValueOperations valueOperations = redisTemplate.opsForValue();
                          return valueOperations.get(key);
                      } catch (Throwable e) {
                          logger.error("获取缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
                      }
                      return null;
                  }
                  /**
                   * 移除缓存
                   *
                   * @param key -
                   * @return -
                   */
                  public boolean removeValue(String key) {
                      try {
                          redisTemplate.delete(key);
                          return true;
                      } catch (Throwable e) {
                          logger.error("移除缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
                      }
                      return false;
                  }
                  /**
                   * 根据前缀移除所有以传入前缀开头的key-value
                   *
                   * @param pattern -
                   * @return -
                   */
                  public boolean removeKeys(String pattern) {
                      try {
                          Set keySet = redisTemplate.keys(pattern + "*");
                          redisTemplate.delete(keySet);
                          return true;
                      } catch (Throwable e) {
                          logger.error("移除key[" + pattern + "]前缀的缓存时失败", "err[" + e.getMessage() + "]");
                      }
                      return false;
                  }
              }
              

              在这个示例中，我们使用 @Resource 注解自动注入了一个 RedisTemplate 对象。然后，我们提供了三个方法来对 Redis 进行操作：cacheValue 方法用于缓存数据，getValue 方法用于获取缓存数据，removeValue 方法用于删除缓存数据。这些方法都是通过 redisTemplate 对象来实现的。

              需要注意的是，在使用 RedisTemplate 时，需要指定键值对的类型。在这个示例中，我们指定了键的类型为 String，值的类型为 Object。

              3.4、使用RedisTemplate

              在上面的示例中，我们已经创建了一个 RedisTemplate 对象，并提供了一些方法来对 Redis 进行操作。现在，我们可以在 SpringBoot 项目中的任何地方使用这个工具类来进行缓存操作。以下是一个示例：

              import org.springframework.beans.factory.annotation.Autowired;
              import org.springframework.web.bind.annotation.GetMapping;
              import org.springframework.web.bind.annotation.PathVariable;
              import org.springframework.web.bind.annotation.RestController;
              @RestController
              public class UserController {
                  @Autowired
                  private RedisUtils redisUtils;
                  @Autowired
                  private UserService userService;
                  @GetMapping("/users/{id}")
                  public User getUserById(@PathVariable Long id) {
                      String key = "user_" + id;
                      User user = (User) redisUtils.getValue(key);
                      if (user == null) {
                          user = userService.getUserById(id);
                          redisUtils.cacheValue(key, user);
                      }
                      return user;
                  }
              }
              

              在这个示例中，我们创建了一个 UserController 类，用于处理 HTTP 请求。在 getUserById 方法中，我们首先构造了一个缓存的 key，然后使用 redisUtils.getValue 方法从 Redis 中获取缓存数据。如果缓存中没有数据，我们调用 userService.getUserById 方法从数据库中获取数据，并使用 redisUtils.cacheValue 方法将数据存入Redis缓存中。最后，返回获取到的数据。

              通过这个示例，我们可以看到，在S pringBoot 项目中使用 Redis 作为缓存的流程。我们首先需要添加 Redis 依赖，然后在配置文件中配置 Redis 连接信息。接着，我们创建了一个 RedisUtil s工具类来管理 RedisTemplate 的创建和使用。最后，我们在控制器中使用 RedisUtils 来对 Redis 进行缓存操作。