Servlet3.0的新特性

合集下载

Servlet3.0 新特性

Servlet3.0 新特性

一、概述Servlet 是Java EE 规范体系的重要组成部分,也是Java 开发人员必须具备的基础技能,Servlet 3.0 引入的若干重要新特性,包括异步处理、新增的注解支持、可插性支持等,为读者顺利向新版本过渡扫清障碍。

Tomcat 支持servlet版本Servlet版本Tomcat版本Jdk最小版本JA V A EE版本Servlet 2.5 Tomcat 6 1.5 Java EE5Servlet 3.0 Tomcat7 1.6 Java EE6servlet3.0 的新特性包括如下方面 :1.异步处理支持:有了该特性,Servlet 线程不再需要一直阻塞,直到业务处理完毕才能再输出响应,最后才结束该Servlet 线程。

在接收到请求之后,Servlet 线程可以将耗时的操作委派给另一个线程来完成,自己在不生成响应的情况下返回至容器。

针对业务处理较耗时的情况,这将大大减少服务器资源的占用,并且提高并发处理速度。

2.新增的注解支持:该版本新增了若干注解,用于简化Servlet、过滤器(Filter)和监听器(Listener)的声明,这使得web.xml 部署描述文件从该版本开始不再是必选的了。

3.可插性支持:开发者可以通过插件的方式很方便的扩充已有Web 应用的功能,而不需要修改原有的应用。

二、异步处理支持异步处理特性可以应用于Servlet 和过滤器两种组件,由于异步处理的工作模式和普通工作模式在实现上有着本质的区别,因此默认情况下,Servlet 和过滤器并没有开启异步处理特性。

异步处理关键是在于将复杂业务处理另外开一个线程,而Servlet将执行好的业务先送往jsp输出,等到耗时业务做完后再送往JSP页面,即先显示一部分,好事业务处理完后再显示一部分。

1.对于使用传统的部署描述文件(web.xml) 配置Servlet 和过滤器的情况,Servlet 3.0 为<servlet> 和<filter> 标签增加了<async-supported> 子标签,该标签的默认取值为false,要启用异步处理支持,则将其设为true 即可。

使用异步servlet提升性能

使用异步servlet提升性能

本文发布之后, 收到了很多的反馈。

基于这些反馈,我们更新了文中的示例,使读者更容易理解和掌握, 如果您发现错误和遗漏,希望能给我们提交反馈,帮助我们改进。

本文针对当今webapp 中一种常碰到的问题,介绍相应的性能优化解决方案。

如今的WEB程序不再只是被动地等待浏览器的请求, 他们之间也会互相进行通信。

典型的场景包括在线聊天, 实时拍卖等——后台程序大部分时间与浏览器的连接处于空闲状态, 并等待某个事件被触发。

这些应用引发了一类新的问题,特别是在负载较高的情况下。

引发的状况包括线程饥饿, 影响用户体验、请求超时等问题。

基于这类应用在高负载下的实践, 我会介绍一种简单的解决方案。

在Servlet 3.0成为主流以后, 这是一种真正简单、标准化并且十分优雅的解决方案。

在演示具体的解决方案前,我们先了解到底发生了什么问题。

请看代码:@WebServlet(urlPatterns = "/BlockingServlet")public class BlockingServlet extends HttpServlet {protected void doGet(HttpServletRequest request, HttpServletResponse response) {waitForData();writeResponse(response, "OK");}public static void waitForData() {try {Thread.sleep(ThreadLocalRandom.current().nextInt(2000));} catch (InterruptedException e) {e.printStackTrace();}}}此servlet 所代表的情景如下:每2秒会有某些事件发生, 例如, 报价信息更新, 聊天信息抵达等。

简述servlet3.0技术

简述servlet3.0技术

一、servlet3.0技术简介Servlet3.0是JavaEE6规范中的一部分,它引入了许多新特性,丰富了Servlet的功能和灵活性。

在之前的Servlet版本中,开发者需要通过web.xml文件配置Servlet的映射关系和其他参数,而在Servlet3.0中,可以为Servlet提供注解方式的配置,简化了开发流程。

Servlet3.0还支持异步处理请求、动态注册Servlet和过滤器等功能,使得Servlet在处理Web请求方面更加高效、灵活。

二、Servlet3.0的新特性1. 注解配置在Servlet3.0中,可以使用注解方式来配置Servlet和Filter,不再需要在web.xml文件中进行繁琐的配置。

开发者只需在Servlet类或者Filter类上使用WebServlet或WebFilter注解,并指定相关的配置参数,即可在应用启动时自动注册Servlet和Filter。

2. 异步处理请求Servlet3.0引入了异步处理请求的功能,通过调用HttpServletRequest的startAsync方法,将请求分发给另一个线程去处理,同时当前线程可以处理其他请求,提高了服务器的并发处理能力。

3. 动态注册Servlet和Filter在Servlet3.0中,可以通过ServletCont本人nerInitializer接口来动态注册Servlet和Filter,无需在web.xml中配置,使得应用的灵活性和可扩展性得到了增强。

4. 文件上传Servlet3.0提供了新的Part接口,用于处理文件上传,开发者可以通过HttpServletRequest的getParts方法获取上传的文件,简化了文件上传的处理流程。

5. 长时间连接Servlet3.0支持长时间连接,可以在Servlet中处理长时间的连接请求,例如WebSocket等。

6. 无部署描述符在Servlet3.0中,支持无部署描述符的部署方式,即可以在不使用web.xml文件的情况下部署应用。

51CTO学院-深入浅出之-JavaEE基础视频教程

51CTO学院-深入浅出之-JavaEE基础视频教程

51cto学院-深入浅出之-JavaEE基础视频教程课程目标javaee是目前大型企业级Web开发的主流技术适用人群在校计算机专业大专、本科生。

课程简介课程目标:javaee是目前大型企业级Web开发的主流技术。

掌握Jsp/Servlet的应用与原理,理解MVC分层思想,了解EL与JSTL的技术。

学会使用Servlet+Dao模型开发简单的Web应用程序。

适合对象:在校计算机专业大专、本科生。

学习条件:已经掌握javase、HTML、SQL、Javascript等基础知识。

课程1JavaWeb简介[免费观看]29分钟什么是Web应用程序静态网页与动态网页JavaWeb简介搭建JavaWeb开发环境手工编写第一个JavaWeb程序2MyEclipse简介[免费观看]31分钟JavaWeb目录结构Tomcat目录结构Tomcat后台管理修改Tomcat默认端口号MyEclipse 简介MyEclipse安装与注册3MyEclipse开发第一个JavaWeb项目[免费观看]20分钟MyEclipse配置使用MyEclipse创建JavaWeb项目MyEclipse项目目录结构项目名与项目虚拟路径设置项目欢迎页4Jsp基础语法(一)[免费观看]27分钟Jsp简介常见动态网站开发技术对比Jsp页面元素构成(指令、注释、声明、脚本、表达式)5Jsp基础语法(二)[免费观看]25分钟Jsp生命周期阶段案例6Jsp内置对象(一)[免费观看]47分钟Jsp内置对象简介四种作用范围out对象request对象7Jsp内置对象(二)[免费观看]48分钟response对象请求重定向与请求转发的区别session对象8Jsp内置对象(三)[免费观看]33分钟session的生命周期application对象使用application实现计数器9Jsp内置对象(四)[免费观看]38分钟page对象pageContext对象config对象exception对象10Jsp内置对象(五)[免费观看]30分钟阶段案例-实现用户登录小例子11JavaBeans(一)41分钟什么是javabeans javabeans设计原则在Jsp页面中使用javabeans <jsp:useBean> <jsp:s etProperty> <jsp:getProperty>12JavaBeans(二)47分钟Javabeans四个作用域Model1模型简介阶段案例-使用Model1实现用户登录13Jsp状态管理(一)44分钟http的无状态性保存用户状态的两大机制session与Cookie Cookie简介Jsp中创建与使用C ookie 使用Cookie实现自动登录效果14Jsp状态管理(二)53分钟Session与Cookie对比阶段案例—使用Cookie实现商品浏览记录15Jsp指令与动作(一)37分钟include指令include动作include指令与include动作的区别<jsp:forward>动作<jsp:par am>动作<jsp:plugin>动作16Jsp指令与动作(二)39分钟阶段案例-实现易买网页面布局效果17Servlet基础(一)42分钟Servlet简介Tomcat容器等级手工编写第一个servlet Servlet生命周期18Servlet基础(二)58分钟使用MyEclipse创建Servlet Servlet与九大内置对象关系Servlet获取表单信息Servlet路径跳转问题19Servlet基础(三)42分钟获取初始化参数MVC简介Model2简介阶段案例—使用Model2模型实现易买网用户注册20Servlet高级(一)43分钟过滤器简介使用过滤器解决中文乱码问题监听器简介使用监听器实现统计在线人数过滤器与监听器对比21Servlet高级(二)39分钟Servlet3.0新特征使用注解定义Servlet 使用注解定义Filter 使用注解定义Listener22Servlet高级(三)45分钟Apache Commons-fileupload组件介绍使用Apache Commons-fileupload实现上传使用Apache Commons-fileupload实现用户注册功能23Servlet高级(四)48分钟阶段案例-使用Servlet实现验证码功能24EL表达式(一)42分钟EL表达式简介基本语法 .运算符[]运算符隐式对象Empty运算符25EL表达式(二)35分钟获取数组元素获取序列元素获取Set元素获取Map元素逻辑运算符数学运算符关系运算符26EL表达式(三)56分钟阶段案例—MVC中使用EL表达式27数据源与JNDI36分钟JNDI简介JNDI简单应用数据库连接池数据源简介访问数据源28JSTL(一)31分钟JSTL简介自定义标签JSP使用自定义标签自定义标签处理流程29JSTL(二)56分钟定义带属性的标签TagSupport的生命周期迭代标签30JSTL(三)38分钟BodyTagSupport类BodyTagSupport类生命周期BodyTagSupport与TagSupport的区别SimpleTagSupport类31JSTL(四)53分钟第一个JSTL小例子JSTL核心标签库32JSTL(五)51分钟JSTL标签库类别格式化标签库SQL标签库33JSTL(六)38分钟XML标签库函数标签库34Ajax(一)30分钟Web2.0简介Ajax简介Ajax工作原理Ajax第一个小例子35Ajax(二)32分钟阶段案例-使用ajax实现搜索自动提示功能36Ajax(三)38分钟JSON简介JSON语法JSON与XML对比Java对象数组转JSON 37Ajax(四)48分钟Ajax返回JSON数据演示案例Ajax返回XML数据演示案例Ajax总结38易买网商城项目(一)21分钟实现用户注册时检查用户名是否已经存在39易买网商城项目(三)即将发布40易买网商城项目(四)即将发布课程地址:/course/course_id-1898.html。

servlet 3.0异步处理

servlet 3.0异步处理

2.15.3 Servlet3.0提供的异步处理(1)在以前的Servlet规范中,如果Servlet作为控制器调用了一个耗时的业务方法,那么Servlet必须等到业务方法完全返回之后才会生成响应,这将使得Servlet 对业务方法的调用变成一种阻塞式的调用,因此效率比较低。

Servlet 3.0规范引入了异步处理来解决这个问题,异步处理允许Servlet重新发起一条新线程去调用耗时的业务方法,这样就可避免等待。

Servlet 3.0的异步处理是通过AsyncContext类来处理的,Servlet可通过ServletRequest的如下两个方法开启异步调用、创建AsyncContext对象:AsyncContext startAsync()AsyncContext startAsync(ServletRequest, ServletResponse)重复调用上面的方法将得到同一个AsyncContext对象。

AsyncContext对象代表异步处理的上下文,它提供了一些工具方法,可完成设置异步调用的超时时长,dispatch用于请求、启动后台线程、获取request、response对象等功能。

下面是一个进行异步处理的Servlet类。

程序清单:codes\02\2.15\servlet3\WEB-INF\src\lee\AsyncServlet.java1.@WebServlet(urlPatterns="/async",asyncSupported=true)2.public class AsyncServlet extends HttpServlet3.{4. @Override5. public void doGet(HttpServletRequest request6. , HttpServletResponse response)throws IOException,ServletException7. {8. response.setContentType("text/html;charset=GBK");9. PrintWriter out = response.getWriter();10. out.println("<title>异步调用示例</title>");11. out.println("进入Servlet的时间:"12. + new java.util.Date() + ".<br/>");13. out.flush();14. //创建AsyncContext,开始异步调用15. AsyncContext actx = request.startAsync();16. //设置异步调用的超时时长17. actx.setTimeout(30*1000);18. //启动异步调用的线程19. actx.start(new Executor(actx));20. out.println("结束Servlet的时间:"21. + new java.util.Date() + ".<br/>");22. out.flush();23. }24.}上面的Servlet类中粗体字代码创建了AsyncContext对象,并通过该对象以异步方式启动了一条后台线程。

Servlet3.0实现文件上传的方法

Servlet3.0实现文件上传的方法

Servlet3.0实现⽂件上传的⽅法Servlet 实现⽂件上传所谓⽂件上传就是将本地的⽂件发送到服务器中保存。

例如我们向百度⽹盘中上传本地的资源或者我们将写好的博客上传到服务器等等就是典型的⽂件上传。

Servlet 3.0上次完成⽂件下载功能使⽤的是 Servlet 2.5,但是想要完成⽂件上传,那么继续使⽤Servlet 2.5 肯定不是⼀个好的选择,因此我们使⽤ Servlet 3.0 来完成⽂件上传。

下⾯我来简单介绍⼀下 Servlet 3.0 的新特性:1、新增的注解⽀持该版本新增了若⼲注解,⽤于简化 Servlet、过滤器(Filter)和监听器(Listener)的声明,这使得 web.xml 部署描述⽂件从该版本开始不再是必选的了。

2、HttpServletRequest 对⽂件上传的⽀持此前,对于处理上传⽂件的操作⼀直是让开发者头疼的问题,因为 Servlet 本⾝没有对此提供直接的⽀持,需要使⽤第三⽅框架来实现,⽽且使⽤起来也不够简单。

如今这都成为了历史,Servlet 3.0 已经提供了这个功能,⽽且使⽤也⾮常简单。

Servlet 3.0 的新特性当然肯定不⽌这些,但是其他的新特性在这⾥我们暂时还⽤不到,也就不做过多了解了。

必要条件想要完成⽂件上传,肯定不是这么简单,它对浏览器端和服务器端都有许多的要求。

对浏览器的要求:1. ⼀个⽂件的⼤⼩⼀般肯定不⽌ 1 KB,既然这样,那么要上传⼀个⽂件肯定不能使⽤get⽅式了,所以上传⽂件时必须采⽤post ⽅式。

2. 2.表单中必须有⼀个⽂件上传项<input type="file"> ,⽽且必须有 name 属性。

3. 必须设置表单的enctype 属性值为multipart/form-data。

对服务器的要求:1. 当然,我们肯定得使⽤ Servlet 3.0。

2. Servlet3.0 中接收普通上传组件(除了⽂件上传组件)通过 request.getParameter(String)接收,⽽⽂件上传组件通过request.getPart(String)接收。

MVC 3.0 的新特性(1)

MVC 3.0 的新特性(1)

我要学 MVC 3.0(一):MVC 3.0 的新特性摘要MVC经过其1.0和2.0版本的发展,现在已经到了3.0的领军时代,随着技术的不断改进,MVC也越来越成熟。

使开发也变得简洁人性化艺术化。

园子里有很多大鸟都对MVC了如指掌,面对问题犹同孙悟空的七十二变一般游刃有余,令人羡慕。

大鸟们的著作我们作为菜鸟看了又看,读了又读但是还是对MVC3.0的了解不是很深。

这种杯具的情况岂止是杯具呀,那简直就是杯具。

综合分析后得出结论:眼高手低!!!最后菜鸟痛定思过,决定从最基本的开始一步一步开始学习MVC 3.0 也希望想学习MVC3.0的小菜们分享一下下。

前言 MVC3 在 MVC 1 和2 的基础上,增加了大量的特性,使得代码更加简化,并且可以深度扩展。

这篇文章提供包含在此次发布中的许多新特性的说明,分为以下部分:∙Razor 视图引擎∙支持多视图引擎∙Controller 改进∙JavaScript 和Ajax∙Model 验证的改进∙依赖注入Dependency Injection 的改进∙其他新特性Razor 视图引擎 MVC3 带来了一种新的名为Razor 的视图引擎,提供了下列优点:∙Razor 的语法简单且清晰,只需要最小化的输入∙Razor 容易学习,语法类似于 C# 和VB∙Visual Studio 对于Razor 提供了智能提示和语法着色∙Razor 视图不需要允许程序或者启动 Web 服务器就可以进行测试Razor 现在提供了一些新的特征:∙@model 用来指定传到视图的Model 类型∙@* * 注释语法∙对于整个站点可以一次性设定默认项目,例如布局。

∙Html.Raw 方法提供了没有进行HTML 编码的输出∙支持在多个视图之间共享代码( _viewstart.cshtml 或者_viewstart.vbhtml ) Razor 还包含新的H TML Helper,例如:∙Chart. 生成图表∙WebGrid, 生成数据表格,支持完整的分页和排序∙Crypto,使用Hash 算法来创建Hash 和加盐的口令∙WebImage, 生成图片∙WebMail, 发送电子邮件如下示例代码:@model List<MvcMusicStore.Models.Album>@{ViewBag.Title = " MVC Music Store";}<div id="promotion"></div><h3><em>Fresh</em>off the grill</h3><ul id="album-list">@foreach (var album in Model){<li><a href="@Url.Action("Details", "Store",new { id = album.AlbumId })"><img alt="@album.Title"src="@album.AlbumArtUrl"/><span>@album.Title</span></a></li>}</ul>关于Razor 更多的资料,可以参考下面的资源:∙Scott Guthrie's blog post introducing Razor∙Scott Guthrie's blog post introducing the @model keyword∙Scott Guthrie's blog post introducing Razor layouts∙Razor API Quick Reference∙MVC 3 Release Notes支持多视图引擎在 MVC3 中,增加视图的对话框中允许你选择你希望的视图引擎,在新建项目对话框中,你可以指定项目默认的视图引擎,可以选择W ebForm,Razor,或者开源的视图引擎,例如:Spark, NHam l, 或者NDjango.选择视图引擎:控制器的改进全局的 Action 过滤器有的时候你希望能够在在一个Action 方法执行之前或者执行之后执行一些处理逻辑,在 MVC2 中,提供了 Action 过滤器,允许对特定控制器的Action 方法进行处理,实际上,有时候你希望对所有的Action 都进行类似的处理,MVC3 允许你将过滤器加入到GlobalFilters 集合中来创建全局的过滤器,详细的介绍,参考下列资源:∙Scott Guthrie's blog on the MVC 3 Preview∙Filtering in MVC新的 ViewBag 属性MVC2 中的控制器支持 ViewData 属性,允许通过后绑定的字典将数据传送给视图模板,在 MVC3 中,你可以通过 ViewBag 来更加简单的完成。

Servlet传统配置方式和Servlet3.0使用注解的方式

Servlet传统配置方式和Servlet3.0使用注解的方式

Servlet传统配置⽅式和Servlet3.0使⽤注解的⽅式⼀、Servlet的传统配置⽅式 在JavaWeb开发中,每次编写⼀个Servlet都需要在web.xml⽂件中进⾏配置,如下所⽰:<servlet><servlet-name>ActionServlet</servlet-name><servlet-class>com.web.controller.ActionServlet</servlet-class></servlet><servlet-mapping><servlet-name>ActionServlet</servlet-name><url-pattern>/servlet/ActionServlet</url-pattern></servlet-mapping>发⼀个Servlet,都要在web.xml中配置Servlet才能够使⽤,这实在是很头疼的事情,所以Servlet3.0之后提供了注解(annotation),使得不再需要在web.xml⽂件中进⾏Servlet的部署描述,简化开发流程。

本⽂所讲的基于注解⽅式配置Servlet不是针对Servlet3.0的,⽽是基于Servlet2.5的,通过开发⾃定义注解和注解处理器来模拟实现类似于Servlet3.0的注解⽅式配置Servlet。

⼆、基于注解的⽅式配置Servlet JDK1. 5版本之后, JAVA提供了⼀种叫做Annotation的新数据类型,中⽂译为注解或标注,它的出现为铺天盖地的XML配置⽂件提供了⼀个完美的解决⽅案,让 JAVA EE开发更加⽅便快速,也更加⼲净了。

不过Servlet2.5默认情况下是不⽀持注解⽅式的配置的,但是我们可以开发⾃定义注解,然后将注解标注到Servlet上,再针对我们⾃定义的注解写⼀个注解处理器.原理: ⾸先,浏览器发出请求后,经过过滤器。

兄弟连_马剑威_JavaWeb_097_Servlet3.0新特性

兄弟连_马剑威_JavaWeb_097_Servlet3.0新特性

第97讲:Servlet3.0新特性课程大纲•1、Annotation进行配置•2、模块化编程•3、Servlet异步处理•4、异步Listener•5、文件上传API简化1、Annotation进行配置•tomcat 7.0.X 支持Servlet 3.0•Servlet、Filter、Listener无需在web.xml中进行配置,可以通过Annotation进行配置• 1.Servlet•只需要在java源文件的Servlet类前面加上:•@WebServlet(name="",urlPatterns={""},initParams={@WebInitParam(name="",value =""),loadOnStartup=1})•public class MyServlet extends HttpServlet{}1、Annotation进行配置•Servlet 3.0 web.xml•<?xml version="1.0" encoding="UTF-8"?>•<web-app version="3.0" xmlns="/xml/ns/javaee"•xmlns:xsi="/2001/XMLSchema-instance"•xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd">•</web-app>1、Annotation进行配置•Servlet、Filter、Listener无需在web.xml中进行配置,可以通过Annotation进行配置• 2.Filter•只需要在java源文件的Filter类前面加上•@WebFilter(filterName="",urlPattern={"/"});1、Annotation进行配置•Servlet、Filter、Listener无需在web.xml中进行配置,可以通过Annotation进行配置• 3.Listener•现在只需要在java源文件的Listener类前面加上•@WebListener即可;2、模块化编程•原本一个web应用的任何配置都需要在web.xml中进行,因此会使得web.xml变得很混乱,而且灵活性差,因此Servlet 3.0可以将每个Servlet、Filter、Listener打成jar包,然后放在WEB-INF\lib中;注意各自的模块都有各自的配置文件,这个配置文件的名称为web-fragment.xml ;web-fragment xml;••制作一个Servlet模块的步骤:• 1.编写Servlet,并编译;1并编译;• 2.将此编译class文件及所在包通过jar包命令打成jar包;• 3.将此jar包解压打开,将META-INF中的•manifest删除并添加web-fragment.xml;web fragment xml• 4.将此jar包放入WEB-INF\lib中即可;•2、模块化编程•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、servlet2、模块化编程•web-fragment.xml 头声明:•<?xml version="1.0" encoding="UTF-8"?>•<web-fragment xmlns="/xml/ns/javaee"•xmlns:xsi="/2001/XMLSchema-instance"•xsi:schemaLocation="/xml/ns/javaee •/xml/ns/javaee/web-fragment_3_0.xsd"•version="3.0">•</web-fragment>3、Servlet异步处理•Servlet在MVC中作为控制器,控制器负责分发任务给MODEL完成,然后把结果交给JSP显示;•而如果有许多MODEL,其中有一个MODEL处理时间很长,则会导致整个页面的显示很慢;很慢•异步处理关键点:将复杂业务处理另外开一个线程,而Servlet将执行好的业务先送往jsp输出,等到耗时业务做完后再送往JSP页面;句话:先显示部分,再显示部分;•一句话:先显示一部分再显示一部分;•异步处理Servlet的注意点是:• 1.需要在Annotation中注明asyncSupported=true;4、异步Listener•异步监听器用来监听异步处理事件;即“三”中讲到的知识点;•此监听器类似于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);5、文件上传API简化•原本文件上传时通过common-fileupload或者SmartUpload,上传比较麻烦,在Servlet3.0 中不需要导入任何第三方jar包,并且提供了很方便进行文件上传的功能;••注意点:注意点• 1.html中<input type="file">表示文件上传控件;• 2. form的enctype="multipart/form-data";• 3.在Servlet类前加上@MultipartConfig类• 4.request.getPart()获得;THANKYOU!微信号:weige-java扫一扫,关注威哥微信公众平台。

ORACLE官方培训servlet-3新特性中文版

ORACLE官方培训servlet-3新特性中文版
<在此处插入图片>
JavaEE 6 Servlet 3.0 中的新特性
议题
• 易于开发和部署 • 模块化 web.xml • 动态配置
<在此处插入图片>
• 异步 Servlet
2
Web Profile
• 用于 Web 应用程序的功能全面的中型 profile • web profile 中的各种技术 – Servlet 3.0、JSP 2.1、对其他语言的调试支持、EL 1.2、JSTL 1.2、JSF 2.0 – EJB Lite 3.1、JTA 1.1、JPA 2.0、通用批注 – Bean validation 1.0
Java EE 6
foo.war
foo_ejb.jar
com.sun.FooBean com.sun.FooHelper
5
Servlet — 下一代
• Servlet 3.0 — 易于开发 – 主要关注点
• 增强了 API 以便使用 SE 5 中新的语言特性 – 例如:批注、泛型(Generics) – 在上次 JavaEE 5 中漏掉的 Servlet
13
Multipart 支持
• Servlet 目前原生支持 multipart 数据 – 以前必须借助于第三方库
• 获得 MIME 内容的新方法 – HttpServletRequest.getParts() – Iterable<Part> – HttpServletRequest.getPart(String name) – String
• @WebListener、@WebFilter 的工作方式相同
9
Servlet 3.0 — 示例 3
@WebServlet( urlPatterns=“/hello”, loadOnStartup=1 , initParams={ @InitParam(name=”db”, value=”jdbc:derby...”) , @InitParam(name=”dbuser”, value=”fred”) , @InitParam(name=”dbpasswd”, value=”fred”) } )

servlet3注解

servlet3注解

servlet3注解一、Servlet3.0介绍Servlet3.0是Java EE6规范的一部分,Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署描述,简化开发流程。

二、开发Servlet3.0程序的所需要的环境开发Servlet3.0的程序需要一定的环境支持。

MyEclipse10和Tomcat7都提供了对Java EE6规范的支持。

Tomcat需要Tomcat7才支持Java EE6,Tomcat7需要使用JDK1.6以上的版本。

所以开发Servlet3.0的程序需要以下的开发环境支持∙IDE:MyEclipse 10+∙JDK:JDK 1.6+∙tomcat:tomcat 7+如果使用的MyEclipse的版本较低,例如MyEclipse8.5,没有提供Java EE6的支持,可以到Oracle官方网站下载JavaEE6的SDK进行安装,或者从Tomcat7的解压目录下的lib文件夹中的【annotations-api.jar、el-api.jar、jasper.jar、jasper-el.jar、jsp-api.jar、servlet-api.jar】这几个jar文件引用到我们的项目路径下。

(例如:先建一个Java EE5的web 项目,然后把Tomcat7的解压目录下的lib文件夹中的【annotations-api.jar、el-api.jar、jasper.jar、jasper-el.jar、jsp-api.jar、servlet-api.jar】这几个jar文件引入到项目中,再删除Java EE5的库引用,最后从Tomcat7的解压目录下的conf文件夹下把web.xml模板拷贝到项目,替换掉原来的web.xml)。

三、使用MyEclipse8.5+Tomcat7+JDK1.7开发Servlet3.0程序3.1、创建WebProject1、使用MyEclipse8.5新建一个Web Project,选择最高版本的Java EE5.0,如下图所示:创建好的项目如下所示:项目的web.xml文件内容如下:1<?xml version="1.0" encoding="UTF-8"?>2<web-app version="2.5"3xmlns="/xml/ns/javaee"4xmlns:xsi="/2001/XMLSchema-instance"5xsi:schemaLocation="/xml/ns/javaee6/xml/ns/javaee/web-app_2_5.xsd">7<welcome-file-list>8<welcome-file>index.jsp</welcome-file>9</welcome-file-list>10</web-app>注意web.xml文件中的version信息,version="2.5"和/xml/ns/javaee/web-app_2_5.xsd。

Servlet工作原理解析

Servlet工作原理解析

Servlet⼯作原理解析Tomcat中真正管理Servlet的是Context容器,⼀个Context对应⼀个Web⼯程,在Tomcat的配置⽂件中可以很容易发现:<Context path-"" docBase="" reloadable="true"/>Tomcat7开始⽀持嵌⼊式⽅式,通过添加⼀个启动类org.apache.catalina.startup.Tomcat,创建⼀个这个类的实例对象并调⽤start⽅法就可以很容易启动Tomcat(SpringBoot的内嵌Tomcat容器启动⼤概就基于此),还可以通过这个对象来添加和修改Tomcat的配置参数,如动态添加Context,Servlet 等Servlet容器启动过程添加⼀个Web应⽤时将会创建⼀个StandardContext对象,这个对象就是Tomcat中管理Servlet的Context具体对象了。

并且会给这个容器对象设置必要的参数,如url和path分别对应这个应⽤在Tomcat中的访问路径和这个应⽤实际的物理路径Tomcat的启⽤逻辑是基于观察者模式设计的,所有的容器都会继承Lifecycle(⽣命周期)接⼝,它管理着容器的整个⽣命周期,所有容器的修改和状态的改变都会由它去通知已经注册的观察者(Listener)Web应⽤的初始化⼯作Web应⽤的初始化⼯作是在ContextConfig的configureStart⽅法中实现的,引⽤⽤的初始化主要是解析web.xml⽂件,这个⽂件描述了⼀个Web 应⽤的关键信息,也是⼀个Web应⽤的⼊⼝web.xml⽂件中的各个配置项会被解析成相应的属性保存在WebXml对象中,如果当前的应⽤⽀持Servlet3.0还会完成⼀些额外的操作,这些操作主要是Servlet3.0新特性的解析以及对annotations注解的⽀持接下来将WebXml对象中的属性设置到Context容器中,当然这⾥包括创建Servlet对象,Filter,Listener等在Tomcat中Servlet会被包装成StandardWrapper,这是因为StandardWrapper是Tomcat容器的⼀部分,具有容器的特性,⽽Servlet作为独⽴的Web开发标准,不应该强耦合在Tomcat⾥,这⾥主要是为了解耦除了将Servlet包装成StandardWrapper并作为⼦容器添加到Context外,其他所有的web.xml属性都被解析到Context中,所以说Context才是真正运⾏Servlet的地⽅⼀个Web应⽤对应⼀个Context容器,容器的配置属性由应⽤的web.xml指定创建Ser vlet实例创建Se r v le t对象如果Servlet的load-on-startup配置项⼤于0,那么在Context容器启动时就会被实例化在Tomcat的conf下的web.xml⽂件(默认配置⽂件)定义了两个Servlet,分别是org.apache.catalina.servlets.DefaultServlet和org.apache.jasper.servlet.JspServlet。

Spring3.0新特性

Spring3.0新特性

一、首先,模块的组织更加的细致,从那么多的jar分包就看的出来:Spring的构建系统以及依赖管理使用的是Apache Ivy,从源码包看出,也使用了Maven。

Maven确实是个好东西,好处不再多言,以后希望能进一步用好它。

二、新特性如下:Spring Expression Language (Spring表达式语言)IoC enhancements/Java based bean metadata (Ioc增强/基于Java的bean元数据)General-purpose type conversion system and UI field formatting system (通用类型转换系统和UI字段格式化系统)Object to XML mapping functionality (OXM) moved from Spring Web Services project (对象到XML映射功能从Spring Web Services项目移出)Comprehensive REST support (广泛的REST支持)@MVC additions (@MVC增强)Declarative model validation (声明式模型验证)Early support for Java EE 6 (提前对Java EE6提供支持)Embedded database support (嵌入式数据库的支持)三、针对Java 5的核心API升级1、BeanFactory接口尽可能返回明确的bean实例,例如:T getBean(String name, Class requiredType)Map getBeansOfType(Class type)Spring3对泛型的支持,又进了一步。

个人建议泛型应该多用,有百利而无一害!2、Spring的TaskExecutor接口现在继承自java.util.concurrent.Executor:扩展的子接口AsyncTaskExecutor支持标准的具有返回结果Futures的Callables。

关于servlet3.0中的异步servlet

关于servlet3.0中的异步servlet

关于servlet3.0中的异步servlet刚看了⼀下维基百科上的介绍,servlet3.0是2009年随着JavaEE6.0发布的:到现在已经有六七年的时间了,在我第⼀次接触java的时候(2011年),servlet3.0就已经出现很久了,但是到现在,⾥边的⼀些东西还是没有能够好好地了解⼀下最近在研究java的长连接,在了解jetty中的continuations机制的时候也重新了解了⼀下servlet3.0中的异步servlet机制,通过看⼏个博客,加上⾃⼰的⼀些测试,算是搞明⽩了⼀些,在这⾥记录⼀下:在服务器的并发请求数量⽐较⼤的时候,会产⽣很多的servlet线程(这些servlet线程在servlet容器的线程池中维护),如果每个请求需要耗费的时间⽐较长(⽐如,执⾏了⼀些IO的处理等),在之前的⾮异步的servlet中,这些servlet线程将会阻塞,严重耗费服务器的资源.⽽在servlet3.0中⾸次出现的异步servlet,通过⼀个单独的新的线程来执⾏这些⽐较耗时的任务(也可以把这些任务放到⼀个⾃⼰维护的线程池⾥),servlet线程⽴即返回servlet容器的servlet池以便响应其他请求,这样,在降低了系统的资源消耗的同时,也会提升系统的吞吐量下⾯是我⾃⼰做的⼀个模拟的操作(代码参考了importnew上的这篇⽂章:)⼀个服务器端需要⼗秒才能返回的servlet,分别有同步的版本和异步的版本,通过JMeter做压⼒测试,配合jprofiler来分析服务器的资源消耗情况(主要是线程的创建和使⽤情况)来分析当服务器处理时间较长的时候,异步的servlet和同步的servlet对服务器性能的影响同步的servlet:package com.jiaoyiping.websample.asyncServlet;/** Created with Intellij IDEA* USER: 焦⼀平* Mail: jiaoyiping@* Date: 2016/10/22* Time: 22:16* To change this template use File | Settings | Editor | File and Code Templates*/import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;import java.io.PrintWriter;@WebServlet(urlPatterns = "/syncServlet")public class SyncServlet extends HttpServlet {//线程睡眠⼗秒才返回的servletprivate static final long serialVersionUID = 1L;</span><span style="color: #0000ff;">protected</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> doGet(HttpServletRequest request,HttpServletResponse response) </span><span style="color: #0000ff;">throws</span><span style="color: #000000;"> ServletException, IOException {</span><span style="color: #0000ff;">long</span> startTime =<span style="color: #000000;"> System.currentTimeMillis();System.out.println(</span>"LongRunningServlet Start::Name="+ Thread.currentThread().getName() + "::ID="+<span style="color: #000000;"> Thread.currentThread().getId());</span><span style="color: #0000ff;">int</span> milliseconds = 10000<span style="color: #000000;">;longProcessing(milliseconds);PrintWriter out </span>=<span style="color: #000000;"> response.getWriter();</span><span style="color: #0000ff;">long</span> endTime =<span style="color: #000000;"> System.currentTimeMillis();out.write(</span>"Processing done for " + milliseconds + " milliseconds!!"<span style="color: #000000;">);System.out.println(</span>"LongRunningServlet Start::Name="+ Thread.currentThread().getName() + "::ID="+ Thread.currentThread().getId() + "::Time Taken="+ (endTime - startTime) + " ms."<span style="color: #000000;">);out.flush();out.close();}</span><span style="color: #0000ff;">private</span> <span style="color: #0000ff;">void</span> longProcessing(<span style="color: #0000ff;">int</span><span style="color: #000000;"> secs) {</span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {Thread.sleep(secs);} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {e.printStackTrace();}}}异步的servlet:package com.jiaoyiping.websample.asyncServlet.async;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;import java.io.IOException;import java.util.concurrent.ThreadPoolExecutor;/*Created with Intellij IDEAUSER: 焦⼀平Mail: jiaoyiping@Date: 2016/10/22Time: 22:38To change this template use File | Settings | Editor | File and Code Templates*/@WebServlet(asyncSupported = true, urlPatterns = "/asyncServlet")public class AsyncServlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {long startTime = System.currentTimeMillis();System.out.println("AsyncLongRunningServlet Start::Name="+ Thread.currentThread().getName() + "::ID="+ Thread.currentThread().getId());request.setAttribute(</span>"org.apache.catalina.ASYNC_SUPPORTED", <span style="color: #0000ff;">true</span><span style="color: #000000;">);</span><span style="color: #0000ff;">int</span> secs = 10000<span style="color: #000000;">;AsyncContext asyncCtx </span>=<span style="color: #000000;"> request.startAsync();asyncCtx.addListener(</span><span style="color: #0000ff;">new</span><span style="color: #000000;"> AppAsyncListener());asyncCtx.setTimeout(</span>2000000<span style="color: #000000;">);ThreadPoolExecutor executor </span>= (ThreadPoolExecutor) request.getServletContext().getAttribute("executor"<span style="color: #000000;">);executor.execute(</span><span style="color: #0000ff;">new</span><span style="color: #000000;"> AsyncRequestProcessor(asyncCtx, secs));</span><span style="color: #0000ff;">long</span> endTime =<span style="color: #000000;"> System.currentTimeMillis();System.out.println(</span>"AsyncLongRunningServlet End::Name="+ Thread.currentThread().getName() + "::ID="+ Thread.currentThread().getId() + "::Time Taken="+ (endTime - startTime) + " ms."<span style="color: #000000;">);}}异步的servlet依赖的处理长时间任务的Thread:package com.jiaoyiping.websample.asyncServlet.async;/** Created with Intellij IDEA* USER: 焦⼀平* Mail: jiaoyiping@* Date: 2016/10/22* Time: 22:43* To change this template use File | Settings | Editor | File and Code Templates*/import javax.servlet.AsyncContext;import java.io.IOException;import java.io.PrintWriter;public class AsyncRequestProcessor implements Runnable {private AsyncContext asyncContext;private int milliseconds;</span><span style="color: #0000ff;">public</span><span style="color: #000000;"> AsyncRequestProcessor() {}</span><span style="color: #0000ff;">public</span> AsyncRequestProcessor(AsyncContext asyncContext, <span style="color: #0000ff;">int</span><span style="color: #000000;"> milliseconds) { </span><span style="color: #0000ff;">this</span>.asyncContext =<span style="color: #000000;"> asyncContext;</span><span style="color: #0000ff;">this</span>.milliseconds =<span style="color: #000000;"> milliseconds;}@Override</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> run() {System.out.println(</span>"Async Supported? "+<span style="color: #000000;"> asyncContext.getRequest().isAsyncSupported());longProcessing(milliseconds);</span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {PrintWriter out </span>=<span style="color: #000000;"> asyncContext.getResponse().getWriter();out.write(</span>"Processing done for " + milliseconds + " milliseconds!!"<span style="color: #000000;">);out.flush();out.close();} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (IOException e) {e.printStackTrace();}plete();}</span><span style="color: #0000ff;">private</span> <span style="color: #0000ff;">void</span> longProcessing(<span style="color: #0000ff;">int</span><span style="color: #000000;"> secs) { </span><span style="color: #008000;">//</span><span style="color: #008000;"> wait for given time before finishing</span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {Thread.sleep(secs);} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {e.printStackTrace();}}}异步的servlet依赖的初始化ThreadPoll的Listener(可选的,本例⼦中使⽤线程池,如不使⽤线程池时不需要):package com.jiaoyiping.websample.asyncServlet.async;/** Created with Intellij IDEA* USER: 焦⼀平* Mail: jiaoyiping@* Date: 2016/10/22* Time: 22:41* To change this template use File | Settings | Editor | File and Code Templates*/import javax.servlet.ServletContextEvent;import javax.servlet.ServletContextListener;import javax.servlet.annotation.WebListener;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;@WebListenerpublic class ApplicationListener implements ServletContextListener {@Overridepublic void contextInitialized(ServletContextEvent sce) {ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 100, 50000L,LISECONDS, new ArrayBlockingQueue<>(5000));sce.getServletContext().setAttribute("executor",executor);}@Override</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> contextDestroyed(ServletContextEvent sce) {ThreadPoolExecutor executor </span>=<span style="color: #000000;"> (ThreadPoolExecutor) sce.getServletContext().getAttribute(</span>"executor"<span style="color: #000000;">);executor.shutdown();}}异步servlet中添加的异步监听器(可选的)package com.jiaoyiping.websample.asyncServlet.async;/** Created with Intellij IDEA* USER: 焦⼀平* Mail: jiaoyiping@* Date: 2016/10/22* Time: 22:48* To change this template use File | Settings | Editor | File and Code Templates*/import javax.servlet.AsyncEvent;import javax.servlet.AsyncListener;import javax.servlet.ServletResponse;import javax.servlet.annotation.WebListener;import java.io.IOException;import java.io.PrintWriter;@WebListenerpublic class AppAsyncListener implements AsyncListener {@Overridepublic void onComplete(AsyncEvent event) throws IOException {System.out.println("AppAsyncListener complete");}@Override</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> onTimeout(AsyncEvent event) <span style="color: #0000ff;">throws</span><span style="color: #000000;"> IOException { ServletResponse response </span>=<span style="color: #000000;"> event.getAsyncContext().getResponse();PrintWriter out </span>=<span style="color: #000000;"> response.getWriter();out.write(</span>"TimeOut Error in Processing"<span style="color: #000000;">);out.flush();out.close();}@Override</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> onError(AsyncEvent event) <span style="color: #0000ff;">throws</span><span style="color: #000000;"> IOException {System.out.println(</span>"AppAsyncListener error"<span style="color: #000000;">);ServletResponse response </span>=<span style="color: #000000;"> event.getAsyncContext().getResponse();PrintWriter out </span>=<span style="color: #000000;"> response.getWriter();out.write(</span>"error on processing"<span style="color: #000000;">);out.flush();out.close();}@Override</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> onStartAsync(AsyncEvent event) <span style="color: #0000ff;">throws</span><span style="color: #000000;"> IOException { System.out.println(</span>"AppAsyncListener start"<span style="color: #000000;">);}}启动tomcat之后,我们jprofile连接到该tomcat容器启动的时候,线程图是这样的,⼀共有⼤概⼗⼏个的线程:线程快照:配置JMeter的线程组,在⼗秒钟内启动500个线程:测试同步的servlet:在请求同步的servlet时,线程图是这样⼦的(jvm中的线程数飙升到了203个,绿⾊的线表明我在那个时刻做了⼀次线程快照):线程快照是这样⼦的(容器中维护的线程数达到了203个):现在请求异步的servlet:请求时的线程图:线程快照:在对异步的servlet做压⼒测试时,jvm中的线程数量并没有⼤量地上升,我们在处理异步的servlet的时候,⾃⼰维护了⼀个线程池,基本上增加的线程都是来⾃这个线程池,因为使⽤了异步的servlet,servlet请求会⽴即返回servlet池,所以,需要servlet容器分配的sevlet线程的数量基本上没有增加多少,系统消耗的线程的数量下降了,对资源的消耗也会下降值得⼀提的是,异步的servlet并不会使客户端的访问速度加快,只是提升了服务器端的处理性能,减轻了服务器端的资源消耗,使得服务器端使⽤⽐较少的线程就能处理⼤量的连接,所以这个特性要在合适的场景下使⽤才可以另外,异步的servlet的编程模型要⽐之前的servlet复杂许多,这也是在开发的时候需要注意的,jetty的continuations也提供了类似的功能,并且提供了简化的编程模型,在任何⽀持servlet3.0的容器⾥都可以运⾏(不是只能在jetty中运⾏),我们项⽬组开发的针对安卓客户端的消息推送服务器就使⽤到了jetty的这个机制,在之后的⽂章⾥总结⼀下。

filterregistrationbean用法

filterregistrationbean用法

filterregistrationbean用法FilterRegistrationBean 是Spring 提供的一个工具类,用于注册和配置Filter。

本文将以[filterregistrationbean用法] 为主题,一步一步回答常见的问题,详细介绍FilterRegistrationBean 的用法。

1. 什么是FilterRegistrationBean?FilterRegistrationBean 是Spring 框架提供的一个类,用于注册和配置Filter。

它是Servlet 3.0 规范中增加的一个特性,用于在Web 应用启动时动态地注册和配置Filter。

2. FilterRegistrationBean 的作用是什么?FilterRegistrationBean 的作用是允许开发人员在Spring 中以编程的方式注册和配置Filter。

通过使用FilterRegistrationBean,我们可以在Spring Boot 应用启动时注册Filter,并通过FilterRegistrationBean 的方法设置Filter 的名称、URL 匹配模式和初始化参数等。

3. 如何使用FilterRegistrationBean 注册Filter?使用FilterRegistrationBean 注册Filter 需要以下几个步骤:3.1 创建一个Filter 类,并实现javax.servlet.Filter 接口的方法。

3.2 在Spring Boot 的配置类中,创建一个FilterRegistrationBean 的Bean,并设置Filter 类。

3.3 调用FilterRegistrationBean 的方法,配置Filter 的名称、URL 匹配模式和初始化参数等。

3.4 将FilterRegistrationBean 的Bean 添加到Spring 容器中。

下面我们一步一步来具体说明这些步骤。

20.Servlet3.0新特性-注解-JSP

20.Servlet3.0新特性-注解-JSP

20.Servlet3.0新特性-注解-JSPservlet3.0新特性之注解在JavaEE6规范中添加了了Servlet3.0 规范,该规范中允许在定义 Servlet、Filter 与 Listener 三⼤组件时使⽤注解,⽽不⽤在web.xml 进⾏注册了。

Servlet3.0 规范允许 Web 项⽬没有 web.xml 配置⽂件。

使⽤servlet3.0时需要jdk6+,tomcat7+servlet注解在3.0规范中使⽤@WebServlet()注解注册⼀个servlet,该注解中有多个属性,常⽤属性如下:属性名类型说明urlPatterns String[]相当于url-pattern的值value String[]与 urlPatterns 意义相同,不能与 urlPatterns 属性同时使⽤name String相当于servlet-name的值loadOnStartup int相当于loadOnStartup,默认值为-1initParams WebInitParam[]相当于init-param标签。

其类型为另⼀个注解 WebInitParam 数组例:之前都是讲解2.5版本的现在我们版本选择3.0,Eclipse 也可以打上勾勾让其允许创建web.xml :简单版:package Servlet;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;@WebServlet("/servlet3") //允许这样相当于只设置了urlPatternspublic class servlet3 extends HttpServlet {protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}}允许这样相当于只设置了urlPatterns,如果这样的话,那么如果有 getServletName 默认返回类名【全路径】 -可以⾃⼰试试例2:package Servlet;import java.io.IOException;import java.util.Enumeration;import javax.servlet.ServletConfig;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;//value 和 urlPatterns 意义相同,但不能⼀起使⽤⼆选⼀咯!我们学过了 url是可以多个的。

Servlet 3.0 实战:异步 Servlet 与 Comet 风格应用程序

Servlet 3.0 实战:异步 Servlet 与 Comet 风格应用程序
l l l l l
可插拔的 Web 架构(Web framework pluggability)。 通过 Annotations 代替传统 web.xml 配置文件的 EOD 易于开发特性(ease of development)。 Serlvet 异步处理支持。 安全性提升,如 Http Only Cookies、login/logout 机制。 其它改进,如文件上传的直接支持等。
回页首 实战 Servlet 异步处理 当前已经有不少支持 Servlet API 3.0 的 Web 容器,如 GlassFish v3、Tomcat 7.0、Jetty 8.0 等,在本文撰写时, Tomcat 7 和 Jetty 8 都仍然处于测试阶段,虽然支持 Servlet 3.0,但是提供的样例代码仍然是与容器耦合的 NIO 实 现,GlassFish v3 提供的样例(玻璃鱼聊天室)则是完全标准的 Servlet 3.0 实现,如果读者需要做找参考样例,不妨 优先查看 GlassFish 的 example 目录。本文后一部分会提供另外一个更具备实用性的例子“Web 日志系统”作为 Servlet API 3.0 的实战演示进行讲解。 Web 日志系统实战 Apache Log4j 是当前最主流的日志处理器,它有许多不同的 Appender 可以将日志输出到控制台、文件、数据库、 Email 等等。在大部分应用中用户都不可能查看服务器的控制台或者日志文件,如果能直接在浏览器上“实时”的查看 日志将会是给开发维护带来方便,在本例中将实现一个日志输出到浏览器的 Appender 实现。
l
长轮询(混合轮询) 长轮询与简单轮询的最大区别就是连接时间的长短:简单轮询时当页面输出完连接就关闭了,而长轮询一般会 保持 30 秒乃至更长时间,当服务器上期待的事件发生,将会立刻输出事件通知到客户端,接着关闭连接,同 时建立下一个连接开始一次新的长轮询。 长轮询的实现方式优势在于当服务端期待事件发生,数据便立即返回到客户端,期间没有数据返回,再较长的 等待时间内也没有新的请求发生,这样可以让发送的请求减少很多,而事件通知的灵敏度却大幅提高到几乎是 “实时”的程度。

weblistener注解

weblistener注解

@WebListener注解是Servlet 3.0+提供的注解,用于将类注册为Web应用程序的侦听器。

使用此注解的类必须实现以下一个或多个接口:javax.servlet.ServletContextListener、javax.servlet.ServletContextAttributeListener、javax.servlet.ServletRequestListener、javax.servlet.ServletRequestAttributeListener、javax.servlet.http.HttpSessionListener、javax.servlet.http.HttpSessionAttributeListener。

带有@WebListener注解的类可以实现以上接口,并重写其事件方法,例如contextInitialized 和contextDestroyed等,以便在Web应用程序启动和关闭时执行特定的操作。

此外,@WebListener注解还可以设置一些属性,如value,用于为侦听器设置一个可选的描述。

需要注意的是,使用@WebListener注解的类通常需要满足Servlet API的依赖关系,因此需要将其部署在一个支持Servlet 3.0或更高版本的Web服务器或应用服务器上。

servlet通俗解释

servlet通俗解释

servlet通俗解释(原创实用版)目录1.Servlet 的定义与作用2.Servlet 的生命周期3.Servlet 的类型4.Servlet 的优点5.Servlet 与 JavaServer Pages(JSP)的关系正文Servlet,全称 Server Applet,是一种运行在服务器端的 Java 程序,用于响应来自客户端的请求。

它接收客户端发送的请求,处理后生成相应的响应,再发送给客户端。

Servlet 充当了服务器与客户端之间的中介角色,是 Web 应用程序的重要组成部分。

Servlet 的生命周期分为以下几个阶段:实例化、初始化、响应客户端请求、销毁。

实例化阶段,服务器会创建一个 Servlet 对象。

初始化阶段,Servlet 对象会执行 init() 方法,进行初始化操作。

响应客户端请求阶段,Servlet 对象会根据客户端的请求执行相应的方法,如 doGet() 或 doPost(),并生成响应。

销毁阶段,Servlet 对象会执行 destroy() 方法,然后被服务器销毁。

Servlet 可以分为两类:HttpServlet 和 HttpServletRequest。

HttpServlet 是继承了 HttpServletRequest 和 HttpServletResponse接口的抽象类,它包含了处理客户端请求的方法,如 doGet()、doPost() 等。

HttpServletRequest 接口包含了客户端请求的信息,如请求的 URL、请求方法、请求头等。

HttpServletResponse 接口包含了响应客户端请求的信息,如响应状态码、响应头、响应体等。

Servlet 具有以下优点:1.跨平台:Servlet 程序可以在不同的操作系统和硬件平台上运行,因为它是基于 Java 语言编写的。

2.可扩展性:Servlet 可以根据需要进行扩展,以支持更多的功能和特性。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

简介:Servlet 是 Java EE 规范体系的重要组成部分,也是 Java 开发人员必须具备的基础技能,Servlet 3.0 是 Servlet 规范的最新版本。

本文主要介绍了 Servlet 3.0 引入的若干重要新特性,包括异步处理、新增的注解支持、可插性支持等等,为读者顺利向新版本过渡扫清障碍.Servlet 3.0 新特性概述Servlet 3.0 作为 Java EE 6 规范体系中一员,随着 Java EE 6 规范一起发布。

该版本在前一版本(Servlet 2.5)的基础上提供了若干新特性用于简化 Web 应用的开发和部署。

其中有几项特性的引入让开发者感到非常兴奋,同时也获得了 Java 社区的一片赞誉之声:异步处理支持:有了该特性,Servlet 线程不再需要一直阻塞,直到业务处理完毕才能再输出响应,最后才结束该 Servlet 线程。

在接收到请求之后,Servlet 线程可以将耗时的操作委派给另一个线程来完成,自己在不生成响应的情况下返回至容器。

针对业务处理较耗时的情况,这将大大减少服务器资源的占用,并且提高并发处理速度。

新增的注解支持:该版本新增了若干注解,用于简化 Servlet、过滤器(Filter)和监听器(Listener)的声明,这使得 web.xml 部署描述文件从该版本开始不再是必选的了。

可插性支持:熟悉 Struts2 的开发者一定会对其通过插件的方式与包括Spring 在内的各种常用框架的整合特性记忆犹新。

将相应的插件封装成 JAR 包并放在类路径下,Struts2 运行时便能自动加载这些插件。

现在 Servlet 3.0 提供了类似的特性,开发者可以通过插件的方式很方便的扩充已有 Web 应用的功能,而不需要修改原有的应用。

下面我们将逐一讲解这些新特性,通过下面的学习,读者将能够明晰了解 Servlet 3.0 的变化,并能够顺利使用它进行日常的开发工作。

异步处理支持Servlet 3.0 之前,一个普通 Servlet 的主要工作流程大致如下:首先,Servlet 接收到请求之后,可能需要对请求携带的数据进行一些预处理;接着,调用业务接口的某些方法,以完成业务处理;最后,根据处理的结果提交响应,Servlet 线程结束。

其中第二步的业务处理通常是最耗时的,这主要体现在数据库操作,以及其它的跨网络调用等,在此过程中,Servlet 线程一直处于阻塞状态,直到业务方法执行完毕。

在处理业务的过程中,Servlet 资源一直被占用而得不到释放,对于并发较大的应用,这有可能造成性能的瓶颈。

对此,在以前通常是采用私有解决方案来提前结束 Servlet 线程,并及时释放资源。

Servlet 3.0 针对这个问题做了开创性的工作,现在通过使用Servlet 3.0 的异步处理支持,之前的 Servlet 处理流程可以调整为如下的过程:首先,Servlet 接收到请求之后,可能首先需要对请求携带的数据进行一些预处理;接着,Servlet 线程将请求转交给一个异步线程来执行业务处理,线程本身返回至容器,此时 Servlet 还没有生成响应数据,异步线程处理完业务以后,可以直接生成响应数据(异步线程拥有 ServletRequest 和 ServletResponse 对象的引用),或者将请求继续转发给其它 Servlet。

如此一来, Servlet 线程不再是一直处于阻塞状态以等待业务逻辑的处理,而是启动异步线程之后可以立即返回。

异步处理特性可以应用于 Servlet 和过滤器两种组件,由于异步处理的工作模式和普通工作模式在实现上有着本质的区别,因此默认情况下,Servlet 和过滤器并没有开启异步处理特性,如果希望使用该特性,则必须按照如下的方式启用:对于使用传统的部署描述文件 (web.xml) 配置 Servlet 和过滤器的情况,Servlet 3.0 为 <servlet> 和 <filter> 标签增加了<async-supported> 子标签,该标签的默认取值为 false,要启用异步处理支持,则将其设为 true 即可。

以 Servlet 为例,其配置方式如下所示: <servlet><servlet-name>DemoServlet</servlet-name><servlet-class>footmark.servlet.DemoServlet</servlet-class><async-supported>true</async-supported></servlet>对于使用 Servlet 3.0 提供的 @WebServlet 和 @WebFilter 进行Servlet 或过滤器配置的情况,这两个注解都提供了asyncSupported 属性,默认该属性的取值为 false,要启用异步处理支持,只需将该属性设置为 true 即可。

以 @WebFilter 为例,其配置方式如下所示:@WebFilter(urlPatterns = "/demo",asyncSupported = true) public class DemoFilter implements Filter{...}一个简单的模拟异步处理的 Servlet 示例如下:@WebServlet(urlPatterns = "/demo", asyncSupported = true) public class AsyncDemoServlet extends HttpServlet {@Overridepublic void doGet(HttpServletRequest req, HttpServletResponse resp)throws IOException, ServletException {resp.setContentType("text/html;charset=UTF-8");PrintWriter out = resp.getWriter();out.println("进入Servlet的时间:" + new Date() + "."); out.flush();//在子线程中执行业务调用,并由其负责输出响应,主线程退出 AsyncContext ctx = req.startAsync();new Thread(new Executor(ctx)).start();out.println("结束Servlet的时间:" + new Date() + "."); out.flush();}}public class Executor implements Runnable {private AsyncContext ctx = null;public Executor(AsyncContext ctx){this.ctx = ctx;}public void run(){try {//等待十秒钟,以模拟业务方法的执行Thread.sleep(10000);PrintWriter out = ctx.getResponse().getWriter();out.println("业务处理完毕的时间:" + new Date() + "."); out.flush();plete();} catch (Exception e) {e.printStackTrace();}}}除此之外,Servlet 3.0 还为异步处理提供了一个监听器,使用AsyncListener 接口表示。

它可以监控如下四种事件:异步线程开始时,调用 AsyncListener 的onStartAsync(AsyncEvent event) 方法;异步线程出错时,调用 AsyncListener 的 onError(AsyncEvent event) 方法;异步线程执行超时,则调用 AsyncListener 的onTimeout(AsyncEvent event) 方法;异步执行完毕时,调用 AsyncListener 的 onComplete(AsyncEvent event) 方法;要注册一个 AsyncListener,只需将准备好的 AsyncListener 对象传递给 AsyncContext 对象的 addListener() 方法即可,如下所示:AsyncContext ctx = req.startAsync();ctx.addListener(new AsyncListener() {public void onComplete(AsyncEvent asyncEvent) throws IOException {// 做一些清理工作或者其他}...});新增的注解支持Servlet 3.0 的部署描述文件 web.xml 的顶层标签 <web-app> 有一个 metadata-complete 属性,该属性指定当前的部署描述文件是否是完全的。

如果设置为 true,则容器在部署时将只依赖部署描述文件,忽略所有的注解(同时也会跳过 web-fragment.xml 的扫描,亦即禁用可插性支持,具体请看后文关于可插性支持的讲解);如果不配置该属性,或者将其设置为 false,则表示启用注解支持(和可插性支持)。

@WebServlet@WebServlet 用于将一个类声明为 Servlet,该注解将会在部署时被容器处理,容器将根据具体的属性配置将相应的类部署为 Servlet。

该注解具有下表给出的一些常用属性(以下所有属性均为可选属性,但是 vlaue 或者 urlPatterns 通常是必需的,且二者不能共存,如果同时指定,通常是忽略 value 的取值):表 1. @WebServlet 主要属性列表属性名类型描述name String 指定 Servlet 的 name 属性,等价于 <servlet-name>。

如果没有显式指定,则该 Servlet 的取值即为类的全限定名。

value String[] 该属性等价于 urlPatterns 属性。

两个属性不能同时使用。

urlPatterns String[] 指定一组 Servlet 的 URL 匹配模式。

等价于 <url-pattern> 标签。

相关文档
最新文档