How to use

sendRedirect

method

in

javax.servlet.http.HttpServletResponse

 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  String username = request.getParameter("username");
  String password = request.getParameter("password");
  User user = userService.find(username, password);

  if (user != null) {
    request.getSession().setAttribute("user", user); // Login user.
    response.sendRedirect("home"); // Redirect to home page.
  } else {
    request.setAttribute("message", "Unknown username/password. Please retry."); // Store error message in request scope.
    request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response); // Forward to JSP page to redisplay login form with error.
  }
}

@WebServlet(name = "LogoutServlet", urlPatterns = {"/logout"})
public class LogoutServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 HttpSession session = request.getSession(false);
 // Destroys the session for this user.
 if (session != null)
   session.invalidate();
 // Redirects back to the initial page.
 response.sendRedirect(request.getContextPath());
}
}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  HttpServletRequest req = (HttpServletRequest) request;
  /* allow signup from the Jenkins home page, or /manage, which is where a /configureSecurity form redirects to */
  if(req.getRequestURI().equals(req.getContextPath()+"/") || req.getRequestURI().equals(req.getContextPath() + "/manage")) {
    if (needsToCreateFirstUser()) {
      ((HttpServletResponse)response).sendRedirect("securityRealm/firstUser");
    } else {// the first user already created. the role of this filter is over.
      PluginServletFilter.removeFilter(this);
      chain.doFilter(request,response);
    }
  } else
    chain.doFilter(request,response);
}

public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  String contextPath = request.getContextPath();
  String servletPath = request.getServletPath();
  String requestURI = request.getRequestURI();
    String usernameParam = request.getParameter(PARAM_NAME_USERNAME);
    String passwordParam = request.getParameter(PARAM_NAME_PASSWORD);
    if (username.equals(usernameParam) && password.equals(passwordParam)) {
      request.getSession().setAttribute(SESSION_USER_KEY, username);
      response.getWriter().print("success");
    } else {
    || path.startsWith("/img"))) {
    if (contextPath.equals("") || contextPath.equals("/")) {
      response.sendRedirect("/druid/login.html");
    } else {
      if ("".equals(path)) {
        response.sendRedirect("druid/login.html");
      } else {
        response.sendRedirect("login.html");
      response.sendRedirect("/druid/index.html");
    } else {
      response.sendRedirect("druid/index.html");
    response.sendRedirect("index.html");
    return;

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
 HttpServletRequest request = (HttpServletRequest) servletRequest;
 HttpServletResponse response = (HttpServletResponse) servletResponse;
 String path = extractPath(request);
 Predicate<Redirect> match = redirect -> redirect.test(path);
 List<Redirect> redirects = REDIRECTS.stream()
  .filter(match)
  .collect(MoreCollectors.toList());
 switch (redirects.size()) {
  case 0:
   chain.doFilter(request, response);
   break;
  case 1:
   response.sendRedirect(redirects.get(0).apply(request));
   break;
  default:
   throw new IllegalStateException(format("Multiple redirects have been found for '%s'", path));
 }
}

String searchStr = request.getParameter("searchStr").trim();
String authRole = (String) request.getSession().getAttribute("authRole");
      request.getSession().setAttribute("flashMsg", "Node created!");
      dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "Creating node: " + currentPath + newNode);
    response.sendRedirect("/home?zkPath=" + displayPath);
    break;
  case "Save Property":
      dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "Saving Property: " + currentPath + "," + newProperty + "=" + newValue);
    response.sendRedirect("/home?zkPath=" + displayPath);
    break;
  case "Update Property":
      dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "Updating Property: " + currentPath + "," + newProperty + "=" + newValue);
    response.sendRedirect("/home?zkPath=" + displayPath);
    break;
  case "Search":
    response.sendRedirect("/home?zkPath=" + displayPath);
    break;
  default:
    response.sendRedirect("/home");

private void handleUpload(final HttpServletRequest req, final HttpServletResponse resp,
  final Map<String, Object> multipart, final Session session) throws ServletException,
  IOException {
 final HashMap<String, String> ret = new HashMap<>();
 final String projectName = (String) multipart.get("project");
 ajaxHandleUpload(req, resp, ret, multipart, session);
 if (ret.containsKey("error")) {
  setErrorMessageInCookie(resp, ret.get("error"));
 }
 if (ret.containsKey("warn")) {
  setWarnMessageInCookie(resp, ret.get("warn"));
 }
 resp.sendRedirect(req.getRequestURI() + "?project=" + projectName);
}

 @Override
 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException {
  String peepText = req.getParameter("peep");

  try {

   PeeperServletContextListener.DATA_STORE.addPeep(peepText);
   resp.sendRedirect("peep");

  } catch (Exception e) {
   throw new ServletException("Error saving peep", e);
  }
 }
}

HttpServletResponse resp = (HttpServletResponse) servletResponse;
String urlString = req.getRequestURI() + "?" + req.getQueryString();
Map<String, Integer> limitedUrlMap = Switch.getLimitedUrlMap();
if (req.getRequestURI().contains(UtilsAndCommons.NACOS_NAMING_INSTANCE_CONTEXT) && !RaftCore.isLeader()) {
    String url = "http://" + RaftCore.getLeader().ip + req.getRequestURI() + "?" + req.getQueryString();
    try {
      resp.sendRedirect(url);
    } catch (Exception ignore) {
      Loggers.SRV_LOG.warn("[DISTRO-FILTER] request failed: " + url);
  filterChain.doFilter(req, resp);
  return;
  filterChain.doFilter(req, resp);
  return;
  filterChain.doFilter(req, resp);
  return;
        + req.getRequestURI() + "?" + req.getQueryString();
    try {
      resp.sendRedirect(url);
    } catch (Exception ignore) {
      Loggers.SRV_LOG.warn("[DISTRO-FILTER] request failed: " + url);

HttpSession session = request.getSession();
  chain.doFilter(req, res);
  return;
    session.setAttribute(LOGIN_HINT, loginHint);
  } else {
    session.removeAttribute(LOGIN_HINT);
        chain.doFilter(req, res);
      } else {
        logger.info("Client requested no prompt");
            response.sendRedirect(uriBuilder.toString());
            return;
      if (session.getAttribute(PROMPTED) == null) {
        session.setAttribute(PROMPT_REQUESTED, Boolean.TRUE);
          chain.doFilter(req, res);
        } else {
      Date authTime = (Date) session.getAttribute(AuthenticationTimeStamper.AUTH_TIMESTAMP);

HttpSession session = request.getSession();
  response.sendRedirect(issResp.getRedirectUrl());
} else {
  String issuer = issResp.getIssuer();
    session.setAttribute(TARGET_SESSION_VARIABLE, issResp.getTargetLinkUri());
  session.setAttribute(ISSUER_SESSION_VARIABLE, serverConfig.getIssuer());
  session.setAttribute(REDIRECT_URI_SESION_VARIABLE, redirectUri);
  response.sendRedirect(authRequest);

    uploadFileName = scmServer + scmFileRevision + "@" + scmFilePath;
    logger.debug("P4 file Processing " + uploadFileName);
    dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "Importing P4 File: " + uploadFileName + "<br/>" + "Overwrite: " + scmOverwrite);
    URL url = new URL(uploadFileName);
    URLConnection conn = url.openConnection();
    dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "Uploading File: " + uploadFileName + "<br/>" + "Overwrite: " + scmOverwrite);
    inpStream = new ByteArrayInputStream(sbFile.toString().getBytes());
  for (String line : importFile) {
    if (line.startsWith("-")) {
      dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "File: " + uploadFileName + ", Deleting Entry: " + line);
    } else {
      dao.insertHistory((String) request.getSession().getAttribute("authName"), request.getRemoteAddr(), "File: " + uploadFileName + ", Adding Entry: " + line);
  request.getSession().setAttribute("flashMsg", "Import Completed!");
  response.sendRedirect("/home");
} catch (FileUploadException | IOException | InterruptedException | KeeperException ex) {
  logger.error(Arrays.toString(ex.getStackTrace()));

String notification = (String) request.getAttribute(STATECHANGENOTIFICATIONTOKEN);
if (Boolean.valueOf(notification)) {
  String uri = request.getRequestURI();
  Enumeration<String> params = request.getParameterNames();
  StringBuilder sb = new StringBuilder();
      sb.append(request.getParameter(param));
    response.sendError(403);
  response.sendRedirect(encoded);
  return true;

Properties globalProps = (Properties) getServletContext().getAttribute("globalProps");
Map<String, Object> templateParam = new HashMap<>();
HttpSession session = request.getSession(true);
session.setMaxInactiveInterval(Integer.valueOf(globalProps.getProperty("sessionTimeout")));
String username = request.getParameter("username");
String password = request.getParameter("password");
String role = null;
Boolean authenticated = false;
  session.setAttribute("authName", username);
  session.setAttribute("authRole", role);
  response.sendRedirect("/home");
} else {
  session.setAttribute("flashMsg", "Invalid Login");
  ServletUtil.INSTANCE.renderHtml(request, response, templateParam, "login.ftl.html");

@Override
public void sendRedirect(HttpServletRequest request, HttpServletResponse response, String url) throws IOException {
  if (!url.startsWith("/")) {
    if (StringUtils.equals(request.getParameter("successUrl"), url) || StringUtils.equals(request.getParameter("failureUrl"), url)) {
      validateRedirectUrl(request.getContextPath(), url, request.getServerName(), request.getServerPort());
    }
  }
  String redirectUrl = calculateRedirectUrl(request.getContextPath(), url);
  redirectUrl = response.encodeRedirectURL(redirectUrl);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Redirecting to '" + url + "'");
  }
  response.sendRedirect(redirectUrl);
}

public void render(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  String contextpath = request.getContextPath();
  String params = "";
  Map queryString = (Map) model.get("params");
  if (queryString != null) {
    for (Object key : queryString.keySet()) {
      String value = (String) queryString.get(key);
      if (value != null) {
        if (params.length() > 0) {
          params += "&";
        }
        params += key + "=" + URLEncoder.encode(value, "UTF-8");
      }
    }
  }
  String paramString = params.isEmpty() ? "" : "?" + params;
  response.sendRedirect(contextpath + "/tab" + target + paramString);
}

  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    try {
      logger.debug("Logout Action!");
      Properties globalProps = (Properties) getServletContext().getAttribute("globalProps");
      String zkServer = globalProps.getProperty("zkServer");
      String[] zkServerLst = zkServer.split(",");
      ZooKeeper zk = ServletUtil.INSTANCE.getZookeeper(request, response, zkServerLst[0],globalProps);
      request.getSession().invalidate();
      zk.close();
      response.sendRedirect("/login");
    } catch (InterruptedException ex) {
      logger.error(Arrays.toString(ex.getStackTrace()));
      ServletUtil.INSTANCE.renderError(request, response, ex.getMessage());
    }

  }
}

  chain.doFilter(request, response);
  return;
    .append(":")
    .append(sslPort)
    .append(httpRequest.getContextPath())
    .append(httpRequest.getServletPath());
((HttpServletResponse) response).sendRedirect(redirectURL);

private void handleRemoveProject(final HttpServletRequest req,
  final HttpServletResponse resp, final Session session) throws ServletException,
  IOException {
 final User user = session.getUser();
 final String projectName = getParam(req, "project");
 final Project project = this.projectManager.getProject(projectName);
 if (project == null) {
  this.setErrorMessageInCookie(resp, "Project " + projectName
    + " doesn't exist.");
  resp.sendRedirect(req.getContextPath());
  return;
 }
 if (!hasPermission(project, user, Type.ADMIN)) {
  this.setErrorMessageInCookie(resp,
    "Cannot delete. User '" + user.getUserId() + "' is not an ADMIN.");
  resp.sendRedirect(req.getRequestURI() + "?project=" + projectName);
  return;
 }
 removeAssociatedSchedules(project);
 try {
  this.projectManager.removeProject(project, user);
 } catch (final ProjectManagerException e) {
  this.setErrorMessageInCookie(resp, e.getMessage());
  resp.sendRedirect(req.getRequestURI() + "?project=" + projectName);
  return;
 }
 this.setSuccessMessageInCookie(resp, "Project '" + projectName
   + "' was successfully deleted and associated schedules are removed.");
 resp.sendRedirect(req.getContextPath());
}

 httpResponse.sendRedirect(httpRequest.getHeader("X-redirect"));
 return;
while (i.hasMoreElements()) {
 headerName = i.nextElement();
 httpResponse.addHeader("X-" + headerName, httpRequest.getParameter(headerName));
 requestBody.append(headerName);
 requestBody.append("_");