import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
@Override
public ServletRegistration.Dynamic addServlet(final String servletName, final Servlet servlet) {
    ensureNotProgramaticListener();
    ensureNotInitialized();
    if (deploymentInfo.getServlets().containsKey(servletName)) {
        return null;
    }
    ServletInfo s = new ServletInfo(servletName, servlet.getClass(), new ImmediateInstanceFactory<>(servlet));
    readServletAnnotations(s);
    deploymentInfo.addServlet(s);
    ServletHandler handler = deployment.getServlets().addServlet(s);
    return new ServletRegistrationImpl(s, handler.getManagedServlet(), deployment);
}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
@Override
public FilterRegistration.Dynamic addFilter(final String filterName, final Filter filter) {
    ensureNotProgramaticListener();
    ensureNotInitialized();

    if (deploymentInfo.getFilters().containsKey(filterName)) {
        return null;
    }
    FilterInfo f = new FilterInfo(filterName, filter.getClass(), new ImmediateInstanceFactory<>(filter));
    deploymentInfo.addFilter(f);
    deployment.getFilters().addFilter(f);
    return new FilterRegistrationImpl(f, deployment, this);

}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
@Override
public <T extends EventListener> void addListener(final T t) {
    ensureNotInitialized();
    ensureNotProgramaticListener();
    if (ApplicationListeners.listenerState() != NO_LISTENER &&
            ServletContextListener.class.isAssignableFrom(t.getClass())) {
        throw UndertowServletMessages.MESSAGES.cannotAddServletContextListener();
    }
    ListenerInfo listener = new ListenerInfo(t.getClass(), new ImmediateInstanceFactory<EventListener>(t));
    deploymentInfo.addListener(listener);
    deployment.getApplicationListeners().addListener(new ManagedListener(listener, true));
}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
private void registerServletContainerInitializerToDriveServletContextInitializers(
		DeploymentInfo deployment, ServletContextInitializer... initializers) {
	ServletContextInitializer[] mergedInitializers = mergeInitializers(initializers);
	Initializer initializer = new Initializer(mergedInitializers);
	deployment.addServletContainerInitalizer(new ServletContainerInitializerInfo(
			Initializer.class,
			new ImmediateInstanceFactory<ServletContainerInitializer>(initializer),
			NO_CLASSES));
}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
protected DeploymentManager createFathomDeploymentManager() throws ServletException {

        DeploymentInfo info = Servlets.deployment();
        info.setDeploymentName("Fathom");
        info.setClassLoader(this.getClass().getClassLoader());
        info.setContextPath(settings.getContextPath());
        info.setIgnoreFlush(true);
        info.setDefaultEncoding("UTF-8");

        FilterInfo guiceFilter = new FilterInfo("GuiceFilter", GuiceFilter.class);
        guiceFilter.setAsyncSupported(true);

        info.addFilterUrlMapping("GuiceFilter", "/*", DispatcherType.REQUEST);
        info.addFilters(guiceFilter);

        ServletInfo defaultServlet = new ServletInfo("DefaultServlet", DefaultServlet.class);
        defaultServlet.setAsyncSupported(true);
        defaultServlet.addMapping("/");

        ServletContextListener fathomListener = new ServletContextListener(settings);

        info.addListeners(new ListenerInfo(ServletContextListener.class, new ImmediateInstanceFactory<>(fathomListener)));

        MultipartConfigElement multipartConfig = new MultipartConfigElement(settings.getUploadFilesLocation(), settings.getUploadFilesMaxSize(), -1L, 0);
        defaultServlet.setMultipartConfig(multipartConfig);
        info.addServlets(defaultServlet);

        DeploymentManager deploymentManager = Servlets.defaultContainer().addDeployment(info);
        deploymentManager.deploy();

        return deploymentManager;
    }
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
@Override
public void postProcess(BootContext context) {
  CachePolicy cachePolicy = new CachePolicy(context.properties());
  if(!cachePolicy.enabled) {
    return;
  }

  EtagCache etagCache = context.getService(EtagCache.class);
  InstanceFactory<CacheFilter> instanceFactory = new ImmediateInstanceFactory<>(new CacheFilter(etagCache));
  FilterInfo filterInfo = Servlets.filter(FILTER_NAME, CacheFilter.class, instanceFactory);
  context.deploymentInfo().addFilter(filterInfo);
  context.deploymentInfo().addFilterUrlMapping(FILTER_NAME, StationsAroundJaxrsDescriptor.MAPPING,
    DispatcherType.REQUEST);
}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
private List<ServletContainerInitializerInfo> getServletContainerInitializers() {
    List<ServletContainerInitializerInfo> infos = new ArrayList<>();
    for (ServletContainerInitializer initializer : ServiceLoader.load(ServletContainerInitializer.class)) {
        HandlesTypes types = initializer.getClass().getAnnotation(HandlesTypes.class);
        infos.add(new ServletContainerInitializerInfo(
            initializer.getClass(),
            new ImmediateInstanceFactory<>(initializer),
            types == null ? Collections.emptySet() : new LinkedHashSet<>(Arrays.asList(types.value()))));
    }
    return infos;
}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
@Override
public void handleDeployment(DeploymentInfo deploymentInfo, ServletContext servletContext) {

    String componentName = "";
    String resourceName = "";
    Pattern insecureEndpointPattern = null;
    Pattern postQueryPattern = null;
    // file to contain configurations options for this Servlet Extension
    InputStream is = servletContext.getResourceAsStream(PROPERTY_FILE);
    if (is != null) {
        try {
            Properties props = new Properties();
            props.load(is);
            componentName = props.getProperty("component");
            resourceName = props.getProperty("resource-name");
            String insecurePatternString = props.getProperty("unsecure-endpoints");
            String postQueryPatternString = props.getProperty("post-query");

            if (insecurePatternString != null) {
                insecureEndpointPattern = Pattern.compile(insecurePatternString);
            }

            if (postQueryPatternString != null) {
                postQueryPattern = Pattern.compile(postQueryPatternString);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    if (componentName == null || componentName.isEmpty()) {
        throw new RuntimeException("Missing or empty 'component' key from the " + PROPERTY_FILE + " configuration file.");
    }

    if (resourceName == null || resourceName.isEmpty()) {
        throw new RuntimeException("Missing or empty 'resource-name' key from the " + PROPERTY_FILE + " configuratin file.");
    }

    final String cName = componentName;
    final String rName = resourceName;
    final Pattern insecurePattern = insecureEndpointPattern;
    final Pattern postQuery = postQueryPattern;

    if (DISABLE_NAMESPACE_FILTER.equalsIgnoreCase("true")) {
        log.info("The OpenShift Namespace Filter has been disabled via the 'DISABLE_NAMESPACE_FILTER' system property.");
    }
    else {
        log.info("Enabling the OpenShift Namespace Filter.");
        deploymentInfo.addInitialHandlerChainWrapper(containerHandler -> {
            namespaceHandler = new NamespaceHandler(containerHandler);
            return namespaceHandler;
        });
    }

    ImmediateInstanceFactory<EventListener> instanceFactory = new ImmediateInstanceFactory<>(new SCListener());
    deploymentInfo.addListener(new ListenerInfo(SCListener.class, instanceFactory));
    deploymentInfo.addInitialHandlerChainWrapper(containerHandler -> {
        openshiftAuthHandler = new OpenshiftAuthHandler(containerHandler, cName, rName, insecurePattern, postQuery);
        return openshiftAuthHandler;
    });

}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
private void addPippoFilter(DeploymentInfo info) {
    if (pippoFilterPath == null) {
        pippoFilterPath = "/*"; // default value
    }

    info.addFilter(new FilterInfo("PippoFilter", PippoFilter.class, new ImmediateInstanceFactory<>(getPippoFilter())));
    info.addFilterUrlMapping("PippoFilter", pippoFilterPath, DispatcherType.REQUEST);
    log.debug("Using pippo filter for path '{}'", pippoFilterPath);
}
 

import io.undertow.servlet.util.ImmediateInstanceFactory; //导入依赖的package包/类
private static ServletContainerInitializerInfo sciInfo() {
    return new ServletContainerInitializerInfo(ContainerInitializer.class,
            new ImmediateInstanceFactory<>(new ContainerInitializer()),
            Collections.singleton(FrameworkStartupHandler.class));
}