import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
@Override
public void postProcess(BootContext context) {
  boolean statelessAuth = statelessAuth(context);
  DeploymentInfo deploymentInfo = context.deploymentInfo();

  deploymentInfo.addAuthenticationMechanism(RestAuthenticationMechanism.MECHANISM_NAME, (name, formParserFactory,
    properties) -> new RestAuthenticationMechanism(statelessAuth, context.getService(UserRepository.class)));

  LoginConfig loginConfig = new LoginConfig(RestAuthenticationMechanism.MECHANISM_NAME, "vas-db-realm");
  deploymentInfo.setLoginConfig(loginConfig);

  deploymentInfo.setIdentityManager(context.getService(IdentityManager.class));
  deploymentInfo.addSecurityConstraint(new SecurityConstraint().addRoleAllowed(User.ROLE).addWebResourceCollection(
    new WebResourceCollection().addUrlPattern("/*")));

  logoutServlet(context, deploymentInfo);
}
 

import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
@Override
public Set<String> setServletSecurity(final ServletSecurityElement constraint) {
    if (constraint == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("constraint");
    }
    DeploymentInfo deploymentInfo = deployment.getDeploymentInfo();

    //this is not super efficient, but it does not really matter
    final Set<String> urlPatterns = new HashSet<>();
    for (SecurityConstraint sc : deploymentInfo.getSecurityConstraints()) {
        for (WebResourceCollection webResources : sc.getWebResourceCollections()) {
            urlPatterns.addAll(webResources.getUrlPatterns());
        }
    }
    final Set<String> ret = new HashSet<>();
    for (String url : servletInfo.getMappings()) {
        if (urlPatterns.contains(url)) {
            ret.add(url);
        }
    }
    ServletSecurityInfo info = new ServletSecurityInfo();
    servletInfo.setServletSecurityInfo(info);
    info.setTransportGuaranteeType(constraint.getTransportGuarantee() == CONFIDENTIAL ? TransportGuaranteeType.CONFIDENTIAL : TransportGuaranteeType.NONE)
            .setEmptyRoleSemantic(emptyRoleSemantic(constraint.getEmptyRoleSemantic()))
            .addRolesAllowed(constraint.getRolesAllowed());

    for (final HttpMethodConstraintElement methodConstraint : constraint.getHttpMethodConstraints()) {
        info.addHttpMethodSecurityInfo(new HttpMethodSecurityInfo()
                .setTransportGuaranteeType(methodConstraint.getTransportGuarantee() == CONFIDENTIAL ? TransportGuaranteeType.CONFIDENTIAL : TransportGuaranteeType.NONE)
                .setMethod(methodConstraint.getMethodName())
                .setEmptyRoleSemantic(emptyRoleSemantic(methodConstraint.getEmptyRoleSemantic()))
                .addRolesAllowed(methodConstraint.getRolesAllowed()));
    }
    return ret;
}
 

import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
private static SecurityConstraint securityConstraint(Config cfg) {
    return Servlets.securityConstraint()
            .addRolesAllowed(cfg.getStringList(KEY_AUTH_ROLES))
            .addWebResourceCollection(Servlets.webResourceCollection()
                    .addHttpMethods(cfg.getStringList(KEY_SECURED_URLS_ALLOWED_METHODS))
                    .addUrlPatterns(cfg.getStringList(KEY_SECURED_URLS)));
}
 

import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
private void configureDeploymentSecurity(DeploymentInfo deploymentInfo) {
    deploymentInfo.setIdentityManager(identityManager);
    deploymentInfo.setLoginConfig(new LoginConfig(HttpServletRequest.BASIC_AUTH, "lightblueRealm"));
    deploymentInfo.addSecurityConstraint(new SecurityConstraint()
            .addWebResourceCollection(new WebResourceCollection().addUrlPattern("/*"))
            .addRoleAllowed(SECURITY_ROLE_AUTHENTICATED));
    deploymentInfo.addSecurityRole(SECURITY_ROLE_AUTHENTICATED);
}
 

import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
public void addConstraints(DeploymentInfo servletBuilder, ServerOptions serverOptions) {
    servletBuilder.addSecurityConstraint(new SecurityConstraint()
            .addWebResourceCollection(new WebResourceCollection()
                    .addUrlPattern("*"))
            .addRoleAllowed("role1")
            .setEmptyRoleSemantic(SecurityInfo.EmptyRoleSemantic.DENY));
}
 

import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
public static SecurityConstraint securityConstraint() {
    return new SecurityConstraint();
}
 

import io.undertow.servlet.api.SecurityConstraint; //导入依赖的package包/类
public void addServant(URL nurl, UndertowHTTPHandler handler) {

        ServletInfo servletInfo = Servlets.servlet("DefaultServlet", DefaultServlet.class).addMapping("/*");

        DeploymentInfo servletBuilder = Servlets.deployment()
            .setClassLoader(WildflyHTTPServerEngine.class.getClassLoader())
            .setContextPath(nurl.getPath())
            .setDeploymentName("cxfdestination.war")
            .addServlets(servletInfo);

        if (nurl.getProtocol().equals("https")) {
            SecurityConstraint securityConstraint = new SecurityConstraint();
            WebResourceCollection webResourceCollection = new WebResourceCollection();
            webResourceCollection.addUrlPattern("/*");

            securityConstraint.addWebResourceCollection(webResourceCollection);
            securityConstraint.setTransportGuaranteeType(TransportGuaranteeType.CONFIDENTIAL);
            securityConstraint.setEmptyRoleSemantic(SecurityInfo.EmptyRoleSemantic.PERMIT);

            servletBuilder.addSecurityConstraint(securityConstraint);
            servletBuilder.setConfidentialPortManager(exchange -> {
                int port = exchange.getConnection().getLocalAddress(InetSocketAddress.class).getPort();
                return defaultHost.getServer().getValue().lookupSecurePort(port);
            });
        }

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

        try {
            HttpHandler servletHandler = manager.start();
            defaultHost.registerDeployment(manager.getDeployment(), servletHandler);

            UndertowHTTPDestination destination = handler.getHTTPDestination();
            destination.setServletContext(manager.getDeployment().getServletContext());

            ManagedServlet managedServlet = manager.getDeployment().getServlets().getManagedServlet("DefaultServlet");
            DefaultServlet servletInstance = (DefaultServlet) managedServlet.getServlet().getInstance();
            servletInstance.setHTTPDestination(destination);
        } catch (ServletException ex) {
            throw new IllegalStateException(ex);
        }
    }