Servlet3.0中Servlet的使用

时间 2019-11-07

标签 servlet3.0 servlet 使用栏目 Tomcat 繁體版

原文原文链接

目录html

1.注解配置java

2.异步调用web

3.文件上传数组

相对于以前的版本，Servlet3.0中的Servlet有如下改进：app

支持注解配置。异步
支持异步调用。async
直接有对文件上传的支持。ide

在这篇文章中我将主要讲这三方面的应用示例。post

1.注解配置

在以往咱们的Servlet都须要在web.xml文件中进行配置（Servlet3.0一样支持），可是在Servlet3.0中引入了注解，咱们只须要在对应的Servlet类上使用@WebServlet注解进行标记，咱们的应用启动以后就能够访问到该Servlet。对于一个@WebServlet而言，有一个属性是必需要的，那就是它的访问路径。@WebServlet中有两个属性能够用来表示Servlet的访问路径，分别是value和urlPatterns。value和urlPatterns都是数组形式，表示咱们能够把一个Servlet映射到多个访问路径，可是value和urlPatterns不能同时使用。若是同时使用了value和urlPatterns，咱们的Servlet是没法访问到的。下面是一个使用@WebServlet的简单Servlet示例。this

 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 *
 * Servlet3.0支持使用注解配置Servlet。咱们只需在Servlet对应的类上使用@WebServlet进行标注，
 * 咱们就能够访问到该Servlet了，而不须要再在web.xml文件中进行配置。@WebServlet的urlPatterns
 * 和value属性均可以用来表示Servlet的部署路径，它们都是对应的一个数组。
 */
@WebServlet(name="exampleServlet", urlPatterns="/servlet/example")
public class ExampleServlet extends HttpServlet {
 
   private static final long serialVersionUID = 1L;
 
   @Override
   protected void doGet(HttpServletRequest request,
         HttpServletResponse response) throws ServletException, IOException {
      this.doPost(request, response);
   }
 
   @Override
   protected void doPost(HttpServletRequest request,
         HttpServletResponse response) throws ServletException, IOException {
      response.getWriter().write("Hello User.");
   }
 
}

初始化参数

使用@WebServlet时也能够配置初始化参数，它是经过@WebServlet的initParams参数来指定的。initParams是一个@WebInitParam数组，每个@WebInitParam表明一个初始化参数。

 
import java.io.IOException;
import java.util.Enumeration;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * 带初始化参数的Servlet
 * WebServlet的属性initParams能够用来指定当前Servlet的初始化参数，它是一个数组，
 * 里面每个@WebInitParam表示一个参数。
 */
@WebServlet(value="/servlet/init-param", initParams={@WebInitParam(name="param1", value="value1")})
public class WebInitParamServlet extends HttpServlet {
 
   /**
    *
    */
   private static final long serialVersionUID = 1L;
 
   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      this.doPost(req, resp);
   }
 
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      Enumeration<String> paramNames = this.getServletConfig().getInitParameterNames();
      String paramName;
      while (paramNames.hasMoreElements()) {
         paramName = paramNames.nextElement();
         resp.getWriter().append(paramName + " = " + this.getServletConfig().getInitParameter(paramName));
      }
      resp.getWriter().close();
   }
  
}

2.异步调用

在Servlet3.0中，在Servlet内部支持异步处理。它的逻辑是当咱们请求一个Servlet时，咱们的Servlet能够先返回一部份内容给客户端。而后在Servlet内部异步处理另一段逻辑，等到异步处理完成以后，再把异步处理的结果返回给客户端。这意味着当咱们的Servlet在处理一段比较费时的业务逻辑时，咱们能够先返回一部分信息给客户端，而后异步处理费时的业务，而没必要让客户端一直等待全部的业务逻辑处理完。等到异步处理完以后，再把对应的处理结果返回给客户端。

异步调用是经过当前HttpServletRequest的startAsync()方法开始的，它返回一个AsyncContext。以后咱们能够调用AsyncContext的start()方法来新起一个线程进行异步调用。在新线程内部程序的最后咱们最好是调用一下当前AsyncContext的complete()方法，不然异步调用的结果须要等到设置的超时时间事后才会返回到客户端。另外当异步调用超时之后会接着调用异步任务，即新起的线程。

 
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * 支持异步返回的Servlet
 * 对于Servlet的异步返回，首先咱们必须指定@WebServlet的asyncSupported属性为true（默认是false），同时在它以前的Filter
 * 的asyncSupported属性也必须是true，不然传递过来的request就是不支持异步调用的。
 *
 */
@WebServlet(value="/servlet/async", asyncSupported=true)
public class AsyncServlet extends HttpServlet {
 
   /**
    *
    */
   private static final long serialVersionUID = 1L;
 
   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      this.doPost(req, resp);
   }
 
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      resp.setContentType("text/plain;charset=UTF-8");
      final PrintWriter writer = resp.getWriter();
      writer.println("异步以前输出的内容。");
      writer.flush();
      //开始异步调用，获取对应的AsyncContext。
      final AsyncContext asyncContext = req.startAsync();
      //设置超时时间，当超时以后程序会尝试从新执行异步任务，即咱们新起的线程。
      asyncContext.setTimeout(10*1000L);
      //新起线程开始异步调用，start方法不是阻塞式的，它会新起一个线程来启动Runnable接口，以后主程序会继续执行
      asyncContext.start(new Runnable() {
 
         @Override
         public void run() {
            try {
                Thread.sleep(5*1000L);
                writer.println("异步调用以后输出的内容。");
                writer.flush();
                //异步调用完成，若是异步调用完成后不调用complete()方法的话，异步调用的结果须要等到设置的超时
                //时间过了以后才能返回到客户端。
                asyncContext.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }
         }
        
      });
      writer.println("可能在异步调用前输出，也可能在异步调用以后输出，由于异步调用会新起一个线程。");
      writer.flush();
   }
 
}

对于一个Servlet若是要支持异步调用的话咱们必须指定其asyncSupported属性为true（默认是false）。使用@WebServlet注解标注的Servlet咱们能够直接指定其asyncSupported属性的值为true，如：

@WebServlet(value=”/servlet/async”, asyncSupported=true)。而对于在web.xml文件中进行配置的Servlet来讲，咱们须要在配置的时候指定其asyncSupported属性为true。

   <servlet>
      <servlet-name>xxx</servlet-name>
      <servlet-class>xxx</servlet-class>
      <async-supported>true</async-supported>
   </servlet>
   <servlet-mapping>
      <servlet-name>xxx</servlet-name>
      <url-pattern>xxx</url-pattern>
   </servlet-mapping>

Servlet的异步调用程序的关键是要调用当前HttpServletRequest的startAsync()方法。至于利用返回的AsyncContext来新起一个线程进行异步处理就不是那么的必须了，由于在HttpServletRequest startAsync()以后，咱们能够本身新起线程进行异步处理。

@WebServlet(value="/servlet/async", asyncSupported=true)
public class AsyncServlet extends HttpServlet {
 
   /**
    *
    */
   private static final long serialVersionUID = 1L;
 
   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      this.doPost(req, resp);
   }
 
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      resp.setContentType("text/plain;charset=UTF-8");
      final PrintWriter writer = resp.getWriter();
      writer.println("异步以前输出的内容。");
      writer.flush();
      //开始异步调用，获取对应的AsyncContext。
      final AsyncContext asyncContext = req.startAsync();
      //设置超时时间，当超时以后程序会尝试从新执行异步任务，即咱们新起的线程。
      asyncContext.setTimeout(10*1000L);
      Runnable r = new Runnable() {
         @Override
         public void run() {
            try {
                Thread.sleep(5*1000L);
                writer.println("异步调用以后输出的内容。");
                writer.flush();
                //异步调用完成
                asyncContext.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }
         } 
      };
      Thread t = new Thread(r);
      //开启本身的线程进行异步处理
      t.start();
      writer.println("可能在异步调用前输出，也可能在异步调用以后输出，由于异步调用会新起一个线程。");
      writer.flush();
   }
  
}

异步调用监听器

当咱们须要对异步调用作一个详细的监听的时候，好比监听它是否超时，咱们能够经过给AsyncContext设置对应的监听器AsyncListener来实现这一功能。AsyncListener是一个接口，里面定义了四个方法，分别是针对于异步调用开始、结束、出错和超时的。

import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * 支持异步返回的Servlet
 * 对于Servlet的异步返回，首先咱们必须指定@WebServlet的asyncSupported属性为true（默认是false），同时在它以前的Filter
 * 的asyncSupported属性也必须是true，不然传递过来的request就是不支持异步调用的。
 *
 */
@WebServlet(value="/servlet/async2", asyncSupported=true)
public class AsyncServlet2 extends HttpServlet {
 
   /**
    *
    */
   private static final long serialVersionUID = 1L;
 
   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      this.doPost(req, resp);
   }
 
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      resp.setContentType("text/plain;charset=UTF-8");
      final PrintWriter writer = resp.getWriter();
      writer.println("异步以前输出的内容。");
      writer.flush();
      //开始异步调用，获取对应的AsyncContext。
      final AsyncContext asyncContext = req.startAsync();
      //设置当前异步调用对应的监听器
      asyncContext.addListener(new MyAsyncListener());
      //设置超时时间，当超时以后程序会尝试从新执行异步任务，即咱们新起的线程。
      asyncContext.setTimeout(10*1000L);
      //新起线程开始异步调用，start方法不是阻塞式的，它会新起一个线程来启动Runnable接口，以后主程序会继续执行
      asyncContext.start(new Runnable() {
 
         @Override
         public void run() {
            try {
                Thread.sleep(5*1000L);
                writer.println("异步调用以后输出的内容。");
                writer.flush();
                //异步调用完成
                asyncContext.complete();
            } catch (Exception e) {
                e.printStackTrace();
            }
         }
        
      });
      writer.println("可能在异步调用前输出，也可能在异步调用以后输出，由于异步调用会新起一个线程。");
      writer.flush();
   }
 
   /**
    * 异步调用对应的监听器
    * @author Yeelim
    * @date 2014-2-8
    * @mail yeelim-zhang@todaytech.com.cn
    */
   private class MyAsyncListener implements AsyncListener {
 
      @Override
      public void onComplete(AsyncEvent event) throws IOException {
         System.out.println("异步调用完成……");
         event.getSuppliedResponse().getWriter().println("异步调用完成……");
      }
 
      @Override
      public void onError(AsyncEvent event) throws IOException {
         System.out.println("异步调用出错……");
         event.getSuppliedResponse().getWriter().println("异步调用出错……");
      }
 
      @Override
      public void onStartAsync(AsyncEvent event) throws IOException {
         System.out.println("异步调用开始……");
         event.getSuppliedResponse().getWriter().println("异步调用开始……");
      }
 
      @Override
      public void onTimeout(AsyncEvent event) throws IOException {
         System.out.println("异步调用超时……");
         event.getSuppliedResponse().getWriter().println("异步调用超时……");
      }
     
   }
  
}

注：

对于正常执行的异步调用而言上述代码中开始是没有监听到的，只有在异步调用超时，从新执行异步任务的时候才有监听到异步调用的开始。不过若是须要监听异步第一次开始的话，咱们能够在异步调用开始的时候作相应的监听器监听到异步调用开始时须要作的内容。

3.文件上传

在Servlet3.0中上传文件变得很是简单。咱们只需经过request的getPart(String partName)获取到上传的对应文件对应的Part或者经过getParts()方法获取到全部上传文件对应的Part。以后咱们就能够经过part的write(String fileName)方法把对应文件写入到磁盘。或者经过part的getInputStream()方法获取文件对应的输入流，而后再对该输入流进行操做。要使用request的getPart()或getParts()方法对上传的文件进行操做的话，有两个要注意的地方。首先，用于上传文件的form表单的enctype必须为multipart/form-data；其次，对于使用注解声明的Servlet，咱们必须在其对应类上使用@MultipartConfig进行标注，而对于在web.xml文件进行配置的Servlet咱们也须要指定其multipart-config属性，如：

   <servlet>
      <servlet-name>xxx</servlet-name>
      <servlet-class>xxx.xxx</servlet-class>
      <multipart-config></multipart-config>
   </servlet>
   <servlet-mapping>
      <servlet-name>xxx</servlet-name>
      <url-pattern>/servlet/xxx</url-pattern>
   </servlet-mapping>

无论是基于注解的@MultipartConfig，仍是基于web.xml文件配置的multipart-config，咱们均可以给它们设置几个属性。

file-size-threshold：数字类型，当文件大小超过指定的大小后将写入到硬盘上。默认是0，表示全部大小的文件上传后都会做为一个临时文件写入到硬盘上。
location：指定上传文件存放的目录。当咱们指定了location后，咱们在调用Part的write(String fileName)方法把文件写入到硬盘的时候能够，文件名称能够不用带路径，可是若是fileName带了绝对路径，那将以fileName所带路径为准把文件写入磁盘。
max-file-size：数值类型，表示单个文件的最大大小。默认为-1，表示不限制。当有单个文件的大小超过了max-file-size指定的值时将抛出IllegalStateException异常。
max-request-size：数值类型，表示一次上传文件的最大大小。默认为-1，表示不限制。当上传时全部文件的大小超过了max-request-size时也将抛出IllegalStateException异常。

上面的属性是针对于web.xml中配置Servlet而言的，其中的每个属性都对应了multipart-config元素下的一个子元素。对于基于注解配置的Servlet而言，@MultipartConfig的属性是类型的，咱们只需把上述对应属性中间的杠去掉，而后把对应字母大写便可，如maxFileSize。

下面给出Servlet3.0中文件上传的一个示例。

Html：

<form method="post" action="servlet/upload" enctype="multipart/form-data">
   <input type="file" name="upload"/>
   <input type="submit" value="upload"/>
</form>

对应Servlet：

@WebServlet("/servlet/upload")
@MultipartConfig
public class FileUploadServlet extends HttpServlet {
 
   /**
    *
    */
   private static final long serialVersionUID = 1L;
 
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      req.setCharacterEncoding("UTF-8");
      Part part = req.getPart("upload");
      //格式如：form-data; name="upload"; filename="YNote.exe"
      String disposition = part.getHeader("content-disposition");
      System.out.println(disposition);
      String fileName = disposition.substring(disposition.lastIndexOf("=")+2, disposition.length()-1);
      String fileType = part.getContentType();
      long fileSize = part.getSize();
      System.out.println("fileName: " + fileName);
      System.out.println("fileType: " + fileType);
      System.out.println("fileSize: " + fileSize);
      String uploadPath = req.getServletContext().getRealPath("/upload");
      System.out.println("uploadPath" + uploadPath);
      part.write(uploadPath + File.separator +fileName);
   }
  
}

对于Servlet3.0中的文件上传还有一个须要注意的地方，当咱们把Part写入到硬盘之后，咱们原先的Part（也就是以前的临时文件）可能已经删了，这个时候若是咱们再次去访问Part的内容的话，那它就是空的，系统会抛出异常说找不到对应的文件。