reactify-cache

Author: hoangtien2k3

reactify-cache/src/main/java/com/reactify/ApplicationContextProvider.java

@@ -22,13 +22,15 @@
 
 /**
  * <p>
- * The {@code ApplicationContextProvider} class serves as a utility for accessing
- * the {@link ApplicationContext} from anywhere within the application.
+ * The {@code ApplicationContextProvider} class serves as a utility for
+ * accessing the {@link ApplicationContext} from anywhere within the
+ * application.
  * </p>
  * <p>
- * This class implements {@link ApplicationContextAware} to store a static reference
- * to the {@link ApplicationContext}, enabling other components to retrieve Spring beans
- * programmatically without requiring dependency injection.
+ * This class implements {@link ApplicationContextAware} to store a static
+ * reference to the {@link ApplicationContext}, enabling other components to
+ * retrieve Spring beans programmatically without requiring dependency
+ * injection.
  * </p>
  * <p>
  * Use the {@link #getBean(Class)} method to obtain a bean instance by its type.
@@ -40,8 +42,8 @@
 public class ApplicationContextProvider implements ApplicationContextAware {
 
     /**
-     * The application context instance, stored as a static volatile variable
-     * to ensure thread safety when accessing the context across multiple threads.
+     * The application context instance, stored as a static volatile variable to
+     * ensure thread safety when accessing the context across multiple threads.
      * <p>
      * The {@code volatile} keyword guarantees visibility of updates to the variable
      * across threads, and the double-checked locking mechanism ensures that the
@@ -53,15 +55,17 @@ public class ApplicationContextProvider implements ApplicationContextAware {
     /**
      * Retrieves a bean from the {@link ApplicationContext} by its type.
      * <p>
-     * This method allows fetching beans from the Spring container without
-     * using {@code @Autowired} or other dependency injection mechanisms.
+     * This method allows fetching beans from the Spring container without using
+     * {@code @Autowired} or other dependency injection mechanisms.
      * </p>
      *
-     * @param clazz the class type of the desired bean
-     * @param <T>   the generic type of the bean
+     * @param clazz
+     *            the class type of the desired bean
+     * @param <T>
+     *            the generic type of the bean
      * @return an instance of the requested bean
      * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
-     *         if no bean of the specified type is found
+     *             if no bean of the specified type is found
      */
     public static <T> T getBean(Class<T> clazz) {
         return context.getBean(clazz);

reactify-cache/src/main/java/com/reactify/CacheAspect.java

@@ -69,16 +69,22 @@ private void processAnnotation() {}
     public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
         Object[] args = joinPoint.getArgs();
         Object key = SimpleKeyGenerator.generateKey(args);
-        String nameCache = ClassUtils.getUserClass(joinPoint.getTarget().getClass()).getSimpleName() + "."
-                + joinPoint.getSignature().getName();
+        String nameCache = ClassUtils.getUserClass(joinPoint.getTarget().getClass())
+                        .getSimpleName() + "." + joinPoint.getSignature().getName();
         Cache<Object, Object> cache = CacheStore.getCache(nameCache);
         log.debug("Checking cache for method: {} with key: {}", nameCache, key);
-        return CacheMono.lookup(k -> Mono.justOrEmpty(!DataUtil.isNullOrEmpty(cache) ? cache.getIfPresent(key) : Mono.empty()).map(Signal::next), key)
+        return CacheMono.lookup(
+                        k -> Mono.justOrEmpty(!DataUtil.isNullOrEmpty(cache) ? cache.getIfPresent(key) : Mono.empty())
+                                .map(Signal::next),
+                        key)
                 .onCacheMissResume(Mono.defer(() -> {
                     try {
                         Object result = joinPoint.proceed(args);
                         if (!(result instanceof Mono<?>)) {
-                            log.warn("Method {} must return a Mono<?> but got: {}", nameCache, result.getClass().getSimpleName());
+                            log.warn(
+                                    "Method {} must return a Mono<?> but got: {}",
+                                    nameCache,
+                                    result.getClass().getSimpleName());
                             return Mono.error(new IllegalStateException("Method must return Mono<?>"));
                         }
                         @SuppressWarnings("unchecked")

reactify-cache/src/main/java/com/reactify/CacheStore.java

@@ -18,6 +18,10 @@
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.Scheduler;
+import java.lang.reflect.Method;
+import java.time.Duration;
+import java.util.*;
+import javax.annotation.PostConstruct;
 import org.reflections.Reflections;
 import org.reflections.scanners.Scanners;
 import org.slf4j.Logger;
@@ -31,18 +35,14 @@
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
 
-import javax.annotation.PostConstruct;
-import java.lang.reflect.Method;
-import java.time.Duration;
-import java.util.*;
-
 /**
- * The {@code CacheStore} class is responsible for managing local caches using Caffeine.
- * It automatically initializes caches based on methods annotated with {@link LocalCache},
- * supports retrieving caches by name, and provides functionalities to clear specific or all caches.
+ * The {@code CacheStore} class is responsible for managing local caches using
+ * Caffeine. It automatically initializes caches based on methods annotated with
+ * {@link LocalCache}, supports retrieving caches by name, and provides
+ * functionalities to clear specific or all caches.
  * <p>
- * This class also supports auto-loading caches on application startup and integrates with Spring's
- * application context lifecycle events.
+ * This class also supports auto-loading caches on application startup and
+ * integrates with Spring's application context lifecycle events.
  * </p>
  *
  * @author hoangtien2k3
@@ -58,7 +58,9 @@ public class CacheStore implements ApplicationContextAware {
     /** Stores the caches mapped by their names. */
     private static final HashMap<String, Cache<Object, Object>> caches = new HashMap<>();
 
-    /** Stores methods annotated with {@link LocalCache} that require auto-loading. */
+    /**
+     * Stores methods annotated with {@link LocalCache} that require auto-loading.
+     */
     private static final Set<Method> autoLoadMethods = new HashSet<>();
 
     /** The base package for scanning cache-related methods. */
@@ -127,7 +129,8 @@ public static List<String> getCaches() {
     /**
      * Clears the specified cache by name.
      *
-     * @param cacheName the name of the cache to clear
+     * @param cacheName
+     *            the name of the cache to clear
      * @return the number of cleared caches (0 or 1)
      */
     public static int clearCachesByName(String cacheName) {
@@ -150,17 +153,19 @@ public static int clearAllCaches() {
         log.info("Clearing all caches");
         int count = 0;
         for (Map.Entry<String, Cache<Object, Object>> entry : caches.entrySet()) {
-            count ++;
+            count++;
             entry.getValue().invalidateAll();
             log.info("Cleared cache: {}", entry.getKey());
         }
         return count;
     }
 
     /**
-     * Automatically loads caches for methods annotated with {@link LocalCache} that support auto-loading.
+     * Automatically loads caches for methods annotated with {@link LocalCache} that
+     * support auto-loading.
      *
-     * @param event the application context refresh event
+     * @param event
+     *            the application context refresh event
      */
     @Async
     @EventListener
@@ -177,10 +182,13 @@ public void autoLoad(ContextRefreshedEvent event) {
     }
 
     /**
-     * Sets the application context and determines the base package for scanning cache methods.
+     * Sets the application context and determines the base package for scanning
+     * cache methods.
      *
-     * @param applicationContext the application context
-     * @throws BeansException if an error occurs while setting the context
+     * @param applicationContext
+     *            the application context
+     * @throws BeansException
+     *             if an error occurs while setting the context
      */
     @Override
     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

reactify-cache/src/main/java/com/reactify/CacheUtils.java

@@ -65,16 +65,19 @@ public static void invokeMethod(Method method) {
             if (result instanceof Mono<?> monoResult) {
                 monoResult.subscribe(
                         success -> log.debug("Successfully executed {}", methodName),
-                        error -> log.error("Error executing {}", methodName, error)
-                );
+                        error -> log.error("Error executing {}", methodName, error));
             } else {
                 log.warn("Method {} does not return a Mono<?>", methodName);
             }
         } catch (IllegalAccessException e) {
             log.error("Access violation when invoking method {}: {}", method.getName(), e.getMessage(), e);
         } catch (Exception e) {
-            log.error("Error when autoload cache {}.{}.{}",
-                    method.getDeclaringClass().getSimpleName(), method.getName(), e.getMessage(), e);
+            log.error(
+                    "Error when autoload cache {}.{}.{}",
+                    method.getDeclaringClass().getSimpleName(),
+                    method.getName(),
+                    e.getMessage(),
+                    e);
         }
     }
 }

reactify-cache/src/main/java/com/reactify/LocalCache.java

@@ -21,16 +21,20 @@
 import java.lang.annotation.Target;
 
 /**
- * Annotation for enabling local caching on method results to enhance performance
- * by reducing redundant computations and minimizing repeated data retrievals from
- * external sources such as databases or APIs.
+ * Annotation for enabling local caching on method results to enhance
+ * performance by reducing redundant computations and minimizing repeated data
+ * retrievals from external sources such as databases or APIs.
  *
  * <p>
- * This annotation provides a flexible caching mechanism with configurable properties:
+ * This annotation provides a flexible caching mechanism with configurable
+ * properties:
  * <ul>
- * <li><strong>durationInMinute</strong>: Defines the lifespan of cached entries in minutes.</li>
- * <li><strong>maxRecord</strong>: Specifies the maximum number of entries that can be stored in the cache.</li>
- * <li><strong>autoCache</strong>: Determines whether caching should be automatically applied when the method is invoked.</li>
+ * <li><strong>durationInMinute</strong>: Defines the lifespan of cached entries
+ * in minutes.</li>
+ * <li><strong>maxRecord</strong>: Specifies the maximum number of entries that
+ * can be stored in the cache.</li>
+ * <li><strong>autoCache</strong>: Determines whether caching should be
+ * automatically applied when the method is invoked.</li>
  * </ul>
  * </p>
  *
@@ -47,33 +51,40 @@
  * {@code
  * @LocalCache(durationInMinute = 15, maxRecord = 200, autoCache = true)
  * public List<User> fetchActiveUsers() {
- *     // Retrieves a list of active users from the database
+ * 	// Retrieves a list of active users from the database
  * }
  * }
  * </pre>
  *
  * <h3>Annotation Properties:</h3>
  * <dl>
  * <dt><strong>durationInMinute</strong></dt>
- * <dd>Specifies how long (in minutes) the cache entry remains valid. Default is 120 minutes.</dd>
+ * <dd>Specifies how long (in minutes) the cache entry remains valid. Default is
+ * 120 minutes.</dd>
  *
  * <dt><strong>maxRecord</strong></dt>
- * <dd>Limits the number of records stored in the cache at any given time. Default is 1000 entries.</dd>
+ * <dd>Limits the number of records stored in the cache at any given time.
+ * Default is 1000 entries.</dd>
  *
  * <dt><strong>autoCache</strong></dt>
- * <dd>If set to <code>true</code>, caching is applied automatically whenever the method is executed. Default is <code>false</code>.</dd>
+ * <dd>If set to <code>true</code>, caching is applied automatically whenever
+ * the method is executed. Default is <code>false</code>.</dd>
  * </dl>
  *
  * <h3>Best Practices:</h3>
  * <ul>
- * <li>Use on methods that return frequently accessed and computationally expensive results.</li>
- * <li>Avoid applying to methods with frequently changing data to prevent stale cache issues.</li>
- * <li>Adjust `durationInMinute` and `maxRecord` according to system load and data update frequency.</li>
+ * <li>Use on methods that return frequently accessed and computationally
+ * expensive results.</li>
+ * <li>Avoid applying to methods with frequently changing data to prevent stale
+ * cache issues.</li>
+ * <li>Adjust `durationInMinute` and `maxRecord` according to system load and
+ * data update frequency.</li>
  * </ul>
  *
  * <p>
- * This annotation is particularly useful in microservices and high-performance applications
- * where minimizing latency and optimizing resource utilization are crucial.
+ * This annotation is particularly useful in microservices and high-performance
+ * applications where minimizing latency and optimizing resource utilization are
+ * crucial.
  * </p>
  */
 @Target(ElementType.METHOD)
@@ -89,18 +100,20 @@
     int durationInMinute() default 120;
 
     /**
-     * Specifies the maximum number of records that can be stored in the cache.
-     * Once this limit is reached, older entries may be evicted based on cache policies.
+     * Specifies the maximum number of records that can be stored in the cache. Once
+     * this limit is reached, older entries may be evicted based on cache policies.
      *
      * @return maximum cache size (default: 1000)
      */
     int maxRecord() default 1000;
 
     /**
-     * Indicates whether caching should be automatically applied when the method is invoked.
-     * If enabled, the method execution result will be stored in the cache for subsequent calls.
+     * Indicates whether caching should be automatically applied when the method is
+     * invoked. If enabled, the method execution result will be stored in the cache
+     * for subsequent calls.
      *
-     * @return <code>true</code> to enable automatic caching, <code>false</code> otherwise (default: false)
+     * @return <code>true</code> to enable automatic caching, <code>false</code>
+     *         otherwise (default: false)
      */
     boolean autoCache() default false;
 }

reactify-cache/src/main/java/com/reactify/request/LocalCacheRequest.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright 2024-2025 the original author Hoàng Anh Tiến.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package com.reactify.request;
 
 /**
@@ -6,18 +21,22 @@
  * </p>
  *
  * <p>
- * This class is used to specify the cache clearing operation, allowing
- * users to delete cache at different levels based on the provided type.
+ * This class is used to specify the cache clearing operation, allowing users to
+ * delete cache at different levels based on the provided type.
  * </p>
  *
  * <ul>
- *     <li><b>SERVICE_LEVEL</b>: Clears all cached entries related to a specific service.</li>
- *     <li><b>METHOD_LEVEL</b>: Clears a specific cache by its unique name (absolute method path).</li>
- *     <li><b>ALL_LEVEL</b>: Clears all caches across all services in the system.</li>
+ * <li><b>SERVICE_LEVEL</b>: Clears all cached entries related to a specific
+ * service.</li>
+ * <li><b>METHOD_LEVEL</b>: Clears a specific cache by its unique name (absolute
+ * method path).</li>
+ * <li><b>ALL_LEVEL</b>: Clears all caches across all services in the
+ * system.</li>
  * </ul>
  *
  * <p>
- * The `nameCache` field is required when using `SERVICE_LEVEL` or `METHOD_LEVEL` type.
+ * The `nameCache` field is required when using `SERVICE_LEVEL` or
+ * `METHOD_LEVEL` type.
  * </p>
  *
  * @author hoangtien2k3
@@ -29,9 +48,10 @@ public class LocalCacheRequest {
      * <p>
      * Accepted values:
      * <ul>
-     *     <li><b>SERVICE_LEVEL</b> - Clear cache for a specific service.</li>
-     *     <li><b>METHOD_LEVEL</b> - Clear a specific cache by its absolute method path.</li>
-     *     <li><b>ALL_LEVEL</b> - Clear all caches in the system.</li>
+     * <li><b>SERVICE_LEVEL</b> - Clear cache for a specific service.</li>
+     * <li><b>METHOD_LEVEL</b> - Clear a specific cache by its absolute method
+     * path.</li>
+     * <li><b>ALL_LEVEL</b> - Clear all caches in the system.</li>
      * </ul>
      * </p>
      */
@@ -42,8 +62,8 @@ public class LocalCacheRequest {
      * <p>
      * This field is required when `type` is either:
      * <ul>
-     *     <li><b>SERVICE_LEVEL</b> - Specifies which service’s cache to clear.</li>
-     *     <li><b>METHOD_LEVEL</b> - Specifies the exact cache entry to remove.</li>
+     * <li><b>SERVICE_LEVEL</b> - Specifies which service’s cache to clear.</li>
+     * <li><b>METHOD_LEVEL</b> - Specifies the exact cache entry to remove.</li>
      * </ul>
      * For `ALL_LEVEL`, this field can be null.
      * </p>

reactify-cache/src/main/resources/HEADER.txt

@@ -0,0 +1,13 @@
+Copyright 2024-2025 the original author Hoàng Anh Tiến.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.