tio-boot官网

使用 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>3.6.3</version>
</dependency>
<dependency>
  <groupId>de.ruedigermoeller</groupId>
  <artifactId>fst</artifactId>
  <version>2.57</version> <!-- 注意:更高版本不支持 jdk 8 -->
</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 {

  @AInitialization
  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();

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

解析 redis_url

REDIS_URL=redis://default:@127.0.0.1:6379
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.dsn.RedisInfo;
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 {

  @AInitialization
  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();

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

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

    TioBootServer.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 类的实例。
    • 如果未找到用户(即 usernull),记录一条日志,并创建一个新的 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.tio.http.server.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 注解

RedisCacheInterceptorEcacheCacheInterceptor可以单独使用,也可以和@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 缓存数据到的使用示例

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

不使用 RedisCacheInterceptorCacheable 的实现

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

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;
  }
}
使用 RedisCacheInterceptorCacheable 的实现

通过使用 RedisCacheInterceptorCacheable 注解,可以大幅简化缓存的处理逻辑。以下是简化后的实现方式:

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);
  }
}
总结

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


李通
215 声望0 粉丝