使用 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
类的实例。 - 如果未找到用户(即
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.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 注解
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
注解,开发者可以更轻松地实现缓存逻辑,减少手动操作缓存的繁琐步骤,确保代码更加简洁和可维护。
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。