import io.undertow.server.handlers.encoding.GzipEncodingProvider; //导入依赖的package包/类
public static HttpHandler gzip(HttpHandler next) {
    return new EncodingHandler(new ContentEncodingRepository()
              .addEncodingHandler("gzip",
                  // This 1000 is a priority, not exactly sure what it does.
                  new GzipEncodingProvider(), 1000,
                  // Anything under a content-length of 20 will not be gzipped
                  Predicates.truePredicate()
                  //Predicates.maxContentSize(20) // https://issues.jboss.org/browse/UNDERTOW-1234
                  ))
              .setNext(next);
}
 

import io.undertow.server.handlers.encoding.GzipEncodingProvider; //导入依赖的package包/类
private HttpHandler configurationCompressionIfNecessary(HttpHandler httpHandler) {
	if (this.compression == null || !this.compression.getEnabled()) {
		return httpHandler;
	}
	ContentEncodingRepository repository = new ContentEncodingRepository();
	repository.addEncodingHandler("gzip", new GzipEncodingProvider(), 50,
			Predicates.and(getCompressionPredicates(this.compression)));
	return new EncodingHandler(repository).setNext(httpHandler);
}
 

import io.undertow.server.handlers.encoding.GzipEncodingProvider; //导入依赖的package包/类
private HttpHandler getHandlers(SpurOptions options) {
    // Path handler
    PathTemplateHandler pathTemplateHandler = Handlers.pathTemplate();
    endpointsMap.forEach((path, methodEndpointMap) -> pathTemplateHandler.add(path, new HttpHandler() {
        public void handleRequest(HttpServerExchange exchange) throws Exception {
            // non-blocking
            if (options.blockableHandlersEnabled && exchange.isInIoThread()) {
                // LOGGER.info("Is in IO thread, dispatching for blockableHandlersEnabled...");
                exchange.dispatch(this);
                return;
            }
            // handler code
            // LOGGER.info("STARTING Async");
            invokePathTemplateHandler(options, methodEndpointMap, exchange);
        }
    }));

    // Websocket
    if (!webSocketHandlerMap.isEmpty()) {
        webSocketHandlerMap.forEach((pathPrefix, webSocketHandler) -> {
            LOGGER.info("Adding WS for path: " + webSocketHandler.getPath());
            addWebSocketHandler(pathTemplateHandler, webSocketHandler);
        });
    }

    // SSE
    if (!sseHandlerMap.isEmpty()) {
        sseHandlerMap.forEach(pathTemplateHandler::add);
    }

    // CORS
    HttpHandler httpHandler = Handlers.predicate(exchange -> isValidCorsOrigin(options, getRequestHeader(exchange, Headers.ORIGIN)),
            new CorsHandler(pathTemplateHandler), pathTemplateHandler);

    // Gzip
    if (options.gzipEnabled) {
        httpHandler = new EncodingHandler(new ContentEncodingRepository().addEncodingHandler("gzip", new GzipEncodingProvider(), 50,
                Predicates.maxContentSize(options.gzipMaxSize))).setNext(httpHandler);
    }

    // Custom handlers
    for (RequestFilter requestFilter : requestFilters) {
        httpHandler = Handlers.predicate(requestFilter.getAssertionPredicate(), httpHandler, requestFilter.getFailureHandler());
    }

    // Graceful shutdown
    httpHandler = Handlers.gracefulShutdown(httpHandler);

    // Basic auth
    if (!options.basicAuthUser.isEmpty() && !options.basicAuthPassword.isEmpty()) {
        httpHandler = new BasicAuthHandler(httpHandler, options.basicAuthUser, options.basicAuthPassword);
    }

    // Force HTTPS
    if (options.forceHttps) {
        httpHandler = Handlers.predicate(Predicates.secure(), httpHandler, new RedirectHttpsHandler());
    }

    return httpHandler;
}
 

import io.undertow.server.handlers.encoding.GzipEncodingProvider; //导入依赖的package包/类
/**
    * Start the management interface.
    *
    */
public void start() {
	
	Builder builder = Undertow.builder();
	
	// add listener
	builder.addHttpListener(this.managementPort, this.managementInterface);
	
	// set up resource handler
	ClassPathResourceManager classPathManager = new ClassPathResourceManager(Thread.currentThread().getContextClassLoader(), "web");
	ResourceHandler resources = Handlers.resource(classPathManager);
	resources.setWelcomeFiles("index.html");
	resources.setDirectoryListingEnabled(false);
	
	// set up servlet handler
	DeploymentInfo servletBuilder = Servlets.deployment()
			.setClassLoader(Thread.currentThread().getContextClassLoader())
			.setContextPath("/services")
			.setDeploymentName("pincushion-services.war")
			;
	
	// add context parameters
	//servletBuilder.addInitParameter(ResteasyContextParameters.RESTEASY_SERVLET_MAPPING_PREFIX, "/");
	
	// add context listener for bootstrap
	ListenerInfo restBootstrapListener = Servlets.listener(ResteasyBootstrap.class, new ResteasyBootstrapInstanceFactory(this.manager));
	servletBuilder.addListener(restBootstrapListener);
	
	// create and add servlet to servlet handler
	ServletInfo restServletInfo = Servlets.servlet("restEasyHandler", HttpServletDispatcher.class);
	restServletInfo.addInitParam("javax.ws.rs.Application", ManagementApplication.class.getName());
	restServletInfo.addMapping("/*");
	restServletInfo.setLoadOnStartup(1);
	servletBuilder.addServlet(restServletInfo);
	
	// deploy servlets
	DeploymentManager deploymentManager = Servlets.defaultContainer().addDeployment(servletBuilder);
	
	deploymentManager.deploy();
	HttpHandler services = null;
	try {
		services = deploymentManager.start();
	} catch (ServletException e) {
		this.logger.error("Could not start services deployment: {}", e.getLocalizedMessage());
	}

	// create paths
	PathHandler path = Handlers.path(resources);
	if(services != null) {
		path.addPrefixPath("/services", services);
	}
	
	// create encoding repository
	ContentEncodingRepository repo = new ContentEncodingRepository();

       // permit gzip and deflate
	repo.addEncodingHandler("gzip", new GzipEncodingProvider(), 1000);
	repo.addEncodingHandler("deflate", new DeflateEncodingProvider(), 10);
	
	// ensure that everything can be encoded with appropriate compression
	EncodingHandler encoder = new EncodingHandler(path, repo);
	
	// add path handler to server
	builder.setHandler(encoder);
	
	// start undertow server
	this.server = builder.build();
	this.server.start();
	
	this.logger.info("Started undertow management interface at {} on port {}", this.managementInterface, this.managementPort);
}
 

import io.undertow.server.handlers.encoding.GzipEncodingProvider; //导入依赖的package包/类
/**
 * Creates a new instance of GzipEncodingHandler
 *
 * @param next
 * @param forceCompression if true requests without gzip encoding in
 * Accept-Encoding header will be rejected
 */
public GzipEncodingHandler(HttpHandler next, boolean forceCompression) {
    super(next, new ContentEncodingRepository().addEncodingHandler("gzip", new GzipEncodingProvider(), 50));
    this.forceCompression = forceCompression;
}