webServer jetty

http://www.jforum.net/confluence/display/integration/Overview

HTTP ERROR: 404

NOT_FOUND

RequestURI=/confluence/display/integration/Overview

Powered by Jetty://

Jetty是什么 Jetty项目简介

http://jiajunde.iteye.com/blog/373262

http://bbs.163jsp.com/posts/list/427.html

【Android】Android上的Jetty

http://www.iteye.com/topic/163603?page=1

研究一下jetty & selenium

http://www.iteye.com/topic/154546

Jetty Powered

http://www.iteye.com/topic/775?page=1

Jetty 源码分析

http://docs.huihoo.com/jetty/1.html

忙活了半天,Jetty比Tomcat在我的开发中没啥优势

http://www.iteye.com/topic/196211?page=2

Google 选择 Jetty, 放弃 Tomcat

http://www.iteye.com/news/9918

http://tech.it168.com/a2009/0819/638/000000638808.shtml

http://jetty.mortbay.org/jetty/

Jetty 是一个开源、基于标准、全功能实现的JAVA服务器。它在Apache2.0协议 下发布，因此可以自由的用于商业用途和发行。首创于1995年，Jetty受益于一个广大的用户社区，有一个稳定的核心开发者来持续专著的开发。有很多正在运行的使用Jetty的例子，这也不过是千分之十的Jetty实例。 虽然Jetty的目标很低调, 无数的站点和产品使用Jetty,但是Jetty无处不见!
Jetty 可以用来:
◆一个传统的web 服务器来处理静态和动态网页；
◆最为一个专用HTTP服务器的后台来处理动态网页，就像Apache使用mod_proxy；
◆作为一个JAVA应用程序的内嵌组件。
这种灵活性意味着Jetty可以用在多种场合：
◆随产品做外盒使用，例如Tapestry, Liferay；
◆随书光盘里，用来运行例子；
◆合并到程序里提供HTTP传输，例如JXTA, MX4J；
◆集成到JavaEE服务器作为web容器，例如JOnAS, Geronimo, JBoss, JFox；
◆作为一个应用程序的组件，例如Continuum, FishEye, Maven。
Jetty 的特点：
简单
Jetty的指导原则是“简单不复杂“。Jetty容易理解和使用：
◆通过API或者XML文件配置；
◆XML文件语法直接了当地在POJOs上影射API操作；
◆默认的配置文件可以使Jetty作为外盒（out-of-the-box）；
◆只需少量的行数就可以嵌入一个Jetty实例。

可扩展性
在异步的WEB2.0类型的应用程序使用的技术，例如AJAX，连接停留时间要比处理一个静态页长，线程和内存需求可能急剧增长。
底层必须优雅地处理这些问题，一个低速的数据库连接可能造成站点瘫痪，因为线程被占满了。使用Jetty...

◆在高强度服务压力性能损失少；
◆在现有的web规范的框架下，能处理大用户负载，保证长时间会话的连续性；
◆整合现有聚类，例如WADI和Terracotta

高效
大量的努力用来优化代码，精炼的代码以至于漏洞尽可能少：
◆相关性尽可能少；
◆核心保持最小，附加函数放在可选包中；
◆可扩展性是一个关键问题；
◆高强度下性能衰减平缓。

嵌入性
Jetty是一个非常好的组件。这意味着很容易嵌入到一个应用程序中，而不需要应用程序去适应它：
◆使用依赖注射和反转的控制模式

插入性
Jetty被建构的适合
Jetty内建插入性。所有Jetty核心组件的实现允许不同的选择，至少一个或者更多，组件的实现总是会提供的。 如果这些仍然不能满足你的要求，你可以自由的编写底层接口和抽象类最为基础。这意味着Jetty能够容易地用在一个特别的应用环境中。当Jetty在一个 JavaEE服务器中作为web容器时，这是相当有用的，Jetty的插入性保证了它和主机容器的一个紧密的集成。

Jetty is an open-source, standards-based, full-featured web server implemented entirely in Java. It is released under the Apache 2.0 licence and is therefore free for commercial use and distribution. First created in 1995, Jetty has benefitted from input from a vast user community and consistent and focused development by a stable core of lead developers. There are many more examples of Jetty in action on the Jetty Powered Page that has selections from among the tens of thousands of production Jetty instances. However, as Jetty aims to be as unobtrusive as possible, countless websites and products are based around Jetty, but Jetty is invisible!

Full commercial support, training and development services for Jetty and Jetty-based projects are available from Webtide.

Jetty can be used as:

* a stand-alone traditional web server for static and dynamic content
* a dynamic content server behind a dedicated HTTP server such as Apache using mod_proxy
* an embedded component within a java application

This flexibility means that Jetty can be encountered in a number of different contexts:

* shipped with products to provide out-of-the-box useability eg Tapestry, Liferay
* distributed on CDs with books to make examples and exercises ready-to-run
* incorporated into applications as a HTTP transport eg JXTA, MX4J
* integrated as a web container in JavaEE app servers eg JOnAS, Geronimo, JBoss, JFox
* included as a component of an application eg Continuum, FishEye, Maven

Some of the defining features of Jetty are:
Simplicity
The guiding principle of Jetty could be said to be "simplicity not complexity". We want to make Jetty easy to understand and use:

* Configuration is either by API or by xml file
* Xml file syntax is a straightforward mapping from the API operating on POJOs
* Default configuration files make Jetty useable out-of-the-box
* Minimal number of lines required to embed a Jetty instance

Scalability
In asynchronous Web 2.0 type applications using techniques such as AJAX, connections stay open longer than when serving static pages, and thread and memory requirements can escalate drastically. Infrastructure must handle that gracefully lest an individual component, such as a slow database connection stop an entire site because of a lack of threads. With Jetty...

* Performance degrades gracefully under stress for high quality of service
* Working Within the framework of existing web specificiations, handle large user loads and long-lived sessions with continuations
* Integrations available to clustering options such as WADI and Terracotta

Efficiency
A lot of effort goes into optimizing Jetty's performance and crafting the code so as to make the footprint as small as possible:

* Dependencies are kept to the absolute minimum
* The core is kept small with extra functionality in optional jars
* Scalability is a key concern
* Performance degrades gracefully under stress

Embeddability
Jetty is designed to be a good component. This means that it can easily be embedded in an application without forcing the application to adapt to it:

* Usage of dependency injection and inversion of control patterns

Pluggability
Jetty is architected for pluggability. The API allows different implementations of all of the principal Jetty components to be selected. At least one, but sometimes more, implementations of a component are always provided. However if these do not meet your needs, you are free to code your own using the interfaces and abstract classes as a basis. This means that Jetty can be easily customised to a particular application environment. This is particularly useful when Jetty is acting as the web container in a JavaEE server, as Jetty's pluggability ensures a tight integration with a host container.

Jetty 源码分析

http://docs.huihoo.com/jetty/1.html

<!-- 开始正文-->

一、 总括      你了解Jetty 吗，就像我们所熟知的Tomcat一样, Jetty是一个免费的开放源码的100%纯Java的Http服务器和Servlet容器。
Jetty具备以下特点：
快速高效
。Jetty是最快的Servlet服务器之一
。Jetty可以处理上千个并发连接
小巧嵌入
。Jetty的jar只有600多K
。可动态嵌入到应用程序，适合开发web2.0等应用
应用广泛
。开源项目有Geronimo , JBoss , JOnAS 等
。商业项目有IBM Tivoli, Sonic MQ and Cisco SESM等
可到Jetty网站 http://jetty.mortbay.org/jetty/ 查看最新信息
本文将通过对Jetty最新稳定版 Jetty5.1.5RC2 源码的研究，向读者展示Jetty在设计方面使用的不同设计理念, 希望对广大开发者在设计自己的系统时有所帮助。
Jetty按照功能可以分为四个主个主要的部分,HttpServer, HttpContext,HttpHandler,HttpListener,详见如下类图:
<图 1-1>
二、HttpServer及配置
对于初次接触Jetty的人一定会对上图感到迷惑，其实在Jetty中 HttpServer是一个服务器的核心控制类, 我们可以看到，其它的组件类都是由该类扩展开来，HttpServer的作用就是在一系列的监听器类和处理器类之间搭起了一个桥梁,有效的控制着消息在系 统内的传递,如下图:
<图 1-2 >
HttpServer职责是接受从HttpListener传递过来的request(请 求),HttpServer通过对request的Host(主机)或Path(路径)进行匹配,然后分发给相应的HttpContext(可以理解为一 个web application)。
这里举个例子，假设我们现在要建立一个提供静态页面web服务,页面内容在c:\root \下,可以通过如此配置HttpServer:
HttpServer server = new HttpServer(); // 创建一个新的HttpServer
SocketListener listener = new SocketListener(); // 创建一个新监听器
listener.setPort(8080);// 设置监听端口为8080
server.addListener(listener);// 将监听类注册到server中
HttpContext context = new HttpContext(); // 创建一个新HttpContext
context.setContextPath("/app/*"); // 设置访问路径
context.setResourceBase("c:/root/"); // 设置静态资源路径
context.addHandler(new ResourceHandler()); // 为这个HttpContext添加一个静态资源处理器
server.addContext(context); // 将这个HttpContext注册到server中
server.start();// 最后启动这个server
当我们要建立一个提供动态页面web服务时, 假设我们自己的 web 应用放在Jetty目录下的webapps下并打好包文件名为myapp.war, 可以通过如此配置HttpServer:
Server server = new Server(); // 创建一个新的HttpServer
SocketListener listener = new SocketListener();// 创建一个新监听器
listener.setPort(8080); // 设置监听端口为8080
server.addListener(listener ); // 将监听类注册到server中
server.addWebApplication("myapp","./webapps/myapp/"); // 将这个web应用注册到这个Server中
server.start(); // 最后启动这个server
短短数行代码就可创建一个web服务器并启动它,这有点类似于我们windows中的即插 即用的概念,需要什么就添加什么,把这些类以HttpServer为核心组合在一起，就可以完成强大的功能。
三、Jetty Server
1.上面我们探讨了HttpServer的启动,读者一定还存在这样疑问,整个Jetty 服务器是怎样启动的？
首先我们可以在图 1-1 看到左下角有一个Server类,这个类实际上继承了HttpServer,当启动Jetty服务器时，具体来说，在Jetty根目录下命令行下如输入 java -jar start.jar etc/demo.xml，注意这里有一个配置文件 demo.xml做为运行参数,这个参数也可以是其它的配置文件,也可是多个xml配置文件，其实这个配置文件好比我们使用struts时的struts -config.xml文件，将运行Server需要用到的组件写在里面，比如上一节中HttpServer的配置需要的组件类都可以写在这个配置文件 中。
2.我们自己部署到Jetty的webapps目录下的web application,Jetty如何运行我们自己的web application?
首先当我们按上述方法启动Jetty Server时,就会调用Server类里面的main方法,这个入口方法首先会构造一个Server类实例(其实也就构造了一个 HttpServer),创建实例过程中就会构造XmlConfiguration类的对象来读取参数配置文件，之后再由这个配置文件产生的 XmlConfiguration对象来配置这个Server,配置过程其实是运用Java的反射机制调用Server的方法并传入配置文件中所写的参数 来向这个Server添加HttpListener,HttpContext,HttpHandler,web application(对应我们自己部署的web应用)。
添加我们自己的web application过程中相应的就会读取我们所熟知的/WEB-INF/web.xml来创建一个WebApplicationContext(这个 类继承了HttpContext)的实例,同时也会创建WebApplicationContext自身的ServletHandler(实现了 HttpHandler接口),注意到ServletHandler中包含一组ServletHolder指向实际的Servlet,譬如说我们在 web.xml文件中配置了两个Filter和一个Servlet,这里就会有三个ServletHolder,实际处理请求时 ServeletHandler就会依次调用这三个ServletHolder传入request,response处理(实际最后交给这两个 Filter和Servlet处理),这样我们自己做好的一个 web应用就挂载到这个Server上了,可以接受客户端相应的request(请求)。
四、运行原理(请参考如下时序图)
<图 1-7 >
上图展示了一个request的处理过程,首先HttpListener监听到客户端发来 的请求创建一个HttpConnection实例(封装了连接细节,比如从Socket连接中获取的输入流和输出流), HttpConnection对象构建过程中会创建Jetty内部自定义的HttpRequest和HttpResponse对象,接着 HttpListener会调用这个HttpConnection实例的handle方法, HttpConnection实例就调用HttpRequest对象的read()方法读取信息,调用HttpServer的service方法以 HttpRequest,HttpResponse为参数传给HttpServer,HttpServer又将HttpRequest和 HttpResponse分发给相应的HttpCotext,HttpContext最后将HttpRequest和HttpResponse交给自身的 HttpHandler 处理,在这里HttpRequest,HttpResponse被再次封装为ServletHttpRequest和 ServletHttpResponse,其实这两个类实现了我们所熟知的HttpServletRequest和 HttpServletResponse接口。
五、高级性能
1.HttpHandler:
该接口的实现类用于处理HttpContext分发过来的reqeust,不同的实现类的 有不同的处理功能,这里介绍几常用的HttpHandler实现类:
ReourceHandler:用于处理静态内容,如以扩展名为.html的文件
SecurityHandler:提供基本的安全验证
ForwardHandler:转发一个request到另一个url
ServletHandler:用于将request交由具体的Servlet类进行处理
2.当你在看图 1-2 时候会注意到HttpServer和HttpListener,HttpServer与HttpContext，HttpContext与 HttpHandler存在一对多的关系,下面就介绍一下它们之间的这种关系如何通过程序来配置.
HttpListener & HttpServer:
HttpListener是所有监听器类的接口,如图中的SocketListener (基于传统的Socket技术)就实现了该接口,Jetty还有其它的实现该接口类,如SocketChannelListener(基于NIO技术)类 等,HttpListener职责主要是在服务器启动后监听相应端口的来自客户端请求并建立连接(图 1-1 中所示用HttpConnection封装连接细节),监听器可在同个IP上开启多个端口为同一个HttpServer 进行监听,所以HttpListener和HttpServer是多对一的关系,如下图:
<图 1-3 >
配置代码：
HttpServer server = new HttpServer();
HttpListenrer listener1 = new SocketChanneListener();
Listener1.setPort(8080);
HttpListenrer listener1 = new SocketListener();
Listener1.setPort(8443);
server.addListener(listener1);
server.addListener(listener2);
HttpContext & HttpHandler:
HttpContext相当于对应客户端请求的URL或某个虚拟机, 其子类中包含若干个HttpHandler, 当接受到request(请求)时,HttpContext会依次(按某个预定的次序)把request交给这些HttpHandler处理,直到这个 request被标示处理过为止, 需要注意的是这个request可能被多个HttpHandler处理，但只能有一个HttpHandler能标示这个request已被处理过.
一个典型的HttpContext有用于安全处理、静态资源处理及Servlet类的 HttpHandler,如下图:
<图 1-4>
配置代码：
HttpContext context = new HttpContext();
context.setContextPath(“/myapp/*”);
HttpHandler securitHandler = new SecurityHandler();
HttpHandler resourceHandler = new ResourceHandler();
HttpHandler servletHandler = new ServletHandler();
context.addHandler(securitHandler);
context.addHandler(resourceHandler);
context.addHandler(servletHandler);
HttpServer & HttpContext:
一般的HTTP服务器软件可以同时处理多个web application,同样一个HttpServer可以包含多个HttpContext,如下图可以通过同一个端口的监听类来映射多个 HttpContext:
<图 1-5 >
配置代码：
HttpServer server = new HttpServer();
HttpContext context1 = new HttpContext();
context1.setContextPath(“/app1/*”);
HttpContext context2 = new HttpContext();
context2.setContextPath(“/app2/*”);
server.addContext(context1);
HttpServer & HttpLister & HttpContext:
另外Jetty对多网卡（多个IP地址,不同的主机名）的服务器也提供了很好的支持,每个 HttpContext都有自身的HttpServer:
<图 1-6 >
配置代码：
HttpServer server1 = new HttpServer();
SocketListener listener1 = new SocketListener();
listener1.setHost(“www.app1.com”);//orListener1.setHost(“www.app2.com”)
listener2.setPort(80);
HttpContext context1 = new HttpContext();
context1.setContextPath(“/”);
server1.addListener(listener1);
server1.addContext(context1);
3.Jetty对高并发的支持
<图 1-8>
如果多用户请求服务就会涉及到多线程的管理，如图 1-8,Jetty中主要由ThreadPool负责管理多线程，注意其中Pool.PondLife是Pool的一个内部接口, ThreadPool.PoolThread是ThreadPool的一个内部线程类,我们看到Pool.PondLife和Pool存在一个聚集的关 系，实际上Pool对象中存放在是一个个ThreadPool.PoolThread线程对象，当有新用户连接上Server时，ThreadPool就 从Pool中取一个空闲的线程为当前用户连接服务。
六、小结
本文通过图示简要介绍了Jetty整个体系架构和主要的组件类及服务器的启动执行过程,其 实Jetty 通常被用来做为内嵌的Web Server来使用，一些常见的服务器软件，如Apache Cocoon、JBoss ,JOnAs等都会采用Jetty作为Web解決方案；另外由于Jetty在性能及稳定性要优于同类HTTP Server的原因，Jetty已在国外已很流行,鉴于这一点,本文作者可以预测在不久的将来Jetty同样也会在国内流行开来。
附：
来源：http://blog.leiling.com/CALM/archive/2005/12/23/106662.aspx 作者联系方式：陈应刚 dycyg@yahoo.com 熊红阳

发布过程5分钟内load飙升性能问题排查

http://zhwj184.iteye.com/blog/1633278

这 几天新项目每次发布，都发现load在jetty重启过程中突然load会从0.1突然升高到15以上，3分钟后慢慢降到正常非常，cpu使用率也升高了 一些，但是jvm内存线程，gc都比较正常，所以怀疑应用已启动，执行了一些耗CPU的处理过程，查看了代码之后，应用已启动，执行最多的方法是 dowork，而这个方法里面会有解析xml的过程：

 public  OfferInfo parseXml(String content)  throws  NumberFormatException, XMLStreamException {
     if  (content ==  null  || content.isEmpty()) {
         return   null ;
     }
     XMLInputFactory factory = XMLInputFactory.newInstance();
     XMLStreamReader reader = null ;
     try  {
         reader = factory.createXMLStreamReader(new  StringReader(content));
     } catch  (XMLStreamException e1) {
         return   null ;
     }

     if  (reader ==  null ) {
         return   null ;
     }

     OfferInfo offerInfo = new  OfferInfo();
     while  (reader.hasNext()) {
         int  event =  0 ;
         try  {
             event = reader.nextTag();
         } catch  (Exception e) {
         }
         switch  (event) {
             case  XMLStreamConstants.START_ELEMENT:
                 if  (reader.getLocalName().equalsIgnoreCase(OFFER_ID)) {
                     offerInfo.setOfferId(Long.parseLong(reader.getElementText()));
                 } else   if  (reader.getLocalName().equalsIgnoreCase(MEMBER_ID)) {
                     offerInfo.setMemberId(reader.getElementText());
                 } else   if  (reader.getLocalName().equalsIgnoreCase(ACTION)) {
                     offerInfo.setAction(reader.getElementText());
                 }
                 break ;
             case  XMLStreamConstants.END_ELEMENT:
                 break ;
         }
     }
     return  offerInfo;

 }

这 段代码会解析整个xml文档，只取出里面三个字段，这里的应用场景是异步消息处理，因为应用在重启过程中，消息堆积，应用启动完后会处理比较多的堆积消 息，导致load和cpu升高，开始怀疑这段解析xml的过程耗性能，因为xml内容很大，达到1m以上，而且消息堆积量一下子也可能上万，然后就开始进 行优化，

 

在while循环中加入以下代码：

 

 //如果已经解析完需要的字段，则跳过剩余xml内容的解析，提高性能
 if (offerInfo.getOfferId() !=  null  && offerInfo.getMemberId() !=  null  && offerInfo.getAction() !=  null ){
     return  offerInfo;
 }

 只要解析出我们需要的三个字段，剩余的xml内容就不需要解析了，返回。

 

加上这段代码后，线上果然正常了。

 

因为在发布过程中来不及用jstack dump线程信息，用jstack dump线程信息，查看下当前线程处理状况，也应该很快能诊断出问题。

 

解析xml时解析完需要的数据就需要返回了，剩下的xml内容不需要解析，xml解析很耗性能。

 

我们看下修改这段代码前后的load和cpu的图

 

 

其他jvm指标都比较正常。

end