Java CorsHandler类代码示例

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
/**
 * Enables CORS
 *
 * @param allowedOriginPattern allowed origin
 * @param allowCredentials     allow credentials (true/false)
 * @param maxAge               in seconds
 * @param allowedHeaders       set of allowed headers
 * @param methods              list of methods ... if empty all methods are allowed  @return self
 * @return self
 */
public RestBuilder enableCors(String allowedOriginPattern,
                              boolean allowCredentials,
                              int maxAge,
                              Set<String> allowedHeaders,
                              HttpMethod... methods) {

	corsHandler = CorsHandler.create(allowedOriginPattern)
	                         .allowCredentials(allowCredentials)
	                         .maxAgeSeconds(maxAge);

	if (methods == null || methods.length == 0) { // if not given than all
		methods = HttpMethod.values();
	}

	for (HttpMethod method : methods) {
		corsHandler.allowedMethod(method);
	}

	corsHandler.allowedHeaders(allowedHeaders);

	return this;
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
/**
 * @param router               to add handler to
 * @param allowedOriginPattern origin pattern
 * @param allowCredentials     allowed credentials
 * @param maxAge               in seconds
 * @param allowedHeaders       set of headers or null for none
 * @param methods              list of methods or empty for all
 */
public void enableCors(Router router,
                       String allowedOriginPattern,
                       boolean allowCredentials,
                       int maxAge,
                       Set<String> allowedHeaders,
                       HttpMethod... methods) {

	CorsHandler handler = CorsHandler.create(allowedOriginPattern)
	                                 .allowCredentials(allowCredentials)
	                                 .maxAgeSeconds(maxAge);

	if (methods == null || methods.length == 0) { // if not given than all
		methods = HttpMethod.values();
	}

	for (HttpMethod method : methods) {
		handler.allowedMethod(method);
	}

	handler.allowedHeaders(allowedHeaders);

	router.route().handler(handler);
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
/**
 * Register this but also register the {@link CorsHandler}. The
 * {@link CorsHandler} will deal with the normal CORS headers after it has been
 * processed initially by this handler. {@inheritDoc}
 */
@Override
public void register(final Router router) {

    router.route().handler(this);

    router.route().handler(CorsHandler.create(".+")
        .maxAgeSeconds(600)
        .allowedMethod(HttpMethod.GET)
        .allowedMethod(HttpMethod.POST)
        .allowedMethod(HttpMethod.PUT)
        .allowedMethod(HttpMethod.DELETE)
        .allowedMethod(HttpMethod.OPTIONS)
        .allowedHeader("Content-Type")
        .allowedHeader("Accept")
        .allowedHeader("Accept-Language")
        .allowedHeader("Authorization"));

}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
/**
 * Enable CORS support.
 *
 * @param router router instance
 */
protected void enableCorsSupport(Router router) {
  Set<String> allowHeaders = new HashSet<>();
  allowHeaders.add("x-requested-with");
  allowHeaders.add("Access-Control-Allow-Origin");
  allowHeaders.add("origin");
  allowHeaders.add("Content-Type");
  allowHeaders.add("accept");
  Set<HttpMethod> allowMethods = new HashSet<>();
  allowMethods.add(HttpMethod.GET);
  allowMethods.add(HttpMethod.PUT);
  allowMethods.add(HttpMethod.OPTIONS);
  allowMethods.add(HttpMethod.POST);
  allowMethods.add(HttpMethod.DELETE);
  allowMethods.add(HttpMethod.PATCH);

  router.route().handler(CorsHandler.create("*")
    .allowedHeaders(allowHeaders)
    .allowedMethods(allowMethods));
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
@Override
public void start() throws Exception {
	Router router = Router.router(vertx);
	
	//Config CORS
	router.route().handler(CorsHandler.create("*")
            .allowedMethod(HttpMethod.GET)
            .allowedHeader("Content-Type"));
	
	// hello endpoint
	router.get("/api/hello/:name").handler(ctx -> {
		ctx.response().end(hello(ctx.request().getParam("name")));
	});
	vertx.createHttpServer().requestHandler(router::accept).listen(8080);
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
@Override
public void mount(final Router router) {
    // 1. Cookie, Body
    router.route()
            .order(Orders.COOKIE)
            .handler(CookieHandler.create());
    router.route()
            .order(Orders.BODY)
            .handler(BodyHandler.create());
    // 2. Cors Template Solution
    router.route()
            .order(Orders.CORS)
            .handler(CorsHandler.create("*")
                    .allowCredentials(false)
                    .allowedHeaders(new HashSet<String>() {
                        {
                            add(HttpHeaders.AUTHORIZATION);
                            add(HttpHeaders.CONTENT_LENGTH);
                            add(HttpHeaders.CONTENT_TYPE);
                        }
                    })
                    .allowedMethods(new HashSet<HttpMethod>() {
                        {
                            add(HttpMethod.DELETE);
                            add(HttpMethod.GET);
                            add(HttpMethod.POST);
                            add(HttpMethod.PUT);
                        }
                    }));

}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
/**
 * Server starting behaviour
 *
 * @param fut Future that handles the start status
 * @throws NullPointerException if fut is null
 */
@Override
public void start(Future<Void> fut) {
    Objects.requireNonNull(fut);
    Router router = Router.router(vertx);
    router.route().handler(CorsHandler.create("*")
            .allowedMethod(HttpMethod.GET)
            .allowedMethod(HttpMethod.POST)
            .allowedMethod(HttpMethod.OPTIONS)
            .allowedHeader("X-PINGARUNER")
            .allowedHeader("Content-Type")
    );

    router.route("/anomaly*").handler(BodyHandler.create()); // enable reading of request's body
    router.get("/anomaly").handler(this::getAnomalies);
    router.post("/anomaly").handler(this::getAnomalies);
    vertx
            .createHttpServer()
            .requestHandler(router::accept)
            .listen(
                    config().getInteger("http.port", 8081), // default value: 8081
                    result -> {
                        if (result.succeeded()) {
                            fut.complete();
                        } else {
                            fut.fail(result.cause());
                        }
                    }
            );
    LOGGER.info("VertxServer started");
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
private static void addCorsHandler(Router router, CorsConfig corsConfig) {
    if (corsConfig != null) {
        CorsHandler corsHandler = CorsHandler.create(corsConfig.getAllowedOriginPattern());

        if (corsConfig.getAllowedMethods() != null) {
            corsHandler.allowedMethods(corsConfig.getAllowedMethods());
        }

        if (corsConfig.getAllowCredentials() != null) {
            corsHandler.allowCredentials(corsConfig.getAllowCredentials());
        }

        if (corsConfig.getAllowedHeaders() != null) {
            corsHandler.allowedHeaders(corsConfig.getAllowedHeaders());
        }

        if (corsConfig.getExposedHeaders() != null) {
            corsHandler.exposedHeaders(corsConfig.getExposedHeaders());
        }

        if (corsConfig.getMaxAgeSeconds() != null) {
            corsHandler.maxAgeSeconds(corsConfig.getMaxAgeSeconds());
        }

        router.route().handler(corsHandler);
    }
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
private void cors(Router router) {
  router.route().handler(CorsHandler.create("*")
    .allowedMethod(HttpMethod.GET)
    .allowedMethod(HttpMethod.POST)
    .allowedHeader("Content-Type")
    .allowedHeader("Accept")
  );
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
private void cors(Router router) {
    router.route().handler(CorsHandler.create("*")
        .allowedMethod(HttpMethod.GET)
        .allowedMethod(HttpMethod.POST)
        .allowedHeader("Content-Type")
        .allowedHeader("Accept")
    );
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
private void checkContainsCors(Router router) {
  if (config().getValue("cors") instanceof JsonObject) {
    JsonObject corsConfig = config().getJsonObject("cors");
    String allowedOriginPattern = corsConfig.getString("allowedOriginPattern", "*");
    CorsHandler corsHandler = CorsHandler.create(allowedOriginPattern);
    if (config().getValue("allowedMethods") instanceof JsonArray) {
      config().getJsonArray("allowedMethods").forEach(o -> {
        if (o instanceof String) {
          String method = (String) o;
          corsHandler.allowedMethod(HttpMethod.valueOf(method.toUpperCase()));
        }
      });
    }
    if (config().getValue("allowedHeaders") instanceof JsonArray) {
      config().getJsonArray("allowedHeaders").forEach(o -> {
        if (o instanceof String) {
          String headerName = (String) o;
          corsHandler.allowedHeader(headerName);
        }
      });
    }
    if (config().getValue("allowCredentials") instanceof Boolean) {
      corsHandler.allowCredentials(config().getBoolean("allowCredentials"));
    }
    if (config().getValue("maxAgeSeconds") instanceof Integer) {
      corsHandler.maxAgeSeconds(config().getInteger("maxAgeSeconds"));
    }
  router.route().handler(corsHandler);
  }
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
@Inject
public RouterStorage(CorsHandler corsHandler, BodyHandlerImpl bodyHandler, Lazy<BootstrapInitializer> boot, Lazy<Database> db) {
	this.boot = boot;
	this.db = db;
	this.corsHandler = corsHandler;
	this.bodyHandler = bodyHandler;

	/**
	 * Initialize the router storage. This will setup the basic route handlers for /api/v1 and cookie/cors handling.
	 */
	initAPIRouter();
	RouterStorage.instances.add(this);
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
public CORSMiddleware() {
  this.corsHandler = CorsHandler.create(allowedOriginPattern())
      .allowedHeaders(allowedHeaders())
      .allowedMethods(allowedMethods())
      .allowCredentials(allowCredentials())
      .exposedHeaders(exposedHeaders());
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
private Route route(final CorsRoute corsRoute) {
  final CorsHandler corsHandler = CorsHandler.create(corsRoute.getAllowedOriginPattern());

  if (corsRoute.getAllowCredentials() != null)
    corsHandler.allowCredentials(corsRoute.getAllowCredentials());

  if (corsRoute.getAllowHeaders() != null)
    corsHandler.allowedHeaders(corsRoute.getAllowHeaders());

  if (corsRoute.getAllowMethods() != null)
    corsHandler.allowedMethods(corsRoute.getAllowMethods());

  if (corsRoute.getExposeHeaders() != null)
    corsHandler.exposedHeaders(corsRoute.getExposeHeaders());

  if (corsRoute.getFromPath() == null) {
    if (corsRoute.getFromMethod() == null) {
      return router.route().handler(corsHandler);
    } else {
      throw new IllegalArgumentException("Cannot configure CORS for a specific Method without a Path");
    }
  } else if (corsRoute.getFromMethod() == null) {
    return router.route(corsRoute.getFromPath()).handler(corsHandler);
  } else {
    return router.route(corsRoute.getFromMethod(), corsRoute.getFromPath()).handler(corsHandler);
  }
}
 

import io.vertx.ext.web.handler.CorsHandler; //导入依赖的package包/类
public void corsHandler(Router router) {
  router
      .route()
      .handler(
          CorsHandler.create("127.0.0.1")
              .allowedMethod(io.vertx.core.http.HttpMethod.GET)
              .allowedMethod(io.vertx.core.http.HttpMethod.POST)
              .allowedMethod(io.vertx.core.http.HttpMethod.OPTIONS)
              .allowedMethod(io.vertx.core.http.HttpMethod.PUT)
              .allowedMethod(io.vertx.core.http.HttpMethod.DELETE)
              .allowedHeader("Content-Type")
              .allowedHeader("X-Requested-With"));
}