import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
public static void start(String[] args) throws ServletException {
    Map<String, String> commands = Arrays.stream(args)
            .map(cmd -> cmd.split(REGEX_EQ))
            .collect(toMap(cmdArray -> cmdArray[IDX_ZERO], cmdArray -> cmdArray[IDX_ONE]));
    Config undertowConf = Configs.DEFAULT.undertow();
    Config httpConf = undertowConf.getConfig(KEY_HTTP);
    Logger logger = LoggerFactory.getLogger(Server.class);
    logger.debug("Commands to AdeptJ Runtime: {}", commands);
    int httpPort = handlePortAvailability(httpConf, logger);
    logger.info("Starting AdeptJ Runtime @port: [{}]", httpPort);
    printBanner(logger);
    DeploymentManager manager = Servlets.defaultContainer().addDeployment(deploymentInfo(undertowConf));
    manager.deploy();
    Builder builder = Undertow.builder();
    optimizeWorkerOptions(builder, undertowConf, logger);
    ServerOptions.build(builder, undertowConf);
    builder.addHttpListener(httpPort, httpConf.getString(KEY_HOST));
    enableHttp2(undertowConf, builder, logger);
    enableAJP(undertowConf, builder, logger);
    GracefulShutdownHandler rootHandler = rootHandler(headersHandler(manager.start(), undertowConf), undertowConf);
    Undertow server = builder.setHandler(rootHandler).build();
    server.start();
    Runtime.getRuntime().addShutdownHook(new ShutdownHook(server, manager, rootHandler));
    launchBrowser(commands, httpPort, logger);
    if (!Environment.isServerConfFileExists()) {
        createServerConfFile(logger);
    }
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
protected void startImpl() {
    try {
        fathomDeploymentManager = createFathomDeploymentManager();
        HttpHandler fathomHandler = fathomDeploymentManager.start();

        String contextPath = settings.getContextPath();

        // create a handler than redirects non-context requests to the context
        PathHandler contextHandler = Handlers.path(Handlers.redirect(contextPath));

        // add the handler with the context prefix
        contextHandler.addPrefixPath(contextPath, fathomHandler);

        GracefulShutdownHandler rootHandler = new GracefulShutdownHandler(contextHandler);
        server = createServer(rootHandler);

        String version = server.getClass().getPackage().getImplementationVersion();
        log.info("Starting Undertow {}", version);

        server.start();
    } catch (Exception e) {
        throw new FathomException(e);
    }
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
@Override
public void start(ServerConfig serverConfig) throws Exception {
    shutdownHandler = new GracefulShutdownHandler(createHandler(dispatcher, serverConfig.contextPath()));
    
    final Builder builder = Undertow.builder()
        .setHandler(shutdownHandler)
        .addHttpListener(serverConfig.port(), serverConfig.host())
        
        // from undertow-edge benchmark
        .setServerOption(UndertowOptions.ALWAYS_SET_KEEP_ALIVE, false) //don't send a keep-alive header for HTTP/1.1 requests, as it is not required
        ;
    
    configureServerPerformance(builder, serverConfig);
    
    server = builder.build();
    server.start();
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
public HttpProtocolReceiver(final UPID localAddress,
                            final Class<?> messageBaseClass,
                            final ManagedEventBus eventBus)
{
    this.localAddress = localAddress;
    this.messageBaseClass = messageBaseClass;
    this.eventBus = eventBus;

    final PathHandler pathHandler = new PathHandler();
    pathHandler.addPrefixPath(localAddress.getId(), new CanonicalPathHandler(new BlockingHandler(this)));

    this.shutdownHandler = new GracefulShutdownHandler(pathHandler);

    this.httpServer = Undertow.builder()
        .setIoThreads(2)
        .setWorkerThreads(16)
        .addHttpListener(localAddress.getPort(), localAddress.getHost())
        .setHandler(shutdownHandler)
        .build();
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
@Override
public void start() {
    try {
        pippoDeploymentManager = createPippoDeploymentManager();
        HttpHandler pippoHandler = pippoDeploymentManager.start();

        HttpHandler contextHandler = createContextHandler(pippoHandler);
        GracefulShutdownHandler rootHandler = new GracefulShutdownHandler(contextHandler);
        server = createServer(rootHandler);

        String version = server.getClass().getPackage().getImplementationVersion();
        log.info("Starting Undertow Server {} on port {}", version, getSettings().getPort());

        server.start();
    } catch (Exception e) {
        throw new PippoRuntimeException(e);
    }
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
/**
 * Create And initialize undertow and handlers stack
 * @param appHandler application handler to use for this server
 * @return
 */
protected Undertow createServer(HttpHandler appHandler) {
	// Fifth Handler Session
	HttpHandler sessionHandler = sessionHandler(appHandler);
	// Fourth Handler crossOrigin
	HttpHandler crossOriginHandler = allowCrossOriginHandler(sessionHandler);
	// Third Handler exception
	HttpHandler exceptionHandler = exceptionHandler(crossOriginHandler);
	// Second Handler log
	HttpHandler logHandler = log(exceptionHandler);
	// First Handler GracefulShutdown
	GracefulShutdownHandler gracefulShutdownHandler = Handlers.gracefulShutdown(logHandler);

	Undertow.Builder builder = Undertow.builder();
	final int port = getPort();
	final String host = getHost();
	builder.addHttpListener(port, host);
	builder.setHandler(gracefulShutdownHandler);

	info("Listens on '" + host + ":" + port + "'");

	return builder.build();
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
/**
 * buildGracefulShutdownHandler
 *
 * @param paths
 * @return
 */
private static GracefulShutdownHandler buildGracefulShutdownHandler(PathHandler paths) {
    return new GracefulShutdownHandler(
            new RequestLimitingHandler(new RequestLimit(configuration.getRequestLimit()),
                    new AllowedMethodsHandler(
                            new BlockingHandler(
                                    new GzipEncodingHandler(
                                            new ErrorHandler(
                                                    new HttpContinueAcceptingHandler(paths)
                                            ), configuration.isForceGzipEncoding()
                                    )
                            ), // allowed methods
                            HttpString.tryFromString(RequestContext.METHOD.GET.name()),
                            HttpString.tryFromString(RequestContext.METHOD.POST.name()),
                            HttpString.tryFromString(RequestContext.METHOD.PUT.name()),
                            HttpString.tryFromString(RequestContext.METHOD.DELETE.name()),
                            HttpString.tryFromString(RequestContext.METHOD.PATCH.name()),
                            HttpString.tryFromString(RequestContext.METHOD.OPTIONS.name())
                    )
            )
    );
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
@Inject
public UndertowServer(final org.jooby.spi.HttpHandler dispatcher, final Config conf,
    final Provider<SSLContext> sslContext) throws Exception {

  awaitShutdown = conf.getDuration("undertow.awaitShutdown", TimeUnit.MILLISECONDS);
  boolean http2 = conf.getBoolean("server.http2.enabled");
  shutdown = new GracefulShutdownHandler(doHandler(dispatcher, conf));
  Undertow.Builder ubuilder = configure(conf, io.undertow.Undertow.builder())
      .addHttpListener(conf.getInt("application.port"),
          host(conf.getString("application.host")));

  ubuilder.setServerOption(UndertowOptions.ENABLE_HTTP2, http2);

  boolean securePort = conf.hasPath("application.securePort");

  if (securePort) {
    ubuilder.addHttpsListener(conf.getInt("application.securePort"),
        host(conf.getString("application.host")), sslContext.get());
  }

  this.server = ubuilder.setHandler(shutdown)
      .build();
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
ShutdownHook(Undertow server, DeploymentManager manager, GracefulShutdownHandler shutdownHandler) {
    super(Constants.SHUTDOWN_HOOK_THREAD_NAME);
    this.server = server;
    this.manager = manager;
    this.shutdownHandler = shutdownHandler;
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
private static GracefulShutdownHandler rootHandler(HttpHandler headersHandler, Config cfg) {
    return Handlers.gracefulShutdown(
            new RequestLimitingHandler(Integer.getInteger(SYS_PROP_MAX_CONCUR_REQ, cfg.getInt(KEY_MAX_CONCURRENT_REQS)),
                    new AllowedMethodsHandler(predicateHandler(headersHandler), allowedMethods(cfg))));
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
/**
    * Creates and starts the server to serve the contents of OUTPUT_DIRECTORY on port
9090.
    */
   protected void startPreview() {
       ResourceHandler resourceHandler = resource(new PathResourceManager(Paths.get(OUTPUT_DIRECTORY), 100, true, true))
               .setDirectoryListingEnabled(false);
       FileErrorPageHandler errorHandler = new FileErrorPageHandler(Paths.get(OUTPUT_DIRECTORY).resolve("404.html"), StatusCodes.NOT_FOUND);
       errorHandler.setNext(resourceHandler);
       GracefulShutdownHandler shutdown = Handlers.gracefulShutdown(errorHandler);
       Undertow server = Undertow.builder().addHttpListener(port, "localhost")
               .setHandler(shutdown)
               .build();
       server.start();
   }
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
protected HttpHandler makeSharedHandlers(App root, OptionMap config,
		HttpHandler next) {
	HttpHandler hh = next;
	if (config.get(Config.METHOD_OVERRIDE)) {
		hh = new MethodOverrideHandler(hh);
	}
	hh = makeSessionHandler(root, config, hh);
	hh = makeFormHandler(root, config, hh);

	if (Config.isInDev(config)) {
		hh = Handlers.disableCache(hh);
	} else {
		GracefulShutdownHandler gsh = Handlers.gracefulShutdown(hh);
		root.stopOn(app -> {
			gsh.shutdown();
			try {
				gsh.awaitShutdown(config.get(
						Config.WAIT_FOR_GRACEFUL_SHUTDOWN, 500));
			} catch (InterruptedException e) {
				// ignore
			}
		});
		hh = gsh;
	}

	hh = new SecurityHandler(hh);
	return new Core(config, hh);
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
void addHandler(GracefulShutdownHandler handler)
{
    this.handlers.add(handler);
}
 

import io.undertow.server.handlers.GracefulShutdownHandler; //导入依赖的package包/类
/**
 * Returns a new handler that can be used to wait for all requests to finish before shutting down the server gracefully.
 *
 * @param next The next http handler
 * @return The graceful shutdown handler
 */
public static GracefulShutdownHandler gracefulShutdown(HttpHandler next) {
    return new GracefulShutdownHandler(next);
}