Java Web基础 --- Servlet 综述(实践篇)

﹏ヽ暗。殇╰゛Y 2022-05-23 04:57 155阅读 0赞

摘要：

伴随 J2EE 6一起发布的Servlet 3.0规范是Servlet规范历史上最重要的变革之一，它的许多新的特性都极大的简化了 Java Web 应用的开发。本文从一个简单的 Servlet 例子开始，说明了如何开发、配置一个 Servlet。此外，还重点叙述了Servlet的一些新特性，包括Servlet 异步处理、Servlet 非阻塞IO 以及 Servlet 文件上传等内容，以便我们对Servlet有一个更全面的了解。

--------------------

本篇主要介绍 Servlet 实践方面的知识，更多关注于Servlet的新特性：

*  Servlet 实例；
 *  Servlet 配置；
 *  Servlet 异步处理；
 *  Servlet 非阻塞IO；
 *  Servlet 文件上传。

--------------------

更多关于Servlet理论方面的介绍见我的上一篇博文[《Servlet 综述(理论篇)》][Servlet]，其具体包括以下几个方面的内容：

*  为什么会有 Servlet；
 *  Servlet 是什么；
 *  Servlet 如何实现预期效果；
 *  Servlet 的作用原理；
 *  Servlet 与 并发；
 *  Servlet 与 Java Web 应用的结构演变历程；
 *  Servlet 与 MVC 的联系。

--------------------

本文原创作者：[书呆子Rico][Rico]   
作者博客地址：[http://blog.csdn.net/justloveyou\_/][http_blog.csdn.net_justloveyou]

--------------------

## 一. 从一个简单的 Servlet 例子说起 ##

我们看下面这个简单的示例：

Servlet:

public class TestServlet extends HttpServlet { 
    
        private static final long serialVersionUID = 1L;
    
        @Override
        protected void doGet(HttpServletRequest request,
                HttpServletResponse response)
                throws ServletException, IOException {
    
            //获取请求参数
            String param1 = request.getParameter("name");
            String param2 = request.getParameter("gentle");
    
            //获取Servlet参数并放到request中
            String age = this.getServletConfig().getInitParameter("age");
            request.setAttribute("age",age);
    
    
            // 此处进行业务逻辑处理
    
    
            //根据处理结果转发到相应的表现层进行显示
            request.getRequestDispatcher("/showInfo.jsp").forward(request, response);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp)
                throws ServletException, IOException {
            doGet(req, resp);
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31

--------------------

web.xml 配置文件片段:

<context-param>
        <param-name>campus</param-name>
        <param-value>NEU</param-value>
    </context-param>
    <servlet>
        <servlet-name>TestServlet</servlet-name>
        <servlet-class>com.edu.tju.rico.servlet.TestServlet</servlet-class>
        <init-param>
            <param-name>age</param-name>
            <param-value>24</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>TestServlet</servlet-name>
        <url-pattern>/servlet/test</url-pattern>
    </servlet-mapping>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16

--------------------

显示逻辑:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    
    <html>
    <head>
    <title>showInfo</title>
    </head>
    <body>
        请求参数： Name：  <%= request.getParameter("name")%><br>
        Gentle：  <%= request.getParameter("gentle")%><br>
        <br> 
        ----------------我是分割线--------------------<br> 
        <br> 
        Web应用初始化参数：   <%= application.getInitParameter("campus")%><br>
        <br> 
        ----------------我是分割线--------------------<br> 
        <br> 
        TestServlet 初始化参数：   ${requestScope.age}<br>
        <br>
    </body>
    </html>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20

开发一个Servlet程序时，如果其是基于HTTP协议的，那么我们一般继承 HttPServlet 抽象类并重写 doGet() 和 doPost() 方法，或者直接重写 service() 方法去处理Http请求。

更多关于 JSP技术的细节见我的其他两篇博客：[ 《Java Web基础 — Jsp 综述(上)》][Java Web_ _ Jsp] 和 [《Java Web基础 — Jsp 综述(下)》][Java Web_ _ Jsp 1]。

--------------------

## 二. Servlet 的配置 ##

为了让 Servlet 能够响应用户请求，还必须将 Servlet 配置到我们的Web应用中。进一步地，如果我们没有为Servlet配置URL，那么该Servlet将不能响应用户请求。从 J2EE 6 (Servlet 3.0) 开始，配置 Servlet 的方式共有两种：

*  在 web.xml 中进行配置；
 *  在对应的Servlet类中使用@WebServlet注解进行配置。

--------------------

我们在这里主要说明使用@WebServlet注解进行配置Servlet，使用 web.xml 配置的方法与该种方式只是在形式不同，作用方式是一样的，此不赘述。

一旦我们使用 @WebServlet 配置了Servlet，那我们就不用在 web.xml 进行再次配置了，并且不能在web.xml中将 metadata-complete 属性设置为true。 支持的常用属性如下表所示：

<table style="border-spacing:0px;width:852px;text-align:center;color:rgb(51,51,51);font-family:'-apple-system', 'SF UI Text', Arial, 'PingFang SC', 'Hiragino Sans GB', 'Microsoft YaHei', 'WenQuanYi Micro Hei', sans-serif, SimHei, SimSun;font-size:14px;background-color:rgb(255,255,255);"> 
 <tbody> 
  <tr> 
   <th style="margin:0px;vertical-align:middle;">属性名</th> 
   <th style="margin:0px;vertical-align:middle;">是否必需</th> 
   <th style="margin:0px;vertical-align:middle;">类型</th> 
   <th style="margin:0px;vertical-align:middle;">描述</th> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">name</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">String</td> 
   <td style="margin:0px;vertical-align:middle;">指定 Servlet 的 name 属性，等价于&lt;servlet-name&gt;标签，默认取值为Servlet类的全限定名</td> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">value</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">String[]</td> 
   <td style="margin:0px;vertical-align:middle;">该属性等价于 urlPatterns 属性，这两个属性不能同时使用</td> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">loadOnStartup</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">int</td> 
   <td style="margin:0px;vertical-align:middle;">指定Servlet的加载时机和顺序，等价于&lt;load-on-startup&gt;标签</td> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">initParam</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">WebInitParam[]</td> 
   <td style="margin:0px;vertical-align:middle;">指定一组 Servlet 初始化参数，等价于&lt;init-param&gt;标签</td> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">asyncSupported</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">boolean</td> 
   <td style="margin:0px;vertical-align:middle;">声明 Servlet 是否支持异步操作模式，等价于&lt;async-supported&gt;标签</td> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">description</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">String</td> 
   <td style="margin:0px;vertical-align:middle;">该Servlet的描述信息，等价于&lt;description&gt;标签</td> 
  </tr> 
  <tr> 
   <td style="margin:0px;vertical-align:middle;">displayName</td> 
   <td style="margin:0px;vertical-align:middle;">否</td> 
   <td style="margin:0px;vertical-align:middle;">String</td> 
   <td style="margin:0px;vertical-align:middle;">该Servlet的显示名，通常配合工具使用，等价于&lt;display-name&gt;标签</td> 
  </tr> 
 </tbody> 
</table>

将上述示例使用@WebServlet注解配置，如下：

@WebServlet(name = "Test", 
        urlPatterns = { "/servlet/test" }, 
        initParams = { @WebInitParam(name = "age", value = "24") })
    public class TestServlet extends HttpServlet { 
        ...
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

--------------------

## 三. Servlet的新特性：异步处理 ##

1、Servlet 不支持异步处理会带来哪些痛点？

在本篇的姊妹篇《Java Web基础 — Servlet 综述(实践篇)》中，我们已经提到Servlet容器处理请求的方式。对于每个到达Web容器的请求，Web容器会为其分配一条执行线程来专门负责该请求，直到回应完成前，该执行线程都不会被释放回Web容器的线程池。 我们知道，执行线程会耗用系统资源，若某些请求需要长时间处理（例如长时间运算、等待某个资源），就会长时间占用执行线程，若这类的请求很多，许多执行线程都被长时间占用，对于整个系统而言就会是个性能负担，甚至造成应用的性能瓶颈。

特别地，基本上一些需长时间处理的请求，通常客户端也较不在乎请求后要有立即的回应，若可以，让这类请求先释放容器分配给该请求的执行线程，让容器可以有机会将执行线程资源分配给其它的请求，这样可以减轻系统负担。这样，原先释放了容器所分配执行线程的请求，其回应将被延后，直到处理完成（例如长时间运算完成、所需资源已获得）再行对客户端的回应。

--------------------

2、如何使用 Servlet 3.0 去支持对耗时事务的异步处理？

1)、Servlet 3.0 对异步处理的支持

在 Servlet 3.0 之前的规范中，如果Servlet作为控制器调用了一个耗时的业务方法，那么 Servlet 必须等到业务方法完全返回之后才能生成响应，这使得 Servlet 对业务方法的调用是一种阻塞式调用，因此效率比较低。Servlet 3.0 规范引入了异步处理来解决问题，异步处理允许Servlet重新发起一个线程去调用耗时的业务方法，这样就可以避免等待。

Servlet 3.0 的异步处理是通过 AsyncContext 类来处理的，Servlet 可以通过 ServletRequest 的如下两个方法开启异步调用、创建 AsyncContext 对象。在这里，AsyncContext 对象代表异步处理的上下文。

*  AsyncContext startAsync()
 *  AsyncContext startAsync(ServletRequest，ServletRequest)

--------------------

这两个方法都会返回 AsyncContext 对象，前者会直接利用原有的请求与响应对象来创建AsyncContext对象，后者则允许你传入自行创建的请求、响应对象。 在调用了startAsync()方法取得AsyncContext对象之后，这次的响应就会被延后，并释放容器所分配的执行线程。

我们可以通过AsyncContext的getRequest()、 getResponse()方法取得请求、响应对象，此次对客户端的响应将暂缓至调用AsyncContext的complete()方法或dispatch()方法为止，前者表示响应完成，后者表示将调用指定URL对应的内容进行响应。特别需要注意的是，dispatch()前后仍是同一个请求，并且被异步请求dispatch的目标页面必须指定：session=”false”。如果我们要支持 Servlet 的异步处理，我们的 Servlet 就必须能够支持非同步处理。也就是说，如果我们使用@WebServlet来标注的话，则必须将其asyncSupported属性设为true，如下所示：

@WebServlet(urlPatterns = "/some.do", asyncSupported = true )   
    public class AsyncServlet extends HttpServlet {    
    ...  
    }

*  1
 *  2
 *  3
 *  4

特别需要注意的是，如果Servlet将支持非同步处理，并且其前端有过滤器，那么过滤器也必须表明其支持非同步处理，如果使用@WebFilter注解的方式，同样是需要设定其asyncSupported属性为true，如下所示：

@WebFilter(urlPatterns = "/some.do", asyncSupported = true )   
    public class AsyncFilter implements Filter{    
    ...
    }

*  1
 *  2
 *  3
 *  4

--------------------

2)、异步处理实例

(1) 进行异步处理的Servlet类：

@WebServlet(urlPatterns = "/async",asyncSupported=true )
    public class AsyncServlet extends HttpServlet { 
    
        private static final long serialVersionUID = 1L;
    
        @Override
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws IOException, ServletException {
            request.setAttribute("param1", "我在异步处理前被设置...");
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
            out.println("<title>异步调用示例</title>");
            out.println("进入Servlet的时间：" + new java.util.Date() + ".<br/>");
    
            //创建AsyncContext对象，开始异步调用
            final AsyncContext async = request.startAsync();  // 在局部(匿名)内部类直接使用，必须设为 final
    
            // 设置异步调用的请求时长
            async.setTimeout(10 * 1000);
    
            // 启动线程去处理耗时任务
            async.start(new Runnable() {   // 匿名内部类
    
                @Override
                public void run() {
                    try {
                        Thread.sleep(5000);
                        HttpServletRequest req = (HttpServletRequest) async
                                .getRequest();
                        req.setAttribute("param2", "我在耗时任务处理线程中被设置...");
                        async.dispatch("/async.jsp");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            out.println("结束Servlet的时间：" + new java.util.Date() + ".<br/>");
            out.flush();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp)
                throws ServletException, IOException {
            doGet(req, resp);
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46

--------------------

(2) 表现层：

<%-- 被异步请求dispatch的目标页面必须指定：session="false" --%>
    <%@ page contentType="text/html; charset=utf-8" language="java" session="false"%>
    <div style="background-color:#ffffdd;height:80px;">
        param1：${ param1}<br />
        param2：${ param2}<br />
    
        <%
            out.println("业务调用结束的时间：" + new java.util.Date());
        %>
    </div>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10

--------------------

(3) 结果展示页面

![Servlet异步处理.png-33.6kB][Servlet_.png-33.6kB]

--------------------

四、Servlet 3.1 支持非阻塞 IO

1、Servlet 不支持非阻塞 IO会带来哪些痛点？

Servlet 3.0 允许异步请求处理，但仅限于传统I/O，这大大限制了程序的可扩展性。我们知道，在应用程序中，一种典型的做法是，通过while循环读取Servlet输入流（Servlet InputStream），如下所示：

public class TestServlet extends HttpServlet { 
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
             throws IOException, ServletException {     
     ServletInputStream input = request.getInputStream();
           byte[] b = new byte[1024];
           int len = -1;
           while ((len = input.read(b)) != -1) {
              . . . 
           }
       }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11

事实上，Servlet 底层的 IO 是通过以下两个 IO 流支撑的：

*  ServletInputStream：Servlet 用于读取数据的输入流；
 *  ServletOutputStream：Servlet 用于输出数据的输出流。

--------------------

以 Servlet 读取数据为例，传统的读取方式采用阻塞式IO —— 当Servlet读取浏览器提交的数据时，如果数据暂时不可用，或者数据没有读取完成，Servlet当前所有线程将会被阻塞，无法继续执行下去。另外，如果传入的数据受到阻塞或流传输的速度慢于服务器读取的速度，则服务器线程就需要一直等待数据的到来。同样的情形在向Servlet输出流（Servlet OutputStream）写数据的时候也会出现。Servlet 3.1 提供的非阻塞IO进行输入、输出，可以更好地提升性能。

--------------------

2、如何使用 Servlet 3.0 去支持非阻塞 IO？

上述问题可以通过添加Servlet 3.1（JSR 340，作为Java EE7发布的一部分）提供的事件监听器ReadListener和WriteListener接口进行解决。通过 ServletInputStream.setReadListener 和 ServletOutputStream.setWriteListener 可以注册监听器。监听器中提供了一些回调方法，在数据读写不受阻塞的时候进行触发。以 ReadListener 为例，实现ReadListener事件监听器需要实现如下三个方法：

*  onDataAvailable()：当有数据可用时激发该方法；
 *  onAllDataRead()：当所有数据读取完成时激发该方法；
 *  onError(Throwable t)：读取数据出现错误时激发该方法。

--------------------

1)、Servlet 3.1 使用非阻塞IO步骤

在 Servlet 3.1 中使用非阻塞IO步骤可分为三步：

(1) 调用 ServletRequest 的startAsync()方法开启异步处理模式；   
(2) 通过 ServletRequest 获取 ServletInputStream，并为 ServletInputStream 设置监听器（ReadListener 实现类）；   
(3) 实现 ReadListener 接口来实现监听器，在该监听器的方法中以非阻塞方式读取数据。

改进后的doGet方法如下所示：

AsyncContext context = request.startAsync();
    ServletInputStream input = request.getInputStream();
    input.setReadListener(new MyReadListener(input, context));

*  1
 *  2
 *  3

setXXXListner方法指出采用非阻塞I/O而不是传统I/O。onReadListener可以通过ServletInputStream进行注册，同样地，oneWritelistener可以通过ServletOutputStream进行注册。特别地，新增加的ServletInputStream.isReady方法和ServletInputStream.isFinished方法用于检测非阻塞I/O的读取状态，而ServletOutputStream.canWrite方法用于检测数据是否能够无阻塞地写入。

--------------------

2)、Servlet 3.1 使用非阻塞IO实例

(1) 请求提交表单 form.html：

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15

--------------------

(2) 在 Servlet中使用非阻塞IO：

@WebServlet(urlPatterns = "/async",asyncSupported=true )
    public class AsyncServlet extends HttpServlet { 
    
        @Override
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws IOException, ServletException {
            request.setAttribute("param1", "我在异步处理前被设置...");
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
            out.println("<title>非阻塞IO示例</title>");
            out.println("进入Servlet的时间：" + new java.util.Date() + ".<br/>");
    
            //创建AsyncContext对象，开始异步调用
            final AsyncContext async = request.startAsync();
    
            // 设置异步调用的请求时长
            async.setTimeout(10 * 1000);
            final ServletInputStream input = request.getInputStream();
    
            // 为输入流注册监听器
            input.setReadListener(new ReadListener() {
    
                @Override
                public void onError(Throwable t) {
                    t.printStackTrace();
                }
    
                @Override
                public void onDataAvailable() throws IOException {
                    System.out.println("数据可用！！");
                    try
                    {
                        // 暂停5秒，模拟读取数据是一个耗时操作。
                        Thread.sleep(5000);
                        StringBuilder sb = new StringBuilder();
                        int len = -1;
                        byte[] buff = new byte[1024];
                        // 采用原始IO方式读取浏览器向Servlet提交的数据
                        while (input.isReady() && (len = input.read(buff)) > 0)
                        {
                            String data = new String(buff , 0 , len);
                            sb.append(data);
                        }
                        System.out.println(sb);
                        // 将数据设置为request范围的属性
                        async.getRequest().setAttribute("data" , sb.toString());
                        // 转发到视图页面
                        async.dispatch("/asyn.jsp");
                    }
                    catch (Exception ex)
                    {
                        ex.printStackTrace();
                    }
                }
    
                @Override
                public void onAllDataRead() throws IOException {
                    System.out.println("数据读取完成");
                }
            });
    
            out.println("结束Servlet的时间：" + new java.util.Date() + ".<br/>");
            out.flush();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp)
                throws ServletException, IOException {
            doGet(req, resp);
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71

--------------------

(3) 表现层：

<%@ page contentType="text/html; charset=utf-8" language="java" session="false"%>
    <div style="background-color:#ffffdd;height:80px;">
    浏览器提交数据为：${data}<br/>
    <%=new java.util.Date()%>
    </div>

*  1
 *  2
 *  3
 *  4
 *  5

--------------------

(4) 结果展示：

![nio.png-14.3kB][]

更多关于Servlet使用、实践方面的介绍以及Servlet新特性的总结见我的下一篇博文《Servlet 综述(实践篇)》。

--------------------

五、Servlet 3.0 支持文件上传

Servlet 3.0之前的版本中，文件上传是个挺让人头疼的问题，虽然有第三方框架（Apache Commons）来实现，但使用起来还是比较麻烦。在Servlet 3.0中，这些问题将不复存在，Servlet 3.0对文件上传提供了直接支持，配合Servlet 3.0中基于Annotations的配置，大大简化上传件的操作。

在使用表单上传文件时，我们需要使用@MultipartConfig注解去修饰对应的Servlet。此外，我们一方面需要在表单里使用<input type=”file” …/>文件域，另一方面必须要为表单域设置 enctype 属性，其有三个值：

*  application/x-www-form-urlencoded：表单数据被编码为名称/值对，这是默认的编码方式；
 *  multipart/form-data：以二进制流的方式处理表单数据，一般用于传输二进制文件，如图片、视频等；
 *  text/plain：不编码特殊字符，适用于通过表单发送邮件。

--------------------

下面跟进这个例子来体会其给我们带来的便捷。

(1) 文件提交表单：

<%@ page contentType="text/html; charset=utf-8" language="java" errorPage="" %>
    <head>
        <title> 文件上传 </title>
    </head>
    <body>
    <form method="post" action="upload" enctype="multipart/form-data">
        文件名：<input type="text" id="name" name="name" /><br/>
        选择文件：<input type="file" id="file" name="file" /><br/>
        <input type="submit" value="上传" /><br/>
    </form>
    </body>
    </html>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12

--------------------

(2) 文件上传Servlet：

@WebServlet(name="upload" , urlPatterns={
       "/upload"})
    @MultipartConfig
    public class UploadServlet extends HttpServlet { 
        public void service(HttpServletRequest request ,
            HttpServletResponse response)
            throws IOException , ServletException
        {
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
            request.setCharacterEncoding("utf-8");
            // 获取普通请求参数
            String name = request.getParameter("name");
            out.println("普通的name参数为：" + name + "<br/>");
            // 获取文件上传域
            Part part = request.getPart("file");
            // 获取上传文件的文件类型
            out.println("上传文件的的类型为："
                + part.getContentType() + "<br/>");
            //获取上传文件的大小。
            out.println("上传文件的的大小为：" + part.getSize()  + "<br/>");
            // 获取该文件上传域的Header Name
            Collection<String> headerNames = part.getHeaderNames();
            // 遍历文件上传域的Header Name、Value
            for (String headerName : headerNames)
            {
                out.println(headerName + "--->"
                    + part.getHeader(headerName) + "<br/>");
            }
            // 获取包含原始文件名的字符串
            String fileNameInfo = part.getHeader("content-disposition");
            // 提取上传文件的原始文件名
            String fileName = fileNameInfo.substring(
                fileNameInfo.indexOf("filename=\"") + 10 , fileNameInfo.length() - 1);
            // 将上传的文件写入服务器
            part.write(getServletContext().getRealPath("/uploadFiles")
                + "/" + fileName );               // ①
    
            System.out.println(getServletContext().getRealPath("/uploadFiles"));
        }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40

--------------------

(3) 结果展示：

![fileupload.png-11kB][]

--------------------

六、拾遗增补

除上面提到的内容，Servlet 还引入了其他新的特性（如下所述），此不赘述。

*  Servlet 3.0 为 Web 模块化提供了支持；
 *  Servlet 3.1 可以强制更改 Session ID，具体由 HttpServletRequest 的 changeSessionId()方法完成。

[Servlet]: http://blog.csdn.net/justloveyou_/article/details/60964714
[Rico]: http://my.csdn.net/justloveyou_
[http_blog.csdn.net_justloveyou]: http://blog.csdn.net/justloveyou_/
[Java Web_ _ Jsp]: http://blog.csdn.net/justloveyou_/article/details/55824500
[Java Web_ _ Jsp 1]: http://blog.csdn.net/justloveyou_/article/details/57154560
[Servlet_.png-33.6kB]: /images/20220523/dc24dec3683d4697b894c620ec1bd9b1.png
[nio.png-14.3kB]: /images/20220523/c1e1b4d919c84601a3aadb1c56646241.png
[fileupload.png-11kB]: /images/20220523/fcbe5f029dd84b6ab3906fe86e706d79.png