使用Maven

Apache Maven是一种软件项目管理和综合工具。基于项目对象模型（POM）的概念，Maven能从核心信息管理一个项目的构建、报告和文档。
他是用于构建一个web应用项目的理想工具，这些项目能用jetty-maven-plugin轻松的运行web应用，从而节省开发时间。你也能用Maven构建、测试和运行一个嵌入Jetty的项目。
首先我们将看一个很简单嵌入Jetty的HelloWorld Java应用，然后看一个简单的webapp怎么使用jetty-maven-plugin加速开发周期。

使用Maven

Maven在配置之上使用惯例，因此最好的方式是使用Maven推荐的项目结构。你能用archetypes快速设置Maven项目，但这里我们为这个简单的指导性例子手动地设置结构：

> mkdir JettyMavenHelloWorld
> cd JettyMavenHelloWorld
> mkdir -p src/main/java/org/example

创建HelloWorld类

用编辑器创建src/main/java/org/example/HelloWorld.java类，包含如下内容：

package org.example;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.handler.AbstractHandler;
 
public class HelloWorld extends AbstractHandler
{
    public void handle(String target,
                       Request baseRequest,
                       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>Hello World</h1>");
    }
 
    public static void main(String[] args) throws Exception
    {
        Server server = new Server(8080);
        server.setHandler(new HelloWorld());
  
        server.start();
        server.join();
    }
}

创建POM描述符

pom.xml文件描述项目名称和它的依赖。用编辑器创建文件pom.xml，包含如下内容：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>hello-world</artifactId>
  <version>0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
  <name>Jetty HelloWorld</name>
 
  <properties>
      <!-- Adapt this to a version found on
           http://central.maven.org/maven2/org/eclipse/jetty/jetty-maven-plugin/
        -->
      <jettyVersion>9.0.2.v20130417</jettyVersion>
  </properties>
 
  <dependencies>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>${jettyVersion}</version>
    </dependency>
  </dependencies>
 
  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.1</version>
        <executions>
          <execution><goals><goal>java</goal></goals></execution>
        </executions>
        <configuration>
          <mainClass>org.example.HelloWorld</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

构建和执行嵌入的HelloWorld

你现在能编译和执行HelloWorld类，使用下面的命令：

mvn clean compile exec:java

你能打开你的浏览器在http://localhost:8080看hello world页。你能通过mvn dependency:tree命令观察Maven正在后台为你做什么，包含了依赖的解析和下载：

> mvn dependency:tree
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'dependency'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Jetty HelloWorld
[INFO]    task-segment: [dependency:tree]
[INFO] ------------------------------------------------------------------------
[INFO] [dependency:tree {execution: default-cli}]
[INFO] org.example:hello-world:jar:0.1-SNAPSHOT
[INFO] \- org.eclipse.jetty:jetty-server:jar:9.0.0:compile
[INFO]    +- org.eclipse.jetty:javax.servlet:jar:3.0.0.v201112011016:compile
[INFO]    +- org.eclipse.jetty:jetty-continuation:jar:9.0.0:compile
[INFO]    \- org.eclipse.jetty:jetty-http:jar:9.0.0:compile
[INFO]       \- org.eclipse.jetty:jetty-io:jar:9.0.0:compile
[INFO]          \- org.eclipse.jetty:jetty-util:jar:9.0.0:compile
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4 seconds
[INFO] Finished at: Thu Jan 24 16:19:08 EST 2013
[INFO] Final Memory: 11M/68M
[INFO] ------------------------------------------------------------------------    

用Jetty和Maven开发一个标准WebApp

先前的例子演示怎么通过Maven在应用中使用嵌入Jetty。现在我们将测试看怎么使用Maven和Jetty开发一个标准webapp。首先创建Maven结构（你也能用maven webapp archetype代替）：

> mkdir JettyMavenHelloWarApp
> cd JettyMavenHelloWebApp
> mkdir -p src/main/java/org/example
> mkdir -p src/main/webapp/WEB-INF

创建一个Servlet

用编辑器创建文件src/main/java/org/example/HelloServlet.java，包含下面的内容：

package org.example;
 
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class HelloServlet extends HttpServlet
{
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    {
        response.setContentType("text/html");
        response.setStatus(HttpServletResponse.SC_OK);
        response.getWriter().println("<h1>Hello Servlet</h1>");
        response.getWriter().println("session=" + request.getSession(true).getId());
    }
}

你需要在部署描述符中宣称这个servlet，编辑文件src/main/webapp/WEB-INF/web.xml，增加下面的内容：

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app
   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 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   metadata-complete="false"
   version="3.0">
 
  <servlet>
    <servlet-name>Hello</servlet-name>
    <servlet-class>org.example.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>Hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
  </servlet-mapping>
 
</web-app>

创建POM描述符

pom.xml文件描述项目的名称和它的依赖。用编辑器创建pom.xml，包含下面的内容，特别注意jetty-maven-plugin的定义：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>hello-world</artifactId>
  <version>0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>Jetty HelloWorld WebApp</name>
 
  <properties>
      <jettyVersion>9.0.2.v20130417</jettyVersion> /// Adapt this to a version found on http://repo.maven.apache.org/maven2/org/eclipse/jetty/jetty-maven-plugin/
  </properties>
 
  <dependencies>
    <dependency>
      <groupId>org.eclipse.jetty.orbit</groupId>
      <artifactId>javax.servlet</artifactId>
      <version>3.0.0.v201112011016</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
 
  <build>
    <plugins>
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>${jettyVersion}</version>
      </plugin>
    </plugins>
  </build>
 
</project>

构建和运行Web应用

通过使用jetty-maven-plugin，现在你能构建和运行web应用不需要打包到war，只需使用下面的命令：

> mvn jetty:run

你能在http://localhost:8080/hello看到静态和动态的内容。
jetty-maven-plugin中有大量的配置选项可用，帮助你构建和运行你的webapp。具体看下一节“配置Jetty Maven插件”。

构建一个WAR文件

你能创建一个Web Application Archive（WAR）文件，用如下命令：

> mvn package

生成的war文件能够部署在任何标准servlet server，包括Jetty。

配置Jetty Maven插件

Jetty Mven插件对于快速开发和测试是非常有用的。你能增加它到任何Maven构建的webapp项目。插件能周期地扫描你的项目，如果发现任何改变，将自动的重新部署webapp。这使开发周期变得更加快速：你通过IDE改变项目，运行中的web容器自动的替换他们，你立即就能测试改变。
注意：使用该插件必须使用Maven 3和Java 1.7。

快速开始：启动并运行

首先，增加jetty-maven-plugin到你的pom.xml：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <version>9.2.2-SNAPSHOT</version>
</plugin>

然后，从你的根pom.xml目录，执行：

mvn jetty:run

这将启动Jetty并且部署你的项目在http://localhost:8080/。
Jetty持续运行直到你停止它。当它运行时，它周期地扫描你的项目文件的改变，如果你保存了改变并且重编译你的class文件，jetty将重新部署你的webapp，你能立即测试这些你做的改变。
你能在命令行中通过ctrl-c终止插件。

支持的目标

Jetty Maven插件有许多不同的Maven目标。无可争议的最有用的是run目标，用于运行未打包的webapp。有其它目标帮助你完成不同的任务。例如，你可能需要运行你的webapp在一个Jetty的分支实例，而不是在运行Maven的实例内；或者你可能需要更细粒度的控制mavne的生命周期阶段。有不同的目标用于完成这些任务，以及其它的任务。
为了看所有Jetty Maven插件支持的目标，输入：

mvn jetty:help

为了看参数的详细列表，外加它的描述信息，输入：

mvn jetty:help -Ddetail=true -Dgoal= goal-name

配置Jetty容器

这些配置元素设置你的webapp执行的Jetty环境。它们适用于大部分目标：

httpConnector

可选。如果没有指定，Jetty将创建一个ServerConnector实例，监听端口8080。你能改变这个默认端口，通过在命令行使用系统属性jetty.port，例如，mvn -Djetty.port=9999 jetty:run。另外，你能用这个配置元素为ServerConnector设置信息。下面是有效的配置子元素：
 1）port：连接器的端口。默认是8080.
 2）host：连接器监听的特定主机。默认是所有。
 3）name：连接器名，在配置上下文对应特定连接器时使用。
 4）idleTimeout：连接器的最大空闲时间。
 5）soLinger：套接字逗留时间。
你能配置连接器在一个标准的Jetty xml配置文件，然后用它的路径配置到jettyXml参数。注意由于jetty 9.0不再能在pom.xml中直接地配置https connector：你需要用jetty xml配置文件做它。

jettyXml

可选。一个逗号分隔的jetty xml文件路径列表，用于配置插件配置参数。参考$JETTY_HOME/etc/jetty.xml。

scanIntervalSeconds
扫描webapp变化的间隔，单位秒，当扫描到变化后，将执行自动热重部署。默认是0，表示停止热部署扫描。配置值大于0激活它。

reload
默认值“automatic”，与scanIntervalSeconds联合使用，表示当改变发生时，自动热重部署。设置到“manual”，表示你需要在控制台执行换行来触发插件执行扫描。这有时候是有用的，当你一次做一系列的改变，你想忽略中间的改变时，就可以使用reload参数。

loginServices
可选。一个org.eclipse.jetty.security.LoginService实现的列表。注意没有默认域。你在web.xml中使用的域，也能够在这里指定。你能在一个jetty xml文件中配置login service，将文件位置指定到jettyXml参数。

requestLog
可选。org.eclipse.jetty.server.RequestLog请求日志接口的一个实现。遵守NCSA格式的实现（ org.eclipse.jetty.server.NCSARequestLog）是可用的。有三种其它方式用于配置RequestLog：
 1）在一个Jetty xml配置文件中，指定文件路径到jettyXml参数；
 2）在一个上下文配置文件中，指定文件路径到contextXml参数；
 3）在webApp元素中。
更多信息参考“Jetty日志”。

stopPort
可选。端口用于监听停止命令。运行stop或者run-forked目标时使用。

stopKey
可选。用于和stopPort联合使用，用于停止jetty。运行stop或者run-forked目标时使用。

systemProperties
可选。允许你配置System属性，用于运行插件。

systemPropertiesFile
可选。一个包含System属性的文件。默认，你在这里做的设置不重载任何已经在命令行、JVM、POM（通过systemProperties）中设置的系统属性。

skip
默认是false。如果true，插件的执行退出。等同于设置SystemProperty  -Djetty.skip在命令行。这是非常有用的，当配置Jetty为综合测试而你想略过测试代码时。

useProvidedScope
默认值false。如果true，<scope>provided</scope>的依赖被放置到容器classpath。注意这不是webapp的classpath，“provided”表示这些依赖通常被期望由容器提供。你应该很少需要用到这。相反，你应该拷贝provided依赖作为插件直接的依赖。

excludedGoals
可选。jetty插件目标名的列表，插件将打印信息然后退出。当你想阻止用户执行项目无法支持的目标时使用。

配置一个Https连接器

为了配置一个https连接器，你需要用jetty xml配置文件。这个例子用的文件直接从jetty发布的etc/目录拷贝过来，你也可以自己实现。我们将用下面这些文件：

jetty.xml
设置the org.eclipse.jetty.server.Server的几个特性，供插件使用。主要是配置org.eclipse.jetty.server.HttpConfiguration元素供配置连接器时使用。下面是相关配置：

<New id="httpConfig" class="org.eclipse.jetty.server.HttpConfiguration">
  <Set name="secureScheme">https</Set>
  <Set name="securePort"><Property name="jetty.secure.port" default="8443" /></Set>
  <Set name="outputBufferSize">32768</Set>
  <Set name="requestHeaderSize">8192</Set>
  <Set name="responseHeaderSize">8192</Set>
  <Set name="sendServerVersion">true</Set>
  <Set name="sendDateHeader">false</Set>
  <Set name="headerCacheSize">512</Set>
 
  <!-- Uncomment to enable handling of X-Forwarded- style headers
  <Call name="addCustomizer">
    <Arg><New class="org.eclipse.jetty.server.ForwardedRequestCustomizer"/></Arg>
  </Call>
  -->
</New>

jetty-ssl.xml
设置同https连接器使用的ssl。下面是来自jetty发布的jetty-ssl.xml文件：

<?xml version="1.0"?>
<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">
 
<!-- ============================================================= -->
<!-- Configure a TLS (SSL) Context Factory                         -->
<!-- This configuration must be used in conjunction with jetty.xml -->
<!-- and either jetty-https.xml or jetty-spdy.xml (but not both)   -->
<!-- ============================================================= -->
<Configure id="sslContextFactory" class="org.eclipse.jetty.util.ssl.SslContextFactory">
  <Set name="KeyStorePath"><Property name="jetty.base" default="." />/<Property name="jetty.keystore" default="etc/keystore"/></Set>
  <Set name="KeyStorePassword"><Property name="jetty.keystore.password" default="OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4"/></Set>
  <Set name="KeyManagerPassword"><Property name="jetty.keymanager.password" default="OBF:1u2u1wml1z7s1z7a1wnl1u2g"/></Set>
  <Set name="TrustStorePath"><Property name="jetty.base" default="." />/<Property name="jetty.truststore" default="etc/keystore"/></Set>
  <Set name="TrustStorePassword"><Property name="jetty.truststore.password" default="OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4"/></Set>
  <Set name="EndpointIdentificationAlgorithm"></Set>
  <Set name="NeedClientAuth"><Property name="jetty.ssl.needClientAuth" default="false"/></Set>
  <Set name="WantClientAuth"><Property name="jetty.ssl.wantClientAuth" default="false"/></Set>
  <Set name="ExcludeCipherSuites">
    <Array type="String">
      <Item>SSL_RSA_WITH_DES_CBC_SHA</Item>
      <Item>SSL_DHE_RSA_WITH_DES_CBC_SHA</Item>
      <Item>SSL_DHE_DSS_WITH_DES_CBC_SHA</Item>
      <Item>SSL_RSA_EXPORT_WITH_RC4_40_MD5</Item>
      <Item>SSL_RSA_EXPORT_WITH_DES40_CBC_SHA</Item>
      <Item>SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA</Item>
      <Item>SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA</Item>
    </Array>
  </Set>
 
  <!-- =========================================================== -->
  <!-- Create a TLS specific HttpConfiguration based on the        -->
  <!-- common HttpConfiguration defined in jetty.xml               -->
  <!-- Add a SecureRequestCustomizer to extract certificate and    -->
  <!-- session information                                         -->
  <!-- =========================================================== -->
  <New id="sslHttpConfig" class="org.eclipse.jetty.server.HttpConfiguration">
    <Arg><Ref refid="httpConfig"/></Arg>
    <Call name="addCustomizer">
      <Arg><New class="org.eclipse.jetty.server.SecureRequestCustomizer"/></Arg>
    </Call>
  </New>
 
</Configure>

jetty-https.xml
设置https连接器，用jetty.xml的HttpConfiguration和jetty-ssl.xml的ssl配置：

<?xml version="1.0"?>
<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">
 
<!-- ============================================================= -->
<!-- Configure a HTTPS connector.                                  -->
<!-- This configuration must be used in conjunction with jetty.xml -->
<!-- and jetty-ssl.xml.                                            -->
<!-- ============================================================= -->
<Configure id="Server" class="org.eclipse.jetty.server.Server">
 
  <!-- =========================================================== -->
  <!-- Add a HTTPS Connector.                                      -->
  <!-- Configure an o.e.j.server.ServerConnector with connection   -->
  <!-- factories for TLS (aka SSL) and HTTP to provide HTTPS.      -->
  <!-- All accepted TLS connections are wired to a HTTP connection.-->
  <!--                                                             -->
  <!-- Consult the javadoc of o.e.j.server.ServerConnector,        -->
  <!-- o.e.j.server.SslConnectionFactory and                       -->
  <!-- o.e.j.server.HttpConnectionFactory for all configuration    -->
  <!-- that may be set here.                                       -->
  <!-- =========================================================== -->
  <Call id="httpsConnector" name="addConnector">
    <Arg>
      <New class="org.eclipse.jetty.server.ServerConnector">
        <Arg name="server"><Ref refid="Server" /></Arg>
          <Arg name="factories">
            <Array type="org.eclipse.jetty.server.ConnectionFactory">
              <Item>
                <New class="org.eclipse.jetty.server.SslConnectionFactory">
                  <Arg name="next">http/1.1</Arg>
                  <Arg name="sslContextFactory"><Ref refid="sslContextFactory"/></Arg>
                </New>
              </Item>
              <Item>
                <New class="org.eclipse.jetty.server.HttpConnectionFactory">
                  <Arg name="config"><Ref refid="sslHttpConfig"/></Arg>
                </New>
              </Item>
            </Array>
          </Arg>
          <Set name="host"><Property name="jetty.host" /></Set>
          <Set name="port"><Property name="https.port" default="443" /></Set>
          <Set name="idleTimeout"><Property name="https.timeout" default="30000"/></Set>
          <Set name="soLingerTime"><Property name="https.soLingerTime" default="-1"/></Set>
        </New>
    </Arg>
  </Call>
</Configure>

接下来你需要让插件知道应用上面的文件：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <jettyXml>jetty.xml,jetty-ssl.xml,jetty-https.xml</jettyXml>
  </configuration>
</plugin>

注意：就像已安装的Jetty发布版本，xml文件的顺序是必要的。

你也能用jetty xml文件配置一个http连接器供插件使用。这儿同样用来自jetty发布版本的jetty-http.xml文件：

<?xml version="1.0"?>
<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">
 
<!-- ============================================================= -->
<!-- Configure the Jetty Server instance with an ID "Server"       -->
<!-- by adding a HTTP connector.                                   -->
<!-- This configuration must be used in conjunction with jetty.xml -->
<!-- ============================================================= -->
<Configure id="Server" class="org.eclipse.jetty.server.Server">
 
  <!-- =========================================================== -->
  <!-- Add a HTTP Connector.                                       -->
  <!-- Configure an o.e.j.server.ServerConnector with a single     -->
  <!-- HttpConnectionFactory instance using the common httpConfig  -->
  <!-- instance defined in jetty.xml                               -->
  <!--                                                             -->
  <!-- Consult the javadoc of o.e.j.server.ServerConnector and     -->
  <!-- o.e.j.server.HttpConnectionFactory for all configuration    -->
  <!-- that may be set here.                                       -->
  <!-- =========================================================== -->
  <Call name="addConnector">
    <Arg>
      <New class="org.eclipse.jetty.server.ServerConnector">
        <Arg name="server"><Ref refid="Server" /></Arg>
        <Arg name="factories">
          <Array type="org.eclipse.jetty.server.ConnectionFactory">
            <Item>
              <New class="org.eclipse.jetty.server.HttpConnectionFactory">
                <Arg name="config"><Ref refid="httpConfig" /></Arg>
              </New>
            </Item>
          </Array>
        </Arg>
        <Set name="host"><Property name="jetty.host" /></Set>
        <Set name="port"><Property name="jetty.port" default="80" /></Set>
        <Set name="idleTimeout"><Property name="http.timeout" default="30000"/></Set>
        <Set name="soLingerTime"><Property name="http.soLingerTime" default="-1"/></Set>
      </New>
    </Arg>
  </Call>
 
</Configure>

接下来为插件添加配置列表：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <jettyXml>jetty.xml,jetty-http.xml,jetty-ssl.xml,jetty-https.xml</jettyXml>
  </configuration>
</plugin>

配置你的WebApp

这些配置参数应用到你的webapp。他们对几乎所有目标都适用。

webApp
类org.eclipse.jetty.webapp.WebAppContext的一个扩展。你能用对象的setter方法配置你的webapp。下面是常用的一些：
 1）contextPath：你的webapp的上下文路径。默认是/。
 2）descriptor：web.xml文件的路径。
 3）defaultsDescriptor：webdefault.xml的路径，在web.xml之前使用。如果你不提供，Jetty用一个默认文件，在jetty-webapp.jar中。
 4）overrideDescriptor：web.xml文件路径，在你的web.xml之后应用。你能用这重载或者添加配置。
 5）tempDirectory：当你的webapp运行时，Jetty用于解压和拷贝jar包和jsp编译结果的文件夹。默认是${project.build.outputDirectory}/tmp。
 6）baseResource：Jetty提供静态资源的路径，默认是src/main/webapp。
 7）resourceBases：用于代替baseResource提供静态资源，是一个数组，可以提供多个提供静态资源的文件夹。
 8）baseAppFirst：默认“true”。

contextXml
一个上下文xml文件的路径，在webApp之后应用到你的webapp。

jetty:run

run目标不必构建webapp到WAR。取而代之，Jetty从它的源头部署webapp。它在Maven项目中查找webapp的组件部分，虽然你能在插件的配置中重载他们。例如，默认它查找：
 1）在${project.basedir}/src/main/webapp中的资源；
 2）在${project.build.outputDirectory}中的类；
 3）在${project.basedir}/src/main/webapp/WEB-INF/中的web.xml。
在部署前，插件自动的确认类被重建和更新。如果你改变了类的源代码，你的IDE会在后台自动的编译它，插件挑选改变的类。
你不需要打包webapp到WAR，节省部署周期时间。你能配置插件持续执行，扫描项目的改变并在需要的时候自动热部署。你做的任何改变会立即反应到运行中的Jetty实例中，让你能快速的从编码跳转到测试，而不是：编码、编译、打包、重部署、测试。
下面是一个简单的例子，每10秒执行一次改变扫描，并设置上下文路径到/test：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <scanIntervalSeconds>10</scanIntervalSeconds>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
  </configuration>
</plugin>

配置

除了webApp元素之外，jetty:run目标支持：
 1）classesDirectory：你的webapp编译后的类的位置。你应该很少需要设置这个参数。取而代之，你应该设置你的pom.xml中的build outputDirectory。
 2）testClassesDirectory：你的webapp的编译后的测试类的位置。默认是 ${project.build.testOutputDirectory}。
 3）useTestScope：如果true，testClassesDirectory中的类和“test”范围的依赖首先被放置在classpath。默认是false。
 4）webAppSourceDirectory：默认，这被设置到 ${project.basedir}/src/main/webapp。如果你的静态资源在不同的位置，相应地设置该参数。
 5）jettyEnvXml：可选。jetty-env.xml文件的位置。
 6）scanTargets：可选。文件和文件夹的列表，除了那些插件自动扫描的目录和文件，插件增加对这些配置的周期扫描。
 7）scanTargetPatterns：可选。如果你需要额外扫描的文件列表过长，你可以通过匹配表达式来指定它们。
下面是一个更详细的配置的例子：

<project>
... 
  <plugins>
... 
    <plugin>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-maven-plugin</artifactId>
      <configuration>
        <webAppSourceDirectory>${project.basedir}/src/staticfiles</webAppSourceDirectory>
        <webApp>
          <contextPath>/</contextPath>
          <descriptor>${project.basedir}/src/over/here/web.xml</descriptor>
          <jettyEnvXml>${project.basedir}/src/over/here/jetty-env.xml</jettyEnvXml>
        </webApp>
        <classesDirectory>${project.basedir}/somewhere/else</classesDirectory>
        <scanTargets>
          <scanTarget>src/mydir</scanTarget>
          <scanTarget>src/myfile.txt</scanTarget>
        </scanTargets>
        <scanTargetPatterns>
          <scanTargetPattern>
            <directory>src/other-resources</directory>
            <includes>
              <include>**/*.xml</include>
              <include>**/*.properties</include>
            </includes>
            <excludes>
              <exclude>**/myspecial.xml</exclude>
              <exclude>**/myspecial.properties</exclude>
            </excludes>
          </scanTargetPattern>
        </scanTargetPatterns>
      </configuration>
    </plugin>
  </plugins>
</project>

如果在某些情况下，你不能运行在未打包webapp上，可以考虑使用run-war和run-exploded目标。

jetty:run-war

这个目标首先将你的webapp打包为WAR，然后部署它到Jetty。如果你设置非0的scanInterval，Jetty监视你的pom.xml和WAR文件；如果改变，它重部署war。

配置

war：WAR文件的位置。默认是${project.build.directory}/${project.build.finalName}.war。如果需要，设置你的自定义路径。
下面是配置的例子：

<project>
... 
  <plugins>
...
    <plugin>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-maven-plugin</artifactId>
      <configuration>
        <war>${project.basedir}/target/mycustom.war</war>
      </configuration>
    </plugin>
  </plugins>
</project>

jetty:run-exploded

run-exploded目标首先打包你的webapp到一个分解的WAR文件，然后部署它到Jetty。如果你设置了非0的scanInterval，Jetty监视你的pom.xml、WEB-INF/lib、WEB-INF/中的类和WEB-INF/web.xml，发现改变后在必要的时候重新部署。

配置

war：分解的WAR的位置。默认是 ${project.build.directory}/${project.build.finalName}，你可以通过设置该参数覆盖该值。
下面是配置的例子：

<project> 
... 
  <plugins>
... 
    <plugin>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>maven-jetty-plugin</artifactId>
      <configuration>
        <war>${project.basedir}/target/myfunkywebapp</war>
      </configuration>
    </plugin>
  </plugins>
</project>

jetty:deploy-war

这个基本上和jetty:run-war相同，除了没有装配当前模块的WAR。不想run-war，插件不必执行到"package"阶段。例如，你可以启动jetty在"test-compile"阶段，停止jetty在"test-phase"阶段。

配置

war：WAR文件的位置。默认 ${project.build.directory}/${project.build.finalName}，你能通过设置该参数覆盖该值。
下面是配置的例子：

<project>
... 
  <plugins>
... 
  <plugin>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-maven-plugin</artifactId>
    <configuration>
      <war>${project.basedir}/target/mycustom.war</war>
    </configuration>
    <executions>
      <execution>
        <id>start-jetty</id>
        <phase>test-compile</phase>
        <goals>
          <goal>deploy-war</goal>
        </goals>
        <configuration>
          <daemon>true</daemon>
          <reload>manual</reload>
        </configuration>
      </execution>
      <execution>
        <id>stop-jetty</id>
        <phase>test</phase>
        <goals>
          <goal>stop</goal>
        </goals>
      </execution>
     </executions>
    </plugin>
  </plugins>
</project>

jetty:run-forked

这个目标允许你在一个新的JVM中启动webapp，随意地传递参数到新的JVM。

配置

注意：不幸的是，不想大部分其它目标，这个不支持webApp参数。因此，如果你的webapp要求许多配置，则不能使用该目标。
下面是可用的配置参数：
 1）jettyXml：jetty xml配置文件的位置，用于在新的JVM中配置容器。
 2）contextXml：可选。上下文文件的位置，用于在新的JVM中配置webapp。
 3）contextPath：可选。新JVM中webapp的上下文路径。默认 /${project.artifactId}。
 4）webAppSourceDirectory：可选。你的webapp的静态资源位置。默认src/main/webapp。
 5）resourceBases：可选。包含你的webapp静态内容的文件夹数组，与webAppSourceDirectory一起。也看baseAppFirst。
 6）baseAppFirst：默认“true”。控制webAppSourceDirectory或者resourceBases是否第一个在资源列表上。
 7）webXml：web.xml文件的位置。默认src/main/webapp/WEB-INF/web.xml。
 8）tmpDirectory：临时文件夹。默认 ${project.build.directory}/tmp。
 9）classesDirectory：编译后的类文件位置。默认 ${project.build.outputDirectory}。
 10）testClassesDirectory：编译后测试类位置。默认 ${project.build.testOutputDirectory}。
 11）useTestScope：默认“false”。如果true，范围"provided"的依赖被放置到jetty容器的classpath。
 12）stopPort：强制的。一个端口号，jetty用于监听stop命令。如果配置，stopKey被用于认证接收的stop命令。
 13）stopKey：强制的。一个String，用于认证stop命令。
 14）skip：可选。默认false。如果true，插件的执行被略过。
 15）jvmArgs：可选。一个String，表示传递到新JVM的任意参数。
为了部署你的未装配的web应用到运行在新JVM中的Jetty：

mvn jetty:run-forked

Jetty将持续执行直到：
 1）在终端窗口执行ctrl+c，同时也停止另一个JVM。
 2）用jetty:stop停止另一个JVM，也停止插件。
注意：如果你想设置一个自定义端口，你需要指定它在jetty.xml文件中，而不是设置连接器和端口标签。你能使用jettyXml参数执行jetty.xml的位置。

jetty:start

这个目标类似于jetty:run目标，然而它直到"test-compile"才执行构建，以确保所有webapp需要的类和文件已经被产生。当你想控制Jetty的start和stop时这是非常有用的。
例如，你能配置插件在你的单元测试开始的时候启动，在单元测试结束时停止。为了做这，你需要为Jetty插件设置一套execution方案，用<daemon>true</daemon>配置选项使Jetty仅当Maven运行时执行。你用pre-integration-test和post-integration-test Maven构建阶段触发Jetty的执行和终止：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <scanIntervalSeconds>10</scanIntervalSeconds>
    <stopKey>foo</stopKey>
    <stopPort>9999</stopPort>
  </configuration>
  <executions>
    <execution>
      <id>start-jetty</id>
      <phase>pre-integration-test</phase>
      <goals>
        <goal>start</goal>
      </goals>
      <configuration>
        <scanIntervalSeconds>0</scanIntervalSeconds>
        <daemon>true</daemon>
      </configuration>
    </execution>
    <execution>
      <id>stop-jetty</id>
      <phase>post-integration-test</phase>
       <goals>
         <goal>stop</goal>
       </goals>
     </execution>
  </executions>
</plugin>

当然你也可以在命令行中使用该目标，但你你需要确保你的webapp需要的所有类和文件已经被产生。

jetty:stop

stop目标用于停止Jetty。为了使用它，你需要使用一个特殊的端口号和key来配置插件。这个端口号和key也将用于start目标。
 1）stopPort：Jetty用于接收stop命令的端口号。
 2）stopKey：用于验证stop命令。
下面是配置的例子：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <stopPort>9966</stopPort>
    <stopKey>foo</stopKey>
    <stopWait>10</stopWait>
  </configuration>
</plugin>

当Jetty正在运行时，执行：

mvn jetty:stop

注意stopPort必须是空闲的。

配置安全设置

你能在插件中配置LoginServices。下面是为webapp设置HashLoginService的例子：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <scanIntervalSeconds>10</scanIntervalSeconds>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
    <loginServices>
      <loginService implementation="org.eclipse.jetty.security.HashLoginService">
        <name>Test Realm</name>
        <config>${project.basedir}/src/etc/realm.properties</config>
      </loginService>
    </loginServices>
  </configuration>
</plugin>

用多个Webapp Root文件夹

如果你有额外的资源想要合并到当前的webapp中，但没有被集成到WAR中，你能告诉Jetty这些额外的资源位于的文件夹。在运行时，当Jetty收到一个资源请求时，它搜索所有的路径得到资源。下面是配置例子：

<configuration>
  <webApp>
    <contextPath>/${build.finalName}</contextPath>
    <baseResource implementation="org.eclipse.jetty.util.resource.ResourceCollection">
      <resourcesAsCSV>src/main/webapp,/home/johndoe/path/to/my/other/source,/yet/another/folder</resourcesAsCSV>
    </baseResource>
  </webApp>
</configuration>

运行超过一个Webapp

你能用一个jetty.xml文件配置你想部署的额外的（预编译的）webapp，或者你能用<contextHandlers>配置元素来做。如果你想部署webapp A，和webapp B和C在同一个Jetty实例中：

放配置想在webapp A的 pom.xml中：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <scanIntervalSeconds>10</scanIntervalSeconds>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
    <contextHandlers>
      <contextHandler implementation="org.eclipse.jetty.webapp.WebAppContext">
        <war>${project.basedir}../../B.war</war>
        <contextPath>/B</contextPath>
      </contextHandler>
      <contextHandler implementation="org.eclipse.jetty.webapp.WebAppContext">
        <war>${project.basedir}../../C.war</war>
        <contextPath>/B</contextPath>
      </contextHandler>
    </contextHandlers>
  </configuration>
</plugin>

或者，增加一个jetty.xml文件到webapp A。从jetty发布版本中拷贝jetty.xml文件，然后为其它两个webapp增加WebAppContext：

<Ref refid="Contexts">
  <Call name="addHandler">
    <Arg>
      <New class="org.eclipse.jetty.webapp.WebAppContext">
        <Set name="contextPath">/B</Set>
        <Set name="war">../../B.war</Set>
      </New>
    </Arg>
  </Call>
  <Call>
    <Arg>
      <New class="org.eclipse.jetty.webapp.WebAppContext">
        <Set name="contextPath">/C</Set>
        <Set name="war">../../C.war</Set>
      </New>
    </Arg>
  </Call>
</Ref>

然后配置这个jetty.xml文件的位置到webapp A的jetty插件：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <scanIntervalSeconds>10</scanIntervalSeconds>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
    <jettyXml>src/main/etc/jetty.xml</jettyXml>
  </configuration>
</plugin> 

为这任何一种方式，其它的webapp都必须已经被构建，并且他们会被监控变化。

设置系统属性

你能用maven properites插件定义系统属性。下面是一个例子配置logback logging系统作为jetty logger：

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>properties-maven-plugin</artifactId>
  <version>1.0-alpha-2</version>
  <executions>
    <execution>
      <goals>
        <goal>set-system-properties</goal>
      </goals>
      <configuration>
        <properties>
          <property>
            <name>logback.configurationFile</name>
            <value>${project.baseUri}/resources/logback.xml</value>
          </property>
        </properties>
      </configuration>
    </execution>
  </executions>
</plugin>

注意：如果一个系统属性已经被设置（例如，从命令行或者通过JVM），那么默认这些配置属性不覆盖他们（看下面的<force>参数的使用）。

指定系统属性在POM中

下面是一个例子怎么在POM中指定系统属性：

<plugin> 
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration> 
    <systemProperties>
      <systemProperty>
        <name>fooprop</name>
        <value>222</value>
      </systemProperty>
    </systemProperties>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
  </configuration> 
</plugin>

为了改变默认的行为，使这些系统属性覆盖命令行中指定的那些，使用<force>参数：

<plugin> 
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <systemProperties>
      <force>true</force>
      <systemProperty>
       <name>fooprop</name>
       <value>222</value>
     </systemProperty>
    </systemProperties>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
  </configuration>
</plugin>

在文件中指定系统属性

你也能在一个文件中指定你的系统属性。通过这种方式指定的系统属性不会覆盖命令行、JVM和POM中指定的系统属性。
假定我们与一个文件mysys.props，包含：

fooprop=222

在插件中的配置方式如下；

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <configuration>
    <systemPropertiesFile>${project.basedir}/mysys.props</systemPropertiesFile>
    <webApp>
      <contextPath>/test</contextPath>
    </webApp>
  </configuration>
</plugin>

你也能通过在命令行设置系统属性jetty.systemPropertiesFile来指定文件。

被Jetty Maven插件扫描的文件

如果你设置一个非0的scanInterval配置参数，jetty maven插件将每scanInterval执行一次文件扫描，如果发现变化，则根据配置重新部署webapp。被扫描的文件依赖被执行的目标。

Jetty Jspc Maven插件

这个插件将帮助你预编译你的jsp，并和相关的maven war插件一起放他们到集成的war中。

配置

下面是jspc插件要求的基本设置：

<plugin>
  <groupId>org.eclipse.jetty</groupId>
   <artifactId>jetty-jspc-maven-plugin</artifactId>
   <version>9.1.0.RC1</version>
   <executions>
     <execution>
       <id>jspc</id>
       <goals>
         <goal>jspc</goal>
       </goals>
       <configuration>
       </configuration>
     </execution>
   </executions>
 </plugin>

配置参数（configuration）如下：

webXmlFragment
 默认值：${project.basedir}/target/webfrag.xml
 用于产生servlet声明。将被嵌入到一个存在的web.xml中。

webAppSourceDirectory
 默认值：${project.basedir}/src/main/webapp
 jsps、tags等放置的资源文件夹的根。

webXml
 默认值：${project.basedir}/src/main/webapp/WEB-INF/web.xml

includes
 默认值：**\/*.jsp, **\/*.jspx
 逗号分隔的模式列表，指定将被处理的文件。

excludes
 默认值：**\/.svn\/**
 逗号分隔的模式列表，指定排除的文件。

classesDirectory
 默认值：${project.build.outputDirectory}
 webapp的类放置的路径

generatedClasses
 默认值：${project.build.outputDirectory}
 jsp产生的类放置的路径

insertionMarker
 默认值：none
 一个标记String，在源web.xml中，指示长生的web.xml片段的插入位置。

useProvidedScope
 默认值：true 是否嵌入产生的片段文件到源web.xml。嵌入的文件将进入同样的文件夹作为webXmlFragment。

keepSources
 默认值：false
 如果true，产生的.java文件被处理完后将不被删除。

tldJarNamePatterns
 默认值：.*taglibs[^/]*\.jar|.*jstl-impl[^/]*\.jar$
 在包含tld的‘系统’（例如容器）路径上的jar的模式。用|分隔。

jspc
 默认值：org.apache.jasper.JspC

JspC类真正执行预编译。在JspC类上的所有setter都是可用的。你能从这里下载javadoc。

采用所有的默认值，下面是怎么配置war查将，使用产生的web.xml，包含所有jsp servlet声明：

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-war-plugin</artifactId>
  <configuration>
    <webXml>${project.basedir}/target/web.xml</webXml>
  </configuration>
</plugin>