`
frank1998819
  • 浏览: 757875 次
  • 性别: Icon_minigender_1
  • 来自: 南京
文章分类
社区版块
存档分类

Servlet 3.0 新特性详解 （转）

 
阅读更多

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 plain copy print?
  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>
<servlet>    
    <servlet-name></servlet-name>
    <servler-class></servlet-class>
    <load-on-startup></load-on-startup>
    <init-param>
         <param-name></param-name>
         <param-value></param-value>
    </init-param>
</servlet>
<servlet-mapping>
     <servlet-name></servlet-name>
      <url-pattern></url-pattern>
</servlet-mapping>

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

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

public class FirstServlet extends HttpServlet{}

 

代码示例：

实现一个最简单的Servlet。

 

[java] view plain copy print?
  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. publicclass HelloServlet extends HttpServlet{
  20. publicvoid init(ServletConfig config)throws ServletException{
  21. super.init(config);
  22. }
  23. publicvoid 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. } 
package org.servlet;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
/*
       name == <servlet-name>
       urlPatterns == <url-pattern>,
       loadOnStartup == <load-on-startup>
       initParam == <init-param>
       name == <param-name>
       value == <param-value>
*/
@WebServlet(name="HelloServlet" ,urlPatterns={"/HelloServlet"},loadOnStartup=1,
                    initParams={
                           @WebInitParam(name="name",value="xiazdong"),
                           @WebInitParam(name="age",value="20")
                    })
public class HelloServlet extends HttpServlet{
       public void init(ServletConfig config)throws ServletException{
              super.init(config);
       }
       public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{
              request.setCharacterEncoding("GBK");
              ServletConfig config = getServletConfig();
              PrintWriter out = response.getWriter();
              out.println("<html>");
              out.println("<body>");
              out.println("Hello world"+"<br />");
              out.println(config.getInitParameter("name"));
              out.println("</body>");
              out.println("</html>");
       }
}

 

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

 

2.Filter

 

原本Filter的配置如下：

 

[html] view plain copy print?
  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>
<filter>
    <filter-name></filter-name>
    <filter-class></filter-class>
<filter>
<filter-mapping>
    <filter-name></filter-name>
    <url-pattern></url-pattern>
</filter-mapping>

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

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

 

3.Listener

 

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

 

[html] view plain copy print?
  1. <listener>
  2. <listener-class></listener-class>
  3. </listener>
<listener> 
      <listener-class></listener-class>
</listener>

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

 

二、web模块化

 

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

 

制作一个Servlet模块的步骤：

1.编写Servlet，并编译；

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

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

4.将此jar包放入WEB-INF\lib中即可；

 

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 plain copy print?
  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. publicclass FirstListener implements ServletRequestListener{
  11. publicvoid requestInitialized(ServletRequestEvent event){
  12. System.out.println("FirstListener created");
  13. }
  14. publicvoid requestDestroyed(ServletRequestEvent event){
  15. System.out.println("FirstListener destroyed");
  16. }
  17. } 
 

package org.listener;
import javax.servlet.annotation.*;
import javax.servlet.http.*;
import javax.servlet.*;
import java.util.*;
import java.sql.*;
import javax.naming.*;
public class FirstListener implements ServletRequestListener{
       public void requestInitialized(ServletRequestEvent event){
              System.out.println("FirstListener created");
       }
       public void requestDestroyed(ServletRequestEvent event){
              System.out.println("FirstListener destroyed");
       }
}

FirstListener 的 web-fragment.xml内容：

 

[html] view plain copy print?
  1. <?xmlversion="1.0"encoding="ISO-8859-1"?>
  2. <web-fragmentxmlns="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. <Ahref="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>
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-fragment xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      <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"
 version="3.0">  
       <name>FirstListener</name>
       <listener>
              <listener-class>org.listener.FirstListener</listener-class>
       </listener>
       <ordering>
              <before>
                    <others/>
              </before>
       </ordering>
</web-fragment>


SecondListener.java

[java] view plain copy print?
  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. publicclass SecondListener implements ServletRequestListener{
  9. publicvoid requestInitialized(ServletRequestEvent event){
  10. System.out.println("SecondListener created"); 
package org.listener;
import javax.servlet.annotation.*;
import javax.servlet.http.*;
import javax.servlet.*;
import java.util.*;
import java.sql.*;
import javax.naming.*;
public class SecondListener implements ServletRequestListener{
       public void requestInitialized(ServletRequestEvent event){
             System.out.println("SecondListener created");
[java] view plain copy print?
  1. }
  2. publicvoid requestDestroyed(ServletRequestEvent event){
  3. System.out.println("SecondListener destroyed");
  4. }
  5. } 
       }
       public void requestDestroyed(ServletRequestEvent event){
             System.out.println("SecondListener destroyed");
       }
}

SecondListener的 web-fragment.xml内容是：

 

[html] view plain copy print?
  1. <?xmlversion="1.0"encoding="ISO-8859-1"?>
  2. <web-fragmentxmlns="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. <Ahref="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>
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-fragment xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      <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"
 version="3.0">  
       <name>SecondListener</name>
       <listener>
[html] view plain copy print?
  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>
              <listener-class>org.listener.SecondListener</listener-class>
       </listener>
       <ordering>
             <after>
                    <name>FirstListener</name>
              </after>
       </ordering>
</web-fragment>

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

 

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

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

 

三、Servlet 异步处理

 

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

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

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

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

异步处理Servlet的注意点是：

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

 

[java] view plain copy print?
  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. publicclass AsyncServlet extends HttpServlet{
  8. publicvoid 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. publicvoid run(){
  30. try{
  31. Thread.sleep(5*1000); //消耗5秒
  32. actx.dispatch("/1.jsp");
  33. }
  34. catch(Exception e){}
  35. }
  36. } 
package org.sync;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.*;
@WebServlet(name="AsyncServlet",urlPatterns={"/AsyncServlet"},asyncSupported=true)
public class AsyncServlet extends HttpServlet{
       public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{  
              request.setCharacterEncoding("GBK");
              response.setContentType("text/html;charset=GBK");
              PrintWriter out = response.getWriter();
              out.println("<html>");
              out.println("<body>");
              out.println("====页面开始====<hr />");
              AsyncContext actx = request.startAsync();
              actx.setTimeout(30*3000);
              actx.start(new MyThread(actx));
              out.println("====页面结束====<hr />");
              out.println("</body>");
              out.println("</html>");
              out.flush();
       }
}
class MyThread implements Runnable{
       private AsyncContext actx;
       public MyThread(AsyncContext actx){
              this.actx = actx;
       }
       public void run(){
              try{
                   Thread.sleep(5*1000); //消耗5秒
                    actx.dispatch("/1.jsp");
              }
              catch(Exception e){}
       }
}

1.jsp

[html] view plain copy print?
  1. <%@ page contentType="text/html;charset=GBK"pageEncoding="GBK"session="false"%>
  2. <html>
  3. <body>
  4. <%
  5. out.println("======复杂业务方法====");
  6. %>
  7. </body>
  8. </html>
<%@ page contentType="text/html;charset=GBK" pageEncoding="GBK" session="false"%>
<html>
       <body>
       <%
              out.println("======复杂业务方法====");
       %>
      </body>
</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 plain copy print?
  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. publicclass MyListener implements AsyncListener{
  10. publicvoid onStartAsync(AsyncEvent event)throws IOException{}
  11. publicvoid onComplete(AsyncEvent event){
  12. System.out.println("-----------------------Complete");
  13. }
  14. publicvoid onTimeout(AsyncEvent event){
  15. }
  16. publicvoid onError(AsyncEvent event){}
  17. } 
package org.listener;
import javax.servlet.annotation.*;
import javax.servlet.http.*;
import javax.servlet.*;
import java.util.*;
import java.sql.*;
import javax.naming.*;
import java.io.*;
public class MyListener implements AsyncListener{
       public void onStartAsync(AsyncEvent event)throws IOException{}
       public void onComplete(AsyncEvent event){
              System.out.println("-----------------------Complete");
      }
       public void onTimeout(AsyncEvent event){
       }
       public void onError(AsyncEvent event){}
}

 

在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 plain copy print?
  1. <html>
  2. <body>
  3. <formmethod="post"enctype="multipart/form-data"action="upload">
  4. <inputtype="file"id="file"name="file"/>
  5. <inputtype="text"id="name"name="name"/>
  6. <inputtype="submit"value="提交"/>
  7. </form>
  8. </body>
  9. </html>
<html>
       <body>
              <form method="post" enctype="multipart/form-data" action="upload">
             <input type="file" id="file" name="file"/>
             <input type="text" id="name" name="name"/>
              <input type="submit" value="提交"/>
              </form>
       </body>
</html>


UploadServlet.java

 

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

UploadUtil.java

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

 

[java] view plain copy print?
  1. /**
  2. * 此工具类只适用于Servlet 3.0
  3. * 为了弥补 Servlet 3.0 文件上传时获取文件类型的困难问题
  4. *
  5. * @author xiazdong
  6. */
  7. import javax.servlet.http.*;
  8. publicclass UploadUtil{
  9. publicstatic 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. publicstatic 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. }
分享到：
| 深度解析RabbitMQ集群（转）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    servlet 3.0新增功能详解

    ### Servlet 3.0 新增功能详解 #### 引言 Servlet 技术自问世以来一直是 Java Web 开发的核心组成部分之一。随着技术的发展，Servlet 规范也在不断更新以适应新的需求和技术趋势。Servlet 3.0 版本是 Java EE 6 的...

    Servlet3.0特性详解

    Servlet3.0是Java EE平台中的一个重要组成部分，它在Servlet2.5的基础上引入了许多新特性，极大地提高了开发效率和灵活性。以下是对Servlet3.0主要特性的详细解释： 1. **注解配置**： 在Servlet3.0中，我们可以...

    详解Servlet3.0新特性（从注解配置到websocket编程）

    Servlet 3.0 新特性详解 Servlet 3.0 的出现标志着 Servlet 历史上最大的变革，其中的许多新特性大大简化了 Web 应用开发，为广大劳苦的程序员减轻了压力，提高了 Web 开发效率。下面，我们将详细解释 Servlet 3.0 ...

    基于Servlet3.0+IBatis+BootStrip技术构建简单会议管理系统

    第03课 servlet3.0新特性之@WebServlet_@WebInitParam详解 第04课 servlet3.0新特性之@WebFilter_@WebListener 第05课 JQuery AJAX 注册验证+二级菜单（JSON） 第06课 mybatis 框架搭建 第07课 mybatis 增删改查 第...

    Servlet3.0微框架

    这篇详解将深入剖析Servlet3.0的特性，以及如何利用这些特性构建微框架。 1. **注解驱动的配置** Servlet3.0引入了注解来替代传统的XML配置，大大简化了部署描述符web.xml的编写。例如，可以使用`@WebServlet`直接...

    Java Web开发详解:XML+DTD+XML Schema+XSLT+Servlet3.0+JSP2.2深入剖析与实例应用/孙鑫编著

    《Java Web开发详解——XML+DTD+XML Schema+XSLT+Servlet3.0+JSP2.2深入剖析与实例应用》内容全面，涵盖了从事Java Web开发所应掌握的所有知识，同时还讲解了最新的Servlet 3.0和JSP 2.2规范新增的特性。在知识的...

    sevlet-api-3.0

    这个压缩包包含了两个关键资源，一个是"Servlet 3.0 新特性详解 .doc"，这可能是一个详细的文档，涵盖了Servlet 3.0的所有新功能和技术亮点；另一个是"servlet-api-3.0.jar"，这是Servlet 3.0 API的实现库，用于在...

    Servlet3.0使用注解标注过滤器(Filter)

    #### 一、Servlet 3.0概述与新特性 Servlet 3.0 是 Java EE 6 的一部分，它引入了许多新的特性和改进，使得开发者能够更方便地开发 Web 应用程序。其中一个重要特性就是支持使用注解来配置过滤器（Filter），这大大...

    test-servlet3-without-webxml.rar

    Servlet 3.0是Java Servlet规范的一个重要版本，它引入了许多新特性，显著提升了开发效率和灵活性。在Servlet 3.0之前，我们通常需要一个`web.xml`部署描述符文件来配置Servlet，但在Servlet 3.0之后，我们可以实现...

    Servlet注解详解.docx

    Tomcat 7.0.x及更高版本开始支持Servlet 3.0规范，因此，使用这些新特性的应用可以部署在这些版本的Tomcat服务器上。 总之，Servlet 3.0的注解配置、模块化编程、异步处理和简化文件上传API等功能显著提升了Java EE...

    详解Servlet 3.0/3.1 中的异步处理

    xt.complete(); // 结束异步上下文 } catch (IllegalStateException e) { ...为了充分利用这些特性，你需要确保你的应用服务器支持Servlet 3.0或3.1规范，同时在编写Servlet时适配这些新特性，以实现高效的异步处理。

    jsp3.0技术详解.rar

    **JSP 3.0 技术详解** JavaServer Pages（JSP）是Java平台上的一个标准技术，用于创建动态web应用程序。JSP 3.0是其最新的版本，引入了多项改进和新特性，旨在提升开发效率和代码可维护性。本教程将深入解析JSP 3.0...

    崔希凡JavaWeb笔记day28（JavaWeb完毕）

    - **MyEclipse10.0或以上版本**：为了确保能够使用Servlet3.0的新特性，开发环境至少需要是MyEclipse10.0或更高版本。 - **Tomcat7.0或以上版本**：部署Servlet3.0的应用程序时，服务器环境也需支持新特性，因此...

    Servlet帮助中文文档.rar

    8. **Servlet 3.0新特性**：从Servlet 3.0版本开始，支持注解驱动的Servlet配置，无需web.xml，可以直接在Servlet类上使用`@WebServlet`注解。同时，还引入了异步Servlet处理和WebSocket协议支持。 9. **安全性**：...

    servlet详解

    此外，Servlet3.0引入了注解配置，允许在Servlet类上直接声明： ```java @WebServlet("/MyServlet") public class MyServlet extends HttpServlet { // ... } ``` 在Servlet中处理请求和响应主要通过重写`doGet()...

    Java Servlet的注解配置与生命周期详解.docx

    最后，Servlet 3.0还引入了一些其他特性，比如支持异步处理、过滤器和监听器的注解配置，以及更灵活的部署选项。这些改进进一步简化了Servlet的开发和管理，增强了其功能。 总结来说，Java Servlet通过XML配置或...

    BookStore.zip

    1. **Servlet3.0特性**： - 自动扫描：Servlet3.0引入了自动扫描容器，无需在web.xml中配置Servlet，只需在类上添加`@WebServlet`注解即可。 - 异步处理：Servlet3.0支持异步处理，提高了服务器对高并发请求的响应...

    Java EE 6 Overview 新特性

    ### Java EE 6 新特性详解 #### Java EE 发展历程概览 自1998年12月8日发布以来，Java EE（最初称为 J2EE）已历经十余年的发展，成为了搭建具备高可伸缩性、灵活性及易维护性的商务系统的首选平台。随着技术的不断...

    spring3.0jar包

    Spring 3.0是其一个重要版本，带来了许多新特性与改进，使得它更加灵活、高效且易于使用。 **主要模块解析：** 1. **org.springframework.context-3.0.5.RELEASE.jar**：这是Spring的核心模块，提供了上下文支持，...

Magicbox
Global site tag (gtag.js) - Google Analytics