How to use

sendError

method

in

javax.servlet.http.HttpServletResponse

/**
 * Sends correct headers to require basic authentication for the given realm.
 */
public static void requireAuthentication(final HttpServletResponse resp, final String realm) throws IOException {
  resp.setHeader(WWW_AUTHENTICATE, "Basic realm=\"" + realm + '\"');
  resp.sendError(HttpServletResponse.SC_UNAUTHORIZED);
}

/**
 * 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);
  }
}

@Override
protected void doGet(HttpServletRequest req,
           HttpServletResponse resp) throws ServletException, IOException {
  if (Strings.isNullOrEmpty(req.getPathInfo())) {
    try (final PrintWriter output = resp.getWriter()) {
      resp.setContentType(CONTENT_TYPE);
      getTasks().stream()
        .map(Task::getName)
        .sorted()
        .forEach(output::println);
    }
  } else if (tasks.containsKey(req.getPathInfo())) {
    resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
  } else {
    resp.sendError(HttpServletResponse.SC_NOT_FOUND);
  }
}

 @Override
 protected void doGet(final HttpServletRequest req, final HttpServletResponse resp)
   throws ServletException, IOException {
  try {
   resp.setContentType(JSON_MIME_TYPE);
   resp.getOutputStream()
     .println(new GsonBuilder()
       .setPrettyPrinting()
       .create()
       .toJson(this.statusService.getStatus()));
   resp.setStatus(HttpServletResponse.SC_OK);
  } catch (final Exception e) {
   log.error("Error!! while reporting status: ", e);
   resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
  } finally {
   resp.getOutputStream().close();
  }
 }
}

if (resultSet.next()) {
  byte[] content = resultSet.getBytes("content");
  response.setContentType(getServletContext().getMimeType(imageName));
  response.setContentLength(content.length);
  response.getOutputStream().write(content);
} else {
  response.sendError(HttpServletResponse.SC_NOT_FOUND); // 404.

public static boolean doXsrfFilter(ServletRequest request, ServletResponse response,
  Set<String> methodsToIgnore, String headerName) throws IOException, ServletException {
 HttpServletRequest httpRequest = (HttpServletRequest)request;
 if (methodsToIgnore == null) { methodsToIgnore = XSRF_METHODS_TO_IGNORE_DEFAULT ; }
 if (headerName == null ) { headerName = XSRF_HEADER_DEFAULT; }
 if (methodsToIgnore.contains(httpRequest.getMethod()) ||
   httpRequest.getHeader(headerName) != null) {
  return true;
 } else {
  ((HttpServletResponse)response).sendError(
    HttpServletResponse.SC_BAD_REQUEST,
    "Missing Required Header for Vulnerability Protection");
  response.getWriter().println(
    "XSRF filter denial, requests must contain header : " + headerName);
  return false;
 }
}

if (resource == null) {
  logger.debug("Resource not found");
  response.sendError(HttpServletResponse.SC_NOT_FOUND);
  return;
  response.setHeader("Allow", getAllowHeader());
  return;
if (request.getHeader(HttpHeaders.RANGE) == null) {
  Assert.state(this.resourceHttpMessageConverter != null, "Not initialized");
  setHeaders(response, resource, mediaType);
  response.setHeader(HttpHeaders.ACCEPT_RANGES, "bytes");
  ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(request);
  try {
    List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
    this.resourceRegionHttpMessageConverter.write(
        HttpRange.toResourceRegions(httpRanges, resource), mediaType, outputMessage);
    response.setHeader("Content-Range", "bytes */" + resource.contentLength());
    response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);

/**
 * 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);
}

String auth = request.getHeader("Authorization");
JID jid;
try {
  response.setHeader("WWW-Authenticate", "Basic realm=\"Openfire WebDAV\"");
  response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
  return false;

 public void handle(String s, Request r, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
  if ("POST".equalsIgnoreCase(request.getMethod())) {
   String p = request.getParameter("test");
   if (isNonEmpty(p)) {
    response.setStatus(HttpServletResponse.SC_OK);
    response.addHeader("X-Param", p);
   } else {
    response.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE);
   }
  } else { // this handler is to handle POST request
   response.sendError(HttpServletResponse.SC_FORBIDDEN);
  }
  response.getOutputStream().flush();
  response.getOutputStream().close();
 }
}

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
  try {
    requestHandler.handleRequest(new DataInputStream(request.getInputStream()),
                   new DataOutputStream(response.getOutputStream()));
  } catch(Exception e) {
    logger.error("Uncaught exception in store servlet:", e);
    response.sendError(HttpURLConnection.HTTP_UNAVAILABLE, e.getMessage());
  }
}

builder.contentLength(payload.size());
String storageClass = request.getHeader("x-amz-storage-class");
if (storageClass == null || storageClass.equalsIgnoreCase("STANDARD")) {
String cannedAcl = request.getHeader("x-amz-acl");
if (cannedAcl == null || cannedAcl.equalsIgnoreCase("private")) {
  access = BlobAccess.PRIVATE;
  throw new S3Exception(S3ErrorCode.NOT_IMPLEMENTED);
} else {
  response.sendError(HttpServletResponse.SC_BAD_REQUEST);
  return;
try (Writer writer = response.getWriter()) {
  response.setContentType(XML_CONTENT_TYPE);
  XMLStreamWriter xml = xmlOutputFactory.createXMLStreamWriter(
      writer);

 @Test
 public void testNoFileFound() throws IOException {
  HttpServletResponse mockResponse = mock(HttpServletResponse.class);
  JdbcJarDownloadServlet servlet = new JdbcJarDownloadServlet();
  servlet.doGet(null, mockResponse);

  verify(mockResponse, times(1)).setHeader(
    "Content-disposition","attachment; filename=hive-jdbc-standalone.jar");
  verify(mockResponse, times(1)).setContentType("application/java-archive");
  verify(mockResponse, times(1)).sendError(HttpServletResponse.SC_NOT_FOUND);
 }
}

@Override
public void render(final RequestContext context) {
  final HttpServletResponse response = context.getResponse();
  response.setContentType("text/html");
  response.setCharacterEncoding("UTF-8");
    writer = response.getWriter();
  } catch (final Exception e) {
    try {
      writer = new PrintWriter(response.getOutputStream());
    } catch (final IOException ex) {
      LOGGER.log(Level.ERROR, "Can not get response writer", ex);
      response.sendError(HttpServletResponse.SC_NOT_FOUND);
    } catch (final IOException ex) {
      LOGGER.log(Level.ERROR, "Can not send error 404!", ex);
      response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    } catch (final IOException ex) {
      LOGGER.log(Level.ERROR, "Sends error 500 failed", ex);

  response.setStatus(HttpServletResponse.SC_FORBIDDEN);
  return;
String authName = request.getHeader(AbstractEurekaIdentity.AUTH_NAME_HEADER_KEY);
String authVersion = request.getHeader(AbstractEurekaIdentity.AUTH_VERSION_HEADER_KEY);
String authId = request.getHeader(AbstractEurekaIdentity.AUTH_ID_HEADER_KEY);
  response.sendError(HttpServletResponse.SC_NOT_FOUND,
      "Request path: " + pathInfo + " not supported by eureka resource mock.");

  public void handle(HttpServletRequest request, HttpServletResponse response, String message, HttpStatus httpStatus) throws IOException {
    if (API_REQUEST_MATCHER.matches(request)) {
      response.setStatus(HttpStatus.BAD_REQUEST.value());
      final ContentTypeAwareResponse contentTypeAwareResponse = CONTENT_TYPE_NEGOTIATION_MESSAGE_HANDLER.getResponse(request);
      response.setCharacterEncoding("utf-8");
      response.setContentType(contentTypeAwareResponse.getContentType().toString());
      response.getOutputStream().print(contentTypeAwareResponse.getFormattedMessage(message));
    } else {
      response.sendError(httpStatus.value(), message);
    }
  }
}

private void doHsErrPid(HttpServletResponse httpResponse,
    List<JavaInformations> javaInformationsList, String path) throws IOException {
  for (final JavaInformations javaInformations : javaInformationsList) {
    for (final HsErrPid hsErrPid : javaInformations.getHsErrPidList()) {
      if (hsErrPid.getFile().replace('\\', '/').equals(path) && new File(path).exists()) {
        final File file = new File(path);
        final OutputStream out = httpResponse.getOutputStream();
        httpResponse.setContentType("text/plain");
        // attachment et non inline pour proposer le téléchargement et non l'affichage direct dans le navigateur
        httpResponse.addHeader("Content-Disposition",
            "attachment;filename=" + file.getName());
        InputOutput.pumpFromFile(file, out);
        return;
      }
    }
  }
  // si le fichier demandé n'est pas dans la liste des fichiers hs_err_pid*.log,
  // alors il n'existe plus ou alors le fichier demandé est une invention malveillante
  httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND);
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
 throws ServletException, IOException {
 LOG.info("POST");
 resp.setContentType("text/html");
 PrintWriter out = resp.getWriter();
 Reconfigurable reconf = getReconfigurable(req);
 String nodeName = reconf.getClass().getCanonicalName();
 printHeader(out, nodeName);
 try { 
  applyChanges(out, reconf, req);
 } catch (ReconfigurationException e) {
  resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, 
          StringUtils.stringifyException(e));
  return;
 }
 out.println("<p><a href=\"" + req.getServletPath() + "\">back</a></p>");
 printFooter(out);
}

@Override
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws
  IOException, ServletException {
 HttpServletRequest request = (HttpServletRequest) req;
 HttpServletResponse response = (HttpServletResponse) resp;
 String token = request.getHeader("Authorization");
 Long consumerId = consumerAuthUtil.getConsumerId(token);
 if (consumerId == null) {
  response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
  return;
 }
 consumerAuthUtil.storeConsumerId(request, consumerId);
 consumerAuditUtil.audit(request, consumerId);
 chain.doFilter(req, resp);
}

if (resource == null) {
  logger.debug("Resource not found");
  response.sendError(HttpServletResponse.SC_NOT_FOUND);
  return;
  response.setHeader("Allow", getAllowHeader());
  return;
if (request.getHeader(HttpHeaders.RANGE) == null) {
  Assert.state(this.resourceHttpMessageConverter != null, "Not initialized");
  setHeaders(response, resource, mediaType);
  response.setHeader(HttpHeaders.ACCEPT_RANGES, "bytes");
  ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(request);
  try {
    List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
    this.resourceRegionHttpMessageConverter.write(
        HttpRange.toResourceRegions(httpRanges, resource), mediaType, outputMessage);
    response.setHeader("Content-Range", "bytes */" + resource.contentLength());
    response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);