官方网址：http://www.eclipse.org/jetty/html
下载地址：http://download.eclipse.org/jetty/stable-9/dist/java
文档网址：http://www.eclipse.org/jetty/documentation/web
当前Jetty网址上推荐使用的稳定版本：Jetty9.0。编程
Jetty9内容位于http://www.eclipse.org/jetty/documentation。api
直接连接：安全
http://www.eclipse.org/jetty/documentation/current/embedding-jetty.html服务器
Jetty有一个标语，“不要部署你的应用在Jetty上，部署Jetty在你的应用中”。这意味着可选择使用Jetty捆绑你的应用做为一个标准WAR进行部署。Jetty设计成一个软件组件，能够实例化而且使用在Java程序中，例如：如何POJO。可是另一种方法，以嵌入式模式运行Jetty，这意味着把HTTP模块放入到你的应用中，而不是把你的应用放入到HTTP服务中。网络
本教程引导你逐步从最简单的Jetty服务实例到使用标准部署描述运行多个Web应用。大部分示例的源代码是标准Jetty项目的一部分。session
在学习该教程以前，完成一个HelloWorld教程是值得的。该教程能够在“嵌入式Jetty网络研讨会记录”中找到。app
Jetty版本：本教程的代码来自于Jetty7，可是也应该在Jetty 8中可使用。对于最新的稳定版本，参考最新发行版的连接代码。可能与本教程中给出的代码例子有稍微的不一样。
为了嵌入Jetty服务，一般执行下面的步骤：
1）建立一个服务
2）添加和配置链接器
3）添加和配置处理器
4）添加和配置Servlet、Webapp处处理器
5）启动服务
6）等待（join服务防止主线程退出）
下面的代码来自于SimplestServer.jar，实例化和运行一个最简单的Jetty服务
http://download.eclipse.org/jetty/stable-9/xref/org/eclipse/jetty/embedded/SimplestServer.html
public class SimplestServer
{
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
server.start();
server.join();
}
}
在端口8080上运行一个HTTP服务。这不是很是有用的服务，由于它不处理，对于每一个请求只是返回一个404错误。
为了生成请求的响应，Jetty要求在服务上设置一个Handler。一个处理器可能：
1） 检查和修改HTTP请求
2）生成完整的HTTP详情
3）调用其余的处理器（参见HandlerWrapper）
4）选择一个或者多个处理器调用（参考HandlerCollection）
http://download.eclipse.org/jetty/stable-9/xref/org/eclipse/jetty/server/handler/HandlerWrapper.html
Hello world处理器：
下面代码基于HelloHandler.java，显示一个简单的Helloworld处理器。
public classHelloHandler extends AbstractHandler
{
public void handle(String target,RequestbaseRequest,HttpServletRequest request,HttpServletResponse response)
throws IOException, ServletException
{
response.setContentType("text/html;charset=utf-8");
response.setStatus(HttpServletResponse.SC_OK);
baseRequest.setHandled(true);
response.getWriter().println("<h1>HelloWorld</h1>");
}
}
传递给handle方法的参数包括：
1） target - 请求的目标，它能够是一个URI或者命名分发器的名称
2） baseRequest – Jetty可变请求对象，它老是解包的
3） request - 不可变的请求对象，它可能已经被封装
4） response - 响应，它可能已经被封装
处理器设置请求的状态，内容类型，在使用writer生成请求体以前标注请求已经处理（后续就再也不处理）。
下面的代码来自于OneHandler.java，显示Jetty服务如何使用该处理器。
public staticvoid main(String[] args) throws Exception
{
Server server = new Server(8080);
server.setHandler(new HelloHandler());
server.start();
server.join();
}
如今你知道基于Jetty编写一个HTTP服务所须要了解的全部东西。然而，复杂的请求处理一般使用多处理器构建。咱们在后面章节中看看它是如何组合处理器的。你能查看Jetty的org.eclipse.jetty.server.handler包中有那些可用处理器。
为了配置服务使用的HTTP链接。你能设置服务上的一个或者多个链接器。你能详细配置每一个连接，例如：接口、端口、缓冲大小，超时时间等。
下面的代码基于ManyConnectors.java，显示如何为HelloWorld示例设置和配置链接器。
public class ManyConnectors
{
public static void main(String[] args) throws Exception
{
Server server = new Server();
SelectChannelConnector connector0 = new SelectChannelConnector();
connector0.setPort(8080);
connector0.setMaxIdleTime(30000);
connector0.setRequestHeaderSize(8192);
SelectChannelConnector connector1 = new SelectChannelConnector();
connector1.setHost("127.0.0.1");
connector1.setPort(8888);
connector1.setThreadPool(new QueuedThreadPool(20));
connector1.setName("admin");
SslSelectChannelConnector ssl_connector = newSslSelectChannelConnector();
String jetty_home =
System.getProperty("jetty.home","../jetty-distribution/target/distribution");
System.setProperty("jetty.home",jetty_home);
ssl_connector.setPort(8443);
SslContextFactory cf = ssl_connector.getSslContextFactory();
cf.setKeyStore(jetty_home + "/etc/keystore");
cf.setKeyStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
cf.setKeyManagerPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");
server.setConnectors(new Connector[]{ connector0, connector1,ssl_connector });
server.setHandler(new HelloHandler());
server.start();
server.join();
}
}
复杂请求处理一般构建多个处理器，可以以各类方式组合：
1） 处理器集合：保留其余处理器集合，依次调用每一个处理器。对于合并统计和日志处理器（生成请求的处理器）是有用的。
2） 处理器列表：一个处理器集合，依次调用处理器直到抛出异常、委派响应或request.isHandled返回true。它能做为合并处理器使用，有条件的处理一个请求。
3） 处理器封装：一个处理器基类能够用于菊花链处理程序，以面向方面编程风格组合在一块儿。例如，一个标准的Web应用经过上下文、会话、安全和Servlet处理器的链式实现。
4） 内容处理器集合：使用最长的请求URI前缀（contextPath）来选择指定的ContextHandler来处理请求。
参见如何编写Jetty处理器。
http://wiki.eclipse.org/Jetty/Howto/Write_Jetty_Handler
下面代码来自于FileServer.java，使用HandleList组合ResourceHandler和DefaultHandler。
public class FileServer
{
public static void main(String[] args) throws Exception
{
Server server = new Server();
SelectChannelConnector connector = new SelectChannelConnector();
connector.setPort(8080);
server.addConnector(connector);
ResourceHandler resource_handler = new ResourceHandler();
resource_handler.setDirectoriesListed(true);
resource_handler.setWelcomeFiles(new String[]{ "index.html"});
resource_handler.setResourceBase(".");
HandlerList handlers = new HandlerList();
handlers.setHandlers(new Handler[] { resource_handler, newDefaultHandler() });
server.setHandler(handlers);
server.start();
server.join();
}
}
资源处理器首先传递给请求，查看在本地目录下是否有知足的文件。若是没有找到一个文件，请求传递给缺省的处理器生成一个404错误（或favicon.ico）。
如今是时候让你记住JettyXML配置格式可以渲染简单的Java代码到XML配置。因此上面的文件服务器例子可使用Jetty XML来编写，以下。
<?xml version="1.0"?>
<!DOCTYPE Configure PUBLIC"-//Jetty//Configure//EN""http://www.eclipse.org/jetty/configure.dtd">
<Configure id="FileServer"class="org.eclipse.jetty.server.Server">
<Call name="addConnector">
<Arg>
<Newclass="org.eclipse.jetty.server.nio.SelectChannelConnector">
<Set name="port">8080</Set>
</New>
</Arg>
</Call>
<Set name="handler">
<New class="org.eclipse.jetty.server.handler.HandlerList">
<Set name="handlers">
<Arraytype="org.eclipse.jetty.server.Handler">
<Item>
<Newclass="org.eclipse.jetty.server.handler.ResourceHandler">
<Setname="directoriesListed">true</Set>
<Setname="welcomeFiles">
<Arraytype="String"><Item>index.html</Item></Array>
</Set>
<Setname="resourceBase">.</Set>
</New>
</Item>
<Item>
<Newclass="org.eclipse.jetty.server.handler.DefaultHandler">
</New>
</Item>
</Array>
</Set>
</New>
</Set>
</Configure>
你能够从FileServerXml.java中运行这个XML文件。
public class FileServerXml
{
public static void main(String[] args) throws Exception
{
Resource fileserver_xml =Resource.newSystemResource("fileserver.xml");
XmlConfiguration configuration = newXmlConfiguration(fileserver_xml.getInputStream());
Server server = (Server)configuration.configure();
server.start();
server.join();
}
}
你也能使用Spring框架聚合Jetty服务，上面的文件服务器示例可使用Spring配置重写，以下：
<beans>
<bean id="Server"class="org.eclipse.jetty.server.Server" init-method="start"destroy-method="stop">
<property name="connectors">
<list>
<bean id="Connector"class="org.eclipse.jetty.server.nio.SelectChannelConnector">
<property name="port" value="8080"/>
</bean>
</list>
</property>
<property name="handler">
<bean id="handlers"class="org.eclipse.jetty.server.handler.HandlerList">
<property name="handlers">
<list>
<beanclass="org.eclipse.jetty.server.handler.ResourceHandler">
<propertyname="directoriesListed" value="true"/>
<propertyname="welcomeFiles">
<list>
<value>index.html</value>
</list>
</property>
<propertyname="resourceBase" value="."/>
</bean>
<beanclass="org.eclipse.jetty.server.handler.DefaultHandler"/>
</list>
</property>
</bean>
</property>
</bean>
</beans>
参考：如何使用Spring配置Jetty。http://wiki.eclipse.org/Jetty/Howto/Spring
ContextHandler是是HandlerWrapper，只负责请求符合配置上下路径的URL前缀。
符合上下文路径（有它们路径方法）的请求将进行相应的更新，如下可选上下文特征被正确的应用。
* 一个线程内容类加载器
* 属性的集合
* 初始化参数集合
* 基础资源（又名文档根目录）
* 虚拟主机名集合
没有匹配的请求不进行处理。
下面的代码基于OneContext.java，设置上下文路径和hello处理器的类加载器。
public class OneContext
{
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
ContextHandler context = new ContextHandler();
context.setContextPath("/hello");
context.setResourceBase(".");
context.setClassLoader(Thread.currentThread().getContextClassLoader());
server.setHandler(context);
context.setHandler(new HelloHandler());
server.start();
server.join();
}
}
Servlet是提供应用逻辑和处理HTTP请求的标准方法。Servlet就像约束标准方法的处理器映射指定URI给指定的Servlet。下面的代码基于HelloServlet.java。
public class HelloServlet extendsHttpServlet
{
private String greeting="Hello World";
public HelloServlet(){}
public HelloServlet(String greeting)
{
this.greeting=greeting;
}
protected void doGet(HttpServletRequest request, HttpServletResponseresponse) throws ServletException, IOException
{
response.setContentType("text/html");
response.setStatus(HttpServletResponse.SC_OK);
response.getWriter().println("<h1>"+greeting+"</h1>");
response.getWriter().println("session=" +request.getSession(true).getId());
}
}
ServletContextHandler是一个支持标准Servlet的专用ContextHandler。下面的代码来自于OneServletContext，显示三个HelloworldServlet实例注册到一个ServletContextHandler上。
public class OneServletContext
{
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
ServletContextHandler context = newServletContextHandler(ServletContextHandler.SESSIONS);
context.setContextPath("/");
server.setHandler(context);
context.addServlet(new ServletHolder(newHelloServlet()),"/*");
context.addServlet(new ServletHolder(new HelloServlet("BuongiornoMondo")),"/it/*");
context.addServlet(new ServletHolder(new HelloServlet("Bonjour leMonde")),"/fr/*");
server.start();
server.join();
}
}
一个Web应用上下文是ServletContextHandler的变种，使用标准的布局和web.xml配置Servlet、过滤器和其它特征。
public class OneWebApp
{
public static void main(String[] args) throws Exception
{
String jetty_home =System.getProperty("jetty.home","..");
Server server = new Server(8080);
WebAppContext webapp = new WebAppContext();
webapp.setContextPath("/");
webapp.setWar(jetty_home+"/webapps/test.war");
server.setHandler(webapp);
server.start();
server.join();
}
}
若是不熟期间，你没有组装应用程序为WAR文件，你能够从源组件上运行它，以下：
public class OneWebAppUnassembled
{
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
WebAppContext context = new WebAppContext();
context.setDescriptor(webapp+"/WEB-INF/web.xml");
context.setResourceBase("../test-jetty-webapp/src/main/webapp");
context.setContextPath("/");
context.setParentLoaderPriority(true);
server.setHandler(context);
server.start();
server.join();
}
}
上下文处理器集合使用最长请求URI前缀选择指定的上下文。下面的示例在单个Jetty服务上组合前面两个示例。
public class ManyContexts
{
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
ServletContextHandler context0 = newServletContextHandler(ServletContextHandler.SESSIONS);
context0.setContextPath("/ctx0");
context0.addServlet(new ServletHolder(newHelloServlet()),"/*");
context0.addServlet(new ServletHolder(new HelloServlet("BuongiornoMondo")),"/it/*");
context0.addServlet(new ServletHolder(new HelloServlet("Bonjour leMonde")),"/fr/*");
WebAppContext webapp = new WebAppContext();
webapp.setContextPath("/ctx1");
webapp.setWar(jetty_home+"/webapps/test.war");
ContextHandlerCollection contexts = new ContextHandlerCollection();
contexts.setHandlers(new Handler[] { context0, webapp });
server.setHandler(contexts);
server.start();
server.join();
}
}
嵌入式JSP支持可能有点使人困惑，若是你查看Jetty发行版lib/jsp目录下的JAR包。这是由于咱们为Eclipse封装了JSP软件集，标记为OSGI软件集，不能直接从Maven Central中直接下载。在Maven中心中有可用的依赖，由于它们有OSGI软件集本身实际源码。OSGI软件集简化Maven中心artifact，解压成多个扩展的bundle。
你能使用的示例以下：
INFO]org.eclipse.jetty:jetty-jsp-2.1:jar:7.2.2-SNAPSHOT
[INFO] +-org.eclipse.jetty:jetty-util:jar:7.2.2-SNAPSHOT:provided
[INFO] +-org.mortbay.jetty:jsp-2.1-glassfish:jar:2.1.v20100127:provided
[INFO] | +- org.eclipse.jdt.core.compiler:ecj:jar:3.5.1:provided
[INFO] | +- org.mortbay.jetty:jsp-api-2.1-glassfish:jar:2.1.v20100127:provided
[INFO] | \- ant:ant:jar:1.6.5:provided
[INFO] \-javax.servlet:servlet-api:jar:2.5:provided
你应该可以依赖于一个嵌入式聚合，咱们提供获取这些依赖，没有任何问题。
http://repo2.maven.org/maven2/org/eclipse/jetty/aggregate