https://github.com/sivaosorg/unused-ngx-blobs-cache
Config middleware base caches
https://github.com/sivaosorg/unused-ngx-blobs-cache
cache cache-storage redis redis-cache redis-cloud redis-cluster redis-command redis-sentinel
Last synced: 3 months ago
JSON representation
Config middleware base caches
- Host: GitHub
- URL: https://github.com/sivaosorg/unused-ngx-blobs-cache
- Owner: sivaosorg
- Created: 2021-12-25T16:08:43.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2022-10-04T15:27:59.000Z (over 2 years ago)
- Last Synced: 2025-01-15T18:45:42.389Z (4 months ago)
- Topics: cache, cache-storage, redis, redis-cache, redis-cloud, redis-cluster, redis-command, redis-sentinel
- Language: Java
- Homepage: https://github.com/sivaosorg/ngx-blobs-cache
- Size: 87.9 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
Config middleware base caches
The base library including redis cache, ...
## ⚡️ Quick start
Build application:
```bash
/bin/bash gradlew jar
```
> output jar: ngx-blobs-cache-1.0.0.jar
## :rocket: Functions
#### Redis Cache Attributes
:package: add file [`application-redis.yml`](src/main/resources/application-redis.yml)
```yml
spring:
redis:
database: 0 # Redis database index (default is 0)
jedis:
pool:
max-active: 20 # Maximum connection number (no limit is limited)
max-wait: -1 # Connect the pool maximum blocking waiting time (no limit is limited)
max-idle: 100 # Connect the maximum idle connection in the pool
min-idle: 10
timeout: 20000 # Connect timeout (s)
```
:package: checkout file [`application-params.yml`](src/main/resources/application-params.yml)
```yml
# ////////////////////////////
# Config Redis Jedis Attributes
# ////////////////////////////
---
spring:
redis:
jedis-starter:
enabled: false # enable jedis client
```
:package: checkout `application-dev.yml`, `application-local.yml`, `application-prod.yml`
```yml
# ////////////////////////////
# Config Spring Attributes
# ////////////////////////////
---
spring:
redis:
host: 127.0.0.1
password: 123456
port: 6379
sentinel:
master:
name: master_node
host-and-port: 13.232.155.79:26379;13.232.155.88:26379;13.232.154.78:26379
```
#### Redis Pub-Sub Attributes
:package: checkout file [`application-params.yml`](src/main/resources/application-params.yml)
```yml
# ////////////////////////////
# Config hook redis pub-sub
# ////////////////////////////
---
spring:
redis:
pub-sub-starter:
topic: CALLBACK # including: CALLBACK, MEMO, SHIFT, EFFECTOR and DEFAULT
clusters:
- enable: true
order: 1 # order priority
label: sys::props
description: This is Sys props state
clusterType: CALLBACK # including: CALLBACK, MEMO, SHIFT, EFFECTOR and DEFAULT
- enable: true
order: 2
label: subscription
description: This is Subscription props state
clusterType: CALLBACK
prefix: ::state
```
#### Services
- `NgxRedisBaseService`: use service for base action on redis
```java
/**
* @apiNote RedisKeys - using this class to get keys type, ex: RedisKeys.getSysConfigKey("test")
*/
public interface NgxRedisBaseService {
/**
* Get list of basic objects of cache
*
* @param pattern string prefix
* @return object list
*/
Collection keys(RedisTemplate redisTemplate, String pattern);
/**
* Cache basic objects, integer, string, physical classes, etc.
*
* @param key Cache key value
* @param value Cache
*/
void setCacheObject(RedisTemplate redisTemplate, String key, T value);
/**
* Cache basic objects, integer, string, physical classes, etc.
*
* @param key Cache key value
* @param value Cache
* @param timeout time
* @param timeUnit Time Parts
*/
void setCacheObject(RedisTemplate redisTemplate, String key, T value, Integer timeout, TimeUnit timeUnit);
/**
* Set effective time
*
* @param key Redis button
* @param timeout timeout time
* @return true = set success; false = set failed
*/
boolean expire(RedisTemplate redisTemplate, String key, long timeout);
/**
* Set effective time
*
* @param key Redis button
* @param timeout timeout time
* @param unit Time Unit
* @return true = set success; false = set failed
*/
boolean expire(RedisTemplate redisTemplate, String key, long timeout, TimeUnit unit);
/**
* Get the basic object of the cache.
*
* @param key Cache key value
* @return Cache key value corresponding to data
*/
T getCacheObject(RedisTemplate redisTemplate, String key);
/**
* Delete a single object
*
* @param key -
*/
boolean deleteObject(RedisTemplate redisTemplate, String key);
/**
* Delete set objects
*
* @param collection multiple objects
* @return integer
*/
long deleteObject(RedisTemplate redisTemplate, Collection collection);
/**
* Cache List data
*
* @param key Cache key value
* @param list worthy List data
* @return object
*/
long setCacheList(RedisTemplate redisTemplate, String key, List list);
/**
* Get the List object of the cache
*
* @param key Cache key value
* @return Cache key value corresponding to data
*/
List getCacheList(RedisTemplate redisTemplate, String key);
/**
* Cache SET
*
* @param key Cache key value
* @param dataSet Cache data
* @return object of cache data
*/
BoundSetOperations setCacheSet(RedisTemplate redisTemplate, String key, Set dataSet);
/**
* Get a cache SET
*
* @param key -
* @return -
*/
Set getCacheSet(RedisTemplate redisTemplate, String key);
/**
* Cache MAP
*
* @param key -
* @param map -
*/
void setCacheMap(RedisTemplate redisTemplate, String key, Map map);
/**
* Get the MAP of the cache
*
* @param key -
* @return -
*/
Map getCacheMap(RedisTemplate redisTemplate, String key);
/**
* Save data from Hash
*
* @param key Redis button
* @param hKey Hash button
* @param value Value
*/
void setCacheMapValue(RedisTemplate redisTemplate, String key, String hKey, T value);
/**
* Get data in hash object
*
* @param key Redis button
* @param hKey Hash button
* @return Hash objects
*/
T getCacheMapValue(RedisTemplate redisTemplate, String key, String hKey);
/**
* Get data in multiple HASH
*
* @param key Redis button
* @param hKeys Hash key collection
* @return hash object set
*/
List getMultiCacheMapValue(RedisTemplate redisTemplate, String key, Collection hKeys);
Collection keys(RedisTemplate redisTemplate);
boolean containsKey(RedisTemplate redisTemplate, String key);
void publishEvent(RedisTemplate redisTemplate, ChannelTopic channelTopic, T data);
void publishEvent(RedisTemplate redisTemplate, RedisPubSubType topic, T data);
void publishEvent(RedisTemplate redisTemplate, RedisPubSubLabel topic, T data);
Long countExistingKeys(RedisTemplate redisTemplate, Collection keys);
Boolean isAvailable(RedisTemplate redisTemplate);
}
```
- `NgxRedisStylesBaseService`: use service for all combine base `NgxRedisBaseService` for action on redis
```java
@SuppressWarnings({"UnusedReturnValue"})
public interface NgxRedisStylesBaseService {
Collection keys(String pattern);
Collection keys();
void setCacheObject(RedisStylesRequest redisStylesRequest, T value);
void setCacheObject(RedisStylesRequest redisStylesRequest, T value, Integer timeout, TimeUnit timeUnit);
boolean expire(RedisStylesRequest redisStylesRequest, long timeout);
boolean expire(RedisStylesRequest redisStylesRequest, long timeout, TimeUnit unit);
T getCacheObject(RedisStylesRequest redisStylesRequest);
boolean deleteObject(RedisStylesRequest redisStylesRequest);
long deleteObject(Collection collection);
long setCacheList(RedisStylesRequest redisStylesRequest, List list);
List getCacheList(RedisStylesRequest redisStylesRequest);
BoundSetOperations setCacheSet(RedisStylesRequest redisStylesRequest, Set dataSet);
Set getCacheSet(RedisStylesRequest redisStylesRequest);
void setCacheMap(RedisStylesRequest redisStylesRequest, Map map);
Map getCacheMap(RedisStylesRequest redisStylesRequest);
void setCacheMapValue(RedisStylesRequest redisStylesRequest, String hKey, T value);
T getCacheMapValue(RedisStylesRequest redisStylesRequest, String hKey);
List getMultiCacheMapValue(RedisStylesRequest redisStylesRequest, Collection hKeys);
boolean containsKey(RedisStylesRequest redisStylesRequest);
Long countExistingKeys(Collection keys);
void publishEvent(ChannelTopic channelTopic, T data);
void publishEvent(RedisPubSubType topic, T data);
void publishEvent(RedisPubSubLabel topic, T data);
SIVAResponseDTO> takeValuesFKeys(RedisStylesRequest redisStylesRequest);
SIVAResponseDTO> takeValuesFKeys(String keyPref);
SIVAResponseDTO> updateCacheObject(String keyPref, T value);
Boolean isAvailable();
}
```
- `NgxRedisUtils`: class utils for action on redis
```java
@SuppressWarnings({"ConstantConditions", "rawtypes", "All"})
public class NgxRedisUtils {
public static Long increaseKey(RedisTemplate redisTemplate, String key) {
if (StringUtility.isEmpty(key)) {
return -1L;
}
return (long) redisTemplate.execute((RedisCallback) connection -> {
byte[] paramBytes = redisTemplate.getStringSerializer().serialize(key);
return connection.incr(paramBytes);
}, true);
}
public static Long increaseKey(RedisTemplate redisTemplate, RedisStylesRequest key) {
return increaseKey(redisTemplate, RedisStylesUtils.takeRedisKey(key));
}
public static Long decreaseKey(RedisTemplate redisTemplate, String key) {
if (StringUtility.isEmpty(key)) {
return -1L;
}
return (long) redisTemplate.execute((RedisCallback) connection -> {
byte[] paramBytes = redisTemplate.getStringSerializer().serialize(key);
return connection.decr(paramBytes);
}, true);
}
public static Long decreaseKey(RedisTemplate redisTemplate, RedisStylesRequest key) {
return decreaseKey(redisTemplate, RedisStylesUtils.takeRedisKey(key));
}
public static Long increaseKeyBy(RedisTemplate redisTemplate, String key, long value) {
final String preKey = key;
final long preValue = value;
return (long) redisTemplate.execute(new RedisCallback() {
public Object doInRedis(RedisConnection connection) {
byte[] paramBytes = redisTemplate.getStringSerializer().serialize(preKey);
return connection.incrBy(paramBytes, preValue);
}
}, true);
}
public static Long increaseKeyBy(RedisTemplate redisTemplate, RedisStylesRequest key, long value) {
return increaseKeyBy(redisTemplate, RedisStylesUtils.takeRedisKey(key), value);
}
public static Long decreaseKeyBy(RedisTemplate redisTemplate, String key, long value) {
final String preKey = key;
final long preValue = value;
return (long) redisTemplate.execute(new RedisCallback() {
public Object doInRedis(RedisConnection connection) {
byte[] paramBytes = redisTemplate.getStringSerializer().serialize(preKey);
return connection.decrBy(paramBytes, preValue);
}
}, true);
}
public static Long decreaseKeyBy(RedisTemplate redisTemplate, RedisStylesRequest key, long value) {
return decreaseKeyBy(redisTemplate, RedisStylesUtils.takeRedisKey(key), value);
}
public static Long increaseKeyEx(RedisTemplate redisTemplate, String key, long timeOut, TimeUnit unit) {
long value = increaseKey(redisTemplate, key);
redisTemplate.expire(key, timeOut, unit);
return value;
}
public static Long increaseKeyEx(RedisTemplate redisTemplate, RedisStylesRequest key, long timeOut, TimeUnit unit) {
return increaseKeyEx(redisTemplate, RedisStylesUtils.takeRedisKey(key), timeOut, unit);
}
public static Long decreaseKeyEx(RedisTemplate redisTemplate, String key, long timeOut, TimeUnit unit) {
long value = decreaseKey(redisTemplate, key);
redisTemplate.expire(key, timeOut, unit);
return value;
}
public static Long decreaseKeyEx(RedisTemplate redisTemplate, RedisStylesRequest key, long timeOut, TimeUnit unit) {
return decreaseKeyEx(redisTemplate, RedisStylesUtils.takeRedisKey(key), timeOut, unit);
}
public static Long increaseKeyByEx(RedisTemplate redisTemplate, String key, long value, long timeOut, TimeUnit unit) {
long keySet = increaseKeyBy(redisTemplate, key, value);
redisTemplate.expire(key, timeOut, unit);
return keySet;
}
public static Long increaseKeyByEx(RedisTemplate redisTemplate, RedisStylesRequest key, long value, long timeOut, TimeUnit unit) {
return increaseKeyByEx(redisTemplate, RedisStylesUtils.takeRedisKey(key), value, timeOut, unit);
}
public static Long decreaseKeyByEx(RedisTemplate redisTemplate, String key, long value, long timeOut, TimeUnit unit) {
long keySet = decreaseKeyBy(redisTemplate, key, value);
redisTemplate.expire(key, timeOut, unit);
return keySet;
}
public static Long decreaseKeyByEx(RedisTemplate redisTemplate, RedisStylesRequest key, long value, long timeOut, TimeUnit unit) {
return decreaseKeyByEx(redisTemplate, RedisStylesUtils.takeRedisKey(key), value, timeOut, unit);
}
}
```
- `RedisStylesRequest`: model to build redis key
```java
private static void onRedisKey() {
RedisStylesRequest request = new RedisStylesRequest.RedisStylesRequestBuilder()
.onMasterKey("parent_key")
.onRedisKey("mouse_child")
.onGeolocationType(GeolocationType.VIETNAM_GEOLOCATION)
.onRedisPropsType(RedisPropsType.ObjectType)
.onRedisStylesType(RedisStylesType.USER_KEY)
.onUserKey("self")
.build();
System.out.println("redis key accomplished = " + request.asKey); // call field public to get redis key, o = parent_key:user:self:vietnam:object
System.out.println("redis key accomplished = " + RedisStylesRequest.asKeyRendered(request)); // call from utils method to get redis key, o = parent_key:user:self:vietnam:object
}
```