How to use

ServletRequest

in

javax.servlet

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  throws IOException, ServletException
{
 HttpServletResponse httpResponse = (HttpServletResponse) response;
 OutputStream out = httpResponse.getOutputStream();
 // make sure the original request isn't trying to fake the auth token checks
 Boolean authInfoChecked = (Boolean) request.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED);
 Boolean allowUnsecured = (Boolean) request.getAttribute(AuthConfig.DRUID_ALLOW_UNSECURED_PATH);
 AuthenticationResult result = (AuthenticationResult) request.getAttribute(AuthConfig.DRUID_AUTHENTICATION_RESULT);
 if (authInfoChecked != null || result != null || allowUnsecured != null) {
  sendJsonError(httpResponse, HttpServletResponse.SC_FORBIDDEN, unauthorizedMessage, out);
  out.close();
  return;
 }
 chain.doFilter(request, response);
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  throws IOException, ServletException
{
 request.setAttribute(AuthConfig.DRUID_AUTHENTICATION_RESULT, ALLOW_ALL_RESULT);
 chain.doFilter(request, response);
}

/** {@inheritDoc} */
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    throws IOException, ServletException {
  final String resource = request.getParameter("resource");
  if (resource != null && customResources.get(resource) != null) {
    final String customResource = customResources.get(resource);
    final HttpServletResponse httpResponse = (HttpServletResponse) response;
    MonitoringController.addHeadersForResource(httpResponse, customResource);
    if (customResources.get("useForward") == null) {
      request.getRequestDispatcher(customResource).include(request, response);
    } else {
      request.getRequestDispatcher(customResource).forward(request, response);
    }
  } else {
    chain.doFilter(request, response);
  }
}

/**
 * Expose the specified request attribute if not already present.
 * @param request current servlet request
 * @param name the name of the attribute
 * @param value the suggested value of the attribute
 */
private static void exposeRequestAttributeIfNotPresent(ServletRequest request, String name, Object value) {
  if (request.getAttribute(name) == null) {
    request.setAttribute(name, value);
  }
}

/**
 * 解析上传文件和表单数据
 * 
 * @param request Http请求
 * @throws IOException IO异常
 */
public void parseRequest(ServletRequest request) throws IOException {
  parseRequestStream(request.getInputStream(), request.getCharacterEncoding());
}

public static String dumpRequestParams(ServletRequest request) {
  StringBuilder sb = new StringBuilder();
  Enumeration<?> en = request.getParameterNames();
  while (en.hasMoreElements()) {
    String name = (String) en.nextElement();
    sb.append("[" + name + "]: " + request.getParameter(name) + '\n');
  }
  return sb.toString();
}

String servletPath = req.getServletPath();
      chain.doFilter(request, response);
      return;
  res.sendRedirect(logoutPageUrl);
  String header = req.getHeader("content-type");
  boolean isJson=  header!=null && header.contains("json");
  if (isJson) {
    res.setContentType("application/json;charset=utf-8");
    res.getWriter().println("{\"code\":"+Conf.SSO_LOGIN_FAIL_RESULT.getCode()+", \"msg\":\""+ Conf.SSO_LOGIN_FAIL_RESULT.getMsg() +"\"}");
    return;
  } else {
    String link = req.getRequestURL().toString();
request.setAttribute(Conf.SSO_USER, xxlUser);
chain.doFilter(request, response);
return;

String servletPath = req.getServletPath();
      chain.doFilter(request, response);
      return;
  res.setStatus(HttpServletResponse.SC_OK);
  res.setContentType("application/json;charset=UTF-8");
  res.getWriter().println("{\"code\":"+ReturnT.SUCCESS_CODE+", \"msg\":\"\"}");
request.setAttribute(Conf.SSO_USER, xxlUser);
chain.doFilter(request, response);
return;

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
    ServletException {
  log.debug("Entered SsoLoginFilter");
  HttpServletRequest req = (HttpServletRequest) request;
  HttpServletResponse res = (HttpServletResponse) response;
  if (req.getSession(false) == null || req.getSession(false).getAttribute(FiltersHelper.Constants.LOGOUT_INPROGRESS) == null) {
    StringBuffer requestURL = req.getRequestURL();
    if (StringUtils.isNotEmpty(req.getQueryString())) {
      requestURL.append("?").append(req.getQueryString());
    }
    if (!FiltersHelper.isAuthenticated(req) || !FiltersHelper.isSessionValid((HttpServletRequest) request)) {
      String url = String.format("%s%s&app_url=%s&locale=%s",
          req.getServletContext().getContextPath(),
          loginUrl,
          URLEncoder.encode(requestURL.toString(), "UTF-8"),
          request.getAttribute("locale").toString());
      log.debug("Redirecting to {}", url);
      res.sendRedirect(url);
    } else {
      log.debug("Already logged in, executing next filter in chain.");
      chain.doFilter(request, response);
    }
  }
  log.debug("Exiting SsoLoginFilter");
}

  logger.debug("Filter chain '" + name + "' processing request " + request.getMethod() + " "
      + request.getRequestURI());
  chain.doFilter(request, response);
}catch (Exception x) {
  logger.error("Uncaught Exception:", x);
  if (req.getAttribute("javax.servlet.error.exception") == null) {
    req.setAttribute("javax.servlet.error.exception", x);
  response.sendError(reasonPhrase.getCode(), reasonPhrase.getPhrase());

if (request.getAttribute(CustomerStateRequestProcessor.getCustomerRequestAttributeName()) == null){
  if (request.getAttribute(CUSTOMER_ID_ATTRIBUTE) != null) {
    customerId = String.valueOf(request.getAttribute(CUSTOMER_ID_ATTRIBUTE));
    customerId = servletRequest.getParameter(CUSTOMER_ID_ATTRIBUTE);
filterChain.doFilter(request, servletResponse);

if (request.getAttribute(AuthConfig.DRUID_AUTHENTICATION_RESULT) != null) {
 filterChain.doFilter(request, response);
 return;
String path = ((HttpServletRequest) request).getRequestURI();
if (isExcluded(path)) {
 filterChain.doFilter(request, response);
} else {
 String clientPrincipal;
 try {
  Cookie[] cookies = httpReq.getCookies();
  if (cookies == null) {
   clientPrincipal = getPrincipalFromRequestNew((HttpServletRequest) request);
  request.setAttribute(
    AuthConfig.DRUID_AUTHENTICATION_RESULT,
    new AuthenticationResult(clientPrincipal, authorizerName, name, null)

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  if (listener == null) {
    listener = (WeldInitialListener) request.getServletContext().getAttribute(WeldInitialListener.class.getName());
  }
 // cross-context means request is dispatched as INCLUDE or FORWARD or ERROR
 boolean crossCtx = request.getAttribute("javax.servlet.include.request_uri") != null
    || request.getAttribute("javax.servlet.forward.request_uri") != null
    || request.getAttribute("javax.servlet.error.request_uri") != null;
 boolean activated = false;
 try {
   if (crossCtx) {
    if (request.getAttribute(REQUEST_CONTEXT_KEY) == null) {
      listener.requestInitialized(new ServletRequestEvent(config.getServletContext(), request));
      activated = true;
    }
   }
   chain.doFilter(request, response);
 } finally {
   if (activated) {
    listener.requestDestroyed(new ServletRequestEvent(config.getServletContext(), request));
   }
 }
}

public static List<GenericValue> getPartyCatalogs(ServletRequest request) {
  HttpSession session = ((HttpServletRequest) request).getSession();
  GenericValue userLogin = (GenericValue) session.getAttribute("userLogin");
  if (userLogin == null) userLogin = (GenericValue) session.getAttribute("autoUserLogin");
  if (userLogin == null) return null;
  String partyId = userLogin.getString("partyId");
  if (partyId == null) return null;
  Delegator delegator = (Delegator) request.getAttribute("delegator");
  return getPartyCatalogs(delegator, partyId);
}

HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;
boolean isHttps = "https".equals(httpRequest.getScheme());
try {
 boolean newToken = false;
      isHttps
    );
    request.setAttribute(SIGNED_TOKEN_ATTRIBUTE, tokenToCookieString(
      signedToken,
      getCookieDomain(),
   request.setAttribute(
     AuthConfig.DRUID_AUTHENTICATION_RESULT,
     new AuthenticationResult(token.getName(), authorizerName, name, null)
 if (!httpResponse.isCommitted()) {
  tokenToAuthCookie(
    httpResponse,
    && (!httpResponse.containsHeader(
    org.apache.hadoop.security.authentication.client.KerberosAuthenticator.WWW_AUTHENTICATE))) {
   errCode = HttpServletResponse.SC_FORBIDDEN;
   filterChain.doFilter(request, response);
  } else {
   httpResponse.sendError(errCode, authenticationEx.getMessage());

public void doFilter(final ServletRequest req, final ServletResponse resp, final FilterChain chain)
    throws IOException, ServletException {
  if (!Mvcs.DISABLE_X_POWERED_BY)
    ((HttpServletResponse)resp).setHeader("X-Powered-By", Mvcs.X_POWERED_BY);
  ServletContext prCtx = Mvcs.getServletContext();
  Mvcs.setServletContext(sc);
  String matchUrl = request.getServletPath() + Strings.sBlank(request.getPathInfo());
  Integer mark = (Integer) req.getAttribute(markKey);
  if (mark != null) {
    req.setAttribute(markKey, mark+1);
  } else {
    req.setAttribute(markKey, 0);
      Mvcs.set(preName, request, response);
      if (mark == 0) {
        req.removeAttribute(markKey);
      } else {
        req.setAttribute(markKey, mark - 1);

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  throws IOException, ServletException {
 request.setAttribute("http.route", ((HttpServletRequest) request).getRequestURI());
 chain.doFilter(request, response);
}

 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) 
  throws IOException, ServletException {

  HttpServletRequest request = (HttpServletRequest) req;
  HttpServletResponse response = (HttpServletResponse) res;
  HttpSession session = request.getSession();

  String email = req.getParameter("email");
  session.setAttribute("email", email);

  chain.doFilter(req, res); // continue to 'ShowOnline'

}

return getRequest().getAttribute(name);
  return null;
return session.getAttribute(name);
return getServletContext().getAttribute(name);

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  throws IOException, ServletException {
 TraceContext context = (TraceContext) request.getAttribute("brave.propagation.TraceContext");
 String extra = ExtraFieldPropagation.get(context, EXTRA_KEY);
 ((HttpServletResponse) response).setHeader(EXTRA_KEY, extra);
 chain.doFilter(request, response);
}