• [转]Servlet 3.0 新特性详解

    原文地址:http://blog.csdn.net/xiazdong/article/details/7208316

    Servlet 3.0 新特性概览

     

    1.Servlet、Filter、Listener无需在web.xml中进行配置，可以通过Annotation进行配置；

    2.模块化编程，即将各个Servlet模块化，将配置文件也分开配置。

    3.Servlet异步处理，应对复杂业务处理；

    4.异步Listener，对于异步处理的创建、完成等进行监听；

    5. 文件上传API简化；

     

    tomcat 7.0.X 支持Servlet 3.0

     

    一、Annotation支持

     

    1.Servlet

     

    原本Servlet开发完后，必须在web.xml中配置如下代码：

     

    [html] view plaincopy
    1. <servlet>      
    2.     <servlet-name></servlet-name>  
    3.     <servler-class></servlet-class>  
    4.     <load-on-startup></load-on-startup>  
    5.     <init-param>  
    6.          <param-name></param-name>  
    7.          <param-value></param-value>  
    8.     </init-param>  
    9. </servlet>  
    10. <servlet-mapping>  
    11.      <servlet-name></servlet-name>  
    12.       <url-pattern></url-pattern>  
    13. </servlet-mapping>  

    现在只需要在java源文件的Servlet类前面加上：

    @WebServlet(name="",urlPatterns={""},initParams={@WebInitParam(name="",value=""),loadOnStartup=1})

    public class FirstServlet extends HttpServlet{}

     

    代码示例：

    实现一个最简单的Servlet。

     

    [java] view plaincopy
    1. package org.servlet;  
    2. import java.io.*;  
    3. import javax.servlet.*;  
    4. import javax.servlet.http.*;  
    5. import javax.servlet.annotation.*;  
    6. /* 
    7.        name == <servlet-name> 
    8.        urlPatterns == <url-pattern>, 
    9.        loadOnStartup == <load-on-startup> 
    10.        initParam == <init-param> 
    11.        name == <param-name> 
    12.        value == <param-value> 
    13. */  
    14. @WebServlet(name="HelloServlet" ,urlPatterns={"/HelloServlet"},loadOnStartup=1,  
    15.                     initParams={  
    16.                            @WebInitParam(name="name",value="xiazdong"),  
    17.                            @WebInitParam(name="age",value="20")  
    18.                     })  
    19. public class HelloServlet extends HttpServlet{  
    20.        public void init(ServletConfig config)throws ServletException{  
    21.               super.init(config);  
    22.        }  
    23.        public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{  
    24.               request.setCharacterEncoding("GBK");  
    25.               ServletConfig config = getServletConfig();  
    26.               PrintWriter out = response.getWriter();  
    27.               out.println("<html>");  
    28.               out.println("<body>");  
    29.               out.println("Hello world"+"<br />");  
    30.               out.println(config.getInitParameter("name"));  
    31.               out.println("</body>");  
    32.               out.println("</html>");  
    33.        }  
    34. }  

     

    这样的话只需要将class文件放入WEB-INFclasses 中，不需要再web.xml中作任何改动就完成部署；

     

    2.Filter

     

    原本Filter的配置如下：

     

    [html] view plaincopy
    1. <filter>  
    2.     <filter-name></filter-name>  
    3.     <filter-class></filter-class>  
    4. <filter>  
    5. <filter-mapping>  
    6.     <filter-name></filter-name>  
    7.     <url-pattern></url-pattern>  
    8. </filter-mapping>   
    9.   
    10.    

    现在只需要在java源文件的Filter类前面加上

    @WebFilter(filterName="",urlPattern={"/"});

     

    3.Listener

     

    原本在web.xml中配置如下：

     

    [html] view plaincopy
    1. <listener>   
    2.       <listener-class></listener-class>  
    3. </listener>  
    4.   
    5.    

    现在只需要在java源文件的Listener类前面加上@WebListener即可；

     

    二、web模块化

     

    原本一个web应用的任何配置都需要在web.xml中进行，因此会使得web.xml变得很混乱，而且灵活性差，因此 Servlet 3.0可以将每个Servlet、Filter、Listener打成jar包，然后放在WEB-INFlib中；注意各自的模块都有各自的配置文件， 这个配置文件的名称为  web-fragment.xml ;

     

    制作一个Servlet模块的步骤：

    1.编写Servlet，并编译；

    2.将此编译class文件及所在包通过jar包命令打成jar包；

    3.将此jar包用winrar打开，并将其中的META-INF中的manifest删除并添加 web-fragment.xml；

    4.将此jar包放入WEB-INFlib中即可；

     

    web-fragment.xml注意点：

    1.根元素为<web-fragment>;

    2.<name></name>表示模块名称；

    3.<ordering></ordering>是此模块的加载顺序；

    4.<before><others/></before>表示第一个加载；

    5.<after><name>A</name></after>表示比A后面加载；

    6.可以在里面部署listener、filter、servlet

    当然可以不设置任何的模块加载顺序；

     

    代码示例：

    配置两个listener模块；

    FirstListener.java

     

    [java] view plaincopy
    1.    
    2.   
    3. package org.listener;  
    4. import javax.servlet.annotation.*;  
    5. import javax.servlet.http.*;  
    6. import javax.servlet.*;  
    7. import java.util.*;  
    8. import java.sql.*;  
    9. import javax.naming.*;  
    10. public class FirstListener implements ServletRequestListener{  
    11.        public void requestInitialized(ServletRequestEvent event){  
    12.               System.out.println("FirstListener created");  
    13.        }  
    14.        public void requestDestroyed(ServletRequestEvent event){  
    15.               System.out.println("FirstListener destroyed");  
    16.        }  
    17. }  

    FirstListener 的 web-fragment.xml内容：

     

    [html] view plaincopy
    1. <?xml version="1.0" encoding="ISO-8859-1"?>  
    2. <web-fragment xmlns="http://java.sun.com/xml/ns/javaee"  
    3.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
    5.                       <A href="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"">http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
    6.  version="3.0">    
    7.        <name>FirstListener</name>  
    8.        <listener>  
    9.               <listener-class>org.listener.FirstListener</listener-class>  
    10.        </listener>  
    11.        <ordering>  
    12.               <before>  
    13.                     <others/>  
    14.               </before>  
    15.        </ordering>  
    16. </web-fragment>  


    SecondListener.java 

    [java] view plaincopy
    1. package org.listener;  
    2. import javax.servlet.annotation.*;  
    3. import javax.servlet.http.*;  
    4. import javax.servlet.*;  
    5. import java.util.*;  
    6. import java.sql.*;  
    7. import javax.naming.*;  
    8. public class SecondListener implements ServletRequestListener{  
    9.        public void requestInitialized(ServletRequestEvent event){  
    10.              System.out.println("SecondListener created");  
    [java] view plaincopy
    1.        }  
    2.        public void requestDestroyed(ServletRequestEvent event){  
    3.              System.out.println("SecondListener destroyed");  
    4.        }  
    5. }  

    SecondListener的 web-fragment.xml内容是：

     

    [html] view plaincopy
    1. <?xml version="1.0" encoding="ISO-8859-1"?>  
    2. <web-fragment xmlns="http://java.sun.com/xml/ns/javaee"  
    3.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
    5.                       <A href="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"">http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
    6.  version="3.0">    
    7.        <name>SecondListener</name>  
    8.        <listener>  
    [html] view plaincopy
    1.        <listener-class>org.listener.SecondListener</listener-class>  
    2. </listener>  
    3. <ordering>  
    4.       <after>  
    5.              <name>FirstListener</name>  
    6.        </after>  
    7. </ordering>  
    8. b-fragment>  

    然后分别打成jar包，放入 WEB-INFlib中即可；

     

    随便访问一个web应用，然后发现 tomcat控制台输出：

    看出先加载FirstListener，再加载SecondListener；

     

    三、Servlet 异步处理

     

    Servlet在MVC中作为控制器，控制器负责分发任务给MODEL完成，然后把结果交给JSP显示；

    而如果有许多MODEL，其中有一个MODEL处理时间很长，则会导致整个页面的显示很慢；

    异步处理关键点：将复杂业务处理另外开一个线程，而Servlet将执行好的业务先送往jsp输出，等到耗时业务做完后再送往JSP页面；

    一句话：先显示一部分，再显示一部分；

    异步处理Servlet的注意点是：

    1.需要在Annotation中注明 asyncSupported=true;

     

    [java] view plaincopy
    1. package org.sync;  
    2. import javax.servlet.*;  
    3. import javax.servlet.http.*;  
    4. import javax.servlet.annotation.*;  
    5. import java.io.*;  
    6. @WebServlet(name="AsyncServlet",urlPatterns={"/AsyncServlet"},asyncSupported=true)  
    7. public class AsyncServlet extends HttpServlet{  
    8.        public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{    
    9.               request.setCharacterEncoding("GBK");  
    10.               response.setContentType("text/html;charset=GBK");  
    11.               PrintWriter out = response.getWriter();  
    12.               out.println("<html>");  
    13.               out.println("<body>");  
    14.               out.println("====页面开始====<hr />");  
    15.               AsyncContext actx = request.startAsync();  
    16.               actx.setTimeout(30*3000);  
    17.               actx.start(new MyThread(actx));  
    18.               out.println("====页面结束====<hr />");  
    19.               out.println("</body>");  
    20.               out.println("</html>");  
    21.               out.flush();  
    22.        }  
    23. }  
    24. class MyThread implements Runnable{  
    25.        private AsyncContext actx;  
    26.        public MyThread(AsyncContext actx){  
    27.               this.actx = actx;  
    28.        }  
    29.        public void run(){  
    30.               try{  
    31.                    Thread.sleep(5*1000); //消耗5秒  
    32.                     actx.dispatch("/1.jsp");  
    33.               }  
    34.               catch(Exception e){}  
    35.        }  
    36. }  

    1.jsp

    [html] view plaincopy
    1. <%@ page contentType="text/html;charset=GBK" pageEncoding="GBK" session="false"%>  
    2. <html>  
    3.        <body>  
    4.        <%  
    5.               out.println("======复杂业务方法====");  
    6.        %>  
    7.       </body>  
    8. </html>  


    四、异步监听器

     

    异步监听器用来监听异步处理事件；即“三”中讲到的知识点；

    此监听器类似于ServletContextListener的机制；

    只需要实现AsyncListener接口即可；

    此接口有4个方法：
    public void onStartAsync(AsyncEvent event)throws IOException;

    public void onComplete(AsyncEvent event);

    public void onTimeout(AsyncEvent event);

    public void onError(AsyncEvent event);

     

    以下是监听器实现的代码：

     

    [java] view plaincopy
    1. package org.listener;  
    2. import javax.servlet.annotation.*;  
    3. import javax.servlet.http.*;  
    4. import javax.servlet.*;  
    5. import java.util.*;  
    6. import java.sql.*;  
    7. import javax.naming.*;  
    8. import java.io.*;  
    9. public class MyListener implements AsyncListener{  
    10.        public void onStartAsync(AsyncEvent event)throws IOException{}  
    11.        public void onComplete(AsyncEvent event){  
    12.               System.out.println("-----------------------Complete");  
    13.       }  
    14.        public void onTimeout(AsyncEvent event){  
    15.        }  
    16.        public void onError(AsyncEvent event){}  
    17. }  

     

    在Servlet异步处理处添加：

    actx.addListener(new MyListener())；就可以添加监听器，每当异步处理完成时就会触发onComplete()事件，输出Complete；

     

    五、文件上传改进API

     

    原本文件上传时通过 common-fileupload或者SmartUpload，上传比较麻烦，在Servlet 3.0 中不需要导入任何第三方jar包，并且提供了很方便进行文件上传的功能；

     

    注意点：

    1. html中 <input type="file">表示文件上传控件；

    2. form的 enctype="multipart/form-data"；

    3.在Servlet类前加上 @MultipartConfig

    4.request.getPart()获得；

     

    下面是一个文件上传的例子：

    upload.html

     

    [html] view plaincopy
    1. <html>  
    2.        <body>  
    3.               <form method="post" enctype="multipart/form-data" action="upload">  
    4.              <input type="file" id="file" name="file"/>  
    5.              <input type="text" id="name" name="name"/>  
    6.               <input type="submit" value="提交"/>  
    7.               </form>  
    8.        </body>  
    9. </html>  


    UploadServlet.java

     

    [java] view plaincopy
    1. package org.servlet;  
    2. import java.io.*;  
    3. import javax.servlet.*;  
    4. import javax.servlet.http.*;  
    5. import javax.servlet.annotation.*;  
    6.    
    7. @WebServlet(name="UploadServlet" ,urlPatterns={"/upload"})  
    8. @MultipartConfig  
    9. public class UploadServlet extends HttpServlet{  
    10.        public void init(ServletConfig config)throws ServletException{  
    11.               super.init(config);  
    12.        }  
    13.        public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{  
    14.               Part part = request.getPart("file");  
    15.               PrintWriter out = response.getWriter();  
    16.               out.println("此文件的大小："+part.getSize()+"<br />");  
    17.               out.println("此文件类型："+part.getContentType()+"<br />");  
    18.               out.println("文本框内容："+request.getParameter("name")+"<br />");  
    19.               out.println(UploadUtil.getFileName(part)+"<br />");  
    20.               part.write("F:\1."+UploadUtil.getFileType(part));  
    21.        }  
    22. }  

    UploadUtil.java

    由于在Servlet 3.0中很难获取上传文件的类型，因此我写了两个工具类，可以方便开发；

     

    [java] view plaincopy
      1. /** 
      2.  * 此工具类只适用于Servlet 3.0 
      3.  * 为了弥补 Servlet 3.0 文件上传时获取文件类型的困难问题 
      4.  *  
      5.  * @author xiazdong 
      6.  */  
      7. import javax.servlet.http.*;  
      8. public class UploadUtil{  
      9.        public static String getFileType(Part p){  
      10.               String name = p.getHeader("content-disposition");  
      11.               String fileNameTmp = name.substring(name.indexOf("filename=")+10);  
      12.               String type = fileNameTmp.substring(fileNameTmp.indexOf(".")+1,fileNameTmp.indexOf("""));  
      13.               return type;  
      14.        }  
      15.        public static String getFileName(Part p){  
      16.               String name = p.getHeader("content-disposition");  
      17.               String fileNameTmp = name.substring(name.indexOf("filename=")+10);  
      18.               String fileName = fileNameTmp.substring(0,fileNameTmp.indexOf("""));  
      19.               return fileName;  
      20.        }  
      21. }  
      22.   
      23.    
      24.   
  • 相关阅读:
    Redis入门--- 五大数据类型 ---String ,List
    Redis入门 --- 安装
    Netty 应用实例-群聊系统，心跳检测机制案例 ，WebSocket 编程实现服务器和客户端长连接
    红锁的实现
    基于Redis实现分布式锁
    基于分布式锁 分布式全局唯一ID
    Netty Java BIO 编程 （一）
    Netty Java NIO 基本介绍Channel 和 buffer (二)
    Java AIO 基本介绍
    SpringBoot 系列教程自动配置选择生效
  • 原文地址：https://www.cnblogs.com/dirgo/p/5007558.html
Copyright © 2020-2023  润新知