Jetty嵌入式Web容器攻略

最新推荐文章于 2022-03-23 22:37:31 发布
最新推荐文章于 2022-03-23 22:37:31 发布
阅读量5.2k 收藏 4
点赞数
分类专栏： java

Jetty是一个用 Java 实现、开源、基于标准的，并且具有丰富功能的 Http 服务器和 Web 容器。Jetty中应用最广泛的一项功能就是可以作为嵌入式Web容器。

  • 在开发阶段，可以使用Jetty在Eclipse里直接启动应用，而不是像Tomcat那样繁琐，先把几十兆应用打包，然后再复制到某个目录后再启动。
  • 在测试阶段，可以直接在测试用例中启动Jetty，而不是先将应用打包部署到容器。
  • 在运行阶段，可以将war包配置成直接能够运行的应用

本文将着重介绍如何配置使用Jetty的嵌入式Web容器功能，关于Jetty的基本配置和功能请参考http://www.ibm.com/developerworks/cn/web/wa-lo-jetty/

一、开发阶段
1、使用maven启动Jetty

我们修改了源码的时候eclipse会自动编译，Jetty Maven Plugin插件发现编译文件有变化后会自动更新到jetty容器中，非常方便我们进行开发。

首先定义Jetty的版本属性

1
2
3
< properties >
  < jetty.version >8.1.9.v20130131</ jetty.version >
  </ properties >

然后引入Jetty依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- jetty -->
  < dependency >
  < groupId >org.eclipse.jetty.aggregate</ groupId >
  < artifactId >jetty-webapp</ artifactId >
  < version >${jetty.version}</ version >
  < scope >test</ scope >
  </ dependency >
  < dependency >
  < groupId >org.eclipse.jetty</ groupId >
  < artifactId >jetty-jsp</ artifactId >
  < version >${jetty.version}</ version >
  < scope >test</ scope >
  </ dependency >

配置Jetty Maven Plugin插件，示例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
< plugin >
  < groupId >org.mortbay.jetty</ groupId >
  < artifactId >jetty-maven-plugin</ artifactId >
  < version >${jetty.version}</ version >
  < configuration >
  < systemProperties >
  < systemProperty >
  < name >spring.profiles.active</ name >
  < value >development</ value >
  </ systemProperty >
  </ systemProperties >
  < useTestClasspath >true</ useTestClasspath >
 
  < webAppConfig >
  < contextPath >/${project.artifactId}</ contextPath >
  </ webAppConfig >
  </ configuration >
  </ plugin >

该配置运行jetty并指定spring的profile为development，同时设定web应用的上下文地址与应用本身的artifactId一致。

执行如下命令启动Jetty，即可通过http://localhost:8080/${project.artifactId}访问Web应用。

1
mvn jetty:run

Jetty Maven Plugin插件支持多个maven goals，最常用的就是run，下面的参数支持大部分的goals

（1）配置Jetty容器（支持所有goals）

  • <connectors>：可选参数，配置org.eclipse.jetty.server.Connector（Jetty端口监听器）列表，如果不指定该参数，将会连接默认的8080端口。
  • <jettyXml>：可选参数，指定Jetty配置文件的路径
  • <scanIntervalSeconds>：可选参数，配置Web应用扫描的暂停时间，Web应用扫描如果发现修改了程序，会自动重新部署。该参数默认值为0，即不启动热部署
  • <systemProperties>：可选参数，设置插件执行时的系统参数，比如上面的配置示例中指定了spring的profile为development，如果不设置该参数，就需要配置maven与spring的profile一致，同时在mvn命令中增加-Pdevelopment选项，或者直接在spring配置文件中设置spring.profiles.active为development
  • <systemPropertiesFile>：可选参数，设置系统参数配置文件的位置，将会批量执行其中的系统参数配置
  • <loginServices>：可选参数，配置org.eclipse.jetty.security.LoginService实现类的列表。
  • <requestLog>：可选参数，配置请求日志接口：org.eclipse.jetty.server.RequestLog的实现类，配置请求日志的处理格式，

比如org.mortbay.jetty.NCSARequestLog就是一个NCSA格式（（美国）国家超级计算技术应用中心 (NCSA) 公用格式，是常用的标准日志格式）的实现。

（2）配置Web应用程序（不支持run-forked、stop两个goals）

  • <webApp>：从jetty6.1.6rc0起使用webAppConfig，web应用程序配置根节点
  • <contextPath>：设置web应用程序的context路径，默认情况下，它被设置成该项目的pom.xml的<artifactId>
  • <descriptor>：设置web应用程序主配置文件web.xml的路径，默认该配置文件位于WEB-INF目录下
  • <defaultsDescriptor>：设置先于web.xml执行的webdefault.xml配置文件的路径
  • <overrideDescriptor>：设置在web.xml读取之后执行的配置文件，使用该参数可以覆盖或增加web.xml中的配置
  • <tempDirectory>：Web应用的临时目录，Jetty可以在此目录编译jsp文件或者复制jar包，默认路径为${project.build.outputDirectory}/tmp
  • <baseResource>：指定Web应用静态资源所在的路径，默认路径为src/main/webapp
  • <resourceBases>：指定多个Web应用静态资源所在的路径，使用逗号分隔
  • <baseAppFirst>：可选参数，默认值为true，控制是否可以在Web应用的原始资源之前或之后叠加多个war包
  • <jettyEnvXml>：可选参数，指定jetty-env.xml配置文件的路径
  • <containerIncludeJarPattern>：jetty-8.1.x之后的版本可以使用，可选参数，配置加载到Jetty容器 Classloader中的Jar包的路径或匹配模式，符合条件的jar包将会被检测META-INF、资源、tld和类的继承关系
  • <webInfIncludeJarPattern>：jetty-8.1.x之后的版本可以使用，可选参数，配置加载到Web应用程序的Classloader（WEB-INF classpath）中的Jar包的路径或匹配模式，符合条件的jar包将会被检测META-INF、资源、tld和类的继承关系
  • <contextXml>：可选参数，指定context xml配置文件的路径

run goals将会启动Jetty并运行应用程序，不需要应用程序编译成war包。另外run还支持webapp节点的其它属性：

  • <classesDirectory>：Web应用程序类编译后的路径
  • <testClassesDirectory>：Web应用程序单元测试类编译后的路径，默认值为${project.build.testOutputDirectory}.
  • <useTestScope>：Jetty-7之前的版本参数名称为useTestClasspath，如果设置为true，开启测试模式，<testClassesDirectory>中指定的类及其依赖将首先被加载到classpath中，默认值为false
  • <useProvidedScope>：如果设置为true，依赖范围标示为“provided”的依赖将被加载到容器的classpath中，该参数很少使用。
  • <webAppSourceDirectory>：Web应用程序静态资源路径，默认值为${basedir}/src/main/webapp
  • <scanTargets>：配置除了插件自动扫描的位置外，其它需要扫描的目录或文件列表
  • <scanTargetPatterns>：配置除了插件自动扫描的位置外，其它需要扫描的目录或文件的匹配模式
  • <skip>：默认值为false，如果设置为true，将会停止执行插件

Jetty Maven Plugin插件支持的其它goals简介如下（详见http://wiki.eclipse.org/Jetty/Feature/Jetty_Maven_Plugin）：

  • run-war：将Web应用程序打包成war包并部署到Jetty中。
  • run-exploded：使用war exploded模式（文件夹模式）将Web应用程序打包并部署到Jetty中
  • deploy-war：功能与run-war类似，区别就是maven生命周期中不包含package阶段
  • run-forked：jetty-7.5.2之后的版本可用，强迫Jetty使用一个新的JVM启动应用程序
  • start：jetty-7.6.0之后的版本可用，一般在配合插件中的execution节点使用，test-compile阶段之后才执行构建，确保必要的类及文件都生成好了。一般用于集成测试时启动Jetty，本文第二部分测试阶段会有详细介绍
  • stop：关闭运行中的Jetty容器

2、在java中启动Jetty
SpringSide4中封装了Jetty的操作提供了工具类JettyFactory ，让我们可以很简单的启动Jetty容器，JettyFactory代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/**
  * Copyright (c) 2005-2012 springside.org.cn
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  */
  package org.springside.modules.test.jetty;
 
  import java.util.List;
 
  import org.apache.commons.lang3.StringUtils;
  import org.eclipse.jetty.server.Connector;
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.server.nio.SelectChannelConnector;
  import org.eclipse.jetty.webapp.WebAppClassLoader;
  import org.eclipse.jetty.webapp.WebAppContext;
 
  import com.google.common.collect.Lists;
 
  /**
  * 创建Jetty Server的工厂类.
  *
  * @author calvin
  */
  public class JettyFactory {
 
  private static final String DEFAULT_WEBAPP_PATH = "src/main/webapp" ;
  private static final String WINDOWS_WEBDEFAULT_PATH = "jetty/webdefault-windows.xml" ;
 
  /**
  * 创建用于开发运行调试的Jetty Server, 以src/main/webapp为Web应用目录.
  */
  public static Server createServerInSource( int port, String contextPath) {
  Server server = new Server();
  // 设置在JVM退出时关闭Jetty的钩子。
  server.setStopAtShutdown( true );
 
  SelectChannelConnector connector = new SelectChannelConnector();
  connector.setPort(port);
  // 解决Windows下重复启动Jetty居然不报告端口冲突的问题.
  connector.setReuseAddress( false );
  server.setConnectors( new Connector[] { connector });
 
  WebAppContext webContext = new WebAppContext(DEFAULT_WEBAPP_PATH, contextPath);
  // 修改webdefault.xml，解决Windows下Jetty Lock住静态文件的问题.
  webContext.setDefaultsDescriptor(WINDOWS_WEBDEFAULT_PATH);
  server.setHandler(webContext);
 
  return server;
  }
 
  /**
  * 设置除jstl-*.jar外其他含tld文件的jar包的名称.
  * jar名称不需要版本号，如sitemesh, shiro-web
  */
  public static void setTldJarNames(Server server, String... jarNames) {
  WebAppContext context = (WebAppContext) server.getHandler();
  List<String> jarNameExprssions = Lists.newArrayList( ".*/jstl-[^/]*\\.jar$" , ".*/.*taglibs[^/]*\\.jar$" );
  for (String jarName : jarNames) {
  jarNameExprssions.add( ".*/" + jarName + "-[^/]*\\.jar$" );
  }
 
  context.setAttribute( "org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern" ,
  StringUtils.join(jarNameExprssions, '|' ));
 
  }
 
  /**
  * 快速重新启动application，重载target/classes与target/test-classes.
  */
  public static void reloadContext(Server server) throws Exception {
  WebAppContext context = (WebAppContext) server.getHandler();
 
  System.out.println( "[INFO] Application reloading" );
  context.stop();
 
  WebAppClassLoader classLoader = new WebAppClassLoader(context);
  classLoader.addClassPath( "target/classes" );
  classLoader.addClassPath( "target/test-classes" );
  context.setClassLoader(classLoader);
 
  context.start();
 
  System.out.println( "[INFO] Application reloaded" );
  }
  }

JettyFactory包含三个方法

  • createServerInSource：以src/main/webapp为Web应用目录创建Jetty WebServer，确保jvm退出时关闭Jetty，在同一个端口启动多个jetty时报告端口冲突，并解决了javascript、css等静态文件被jetty锁定而不能修改的问题。
  • setTldJarNames：Jetty，tomcat等web容器通常都会对classloader做扩展，Jetty中的org.mortbay.jetty.webapp.WebAppClassLoader负责加载一个Web应用context中的应用类。
  • Jetty的jsp处理引擎来自于Glassfish，要求JSF标签必须位于Jetty容器的classpath中，不能位于Web应用的classpath中，而Jetty的WebAppClassLoader优先使用父classloader加载类，导致tld文件都被加载到父classloader中，在Jetty的classpath中根本扫描不到，所以会出现找不到tld文件的情况。setTldJarNames方法可以设置将包含tld的jar包加载到Jetty的classpath中。
  • reloadContext：重新加载Jetty的context

调用JettyFactory在Jetty中运行调试Maven Web应用的示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package org.springside.examples.quickstart;
 
  import org.eclipse.jetty.server.Server;
  import org.springside.modules.test.jetty.JettyFactory;
  import org.springside.modules.test.spring.Profiles;
 
  /**
  * 使用Jetty运行调试Web应用, 在Console输入回车快速重新加载应用.
  *
  * @author calvin
  */
  public class QuickStartServer {
 
  public static final int PORT = 8080 ;
  public static final String CONTEXT = "/quickstart" ;
  public static final String[] TLD_JAR_NAMES = new String[] { "sitemesh" , "spring-webmvc" , "shiro-web" ,
  "springside-core" };
 
  public static void main(String[] args) throws Exception {
  // 设定Spring的profile
  Profiles.setProfileAsSystemProperty(Profiles.DEVELOPMENT);
 
  // 启动Jetty
  Server server = JettyFactory.createServerInSource(PORT, CONTEXT);
  JettyFactory.setTldJarNames(server, TLD_JAR_NAMES);
 
  try {
  server.start();
 
  System.out.println( "[INFO] Server running at http://localhost:" + PORT + CONTEXT);
  System.out.println( "[HINT] Hit Enter to reload the application quickly" );
 
  // 等待用户输入回车重载应用.
  while ( true ) {
  char c = ( char ) System.in.read();
  if (c == '\n' ) {
  JettyFactory.reloadContext(server);
  }
  }
  } catch (Exception e) {
  e.printStackTrace();
  System.exit(- 1 );
  }
  }
  }

上段代码还提供了通过捕获在console中输入的回车自动重新载入上下文，并重新载入Class文件，提高了响应速度。

在执行main方法过程中如果发生如下错误：

class “javax.servlet.HttpConstraintElement”‘s signer information does not match signer information of other classes in the same package

通过执行如下命令检查依赖

1
mvn dependency:tree -Dverbose|grep servlet

检查结果如图

发现是因为Jetty8版本的包的依赖包org.eclipse.jetty.orbit.javax.servlet3.0.jar提供了javax.servlet.HttpConstraintElement类，而javax.servlet.servlet-api.jar的依赖包javax.servlet.javax.servlet-api-3.0.1.jar也提供了javax.servlet.HttpConstraintElement类，两者发生了冲突。可以使用7.6.14.v20131031版本的Jetty解决此问题。

二、测试阶段

在功能测试或集成测试阶段，希望在测试开始时自动运行Jetty加载项目进行测试，测试完成时停止Jetty容器。Jetty Maven Plugin插件可以帮助我们完成这种自动化工作。配置示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
< plugin >
  < groupId >org.mortbay.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 >

在上述配置中，通过execution来自定义运行阶段：

  • 在pre-integration-test阶段运行start goals启动Jetty容器
  • 在post-integration-test阶段运行stop goals停止Jetty容器。

使用<daemon>true</daemon>配置选项来预防Jetty无限期运行，迫使它只在执行Maven时才运行。

三、运行阶段

为了能够创建可以直接运行的war包，需要把jetty jar包解开，将其中的class直接编译到war包中，并需要在war中提供一个可以创建并运行Jetty的Main方法。本文提供两种实现方法：

方法一
SpringSide4中提供了一种实现方法，稍加修改优化后步骤如下：

1、使用maven-assembly-plugin重新打包

maven-assembly-plugin插件能将应用程序打包成指定格式的分发包，更重要的是能够自定义包含/排除指定的目录或文件。

为方便操作，单独建立一个Maven Profile用于打包，配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
< profile >
  < id >standalone</ id >
  < build >
  < plugins >
  < plugin >
  < groupId >org.apache.maven.plugins</ groupId >
  < artifactId >maven-assembly-plugin</ artifactId >
  < executions >
  < execution >
  < phase >package</ phase >
  < goals >
  < goal >single</ goal >
  </ goals >
  < configuration >
  < descriptors >
  < descriptor >assembly-standalone.xml</ descriptor >
  </ descriptors >
  < archive >
  < manifest >
  < mainClass >org.springside.examples.showcase.Main</ mainClass >
  </ manifest >
  </ archive >
  </ configuration >
  </ execution >
  </ executions >
  </ plugin >
  </ plugins >
  </ build >
  </ profile >

上述配置中，通过execution配置打包操作在package阶段开始，引入assembly-standalone.xml文件定义打包的规则，配置archive修改war包中的META-INF/Manifest.mf，替换main class为org.springside.examples.showcase.Main。

assembly-standalone.xml中的配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<? xml version = "1.0" encoding = "UTF-8" ?>
  < assembly xmlns = "http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation = "http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd" >
  < id >standalone</ id >
  < formats >
  < format >war</ format >
  </ formats >
  < includeBaseDirectory >false</ includeBaseDirectory >
 
  < dependencySets >
  < dependencySet >
  < outputDirectory >/</ outputDirectory >
  < includes >
  < include >org.eclipse.jetty*:*</ include >
  </ includes >
  < scope >provided</ scope >
  < unpack >true</ unpack >
  < unpackOptions >
  < excludes >
  < exclude >*</ exclude >
  < exclude >META-INF/*</ exclude >
  < exclude >about_files/*</ exclude >
  </ excludes >
  </ unpackOptions >
  </ dependencySet >
  </ dependencySets >
 
  < fileSets >
  < fileSet >
  < directory >${project.basedir}/target/${project.build.finalName}</ directory >
  < outputDirectory >/</ outputDirectory >
  < excludes >
  < exclude >META-INF/**/*</ exclude >
  </ excludes >
  </ fileSet >
  < fileSet >
  < directory >${project.basedir}/target/classes</ directory >
  < includes >
  < include >**/*/Main.class</ include >
  </ includes >
  < outputDirectory >/</ outputDirectory >
  </ fileSet >
  </ fileSets >
  </ assembly >

assembly-standalone.xml涉及到几个关键点：

  • formats指定打包的格式为war
  • includeBaseDirectory为false表示创建的压缩包不使用应用程序的名称创建根目录
  • dependencySets用来定义选择依赖并定义最终打包到什么目录，这里我们通过include设置打包过程中包含Jetty的所有jar包，unpack设置将Jetty的jar包解压缩，unpackOptions中的exclude将根目录、META-INF、about_files里的内容排除，避免签名冲突同时减小war包的大小
  • fileSets允许用户通过文件或目录的粒度来控制打包，这里第一个fileSet指定将${project.basedir}/target/${project.build.finalName}中的所有静态资源打包到根目录下，并排除META-INF目录下的所有文件，第二个fileSet将${project.basedir}/target/classes中的所有class及配置文件打包到根目录下，并将org.springside.examples.showcase.Main编译后的Main.class添加到war包中

2、使用代码创建Jetty容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package org.springside.examples.quickstart;
 
  import java.io.File;
  import java.net.URL;
  import java.security.ProtectionDomain;
 
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.webapp.WebAppContext;
 
  /**
  * Main Class for standalone running.
  *
  * @author calvin
  */
  public class Main {
 
  public static void main(String[] args) throws Exception {
 
  String contextPath = "/" ;
  int port = Integer.getInteger( "port" , 8080 );
 
  Server server = createServer(contextPath, port);
 
  try {
  server.start();
  server.join();
  } catch (Exception e) {
  e.printStackTrace();
  System.exit( 100 );
  }
  }
 
  private static Server createServer(String contextPath, int port) {
  // use Eclipse JDT compiler
  System.setProperty( "org.apache.jasper.compiler.disablejsr199" , "true" );
 
  Server server = new Server(port);
  server.setStopAtShutdown( true );
 
  ProtectionDomain protectionDomain = Main. class .getProtectionDomain();
  URL location = protectionDomain.getCodeSource().getLocation();
 
  String warFile = location.toExternalForm();
  WebAppContext context = new WebAppContext(warFile, contextPath);
  context.setServer(server);
 
  // 设置work dir,war包将解压到该目录，jsp编译后的文件也将放入其中。
  String currentDir = new File(location.getPath()).getParent();
  File workDir = new File(currentDir, "work" );
  context.setTempDirectory(workDir);
 
  server.setHandler(context);
  return server;
  }
  }

createServer方法负责创建Jetty服务，获取war包路径，创建context及工作目录

main方法负责调用createServer方法创建Jetty服务，设置上下文路径及启动端口，并启动Jetty服务，另外如果war包所在的路径包含中文，则获取路径的代码应修改为：

1
2
3
ProtectionDomain protectionDomain = Main. class .getProtectionDomain();
  URL location = protectionDomain.getCodeSource().getLocation();
  location = java.net.URLDecoder.decode(location , "utf-8" );

3、注意事项

通过以上配置，已经可以在Web应用程序内嵌入Jetty容器了，但还需要注意以下几点

Maven Pom中的Jetty依赖注意scope修改为provided，防止Jetty的Jar包被打到WEB-INF/lib中。
如果需要解析jsp页面，需要在依赖中加入jsp-2.1-glassfish包的引用，注意其scope不能设置为provided

1
2
3
4
5
< dependency >
  < groupId >org.mortbay.jetty</ groupId >
  < artifactId >jsp-2.1-glassfish</ artifactId >
  < version >2.1.v20100127</ version >
  </ dependency >

由于Jetty只会在容器的classpath中寻找jstl tags，所以需要注意将jstl包拆包到Jetty容器的classpath中，但是jetty-7 (7.6.9)、jetty-8 (8.1.9)、jetty-9 (9.0.0.M4)之后的版本内嵌了jstl包，不需要添加jstl包。

4、运行

执行如下命令将Web应用打包成war包，在${project.basedir}/target目录下将会生成嵌入Jetty容器的war包。

1
mvn package -Pstandalone

通过如下命令运行war包。

1
Java -Xms2048m -Xmx2048m -XX:MaxPermSize=128m -jar xxx.war

方法二


方法一中主要是使用了maven-assembly-plugin进行自定义打包，除此之外还可以使用maven-war-plugin、maven-antrun-plugin、maven-dependency-plugin、maven-compiler-plugin共同实现创建可执行的war包

Maven POM配置示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
< profile >
  < id >standalone</ id >
  < build >
  < finalName >quickstart</ finalName >
  < plugins >
  < plugin >
  < groupId >org.apache.maven.plugins</ groupId >
  < artifactId >maven-war-plugin</ artifactId >
  < version >2.3</ version >
  < configuration >
  < archive >
  < manifest >
  < mainClass >org.springside.examples.quickstart.Main</ mainClass >
  </ manifest >
  </ archive >
  < warName >${project.artifactId}-standalone</ warName >
  </ configuration >
  </ plugin >
 
  < plugin >
  < groupId >org.apache.maven.plugins</ groupId >
  < artifactId >maven-antrun-plugin</ artifactId >
  < version >1.7</ version >
  < executions >
  < execution >
  < id >main-class-placement</ id >
  < phase >prepare-package</ phase >
  < configuration >
  < target >
  < move todir = "${project.build.directory}/${project.artifactId}/" >
  < fileset dir = "${project.build.directory}/classes/" >
  < include name = "**/*/Main.class" />
  </ fileset >
  </ move >
  </ target >
  </ configuration >
  < goals >
  < goal >run</ goal >
  </ goals >
  </ execution >
  </ executions >
  </ plugin >
  < plugin >
  < groupId >org.apache.maven.plugins</ groupId >
  < artifactId >maven-dependency-plugin</ artifactId >
  < version >2.5.1</ version >
  < executions >
  < execution >
  < id >jetty-classpath</ id >
  < phase >prepare-package</ phase >
  < goals >
  < goal >unpack-dependencies</ goal >
  </ goals >
  < configuration >
  < includeGroupIds >org.eclipse.jetty, org.eclipse.jetty.orbit,
  javax.servlet</ includeGroupIds >
  < includeScope >provided</ includeScope >
  <!-- remove some files in order to decrease size -->
  < excludes >*, about_files/*, META-INF/*</ excludes >
  <!-- <excludeArtifactIds>jsp-api,jstl</excludeArtifactIds> -->
  < outputDirectory >
  ${project.build.directory}/${project.artifactId}
  </ outputDirectory >
  </ configuration >
  </ execution >
  </ executions >
  </ plugin >
  <!-- to support compilation in linux -->
  < plugin >
  < groupId >org.apache.maven.plugins</ groupId >
  < artifactId >maven-compiler-plugin</ artifactId >
  < version >2.5.1</ version >
  < configuration >
  < target >1.6</ target >
  < source >1.6</ source >
  < encoding >UTF-8</ encoding >
  </ configuration >
  </ plugin >
  </ plugins >
  </ build >
  </ profile >
  • maven-war-plugin负责打包，并设置Main方法实现类为org.springside.examples.quickstart.Main
  • maven-antrun-plugin执行ant的target任务，将org.springside.examples.quickstart.Main类转移到war包的跟路径下
  • maven-dependency-plugin负责将jetty相关的jar包进行拆包并重新输出到war包根路径下，以便重新打包
  • maven-compiler-plugin负责编译web应用

注意事项、org.springside.examples.showcase.Main类实现及运行方法同方法一。

问啊-一键呼叫程序员答题神器，牛人一对一服务，开发者编程必备官方网站：www.wenaaa.com


QQ群290551701 聚集很多互联网精英，技术总监，架构师，项目经理！开源技术研究，欢迎业内人士，大牛及新手有志于从事IT行业人员进入！

jetty嵌入式 webApp开发（Simple Demo）
happy_boys_的专栏
03-11 2322
时间可以带走一切    ---路 jetty是一个轻量级的servlet容器，有点类似tomcat，但是用起来比tomcat方便。 jetty下载链接：http://download.eclipse.org/jetty/ 我的开发环境 ： 操作系统：UBuntu 14.04 LTS 集成工具：Eclipse（Version: Luna Service Release 1 (
jetty嵌入式web容器jar包
09-11
jetty嵌入式web容器jar包 示例： public static void main(String[] args) { // 服务器的监听端口 Server server = new Server(6666); // 关联一个已经存在的上下文 WebAppContext context = new WebAppContext(); // 设置描述符位置 context.setDescriptor("./WebContent/WEB-INF/web.xml"); // 设置Web内容上下文路径 context.setResourceBase("./WebContent"); // 设置上下文路径 context.setContextPath("/"); context.setParentLoaderPriority(true); server.setHandler(context); try { server.start(); } catch (Exception e) { e.printStackTrace(); } }
jetty的xml文件配置说明.pdf
09-21
jetty的xml文件配置说明
jetty嵌入式实例
10-31
jetty实例,嵌入式jetty，java接收json数据，取特定字符，展示到浏览器，
Web容器Jetty
侠客行
09-07 282
一、Jetty简介        Jetty 是一个开源的servlet容器，它为基于Java的web容器（例如JSP和servlet）提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。        开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。   二、Jetty...
嵌入式Web容器-Jetty
jjsmdhhh的博客
08-08 438
Spring MVC是Spring生态体系中最重要的部分 M:（Model模型）、V：（View视图）、C：（Controller控制器） MVC是一种编程结构，而不是一种模式。 Jetty 1. Jetty是一个开源的servlet容器 2. 开发人员可以将Jetty容器实例化成一个对象，无需依赖外部环境，让程序以独立方式（stand-alone）运行。 3. Jetty相比Tomc...
深入探究JAVA中Jetty嵌入式Web容器的应用
在探讨如何在Java中使用Jetty作为轻量级嵌入式Web容器的知识点之前，我们首先需要明确几个核心概念。Jetty是一款开源的Servlet容器，它提供了Web服务器和Java Servlet容器的全部功能。它是一个成熟的项目，被广泛...
Java如何使用Jetty实现嵌入式的Servlet容器
08-25
在Java中，实现嵌入式的Servlet容器可以使用Jetty，Jetty是一个Java实现的开源的servlet容器，可以作为一个完整的Web服务器和Servlet容器，同时也可以嵌入在Java应用程序中。在Java程序中调用Jetty可以实现嵌入式的...
JAVA里使用Jetty作为轻量级嵌入式的Web容器
08-06
3. **使用Jetty作为Web容器** - 首先，需要在项目中添加Jetty的依赖，可以通过Maven或Gradle来管理。 - 创建一个`Server`实例，并配置监听端口。 - 添加`Handler`，如`ServletContextHandler`，来处理HTTP请求。 ...
[课堂课件讲解]Java微服务实践-Spring Boot嵌入式Web容器.pptx
08-27
Embedded Jetty和Embedded Tomcat是两个常用的嵌入式Web容器，它们提供了不同的功能和配置方式。 Embedded Jetty： Embedded Jetty是Spring Boot提供的一种嵌入式Web容器，提供了便捷的配置和使用方式。Embedded ...
使用Gradle在嵌入式Web容器Jetty中运行Web应用
weixin_33995481的博客
03-13 181
2019独角兽企业重金招聘Python工程师标准>>> ...
jetty嵌入式服务.rar
06-22
jetty嵌入式服务.rar
使用jetty来启动一个web服务
03-01
NULL 博文链接：https://congpeixue.iteye.com/blog/254664
web 容器 Jetty 简介
whatday的专栏
06-02 666
前言： 最近公司项目中用到了Jetty来作为项目的web容器，借此机会来分享一下我的学习心得。在学习Jetty之前，一定要了解一些Jetty的基本概念以及优缺点，这样才方便做更深入的学习，现在让我来慢慢揭开它的神秘面纱吧！ 基础： 什么是Jetty? 简单来讲Jetty就是一个开源的HTTP服务器和Servlet引擎，它可以为JSP和Servlet提供运行时环境，比如Java Web应用最常用的Servlet容器Tomcat，由于其轻量、灵活的...
详解web容器 - Jetty与Tomcat孰强孰弱
qq_35381274的博客
01-09 162
详解web容器 - Jetty与Tomcat孰强孰弱 https://www.cnblogs.com/crazyacking/p/5734849.html
嵌入式Jetty
allway2的博客
03-23 878
Jetty 可以在嵌入式模式下运行。这意味着无需构建 WAR 文件并将其部署在独立的 Jetty 服务器中。Jetty 是一个软件组件，可以像任何其他 POJO（Plain Old Java Object）一样实例化和使用。 简单的处理程序 AHandler是处理传入请求的组件。请求在handle方法中处理。处理程序被传递 servlet API 请求和响应对象，但它们不是 servlet。 $ mkdir simplehandler $ cd simplehandler/ $ mkdir -p
Jetty实战之 嵌入式Jetty集成Spring运行
qq_44943584的博客
04-23 188
Jetty实战之 嵌入式Jetty集成Spring运行
java jetty 嵌入式_使用Jetty作为嵌入式服务器
weixin_42133415的博客
03-04 378
项目中用到嵌入式服务器的功能，于是去jetty的官方网站看了jetty嵌入方面的文档，简要翻译了其中可能用到的部分，方便以后参考。Jetty有一个口号：不要把你的应用部署到Jetty中，把Jetty部署到你的应用中。Jetty可以在Java应用程序中向其他POJO一样被实例化，换句话说，以嵌入式的模式运行Jetty是指将Http模块放入你的应用程序中，而非部署你的程序到一个HTTP服务器。嵌入式J...
嵌入式jetty相关知识总结
李昊的专栏
01-27 3799
1嵌入式jetty简介 在介绍嵌入式jetty之前，首先介绍一下jetty。 Jetty 是一个开源的servlet容器，它为基于Java的web内容，例如JSP和servlet提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和Web连接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值