Vert.x 类似Spring Controller模式编写接口

/**
 * 路由处理工厂
 * <p>
 *   用于初始化router
 * </p>
 */
@Slf4j
public class RouterHandlerFactory {

  /**
   * 扫描的router路径
   */
  private static volatile Reflections reflections;

  /**
   * 默认路由前缀
   */
  private static final String DEFAULT_ROUTER_PREFIX = "/";
  /**
   * 设置路由前缀
   */
  private volatile String routerPrefix = DEFAULT_ROUTER_PREFIX;

  public RouterHandlerFactory(String routerScanPackages) {
    Objects.requireNonNull(routerScanPackages, "routerScanPackages must not be null");
    reflections = ReflectionUtils.getReflections(routerScanPackages);
  }

  public RouterHandlerFactory(String routerScanPackages,String routerPrefix) {
    Objects.requireNonNull(routerScanPackages, "routerScanPackages must not be null");
    reflections = ReflectionUtils.getReflections(routerScanPackages);
    if (!StringUtils.isEmpty(routerPrefix)) {
      this.routerPrefix = routerPrefix;
    }
  }

  public Router createRouter(){
    Vertx vertx = VertxHolder.getVertx();
    Router router = Router.router(vertx);
   return createRouter(router);
  }

  public Router createRouter(Router router) {
    router.route()
      .handler(routingContext -> {
        //日志记录
        log.info("request path:{},uri:{},method:{}", routingContext.request().path(), routingContext.request().uri(), routingContext.request().method());

        routingContext.response()
          //设定默认返回头
          .putHeader("content-type", "application/json; charset=utf-8")
          //设定跨域
          .putHeader("access-control-expose-headers", "*")
          .putHeader("access-control-allow-origin", "*")
          .putHeader("access-control-allow-methods", "GET, POST, PUT, DELETE, OPTIONS")
          .putHeader("access-control-max-age", "3600");
        //调用下一个
        routingContext.next();
      });

    //跨域再次设置
    router.route().handler(CorsHandler.create().addOrigin("*").allowedMethods(new HashSet<>(HttpMethod.values())));
    //body参数解析
    router.route().handler(BodyHandler.create());

    //通过反射注册所有标记@RouterHandler#@RouterMapping的路由信息
    try {
      Set<Class<?>> handlers = reflections.getTypesAnnotatedWith(RouterHandler.class);

      //排序器
      Comparator<Class<?>> comparator = (c1, c2) -> {
        RouterHandler routeHandler1 = c1.getAnnotation(RouterHandler.class);
        RouterHandler routeHandler2 = c2.getAnnotation(RouterHandler.class);
        return Integer.compare(routeHandler1.order(), routeHandler2.order());
      };
      //排序再循环处理
      handlers.stream().sorted(comparator).forEach(handler -> {
        try {
          registerNewHandler(router, handler);
        } catch (Exception e){
          log.error("registerNewHandler error : {}", handler,e);
        }
      });


    } catch (Exception e) {
      log.error("router factory register error", e);
      throw new RuntimeException(e);
    }
    return router;
  }

  @SuppressWarnings("unchecked")
  private void registerNewHandler(Router router,Class<?> handlerClass) throws Exception {
    String path = routerPrefix;
    path = path.startsWith("/") ? path : "/"+path;
    path = path.endsWith("/") ? path : path+"/";

    if (handlerClass.isAnnotationPresent(RouterHandler.class)){
      RouterHandler routerHandler = handlerClass.getAnnotation(RouterHandler.class);
      path = path + routerHandler.value();
    }

    Object instance = handlerClass.getDeclaredConstructor().newInstance();
    Method[] methods = handlerClass.getMethods();
    //方法排序
    Comparator<Method> comparator = (m1, m2) -> {
      RouterMapping mapping1 = m1.getAnnotation(RouterMapping.class);
      RouterMapping mapping2 = m2.getAnnotation(RouterMapping.class);
      return Integer.compare(mapping1.order(), mapping2.order());
    };
    //赛选/排序/循环处理
    List<Method> methodList  = Stream.of(methods).filter(method -> method.isAnnotationPresent(RouterMapping.class)).sorted(comparator).toList();
    for (Method method : methodList) {
      //       method.setAccessible(true);
      RouterMapping routerMapping = method.getAnnotation(RouterMapping.class);
      String routerUrl = routerMapping.value();
      RouterMethod routerMethod = routerMapping.method();
      if (routerUrl.startsWith("/:")){
        routerUrl = method.getName() + routerMapping.value();
      }else{
        routerUrl = routerUrl.endsWith(method.getName())?routerUrl:(routerMapping.overwrite()?routerUrl:routerUrl+method.getName());
        routerUrl = routerUrl.endsWith("/")?routerUrl.substring(1):routerUrl;
      }

      String fullPath = path + routerUrl;
      fullPath = fullPath.replaceAll("//","/");
      Handler<RoutingContext> handlerMethod = (Handler<RoutingContext>)method.invoke(instance);
      String consumes = routerMapping.consumes();
      log.info("Register New Handler -> method:{},url:{},type:{}",routerMapping.method(),fullPath,routerMapping.consumes());

      Route route = switch (routerMethod) {
        case POST -> router.post(fullPath);
        case PUT -> router.put(fullPath);
        case DELETE -> router.delete(fullPath);
        case OPTIONS -> router.options(fullPath);
        case HEAD -> router.head(fullPath);
        case PATCH -> router.patch(fullPath);
        case TRACE -> router.trace(fullPath);
        case CONNECT -> router.connect(fullPath);
        case ROUTE -> router.route(fullPath);
        default -> router.get(fullPath);
      };

      if (!StringUtils.isEmpty(consumes)) {
         route.consumes(consumes);
      }
      route.handler(handlerMethod);
    }

  }

}