import io.undertow.predicate.Predicates; //导入依赖的package包/类
public static HttpHandler createErrorContext(final String slot) throws ModuleLoadException {
    final ClassPathResourceManager cpresource = new ClassPathResourceManager(getClassLoader(Module.getCallerModuleLoader(), ERROR_MODULE, slot), "");
    final io.undertow.server.handlers.resource.ResourceHandler handler = new io.undertow.server.handlers.resource.ResourceHandler(cpresource)
            .setAllowed(not(path("META-INF")))
            .setDirectoryListingEnabled(false)
            .setCachable(Predicates.<HttpServerExchange>falsePredicate());

    //we also need to setup the default resource redirect
    return new PredicateHandler(path("/"), new RedirectHandler(ExchangeAttributes.constant(ERROR_CONTEXT + DEFAULT_RESOURCE)), handler);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
public void addTo(RoutingHandler rh, OptionMap config) {
	List<Predicate> list = new ArrayList<>();
	list.add(this.predicate);
	list.add(this.matches);
	Route route = this.route;
	if (this.type != null && this.type.isEmpty() == false) {
		list.add(MIMEPredicate.accept(type));
		route = (req, res) -> {
			Object result = this.route.handle(req, res);
			res.type(this.type);
			return result;
		};
	}
	this.accepts.stream().filter(s -> s.isEmpty() == false)
			.map(s -> MIMEPredicate.contentType(s)).forEach(list::add);
	rh.add(Predicates.and(list.toArray(new Predicate[list.size()])), route,
			this.renderer);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
@Test
public void testEspeciallyPkgsAreNotRender() throws Exception {
	this.exchange.putAttachment(Core.CONFIG, Config.defaults().getMap());
	this.exchange.putAttachment(Core.RESPONSE, new SidenResponse(
			this.exchange));

	RoutingHandler target = new RoutingHandler(Testing.empty());
	target.add(Predicates.truePredicate(),
			(q, s) -> s.cookie("hoge", "fuga"),
			new MockUp<Renderer<Object>>() {
				@Mock(invocations = 0)
				void render(Object model, HttpServerExchange sink)
						throws IOException {
				}
			}.getMockInstance());

	target.handleRequest(this.exchange);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
@Test
public void testSimpleCall() throws Exception {
	Filter filter = new MockUp<Filter>() {
		@Mock(invocations = 2)
		public void filter(Request req, Response res, FilterChain chain)
				throws Exception {
			chain.next();
		}
	}.getMockInstance();

	FiltersHandler target = new FiltersHandler(Testing.mustCall());
	target.add(new FilterDef(Predicates.truePredicate(), filter));
	target.add(new FilterDef(Predicates.falsePredicate(),
			(req, res, ch) -> {
				throw new AssertionError();
			}));
	target.add(new FilterDef(Predicates.truePredicate(), filter));

	target.handleRequest(this.exchange);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
public static List<PredicatedHandler> parse(final String contents, final ClassLoader classLoader) {
    String[] lines = contents.split("\\n");
    final List<PredicatedHandler> wrappers = new ArrayList<>();

    for (String line : lines) {
        if (line.trim().length() > 0) {
            Predicate predicate;
            HandlerWrapper handler;
            String[] parts = line.split("->");
            if (parts.length == 2) {
                predicate = PredicateParser.parse(parts[0], classLoader);
                handler = HandlerParser.parse(parts[1], classLoader);
            } else if (parts.length == 1) {
                predicate = Predicates.truePredicate();
                handler = HandlerParser.parse(parts[0], classLoader);
            } else {
                predicate = PredicateParser.parse(parts[0], classLoader);
                HandlerWrapper[] handlers = new HandlerWrapper[parts.length -1];
                for(int i = 0; i < handlers.length; ++i) {
                    handlers[i] = HandlerParser.parse(parts[i + 1], classLoader);
                }
                handler = new ChaninedHandlerWrapper(Arrays.asList(handlers));
            }
            wrappers.add(new PredicatedHandler(predicate, handler));
        }
    }
    return wrappers;
}
 

import io.undertow.predicate.Predicates; //导入依赖的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.predicate.Predicates; //导入依赖的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.predicate.Predicates; //导入依赖的package包/类
private Predicate[] getCompressionPredicates(Compression compression) {
	List<Predicate> predicates = new ArrayList<Predicate>();
	predicates.add(new MaxSizePredicate(compression.getMinResponseSize()));
	predicates.add(new CompressibleMimeTypePredicate(compression.getMimeTypes()));
	if (compression.getExcludedUserAgents() != null) {
		for (String agent : compression.getExcludedUserAgents()) {
			RequestHeaderAttribute agentHeader = new RequestHeaderAttribute(
					new HttpString(HttpHeaders.USER_AGENT));
			predicates.add(Predicates.not(Predicates.regex(agentHeader, agent)));
		}
	}
	return predicates.toArray(new Predicate[predicates.size()]);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
/**
 * Wraps the passed {@link ServletInitialHandler} with a PredicateHandler for serving static content.
 *
 * @param servletInitialHandler the ServletInitialHandler
 * @return PredicateHandler which decides whether to invoke ResourceHandler or pass on the request to
 * next handler in the chain which is ServletInitialHandler.
 * @see ServletInitialHandlerWrapper class header for detailed information.
 */
@Override
public HttpHandler wrap(HttpHandler servletInitialHandler) {
    Config cfg = Configs.DEFAULT.undertow();
    return Handlers.predicate(Predicates.and(Predicates.prefix(cfg.getString(RESOURCE_PREFIX)),
            Predicates.suffixes(cfg.getStringList(RESOURCE_EXTNS).toArray(new String[0]))),
            Handlers.resource(new ClassPathResourceManager(this.getClass().getClassLoader(),
                    cfg.getString(RESOURCE_MGR_PREFIX))),
            servletInitialHandler);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
private Predicate[] getCompressionPredicates(Compression compression) {
	List<Predicate> predicates = new ArrayList<Predicate>();
	predicates.add(Predicates.maxContentSize(compression.getMinResponseSize()));
	predicates.add(new CompressibleMimeTypePredicate(compression.getMimeTypes()));
	if (compression.getExcludedUserAgents() != null) {
		for (String agent : compression.getExcludedUserAgents()) {
			RequestHeaderAttribute agentHeader = new RequestHeaderAttribute(
					new HttpString(HttpHeaders.USER_AGENT));
			predicates.add(Predicates.not(Predicates.regex(agentHeader, agent)));
		}
	}
	return predicates.toArray(new Predicate[predicates.size()]);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
private void addCacheHandler(final DeploymentInfo servletBuilder) {
    // this handles mime types and adds a simple cache for static files
    servletBuilder.addInitialHandlerChainWrapper(new HandlerWrapper() {
        @Override
        public HttpHandler wrap(final HttpHandler handler) {
          final ResourceHandler resourceHandler = new ResourceHandler(servletBuilder.getResourceManager());
            io.undertow.util.MimeMappings.Builder mimes = MimeMappings.builder();
            List<String> suffixList = new ArrayList<String>();
            // add font mime types not included by default
            mimes.addMapping("eot", "application/vnd.ms-fontobject");
            mimes.addMapping("otf", "font/opentype");
            mimes.addMapping("ttf", "application/x-font-ttf");
            mimes.addMapping("woff", "application/x-font-woff");
            suffixList.addAll(Arrays.asList(".eot",".otf",".ttf",".woff"));
            // add the default types and any added in web.xml files
            for(MimeMapping mime : servletBuilder.getMimeMappings()) {
                log.debug("Adding mime-type: " + mime.getExtension() + " - " + mime.getMimeType());
                mimes.addMapping(mime.getExtension(), mime.getMimeType());
                suffixList.add("."+mime.getExtension());
            }
            resourceHandler.setMimeMappings(mimes.build());
            String[] suffixes = new String[suffixList.size()];
            suffixes = suffixList.toArray(suffixes);
            // simple cacheHandler, someday maybe make this configurable
            final CacheHandler cacheHandler = new CacheHandler(new DirectBufferCache(1024, 10, 10480), resourceHandler);
            final PredicateHandler predicateHandler = predicate(Predicates.suffixes(suffixes), cacheHandler, handler);
            return predicateHandler;
        }
    });
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
static ResourceHandlerDefinition createConsoleHandler(String slot, String resource) throws ModuleLoadException {
    final ClassPathResourceManager cpresource = new ClassPathResourceManager(getClassLoader(Module.getCallerModuleLoader(), ERROR_MODULE, slot), "");
    final io.undertow.server.handlers.resource.ResourceHandler handler = new io.undertow.server.handlers.resource.ResourceHandler(cpresource)
            .setAllowed(not(path("META-INF")))
            .setResourceManager(cpresource)
            .setDirectoryListingEnabled(false)
            .setCachable(Predicates.<HttpServerExchange>falsePredicate());

    //we also need to setup the default resource redirect
    PredicateHandler predicateHandler = new PredicateHandler(path("/"), new RedirectHandler(ExchangeAttributes.constant(CONTEXT + resource)), handler);
    return new ResourceHandlerDefinition(CONTEXT, resource, predicateHandler);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
@Test
public void testSimpleMatch() throws Exception {
	RoutingHandler target = new RoutingHandler(Testing.empty());
	target.add(Predicates.truePredicate(), (q, s) -> "Hello",
			new MockUp<Renderer<Object>>() {
				@Mock(invocations = 1)
				void render(Object model, HttpServerExchange sink)
						throws IOException {
					assertEquals("Hello", model);
				}
			}.getMockInstance());
	target.handleRequest(this.exchange);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
@Test
public void testReturnOptinal() throws Exception {
	RoutingHandler target = new RoutingHandler(Testing.empty());
	target.add(Predicates.truePredicate(), (q, s) -> Optional.of("Hello"),
			new MockUp<Renderer<Object>>() {
				@Mock(invocations = 1)
				void render(Object model, HttpServerExchange sink)
						throws IOException {
					assertEquals("Hello", model);
				}
			}.getMockInstance());
	target.handleRequest(this.exchange);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
@Test
public void testResponseCodeSettigIsOnce() throws Exception {
	this.exchange = new MockUp<HttpServerExchange>() {
		@Mock
		public boolean isInIoThread() {
			return false;
		}

		@Mock
		public HeaderMap getResponseHeaders() {
			return new HeaderMap();
		}

		@Mock(invocations = 1)
		public HttpServerExchange setResponseCode(final int responseCode) {
			return getMockInstance();
		}

		@Mock(invocations = 1)
		public HttpServerExchange endExchange() {
			return getMockInstance();
		}
	}.getMockInstance();

	this.exchange.putAttachment(Core.CONFIG, Config.defaults().getMap());
	this.exchange.putAttachment(Core.RESPONSE, new SidenResponse(
			this.exchange));

	RoutingHandler target = new RoutingHandler(Testing.empty());
	target.add(Predicates.truePredicate(),
			(q, s) -> s.redirect("/hoge/fuga/moge"), null);

	target.handleRequest(this.exchange);
}
 

import io.undertow.predicate.Predicates; //导入依赖的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.predicate.Predicates; //导入依赖的package包/类
public HttpContinueAcceptingHandler(HttpHandler next) {
    this(next, Predicates.truePredicate());
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
public synchronized ContentEncodingRepository addEncodingHandler(final String encoding, final ContentEncodingProvider encoder, int priority) {
    addEncodingHandler(encoding, encoder, priority, Predicates.truePredicate());
    return this;
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
MaxSizePredicate(int size) {
	this.maxContentSize = Predicates.maxContentSize(size);
}
 

import io.undertow.predicate.Predicates; //导入依赖的package包/类
@Override
public void addNotPredicate(int priority, Predicate predicate, HttpHandler truePredicate) {
  addPredicate(priority, Predicates.not(predicate), truePredicate);
}