How to use

setStatus

method

in

javax.servlet.http.HttpServletResponse

  protected void renderMergedOutputModel(Map model, HttpServletRequest request,
                      HttpServletResponse response) throws Exception {
    response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
    response.getWriter().close();
  }
});

  public ModelAndView respond(HttpServletResponse response) throws Exception {
    response.setStatus(status);
    response.setContentType(contentType);
    response.setHeader("Content-Disposition", "Inline; filename=" + jobName + "Properties.csv");
    response.getWriter().write(message);
    return null;
  }
}

  public ModelAndView respond(HttpServletResponse response) throws Exception {
    response.setStatus(status);
    response.setContentType(contentType);
    response.getWriter().write(message);
    return null;
  }
}

private void render404(HttpServletResponse response) throws IOException {
  response.setStatus(404);
  response.setCharacterEncoding("utf-8");
  response.setContentType("text/plain");
  response.getOutputStream().println("The url you are trying to reach appears to be incorrect.");
}

while (en.hasMoreElements()) {
  String name = en.nextElement().toString();
  String value = req.getParameter(name);
  attributes.put(name, value);
  resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
  return;
  resp.sendError(HttpServletResponse.SC_NOT_FOUND);
  bytes = ("File not found: " + file).getBytes(StandardCharsets.UTF_8);
} else {
    bytes = page.getBytes(StandardCharsets.UTF_8);
  resp.setContentType(mimeType);
  if (!cache) {
    resp.setHeader("Cache-Control", "no-cache");
  } else {
    resp.setHeader("Cache-Control", "max-age=10");
    resp.setHeader("Last-Modified", server.getStartDateTime());
  ServletOutputStream out = resp.getOutputStream();
  out.write(bytes);

  public static void writeErrMsg(HttpServletResponse response, int httpCode,
                  String msg) {
    response.setStatus(httpCode);
    try {
      response.getWriter().println(msg);
    } catch (IOException e) {
      defaultLog.error("ResponseUtil:writeErrMsg wrong", e);
    }
  }
}

 @Override
 public void handle(String pathInContext, org.eclipse.jetty.server.Request request, HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws IOException,
     ServletException {
  String authorization = httpRequest.getHeader("Authorization");
  if (authorization == null) {
   httpResponse.setStatus(401);
   httpResponse.setHeader("WWW-Authenticate", "NTLM");
  } else if (authorization.equals("NTLM TlRMTVNTUAABAAAAAYIIogAAAAAoAAAAAAAAACgAAAAFASgKAAAADw==")) {
   httpResponse.setStatus(401);
   httpResponse.setHeader("WWW-Authenticate", "NTLM TlRMTVNTUAACAAAAAAAAACgAAAABggAAU3J2Tm9uY2UAAAAAAAAAAA==");
  } else if (authorization
      .equals("NTLM TlRMTVNTUAADAAAAGAAYAEgAAAAYABgAYAAAABQAFAB4AAAADAAMAIwAAAASABIAmAAAAAAAAACqAAAAAYIAAgUBKAoAAAAPrYfKbe/jRoW5xDxHeoxC1gBmfWiS5+iX4OAN4xBKG/IFPwfH3agtPEia6YnhsADTVQBSAFMAQQAtAE0ASQBOAE8AUgBaAGEAcABoAG8AZABMAEkARwBIAFQAQwBJAFQAWQA=")) {
   httpResponse.setStatus(200);
  } else {
   httpResponse.setStatus(401);
  }
  httpResponse.setContentLength(0);
  httpResponse.getOutputStream().flush();
  httpResponse.getOutputStream().close();
 }
}

   response.setContentType("application/javascript; charset=utf8");
   writer.write(jsonpcb + "(");
  } else {
   response.setContentType("application/json; charset=utf8");
  String tmpStr = request.getParameter(INCLUDE_DESCRIPTION);
  boolean description = tmpStr != null && tmpStr.length() > 0;
  String getmethod = request.getParameter("get");
  if (getmethod != null) {
   String[] splitStrings = getmethod.split("\\:\\:");
    beanWriter.write("message", "query format is not as expected.");
    beanWriter.flush();
    response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
    return;
     splitStrings[1], description) != 0) {
    beanWriter.flush();
    response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
   response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} catch (MalformedObjectNameException e) {
 LOG.error("Caught an exception while processing JMX request", e);
 response.sendError(HttpServletResponse.SC_BAD_REQUEST);

public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
 String maxRequests = req.getParameter("maxRequests");
 int max;
 try {
  max = 3;
  res.setHeader("Success-On-Attempt", "" + requestNo);
  res.setHeader("id", id);
  if (servlet != null && servlet.trim().length() > 0)
   res.setHeader("type", "servlet");
  if (error != null && error.trim().length() > 0)
   res.setHeader("type", "500");
  if (io != null && io.trim().length() > 0)
   res.setHeader("type", "io");
  res.setStatus(200);
  res.setContentLength(0);
  res.flushBuffer();
 res.setStatus(200);
 res.setContentLength(100);
 res.setContentType("application/octet-stream");
 res.flushBuffer();
  res.sendError(500, "servlet process was 500");

private void needAuthenticate(final HttpServletResponse response) {
  response.setStatus(401);
  response.setHeader("Cache-Control", "no-store");
  response.setDateHeader("Expires", 0);
  response.setHeader("WWW-authenticate", AUTH_PREFIX + "Realm=\"Elastic Job Console Auth\"");
}

 private void handleBadRequest(HttpServletResponse response, String errorMessage) throws IOException
 {
  if (!response.isCommitted()) {
   response.resetBuffer();
   response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
   jsonMapper.writeValue(response.getOutputStream(), ImmutableMap.of("error", errorMessage));
  }
  response.flushBuffer();
 }
}

public void setResponse(final HttpServletResponse response, final String mime) {
  long access_time = this.getAccessTime();
  response.setDateHeader("Last-Modified", access_time);
  response.setDateHeader("Expires", access_time + 2 * DAO.getConfig("DoS.servicereduction", 1000));
  response.setContentType(mime);
  response.setHeader("X-Robots-Tag",  "noindex,noarchive,nofollow,nosnippet");
  response.setCharacterEncoding("UTF-8");
  response.setStatus(HttpServletResponse.SC_OK);
}
public int hashCode() {

/**
 * Set the response status according to the {@link ResponseStatus} annotation.
 */
private void setResponseStatus(ServletWebRequest webRequest) throws IOException {
  HttpStatus status = getResponseStatus();
  if (status == null) {
    return;
  }
  HttpServletResponse response = webRequest.getResponse();
  if (response != null) {
    String reason = getResponseStatusReason();
    if (StringUtils.hasText(reason)) {
      response.sendError(status.value(), reason);
    }
    else {
      response.setStatus(status.value());
    }
  }
  // To be picked up by RedirectView
  webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status);
}

private void responseResult(HttpServletResponse response, Result result) {
  response.setCharacterEncoding("UTF-8");
  response.setHeader("Content-type", "application/json;charset=UTF-8");
  response.setStatus(200);
  try {
    response.getWriter().write(JSON.toJSONString(result));
  } catch (IOException ex) {
    logger.error(ex.getMessage());
  }
}

 public void handle(String s, Request r, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
  if ("POST".equalsIgnoreCase(request.getMethod())) {
   byte[] bytes = new byte[3];
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   int read = 0;
   while (read > -1) {
    read = request.getInputStream().read(bytes);
    if (read > 0) {
     bos.write(bytes, 0, read);
    }
   }
   response.setStatus(HttpServletResponse.SC_OK);
   response.addHeader("X-Param", new String(bos.toByteArray()));
  } else { // this handler is to handle POST request
   response.sendError(HttpServletResponse.SC_FORBIDDEN);
  }
  response.getOutputStream().flush();
  response.getOutputStream().close();
 }
}

String cluster = normalize(request.getParameter(QUERY_PARAM_CLUSTER));
String user = normalize(request.getParameter(QUERY_PARAM_USER));
String statusParam = normalize(request.getParameter(QUERY_PARAM_STATUS));
Status status = getEnum(statusParam, Status.class, null);
String startRowParam = normalize(request.getParameter(QUERY_PARAM_START_KEY));
  cluster, status, user, 10, startRow);
response.setContentType(MIME_TYPE_JSON);
response.setStatus(HttpServletResponse.SC_OK);
sendJson(request, response, workflows);
response.setContentType(MIME_TYPE_JSON);
response.setStatus(HttpServletResponse.SC_OK);
sendJson(request, response, nodes.toArray(new DAGNode[nodes.size()]));
  .getEventsSinceId(request.getParameter(QUERY_PARAM_WORKFLOW_ID), lastEventId, maxEvents);
response.setContentType(MIME_TYPE_JSON);
response.setStatus(HttpServletResponse.SC_OK);
sendJson(request, response, events.toArray(new Event[events.size()]));

/**
 * Trigger a browser redirect with specific http 3XX status code.
 *
 * @param location       Where to redirect permanently
 * @param httpStatusCode the http status code
 */
public void redirect(String location, int httpStatusCode) {
  if (LOG.isDebugEnabled()) {
    LOG.debug("Redirecting ({} to {}", httpStatusCode, location);
  }
  response.setStatus(httpStatusCode);
  response.setHeader("Location", location);
  response.setHeader("Connection", "close");
  try {
    response.sendError(httpStatusCode);
  } catch (IOException e) {
    LOG.warn("Exception when trying to redirect permanently", e);
  }
}

 public static void sendJsonError(HttpServletResponse resp, int error, String errorJson, OutputStream outputStream)
 {
  resp.setStatus(error);
  resp.setContentType("application/json");
  resp.setCharacterEncoding("UTF-8");
  try {
   outputStream.write(errorJson.getBytes(StandardCharsets.UTF_8));
  }
  catch (IOException ioe) {
   log.error("WTF? Can't get writer from HTTP response.");
  }
 }
}

 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  response.setContentType("text/json;charset=utf-8");
  response.setStatus(HttpServletResponse.SC_OK);
  response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
  String result = mObjectMapper.writeValueAsString(mMetricsRegistry);
  response.getWriter().println(result);
 }
};

  private void sendMessage(HttpServletResponse response, String message, int statusCode) throws IOException {
    response.setContentType("text/plain");
    response.setCharacterEncoding("UTF-8");
    response.setStatus(statusCode);

    try (InputStream in = new ByteArrayInputStream(message.getBytes("UTF-8"))) {
      ByteStreams.copy(in, response.getOutputStream());
    } finally {
      response.getOutputStream().close();
    }
  }
}