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

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {

    // 包装请求和响应
    if (LOGGER.isDebugEnabled()) {
        request = new RequestWrapper((HttpServletRequest) request);
        response = new ResponseWrapper((HttpServletResponse) response);
    }
    try {

        chain.doFilter(request, response);

    } finally {
        if (LOGGER.isDebugEnabled()) {
            // 进行打印
            logRequest((RequestWrapper) request);
            logResponse((ResponseWrapper) response);
        }
    }
}

@Override
public void doFilter(final ServletRequest req, final ServletResponse res, final FilterChain chain)
    throws IOException, ServletException {
  final HttpServletRequest request = (HttpServletRequest) req;

  final String authHeader = request.getHeader("Authorization");
  if (authHeader == null || !authHeader.startsWith("Bearer ")) {
    ExceptionUtils.createUnauthorizedException("Missing or invalid Authorization header.", res);
    return;
  }

  try {
    final String token = authHeader.substring(7); // The part after "Bearer "
    final Claims claims =
        Jwts.parser().setSigningKey("secretkey").parseClaimsJws(token).getBody();
    request.setAttribute("claims", claims);
  } catch (final Exception e) {
    ExceptionUtils.createUnauthorizedException("Invalid token", res);
    return;
  }

  chain.doFilter(req, res);
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
    throws IOException, ServletException {

  HttpServletRequest req = (HttpServletRequest) request;
  HttpServletResponse resp = (HttpServletResponse) response;
  String servletPath = req.getServletPath() + req.getPathInfo();
  xLogger.fine("Servlet path: ", servletPath);
  if (req.getCharacterEncoding() == null) {
    request.setCharacterEncoding(Constants.UTF8);
  }

  if (!(StringUtils.isNotBlank(servletPath) && servletPath.startsWith(MEDIA_ENDPOINT_URL))) {
    resp.sendError(HttpServletResponse.SC_NOT_FOUND);
    return;
  }
  if (filterChain != null) {
    filterChain.doFilter(request, response);
  }
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
    throws ServletException, IOException {

    String requestUri = request.getRequestURI();
    String spaceId = getSpaceIdFromUri(requestUri);

    try {
        // The spaceId will be null when the requestURI does not match the expected one /api/v1/spaces/*.
        // This could happen when the filter is used for processing requests from the SLP API.
        // In such cases the filter will be skipped.
        if (spaceId != null) {
            UserInfo userInfo = SecurityContextUtil.getUserInfo();
            AuthorizationChecker.ensureUserIsAuthorized(request, clientProvider, userInfo, spaceId, null);
        }
    } catch (WebApplicationException e) {
        response.sendError(401, MessageFormat.format(Messages.NOT_AUTHORIZED_TO_PERFORM_OPERATIONS_IN_SPACE, spaceId));
        return;
    }

    filterChain.doFilter(request, response);
}

@Override
public void doFilter(ServletRequest request, ServletResponse response,
                     FilterChain chain
                     ) throws IOException, ServletException {
  HttpServletRequest httpRequest = (HttpServletRequest) request;
  // if the user is already authenticated, don't override it
  if (httpRequest.getRemoteUser() != null) {
    chain.doFilter(request, response);
  } else {
    HttpServletRequestWrapper wrapper = 
        new HttpServletRequestWrapper(httpRequest) {
      @Override
      public Principal getUserPrincipal() {
        return user;
      }
      @Override
      public String getRemoteUser() {
        return username;
      }
    };
    chain.doFilter(wrapper, response);
  }
}

@Before
public void setup() throws Exception {
    filter = new AuthorizationFilter();
    filter.authService = mock(APPAuthenticationServiceBean.class);

    VOUserDetails user = new VOUserDetails();
    user.setLocale("de");
    doReturn(user).when(filter.authService).authenticateAdministrator(
            any(PasswordAuthentication.class));

    chain = mock(FilterChain.class);
    config = mock(FilterConfig.class);
    req = mock(HttpServletRequest.class);
    resp = mock(HttpServletResponse.class);
    session = mock(HttpSession.class);

    when(req.getSession()).thenReturn(session);
    when(req.getLocale()).thenReturn(new Locale("en"));
    when(req.getServletPath()).thenReturn("/xxx");
    when(config.getInitParameter(any(String.class))).thenReturn("css");
}

@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    HttpServletResponse response = (HttpServletResponse) res;
    HttpServletRequest request = (HttpServletRequest) req;
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
    response.setHeader("Access-Control-Max-Age", "3600");
    response.setHeader("Access-Control-Allow-Headers", "x-requested-with, authorization, content-type, correlation-id");

    if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
        response.setStatus(HttpServletResponse.SC_OK);
    }
    else {
        chain.doFilter(req, res);
    }
}

public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException
{
    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) resp;
    String relativeURI = request.getRequestURI().trim();// 相对地址
    if(request.getContextPath().length() > 0)
    {
        relativeURI = relativeURI.replaceFirst(request.getContextPath(), "");
    }
    if(isIgnoreURI(relativeURI))// 是否不用判断
    {
        chain.doFilter(request, response);
        return;
    }
    // 取得当前用户账号
    String userAccount = WebFilter.getAccount(request.getSession());
    if(isAccess(request, userAccount, relativeURI))// 判断是否能访问该页面
    {
        chain.doFilter(request, response);// 有权限访问
        return;
    }
    // 没权限
    response.sendRedirect(request.getContextPath() + PAGE_NOACCESS); // 无权限访问，跳转页面
    return;
}

@Override
public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain) throws IOException {
    try {
        chain.doFilter(request, response);
    } catch (final Exception exception) {
        // Error before security/jax-rs management
        log.error("High level error", exception);

        // Catch this stack
        final HttpServletResponse response3 = (HttpServletResponse) response;
        response3.setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode());
        response3.setContentType(MediaType.APPLICATION_JSON_TYPE.toString());
        response3.setCharacterEncoding(StandardCharsets.UTF_8.name());
        response3.getOutputStream().write("{\"code\":\"internal\"}".getBytes(StandardCharsets.UTF_8));
        response3.flushBuffer();
    }

}

@Override
public void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse,
        FilterChain chain)
        throws ServletException, IOException {
    HttpServletRequest request = (HttpServletRequest)servletRequest;
    String str = request.getRequestURI().toLowerCase();
    boolean flag = true;
    int idx = 0;
    if ((idx = str.indexOf(".")) > 0){
        str = str.substring(idx);
        if (ignoreExt.contains(str.toLowerCase())){
            flag = false;
        }
    }
    if (flag){
        super.doFilterInternal(servletRequest, servletResponse, chain);
    } else {
        chain.doFilter(servletRequest, servletResponse);
    }
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
    if (!registry.isEnabled()) {
        filterChain.doFilter(request, response);
        return;
    }
    final long startTime = registry.getNanos();
    filterChain.doFilter(request, response);
    final long duration = registry.getNanos() - startTime;

    final String username = getUsername();
    registry.increment("spring.Username.Invocations", username);
    registry.add("spring.Username.Durations", username, duration);
}

@Override
protected void doFilterInternal(HttpServletRequest request,
        HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {

    String allowedRequestHeaders = request.getHeader("Access-Control-Request-Headers");
    String responseHeader = XApiConstants.XAPI_VERSION_HEADER;

    if (StringUtils.isNotBlank(allowedRequestHeaders)) {
        if (StringUtils.contains(allowedRequestHeaders, XApiConstants.XAPI_VERSION_HEADER.toLowerCase())) {
            responseHeader = responseHeader.toLowerCase();
        }
    }

    response.addHeader(responseHeader, version);
    filterChain.doFilter(request, response);
}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest hsrq = (HttpServletRequest) request;
    HttpServletResponse hsrp = (HttpServletResponse) response;
    String clientType = hsrq.getParameter("clientType");
    if ("WORD".equals(clientType)) {
        chain.doFilter(request, response);
    } else {
        SessionUser person = null;
        String reqPage = hsrq.getServletPath();
        if (!reqPage.trim().equals("/login.do") && !reqPage.trim().equals("/logout.do")
                ) {
            person = (SessionUser) hsrq.getSession().getAttribute(SysConstants.SESSION_USER_KEY);
            if (person == null) {
                hsrp.sendRedirect("login.do");
                return;
            }
        }
        chain.doFilter(request, response);
    }

}

@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1,
        FilterChain arg2) throws IOException, ServletException {

    arg0.setAttribute("siteName", Config.SITE_NAME);
    arg0.setAttribute("pageTitle", Config.TITLE_SITE);
    arg0.setAttribute("metaDescription", Config.META_DESCRIPTION);
    arg0.setAttribute("metaKeywords", Config.META_KEYWORDS);
    arg0.setAttribute("year", Config.getYear());
    arg0.setAttribute("url", Config.SITE_URL);
    arg0.setAttribute("tplUrl", Config.TPL_URL);
    arg0.setAttribute("staticUrl", Config.STATIC_URL);
    arg0.setAttribute("analyticsId", Config.ANALYTICS_ID);
    arg0.setAttribute("emailAddress", Config.CONTACT_EMAIL);

    arg2.doFilter(arg0, arg1);

}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    HttpServletResponse httpResponse = (HttpServletResponse) response;

    MDC.put("url", httpRequest.getRequestURI());
    MDC.put("referer", httpRequest.getHeader("referer"));
    MDC.put("request-id", UUID.randomUUID().toString());
    MDC.put("accept-encoding", httpRequest.getHeader("accept-encoding"));
    MDC.put("accept-language", httpRequest.getHeader("accept-language"));
    MDC.put("accept", httpRequest.getHeader("accept"));
    MDC.put("user-agent", httpRequest.getHeader("user-agent"));
    MDC.put("client-ip", httpRequest.getRemoteAddr());
    MDC.put("forwarded-for", httpRequest.getHeader("x-forwarded-for"));
    MDC.put("client", RequestHelper.getIpAdress(httpRequest));

    chain.doFilter(request, response);

    MDC.put("http-status", Integer.toString(httpResponse.getStatus()));

    LOGGER.info("outgoing response");
}

/**
 * Select and set (if specified) the character encoding to be used to
 * interpret request parameters for this request.
 *
 * @param request The servlet request we are processing
 * @param response The servlet response we are creating
 * @param chain The filter chain we are processing
 *
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet error occurs
 */
@Override
public void doFilter(ServletRequest request, ServletResponse response,
                     FilterChain chain)
    throws IOException, ServletException {

    // Conditionally select and set the character encoding to be used
    if (ignore || (request.getCharacterEncoding() == null)) {
        String characterEncoding = selectEncoding(request);
        if (characterEncoding != null) {
            request.setCharacterEncoding(characterEncoding);
        }
    }

    // Pass control on to the next filter
    chain.doFilter(request, response);
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {

    // Lazily initialize the delegate if necessary.
    Filter delegateToUse = this.delegate;
    if (delegateToUse == null) {
        synchronized (this.delegateMonitor) {
            if (this.delegate == null) {
                WebApplicationContext wac = findWebApplicationContext();
                if (wac == null) {
                    throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener registered?");
                }
                this.delegate = initDelegate(wac);
            }
            delegateToUse = this.delegate;
        }
    }

    // Let the delegate perform the actual doFilter operation.
    invokeDelegate(delegateToUse, request, response, filterChain);
}

@Override
public void doFilter(ServletRequest srequset, ServletResponse sresponse, FilterChain filterChain)
        throws IOException, ServletException {
    //new两个，一个用来遍历，一个用来换数据
    CumServlet cumRequestWrapper=new CumServlet((HttpServletRequest) srequset);
    CumServlet cumRequestWrapper2=new CumServlet((HttpServletRequest) srequset);
    Iterator<Entry<String, String[]>> iterator = cumRequestWrapper.getParams().entrySet().iterator();
    while(iterator.hasNext()){
        Entry<String, String[]> next = iterator.next();
        String key = next.getKey();
        //解码两次
        String decode = URLDecoder.decode(next.getValue()[0], "utf-8");
        String decode2 = URLDecoder.decode(decode, "utf-8");
        cumRequestWrapper2.addParameter(key, decode2);
    }
       filterChain.doFilter(cumRequestWrapper2, sresponse);  

}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
    String authToken = request.getHeader(this.tokenHeader);
    // authToken.startsWith("Bearer ")
    // String authToken = header.substring(7);
    String username = jwtTokenUtil.getUsernameFromToken(authToken);

    logger.info("checking authentication user " + username);

    if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

        UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

        if (jwtTokenUtil.validateToken(authToken, userDetails)) {
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            logger.info("authenticated user " + username + ", setting security context");
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
    }

    chain.doFilter(request, response);
}

@Override
protected void doFilterInternal(final HttpServletRequest request, HttpServletResponse response,
        FilterChain filterChain) throws ServletException, IOException {

    if (("PUT".equals(request.getMethod()) || "PATCH".equals(request.getMethod())) && isFormContentType(request)) {
        HttpInputMessage inputMessage = new ServletServerHttpRequest(request) {
            @Override
            public InputStream getBody() throws IOException {
                return request.getInputStream();
            }
        };
        MultiValueMap<String, String> formParameters = formConverter.read(null, inputMessage);
        HttpServletRequest wrapper = new HttpPutFormContentRequestWrapper(request, formParameters);
        filterChain.doFilter(wrapper, response);
    }
    else {
        filterChain.doFilter(request, response);
    }
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
    if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
        String agent = ((HttpServletRequest)request).getHeader("user-agent");
        if (agent != null && iUserAgent.matcher(agent).find())
            response = new HttpServletResponseWrapper((HttpServletResponse)response).createResponse();
    }
    chain.doFilter(request,response);
}

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

  // Setup the configuration settings of the server
  Map<String, String> conf = new HashMap<String, String>();
  conf.put(CrossOriginFilter.ALLOWED_ORIGINS, "example.com");
  FilterConfig filterConfig = new FilterConfigTest(conf);

  // Origin is not specified for same origin requests
  HttpServletRequest mockReq = mock(HttpServletRequest.class);
  when(mockReq.getHeader(CrossOriginFilter.ORIGIN)).thenReturn("example.org");

  // Objects to verify interactions based on request
  HttpServletResponse mockRes = mock(HttpServletResponse.class);
  FilterChain mockChain = mock(FilterChain.class);

  // Object under test
  CrossOriginFilter filter = new CrossOriginFilter();
  filter.init(filterConfig);
  filter.doFilter(mockReq, mockRes, mockChain);

  verifyZeroInteractions(mockRes);
  verify(mockChain).doFilter(mockReq, mockRes);
}

@Test
public void testAsyncServletRequestHasListenerAdded() throws IOException, ServletException {
    AWSXRayServletFilter servletFilter = new AWSXRayServletFilter("test");

    AsyncContext asyncContext = Mockito.mock(AsyncContext.class);

    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("test_url"));
    Mockito.when(request.getMethod()).thenReturn("TEST_METHOD");
    Mockito.when(request.isAsyncStarted()).thenReturn(true);
    Mockito.when(request.getAsyncContext()).thenReturn(asyncContext);

    HttpServletResponse response = Mockito.mock(HttpServletResponse.class);

    FilterChain chain = Mockito.mock(FilterChain.class);

    servletFilter.doFilter(request, response, chain);

    Mockito.verify(asyncContext, Mockito.times(1)).addListener(Mockito.any());
}

/**这个方法完成实际的过滤操作。当客户请求访问与过滤器关联的URL的时候，Servlet过滤器将先执行doFilter方法。FilterChain参数用于访问后续过滤器。*/
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        //忽略不过滤页面
        if(!Statics.ignore_login_page.contains(httpRequest.getServletPath())){
            long memberId = StorageUtil.init(httpRequest.getSession()).getLoginMemberId();
            if(memberId==ReturnUtil.NOT_LOGIN_CODE){
                String url = httpRequest.getScheme()+"://"+httpRequest.getServerName()+":"+httpRequest.getServerPort()+httpRequest.getContextPath();
                DataUtil.OutStreamByResponse(httpResponse, "<script type='text/javascript'>top.location.href= '"+url+Statics.Login_Page+"';</script>");
                return;
            }
        }
        chain.doFilter(request, response);
//      httpRequest.getScheme();//协议类型          http
//      httpRequest.getServerName();//域名        mycdsxlc.f3322.net
//      httpRequest.getServerPort();//端口号       8989
//      httpRequest.getContextPath();//项目名      /Report
//      httpRequest.getServletPath();//请求页面 /web/index.jsp
//      httpRequest.getQueryString();//参数       null
    }

@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
        throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) req;
    if (request.getMethod().equals(GET_METHOD)) {
        HttpServletResponse response = (HttpServletResponse) res;
        SessionScopeBean sessionScopeBean = WebUtil.getSessionScopeBean(request);
        if (sessionScopeBean == null || !sessionScopeBean.isLoggedIn()) {
            StringBuilder url = new StringBuilder(Urls.LOGIN.toString(request));
            if (!(request.getRequestURI().equals(url.toString()) || request.getRequestURI().equals(Urls.PORTAL.toString(request)))) {
                url.append("?");
                url.append(GetParamNames.AUTHENTICATION_FAILED);
                url.append("=true&");
                url.append(GetParamNames.AUTHENTICATION_FAILED_MESSAGE);
                url.append("=");
                url.append(JsUtil.encodeBase64(Messages.getMessage(MessageCodes.AUTHENTICATION_REQUIRED_ERROR_MESSAGE), true));
                WebUtil.appendRefererParameter(url, request, "&");
            }
            response.sendRedirect(url.toString());
            return;
        }
    }
    chain.doFilter(req, res);
}

@Override
protected void successfulAuthentication(HttpServletRequest request,
                                        HttpServletResponse response,
                                        FilterChain chain,
                                        Authentication authResult
) throws IOException, ServletException {

    final SecurityContext context = SecurityContextHolder.createEmptyContext();
    context.setAuthentication(authResult);
    SecurityContextHolder.setContext(context);
    chain.doFilter(request, response);
}

/**
 * Check for the broken MS WebDAV client and if detected issue a re-direct
 * that hopefully will cause the non-broken client to be used.
 */
@Override
public void doFilter(ServletRequest request, ServletResponse response,
        FilterChain chain) throws IOException, ServletException {
    if (!(request instanceof HttpServletRequest) ||
            !(response instanceof HttpServletResponse)) {
        chain.doFilter(request, response);
        return;
    }
    HttpServletRequest httpRequest = ((HttpServletRequest) request);
    HttpServletResponse httpResponse = ((HttpServletResponse) response);
    String ua = httpRequest.getHeader("User-Agent");

    if (ua == null || ua.length() == 0 ||
            !ua.startsWith(UA_MINIDIR_START)) {
        // No UA or starts with non MS value
        // Hope everything just works...
        chain.doFilter(request, response);
    } else if (ua.startsWith(UA_MINIDIR_5_1_2600)) {
        // XP 32-bit SP3 - needs redirect with explicit port
        httpResponse.sendRedirect(buildRedirect(httpRequest));
    } else if (ua.startsWith(UA_MINIDIR_5_2_3790)) {
        // XP 64-bit SP2
        if (!"".equals(httpRequest.getContextPath())) {
            log(request,
                    "XP-x64-SP2 clients only work with the root context");
        }
        // Namespace issue maybe
        // see http://greenbytes.de/tech/webdav/webdav-redirector-list.html
        log(request, "XP-x64-SP2 is known not to work with WebDAV Servlet");

        chain.doFilter(request, response);
    } else {
        // Don't know which MS client it is - try the redirect with an
        // explicit port in the hope that it moves the client to a different
        // WebDAV implementation that works
        httpResponse.sendRedirect(buildRedirect(httpRequest));
    }        
}

public void doFilter(ServletRequest request, ServletResponse response,
        FilterChain chain) throws IOException, ServletException {
    ProxyFilterChain proxyFilterChain = new ProxyFilterChain();

    for (Filter filter : filters) {
        proxyFilterChain.setInvokeNextFilter(false);
        filter.doFilter(request, response, proxyFilterChain);

        if (!proxyFilterChain.isInvokeNextFilter()) {
            return;
        }
    }

    chain.doFilter(request, response);
}

@Override
public void doFilter(ServletRequest request, ServletResponse response,
        FilterChain chain) throws IOException, ServletException {

    if (request instanceof HttpServletRequest
            && response instanceof HttpServletResponse) {
        MethodType mType = MethodType.MODIFYING_METHOD;
        String method = ((HttpServletRequest) request).getMethod();
        if (method != null
                && NON_MODIFYING_METHODS_PATTERN.matcher(method).matches()) {
            mType = MethodType.NON_MODIFYING_METHOD;
        }

        RestCsrfPreventionStrategy strategy;
        switch (mType) {
        case NON_MODIFYING_METHOD:
            strategy = new FetchRequest();
            break;
        default:
            strategy = new StateChangingRequest();
            break;
        }

        if (!strategy.apply((HttpServletRequest) request,
                (HttpServletResponse) response)) {
            return;
        }
    }
    chain.doFilter(request, response);
}

/**
 * Wrap the incoming <code>request</code> in a {@link XForwardedRequest} if
 * the http header <code>x-forwarded-for</code> is not empty.
 */
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
    if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
        doFilter((HttpServletRequest) request, (HttpServletResponse) response, chain);
    } else {
        chain.doFilter(request, response);
    }
}