java类javax.servlet.DispatcherType的实例源码

private void addApplication(final ServletContextHandler context, final MinijaxApplication application)
        throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

    // (0) Sort the resource methods by literal length
    application.sortResourceMethods();

    // (1) Add Minijax filter (must come before websocket!)
    context.addFilter(new FilterHolder(new MinijaxFilter(application)), "/*", EnumSet.of(DispatcherType.REQUEST));

    // (2) WebSocket endpoints
    if (OptionalClasses.WEB_SOCKET_UTILS != null) {
        OptionalClasses.WEB_SOCKET_UTILS
                .getMethod("init", ServletContextHandler.class, MinijaxApplication.class)
                .invoke(null, context, application);
    }

    // (3) Dynamic JAX-RS content
    final MinijaxServlet servlet = new MinijaxServlet(application);
    final ServletHolder servletHolder = new ServletHolder(servlet);
    servletHolder.getRegistration().setMultipartConfig(new MultipartConfigElement(""));
    context.addServlet(servletHolder, "/*");
}

@Override
protected void putHeaders(HttpServletResponse response, HttpContent content, long contentLength) {
    super.putHeaders(response, content, contentLength);
    HttpFields fields = ((Response) response).getHttpFields();
    if (requestHolder.get().getDispatcherType() == DispatcherType.ERROR) {
        /*
         * Do not cache error page and also makes sure that error page is not eligible for 
         * modification check. That is, error page will be always retrieved.
         */
           fields.put(HttpHeader.CACHE_CONTROL, "must-revalidate,no-cache,no-store");
    } else if (requestHolder.get().getRequestURI().equals("/favicon.ico")) {
        /*
         * Make sure favicon request is cached. Otherwise, it will be requested for every 
         * page request.
         */
        fields.put(HttpHeader.CACHE_CONTROL, "max-age=86400,public");
    }
}

@Override
public void run(@Nonnull final GraphiakConfiguration configuration,
        @Nonnull final Environment environment) throws Exception {

    // Enable CORS
    final FilterRegistration.Dynamic cors = environment.servlets()
            .addFilter("cors", CrossOriginFilter.class);
    cors.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true,
            "/*");

    // get Riak client
    final RiakClient client = configuration.getRiak().build();

    final MetricStore store = new MetricStore(client);
    environment.lifecycle().manage(new MetricStoreManager(store));

    // Configure the Netty TCP server
    configuration.getNetty().build(environment, store);

    // Resources
    environment.jersey().register(new DashboardResource());
    environment.jersey().register(new MetricsResource(store));
    environment.jersey().register(new EventsResource());
    environment.jersey().register(new PingResource());
    environment.jersey().register(new VersionResource());
}

/**
 * Set the request that we are wrapping.
 *
 * @param request
 *            The new wrapped request
 */
void setRequest(HttpServletRequest request) {

    super.setRequest(request);

    // Initialize the attributes for this request
    dispatcherType = (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);
    requestDispatcherPath = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);

    // Initialize the path elements for this request
    contextPath = request.getContextPath();
    pathInfo = request.getPathInfo();
    queryString = request.getQueryString();
    requestURI = request.getRequestURI();
    servletPath = request.getServletPath();

}

public String[] getDispatcherNames() {
    ArrayList<String> result = new ArrayList<String>();
    if ((dispatcherMapping & FORWARD) > 0) {
        result.add(DispatcherType.FORWARD.name());
    }
    if ((dispatcherMapping & INCLUDE) > 0) {
        result.add(DispatcherType.INCLUDE.name());
    }
    if ((dispatcherMapping & REQUEST) > 0) {
        result.add(DispatcherType.REQUEST.name());
    }
    if ((dispatcherMapping & ERROR) > 0) {
        result.add(DispatcherType.ERROR.name());
    }
    if ((dispatcherMapping & ASYNC) > 0) {
        result.add(DispatcherType.ASYNC.name());
    }
    return result.toArray(new String[result.size()]);
}

@Bean(name = "VIFilterRegistrationBeanNew")
public org.springframework.boot.web.servlet.FilterRegistrationBean factory() {

    if(environment != null) {
        String port = environment.getProperty("server.port");
        if(port !=null) {
            System.setProperty(SysKeys.SPRINGBOOTPORTKEY, port);
        }
    }
    org.springframework.boot.web.servlet.FilterRegistrationBean filter =
            new org.springframework.boot.web.servlet.FilterRegistrationBean();
    filter.setFilter(new VIFilter());
    filter.setName("vi-filter");
    filter.addUrlPatterns(URLPATTERNS);
    filter.setDispatcherTypes(DispatcherType.REQUEST, DispatcherType.FORWARD);
    filter.setAsyncSupported(true);
    filter.setOrder(Ordered.HIGHEST_PRECEDENCE);
    return filter;
}

@Bean(name = "VIFilterRegistrationBeanOld")
public org.springframework.boot.context.embedded.FilterRegistrationBean factory() {

    if(environment != null) {
        String port = environment.getProperty("server.port");
        if(port !=null) {
            System.setProperty(SysKeys.SPRINGBOOTPORTKEY, port);
        }
    }
    org.springframework.boot.context.embedded.FilterRegistrationBean filter =
            new org.springframework.boot.context.embedded.FilterRegistrationBean();
        filter.setFilter(new VIFilter());
        filter.setName("vi-filter");
        filter.addUrlPatterns(URLPATTERNS);
        filter.setDispatcherTypes(DispatcherType.REQUEST, DispatcherType.FORWARD);
        filter.setAsyncSupported(true);
        filter.setOrder(Ordered.HIGHEST_PRECEDENCE);
    return filter;
}

/**
 *
 * This method will be used to set the current state of the FilterMap
 * representing the state of when filters should be applied.
 */
public void setDispatcher(String dispatcherString) {
    String dispatcher = dispatcherString.toUpperCase(Locale.ENGLISH);

    if (dispatcher.equals(DispatcherType.FORWARD.name())) {
        // apply FORWARD to the global dispatcherMapping.
        dispatcherMapping |= FORWARD;
    } else if (dispatcher.equals(DispatcherType.INCLUDE.name())) {
        // apply INCLUDE to the global dispatcherMapping.
        dispatcherMapping |= INCLUDE;
    } else if (dispatcher.equals(DispatcherType.REQUEST.name())) {
        // apply REQUEST to the global dispatcherMapping.
        dispatcherMapping |= REQUEST;
    }  else if (dispatcher.equals(DispatcherType.ERROR.name())) {
        // apply ERROR to the global dispatcherMapping.
        dispatcherMapping |= ERROR;
    }  else if (dispatcher.equals(DispatcherType.ASYNC.name())) {
        // apply ERROR to the global dispatcherMapping.
        dispatcherMapping |= ASYNC;
    }
}

public String[] getDispatcherNames() {
    ArrayList<String> result = new ArrayList<String>();
    if ((dispatcherMapping & FORWARD) > 0) {
        result.add(DispatcherType.FORWARD.name());
    }
    if ((dispatcherMapping & INCLUDE) > 0) {
        result.add(DispatcherType.INCLUDE.name());
    }
    if ((dispatcherMapping & REQUEST) > 0) {
        result.add(DispatcherType.REQUEST.name());
    }
    if ((dispatcherMapping & ERROR) > 0) {
        result.add(DispatcherType.ERROR.name());
    }
    if ((dispatcherMapping & ASYNC) > 0) {
        result.add(DispatcherType.ASYNC.name());
    }
    return result.toArray(new String[result.size()]);
}

/**
 * Override the <code>setAttribute()</code> method of the wrapped request.
 *
 * @param name
 *            Name of the attribute to set
 * @param value
 *            Value of the attribute to set
 */
@Override
public void setAttribute(String name, Object value) {

    if (name.equals(Globals.DISPATCHER_TYPE_ATTR)) {
        dispatcherType = (DispatcherType) value;
        return;
    } else if (name.equals(Globals.DISPATCHER_REQUEST_PATH_ATTR)) {
        requestDispatcherPath = value;
        return;
    }

    if (!setSpecial(name, value)) {
        getRequest().setAttribute(name, value);
    }

}

public String[] getDispatcherNames() {
    ArrayList<String> result = new ArrayList<String>();
    if ((dispatcherMapping & FORWARD) > 0) {
        result.add(DispatcherType.FORWARD.name());
    }
    if ((dispatcherMapping & INCLUDE) > 0) {
        result.add(DispatcherType.INCLUDE.name());
    }
    if ((dispatcherMapping & REQUEST) > 0) {
        result.add(DispatcherType.REQUEST.name());
    }
    if ((dispatcherMapping & ERROR) > 0) {
        result.add(DispatcherType.ERROR.name());
    }
    if ((dispatcherMapping & ASYNC) > 0) {
        result.add(DispatcherType.ASYNC.name());
    }
    return result.toArray(new String[result.size()]);
}

/**
 *
 * This method will be used to set the current state of the FilterMap
 * representing the state of when filters should be applied.
 */
public void setDispatcher(String dispatcherString) {
    String dispatcher = dispatcherString.toUpperCase(Locale.ENGLISH);

    if (dispatcher.equals(DispatcherType.FORWARD.name())) {
        // apply FORWARD to the global dispatcherMapping.
        dispatcherMapping |= FORWARD;
    } else if (dispatcher.equals(DispatcherType.INCLUDE.name())) {
        // apply INCLUDE to the global dispatcherMapping.
        dispatcherMapping |= INCLUDE;
    } else if (dispatcher.equals(DispatcherType.REQUEST.name())) {
        // apply REQUEST to the global dispatcherMapping.
        dispatcherMapping |= REQUEST;
    } else if (dispatcher.equals(DispatcherType.ERROR.name())) {
        // apply ERROR to the global dispatcherMapping.
        dispatcherMapping |= ERROR;
    } else if (dispatcher.equals(DispatcherType.ASYNC.name())) {
        // apply ERROR to the global dispatcherMapping.
        dispatcherMapping |= ASYNC;
    }
}

/**
 * {@inheritDoc}
 */
public void flush() throws IOException {
    //according to the servlet spec we ignore a flush from within an include
    if (servletRequestContext.getOriginalRequest().getDispatcherType() == DispatcherType.INCLUDE ||
            servletRequestContext.getOriginalResponse().isTreatAsCommitted()) {
        return;
    }
    if (servletRequestContext.getDeployment().getDeploymentInfo().isIgnoreFlush() &&
            servletRequestContext.getExchange().isRequestComplete() &&
            servletRequestContext.getOriginalResponse().getHeader(Headers.TRANSFER_ENCODING_STRING) == null) {
        //we mark the stream as flushed, but don't actually flush
        //because in most cases flush just kills performance
        //we only do this if the request is fully read, so that http tunneling scenarios still work
        servletRequestContext.getOriginalResponse().setIgnoredFlushPerformed(true);
        return;
    }
    flushInternal();
}

@Override
public void handleRequest(final HttpServerExchange exchange) throws Exception {
    final ServletRequestContext servletRequestContext = exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY);
    ServletRequest request = servletRequestContext.getServletRequest();
    if (request.getDispatcherType() == DispatcherType.REQUEST) {
        List<SingleConstraintMatch> constraints = servletRequestContext.getRequiredConstrains();
        SecurityContext sc = exchange.getSecurityContext();
        if (!authorizationManager.canAccessResource(constraints, sc.getAuthenticatedAccount(), servletRequestContext.getCurrentServlet().getManagedServlet().getServletInfo(), servletRequestContext.getOriginalRequest(), servletRequestContext.getDeployment())) {

            HttpServletResponse response = (HttpServletResponse) servletRequestContext.getServletResponse();
            response.sendError(StatusCodes.FORBIDDEN);
            return;
        }
    }
    next.handleRequest(exchange);
}

@Override
public void handleRequest(final HttpServerExchange exchange) throws Exception {
    final ServletRequestContext servletRequestContext = exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY);
    ServletRequest request = servletRequestContext.getServletRequest();
    ServletResponse response = servletRequestContext.getServletResponse();
    DispatcherType dispatcher = servletRequestContext.getDispatcherType();
    Boolean supported = asyncSupported.get(dispatcher);
    if(supported != null && ! supported) {
        exchange.putAttachment(AsyncContextImpl.ASYNC_SUPPORTED, false    );
    }

    final List<ManagedFilter> filters = this.filters.get(dispatcher);
    if(filters == null) {
        next.handleRequest(exchange);
    } else {
        final FilterChainImpl filterChain = new FilterChainImpl(exchange, filters, next, allowNonStandardWrappers);
        filterChain.doFilter(request, response);
    }
}

@Override
public MockHttpServletRequest buildRequest(ServletContext servletContext) {
    MockHttpServletRequest request = this.result.getRequest();
    request.setDispatcherType(DispatcherType.ERROR);
    request.setRequestURI(this.path);
    return request;
}

/**
 * @return CSRF protection filter bean
 */
@Bean
public FilterRegistrationBean csrfFilterRegistrationBean() {
    String path = "/*";
    logger.debug("Initializing CSRF filter [{}]...", path);
    FilterRegistrationBean frb = new FilterRegistrationBean(new CsrfFilter());
    frb.setDispatcherTypes(EnumSet.of(DispatcherType.REQUEST));
    frb.setName("csrfFilter");
    frb.setAsyncSupported(true);
    frb.addUrlPatterns(path);
    frb.setMatchAfter(false);
    frb.setEnabled(true);
    frb.setOrder(2);
    return frb;
}

@Override
public void run(final DeviceUsageTrackerConfig configuration, final Environment environment) {
    ConfigurationHolder.set(configuration);

    environment.jersey().register(DeviceResource.class);
    environment.jersey().register(UserResource.class);
    environment.jersey().register(ProfileResource.class);
    environment.jersey().register(ClaimResource.class);
    environment.jersey().register(DeviceSlackResource.class);
    environment.jersey().register(DeviceClaimResource.class);

    // JSON property naming
    environment.getObjectMapper().setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);

    environment.jersey().register(new CustomExceptionMapper());

    // Enable CORS headers
    final FilterRegistration.Dynamic cors = environment.servlets()
            .addFilter("CORS", CrossOriginFilter.class);

    // Configure CORS parameters
    cors.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM,
            "*");
    cors.setInitParameter(CrossOriginFilter.ALLOWED_HEADERS_PARAM,
            "X-Requested-With,Content-Type,Accept,Origin,Authorization");
    cors.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM,
            "OPTIONS,GET,PUT,POST,DELETE,HEAD");

    // Add URL mapping
    cors.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");

    // Auth
    environment.jersey().register(
            new AuthenticatorFeature(environment.metrics(), configuration.getAuthConfig()));
}

@Override
public void addMappingForServletNames(
        EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
        String... servletNames) {

    FilterMap filterMap = new FilterMap();

    filterMap.setFilterName(filterDef.getFilterName());

    if (dispatcherTypes != null) {
        for (DispatcherType dispatcherType : dispatcherTypes) {
            filterMap.setDispatcher(dispatcherType.name());
        }
    }

    if (servletNames != null) {
        for (String servletName : servletNames) {
            filterMap.addServletName(servletName);
        }

        if (isMatchAfter) {
            context.addFilterMap(filterMap);
        } else {
            context.addFilterMapBefore(filterMap);
        }
    }
    // else error?
}

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
    if (env.getActiveProfiles().length != 0) {
        log.info("Web application configuration, using profiles: {}", (Object[]) env.getActiveProfiles());
    }
    EnumSet<DispatcherType> disps = EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC);
    log.info("Web application fully configured");
}

/**
 * Convenience method which returns true if  the dispatcher type
 * matches the dispatcher types specified in the FilterMap
 */
private boolean matchDispatcher(FilterMap filterMap, DispatcherType type) {
    switch (type) {
        case FORWARD : {
            if ((filterMap.getDispatcherMapping() & FilterMap.FORWARD) > 0) {
                    return true;
            }
            break;
        }
        case INCLUDE : {
            if ((filterMap.getDispatcherMapping() & FilterMap.INCLUDE) > 0) {
                return true;
            }
            break;
        }
        case REQUEST : {
            if ((filterMap.getDispatcherMapping() & FilterMap.REQUEST) > 0) {
                return true;
            }
            break;
        }
        case ERROR : {
            if ((filterMap.getDispatcherMapping() & FilterMap.ERROR) > 0) {
                return true;
            }
            break;
        }
        case ASYNC : {
            if ((filterMap.getDispatcherMapping() & FilterMap.ASYNC) > 0) {
                return true;
            }
            break;
        }
    }
    return false;
}

@Override
public void addMappingForUrlPatterns(
        EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
        String... urlPatterns) {

    FilterMap filterMap = new FilterMap();

    filterMap.setFilterName(filterDef.getFilterName());

    if (dispatcherTypes != null) {
        for (DispatcherType dispatcherType : dispatcherTypes) {
            filterMap.setDispatcher(dispatcherType.name());
        }
    }

    if (urlPatterns != null) {
        for (String urlPattern : urlPatterns) {
            filterMap.addURLPattern(urlPattern);
        }

        if (isMatchAfter) {
            context.addFilterMap(filterMap);
        } else {
            context.addFilterMapBefore(filterMap);
        }
    }
    // else error?

}

@Override
public void run(final ApiConfiguration configuration, final Environment environment) throws Exception {
    environment.jersey().register(new SSEController());

    // Enable CORS headers; https://gist.github.com/yunspace/07d80a9ac32901f1e149
    final FilterRegistration.Dynamic filter = environment.servlets().addFilter("CORS", CrossOriginFilter.class);

    filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, environment.getApplicationContext().getContextPath() + "*");
    filter.setInitParameter(ALLOWED_METHODS_PARAM, "GET,PUT,POST,OPTIONS");
    filter.setInitParameter(ALLOWED_ORIGINS_PARAM, "*");
    filter.setInitParameter(ALLOWED_HEADERS_PARAM, "X-Requested-With,Content-Type,Accept,Origin,Authorization");
    filter.setInitParameter(ALLOW_CREDENTIALS_PARAM, "true");
}

/**
 * Prepare the request based on the filter configuration.
 * 
 * @param request
 *            The servlet request we are processing
 * @param response
 *            The servlet response we are creating
 * @param state
 *            The RD state
 *
 * @exception IOException
 *                if an input/output error occurs
 * @exception ServletException
 *                if a servlet error occurs
 */
private void processRequest(ServletRequest request, ServletResponse response, State state)
        throws IOException, ServletException {

    DispatcherType disInt = (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);
    if (disInt != null) {
        boolean doInvoke = true;

        if (context.getFireRequestListenersOnForwards() && !context.fireRequestInitEvent(request)) {
            doInvoke = false;
        }

        if (doInvoke) {
            if (disInt != DispatcherType.ERROR) {
                state.outerRequest.setAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR, getCombinedPath());
                state.outerRequest.setAttribute(Globals.DISPATCHER_TYPE_ATTR, DispatcherType.FORWARD);
                invoke(state.outerRequest, response, state);
            } else {
                invoke(state.outerRequest, response, state);
            }

            if (context.getFireRequestListenersOnForwards()) {
                context.fireRequestDestroyEvent(request);
            }
        }
    }
}

/**
 * onAppStart
 * 
 * @param args
 */
public void onAppStart(Object... args) {

    WebAppContext sc = getWebAppContext(args);

    if (sc == null) {
        return;
    }

    InterceptSupport iSupport = InterceptSupport.instance();
    InterceptContext context = iSupport.createInterceptContext(Event.WEBCONTAINER_STARTED);
    context.put(InterceptConstants.WEBAPPLOADER, sc.getClassLoader());
    context.put(InterceptConstants.WEBWORKDIR, sc.getServletContext().getRealPath(""));
    context.put(InterceptConstants.CONTEXTPATH, sc.getContextPath());
    context.put(InterceptConstants.APPNAME, sc.getDisplayName());

    ServletContext sContext = sc.getServletContext();

    context.put(InterceptConstants.SERVLET_CONTEXT, sContext);

    getBasePath(context, sContext);

    iSupport.doIntercept(context);

    // GlobalFilter
    sc.addFilter("com.creditease.monitor.jee.filters.GlobalFilter", "/*", EnumSet.of(DispatcherType.REQUEST));
}

@Bean
public FilterRegistrationBean shallowEtagHeaderFilter() {
    FilterRegistrationBean registration = new FilterRegistrationBean();
    registration.setFilter(new ShallowEtagHeaderFilter());
    registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
    return registration;
}

private void doDispatch(ServletRequest request, ServletResponse response)
        throws ServletException, IOException {

    // Set up to handle the specified request and response
    State state = new State(request, response, false);

    // Create a wrapped response to use for this request
    wrapResponse(state);

    ApplicationHttpRequest wrequest =
        (ApplicationHttpRequest) wrapRequest(state);

    if (queryString != null) {
        wrequest.setQueryParams(queryString);
    }

    wrequest.setAttribute(Globals.DISPATCHER_TYPE_ATTR,
            DispatcherType.ASYNC);
    wrequest.setAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR,
            getCombinedPath());

    wrequest.setContextPath(context.getPath());
    wrequest.setRequestURI(requestURI);
    wrequest.setServletPath(servletPath);
    wrequest.setPathInfo(pathInfo);
    if (queryString != null) {
        wrequest.setQueryString(queryString);
        wrequest.setQueryParams(queryString);
    }

    invoke(state.outerRequest, state.outerResponse, state);
}

public ServletContextHandler(HandlerContainer parent, String contextPath, SessionHandler sessionHandler, SecurityHandler securityHandler, ServletHandler servletHandler, ErrorHandler errorHandler,int options)
{
    super((ContextHandler.Context)null);
    _options=options;
    _scontext = new Context();
    _sessionHandler = sessionHandler;
    _securityHandler = securityHandler;
    _servletHandler = servletHandler;

    if (contextPath!=null)
        setContextPath(contextPath);

    if (parent instanceof HandlerWrapper)
        ((HandlerWrapper)parent).setHandler(this);
    else if (parent instanceof HandlerCollection)
        ((HandlerCollection)parent).addHandler(this);


    // Link the handlers
    relinkHandlers();

    if (errorHandler!=null)
        setErrorHandler(errorHandler);


    this.addFilter(new FilterHolder(new HTTPAuthFilter()), "/v2/*", EnumSet.allOf(DispatcherType.class));

}

/**
 * Convenience method which returns true if  the dispatcher type
 * matches the dispatcher types specified in the FilterMap
 */
private boolean matchDispatcher(FilterMap filterMap, DispatcherType type) {
    switch (type) {
        case FORWARD : {
            if ((filterMap.getDispatcherMapping() & FilterMap.FORWARD) > 0) {
                    return true;
            }
            break;
        }
        case INCLUDE : {
            if ((filterMap.getDispatcherMapping() & FilterMap.INCLUDE) > 0) {
                return true;
            }
            break;
        }
        case REQUEST : {
            if ((filterMap.getDispatcherMapping() & FilterMap.REQUEST) > 0) {
                return true;
            }
            break;
        }
        case ERROR : {
            if ((filterMap.getDispatcherMapping() & FilterMap.ERROR) > 0) {
                return true;
            }
            break;
        }
        case ASYNC : {
            if ((filterMap.getDispatcherMapping() & FilterMap.ASYNC) > 0) {
                return true;
            }
            break;
        }
    }
    return false;
}

@Override
public void addMappingForServletNames(
        EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
        String... servletNames) {

    FilterMap filterMap = new FilterMap();

    filterMap.setFilterName(filterDef.getFilterName());

    if (dispatcherTypes != null) {
        for (DispatcherType dispatcherType : dispatcherTypes) {
            filterMap.setDispatcher(dispatcherType.name());
        }
    }

    if (servletNames != null) {
        for (String servletName : servletNames) {
            filterMap.addServletName(servletName);
        }

        if (isMatchAfter) {
            context.addFilterMap(filterMap);
        } else {
            context.addFilterMapBefore(filterMap);
        }
    }
    // else error?
}