lxy/redkale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cached优化

Browse Source
This commit is contained in:
redkale
2024-06-08 15:23:58 +08:00
parent f62b276033
commit bbf72bb27b
8 changed files with 249 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/main/java/org/redkale/cached/Cached.java
View File

@@ -29,7 +29,7 @@ public @interface Cached {
* 缓存的key，支持参数动态组合，比如"key_#{id}" <br> * 缓存的key，支持参数动态组合，比如"key_#{id}" <br>
* <b>'@'开头的key值视为CacheKeyGenerator对象名称</b> <br> * <b>'@'开头的key值视为CacheKeyGenerator对象名称</b> <br>
* *
* @see org.redkale.cache.spi.CacheKeyGenerator#name() * @see org.redkale.cached.spi.CachedKeyGenerator#name()
* *
* @return 键 * @return 键
*/ */
@@ -38,9 +38,9 @@ public @interface Cached {
/** /**
* 缓存的hash, 不能含有':'、'#'、'@'字符 * 缓存的hash, 不能含有':'、'#'、'@'字符
* *
* @return hash * @return schema
*/ */
String hash() default CachedManager.DEFAULT_HASH; String schema() default CachedManager.DEFAULT_SCHEMA;
/** /**
* 本地缓存过期时长， 0表示永不过期， -1表示不作本地缓存。<br> * 本地缓存过期时长， 0表示永不过期， -1表示不作本地缓存。<br>

208
src/main/java/org/redkale/cached/CachedManager.java
View File

@@ -19,19 +19,19 @@ import org.redkale.util.ThrowSupplier;
public interface CachedManager { public interface CachedManager {
/** 默认的hash */ /** 默认的hash */
public static final String DEFAULT_HASH = "cached-hash"; public static final String DEFAULT_SCHEMA = "cached-schema";
// -------------------------------------- 本地缓存 -------------------------------------- // -------------------------------------- 本地缓存 --------------------------------------
/** /**
* 本地获取缓存数据, 过期返回null * 本地获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
public <T> T localGet(final String hash, final String key, final Type type); public <T> T localGet(final String schema, final String key, final Type type);
/** /**
* 本地获取缓存数据, 过期返回null * 本地获取缓存数据, 过期返回null
@@ -42,18 +42,18 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default <T> T localGet(final String key, final Type type) { default <T> T localGet(final String key, final Type type) {
return localGet(DEFAULT_HASH, key, type); return localGet(DEFAULT_SCHEMA, key, type);
} }
/** /**
* 本地获取字符串缓存数据, 过期返回null * 本地获取字符串缓存数据, 过期返回null
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 数据值 * @return 数据值
*/ */
default String localGetString(final String hash, final String key) { default String localGetString(final String schema, final String key) {
return localGet(hash, key, String.class); return localGet(schema, key, String.class);
} }
/** /**
@@ -63,14 +63,14 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default String localGetString(final String key) { default String localGetString(final String key) {
return localGetString(DEFAULT_HASH, key); return localGetString(DEFAULT_SCHEMA, key);
} }
/** /**
* 本地获取缓存数据, 过期返回null * 本地获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -79,7 +79,7 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
public <T> T localGetSet( public <T> T localGetSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
boolean nullable, boolean nullable,
@@ -99,14 +99,14 @@ public interface CachedManager {
*/ */
default <T> T localGetSet( default <T> T localGetSet(
final String key, final Type type, boolean nullable, Duration expire, ThrowSupplier<T> supplier) { final String key, final Type type, boolean nullable, Duration expire, ThrowSupplier<T> supplier) {
return localGetSet(DEFAULT_HASH, key, type, nullable, expire, supplier); return localGetSet(DEFAULT_SCHEMA, key, type, nullable, expire, supplier);
} }
/** /**
* 本地异步获取缓存数据, 过期返回null * 本地异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -115,7 +115,7 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
public <T> CompletableFuture<T> localGetSetAsync( public <T> CompletableFuture<T> localGetSetAsync(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -135,20 +135,20 @@ public interface CachedManager {
*/ */
default <T> CompletableFuture<T> localGetSetAsync( default <T> CompletableFuture<T> localGetSetAsync(
String key, Type type, boolean nullable, Duration expire, ThrowSupplier<CompletableFuture<T>> supplier) { String key, Type type, boolean nullable, Duration expire, ThrowSupplier<CompletableFuture<T>> supplier) {
return localGetSetAsync(DEFAULT_HASH, key, type, nullable, expire, supplier); return localGetSetAsync(DEFAULT_SCHEMA, key, type, nullable, expire, supplier);
} }
/** /**
* 本地缓存数据 * 本地缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
public <T> void localSet(String hash, String key, Type type, T value, Duration expire); public <T> void localSet(String schema, String key, Type type, T value, Duration expire);
/** /**
* 本地缓存数据 * 本地缓存数据
@@ -160,19 +160,19 @@ public interface CachedManager {
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
default <T> void localSet(String key, Type type, T value, Duration expire) { default <T> void localSet(String key, Type type, T value, Duration expire) {
localSet(DEFAULT_HASH, key, type, value, expire); localSet(DEFAULT_SCHEMA, key, type, value, expire);
} }
/** /**
* 本地缓存字符串数据 * 本地缓存字符串数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
default void localSetString(final String hash, final String key, final String value, Duration expire) { default void localSetString(final String schema, final String key, final String value, Duration expire) {
localSet(hash, key, String.class, value, expire); localSet(schema, key, String.class, value, expire);
} }
/** /**
@@ -183,17 +183,17 @@ public interface CachedManager {
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
default void localSetString(final String key, final String value, Duration expire) { default void localSetString(final String key, final String value, Duration expire) {
localSetString(DEFAULT_HASH, key, value, expire); localSetString(DEFAULT_SCHEMA, key, value, expire);
} }
/** /**
* 本地删除缓存数据 * 本地删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
public long localDel(String hash, String key); public long localDel(String schema, String key);
/** /**
* 本地删除缓存数据 * 本地删除缓存数据
@@ -202,7 +202,7 @@ public interface CachedManager {
* @return 删除数量 * @return 删除数量
*/ */
default long localDel(String key) { default long localDel(String key) {
return localDel(DEFAULT_HASH, key); return localDel(DEFAULT_SCHEMA, key);
} }
// -------------------------------------- 远程缓存 -------------------------------------- // -------------------------------------- 远程缓存 --------------------------------------
@@ -210,12 +210,12 @@ public interface CachedManager {
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
public <T> T remoteGet(final String hash, final String key, final Type type); public <T> T remoteGet(final String schema, final String key, final Type type);
/** /**
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
@@ -226,18 +226,18 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default <T> T remoteGet(final String key, final Type type) { default <T> T remoteGet(final String key, final Type type) {
return remoteGet(DEFAULT_HASH, key, type); return remoteGet(DEFAULT_SCHEMA, key, type);
} }
/** /**
* 远程获取字符串缓存数据, 过期返回null * 远程获取字符串缓存数据, 过期返回null
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 数据值 * @return 数据值
*/ */
default String remoteGetString(final String hash, final String key) { default String remoteGetString(final String schema, final String key) {
return remoteGet(hash, key, String.class); return remoteGet(schema, key, String.class);
} }
/** /**
@@ -247,19 +247,19 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default String remoteGetString(final String key) { default String remoteGetString(final String key) {
return remoteGetString(DEFAULT_HASH, key); return remoteGetString(DEFAULT_SCHEMA, key);
} }
/** /**
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
public <T> CompletableFuture<T> remoteGetAsync(final String hash, final String key, final Type type); public <T> CompletableFuture<T> remoteGetAsync(final String schema, final String key, final Type type);
/** /**
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
@@ -270,18 +270,18 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default <T> CompletableFuture<T> remoteGetAsync(final String key, final Type type) { default <T> CompletableFuture<T> remoteGetAsync(final String key, final Type type) {
return remoteGetAsync(DEFAULT_HASH, key, type); return remoteGetAsync(DEFAULT_SCHEMA, key, type);
} }
/** /**
* 远程异步获取字符串缓存数据, 过期返回null * 远程异步获取字符串缓存数据, 过期返回null
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 数据值 * @return 数据值
*/ */
default CompletableFuture<String> remoteGetStringAsync(final String hash, final String key) { default CompletableFuture<String> remoteGetStringAsync(final String schema, final String key) {
return remoteGetAsync(hash, key, String.class); return remoteGetAsync(schema, key, String.class);
} }
/** /**
@@ -291,14 +291,14 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default CompletableFuture<String> remoteGetStringAsync(final String key) { default CompletableFuture<String> remoteGetStringAsync(final String key) {
return remoteGetStringAsync(DEFAULT_HASH, key); return remoteGetStringAsync(DEFAULT_SCHEMA, key);
} }
/** /**
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -307,7 +307,7 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
public <T> T remoteGetSet( public <T> T remoteGetSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
boolean nullable, boolean nullable,
@@ -327,14 +327,14 @@ public interface CachedManager {
*/ */
default <T> T remoteGetSet( default <T> T remoteGetSet(
final String key, final Type type, boolean nullable, Duration expire, ThrowSupplier<T> supplier) { final String key, final Type type, boolean nullable, Duration expire, ThrowSupplier<T> supplier) {
return remoteGetSet(DEFAULT_HASH, key, type, nullable, expire, supplier); return remoteGetSet(DEFAULT_SCHEMA, key, type, nullable, expire, supplier);
} }
/** /**
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -343,7 +343,7 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
public <T> CompletableFuture<T> remoteGetSetAsync( public <T> CompletableFuture<T> remoteGetSetAsync(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -363,20 +363,20 @@ public interface CachedManager {
*/ */
default <T> CompletableFuture<T> remoteGetSetAsync( default <T> CompletableFuture<T> remoteGetSetAsync(
String key, Type type, boolean nullable, Duration expire, ThrowSupplier<CompletableFuture<T>> supplier) { String key, Type type, boolean nullable, Duration expire, ThrowSupplier<CompletableFuture<T>> supplier) {
return remoteGetSetAsync(DEFAULT_HASH, key, type, nullable, expire, supplier); return remoteGetSetAsync(DEFAULT_SCHEMA, key, type, nullable, expire, supplier);
} }
/** /**
* 远程缓存数据 * 远程缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
public <T> void remoteSet(final String hash, final String key, final Type type, final T value, Duration expire); public <T> void remoteSet(final String schema, final String key, final Type type, final T value, Duration expire);
/** /**
* 远程缓存数据 * 远程缓存数据
@@ -388,19 +388,19 @@ public interface CachedManager {
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
default <T> void remoteSet(final String key, final Type type, final T value, Duration expire) { default <T> void remoteSet(final String key, final Type type, final T value, Duration expire) {
remoteSet(DEFAULT_HASH, key, type, value, expire); remoteSet(DEFAULT_SCHEMA, key, type, value, expire);
} }
/** /**
* 远程缓存字符串数据 * 远程缓存字符串数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
default void remoteSetString(final String hash, final String key, final String value, Duration expire) { default void remoteSetString(final String schema, final String key, final String value, Duration expire) {
remoteSet(hash, key, String.class, value, expire); remoteSet(schema, key, String.class, value, expire);
} }
/** /**
@@ -411,21 +411,21 @@ public interface CachedManager {
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
default void remoteSetString(final String key, final String value, Duration expire) { default void remoteSetString(final String key, final String value, Duration expire) {
remoteSetString(DEFAULT_HASH, key, value, expire); remoteSetString(DEFAULT_SCHEMA, key, value, expire);
} }
/** /**
* 远程异步缓存数据 * 远程异步缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
* @return void * @return void
*/ */
public <T> CompletableFuture<Void> remoteSetAsync(String hash, String key, Type type, T value, Duration expire); public <T> CompletableFuture<Void> remoteSetAsync(String schema, String key, Type type, T value, Duration expire);
/** /**
* 远程异步缓存数据 * 远程异步缓存数据
@@ -438,21 +438,21 @@ public interface CachedManager {
* @return void * @return void
*/ */
default <T> CompletableFuture<Void> remoteSetAsync(String key, Type type, T value, Duration expire) { default <T> CompletableFuture<Void> remoteSetAsync(String key, Type type, T value, Duration expire) {
return remoteSetAsync(DEFAULT_HASH, key, type, value, expire); return remoteSetAsync(DEFAULT_SCHEMA, key, type, value, expire);
} }
/** /**
* 远程异步缓存字符串数据 * 远程异步缓存字符串数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
* @return void * @return void
*/ */
default CompletableFuture<Void> remoteSetStringAsync( default CompletableFuture<Void> remoteSetStringAsync(
final String hash, final String key, final String value, Duration expire) { final String schema, final String key, final String value, Duration expire) {
return remoteSetAsync(hash, key, String.class, value, expire); return remoteSetAsync(schema, key, String.class, value, expire);
} }
/** /**
@@ -464,17 +464,17 @@ public interface CachedManager {
* @return void * @return void
*/ */
default CompletableFuture<Void> remoteSetStringAsync(final String key, final String value, Duration expire) { default CompletableFuture<Void> remoteSetStringAsync(final String key, final String value, Duration expire) {
return remoteSetStringAsync(DEFAULT_HASH, key, value, expire); return remoteSetStringAsync(DEFAULT_SCHEMA, key, value, expire);
} }
/** /**
* 远程删除缓存数据 * 远程删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
public long remoteDel(String hash, String key); public long remoteDel(String schema, String key);
/** /**
* 远程删除缓存数据 * 远程删除缓存数据
@@ -483,17 +483,17 @@ public interface CachedManager {
* @return 删除数量 * @return 删除数量
*/ */
default long remoteDel(String key) { default long remoteDel(String key) {
return remoteDel(DEFAULT_HASH, key); return remoteDel(DEFAULT_SCHEMA, key);
} }
/** /**
* 远程异步删除缓存数据 * 远程异步删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
public CompletableFuture<Long> remoteDelAsync(String hash, String key); public CompletableFuture<Long> remoteDelAsync(String schema, String key);
/** /**
* 远程异步删除缓存数据 * 远程异步删除缓存数据
@@ -502,7 +502,7 @@ public interface CachedManager {
* @return 删除数量 * @return 删除数量
*/ */
default CompletableFuture<Long> remoteDelAsync(String key) { default CompletableFuture<Long> remoteDelAsync(String key) {
return remoteDelAsync(DEFAULT_HASH, key); return remoteDelAsync(DEFAULT_SCHEMA, key);
} }
// -------------------------------------- both缓存 -------------------------------------- // -------------------------------------- both缓存 --------------------------------------
@@ -510,12 +510,12 @@ public interface CachedManager {
* 本地或远程获取缓存数据, 过期返回null * 本地或远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
public <T> T bothGet(final String hash, final String key, final Type type); public <T> T bothGet(final String schema, final String key, final Type type);
/** /**
* 本地或远程获取缓存数据, 过期返回null * 本地或远程获取缓存数据, 过期返回null
@@ -526,18 +526,18 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default <T> T bothGet(final String key, final Type type) { default <T> T bothGet(final String key, final Type type) {
return bothGet(DEFAULT_HASH, key, type); return bothGet(DEFAULT_SCHEMA, key, type);
} }
/** /**
* 本地或远程获取字符串缓存数据, 过期返回null * 本地或远程获取字符串缓存数据, 过期返回null
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 数据值 * @return 数据值
*/ */
default String bothGetString(final String hash, final String key) { default String bothGetString(final String schema, final String key) {
return bothGet(hash, key, String.class); return bothGet(schema, key, String.class);
} }
/** /**
@@ -547,19 +547,19 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default String bothGetString(final String key) { default String bothGetString(final String key) {
return bothGetString(DEFAULT_HASH, key); return bothGetString(DEFAULT_SCHEMA, key);
} }
/** /**
* 本地或远程异步获取缓存数据, 过期返回null * 本地或远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
public <T> CompletableFuture<T> bothGetAsync(final String hash, final String key, final Type type); public <T> CompletableFuture<T> bothGetAsync(final String schema, final String key, final Type type);
/** /**
* 本地或远程异步获取缓存数据, 过期返回null * 本地或远程异步获取缓存数据, 过期返回null
@@ -570,18 +570,18 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default <T> CompletableFuture<T> bothGetAsync(final String key, final Type type) { default <T> CompletableFuture<T> bothGetAsync(final String key, final Type type) {
return bothGetAsync(DEFAULT_HASH, key, type); return bothGetAsync(DEFAULT_SCHEMA, key, type);
} }
/** /**
* 本地或远程异步获取字符串缓存数据, 过期返回null * 本地或远程异步获取字符串缓存数据, 过期返回null
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 数据值 * @return 数据值
*/ */
default CompletableFuture<String> bothGetStringAsync(final String hash, final String key) { default CompletableFuture<String> bothGetStringAsync(final String schema, final String key) {
return bothGetAsync(hash, key, String.class); return bothGetAsync(schema, key, String.class);
} }
/** /**
@@ -591,14 +591,14 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
default CompletableFuture<String> bothGetStringAsync(final String key) { default CompletableFuture<String> bothGetStringAsync(final String key) {
return bothGetStringAsync(DEFAULT_HASH, key); return bothGetStringAsync(DEFAULT_SCHEMA, key);
} }
/** /**
* 本地或远程获取缓存数据, 过期返回null * 本地或远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -608,7 +608,7 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
public <T> T bothGetSet( public <T> T bothGetSet(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -635,14 +635,14 @@ public interface CachedManager {
Duration localExpire, Duration localExpire,
Duration remoteExpire, Duration remoteExpire,
ThrowSupplier<T> supplier) { ThrowSupplier<T> supplier) {
return bothGetSet(DEFAULT_HASH, key, type, nullable, localExpire, remoteExpire, supplier); return bothGetSet(DEFAULT_SCHEMA, key, type, nullable, localExpire, remoteExpire, supplier);
} }
/** /**
* 本地或远程异步获取缓存数据, 过期返回null * 本地或远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -652,7 +652,7 @@ public interface CachedManager {
* @return 数据值 * @return 数据值
*/ */
public <T> CompletableFuture<T> bothGetSetAsync( public <T> CompletableFuture<T> bothGetSetAsync(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -679,14 +679,14 @@ public interface CachedManager {
Duration localExpire, Duration localExpire,
Duration remoteExpire, Duration remoteExpire,
ThrowSupplier<CompletableFuture<T>> supplier) { ThrowSupplier<CompletableFuture<T>> supplier) {
return bothGetSetAsync(DEFAULT_HASH, key, type, nullable, localExpire, remoteExpire, supplier); return bothGetSetAsync(DEFAULT_SCHEMA, key, type, nullable, localExpire, remoteExpire, supplier);
} }
/** /**
* 本地和远程缓存数据 * 本地和远程缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
@@ -694,7 +694,7 @@ public interface CachedManager {
* @param remoteExpire 远程过期时长，Duration.ZERO为永不过期，为null表示不远程缓存 * @param remoteExpire 远程过期时长，Duration.ZERO为永不过期，为null表示不远程缓存
*/ */
public <T> void bothSet( public <T> void bothSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
final T value, final T value,
@@ -713,21 +713,21 @@ public interface CachedManager {
*/ */
default <T> void bothSet( default <T> void bothSet(
final String key, final Type type, final T value, Duration localExpire, Duration remoteExpire) { final String key, final Type type, final T value, Duration localExpire, Duration remoteExpire) {
bothSet(DEFAULT_HASH, key, type, value, localExpire, remoteExpire); bothSet(DEFAULT_SCHEMA, key, type, value, localExpire, remoteExpire);
} }
/** /**
* 本地和远程缓存字符串数据 * 本地和远程缓存字符串数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param value 数据值 * @param value 数据值
* @param localExpire 本地过期时长，Duration.ZERO为永不过期，为null表示不本地缓存 * @param localExpire 本地过期时长，Duration.ZERO为永不过期，为null表示不本地缓存
* @param remoteExpire 远程过期时长，Duration.ZERO为永不过期，为null表示不远程缓存 * @param remoteExpire 远程过期时长，Duration.ZERO为永不过期，为null表示不远程缓存
*/ */
default void bothSetString( default void bothSetString(
final String hash, final String key, final String value, Duration localExpire, Duration remoteExpire) { final String schema, final String key, final String value, Duration localExpire, Duration remoteExpire) {
bothSet(hash, key, String.class, value, localExpire, remoteExpire); bothSet(schema, key, String.class, value, localExpire, remoteExpire);
} }
/** /**
@@ -739,14 +739,14 @@ public interface CachedManager {
* @param remoteExpire 远程过期时长，Duration.ZERO为永不过期，为null表示不远程缓存 * @param remoteExpire 远程过期时长，Duration.ZERO为永不过期，为null表示不远程缓存
*/ */
default void bothSetString(final String key, final String value, Duration localExpire, Duration remoteExpire) { default void bothSetString(final String key, final String value, Duration localExpire, Duration remoteExpire) {
bothSet(DEFAULT_HASH, key, String.class, value, localExpire, remoteExpire); bothSet(DEFAULT_SCHEMA, key, String.class, value, localExpire, remoteExpire);
} }
/** /**
* 本地和远程异步缓存数据 * 本地和远程异步缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
@@ -755,7 +755,7 @@ public interface CachedManager {
* @return void * @return void
*/ */
public <T> CompletableFuture<Void> bothSetAsync( public <T> CompletableFuture<Void> bothSetAsync(
String hash, String key, Type type, T value, Duration localExpire, Duration remoteExpire); String schema, String key, Type type, T value, Duration localExpire, Duration remoteExpire);
/** /**
* 本地和远程异步缓存数据 * 本地和远程异步缓存数据
@@ -770,13 +770,13 @@ public interface CachedManager {
*/ */
default <T> CompletableFuture<Void> bothSetAsync( default <T> CompletableFuture<Void> bothSetAsync(
String key, Type type, T value, Duration localExpire, Duration remoteExpire) { String key, Type type, T value, Duration localExpire, Duration remoteExpire) {
return bothSetAsync(DEFAULT_HASH, key, type, value, localExpire, remoteExpire); return bothSetAsync(DEFAULT_SCHEMA, key, type, value, localExpire, remoteExpire);
} }
/** /**
* 本地和远程异步缓存字符串数据 * 本地和远程异步缓存字符串数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param value 数据值 * @param value 数据值
* @param localExpire 本地过期时长，Duration.ZERO为永不过期，为null表示不本地缓存 * @param localExpire 本地过期时长，Duration.ZERO为永不过期，为null表示不本地缓存
@@ -784,8 +784,8 @@ public interface CachedManager {
* @return void * @return void
*/ */
default CompletableFuture<Void> bothSetStringAsync( default CompletableFuture<Void> bothSetStringAsync(
String hash, String key, String value, Duration localExpire, Duration remoteExpire) { String schema, String key, String value, Duration localExpire, Duration remoteExpire) {
return bothSetAsync(hash, key, String.class, value, localExpire, remoteExpire); return bothSetAsync(schema, key, String.class, value, localExpire, remoteExpire);
} }
/** /**
@@ -799,17 +799,17 @@ public interface CachedManager {
*/ */
default CompletableFuture<Void> bothSetStringAsync( default CompletableFuture<Void> bothSetStringAsync(
String key, String value, Duration localExpire, Duration remoteExpire) { String key, String value, Duration localExpire, Duration remoteExpire) {
return bothSetAsync(DEFAULT_HASH, key, String.class, value, localExpire, remoteExpire); return bothSetAsync(DEFAULT_SCHEMA, key, String.class, value, localExpire, remoteExpire);
} }
/** /**
* 本地和远程删除缓存数据 * 本地和远程删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
public long bothDel(String hash, String key); public long bothDel(String schema, String key);
/** /**
* 本地和远程删除缓存数据 * 本地和远程删除缓存数据
@@ -818,17 +818,17 @@ public interface CachedManager {
* @return 删除数量 * @return 删除数量
*/ */
default long bothDel(String key) { default long bothDel(String key) {
return bothDel(DEFAULT_HASH, key); return bothDel(DEFAULT_SCHEMA, key);
} }
/** /**
* 本地和远程异步删除缓存数据 * 本地和远程异步删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
public CompletableFuture<Long> bothDelAsync(String hash, String key); public CompletableFuture<Long> bothDelAsync(String schema, String key);
/** /**
* 本地和远程异步删除缓存数据 * 本地和远程异步删除缓存数据
@@ -837,6 +837,6 @@ public interface CachedManager {
* @return 删除数量 * @return 删除数量
*/ */
default CompletableFuture<Long> bothDelAsync(String key) { default CompletableFuture<Long> bothDelAsync(String key) {
return bothDelAsync(DEFAULT_HASH, key); return bothDelAsync(DEFAULT_SCHEMA, key);
} }
} }

6
src/main/java/org/redkale/cached/spi/CachedAction.java
View File

@@ -96,9 +96,9 @@ public class CachedAction {
} }
void init(ResourceFactory resourceFactory, Object service) { void init(ResourceFactory resourceFactory, Object service) {
this.hash = cached.getHash().trim().isEmpty() || CachedManager.DEFAULT_HASH.equals(cached.getHash()) this.hash = cached.getSchema().trim().isEmpty() || CachedManager.DEFAULT_SCHEMA.equals(cached.getSchema())
? CachedManager.DEFAULT_HASH ? CachedManager.DEFAULT_SCHEMA
: environment.getPropertyValue(cached.getHash()); : environment.getPropertyValue(cached.getSchema());
String key = environment.getPropertyValue(cached.getKey()); String key = environment.getPropertyValue(cached.getKey());
this.templetKey = key; this.templetKey = key;
if (key.startsWith("@")) { // 动态加载缓存key生成器 if (key.startsWith("@")) { // 动态加载缓存key生成器

10
src/main/java/org/redkale/cached/spi/CachedEntry.java
View File

@@ -20,7 +20,7 @@ public class CachedEntry {
private String key; private String key;
private String hash; private String schema;
private String localExpire; private String localExpire;
@@ -34,7 +34,7 @@ public class CachedEntry {
public CachedEntry(DynForCached cached) { public CachedEntry(DynForCached cached) {
this.key = cached.key(); this.key = cached.key();
this.hash = cached.hash(); this.schema = cached.schema();
this.localExpire = cached.localExpire(); this.localExpire = cached.localExpire();
this.remoteExpire = cached.remoteExpire(); this.remoteExpire = cached.remoteExpire();
this.timeUnit = cached.timeUnit(); this.timeUnit = cached.timeUnit();
@@ -43,7 +43,7 @@ public class CachedEntry {
public CachedEntry(Cached cached) { public CachedEntry(Cached cached) {
this.key = cached.key(); this.key = cached.key();
this.hash = cached.hash(); this.schema = cached.schema();
this.localExpire = cached.localExpire(); this.localExpire = cached.localExpire();
this.remoteExpire = cached.remoteExpire(); this.remoteExpire = cached.remoteExpire();
this.timeUnit = cached.timeUnit(); this.timeUnit = cached.timeUnit();
@@ -54,8 +54,8 @@ public class CachedEntry {
return key; return key;
} }
public String getHash() { public String getSchema() {
return hash; return schema;
} }
public String getLocalExpire() { public String getLocalExpire() {

12
src/main/java/org/redkale/cached/spi/CachedKeyGenerator.java
View File

@@ -10,7 +10,7 @@ import org.redkale.util.MultiHashKey;
/** /**
* 缓存key生成器 * 缓存key生成器
* *
* @see org.redkale.cache.Cached#key() * @see org.redkale.cached.Cached#key()
* *
* <p>详情见: https://redkale.org * <p>详情见: https://redkale.org
* *
@@ -22,8 +22,8 @@ public interface CachedKeyGenerator {
/** /**
* 根据service和方法名生成key * 根据service和方法名生成key
* *
* @param target Service对象 * @param target 依附对象
* @param action CacheAction对象 * @param action {@link org.redkale.cached.spi.CachedAction}对象
* @param params 参数值 * @param params 参数值
* @return key值 * @return key值
*/ */
@@ -32,15 +32,15 @@ public interface CachedKeyGenerator {
/** /**
* 生成器的名字 * 生成器的名字
* *
* @see org.redkale.cache.Cached#key() * @see org.redkale.cached.Cached#key()
* *
* @return name * @return name
*/ */
public String name(); public String name();
/** /**
* 根据MultiHashKey生成一个CacheKeyGenerator * 根据MultiHashKey生成一个CachedKeyGenerator
* @param key MultiHashKey 不能为空 * @param key {@link org.redkale.util.MultiHashKey} 不能为空
* @return CachedKeyGenerator * @return CachedKeyGenerator
*/ */
public static CachedKeyGenerator create(MultiHashKey key) { public static CachedKeyGenerator create(MultiHashKey key) {

190
src/main/java/org/redkale/cached/spi/CachedManagerService.java
View File

@@ -58,11 +58,11 @@ public class CachedManagerService implements CachedManager, Service {
// 本地缓存Source // 本地缓存Source
protected final CacheMemorySource localSource = new CacheMemorySource("cache-local"); protected final CacheMemorySource localSource = new CacheMemorySource("cache-local");
// 缓存hash集合, 用于定时遍历删除过期数据 // 缓存schema集合, 用于定时遍历删除过期数据
protected final ConcurrentSkipListSet<String> hashNames = new ConcurrentSkipListSet<>(); protected final ConcurrentSkipListSet<String> hashNames = new ConcurrentSkipListSet<>();
// 缓存无效时使用的同步锁 // 缓存无效时使用的同步锁
private final ConcurrentHashMap<String, CachedValue> syncLock = new ConcurrentHashMap<>(); private final ConcurrentHashMap<String, CachedValue> syncLockMap = new ConcurrentHashMap<>();
// 缓存无效时使用的异步锁 // 缓存无效时使用的异步锁
private final ConcurrentHashMap<String, CachedAsyncLock> asyncLockMap = new ConcurrentHashMap<>(); private final ConcurrentHashMap<String, CachedAsyncLock> asyncLockMap = new ConcurrentHashMap<>();
@@ -132,8 +132,8 @@ public class CachedManagerService implements CachedManager, Service {
return enabled; return enabled;
} }
public CachedManagerService addHash(String hash) { public CachedManagerService addSchema(String schema) {
this.hashNames.add(hash); this.hashNames.add(schema);
return this; return this;
} }
@@ -158,22 +158,22 @@ public class CachedManagerService implements CachedManager, Service {
* 本地获取缓存数据, 过期返回null * 本地获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
@Override @Override
public <T> T localGet(final String hash, final String key, final Type type) { public <T> T localGet(final String schema, final String key, final Type type) {
checkEnable(); checkEnable();
return CachedValue.get(localSource.get(idFor(hash, key), loadCacheType(type))); return CachedValue.get(localSource.get(idFor(schema, key), loadCacheType(type)));
} }
/** /**
* 本地获取缓存数据, 过期返回null * 本地获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -183,7 +183,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> T localGetSet( public <T> T localGetSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
boolean nullable, boolean nullable,
@@ -192,7 +192,7 @@ public class CachedManagerService implements CachedManager, Service {
return getSet( return getSet(
(id, ex, ct) -> localSource.get(id, ct), (id, ex, ct) -> localSource.get(id, ct),
this::localSetCache, this::localSetCache,
hash, schema,
key, key,
type, type,
nullable, nullable,
@@ -204,7 +204,7 @@ public class CachedManagerService implements CachedManager, Service {
* 本地异步获取缓存数据, 过期返回null * 本地异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -214,7 +214,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> CompletableFuture<T> localGetSetAsync( public <T> CompletableFuture<T> localGetSetAsync(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -223,7 +223,7 @@ public class CachedManagerService implements CachedManager, Service {
return getSetAsync( return getSetAsync(
(id, ex, ct) -> localSource.getAsync(id, ct), (id, ex, ct) -> localSource.getAsync(id, ct),
this::localSetCacheAsync, this::localSetCacheAsync,
hash, schema,
key, key,
type, type,
nullable, nullable,
@@ -235,28 +235,28 @@ public class CachedManagerService implements CachedManager, Service {
* 本地缓存数据 * 本地缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
@Override @Override
public <T> void localSet(String hash, String key, Type type, T value, Duration expire) { public <T> void localSet(String schema, String key, Type type, T value, Duration expire) {
setCache(localSource, hash, key, type, value, expire); setCache(localSource, schema, key, type, value, expire);
} }
/** /**
* 本地删除缓存数据 * 本地删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
@Override @Override
public long localDel(String hash, String key) { public long localDel(String schema, String key) {
checkEnable(); checkEnable();
return localSource.del(idFor(hash, key)); return localSource.del(idFor(schema, key));
} }
// -------------------------------------- 远程缓存 -------------------------------------- // -------------------------------------- 远程缓存 --------------------------------------
@@ -264,30 +264,30 @@ public class CachedManagerService implements CachedManager, Service {
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
@Override @Override
public <T> T remoteGet(final String hash, final String key, final Type type) { public <T> T remoteGet(final String schema, final String key, final Type type) {
checkEnable(); checkEnable();
return CachedValue.get(remoteSource.get(idFor(hash, key), loadCacheType(type))); return CachedValue.get(remoteSource.get(idFor(schema, key), loadCacheType(type)));
} }
/** /**
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
@Override @Override
public <T> CompletableFuture<T> remoteGetAsync(final String hash, final String key, final Type type) { public <T> CompletableFuture<T> remoteGetAsync(final String schema, final String key, final Type type) {
checkEnable(); checkEnable();
CompletableFuture<CachedValue<T>> future = remoteSource.getAsync(idFor(hash, key), loadCacheType(type)); CompletableFuture<CachedValue<T>> future = remoteSource.getAsync(idFor(schema, key), loadCacheType(type));
return future.thenApply(CachedValue::get); return future.thenApply(CachedValue::get);
} }
@@ -295,7 +295,7 @@ public class CachedManagerService implements CachedManager, Service {
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -305,7 +305,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> T remoteGetSet( public <T> T remoteGetSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
boolean nullable, boolean nullable,
@@ -314,7 +314,7 @@ public class CachedManagerService implements CachedManager, Service {
return getSet( return getSet(
(id, ex, ct) -> remoteSource.get(id, ct), (id, ex, ct) -> remoteSource.get(id, ct),
this::remoteSetCache, this::remoteSetCache,
hash, schema,
key, key,
type, type,
nullable, nullable,
@@ -326,7 +326,7 @@ public class CachedManagerService implements CachedManager, Service {
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -336,7 +336,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> CompletableFuture<T> remoteGetSetAsync( public <T> CompletableFuture<T> remoteGetSetAsync(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -345,7 +345,7 @@ public class CachedManagerService implements CachedManager, Service {
return getSetAsync( return getSetAsync(
(id, ex, ct) -> remoteSource.getAsync(id, ct), (id, ex, ct) -> remoteSource.getAsync(id, ct),
this::remoteSetCacheAsync, this::remoteSetCacheAsync,
hash, schema,
key, key,
type, type,
nullable, nullable,
@@ -357,56 +357,56 @@ public class CachedManagerService implements CachedManager, Service {
* 远程缓存数据 * 远程缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
@Override @Override
public <T> void remoteSet(final String hash, final String key, final Type type, final T value, Duration expire) { public <T> void remoteSet(final String schema, final String key, final Type type, final T value, Duration expire) {
setCache(remoteSource, hash, key, type, value, expire); setCache(remoteSource, schema, key, type, value, expire);
} }
/** /**
* 远程异步缓存数据 * 远程异步缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
*/ */
@Override @Override
public <T> CompletableFuture<Void> remoteSetAsync(String hash, String key, Type type, T value, Duration expire) { public <T> CompletableFuture<Void> remoteSetAsync(String schema, String key, Type type, T value, Duration expire) {
return setCacheAsync(remoteSource, hash, key, type, value, expire); return setCacheAsync(remoteSource, schema, key, type, value, expire);
} }
/** /**
* 远程删除缓存数据 * 远程删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
@Override @Override
public long remoteDel(String hash, String key) { public long remoteDel(String schema, String key) {
checkEnable(); checkEnable();
return remoteSource.del(idFor(hash, key)); return remoteSource.del(idFor(schema, key));
} }
/** /**
* 远程异步删除缓存数据 * 远程异步删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
@Override @Override
public CompletableFuture<Long> remoteDelAsync(String hash, String key) { public CompletableFuture<Long> remoteDelAsync(String schema, String key) {
checkEnable(); checkEnable();
return remoteSource.delAsync(idFor(hash, key)); return remoteSource.delAsync(idFor(schema, key));
} }
// -------------------------------------- both缓存 -------------------------------------- // -------------------------------------- both缓存 --------------------------------------
@@ -414,35 +414,35 @@ public class CachedManagerService implements CachedManager, Service {
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
@Override @Override
public <T> T bothGet(final String hash, final String key, final Type type) { public <T> T bothGet(final String schema, final String key, final Type type) {
return CachedValue.get(bothGetCache(hash, key, (Duration) null, type)); return CachedValue.get(bothGetCache(schema, key, (Duration) null, type));
} }
/** /**
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
@Override @Override
public <T> CompletableFuture<T> bothGetAsync(final String hash, final String key, final Type type) { public <T> CompletableFuture<T> bothGetAsync(final String schema, final String key, final Type type) {
return bothGetCacheAsync(hash, key, (Duration) null, type).thenApply(CachedValue::get); return bothGetCacheAsync(schema, key, (Duration) null, type).thenApply(CachedValue::get);
} }
/** /**
* 远程获取缓存数据, 过期返回null * 远程获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -453,7 +453,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> T bothGetSet( public <T> T bothGetSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
boolean nullable, boolean nullable,
@@ -471,11 +471,11 @@ public class CachedManagerService implements CachedManager, Service {
} }
if (remoteExpire == null) { // 只有本地缓存 if (remoteExpire == null) { // 只有本地缓存
Objects.requireNonNull(localExpire); Objects.requireNonNull(localExpire);
return localGetSet(hash, key, type, nullable, localExpire, supplier); return localGetSet(schema, key, type, nullable, localExpire, supplier);
} }
if (localExpire == null) { // 只有远程缓存 if (localExpire == null) { // 只有远程缓存
Objects.requireNonNull(remoteExpire); Objects.requireNonNull(remoteExpire);
return remoteGetSet(hash, key, type, nullable, remoteExpire, supplier); return remoteGetSet(schema, key, type, nullable, remoteExpire, supplier);
} }
return getSet( return getSet(
this::bothGetCache, this::bothGetCache,
@@ -485,7 +485,7 @@ public class CachedManagerService implements CachedManager, Service {
remoteSetCache(i, remoteExpire, t, v); remoteSetCache(i, remoteExpire, t, v);
} }
}, },
hash, schema,
key, key,
type, type,
nullable, nullable,
@@ -497,7 +497,7 @@ public class CachedManagerService implements CachedManager, Service {
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -508,7 +508,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> CompletableFuture<T> bothGetSetAsync( public <T> CompletableFuture<T> bothGetSetAsync(
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -524,11 +524,11 @@ public class CachedManagerService implements CachedManager, Service {
} }
if (remoteExpire == null) { // 只有本地缓存 if (remoteExpire == null) { // 只有本地缓存
Objects.requireNonNull(localExpire); Objects.requireNonNull(localExpire);
return localGetSetAsync(hash, key, type, nullable, localExpire, supplier); return localGetSetAsync(schema, key, type, nullable, localExpire, supplier);
} }
if (localExpire == null) { // 只有远程缓存 if (localExpire == null) { // 只有远程缓存
Objects.requireNonNull(remoteExpire); Objects.requireNonNull(remoteExpire);
return remoteGetSetAsync(hash, key, type, nullable, remoteExpire, supplier); return remoteGetSetAsync(schema, key, type, nullable, remoteExpire, supplier);
} }
return getSetAsync( return getSetAsync(
this::bothGetCacheAsync, this::bothGetCacheAsync,
@@ -540,7 +540,7 @@ public class CachedManagerService implements CachedManager, Service {
return CompletableFuture.completedFuture(null); return CompletableFuture.completedFuture(null);
} }
}, },
hash, schema,
key, key,
type, type,
nullable, nullable,
@@ -552,7 +552,7 @@ public class CachedManagerService implements CachedManager, Service {
* 远程缓存数据 * 远程缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
@@ -561,7 +561,7 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> void bothSet( public <T> void bothSet(
final String hash, final String schema,
final String key, final String key,
final Type type, final Type type,
final T value, final T value,
@@ -569,13 +569,13 @@ public class CachedManagerService implements CachedManager, Service {
Duration remoteExpire) { Duration remoteExpire) {
checkEnable(); checkEnable();
if (localExpire != null) { if (localExpire != null) {
setCache(localSource, hash, key, type, value, localExpire); setCache(localSource, schema, key, type, value, localExpire);
} }
if (remoteExpire != null && remoteSource != null) { if (remoteExpire != null && remoteSource != null) {
setCache(remoteSource, hash, key, type, value, remoteExpire); setCache(remoteSource, schema, key, type, value, remoteExpire);
} }
if (remoteSource != null && broadcastable) { if (remoteSource != null && broadcastable) {
remoteSource.publish(CACHE_CHANNEL_TOPIC, new CachedEventMessage(idFor(hash, key))); remoteSource.publish(CACHE_CHANNEL_TOPIC, new CachedEventMessage(idFor(schema, key)));
} }
} }
@@ -583,7 +583,7 @@ public class CachedManagerService implements CachedManager, Service {
* 远程异步缓存数据 * 远程异步缓存数据
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param value 数据值 * @param value 数据值
@@ -593,18 +593,18 @@ public class CachedManagerService implements CachedManager, Service {
*/ */
@Override @Override
public <T> CompletableFuture<Void> bothSetAsync( public <T> CompletableFuture<Void> bothSetAsync(
String hash, String key, Type type, T value, Duration localExpire, Duration remoteExpire) { String schema, String key, Type type, T value, Duration localExpire, Duration remoteExpire) {
checkEnable(); checkEnable();
if (localExpire != null) { if (localExpire != null) {
setCache(localSource, hash, key, type, value, localExpire); setCache(localSource, schema, key, type, value, localExpire);
} }
CompletableFuture<Void> future = CompletableFuture.completedFuture(null); CompletableFuture<Void> future = CompletableFuture.completedFuture(null);
if (remoteSource != null && remoteExpire != null) { if (remoteSource != null && remoteExpire != null) {
future = setCacheAsync(remoteSource, hash, key, type, value, remoteExpire); future = setCacheAsync(remoteSource, schema, key, type, value, remoteExpire);
} }
if (remoteSource != null && broadcastable) { if (remoteSource != null && broadcastable) {
future = future.thenCompose(r -> remoteSource future = future.thenCompose(r -> remoteSource
.publishAsync(CACHE_CHANNEL_TOPIC, new CachedEventMessage(idFor(hash, key))) .publishAsync(CACHE_CHANNEL_TOPIC, new CachedEventMessage(idFor(schema, key)))
.thenApply(n -> r)); .thenApply(n -> r));
} }
return future; return future;
@@ -613,14 +613,14 @@ public class CachedManagerService implements CachedManager, Service {
/** /**
* 远程删除缓存数据 * 远程删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
@Override @Override
public long bothDel(String hash, String key) { public long bothDel(String schema, String key) {
checkEnable(); checkEnable();
String id = idFor(hash, key); String id = idFor(schema, key);
long v = localSource.del(id); long v = localSource.del(id);
if (remoteSource != null) { if (remoteSource != null) {
v = remoteSource.del(id); v = remoteSource.del(id);
@@ -634,14 +634,14 @@ public class CachedManagerService implements CachedManager, Service {
/** /**
* 远程异步删除缓存数据 * 远程异步删除缓存数据
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return 删除数量 * @return 删除数量
*/ */
@Override @Override
public CompletableFuture<Long> bothDelAsync(String hash, String key) { public CompletableFuture<Long> bothDelAsync(String schema, String key) {
checkEnable(); checkEnable();
String id = idFor(hash, key); String id = idFor(schema, key);
long v = localSource.del(id); // 内存操作，无需异步 long v = localSource.del(id); // 内存操作，无需异步
if (remoteSource != null) { if (remoteSource != null) {
return remoteSource.delAsync(id).thenCompose(r -> { return remoteSource.delAsync(id).thenCompose(r -> {
@@ -663,7 +663,7 @@ public class CachedManagerService implements CachedManager, Service {
* @param <T> 泛型 * @param <T> 泛型
* @param getter 获取数据函数 * @param getter 获取数据函数
* @param setter 设置数据函数 * @param setter 设置数据函数
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -674,7 +674,7 @@ public class CachedManagerService implements CachedManager, Service {
protected <T> T getSet( protected <T> T getSet(
GetterFunc<CachedValue<T>> getter, GetterFunc<CachedValue<T>> getter,
SetterSyncFunc setter, SetterSyncFunc setter,
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -684,7 +684,7 @@ public class CachedManagerService implements CachedManager, Service {
Objects.requireNonNull(expire); Objects.requireNonNull(expire);
Objects.requireNonNull(supplier); Objects.requireNonNull(supplier);
final Type cacheType = loadCacheType(type); final Type cacheType = loadCacheType(type);
final String id = idFor(hash, key); final String id = idFor(schema, key);
CachedValue<T> cacheVal = getter.get(id, expire, cacheType); CachedValue<T> cacheVal = getter.get(id, expire, cacheType);
if (CachedValue.isValid(cacheVal)) { if (CachedValue.isValid(cacheVal)) {
return cacheVal.getVal(); return cacheVal.getVal();
@@ -707,11 +707,11 @@ public class CachedManagerService implements CachedManager, Service {
} }
return newCacheVal; return newCacheVal;
}; };
cacheVal = syncLock.computeIfAbsent(id, func); cacheVal = syncLockMap.computeIfAbsent(id, func);
try { try {
return CachedValue.get(cacheVal); return CachedValue.get(cacheVal);
} finally { } finally {
syncLock.remove(id); syncLockMap.remove(id);
} }
} }
@@ -721,7 +721,7 @@ public class CachedManagerService implements CachedManager, Service {
* @param <T> 泛型 * @param <T> 泛型
* @param getter 获取数据函数 * @param getter 获取数据函数
* @param setter 设置数据函数 * @param setter 设置数据函数
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param type 数据类型 * @param type 数据类型
* @param nullable 是否缓存null值 * @param nullable 是否缓存null值
@@ -732,7 +732,7 @@ public class CachedManagerService implements CachedManager, Service {
protected <T> CompletableFuture<T> getSetAsync( protected <T> CompletableFuture<T> getSetAsync(
GetterFunc<CompletableFuture<CachedValue<T>>> getter, GetterFunc<CompletableFuture<CachedValue<T>>> getter,
SetterAsyncFunc setter, SetterAsyncFunc setter,
String hash, String schema,
String key, String key,
Type type, Type type,
boolean nullable, boolean nullable,
@@ -741,7 +741,7 @@ public class CachedManagerService implements CachedManager, Service {
checkEnable(); checkEnable();
Objects.requireNonNull(supplier); Objects.requireNonNull(supplier);
final Type cacheType = loadCacheType(type); final Type cacheType = loadCacheType(type);
final String id = idFor(hash, key); final String id = idFor(schema, key);
CompletableFuture<CachedValue<T>> sourceFuture = getter.get(id, expire, cacheType); CompletableFuture<CachedValue<T>> sourceFuture = getter.get(id, expire, cacheType);
return sourceFuture.thenCompose(val -> { return sourceFuture.thenCompose(val -> {
if (CachedValue.isValid(val)) { if (CachedValue.isValid(val)) {
@@ -813,32 +813,32 @@ public class CachedManagerService implements CachedManager, Service {
} }
} }
protected <T> void setCache(CacheSource source, String hash, String key, Type type, T value, Duration expire) { protected <T> void setCache(CacheSource source, String schema, String key, Type type, T value, Duration expire) {
setCache(source, idFor(hash, key), expire, loadCacheType(type, value), CachedValue.create(value)); setCache(source, idFor(schema, key), expire, loadCacheType(type, value), CachedValue.create(value));
} }
protected <T> CompletableFuture<Void> setCacheAsync( protected <T> CompletableFuture<Void> setCacheAsync(
CacheSource source, String hash, String key, Type type, T value, Duration expire) { CacheSource source, String schema, String key, Type type, T value, Duration expire) {
return setCacheAsync(source, idFor(hash, key), expire, loadCacheType(type, value), CachedValue.create(value)); return setCacheAsync(source, idFor(schema, key), expire, loadCacheType(type, value), CachedValue.create(value));
} }
protected <T> CachedValue<T> bothGetCache(String hash, String key, Duration expire, Type type) { protected <T> CachedValue<T> bothGetCache(String schema, String key, Duration expire, Type type) {
return bothGetCache(idFor(hash, key), expire, loadCacheType(type)); return bothGetCache(idFor(schema, key), expire, loadCacheType(type));
} }
/** /**
* 远程异步获取缓存数据, 过期返回null * 远程异步获取缓存数据, 过期返回null
* *
* @param <T> 泛型 * @param <T> 泛型
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @param expire 过期时长，Duration.ZERO为永不过期 * @param expire 过期时长，Duration.ZERO为永不过期
* @param type 数据类型 * @param type 数据类型
* @return 数据值 * @return 数据值
*/ */
protected <T> CompletableFuture<CachedValue<T>> bothGetCacheAsync( protected <T> CompletableFuture<CachedValue<T>> bothGetCacheAsync(
final String hash, final String key, Duration expire, final Type type) { final String schema, final String key, Duration expire, final Type type) {
return bothGetCacheAsync(idFor(hash, key), expire, loadCacheType(type)); return bothGetCacheAsync(idFor(schema, key), expire, loadCacheType(type));
} }
protected <T> CachedValue<T> bothGetCache(final String id, final Duration expire, final Type cacheType) { protected <T> CachedValue<T> bothGetCache(final String id, final Duration expire, final Type cacheType) {
@@ -895,12 +895,12 @@ public class CachedManagerService implements CachedManager, Service {
/** /**
* 创建一个锁key * 创建一个锁key
* *
* @param hash 缓存hash * @param schema 缓存schema
* @param key 缓存键 * @param key 缓存键
* @return key * @return key
*/ */
protected String idFor(String hash, String key) { protected String idFor(String schema, String key) {
return hash + ':' + key; return schema + ':' + key;
} }
/** /**

9
src/main/java/org/redkale/cached/spi/DynForCached.java
View File

@@ -3,17 +3,16 @@
*/ */
package org.redkale.cached.spi; package org.redkale.cached.spi;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented; import java.lang.annotation.Documented;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Target; import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.redkale.service.LoadMode; import org.redkale.service.LoadMode;
/** /**
* {@link org.redkale.cache.Cached}注解的动态扩展版，会多一个字段信息 用于识别方法是否已经动态处理过 * {@link org.redkale.cached.Cached}注解的动态扩展版，会多一个字段信息 用于识别方法是否已经动态处理过
* *
* @author zhangjx * @author zhangjx
* @since 2.8.0 * @since 2.8.0
@@ -27,7 +26,7 @@ public @interface DynForCached {
String key(); String key();
String hash(); String schema();
String localExpire(); String localExpire();

58
src/test/java/org/redkale/test/cached/_DynLocalCacheInstance.java
View File

@@ -12,11 +12,11 @@ import java.util.concurrent.TimeUnit;
import org.redkale.annotation.Resource; import org.redkale.annotation.Resource;
import org.redkale.annotation.ResourceType; import org.redkale.annotation.ResourceType;
import org.redkale.cached.spi.CachedAction; import org.redkale.cached.spi.CachedAction;
import org.redkale.cached.spi.DynForCached;
import org.redkale.net.sncp.Sncp.SncpDyn; import org.redkale.net.sncp.Sncp.SncpDyn;
import org.redkale.util.AnyValue; import org.redkale.util.AnyValue;
import org.redkale.util.RedkaleException; import org.redkale.util.RedkaleException;
import org.redkale.util.ThrowSupplier; import org.redkale.util.ThrowSupplier;
import org.redkale.cached.spi.DynForCached;
@Resource(name = "") @Resource(name = "")
@SncpDyn(remote = false, type = CachedInstance.class) @SncpDyn(remote = false, type = CachedInstance.class)
@@ -27,25 +27,25 @@ public class _DynLocalCacheInstance extends CachedInstance {
private String _redkale_mq; private String _redkale_mq;
private CachedAction _redkale_getNameCacheAction1; private CachedAction _redkale_getNameCachedAction1;
private CachedAction _redkale_getInfoCacheAction2; private CachedAction _redkale_getInfoCachedAction2;
private CachedAction _redkale_getNameAsyncCacheAction3; private CachedAction _redkale_getNameAsyncCachedAction3;
private CachedAction _redkale_getInfo2AsyncCacheAction4; private CachedAction _redkale_getInfo2AsyncCachedAction4;
private CachedAction _redkale_getName2AsyncCacheAction5; private CachedAction _redkale_getName2AsyncCachedAction5;
private CachedAction _redkale_getInfoAsyncCacheAction6; private CachedAction _redkale_getInfoAsyncCachedAction6;
private CachedAction _redkale_getName2CacheAction7; private CachedAction _redkale_getName2CachedAction7;
public _DynLocalCacheInstance() {} public _DynLocalCacheInstance() {}
@DynForCached( @DynForCached(
dynField = "_redkale_getNameCacheAction1", dynField = "_redkale_getNameCachedAction1",
hash = "", schema = "",
key = "name", key = "name",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -53,7 +53,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
localExpire = "30") localExpire = "30")
public String getName() { public String getName() {
ThrowSupplier<String> supplier = () -> this.getName_afterCache(); ThrowSupplier<String> supplier = () -> this.getName_afterCache();
return _redkale_getNameCacheAction1.get(supplier); return _redkale_getNameCachedAction1.get(supplier);
} }
private String getName_afterCache() { private String getName_afterCache() {
@@ -61,8 +61,8 @@ public class _DynLocalCacheInstance extends CachedInstance {
} }
@DynForCached( @DynForCached(
dynField = "_redkale_getInfoCacheAction2", dynField = "_redkale_getInfoCachedAction2",
hash = "", schema = "",
key = "info_#{id}_file#{files.one}", key = "info_#{id}_file#{files.one}",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -70,7 +70,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
localExpire = "30") localExpire = "30")
public File getInfo(CachedInstance.ParamBean bean, int id, List<String> idList, Map<String, File> files) { public File getInfo(CachedInstance.ParamBean bean, int id, List<String> idList, Map<String, File> files) {
ThrowSupplier<File> supplier = () -> this.getInfo_afterCache(bean, id, idList, files); ThrowSupplier<File> supplier = () -> this.getInfo_afterCache(bean, id, idList, files);
return _redkale_getInfoCacheAction2.get(supplier); return _redkale_getInfoCachedAction2.get(supplier);
} }
private File getInfo_afterCache( private File getInfo_afterCache(
@@ -79,8 +79,8 @@ public class _DynLocalCacheInstance extends CachedInstance {
} }
@DynForCached( @DynForCached(
dynField = "_redkale_getNameAsyncCacheAction3", dynField = "_redkale_getNameAsyncCachedAction3",
hash = "", schema = "",
key = "name", key = "name",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -88,7 +88,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
localExpire = "30") localExpire = "30")
public CompletableFuture<String> getNameAsync() { public CompletableFuture<String> getNameAsync() {
ThrowSupplier<CompletableFuture<String>> supplier = () -> this.getNameAsync_afterCache(); ThrowSupplier<CompletableFuture<String>> supplier = () -> this.getNameAsync_afterCache();
return _redkale_getNameAsyncCacheAction3.get(supplier); return _redkale_getNameAsyncCachedAction3.get(supplier);
} }
private CompletableFuture<String> getNameAsync_afterCache() { private CompletableFuture<String> getNameAsync_afterCache() {
@@ -96,8 +96,8 @@ public class _DynLocalCacheInstance extends CachedInstance {
} }
@DynForCached( @DynForCached(
dynField = "_redkale_getInfo2AsyncCacheAction4", dynField = "_redkale_getInfo2AsyncCachedAction4",
hash = "", schema = "",
key = "info_#{id}_file#{files.one}", key = "info_#{id}_file#{files.one}",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -108,7 +108,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
throws IOException, InstantiationException { throws IOException, InstantiationException {
ThrowSupplier<CompletableFuture<Map<String, Integer>>> supplier = ThrowSupplier<CompletableFuture<Map<String, Integer>>> supplier =
() -> this.getInfo2Async_afterCache(bean, id, idList, files); () -> this.getInfo2Async_afterCache(bean, id, idList, files);
return _redkale_getInfo2AsyncCacheAction4.get(supplier, bean, id, idList, files); return _redkale_getInfo2AsyncCachedAction4.get(supplier, bean, id, idList, files);
} }
private CompletableFuture<Map<String, Integer>> getInfo2Async_afterCache( private CompletableFuture<Map<String, Integer>> getInfo2Async_afterCache(
@@ -118,8 +118,8 @@ public class _DynLocalCacheInstance extends CachedInstance {
} }
@DynForCached( @DynForCached(
dynField = "_redkale_getName2AsyncCacheAction5", dynField = "_redkale_getName2AsyncCachedAction5",
hash = "", schema = "",
key = "name", key = "name",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -127,7 +127,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
localExpire = "30") localExpire = "30")
public CompletableFuture<String> getName2Async() throws IOException, InstantiationException { public CompletableFuture<String> getName2Async() throws IOException, InstantiationException {
ThrowSupplier<CompletableFuture<String>> supplier = () -> this.getName2Async_afterCache(); ThrowSupplier<CompletableFuture<String>> supplier = () -> this.getName2Async_afterCache();
return _redkale_getName2AsyncCacheAction5.get(supplier); return _redkale_getName2AsyncCachedAction5.get(supplier);
} }
private CompletableFuture<String> getName2Async_afterCache() throws IOException, InstantiationException { private CompletableFuture<String> getName2Async_afterCache() throws IOException, InstantiationException {
@@ -135,8 +135,8 @@ public class _DynLocalCacheInstance extends CachedInstance {
} }
@DynForCached( @DynForCached(
dynField = "_redkale_getInfoAsyncCacheAction6", dynField = "_redkale_getInfoAsyncCachedAction6",
hash = "", schema = "",
key = "info_#{id}_file#{files.one}", key = "info_#{id}_file#{files.one}",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -145,7 +145,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
public CompletableFuture<File> getInfoAsync( public CompletableFuture<File> getInfoAsync(
CachedInstance.ParamBean bean, int id, List<String> idList, Map<String, File> files) { CachedInstance.ParamBean bean, int id, List<String> idList, Map<String, File> files) {
ThrowSupplier<CompletableFuture<File>> supplier = () -> this.getInfoAsync_afterCache(bean, id, idList, files); ThrowSupplier<CompletableFuture<File>> supplier = () -> this.getInfoAsync_afterCache(bean, id, idList, files);
return _redkale_getInfoAsyncCacheAction6.get(supplier, bean, id, idList, files); return _redkale_getInfoAsyncCachedAction6.get(supplier, bean, id, idList, files);
} }
private CompletableFuture<File> getInfoAsync_afterCache( private CompletableFuture<File> getInfoAsync_afterCache(
@@ -154,8 +154,8 @@ public class _DynLocalCacheInstance extends CachedInstance {
} }
@DynForCached( @DynForCached(
dynField = "_redkale_getName2CacheAction7", dynField = "_redkale_getName2CachedAction7",
hash = "", schema = "",
key = "name", key = "name",
nullable = false, nullable = false,
timeUnit = TimeUnit.SECONDS, timeUnit = TimeUnit.SECONDS,
@@ -163,7 +163,7 @@ public class _DynLocalCacheInstance extends CachedInstance {
localExpire = "30") localExpire = "30")
public String getName2() throws RedkaleException { public String getName2() throws RedkaleException {
ThrowSupplier<String> supplier = () -> this.getName2_afterCache(); ThrowSupplier<String> supplier = () -> this.getName2_afterCache();
return _redkale_getName2CacheAction7.get(supplier); return _redkale_getName2CachedAction7.get(supplier);
} }
private String getName2_afterCache() throws RedkaleException { private String getName2_afterCache() throws RedkaleException {