活动公告

系统通知
通知：关于部分勋章领取条件及购买价格调整的通知
05-18 21:22
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

Servlet输出语句完全指南掌握PrintWriter和OutputStream的实用技巧与常见问题解决方案

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

2860

科技点

3万

积分

白金月票

碾压王

积分
32872

塔罗立华奏
<font color=白金月票" /> 发表于 2025-9-6 20:40:32 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

在Java Web开发中，Servlet作为核心技术之一，负责处理客户端请求并生成响应。而在Servlet生成响应的过程中，输出语句扮演着至关重要的角色。无论是返回HTML页面、JSON数据，还是输出文件内容，都需要通过适当的输出机制来完成。Servlet提供了两种主要的输出方式：PrintWriter和OutputStream，它们各有特点和适用场景。本文将全面介绍这两种输出方式的使用方法、实用技巧以及常见问题的解决方案，帮助开发者更好地掌握Servlet输出语句的使用。

Servlet输出机制概述

在深入了解PrintWriter和OutputStream之前，我们首先需要理解Servlet的输出机制。当Servlet处理完客户端请求后，需要通过HTTP响应将结果返回给客户端。HTTP响应由状态行、响应头和响应体三部分组成，而输出语句主要用于构建响应体。

Servlet通过HttpServletResponse对象提供了两种获取输出流的方法：

1. getWriter()：返回一个PrintWriter对象，用于输出文本数据。
2. getOutputStream()：返回一个ServletOutputStream对象，用于输出二进制数据。

这两种方法都是将数据写入响应体，但它们的使用方式和适用场景有所不同。下面我们将详细介绍这两种输出方式。

PrintWriter详解

基本用法

PrintWriter是Servlet中用于输出文本数据的主要方式，它继承自Java.io.Writer，提供了方便的文本输出功能。获取PrintWriter对象的基本方法如下：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 获取PrintWriter对象
  6.     PrintWriter out = response.getWriter();
  7.    
  8.     // 使用PrintWriter输出文本
  9.     out.println("<html>");
  10.     out.println("<head>");
  11.     out.println("<title>PrintWriter示例</title>");
  12.     out.println("</head>");
  13.     out.println("<body>");
  14.     out.println("<h1>Hello, World!</h1>");
  15.     out.println("</body>");
  16.     out.println("</html>");
  17. }
复制代码

字符编码处理

使用PrintWriter时，字符编码是一个重要的问题。默认情况下，PrintWriter使用ISO-8859-1编码，这可能导致中文等非ASCII字符显示为乱码。为了避免这种情况，我们应该在获取PrintWriter对象之前设置正确的字符编码：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型和字符编码
  6.     response.setContentType("text/html;charset=UTF-8");
  7.    
  8.     // 获取PrintWriter对象
  9.     PrintWriter out = response.getWriter();
  10.    
  11.     // 使用PrintWriter输出中文
  12.     out.println("<html>");
  13.     out.println("<head>");
  14.     out.println("<title>PrintWriter中文示例</title>");
  15.     out.println("</head>");
  16.     out.println("<body>");
  17.     out.println("<h1>你好，世界！</h1>");
  18.     out.println("</body>");
  19.     out.println("</html>");
  20. }
复制代码

实用技巧

在现代Web应用中，经常需要使用Servlet返回JSON数据。PrintWriter非常适合这种场景：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型为JSON
  6.     response.setContentType("application/json;charset=UTF-8");
  7.    
  8.     // 获取PrintWriter对象
  9.     PrintWriter out = response.getWriter();
  10.    
  11.     // 创建JSON对象
  12.     JsonObject jsonObject = new JsonObject();
  13.     jsonObject.addProperty("name", "张三");
  14.     jsonObject.addProperty("age", 30);
  15.     jsonObject.addProperty("email", "zhangsan@example.com");
  16.    
  17.     // 输出JSON数据
  18.     out.println(jsonObject.toString());
  19. }
复制代码

PrintWriter默认是缓冲输出的，我们可以通过设置缓冲区大小来优化性能：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置缓冲区大小为8KB
  6.     response.setBufferSize(8192);
  7.    
  8.     // 设置响应内容类型和字符编码
  9.     response.setContentType("text/html;charset=UTF-8");
  10.    
  11.     // 获取PrintWriter对象
  12.     PrintWriter out = response.getWriter();
  13.    
  14.     // 输出大量内容
  15.     for (int i = 0; i < 1000; i++) {
  16.         out.println("<p>这是第 " + i + " 行内容</p>");
  17.     }
  18.    
  19.     // 手动刷新缓冲区
  20.     out.flush();
  21. }
复制代码

PrintWriter支持printf和format方法，可以方便地进行格式化输出：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型和字符编码
  6.     response.setContentType("text/html;charset=UTF-8");
  7.    
  8.     // 获取PrintWriter对象
  9.     PrintWriter out = response.getWriter();
  10.    
  11.     // 使用printf格式化输出
  12.     out.printf("<h1>%s，欢迎访问！</h1>", "张三");
  13.     out.printf("<p>当前时间：%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS</p>", new Date());
  14.    
  15.     // 使用format格式化输出
  16.     String message = String.format("您的账户余额：%.2f 元", 1234.567);
  17.     out.println("<p>" + message + "</p>");
  18. }
复制代码

完整示例

下面是一个使用PrintWriter生成完整HTML页面的示例：
  2. @WebServlet("/userList")
  3. public class UserListServlet extends HttpServlet {
  4.     private static final long serialVersionUID = 1L;
  5.    
  6.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
  7.             throws ServletException, IOException {
  8.         
  9.         // 设置响应内容类型和字符编码
  10.         response.setContentType("text/html;charset=UTF-8");
  11.         
  12.         // 获取PrintWriter对象
  13.         PrintWriter out = response.getWriter();
  14.         
  15.         // 模拟用户数据
  16.         List<User> users = new ArrayList<>();
  17.         users.add(new User(1, "张三", "zhangsan@example.com", 25));
  18.         users.add(new User(2, "李四", "lisi@example.com", 30));
  19.         users.add(new User(3, "王五", "wangwu@example.com", 28));
  20.         
  21.         // 输出HTML页面
  22.         out.println("<!DOCTYPE html>");
  23.         out.println("<html>");
  24.         out.println("<head>");
  25.         out.println("<meta charset="UTF-8">");
  26.         out.println("<title>用户列表</title>");
  27.         out.println("<style>");
  28.         out.println("table { border-collapse: collapse; width: 100%; }");
  29.         out.println("th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }");
  30.         out.println("th { background-color: #f2f2f2; }");
  31.         out.println("tr:nth-child(even) { background-color: #f9f9f9; }");
  32.         out.println("</style>");
  33.         out.println("</head>");
  34.         out.println("<body>");
  35.         out.println("<h1>用户列表</h1>");
  36.         out.println("<table>");
  37.         out.println("<tr><th>ID</th><th>姓名</th><th>邮箱</th><th>年龄</th></tr>");
  38.         
  39.         for (User user : users) {
  40.             out.printf("<tr><td>%d</td><td>%s</td><td>%s</td><td>%d</td></tr>",
  41.                       user.getId(), user.getName(), user.getEmail(), user.getAge());
  42.         }
  43.         
  44.         out.println("</table>");
  45.         out.println("</body>");
  46.         out.println("</html>");
  47.     }
  48. }
  50. class User {
  51.     private int id;
  52.     private String name;
  53.     private String email;
  54.     private int age;
  55.    
  56.     public User(int id, String name, String email, int age) {
  57.         this.id = id;
  58.         this.name = name;
  59.         this.email = email;
  60.         this.age = age;
  61.     }
  62.    
  63.     // Getter方法
  64.     public int getId() { return id; }
  65.     public String getName() { return name; }
  66.     public String getEmail() { return email; }
  67.     public int getAge() { return age; }
  68. }
复制代码

OutputStream详解

基本用法

OutputStream是Servlet中用于输出二进制数据的主要方式，它继承自Java.io.OutputStream，适合输出图片、音频、视频等非文本数据。获取OutputStream对象的基本方法如下：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 获取OutputStream对象
  6.     ServletOutputStream out = response.getOutputStream();
  7.    
  8.     // 输出二进制数据
  9.     out.write("This is binary data".getBytes());
  10. }
复制代码

二进制数据处理

OutputStream的主要用途是处理二进制数据，例如文件下载：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型
  6.     response.setContentType("application/octet-stream");
  7.    
  8.     // 设置Content-Disposition头，指示浏览器下载文件
  9.     response.setHeader("Content-Disposition", "attachment;filename="example.txt"");
  10.    
  11.     // 获取OutputStream对象
  12.     ServletOutputStream out = response.getOutputStream();
  13.    
  14.     // 模拟文件内容
  15.     String fileContent = "这是一个示例文件的内容。\n这是第二行内容。\n这是第三行内容。";
  16.    
  17.     // 将字符串转换为字节数组并输出
  18.     out.write(fileContent.getBytes(StandardCharsets.UTF_8));
  19.    
  20.     // 关闭输出流
  21.     out.close();
  22. }
复制代码

实用技巧

使用OutputStream输出图片是一种常见需求：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型为图片
  6.     response.setContentType("image/jpeg");
  7.    
  8.     // 获取OutputStream对象
  9.     ServletOutputStream out = response.getOutputStream();
  10.    
  11.     // 读取图片文件
  12.     String imagePath = getServletContext().getRealPath("/images/sample.jpg");
  13.     File imageFile = new File(imagePath);
  14.    
  15.     if (imageFile.exists()) {
  16.         // 使用缓冲输入流读取图片
  17.         try (FileInputStream fis = new FileInputStream(imageFile);
  18.              BufferedInputStream bis = new BufferedInputStream(fis)) {
  19.             
  20.             byte[] buffer = new byte[4096];
  21.             int bytesRead;
  22.             
  23.             // 将图片数据写入输出流
  24.             while ((bytesRead = bis.read(buffer)) != -1) {
  25.                 out.write(buffer, 0, bytesRead);
  26.             }
  27.         }
  28.     } else {
  29.         // 如果图片不存在，输出错误信息
  30.         out.write("Image not found".getBytes());
  31.     }
  32.    
  33.     // 关闭输出流
  34.     out.close();
  35. }
复制代码

使用OutputStream输出PDF文件：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型为PDF
  6.     response.setContentType("application/pdf");
  7.    
  8.     // 设置Content-Disposition头，指示浏览器下载文件
  9.     response.setHeader("Content-Disposition", "inline;filename="sample.pdf"");
  10.    
  11.     // 获取OutputStream对象
  12.     ServletOutputStream out = response.getOutputStream();
  13.    
  14.     // 读取PDF文件
  15.     String pdfPath = getServletContext().getRealPath("/docs/sample.pdf");
  16.     File pdfFile = new File(pdfPath);
  17.    
  18.     if (pdfFile.exists()) {
  19.         // 使用缓冲输入流读取PDF
  20.         try (FileInputStream fis = new FileInputStream(pdfFile);
  21.              BufferedInputStream bis = new BufferedInputStream(fis)) {
  22.             
  23.             byte[] buffer = new byte[4096];
  24.             int bytesRead;
  25.             
  26.             // 将PDF数据写入输出流
  27.             while ((bytesRead = bis.read(buffer)) != -1) {
  28.                 out.write(buffer, 0, bytesRead);
  29.             }
  30.         }
  31.     } else {
  32.         // 如果PDF不存在，输出错误信息
  33.         out.write("PDF not found".getBytes());
  34.     }
  35.    
  36.     // 关闭输出流
  37.     out.close();
  38. }
复制代码

使用OutputStream输出Excel文件：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     // 设置响应内容类型为Excel
  6.     response.setContentType("application/vnd.ms-excel");
  7.    
  8.     // 设置Content-Disposition头，指示浏览器下载文件
  9.     response.setHeader("Content-Disposition", "attachment;filename="users.xlsx"");
  10.    
  11.     // 获取OutputStream对象
  12.     ServletOutputStream out = response.getOutputStream();
  13.    
  14.     // 创建工作簿
  15.     try (Workbook workbook = new XSSFWorkbook()) {
  16.         // 创建工作表
  17.         Sheet sheet = workbook.createSheet("用户列表");
  18.         
  19.         // 创建标题行
  20.         Row headerRow = sheet.createRow(0);
  21.         headerRow.createCell(0).setCellValue("ID");
  22.         headerRow.createCell(1).setCellValue("姓名");
  23.         headerRow.createCell(2).setCellValue("邮箱");
  24.         headerRow.createCell(3).setCellValue("年龄");
  25.         
  26.         // 添加数据行
  27.         Object[][] userData = {
  28.             {1, "张三", "zhangsan@example.com", 25},
  29.             {2, "李四", "lisi@example.com", 30},
  30.             {3, "王五", "wangwu@example.com", 28}
  31.         };
  32.         
  33.         for (int i = 0; i < userData.length; i++) {
  34.             Row row = sheet.createRow(i + 1);
  35.             for (int j = 0; j < userData[i].length; j++) {
  36.                 if (userData[i][j] instanceof String) {
  37.                     row.createCell(j).setCellValue((String) userData[i][j]);
  38.                 } else if (userData[i][j] instanceof Integer) {
  39.                     row.createCell(j).setCellValue((Integer) userData[i][j]);
  40.                 }
  41.             }
  42.         }
  43.         
  44.         // 自动调整列宽
  45.         for (int i = 0; i < 4; i++) {
  46.             sheet.autoSizeColumn(i);
  47.         }
  48.         
  49.         // 将Excel写入输出流
  50.         workbook.write(out);
  51.     } catch (Exception e) {
  52.         e.printStackTrace();
  53.         out.write("生成Excel文件时出错".getBytes(StandardCharsets.UTF_8));
  54.     }
  55.    
  56.     // 关闭输出流
  57.     out.close();
  58. }
复制代码

完整示例

下面是一个使用OutputStream实现文件下载功能的完整示例：
  2. @WebServlet("/download")
  3. public class FileDownloadServlet extends HttpServlet {
  4.     private static final long serialVersionUID = 1L;
  5.    
  6.     // 支持的文件类型和对应的MIME类型
  7.     private static final Map<String, String> MIME_TYPES = new HashMap<>();
  8.     static {
  9.         MIME_TYPES.put(".pdf", "application/pdf");
  10.         MIME_TYPES.put(".doc", "application/msword");
  11.         MIME_TYPES.put(".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
  12.         MIME_TYPES.put(".xls", "application/vnd.ms-excel");
  13.         MIME_TYPES.put(".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
  14.         MIME_TYPES.put(".ppt", "application/vnd.ms-powerpoint");
  15.         MIME_TYPES.put(".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation");
  16.         MIME_TYPES.put(".jpg", "image/jpeg");
  17.         MIME_TYPES.put(".jpeg", "image/jpeg");
  18.         MIME_TYPES.put(".png", "image/png");
  19.         MIME_TYPES.put(".gif", "image/gif");
  20.         MIME_TYPES.put(".txt", "text/plain");
  21.         MIME_TYPES.put(".zip", "application/zip");
  22.         MIME_TYPES.put(".mp3", "audio/mpeg");
  23.         MIME_TYPES.put(".mp4", "video/mp4");
  24.     }
  25.    
  26.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
  27.             throws ServletException, IOException {
  28.         
  29.         // 获取请求参数
  30.         String fileName = request.getParameter("file");
  31.         
  32.         if (fileName == null || fileName.isEmpty()) {
  33.             response.sendError(HttpServletResponse.SC_BAD_REQUEST, "文件名不能为空");
  34.             return;
  35.         }
  36.         
  37.         // 安全检查，防止目录遍历攻击
  38.         if (fileName.contains("..") || fileName.contains("/")) {
  39.             response.sendError(HttpServletResponse.SC_BAD_REQUEST, "非法文件名");
  40.             return;
  41.         }
  42.         
  43.         // 构建文件路径
  44.         String filePath = getServletContext().getRealPath("/files/" + fileName);
  45.         File downloadFile = new File(filePath);
  46.         
  47.         if (!downloadFile.exists()) {
  48.             response.sendError(HttpServletResponse.SC_NOT_FOUND, "文件不存在");
  49.             return;
  50.         }
  51.         
  52.         // 获取文件扩展名
  53.         String fileExtension = fileName.substring(fileName.lastIndexOf(".")).toLowerCase();
  54.         
  55.         // 根据文件扩展名设置MIME类型
  56.         String mimeType = MIME_TYPES.get(fileExtension);
  57.         if (mimeType == null) {
  58.             mimeType = "application/octet-stream";
  59.         }
  60.         
  61.         // 设置响应内容类型
  62.         response.setContentType(mimeType);
  63.         
  64.         // 设置Content-Disposition头，指示浏览器下载文件
  65.         response.setHeader("Content-Disposition", "attachment;filename="" + fileName + """);
  66.         
  67.         // 设置文件大小
  68.         response.setContentLength((int) downloadFile.length());
  69.         
  70.         // 获取OutputStream对象
  71.         try (ServletOutputStream out = response.getOutputStream();
  72.              FileInputStream in = new FileInputStream(downloadFile);
  73.              BufferedInputStream bis = new BufferedInputStream(in)) {
  74.             
  75.             byte[] buffer = new byte[4096];
  76.             int bytesRead;
  77.             
  78.             // 将文件内容写入输出流
  79.             while ((bytesRead = bis.read(buffer)) != -1) {
  80.                 out.write(buffer, 0, bytesRead);
  81.             }
  82.         }
  83.     }
  84. }
复制代码

PrintWriter与OutputStream的比较

区别与联系

PrintWriter和OutputStream都是Servlet中用于输出数据的方式，但它们有以下主要区别：

1. 数据类型：PrintWriter主要用于输出文本数据（字符流）。OutputStream主要用于输出二进制数据（字节流）。
2. PrintWriter主要用于输出文本数据（字符流）。
3. OutputStream主要用于输出二进制数据（字节流）。
4. 编码处理：PrintWriter会自动处理字符编码，将字符转换为字节。OutputStream直接输出字节数据，不进行编码转换。
5. PrintWriter会自动处理字符编码，将字符转换为字节。
6. OutputStream直接输出字节数据，不进行编码转换。
7. 使用方法：PrintWriter提供了print()、println()、printf()等方便的文本输出方法。OutputStream主要提供write()方法来输出字节数据。
8. PrintWriter提供了print()、println()、printf()等方便的文本输出方法。
9. OutputStream主要提供write()方法来输出字节数据。
10. 获取方式：PrintWriter通过response.getWriter()获取。OutputStream通过response.getOutputStream()获取。
11. PrintWriter通过response.getWriter()获取。
12. OutputStream通过response.getOutputStream()获取。
13. 互斥性：在同一个响应中，不能同时使用PrintWriter和OutputStream。如果已经调用了getWriter()方法，再调用getOutputStream()会抛出IllegalStateException异常，反之亦然。
14. 在同一个响应中，不能同时使用PrintWriter和OutputStream。如果已经调用了getWriter()方法，再调用getOutputStream()会抛出IllegalStateException异常，反之亦然。

数据类型：

• PrintWriter主要用于输出文本数据（字符流）。
• OutputStream主要用于输出二进制数据（字节流）。

编码处理：

• PrintWriter会自动处理字符编码，将字符转换为字节。
• OutputStream直接输出字节数据，不进行编码转换。

使用方法：

• PrintWriter提供了print()、println()、printf()等方便的文本输出方法。
• OutputStream主要提供write()方法来输出字节数据。

获取方式：

• PrintWriter通过response.getWriter()获取。
• OutputStream通过response.getOutputStream()获取。

互斥性：

• 在同一个响应中，不能同时使用PrintWriter和OutputStream。如果已经调用了getWriter()方法，再调用getOutputStream()会抛出IllegalStateException异常，反之亦然。

选择标准

在选择使用PrintWriter还是OutputStream时，可以根据以下标准进行判断：

1. 输出内容类型：如果输出的是文本内容（如HTML、XML、JSON等），应选择PrintWriter。如果输出的是二进制内容（如图片、音频、视频、PDF等），应选择OutputStream。
2. 如果输出的是文本内容（如HTML、XML、JSON等），应选择PrintWriter。
3. 如果输出的是二进制内容（如图片、音频、视频、PDF等），应选择OutputStream。
4. 编码需求：如果需要处理字符编码（特别是非ASCII字符），PrintWriter是更好的选择。如果输出的是不需要编码转换的原始字节数据，应选择OutputStream。
5. 如果需要处理字符编码（特别是非ASCII字符），PrintWriter是更好的选择。
6. 如果输出的是不需要编码转换的原始字节数据，应选择OutputStream。
7. 输出方法：如果需要使用print()、println()、printf()等方便的文本输出方法，应选择PrintWriter。如果只需要简单的字节输出，OutputStream就足够了。
8. 如果需要使用print()、println()、printf()等方便的文本输出方法，应选择PrintWriter。
9. 如果只需要简单的字节输出，OutputStream就足够了。

输出内容类型：

• 如果输出的是文本内容（如HTML、XML、JSON等），应选择PrintWriter。
• 如果输出的是二进制内容（如图片、音频、视频、PDF等），应选择OutputStream。

编码需求：

• 如果需要处理字符编码（特别是非ASCII字符），PrintWriter是更好的选择。
• 如果输出的是不需要编码转换的原始字节数据，应选择OutputStream。

输出方法：

• 如果需要使用print()、println()、printf()等方便的文本输出方法，应选择PrintWriter。
• 如果只需要简单的字节输出，OutputStream就足够了。

性能考虑

在性能方面，PrintWriter和OutputStream有以下差异：

1. 缓冲机制：PrintWriter默认是缓冲的，可以通过setBufferSize()方法设置缓冲区大小。OutputStream也可以通过response.setBufferSize()设置缓冲区大小。
2. PrintWriter默认是缓冲的，可以通过setBufferSize()方法设置缓冲区大小。
3. OutputStream也可以通过response.setBufferSize()设置缓冲区大小。
4. 编码开销：PrintWriter需要将字符转换为字节，这会带来一定的性能开销。OutputStream直接输出字节数据，没有编码转换的开销。
5. PrintWriter需要将字符转换为字节，这会带来一定的性能开销。
6. OutputStream直接输出字节数据，没有编码转换的开销。
7. 使用场景：对于大量文本输出，PrintWriter的便利性通常超过了其性能开销。对于大量二进制数据输出，OutputStream是更高效的选择。
8. 对于大量文本输出，PrintWriter的便利性通常超过了其性能开销。
9. 对于大量二进制数据输出，OutputStream是更高效的选择。

缓冲机制：

• PrintWriter默认是缓冲的，可以通过setBufferSize()方法设置缓冲区大小。
• OutputStream也可以通过response.setBufferSize()设置缓冲区大小。

编码开销：

• PrintWriter需要将字符转换为字节，这会带来一定的性能开销。
• OutputStream直接输出字节数据，没有编码转换的开销。

使用场景：

• 对于大量文本输出，PrintWriter的便利性通常超过了其性能开销。
• 对于大量二进制数据输出，OutputStream是更高效的选择。

在实际应用中，除非在极端性能敏感的场景下，否则应根据输出内容的类型选择合适的输出方式，而不是仅仅考虑性能因素。

常见问题及解决方案

中文乱码问题

中文乱码是Servlet开发中最常见的问题之一，主要原因是字符编码不一致。

当使用PrintWriter输出中文时，浏览器显示的是乱码字符，而不是正确的中文内容。

1. 没有设置正确的字符编码。
2. Servlet容器和浏览器的字符编码不一致。
3. 数据库或文件读取时的编码问题。

1. 设置响应字符编码：
  2. // 在获取PrintWriter之前设置字符编码
  3. response.setContentType("text/html;charset=UTF-8");
  4. PrintWriter out = response.getWriter();
复制代码

1. 统一使用UTF-8编码：
  2. // 设置请求和响应的字符编码
  3. request.setCharacterEncoding("UTF-8");
  4. response.setContentType("text/html;charset=UTF-8");
  5. PrintWriter out = response.getWriter();
复制代码

1. 在web.xml中配置编码过滤器：
  2. <filter>
  3.     <filter-name>CharacterEncodingFilter</filter-name>
  4.     <filter-class>org.apache.catalina.filters.SetCharacterEncodingFilter</filter-class>
  5.     <init-param>
  6.         <param-name>encoding</param-name>
  7.         <param-value>UTF-8</param-value>
  8.     </init-param>
  9.     <init-param>
  10.         <param-name>forceEncoding</param-name>
  11.         <param-value>true</param-value>
  12.     </init-param>
  13. </filter>
  14. <filter-mapping>
  15.     <filter-name>CharacterEncodingFilter</filter-name>
  16.     <url-pattern>/*</url-pattern>
  17. </filter-mapping>
复制代码

1. HTML页面中指定字符编码：
  2. PrintWriter out = response.getWriter();
  3. out.println("<!DOCTYPE html>");
  4. out.println("<html>");
  5. out.println("<head>");
  6. out.println("<meta charset="UTF-8">");  // 指定HTML字符编码
  7. out.println("<title>中文页面</title>");
  8. out.println("</head>");
  9. out.println("<body>");
  10. out.println("<h1>你好，世界！</h1>");
  11. out.println("</body>");
  12. out.println("</html>");
复制代码

输出流关闭问题

在使用PrintWriter或OutputStream后，没有正确关闭输出流，可能导致资源泄露或数据不完整。

1. 忘记调用close()方法关闭输出流。
2. 在关闭输出流之前发生了异常，导致close()方法没有被调用。
3. 重复关闭输出流。

1. 使用try-with-resources语句：
  2. // 对于OutputStream
  3. try (ServletOutputStream out = response.getOutputStream()) {
  4.     // 使用输出流
  5.     out.write("Hello, World!".getBytes());
  6. } catch (IOException e) {
  7.     e.printStackTrace();
  8. }
  10. // 对于PrintWriter
  11. try (PrintWriter out = response.getWriter()) {
  12.     // 使用PrintWriter
  13.     out.println("Hello, World!");
  14. } catch (IOException e) {
  15.     e.printStackTrace();
  16. }
复制代码

1. 在finally块中关闭输出流：
  2. PrintWriter out = null;
  3. try {
  4.     out = response.getWriter();
  5.     out.println("Hello, World!");
  6. } catch (IOException e) {
  7.     e.printStackTrace();
  8. } finally {
  9.     if (out != null) {
  10.         out.close();
  11.     }
  12. }
复制代码

1. 注意不要重复关闭输出流：
  2. PrintWriter out = response.getWriter();
  3. try {
  4.     out.println("Hello, World!");
  5. } finally {
  6.     if (out != null) {
  7.         out.close();  // 只关闭一次
  8.     }
  9. }
  10. // 不要在这里再次关闭out
复制代码

1. 注意Servlet容器会自动关闭输出流：
  2. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  3.         throws ServletException, IOException {
  4.    
  5.     PrintWriter out = response.getWriter();
  6.     out.println("Hello, World!");
  7.     // 不需要显式关闭输出流，Servlet容器会在service方法结束后自动关闭
  8. }
复制代码

IllegalStateException异常

在同一个Servlet响应中同时调用getWriter()和getOutputStream()方法，导致抛出IllegalStateException异常。

根据Servlet规范，在同一个响应中只能使用一种输出方式，要么是PrintWriter，要么是OutputStream，不能同时使用。

1. 根据输出内容类型选择合适的输出方式：
  2. // 如果输出文本内容
  3. if (isTextContent) {
  4.     response.setContentType("text/html;charset=UTF-8");
  5.     PrintWriter out = response.getWriter();
  6.     out.println("<h1>文本内容</h1>");
  7. }
  8. // 如果输出二进制内容
  9. else {
  10.     response.setContentType("image/jpeg");
  11.     ServletOutputStream out = response.getOutputStream();
  12.     // 输出图片数据
  13. }
复制代码

1. 在条件分支中确保只使用一种输出方式：
  2. String outputType = request.getParameter("type");
  3. PrintWriter writer = null;
  4. ServletOutputStream stream = null;
  6. try {
  7.     if ("text".equals(outputType)) {
  8.         response.setContentType("text/plain;charset=UTF-8");
  9.         writer = response.getWriter();
  10.         writer.println("这是一段文本内容");
  11.     } else if ("binary".equals(outputType)) {
  12.         response.setContentType("application/octet-stream");
  13.         stream = response.getOutputStream();
  14.         stream.write("这是一段二进制内容".getBytes());
  15.     }
  16. } catch (IOException e) {
  17.     e.printStackTrace();
  18. } finally {
  19.     if (writer != null) {
  20.         writer.close();
  21.     }
  22.     if (stream != null) {
  23.         stream.close();
  24.     }
  25. }
复制代码

1. 使用设计模式确保输出方式的互斥性：
  2. public abstract class OutputHandler {
  3.     public abstract void handle(HttpServletRequest request, HttpServletResponse response)
  4.             throws IOException;
  5. }
  7. public class TextOutputHandler extends OutputHandler {
  8.     @Override
  9.     public void handle(HttpServletRequest request, HttpServletResponse response)
  10.             throws IOException {
  11.         response.setContentType("text/html;charset=UTF-8");
  12.         try (PrintWriter out = response.getWriter()) {
  13.             out.println("<h1>文本内容</h1>");
  14.         }
  15.     }
  16. }
  18. public class BinaryOutputHandler extends OutputHandler {
  19.     @Override
  20.     public void handle(HttpServletRequest request, HttpServletResponse response)
  21.             throws IOException {
  22.         response.setContentType("application/octet-stream");
  23.         try (ServletOutputStream out = response.getOutputStream()) {
  24.             out.write("二进制内容".getBytes());
  25.         }
  26.     }
  27. }
  29. // 在Servlet中使用
  30. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  31.         throws ServletException, IOException {
  32.    
  33.     String outputType = request.getParameter("type");
  34.     OutputHandler handler = null;
  35.    
  36.     if ("text".equals(outputType)) {
  37.         handler = new TextOutputHandler();
  38.     } else if ("binary".equals(outputType)) {
  39.         handler = new BinaryOutputHandler();
  40.     } else {
  41.         response.sendError(HttpServletResponse.SC_BAD_REQUEST, "不支持的输出类型");
  42.         return;
  43.     }
  44.    
  45.     handler.handle(request, response);
  46. }
复制代码

性能优化问题

当输出大量数据时，Servlet的响应速度变慢，占用过多内存。

1. 没有使用缓冲区，导致频繁的I/O操作。
2. 一次性加载大量数据到内存中。
3. 没有正确设置Content-Length头，导致浏览器无法使用持久连接。

1. 设置合适的缓冲区大小：
  2. // 设置响应缓冲区大小为8KB
  3. response.setBufferSize(8192);
  5. PrintWriter out = response.getWriter();
  6. // 输出大量数据
  7. for (int i = 0; i < 10000; i++) {
  8.     out.println("<p>这是第 " + i + " 行内容</p>");
  9. }
复制代码

1. 分块输出大数据：
  2. // 输出大型文件
  3. response.setContentType("application/octet-stream");
  4. response.setHeader("Content-Disposition", "attachment;filename="largefile.dat"");
  6. try (ServletOutputStream out = response.getOutputStream();
  7.      FileInputStream in = new FileInputStream("/path/to/largefile.dat");
  8.      BufferedInputStream bis = new BufferedInputStream(in)) {
  9.    
  10.     byte[] buffer = new byte[8192];  // 8KB缓冲区
  11.     int bytesRead;
  12.    
  13.     while ((bytesRead = bis.read(buffer)) != -1) {
  14.         out.write(buffer, 0, bytesRead);
  15.     }
  16. }
复制代码

1. 设置Content-Length头：
  2. File file = new File("/path/to/file.dat");
  3. long fileSize = file.length();
  5. response.setContentType("application/octet-stream");
  6. response.setHeader("Content-Disposition", "attachment;filename="file.dat"");
  7. response.setContentLengthLong(fileSize);  // 设置文件大小
  9. try (ServletOutputStream out = response.getOutputStream();
  10.      FileInputStream in = new FileInputStream(file);
  11.      BufferedInputStream bis = new BufferedInputStream(in)) {
  12.    
  13.     byte[] buffer = new byte[8192];
  14.     int bytesRead;
  15.    
  16.     while ((bytesRead = bis.read(buffer)) != -1) {
  17.         out.write(buffer, 0, bytesRead);
  18.     }
  19. }
复制代码

1. 使用GZIP压缩：
  2. // 检查浏览器是否支持GZIP
  3. String acceptEncoding = request.getHeader("Accept-Encoding");
  4. if (acceptEncoding != null && acceptEncoding.contains("gzip")) {
  5.     response.setHeader("Content-Encoding", "gzip");
  6.    
  7.     try (PrintWriter out = new PrintWriter(new GZIPOutputStream(response.getOutputStream()))) {
  8.         out.println("<html>");
  9.         out.println("<head><title>GZIP压缩示例</title></head>");
  10.         out.println("<body>");
  11.         
  12.         // 输出大量内容
  13.         for (int i = 0; i < 1000; i++) {
  14.             out.println("<p>这是第 " + i + " 行内容，使用GZIP压缩传输</p>");
  15.         }
  16.         
  17.         out.println("</body>");
  18.         out.println("</html>");
  19.     }
  20. } else {
  21.     // 浏览器不支持GZIP，使用普通输出
  22.     PrintWriter out = response.getWriter();
  23.     out.println("<html>");
  24.     out.println("<head><title>普通输出示例</title></head>");
  25.     out.println("<body>");
  26.    
  27.     // 输出大量内容
  28.     for (int i = 0; i < 1000; i++) {
  29.         out.println("<p>这是第 " + i + " 行内容，不使用压缩</p>");
  30.     }
  31.    
  32.     out.println("</body>");
  33.     out.println("</html>");
  34. }
复制代码

其他常见错误

问题描述：浏览器无法正确识别响应内容类型，导致显示异常。

解决方案：始终设置正确的Content-Type头：
  2. // 输出HTML
  3. response.setContentType("text/html;charset=UTF-8");
  5. // 输出JSON
  6. response.setContentType("application/json;charset=UTF-8");
  8. // 输出XML
  9. response.setContentType("application/xml;charset=UTF-8");
  11. // 输出普通文本
  12. response.setContentType("text/plain;charset=UTF-8");
  14. // 输出PDF
  15. response.setContentType("application/pdf");
复制代码

问题描述：在输出内容后尝试进行重定向或转发，导致异常。

解决方案：确保在输出内容之前完成重定向或转发：
  2. // 错误示例
  3. PrintWriter out = response.getWriter();
  4. out.println("一些内容");
  5. response.sendRedirect("other.jsp");  // 这会抛出IllegalStateException
  7. // 正确示例
  8. if (someCondition) {
  9.     response.sendRedirect("other.jsp");
  10. } else {
  11.     PrintWriter out = response.getWriter();
  12.     out.println("一些内容");
  13. }
复制代码

问题描述：在输出内容后尝试修改响应头，导致修改无效或抛出异常。

解决方案：在输出内容之前设置所有必要的响应头：
  2. // 错误示例
  3. PrintWriter out = response.getWriter();
  4. out.println("一些内容");
  5. response.setHeader("Content-Disposition", "attachment");  // 这可能无效
  7. // 正确示例
  8. response.setHeader("Content-Disposition", "attachment");
  9. response.setContentType("application/octet-stream");
  10. PrintWriter out = response.getWriter();
  11. out.println("一些内容");
复制代码

问题描述：尝试一次性输出大量数据到内存中，导致内存溢出。

解决方案：分块输出数据，避免一次性加载所有数据到内存：
  2. // 错误示例：一次性加载大文件到内存
  3. byte[] fileData = Files.readAllBytes(Paths.get("/path/to/largefile.dat"));
  4. ServletOutputStream out = response.getOutputStream();
  5. out.write(fileData);
  7. // 正确示例：分块读取和输出
  8. response.setContentType("application/octet-stream");
  9. try (ServletOutputStream out = response.getOutputStream();
  10.      FileInputStream in = new FileInputStream("/path/to/largefile.dat");
  11.      BufferedInputStream bis = new BufferedInputStream(in)) {
  12.    
  13.     byte[] buffer = new byte[8192];
  14.     int bytesRead;
  15.    
  16.     while ((bytesRead = bis.read(buffer)) != -1) {
  17.         out.write(buffer, 0, bytesRead);
  18.     }
  19. }
复制代码

最佳实践

1. 统一字符编码

在整个应用中统一使用UTF-8字符编码，避免中文乱码问题：
  2. // 在Servlet基类或过滤器中设置
  3. request.setCharacterEncoding("UTF-8");
  4. response.setContentType("text/html;charset=UTF-8");
复制代码

2. 使用try-with-resources

使用try-with-resources语句自动关闭输出流，避免资源泄露：
  2. try (PrintWriter out = response.getWriter()) {
  3.     // 使用PrintWriter输出内容
  4.     out.println("<h1>Hello, World!</h1>");
  5. } catch (IOException e) {
  6.     e.printStackTrace();
  7. }
复制代码

3. 合理设置缓冲区

根据输出内容的大小设置合适的缓冲区，提高性能：
  2. // 设置8KB的缓冲区
  3. response.setBufferSize(8192);
  4. PrintWriter out = response.getWriter();
  5. // 输出内容
复制代码

4. 使用工具类封装常用操作

创建工具类封装常用的输出操作，提高代码复用性：
  2. public class ServletOutputUtils {
  3.    
  4.     // 输出JSON响应
  5.     public static void writeJson(HttpServletResponse response, Object data) throws IOException {
  6.         response.setContentType("application/json;charset=UTF-8");
  7.         try (PrintWriter out = response.getWriter()) {
  8.             Gson gson = new Gson();
  9.             out.println(gson.toJson(data));
  10.         }
  11.     }
  12.    
  13.     // 输出错误响应
  14.     public static void writeError(HttpServletResponse response, int statusCode, String message) throws IOException {
  15.         response.setStatus(statusCode);
  16.         response.setContentType("application/json;charset=UTF-8");
  17.         try (PrintWriter out = response.getWriter()) {
  18.             JsonObject error = new JsonObject();
  19.             error.addProperty("status", statusCode);
  20.             error.addProperty("message", message);
  21.             out.println(error.toString());
  22.         }
  23.     }
  24.    
  25.     // 输出文件下载
  26.     public static void writeFileDownload(HttpServletResponse response, String filePath, String fileName) throws IOException {
  27.         File downloadFile = new File(filePath);
  28.         if (!downloadFile.exists()) {
  29.             writeError(response, HttpServletResponse.SC_NOT_FOUND, "文件不存在");
  30.             return;
  31.         }
  32.         
  33.         // 获取文件扩展名
  34.         String fileExtension = fileName.substring(fileName.lastIndexOf(".")).toLowerCase();
  35.         
  36.         // 根据文件扩展名设置MIME类型
  37.         String mimeType = getMimeType(fileExtension);
  38.         response.setContentType(mimeType);
  39.         response.setHeader("Content-Disposition", "attachment;filename="" + fileName + """);
  40.         response.setContentLength((int) downloadFile.length());
  41.         
  42.         // 输出文件内容
  43.         try (ServletOutputStream out = response.getOutputStream();
  44.              FileInputStream in = new FileInputStream(downloadFile);
  45.              BufferedInputStream bis = new BufferedInputStream(in)) {
  46.             
  47.             byte[] buffer = new byte[8192];
  48.             int bytesRead;
  49.             
  50.             while ((bytesRead = bis.read(buffer)) != -1) {
  51.                 out.write(buffer, 0, bytesRead);
  52.             }
  53.         }
  54.     }
  55.    
  56.     // 根据文件扩展名获取MIME类型
  57.     private static String getMimeType(String fileExtension) {
  58.         switch (fileExtension.toLowerCase()) {
  59.             case ".pdf": return "application/pdf";
  60.             case ".doc": return "application/msword";
  61.             case ".docx": return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
  62.             case ".xls": return "application/vnd.ms-excel";
  63.             case ".xlsx": return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
  64.             case ".jpg":
  65.             case ".jpeg": return "image/jpeg";
  66.             case ".png": return "image/png";
  67.             case ".gif": return "image/gif";
  68.             case ".txt": return "text/plain";
  69.             case ".zip": return "application/zip";
  70.             case ".mp3": return "audio/mpeg";
  71.             case ".mp4": return "video/mp4";
  72.             default: return "application/octet-stream";
  73.         }
  74.     }
  75. }
复制代码

5. 使用MVC框架简化输出

考虑使用Spring MVC等框架简化输出操作：
  2. @Controller
  3. public class UserController {
  4.    
  5.     // 返回JSON数据
  6.     @GetMapping("/api/users")
  7.     @ResponseBody
  8.     public List<User> getUsers() {
  9.         return userService.getAllUsers();
  10.     }
  11.    
  12.     // 返回HTML视图
  13.     @GetMapping("/users")
  14.     public String getUsersView(Model model) {
  15.         model.addAttribute("users", userService.getAllUsers());
  16.         return "userList";  // 返回视图名称
  17.     }
  18.    
  19.     // 下载文件
  20.     @GetMapping("/download/{fileName}")
  21.     public ResponseEntity<Resource> downloadFile(@PathVariable String fileName) {
  22.         Resource resource = fileService.loadFileAsResource(fileName);
  23.         
  24.         return ResponseEntity.ok()
  25.                 .contentType(MediaType.APPLICATION_OCTET_STREAM)
  26.                 .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename="" + resource.getFilename() + """)
  27.                 .body(resource);
  28.     }
  29. }
复制代码

6. 使用异步Servlet处理长时间运行的任务

对于长时间运行的任务，使用异步Servlet避免阻塞容器线程：
  2. @WebServlet("/asyncReport")
  3. public class AsyncReportServlet extends HttpServlet {
  4.     private static final long serialVersionUID = 1L;
  5.    
  6.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
  7.             throws ServletException, IOException {
  8.         
  9.         // 启用异步支持
  10.         AsyncContext asyncContext = request.startAsync();
  11.         
  12.         // 设置超时时间
  13.         asyncContext.setTimeout(30000);  // 30秒
  14.         
  15.         // 在新线程中执行长时间运行的任务
  16.         ExecutorService executor = (ExecutorService) request.getServletContext()
  17.                 .getAttribute("executorService");
  18.         
  19.         executor.submit(() -> {
  20.             try {
  21.                 // 生成报告
  22.                 generateReport(asyncContext);
  23.             } catch (Exception e) {
  24.                 e.printStackTrace();
  25.                 asyncContext.complete();
  26.             }
  27.         });
  28.     }
  29.    
  30.     private void generateReport(AsyncContext asyncContext) {
  31.         HttpServletRequest request = (HttpServletRequest) asyncContext.getRequest();
  32.         HttpServletResponse response = (HttpServletResponse) asyncContext.getResponse();
  33.         
  34.         try {
  35.             // 设置响应内容类型
  36.             response.setContentType("application/vnd.ms-excel");
  37.             response.setHeader("Content-Disposition", "attachment;filename="report.xlsx"");
  38.             
  39.             // 获取输出流
  40.             try (ServletOutputStream out = response.getOutputStream();
  41.                  Workbook workbook = new XSSFWorkbook()) {
  42.                
  43.                 // 创建工作表
  44.                 Sheet sheet = workbook.createSheet("报告");
  45.                
  46.                 // 生成报告数据...
  47.                
  48.                 // 将Excel写入输出流
  49.                 workbook.write(out);
  50.             }
  51.         } catch (IOException e) {
  52.             e.printStackTrace();
  53.             try {
  54.                 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "生成报告时出错");
  55.             } catch (IOException ex) {
  56.                 ex.printStackTrace();
  57.             }
  58.         } finally {
  59.             // 完成异步处理
  60.             asyncContext.complete();
  61.         }
  62.     }
  63. }
复制代码

总结

Servlet输出语句是Java Web开发中的基础且重要的部分。通过本文的介绍，我们深入了解了PrintWriter和OutputStream两种输出方式的特点、使用方法和适用场景。

PrintWriter主要用于输出文本数据，提供了方便的文本输出方法，如print()、println()和printf()，适合输出HTML、XML、JSON等文本内容。而OutputStream主要用于输出二进制数据，适合输出图片、音频、视频、PDF等非文本内容。

在使用Servlet输出语句时，需要注意以下几点：

1. 根据输出内容的类型选择合适的输出方式。
2. 正确处理字符编码，避免中文乱码问题。
3. 合理使用缓冲区，提高性能。
4. 正确关闭输出流，避免资源泄露。
5. 不要在同一个响应中同时使用PrintWriter和OutputStream。
6. 在输出内容之前设置所有必要的响应头。

通过遵循这些最佳实践，并结合本文提供的实用技巧和常见问题解决方案，开发者可以更加高效、稳定地使用Servlet输出语句，构建出功能强大、性能优良的Java Web应用。
扮演着, 二进制
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则