javax.servlet.HttpMethodConstraintElement#io.undertow.servlet.api.DeploymentInfo源码实例Demo

@Override
protected void before() throws Throwable {
    // Used by Jersey Client to store cookies
    CookieHandler.setDefault(new CookieManager());

    // we don't need a resteasy client, and the jersey one works better with redirect
    client = new JerseyClientBuilder().build();

    // TODO use an autogenerated port...
    System.setProperty("org.jboss.resteasy.port", "24257");
    server = new UndertowJaxrsServer().start();

    ResteasyDeployment deployment = new ResteasyDeployment();
    deployment.setInjectorFactoryClass(CdiInjectorFactory.class.getName());
    deployment.setApplication(new MyApp());
    DeploymentInfo di = server.undertowDeployment(deployment)
            .setContextPath("/")
            .setDeploymentName("DI")
            .setClassLoader(getClass().getClassLoader())
            .addListeners(Servlets.listener(Listener.class));
    server.deploy(di);
}
 

protected int initServer() throws Exception {
  DeploymentInfo servletBuilder = Servlets.deployment()
    .setClassLoader(getClass().getClassLoader())
    .setContextPath("/")
    .setDeploymentName("test.war");

  init(servletBuilder);

  DeploymentManager manager = Servlets.defaultContainer().addDeployment(servletBuilder);
  manager.deploy();
  server = Undertow.builder()
    .addHttpListener(0, "127.0.0.1")
    .setHandler(manager.start()).build();
  server.start();
  return ((InetSocketAddress) server.getListenerInfo().get(0).getAddress()).getPort();
}
 

private void validateEndpointContextPath(URI httpURI) {
    String undertowEndpointPath = getContextPath(httpURI);
    Set<Deployment> deployments = defaultHost.getDeployments();
    for (Deployment deployment : deployments) {
        DeploymentInfo depInfo = deployment.getDeploymentInfo();
        String contextPath = depInfo.getContextPath();
        if (contextPath.equals(undertowEndpointPath)) {
            final HttpHandler handler = deployment.getHandler();
            if (handler instanceof CamelEndpointDeployerHandler && ((CamelEndpointDeployerHandler)handler).getRoutingHandler() instanceof DelegatingRoutingHandler) {
                final ModuleClassLoader oldCl = ((DelegatingRoutingHandler)((CamelEndpointDeployerHandler)handler).getRoutingHandler()).classLoader;
                final ModuleClassLoader tccl = checkTccl();
                if (tccl != oldCl) {
                    // Avoid allowing handlers from distinct apps to handle the same path
                    throw new IllegalStateException("Cannot add "+ HttpHandler.class.getName() +" for path " + contextPath + " defined in " + tccl.getName() + " because that path is already served by "+ oldCl.getName());
                }
            } else {
                // Another application already serves this path
                throw new IllegalStateException("Cannot overwrite context path " + contextPath + " owned by " + depInfo.getDeploymentName());
            }
        }
    }
}
 

public SimpleServletServer() {
    DeploymentInfo deploymentInfo = deployment()
            .setClassLoader(SimpleServletServer.class.getClassLoader())
            .setContextPath("/helloworld")
            .setDeploymentName("helloworld.war")
            .addServlets(
                    Servlets.servlet("MyServlet", MyServlet.class)
                        .addInitParam("message", "Hello World")
                        .addMapping("/MyServlet"),
                    Servlets.servlet("MyAnotherServlet", MyAnotherServlet.class)
                        .addMapping("/MyAnotherServlet")
            );

    DeploymentManager manager = defaultContainer().addDeployment(deploymentInfo);
    manager.deploy ();
    try {
        server = Undertow.builder()
                .addListener(8080, "localhost")
                .setHandler(manager.start())
                .build();
    } catch (ServletException ex) {
        Logger.getLogger(SimpleServletServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

private void initializeErrorPages(final DeploymentImpl deployment, final DeploymentInfo deploymentInfo) {
    final Map<Integer, String> codes = new HashMap<>();
    final Map<Class<? extends Throwable>, String> exceptions = new HashMap<>();
    String defaultErrorPage = null;
    for (final ErrorPage page : deploymentInfo.getErrorPages()) {
        if (page.getExceptionType() != null) {
            exceptions.put(page.getExceptionType(), page.getLocation());
        } else if (page.getErrorCode() != null) {
            codes.put(page.getErrorCode(), page.getLocation());
        } else {
            if (defaultErrorPage != null) {
                throw UndertowServletMessages.MESSAGES.moreThanOneDefaultErrorPage(defaultErrorPage, page.getLocation());
            } else {
                defaultErrorPage = page.getLocation();
            }
        }
    }
    deployment.setErrorPages(new ErrorPages(codes, exceptions, defaultErrorPage));
}
 

@Test
public void testServletLifecycle() throws Exception {


    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    FilterInfo f = new FilterInfo("filter", LifecycleFilter.class);

    DeploymentInfo builder = new DeploymentInfo()
            .setClassLoader(EagerServletLifecycleTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setDeploymentName("servletContext.war")
            .setEagerFilterInit(true)
            .addFilter(f)
            .addFilterUrlMapping("filter", "/aa", DispatcherType.REQUEST);

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(root);

    Assert.assertTrue(LifecycleFilter.initCalled);
}
 

/**
 * Sets up a simple servlet deployment with the provided servlets.
 *
 * This is just a convenience method for simple deployments
 *
 * @param servlets The servlets to add
 */
public static Deployment setupServlet(final ServletExtension servletExtension, final ServletInfo... servlets) {

    final PathHandler pathHandler = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();
    DeploymentInfo builder = new DeploymentInfo()
            .setClassLoader(SimpleServletTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setDeploymentName("servletContext.war")
            .addServlets(servlets);
    if(servletExtension != null) {
        builder.addServletExtension(servletExtension);
    }
    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    try {
        pathHandler.addPrefixPath(builder.getContextPath(), manager.start());
    } catch (ServletException e) {
        throw new RuntimeException(e);
    }
    DefaultServer.setRootHandler(pathHandler);

    return manager.getDeployment();

}
 

@BeforeClass
public static void setup() throws ServletException {

    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    DeploymentInfo builder = new DeploymentInfo()
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setClassLoader(GetResourceTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setDeploymentName("servletContext.war")
            .setResourceManager(new TestResourceLoader(GetResourceTestCase.class));

    builder.addServlet(new ServletInfo("ReadFileServlet", ReadFileServlet.class)
            .addMapping("/file"));

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(root);
}
 

@BeforeClass
public static void setup() throws ServletException {

    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    ServletInfo a = new ServletInfo("asyncServlet", AsyncServlet.class)
            .setAsyncSupported(true)
            .addMapping("/async");

    DeploymentInfo builder = new DeploymentInfo()
            .setClassLoader(NestedListenerInvocationTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setDeploymentName("servletContext.war")
            .addServlets(a)
            .addListener(new ListenerInfo(SimpleRequestListener.class));

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(root);
}
 

@Test
void customize() throws IOException {
	UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();

	this.jsfUndertowFactoryCustomizer.customize(factory);

	UndertowDeploymentInfoCustomizer undertowDeploymentInfoCustomizer
		= factory.getDeploymentInfoCustomizers().iterator().next();

	DeploymentInfo deploymentInfo = new DeploymentInfo();
	deploymentInfo.setClassLoader(this.getClass().getClassLoader());

	undertowDeploymentInfoCustomizer.customize(deploymentInfo);

	assertThat(deploymentInfo.getResourceManager().getResource("testUndertow.txt"))
		.isNotNull();
}
 

@BeforeClass
public static void setup() throws ServletException {

    final PathHandler path = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    DeploymentInfo builder = new DeploymentInfo()
            .setClassLoader(SimpleServletTestCase.class.getClassLoader())
            .setContextPath("/listener")
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setDeploymentName("listener.war")
            .addListener(new ListenerInfo(FirstListener.class))
            .addListener(new ListenerInfo(SecondListener.class))
            .addServlet(new ServletInfo("message", EmptyServlet.class)
                    .addMapping("/*"));

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    path.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(path);
}
 

public AnnotatedWebSocketServer() throws IOException {
    final Xnio xnio = Xnio.getInstance("nio", Undertow.class.getClassLoader());
    final XnioWorker xnioWorker = xnio.createWorker(OptionMap.builder().getMap());

    WebSocketDeploymentInfo websocket = new WebSocketDeploymentInfo()
            .addEndpoint(MyAnnotatedEndpoint.class)
            .setWorker(xnioWorker);

    DeploymentInfo deploymentInfo = deployment()
            .setClassLoader(MyAnnotatedEndpoint.class.getClassLoader())
            .setContextPath("/myapp")
            .setDeploymentName("websockets")
            .addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, websocket);

    manager = defaultContainer().addDeployment(deploymentInfo);
    manager.deploy();
}
 

public ProgrammaticWebSocketServer() throws IOException {
    final Xnio xnio = Xnio.getInstance("nio", Undertow.class.getClassLoader());
    final XnioWorker xnioWorker = xnio.createWorker(OptionMap.builder().getMap());

    WebSocketDeploymentInfo websocket = new WebSocketDeploymentInfo()
            .addEndpoint(MyAnnotatedEndpoint.class)
            .setWorker(xnioWorker);

    DeploymentInfo deploymentInfo = deployment()
            .setClassLoader(MyAnnotatedEndpoint.class.getClassLoader())
            .setContextPath("/myapp")
            .setDeploymentName("websockets")
            .addServletContextAttribute(WebSocketDeploymentInfo.ATTRIBUTE_NAME, websocket);

    manager = defaultContainer().addDeployment(deploymentInfo);
    manager.deploy();
}
 

@BeforeClass
public static void setup() throws ServletException {
    DeploymentUtils.setupServlet(new ServletExtension() {
                                     @Override
                                     public void handleDeployment(DeploymentInfo deploymentInfo, ServletContext servletContext) {
                                         deploymentInfo.addOuterHandlerChainWrapper(new HandlerWrapper() {
                                             @Override
                                             public HttpHandler wrap(HttpHandler handler) {

                                                 byte[] data = "RewriteRule /foo1 /bar1".getBytes(StandardCharsets.UTF_8);
                                                 RewriteConfig config = RewriteConfigFactory.build(new ByteArrayInputStream(data));

                                                 return new RewriteHandler(config, handler);
                                             }
                                         });
                                     }
                                 },
            new ServletInfo("servlet", PathTestServlet.class)
                    .addMapping("/"));
}
 

@BeforeClass
public static void setup() throws ServletException {
    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    DeploymentInfo builder = new DeploymentInfo()
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setClassLoader(ResponseWriterTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setDeploymentName("servletContext.war")
            .addServlet(Servlets.servlet("resp", ResponseWriterServlet.class)
                    .addMapping("/resp"))
            .addServlet(Servlets.servlet("respLArget", LargeResponseWriterServlet.class)
                    .addMapping("/large"));

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());
    DefaultServer.setRootHandler(root);
}
 

public void addTokenStoreUpdaters(DeploymentInfo deploymentInfo) {
    deploymentInfo.addSessionListener(new IdMapperUpdaterSessionListener(idMapper));    // This takes care of HTTP sessions manipulated locally
    SessionIdMapperUpdater updater = SessionIdMapperUpdater.EXTERNAL;

    try {
        Map<String, String> initParameters = deploymentInfo.getInitParameters();
        String idMapperSessionUpdaterClasses = initParameters == null
          ? null
          : initParameters.get("keycloak.sessionIdMapperUpdater.classes");
        if (idMapperSessionUpdaterClasses == null) {
            return;
        }

        for (String clazz : idMapperSessionUpdaterClasses.split("\\s*,\\s*")) {
            if (! clazz.isEmpty()) {
                updater = invokeAddTokenStoreUpdaterMethod(clazz, deploymentInfo, updater);
            }
        }
    } finally {
        setIdMapperUpdater(updater);
    }
}
 

@BeforeClass
public static void setup() throws ServletException {

    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    DeploymentInfo builder = new DeploymentInfo()
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setClassLoader(ServletPathMappingTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setDeploymentName("servletContext.war")
            .setResourceManager(new TestResourceLoader(ServletAndResourceWelcomeFileTestCase.class))
            .addWelcomePages("doesnotexist.html", "index.html", "default");

    builder.addServlet(new ServletInfo("DefaultTestServlet", PathTestServlet.class)
            .addMapping("*.html"));

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(root);
}
 

@Override
public void customize(DeploymentInfo deploymentInfo) {
    deploymentInfo.addInitialHandlerChainWrapper(handler -> {
            return Handlers.path()
                .addPrefixPath("/", handler)
                .addPrefixPath(path, new WebSocketProtocolHandshakeHandler(new WSHandler()) {
                    @Override
                    @SuppressWarnings("PMD.SignatureDeclareThrowsException")
                    public void handleRequest(HttpServerExchange exchange) throws Exception {
                        if (reservationCheck(exchange)) {
                            super.handleRequest(exchange);
                        }
                    }
                });
        }
    );
}
 

@BeforeClass
public static void setup() throws ServletException {

    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    ServletInfo s = new ServletInfo("servlet", ParameterEchoServlet.class)
            .addMapping("/aaa");

    DeploymentInfo builder = new DeploymentInfo()
            .setClassLoader(ParameterEchoTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setDeploymentName("servletContext.war")
            .addServlet(s);

    DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(root);
}
 

@BeforeClass
public static void setup() throws ServletException {
    DeploymentUtils.setupServlet(new ServletExtension() {
        @Override
        public void handleDeployment(DeploymentInfo deploymentInfo, ServletContext servletContext) {
            deploymentInfo.setIgnoreFlush(false);
        }
    },
            new ServletInfo(BLOCKING_SERVLET, BlockingOutputStreamServlet.class)
                    .addMapping("/" + BLOCKING_SERVLET),
            new ServletInfo(ASYNC_SERVLET, AsyncOutputStreamServlet.class)
                    .addMapping("/" + ASYNC_SERVLET)
                    .setAsyncSupported(true),
            new ServletInfo(CONTENT_LENGTH_SERVLET, ContentLengthCloseFlushServlet.class)
                    .addMapping("/" + CONTENT_LENGTH_SERVLET),
            new ServletInfo(RESET, ResetBufferServlet.class).addMapping("/" + RESET));
}
 

public RuntimeValue<ServletInfo> registerServlet(RuntimeValue<DeploymentInfo> deploymentInfo,
        String name,
        Class<?> servletClass,
        boolean asyncSupported,
        int loadOnStartup,
        BeanContainer beanContainer,
        InstanceFactory<? extends Servlet> instanceFactory) throws Exception {

    InstanceFactory<? extends Servlet> factory = instanceFactory != null ? instanceFactory
            : new QuarkusInstanceFactory(beanContainer.instanceFactory(servletClass));
    ServletInfo servletInfo = new ServletInfo(name, (Class<? extends Servlet>) servletClass,
            factory);
    deploymentInfo.getValue().addServlet(servletInfo);
    servletInfo.setAsyncSupported(asyncSupported);
    if (loadOnStartup > 0) {
        servletInfo.setLoadOnStartup(loadOnStartup);
    }
    return new RuntimeValue<>(servletInfo);
}
 

@Override
public void handleDeployment(DeploymentInfo deploymentInfo, ServletContext servletContext) {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    try (InputStream handlers = classLoader.getResourceAsStream(META_INF_UNDERTOW_HANDLERS_CONF)) {
        if (handlers != null) {
            // From Stuart Douglas: Ideally these would be parsed at deployment time and passed into a recorder,
            // however they are likely not bytecode serialisable. Even though this approach
            // does not 100% align with the Quarkus ethos I think it is ok in this case as
            // the gains would be marginal compared to the cost of attempting to make
            // every predicate bytecode serialisable.
            List<PredicatedHandler> handlerList = PredicatedHandlersParser.parse(handlers, classLoader);
            if (!handlerList.isEmpty()) {
                deploymentInfo.addOuterHandlerChainWrapper(new RewriteCorrectingHandlerWrappers.PostWrapper());
                deploymentInfo.addOuterHandlerChainWrapper(new HandlerWrapper() {
                    @Override
                    public HttpHandler wrap(HttpHandler handler) {
                        return Handlers.predicates(handlerList, handler);
                    }
                });
                deploymentInfo.addOuterHandlerChainWrapper(new RewriteCorrectingHandlerWrappers.PreWrapper());
            }
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

private static void deployMetricsServlet(KeycloakServer keycloakServer) {

        DeploymentInfo di = Servlets.deployment()
                .setClassLoader(KeycloakServer.class.getClassLoader())
                .setContextPath("/")
                .setDeploymentName("Metrics")
                .addServlets(Servlets.servlet("smallrye-metrics-servlet", MetricsServlet.class)
                        .addMapping("/metrics"));

        keycloakServer.getServer().deploy(di);
    }
 

@Override
public void handleDeployment(DeploymentInfo deploymentInfo, ServletContext servletContext) {

    long timeThreshold = DEFAULT_THRESHOLD_VALUE;

    String thresholdValue;

    thresholdValue = System.getProperty(THRESHOLD_PROPERTY_KEY);

    if ( thresholdValue == null){
        thresholdValue = System.getenv(THRESHOLD_ENV_VAR);
    }

    if ( thresholdValue != null && !thresholdValue.isEmpty()) {
        try {
            timeThreshold = Long.parseLong(thresholdValue);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    final long cTimeThreshold = timeThreshold;

    deploymentInfo.addInitialHandlerChainWrapper(containerHandler -> {
        requestTimeLogger = new RequestTimeLogger(containerHandler, cTimeThreshold);
        return requestTimeLogger;
    });
}
 

public static void main(final String[] args) throws Exception {

        assertJavaVersion8();

        DeploymentInfo servletBuilder = deployment()
                .setClassLoader(HelloWorldServlet.class.getClassLoader())
                .setContextPath(MYAPP)
                .setDeploymentName("hello-world.war")
                .addServlets(
                        servlet("HelloWorldServlet", HelloWorldServlet.class)
                                .addInitParam("message", "Hello World")
                                .addMapping("/api/hello-world"));

        DeploymentManager manager = defaultContainer().addDeployment(servletBuilder);
        manager.deploy();

        HttpHandler servletHandler = manager.start();
        PathHandler path = Handlers.path(Handlers.redirect(MYAPP))
                .addPrefixPath(MYAPP, servletHandler);

        String bindAddress = System.getProperty("bind.address", "localhost");
        SSLContext sslContext = createSSLContext(loadKeyStore("server.keystore"), loadKeyStore("server.truststore"));
        Undertow server = Undertow.builder()
                .setServerOption(UndertowOptions.ENABLE_HTTP2, true)
                .addHttpsListener(8443, bindAddress, sslContext)
                .setHandler(path)
                .build();

        server.start();
    }
 

@Override
public DeploymentManager addDeployment(final DeploymentInfo deployment) {
    final DeploymentInfo dep = deployment.clone();
    DeploymentManager deploymentManager = new DeploymentManagerImpl(dep, this);
    deployments.put(dep.getDeploymentName(), deploymentManager);
    deploymentsByPath.put(dep.getContextPath(), deploymentManager);
    return deploymentManager;
}
 

@Test
public void testExtensionMatchServletWithGlobalFilter() throws IOException, ServletException {

    DeploymentInfo builder = new DeploymentInfo();

    final PathHandler root = new PathHandler();
    final ServletContainer container = ServletContainer.Factory.newInstance();

    builder.addServlet(new ServletInfo("*.jsp", PathMappingServlet.class)
            .addMapping("*.jsp"));

    builder.addFilter(new FilterInfo("/*", PathFilter.class));
    builder.addFilterUrlMapping("/*", "/*", DispatcherType.REQUEST);

    builder.setClassIntrospecter(TestClassIntrospector.INSTANCE)
            .setClassLoader(FilterPathMappingTestCase.class.getClassLoader())
            .setContextPath("/servletContext")
            .setDeploymentName("servletContext.war");

    final DeploymentManager manager = container.addDeployment(builder);
    manager.deploy();
    root.addPrefixPath(builder.getContextPath(), manager.start());

    DefaultServer.setRootHandler(root);


    TestHttpClient client = new TestHttpClient();
    try {
        runTest(client, "aa.jsp", "*.jsp - /aa.jsp - null", "/*");

    } finally {
        client.getConnectionManager().shutdown();
    }
}
 

private HTTPContext createHttpContextForDeploymentInfo(DeploymentInfo deploymentInfo) {
    HTTPContext httpContext = new HTTPContext(configuration.getBindAddress(), configuration.getBindHttpPort());
    final Map<String, ServletInfo> servlets = deploymentInfo.getServlets();
    final Collection<ServletInfo> servletsInfo = servlets.values();
    for (ServletInfo servletInfo : servletsInfo) {
        httpContext.add(new Servlet(servletInfo.getName(), deploymentInfo.getContextPath()));
    }
    return httpContext;
}
 

@Override
public Collection<String> getServletNameMappings() {
    DeploymentInfo deploymentInfo = deployment.getDeploymentInfo();
    final List<String> ret = new ArrayList<>();
    for(final FilterMappingInfo mapping : deploymentInfo.getFilterMappings()) {
        if(mapping.getMappingType() == FilterMappingInfo.MappingType.SERVLET) {
            if(mapping.getFilterName().equals(filterInfo.getName())) {
                ret.add(mapping.getMapping());
            }
        }
    }
    return ret;
}
 

public static void main(String[] args) throws Exception {
    DeploymentInfo servletBuilder = Servlets.deployment()
            .setContextPath("/")
            .setClassLoader(Main.class.getClassLoader())
            .setDeploymentName("zooadmin.war")
            ;
    Integer port= PropUtil.getInt("port");
    String host=PropUtil.getString("host");
    String resource=PropUtil.getString("resource");
    FilterInfo jfinalFilter=new FilterInfo("jfinal",JFinalFilter.class);
    jfinalFilter.addInitParam("configClass","com.baicai.core.Config");
    servletBuilder.addFilter(jfinalFilter);
    servletBuilder.addFilterUrlMapping("jfinal","/*", DispatcherType.REQUEST);
    servletBuilder.addFilterUrlMapping("jfinal","/*", DispatcherType.FORWARD);
    servletBuilder.setResourceManager(new FileResourceManager(new File(resource), 1024));


    DeploymentManager manager = Servlets.defaultContainer().addDeployment(servletBuilder);
    manager.deploy();
    PathHandler path = Handlers.path(Handlers.redirect("/"))
           .addPrefixPath("/", manager.start());
    Undertow server = Undertow.builder()
            .addHttpListener(port, host)
            .setHandler(path)
            .build();
    // start server
    server.start();
    log.info("http://"+host+":"+port);
}