码迷,mamicode.com
首页 > 其他好文 > 详细

Jetty开发指导:Maven和Jetty

时间:2014-07-18 18:09:13      阅读:271      评论:0      收藏:0      [点我收藏+]

标签:java   jetty   web应用   框架   

使用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:run pom.xml, <dependencies>, <classesDirectory>, <testClassesDirectory>, <webXml> or <webAppSourceDirectory>/WEB-INF/web.xml, <jettyEnvXml> or <webAppSourceDirectory>/WEB-INF/jetty-web.xml, <webAppSourceDirectory>/WEB-INF/jetty-web.xml, <scanTargets>, <scanTargetPatterns>, any defaultsDescriptor for the webapp, any overrideDescriptor for the webapp
jetty:run-war pom.xml, <war>
jetty:run-exploded pom.xml, <war>/WEB-INF/web.xml, <war>/WEB-INF/jetty-web.xml, <war>/WEB-INF/jetty-env.xml,<war>/WEB-INF/classes, <war>/WEB-INF/lib
jetty:deploy-war pom.xml, <war>
jetty:run-forked  
jetty:start pom.xml, <dependencies> from the pom, <classesDirectory>, <testClassesDirectory>, <webXml> or <webAppSourceDirectory>/WEB-INF/web.xml, <jettyEnvXml> or <webAppSourceDirectory>/WEB-INF/jetty-web.xml, <webAppSourceDirectory>/WEB-INF/jetty-web.xml, <scanTargets>, <scanTargetPatterns>, any defaultsDescriptor for the webapp, any overrideDescriptor for the webapp
jetty:stop  

 

 

 

 

 

 

 

 

 

 

 

 

 

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>

 

Jetty开发指导:Maven和Jetty,布布扣,bubuko.com

Jetty开发指导:Maven和Jetty

标签:java   jetty   web应用   框架   

原文地址:http://blog.csdn.net/tomato__/article/details/37927813

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!