SingletonCallAspect.java

package org.cardanofoundation.explorer.api.config.aop.singletoncache;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.concurrent.TimeUnit;

import lombok.RequiredArgsConstructor;

import lombok.extern.log4j.Log4j2;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import com.google.gson.Gson;

import com.google.gson.GsonBuilder;

import com.google.gson.JsonDeserializer;

import com.google.gson.JsonPrimitive;

import com.google.gson.JsonSerializer;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.reflect.CodeSignature;

@Aspect

@Component

public class SingletonCallAspect {

  @Value("${application.network}")

  private String network;

  private static final String LOCKED = "LOCKED";

  private static final String PREFIX_KEY = "METHOD_CACHE:";

  private final RedisTemplate<String, Object> redisTemplate;

  /* Config Gson for working with LocalDate/LocalDateTime */

      new GsonBuilder()

              LocalDate.class,

              (JsonSerializer<LocalDate>)

                  (value, type, context) ->

              LocalDateTime.class,

              (JsonSerializer<LocalDateTime>)

                  (value, type, context) ->

              LocalDate.class,

              (JsonDeserializer<LocalDate>)

                  (jsonElement, type, context) ->

                          DateTimeFormatter.ISO_LOCAL_DATE))

              LocalDateTime.class,

              (JsonDeserializer<LocalDateTime>)

                  (jsonElement, type, context) ->

                          DateTimeFormatter.ISO_LOCAL_DATE_TIME))

  /**

   * this method will be called with the method has annotation @SingletonCall if there are multiple

   * request calls at the same time, only first request can be processed other request must wait for

   * data from first request. Firstly, those request will check Redis cache, If having data (value

   * != LOCKED) return intermediately Or else, first request will call database and process, then

   * save data to redis cache Other requests will recall redis after each `callAfterMilis`, until

   * having data in redis This appoach will save CPU of database server in case expensive queries

   */

  @Around("@annotation(singletonCall)")

  public Object aroundAdvice(ProceedingJoinPoint joinPoint, SingletonCall singletonCall)

      throws Throwable {

    try {

      } else {

          do {

            }

        } else {

        }

      }

      // do nothing

  }

  private String generateCacheKey(

      String methodName, String[] sigParamNames, Object[] sigParamValues) {

    }

  }

}

Mutations