Spring AOP实现断路器方式

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface PackFuse {

  /**降级方法*/
  String fallback() default "" ;

  /**失败次数*/
  int fails() default 5 ;

  /**窗口时间:s*/
  int windowSize() default 10 ;

}

public enum EnumState {

  CLOSE, HALF_OPEN, OPEN ;
  
}

public class PackFuseState {

  /**当前状态*/
  private EnumState state = EnumState.CLOSE ;
  /**失败次数*/
  private AtomicInteger failCount = new AtomicInteger(0) ;
  /**最大失败次数*/
  private int maxFailCount = 5 ;
  /**窗口大小；默认每10秒重置*/
  private int windowTime = 10 ;
  
  private static final ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1)) ;
  
  private Object lock = new Object() ;
  
  public PackFuseState(int maxFailCount, int windowTime) {
    this.maxFailCount = maxFailCount ;
    this.windowTime = windowTime ;
    executor.execute(() -> {
      while(true) {
        if (state == EnumState.CLOSE) {
          try {
            TimeUnit.SECONDS.sleep(windowTime) ;
            if (state == EnumState.CLOSE) {
              failCount.set(0) ;
            }
          } catch (InterruptedException e) {
            e.printStackTrace() ;
          }
        } else {
          synchronized (lock) {
            try {
              lock.wait() ;
            } catch (InterruptedException e) {
              e.printStackTrace() ;
            }
          }
        }
      }
    }) ;
  }
  
  public EnumState getState() {
    return state;
  }
  public void setState(EnumState state) {
    this.state = state;
  }
  public AtomicInteger getFailCount() {
    return failCount;
  }
  public void setFailCount(AtomicInteger failCount) {
    this.failCount = failCount;
  }
  public int getwindowTime() {
    return windowTime;
  }
  public void setwindowTime(int windowTime) {
    this.windowTime = windowTime;
  }
  
  public PackFuseState addFailCount() {
    int count = this.failCount.incrementAndGet() ;
    if (count >= maxFailCount) {
      this.setState(EnumState.OPEN) ;
      executor.execute(() -> {
        try {
          TimeUnit.SECONDS.sleep(windowTime) ;
          setState(EnumState.HALF_OPEN) ;
          failCount.set(0) ;
        } catch (InterruptedException e) {
          e.printStackTrace() ;
        }
      }) ;
    }
    return this ;
  }
  
  public PackFuseState closeState() {
    this.setState(EnumState.CLOSE) ;
    this.failCount.set(0) ;
    return this ;
  }

  public Object getLock() {
    return lock;
  }

}

@Aspect
@Component
public class PackFuseAspect {

  private static final Map<String, PackFuseState> META_HOLDER_MAP = new ConcurrentHashMap<>() ;
  private static final Map<String, Object> FALLBACK = new ConcurrentHashMap<>() ;
  private static final String DEFAULT_RET_DATA = "服务不可用" ;
  
  @Pointcut("@annotation(fuse)")
  private void fuse(PackFuse fuse) {}
  
  @Around("fuse(fuse)")
  public Object packFuse(ProceedingJoinPoint pjp, PackFuse fuse) {
    MethodSignature joinPointObject = (MethodSignature) pjp.getSignature() ;
    Class<?> targetType = joinPointObject.getDeclaringType() ;
    Method method = joinPointObject.getMethod() ;
    String targetKey = getKey(targetType, method);
    
    String fallback = fuse.fallback() ;
    if (!FALLBACK.containsKey(targetKey)) {
      if (StringUtils.hasLength(fallback)) {
        try {
          Method fallbackMethod = targetType.getDeclaredMethod(fallback) ;
          FALLBACK.put(targetKey, fallbackMethod.invoke(pjp.getTarget())) ;
        } catch (Exception e) {
          e.printStackTrace() ;
        }
      } else {
        FALLBACK.put(targetKey, DEFAULT_RET_DATA) ;
      }
    }
    int fails = fuse.fails() ;
    int windowSize = fuse.windowSize() ;
    
    PackFuseState fuseState = null ;
    try {
      fuseState = META_HOLDER_MAP.computeIfAbsent(targetKey, key -> new PackFuseState(fails, windowSize)) ;
      switch (fuseState.getState()) {
        case CLOSE:
          return pjp.proceed() ;
        case HALF_OPEN:
          Random rd = new Random() ;
          int c = rd.nextInt(fails) ;
          if (c >= (fails / 2)) {
            Object ret = pjp.proceed() ;
            fuseState.closeState() ;
            synchronized (fuseState.getLock()) {
              fuseState.getLock().notifyAll() ; 
            }
            return ret ;
          }
          return FALLBACK.get(targetKey) ;
        case OPEN:
          return FALLBACK.get(targetKey) ;
      }
    } catch (Throwable e) {
      fuseState.addFailCount() ;
    }
    return FALLBACK.get(targetKey) ;
  }
  
  private String getKey(Class<?> targetType, Method method) {
    StringBuilder builder = new StringBuilder();
    builder.append(targetType.getSimpleName());
    builder.append('#').append(method.getName()).append('(');
    if (method.getParameterTypes().length > 0) {
      builder.deleteCharAt(builder.length() - 1);
    }
    return builder.append(')').toString().replaceAll("[^a-zA-Z0-9]", "") ;
  }
  
}