使用 java-db 整合 redis

概述

java-db 内置 RedisPlugin 是支持 Redis 的极速化插件。使用 RedisPlugin 可以极度方便的使用 redis，该插件不仅提供了丰富的 API，而且还同时支持多 redis 服务端。Redis 拥有超高的性能，丰富的数据结构，天然支持数据持久化，是目前应用非常广泛的 nosql 数据库。对于 redis 的有效应用可极大提升系统性能，节省硬件成本。

入门示例

添加依赖

<dependency>
  <groupId>com.litongjava</groupId>
  <artifactId>java-db</artifactId>
  <version>${java-db.version}</version>
</dependency>
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>4.3.1</version>
</dependency>
<dependency>
  <groupId>de.ruedigermoeller</groupId>
  <artifactId>fst</artifactId>
  <version>2.57</version> <!-- 注意：更高版本不支持 jdk 8 -->
</dependency>
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
  <version>2.11.1</version>
</dependency>

依赖解释

• java-db 提供与 Ehcache 的集成
• jedis:3.6.3 连接 reids
• fst:2.57 序列化支持

使用示例

RedisPlugin 也可以在多种环境下使用，只需引入依赖后多调用一下 redisPlugin.start()即可，以下是代码示例：

public class RedisTest {
  public static void main(String[] args) {
    RedisPlugin rp = new RedisPlugin("myRedis", "localhost");
    // 与web下唯一区别是需要这里调用一次start()方法
    rp.start();

    Redis.use().set("key", "value");
    Redis.use().get("key");
  }
}

Redis Plugin 使用

基本配置

使用时实例化 RedisPlugin 即可，以下是 RedisPlugin 配置示例代码：

// 用于缓存bbs模块的redis服务
RedisPlugin bbsRedis = new RedisPlugin("bbs", "localhost");
bbsRedis.start()


// 用于缓存news模块的redis服务
RedisPlugin newsRedis = new RedisPlugin("news", "192.168.3.9");
newsRedis.start

以上代码创建了两个 RedisPlugin 对象，分别为 bbsRedis 和 newsRedis。最先创建的 RedisPlugin 对象所持有的 Cache 对象将成为主缓存对象，主缓存对象可通过 Redis.use()直接获取，否则需要提供 cacheName 参数才能获取，例如：Redis.use("news")

远程连接

如果 reids 服务端处于远程的另一台服务器，那么需要修改其配置文件 /etc/redis.conf 中的部分配置才能连上：

# 将原有的 bind 值由 127.0.0.1 改成 0.0.0.0
bind 0.0.0.0

# 添加 requirepass 配置，设置密码
requirepass 连接密码在此

配置完成以后，别忘了重启 reids：

# centos 操作系统的启动方式如下
service redis restart

如果你使用的是云服务器，别忘了打开相应的端口号，reids 默认端口号是 6379。

最后，远程连接时的 RedisPlugin 在创建时要传入相应的密码：

RedisPlugin rp = new RedisPlugin("main", "xxx.com", 6379, 10000, "密码在此");
me.add(rp);

以上 RedisPlugin 各参数最后一个是在 redis.config 中配置的密码，其后还支持更多参数，例如数据库：

RedisPlugin rp = new RedisPlugin("main", "xxx.com", 6379, 10000, "密码在此", 数据库);
me.add(rp);

根据需求选用参数即可。

Redis 与 Cache

基本用法

Redis 与 Cache 联合起来可以非常方便地使用 Redis 服务，Redis 对象通过 use()方法来获取到 Cache 对象，Cache 对象提供了丰富的 API 用于使用 Redis 服务，下面是具体使用示例：

public void redisDemo() {
  // 获取名称为bbs的Redis Cache对象
  Cache bbsCache = Redis.use("bbs");
  bbsCache.set("key", "value");
  bbsCache.get("key");

  // 获取名称为news的Redis Cache对象
  Cache newsCache = Redis.use("news");
  newsCache.set("k", "v");
  newsCache.get("k");

  // 最先创建的Cache将成为主Cache，所以可以省去cacheName参数来获取
  bbsCache = Redis.use();    // 主缓存可以省去cacheName参数
  bbsCache.set("tio", "awesome");
}

以上代码中通过”bbs”、”news”做为 use 方法的参数分别获取到了两个 Cache 对象，使用这两个对象即可操作其所对应的 Redis 服务端。

通常情况下只会创建一个 RedisPlugin 连接一个 redis 服务端，使用 Redis.use().set(key,value)即可。

注意：使用 incr、incrBy、decr、decrBy 方法操作的计数器，需要使用 getCounter(key) 进行读取而不能使用 get(key)，否则会抛反序列化异常。同理：incrBy(key, value) 操作不能使用 set(key, value) 。

新用法(建议)

java-db 针对 Redis、Cache 这两个类新增了 call 方法，该方法直接暴漏出 Jedis 对象供使用，可以绕过序列化、反序列化过程

// 使用 lambda 开放 Jedis API
Long ret = Redis.call(j -> j.incrBy("key", 1));

Long ret = Redis.call(jedis -> {
    return jedis.incrBy("key", 1);
});

如果配置了多个 cache 可以通过 Redis.use(...) 先获取对应的 cache 对象再进行操作

// 指定 cacheName 参数再操作
Long ret = Redis.use("mycache").call(j -> j.incrBy("key", 1));

// Redis.use() 不带参表示获取默认 cache
Long ret = Redis.use().call(j -> j.incrBy("key", 1));

存入 String 以外类型数可以将其先转成 json 再操作

User user = dao.findById(userId);
String userJson = JsonUtils.toJson(user);

Redis.call(jedis -> {
    return jedis.set("user", userJson);
});

// 或者简化为下面代码
Redis.call(j -> j.set("user", JsonUtils.toJson(user)));

User user1 = Redis.call(jedis -> {
  String user = jedis.get("user");
  return JSON.parseObject(user, User.class);
})

以上 call 用法，不涉及对象的序列化、反序列化，直接操作 jedis 对象，在当下 json 非常普及的背景下是 笔者推荐的使用方法

工具类

推荐编写一个工具类简化上面的操作,后续会将工具类添加到 Redis 类中

import com.litongjava.db.redis.Redis;
import com.litongjava.tio.utils.json.JsonUtils;

public class RedisUtils {

  public static <T> T getBean(String key, Class<T> type) {
    return Redis.call(jedis -> {
      String str = jedis.get(key);
      if (str != null) {
        return JsonUtils.parse(str, type);
      } else {
        return null;
      }
    });
  }

  public static <R> String setBean(String key, long seconds, Object input) {
    return Redis.call(j -> j.setex(key, seconds, JsonUtils.toJson(input)));
  }

  public static <R> String setBean(String key, Object input) {
    return Redis.call(j -> j.set(key, JsonUtils.toJson(input)));
  }
}

TioBoot 整合 RedisPlugin

app.properties

redis.host=127.0.0.1
redis.port=6789
redis.password=
redis.database=2
redis.timeout=15000
redis.cacheName=main

RedisPluginConfig 配置类

这个类是一个配置类，用于初始化和配置 EhCache 插件。它通过 @AConfiguration 注解标记为配置类。类中的方法 redisPlugin 通过 @ABean 注解标记为 Bean 方法,框架启动时会执行该方法并将返回值放到 bean 容器中。在这个方法中，创建了一个 Plugin 实例并启动它。destroyMethod 指定在服务关闭时将会调用该方法,关闭该插件

package com.litongjava.tio.boot.admin.config;

import com.litongjava.jfinal.aop.annotation.AConfiguration;
import com.litongjava.jfinal.aop.annotation.AInitialization;
import com.litongjava.jfinal.plugin.redis.Cache;
import com.litongjava.jfinal.plugin.redis.Redis;
import com.litongjava.jfinal.plugin.redis.RedisPlugin;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.utils.environment.EnvUtils;

@AConfiguration
public class RedisPluginConfig {

  @Initialization
  public RedisPlugin redisPlugin() {
    String host = EnvUtils.getStr("redis.host");
    Integer port = EnvUtils.getInt("redis.port");
    String password = EnvUtils.getStr("redis.password");
    int redisTimeout = EnvUtils.getInt("redis.timeout", 60);
    int redisDatabase = EnvUtils.getInt("redis.database", 0);
    String cacheName = EnvUtils.get("redis.cacheName");

    // 创建并启动 Redis 插件
    RedisPlugin mainRedis = new RedisPlugin(cacheName, host, port, redisTimeout, password, redisDatabase);
    mainRedis.start();

    // 测试连接
    Cache cache = Redis.use(cacheName);
    cache.getJedis().connect();

    HookCan.me().addDestroyMethod(mainRedis::stop);
    return mainRedis;
  }
}

解析 redis_url

REDIS_URL=redis://default:@127.0.0.1:6379

package com.litongjava.config;

import com.litongjava.annotation.AConfiguration;
import com.litongjava.annotation.AInitialization;
import com.litongjava.model.dsn.RedisInfo;
import com.litongjava.redis.Redis;
import com.litongjava.redis.RedisCache;
import com.litongjava.redis.RedisPlugin;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.utils.dsn.RedisUrlParser;
import com.litongjava.tio.utils.environment.EnvUtils;

import lombok.extern.slf4j.Slf4j;
import redis.clients.jedis.Jedis;

@AConfiguration
@Slf4j
public class RedisPluginConfig {

  @Initialization
  public void redisPlugin() {
    String redisUrl = EnvUtils.get("REDIS_URL");
    if (redisUrl == null) {
      return;
    }
    RedisInfo redisInfo = new RedisUrlParser().parse(redisUrl);
    int redistimeout = EnvUtils.getInt("redis.timeout", 60);
    int redisDatabase = EnvUtils.getInt("redis.database", 0);
    String cacheName = EnvUtils.get("redis.cacheName", "main");

    // 创建并启动 Redis 插件
    RedisPlugin mainRedis = new RedisPlugin(cacheName, redisInfo.getHost(), redisInfo.getPort(), redistimeout, redisInfo.getPswd(), redisDatabase);

    mainRedis.start();

    // 测试连接
    RedisCache cache = Redis.use(cacheName);

    Jedis jedis = cache.getJedis();
    try {
      jedis.connect();
      log.info("connect redis successful");
    } catch (Exception e) {
      e.printStackTrace();
    }

    HookCan.me().addDestroyMethod(mainRedis::stop);
  }
}

控制器

RedisTestController 包含三个方法，每个方法都演示了如何使用 Redis 进行不同类型的操作。以下是对每个方法的详细解释：

1. test01() 方法 - 基本的 Redis 缓存操作

• 目的: 演示了如何使用 Redis 进行基本的缓存操作。
• 过程:
  • 使用 Redis.use("bbs") 获取名为 "bbs" 的 Redis 缓存实例。
  • 试图使用键 "litong" 从缓存中获取值。
  • 如果值不存在（即 null），记录一条日志（表示需要计算新的值），并将一个新值 "value___001" 设置到这个键中。
  • 返回缓存中的值（如果是首次调用，将返回 null，因为设置值是在检查之后）。

2. test02() 方法 - 使用 Redis.call 方法

• 目的: 演示了如何使用 Redis.call 方法执行更复杂的 Redis 操作。
• 过程:
  • 使用 Redis.call 方法执行一个 lambda 表达式，它使用 jedis 客户端从 Redis 中获取键为 "user" 的值。
  • 将获取的 JSON 字符串解析为 User 类的实例。
  • 如果未找到用户（即 user 为 null），记录一条日志，并创建一个新的 User 实例。
  • 使用 Redis.call 再次将新的 User 实例以 JSON 格式保存到 Redis 中。
  • 返回 User 对象。

3. test03() 方法 - 调用 Jedis API

• 目的: 演示如何直接调用 Jedis API 进行 Redis 操作。
• 过程:
  • 使用 Redis.call 方法执行一个 lambda 表达式，该表达式调用 j.incrBy 方法增加 "increase" 键的值。
  • j.incrBy("increase", 1) 表示将 "increase" 键的值增加 1。
  • 返回增加后的值。

package com.litongjava.tio.web.hello.AController;

import com.alibaba.fastjson2.JSON;
import com.litongjava.jfinal.plugin.redis.Cache;
import com.litongjava.jfinal.plugin.redis.Redis;
import com.litongjava.annotation.RequestPath;
import com.litongjava.tio.web.hello.model.User;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequestPath("/redis/test")
public class RedisTestController {

  /**
   * 测试redis
   * @return
   */
  public Object test01() {
    String cacheKey = "litong";

    Cache bbsCache = Redis.use("bbs");

    Object value = bbsCache.get(cacheKey);
    if (value == null) {
      log.info("计算新的值");
      bbsCache.set(cacheKey, "value___001");
    }
    return value;
  }

  /**
   * 使用Redis.call方法
   * @return
   */
  public User test02() {
    User user = Redis.call(jedis -> {
      String userJsonString = jedis.get("user");
      return JSON.parseObject(userJsonString, User.class);
    });

    if (user == null) {
      log.info("重新计算user");
      User user1 = new User("ping", "00000000");
      user = user1;
      // 或者简化为下面代码
      Redis.call(j -> {
        return j.set("user", JSON.toJSONString(user1));
      });
    }

    return user;

  }

  /**
   * 调用Jedis API
   * @return
   */
  public Long test03() {
    Long ret = Redis.call(j -> j.incrBy("increase", 1));
    return ret;
  }
}

访问测试 http://localhost/redis/test/test01 http://localhost/redis/test/test02 http://localhost/redis/test/test03

Cacheable 注解

RedisCacheInterceptor和EcacheCacheInterceptor可以单独使用，也可以和@Cacheable注解配合使用。全类名为com.litongjava.jfinal.plugin.cache.Cacheable。下面是一个示例：

@Before(RedisCacheInterceptor.class)
@Cacheable(name = "userService", value = "getUser", ttl = 300)
public String getUser(String username) {
  System.out.println("select from db username:" + username);
  return username;
}

在单独使用时及不使用@Cacheable 注解时，@Cacheable注解的默认name值是类名，value值是方法名加上所有参数名的 HashCode 值，ttl（Time To Live）值默认为 3600 秒。具体的实现细节可以参考源码com.litongjava.jfinal.plugin.cache.CacheableModel.buildCacheModel。

简单来说，@Cacheable注解用于标记一个方法的结果是可以被缓存的。当一个被@Cacheable注解的方法被调用时，系统首先会检查缓存中是否已经有了这个方法的结果，如果有，就直接返回缓存的结果，否则，就运行方法并把结果存入缓存中。这样，当我们需要再次调用这个方法时，就可以直接从缓存中获取结果.

使用 Cacheable 和 Before 缓存数据到的使用示例

在开发过程中，为了提升应用性能，减少数据库的访问次数，通常会使用缓存来存储一些经常访问的数据。下面展示了两种实现方式：一种是不使用 RedisCacheInterceptor 和 Cacheable 注解的传统方式，另一种是使用这些注解简化后的方式。

不使用 RedisCacheInterceptor 和 Cacheable 的实现

在没有使用 RedisCacheInterceptor 和 Cacheable 注解的情况下，需要手动处理缓存的获取和存储。以下是一个示例：

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.redis.Redis;
import com.testdao.ArticleDao;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ProtocolService {
  private String keyPlatformProtocol = "sys_platform_protocol";

  public String getPlatformProtocol() {
    // 从 Redis 获取缓存的数据
    String str = Redis.getStr(keyPlatformProtocol);
    if (str == null) {
      // 如果缓存中没有数据，从数据库中查询
      log.info("select data from db");
      str = Aop.get(ArticleDao.class).getPlatformProtocol();
      // 将查询结果存入缓存
      Redis.setStr(keyPlatformProtocol, 6000, str);
    }
    return str;
  }
}

使用 RedisCacheInterceptor 和 Cacheable 的实现

通过使用 RedisCacheInterceptor 和 Cacheable 注解，可以大幅简化缓存的处理逻辑。以下是简化后的实现方式：

import com.litongjava.cache.Cacheable;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.jfinal.aop.Before;
import com.litongjava.redis.RedisCacheInterceptor;
import com.testdao.ArticleDao;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ProtocolService {
  @Before(RedisCacheInterceptor.class)
  @Cacheable(name = "sys", value = "platform_protocol", ttl = 6000)
  public String getPlatformProtocol() {
    // 仅在缓存未命中时才执行此方法，从数据库中查询数据
    log.info("select data from db");
    return Aop.get(ArticleDao.class).getPlatformProtocol();
  }
}

测试代码

为了验证上述方法的正确性，可以通过以下测试代码进行测试：

import org.junit.jupiter.api.Test;

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.tio.utils.environment.EnvUtils;

class ProtocolServiceTest {

  @Test
  void getPlatformProtocol() {
    // 加载环境配置
    EnvUtils.load();
    // 配置数据库连接
    new DbConfig().configWithoutSpring();
    // 配置 Redis 插件
    new RedisPluginConfig().redisPlugin();

    // 获取 ProtocolService 实例并调用方法
    ProtocolService protocolService = Aop.get(ProtocolService.class);
    String platformProtocol = protocolService.getPlatformProtocol();
    platformProtocol = protocolService.getPlatformProtocol();
    platformProtocol = protocolService.getPlatformProtocol();

    // 输出结果
    System.out.println(platformProtocol);
  }
}

总结

通过使用 RedisCacheInterceptor 和 Cacheable 注解，开发者可以更轻松地实现缓存逻辑，减少手动操作缓存的繁琐步骤，确保代码更加简洁和可维护。