How to use

setContentType

method

in

javax.servlet.http.HttpServletResponse

 @Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  String text = "some text";

  response.setContentType("text/plain");  // Set content type of the response so that jQuery knows what it can expect.
  response.setCharacterEncoding("UTF-8"); // You want world domination, huh?
  response.getWriter().write(text);       // Write response body.
}

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
  Assert.state(this.liveBeansView != null, "No LiveBeansView available");
  String content = this.liveBeansView.getSnapshotAsJson();
  response.setContentType("application/json");
  response.setContentLength(content.length());
  response.getWriter().write(content);
}

/**
 * Write the given temporary OutputStream to the HTTP response.
 * @param response current HTTP response
 * @param baos the temporary OutputStream to write
 * @throws IOException if writing/flushing failed
 */
protected void writeToResponse(HttpServletResponse response, ByteArrayOutputStream baos) throws IOException {
  // Write content type and also length (determined via byte array).
  response.setContentType(getContentType());
  response.setContentLength(baos.size());
  // Flush byte array to servlet output stream.
  ServletOutputStream out = response.getOutputStream();
  baos.writeTo(out);
  out.flush();
}

  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;
  }
}

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, java.io.IOException {
  String id = request.getParameter("id");
  PrintWriter out = response.getWriter();
  response.setContentType("text/plain");
  out.println("Id is " + id);
}

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.");
}

  /**
   * 判断是否是 ajax 请求
   * 如果是，则返回 403 状态码
   */
  @Override
  protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
    if (HttpUtils.isAjaxRequest((HttpServletRequest) request)) {
      HttpServletResponse httpServletResponse = (HttpServletResponse) response;
      httpServletResponse.setStatus(HttpStatus.FORBIDDEN.value());
      httpServletResponse.setContentType("application/json; charset=utf-8");
      httpServletResponse.getWriter().print(JSON.toJSON(ResponseBo.error()));
      return false;
    } else {
      saveRequestAndRedirectToLogin(request, response);
      return false;
    }
  }
}

private void generateHTMLResponse() {
  response.setContentType("text/html");
  response.setCharacterEncoding("utf-8");
  try {
    response.getWriter().print(htmlResponse);
  } catch (IOException e) {
    LOGGER.error("General IOException: {}", e.getMessage());
  }
}

@RequestMapping(value = "helloReport1", method = RequestMethod.GET)
@ResponseBody
public void getRpt1(HttpServletResponse response) throws JRException, IOException {
 InputStream jasperStream = this.getClass().getResourceAsStream("/jasperreports/HelloWorld1.jasper");
 Map<String,Object> params = new HashMap<>();
 JasperReport jasperReport = (JasperReport) JRLoader.loadObject(jasperStream);
 JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, params, new JREmptyDataSource());
 response.setContentType("application/x-pdf");
 response.setHeader("Content-disposition", "inline; filename=helloWorldReport.pdf");
 final OutputStream outStream = response.getOutputStream();
 JasperExportManager.exportReportToPdfStream(jasperPrint, outStream);
}

protected void setDownloadResponse(String downloadFile, final HttpServletResponse response) {
  File file = new File(downloadFile);
  try (InputStream fileInputStream = new FileInputStream(file);
      OutputStream output = response.getOutputStream()) {
    response.reset();
    response.setContentType("application/octet-stream");
    response.setContentLength((int) (file.length()));
    response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
    IOUtils.copyLarge(fileInputStream, output);
    output.flush();
  } catch (IOException e) {
    throw new InternalErrorException("Failed to download file: " + e.getMessage(), e);
  }
}

public void render(HttpServletRequest req, HttpServletResponse resp, Object obj)
    throws IOException {
  if (resp.getContentType() == null)
    if (jsonp)
      resp.setContentType(JSONP_CT);
    else
      resp.setContentType(CT);
  Writer writer = resp.getWriter();
  if (jsonp)
    writer.write(req.getParameter(jsonpParam == null ? "callback" : jsonpParam) + "(");
  Mvcs.write(resp, writer, null == obj ? data : obj, format);
  if (jsonp)
    writer.write(");");
}

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

 @Override public void withMessage( String text ) throws IOException {
  resp.setContentType( "text/plain" );
  resp.getWriter().println( text );
 }
};

req.setAttribute("loginForm", loginForm);
rsp.setStatus(SC_FORBIDDEN);
rsp.setContentType("text/html;charset=UTF-8");
  out = new PrintWriter(new OutputStreamWriter(rsp.getOutputStream()));
} catch (IllegalStateException e) {
  out = rsp.getWriter();
  out.print("                              ");
out.close();

 public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {

   ServletContext cntx= req.getServletContext();
   // Get the absolute path of the image
   String filename = cntx.getRealPath("Images/button.png");
   // retrieve mimeType dynamically
   String mime = cntx.getMimeType(filename);
   if (mime == null) {
    resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    return;
   }

   resp.setContentType(mime);
   File file = new File(filename);
   resp.setContentLength((int)file.length());

   FileInputStream in = new FileInputStream(file);
   OutputStream out = resp.getOutputStream();

   // Copy the contents of the file to the output stream
    byte[] buf = new byte[1024];
    int count = 0;
    while ((count = in.read(buf)) >= 0) {
     out.write(buf, 0, count);
   }
  out.close();
  in.close();

}

private void testCarteResponse( CarteRequestHandler.CarteResponse response ) throws IOException {
 when( resp.getWriter() ).thenReturn( printWriter );
 when( resp.getOutputStream() ).thenReturn( outputStream );
 response.with( "text/xml", writerResponse );
 verify( resp ).setContentType( "text/xml" );
 verify( writerResponse ).write( printWriter );
 response.with( "text/sgml", outputStreamResponse );
 verify( resp ).setContentType( "text/sgml" );
 verify( outputStreamResponse ).write( outputStream );
 response.withMessage( "Message" );
 verify( resp ).setContentType( "text/plain" );
 verify( printWriter ).println( "Message" );
}

/**
 * {@inheritDoc}
 */
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 logger.info("GET SPIED query from " + request.getRemoteAddr());
 if (request.getCharacterEncoding() == null) {
  request.setCharacterEncoding("utf-8");
 }
 response.setContentType("text/json; charset=UTF-8");
 PrintWriter out = response.getWriter();
 try {
  String raw = request.getParameter("q");
  String seedwords = request.getParameter("seedwords");
  String model = request.getParameter("model");
  if (raw == null || "".equals(raw)) {
   out.print("{\"okay\":false,\"reason\":\"No data provided\"}");
  } else {
   run(out, raw, seedwords, model);
  }
 } catch (Exception t) {
  writeError(t, out, request.toString());
 }
 out.close();
}

private void writeSpansToResponse(HttpServletResponse response, Collection<Pair<Long, SpanWrapper>> spans)
    throws IOException {
  if (spans == null) {
    spans = Collections.emptyList();
  }
  response.setContentType("application/json");
  response.setHeader("Pragma", "no-cache");
  response.setHeader("Cache-Control", "max-age=0, no-cache, no-store, must-revalidate");
  response.setHeader("Expires", "0");
  response.setCharacterEncoding("UTF-8");
  final ArrayList<String> jsonResponse = new ArrayList<String>(spans.size());
  for (Pair<Long, SpanWrapper> spanPair : spans) {
    logger.debug("writeSpansToResponse {}", spanPair);
    jsonResponse.add(JsonUtils.toJson(spanPair.getB(), SpanUtils.CALL_TREE_ASCII));
  }
  response.getWriter().print(jsonResponse.toString());
  response.getWriter().close();
}

/**
 * Write the given RemoteInvocationResult to the given HTTP response.
 * @param request current HTTP request
 * @param response current HTTP response
 * @param result the RemoteInvocationResult object
 * @throws IOException in case of I/O failure
 */
protected void writeRemoteInvocationResult(
    HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result)
    throws IOException {
  response.setContentType(getContentType());
  writeRemoteInvocationResult(request, response, result, response.getOutputStream());
}

private void setResponseHeaders(final HttpServletResponse response) {
 response.setContentType(HttpConstants.CONTENT_TYPE_JSON);
 response.setHeader(HttpConstants.ACCESS_CONTROL_ALLOW_METHODS,
  HttpConstants.METHOD_GET + "," + HttpConstants.METHOD_DELETE);
 response.setHeader(HttpConstants.ACCESS_CONTROL_ALLOW_ORIGIN, HttpConstants.WILDCARD);
}