@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Degrade {

    /**
     * 降级key
     * 自定义,配置了则
     *
     * @return 降级key
     */
    DegradeEnum value();

}

@Slf4j
public final class DegradeUtils {

    /**
     * 服务降级配置
     * key 自定义降级Key
     * val 是否降级 默认 false不降级
     */
    private static volatile Map<String, Boolean> DEGRADE_CONFIG_MAP = new ConcurrentHashMap<>();


    /**
     * setDegradeConfigMap
     *
     * @param degradeConfigMap degradeConfigMap
     */
    public static void setDegradeConfigMap(Map<String, Boolean> degradeConfigMap) {
        if (log.isWarnEnabled()){
            log.warn("[降级监控] 当前: {}，设置后:{}", JSON.toJSONString(DEGRADE_CONFIG_MAP), degradeConfigMap);
        }
        DEGRADE_CONFIG_MAP = degradeConfigMap;
    }


    /**
     * 是否降级
     *
     * @return 是否降级
     */
    public static boolean isDegrade(DegradeEnum degradeEnum) {
        boolean degradeFlag = MapUtils.getBoolean(DEGRADE_CONFIG_MAP, degradeEnum.name(), false);
        if (degradeFlag) {
            if (log.isWarnEnabled()){
                log.warn("降级监控 [{} 已降级] key:{}", degradeEnum.getDesc(), degradeEnum.name());
            }
        } else {
            if (log.isDebugEnabled()){
                log.debug("降级监控[{} 未降级] key:{}", degradeEnum.getDesc(), degradeEnum.name());
            }
        }
        return degradeFlag;
    }
}

@Aspect
@Component
@Slf4j
public class DegradeAspect {


    /**
     * forceBotActionServices
     */
    @Resource
    private List<DegradeService<?>> degradeServices;

    /**
     * 注解切面
     */
    @Pointcut("@annotation(com.xxxx.Degrade)")
    public void pointcutInterface() {
        // Do nothing because of pointcut expression
    }


    /**
     * doAroundAdvice
     *
     * @param joinPoint joinPoint
     * @param degrade   degrade
     * @return {@link Object}
     */
    @Around("pointcutInterface() && @annotation(degrade)")
    public Object doAroundAdvice(ProceedingJoinPoint joinPoint, Degrade degrade) throws Throwable {
        DegradeEnum degradeEnum = degrade.value();
        boolean degradeFlag = DegradeUtils.isDegrade(degradeEnum);
        if (!degradeFlag) {
            return joinPoint.proceed();
        }
      
        DegradeService<?> degradeService = degradeServices.stream()
                .filter(item -> item.getDegradeEnum() == degradeEnum)
                .findFirst()
                .orElseThrow(() -> new RuntimeException("未找到降级服务"));
        DegradeReqBO degradeReq = new DegradeReqBO();
        degradeReq.setArgs(joinPoint.getArgs());
        return degradeService.execute(degradeReq);
    }


    /**
     * 获取方法名
     *
     * @param joinPoint ProceedingJoinPoint
     * @return 方法名
     */
    private String getMethodName(ProceedingJoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        if (signature instanceof MethodSignature) {
            MethodSignature methodSignature = (MethodSignature) signature;
            return methodSignature.getMethod().getName();
        }
        return "None";
    }
}

@Component
@Slf4j
public class DegradeRiskFireEyesServiceImpl implements DegradeService<String> {

    @Override
    public String execute(DegradeReqBO req) {
        return "pass";
    }

    @Override
    public DegradeEnum getDegradeEnum() {
        return DegradeEnum.RISK_FIRE_EYES;
    }


}