`

用Maven构建Java Web开发环境(Jetty容器)之二(转载)

阅读更多

目前为止我们还是手工命令行方式执行程序的,没有和IDE结合,其实Maven天生就对Eclipse做了集成,我们使用mvn eclipse:eclipse就得到了一个Eclipse的项目结构,在Eclipse中使用import功能就能直接导入到IDE中了。我们来看一下 这个过程:

    此时的demo就是Eclipse项目格式的了,出现了.project和.classpath文件。我们在Eclipse中引入这个项目,此时的 Eclipse没有安装Maven插件,不能自动运行Maven命令,我们来安装Maven的Eclipse插件M2E。

    在Eclipse的Install New Software中直接选择安装即可,非常简单。下面我们来创建Web项目并导入Eclipse中,在Jetty容器中运行程序。首先执行mvn archetype:generate命令创建。

    可以看到,刚创建的web项目结构包含了resources目录,而没有java代码目录,我们需要手工创建,在Eclipse中创建source folder,路径为src/main/java/src,现在我们得到如下一个项目结构,新建一个Servlet用于测试。

    此时,项目中没有Servlet的依赖,需要添加,我们使用m2eclipse插件来直接添加依赖,如下所示:

    相应的XML为:

Xml代码
  1. < dependency >   
  2.         < groupId > javax.servlet </ groupId >   
  3.         < artifactId > servlet-api </ artifactId >   
  4.         < version > 2.5 </ version >   
  5.         < type > jar </ type >   
  6.         < scope > compile </ scope >   
  7. </ dependency >   
    <dependency>
    		<groupId>javax.servlet</groupId>
    		<artifactId>servlet-api</artifactId>
    		<version>2.5</version>
    		<type>jar</type>
    		<scope>compile</scope>
    </dependency>


    下面就可以编写Servlet了,很简单,就输出HelloWorld吧。

Java代码
  1. package  org.ourpioneer.servlets;  
  2.   
  3. import  java.io.IOException;  
  4. import  java.io.PrintWriter;  
  5.   
  6. import  javax.servlet.ServletException;  
  7. import  javax.servlet.http.HttpServlet;  
  8. import  javax.servlet.http.HttpServletRequest;  
  9. import  javax.servlet.http.HttpServletResponse;  
  10.   
  11. public   class  HelloWorldServlet  extends  HttpServlet {  
  12.   
  13.     protected   void  doGet(HttpServletRequest request,  
  14.             HttpServletResponse response) throws  ServletException, IOException {  
  15.         this .process(request, response);  
  16.     }  
  17.   
  18.     protected   void  doPost(HttpServletRequest request,  
  19.             HttpServletResponse response) throws  ServletException, IOException {  
  20.         this .process(request, response);  
  21.     }  
  22.   
  23.     private   void  process(HttpServletRequest request,  
  24.             HttpServletResponse response) throws  ServletException, IOException {  
  25.         response.setContentType("text/html;charset=utf-8" );  
  26.         response.setCharacterEncoding("utf-8" );  
  27.         PrintWriter out = response.getWriter();  
  28.         String title="Webapp Demo" ;  
  29.         out.println("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" );  
  30.         out.println("<html xmlns=\"http://www.w3.org/1999/xhtml\">" );  
  31.         out.println("<head>" );  
  32.         out.println("<meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\" />" );  
  33.         out.println("<title>"  + title +  "</title>" );  
  34.         out.println("<body>" );  
  35.         out.println("<h1>Hello World!</h1>" );  
  36.         out.println("</body>" );  
  37.         out.println("</html>" );  
  38.     }  
  39. }  
package org.ourpioneer.servlets;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloWorldServlet extends HttpServlet {

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		this.process(request, response);
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		this.process(request, response);
	}

	private void process(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		response.setContentType("text/html;charset=utf-8");
		response.setCharacterEncoding("utf-8");
		PrintWriter out = response.getWriter();
		String title="Webapp Demo";
		out.println("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">");
		out.println("<html xmlns=\"http://www.w3.org/1999/xhtml\">");
		out.println("<head>");
		out.println("<meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\" />");
		out.println("<title>" + title + "</title>");
		out.println("<body>");
		out.println("<h1>Hello World!</h1>");
		out.println("</body>");
		out.println("</html>");
	}
}


    然后不能忘了在web.xml中配置这个Servlet,这里是Servlet 2.5的规范,不是Servlet 3,不能用注解。这也很简单。

Xml代码
  1. <? xml   version = "1.0"   encoding = "UTF-8" ?>   
  2. < web-app   version = "2.5"   xmlns = "http://java.sun.com/xml/ns/javaee"   
  3.     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"   
  4.     xsi:schemaLocation ="http://java.sun.com/xml/ns/javaee   
  5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">   
  6.   
  7.     < display-name > Archetype Created Web Application </ display-name >   
  8.   
  9.     < servlet >   
  10.         < servlet-name > helloworld </ servlet-name >   
  11.         < servlet-class > org.ourpioneer.servlets.HelloWorldServlet </ servlet-class >   
  12.     </ servlet >   
  13.   
  14.     < servlet-mapping >   
  15.         < servlet-name > helloworld </ servlet-name >   
  16.         < url-pattern > /helloworld </ url-pattern >   
  17.     </ servlet-mapping >   
  18. </ web-app >   
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 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_2_5.xsd">

	<display-name>Archetype Created Web Application</display-name>

	<servlet>
		<servlet-name>helloworld</servlet-name>
		<servlet-class>org.ourpioneer.servlets.HelloWorldServlet</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>helloworld</servlet-name>
		<url-pattern>/helloworld</url-pattern>
	</servlet-mapping>
</web-app>


    程序都有了,剩下就是运行了,Maven既然天生和Jetty是一对儿,这里我们就使用Jetty吧,在Maven中配置Jetty,首先是 webdefault.xml要准备好,它是配置Jetty的,这个可以从Jetty的包中找到,并复制到resources下,这里多说一点,默认 Jetty运行时是锁定JS/CSS等静态文件的,如果想在Jetty运行时也能修改它们,要在webdefault.xml中修改如下设置:

Xml代码
  1. < init-param >   
  2.   < param-name > useFileMappedBuffer </ param-name >   
  3.   < param-value > false </ param-value >   
  4. </ init-param >   
    <init-param>
      <param-name>useFileMappedBuffer</param-name>
      <param-value>false</param-value>
    </init-param>


    Jetty也准备了,运行命令是jetty:run,这要在Maven中设置,那么需要在pom.xml中加入Jetty的插件的设置信息。这里直接贴出其整体构建信息。

Xml代码
  1. < build >   
  2.     < finalName > webapp </ finalName >   
  3.     < sourceDirectory > src/main/java/src </ sourceDirectory >   
  4.     < testSourceDirectory > src/test </ testSourceDirectory >   
  5.     < plugins >   
  6.         < plugin >   
  7.             < groupId > org.apache.maven.plugins </ groupId >   
  8.             < artifactId > maven-compiler-plugin </ artifactId >   
  9.             < version > 2.0.2 </ version >   
  10.             < configuration >   
  11.                 < source > 1.6 </ source >   
  12.                 < target > 1.6 </ target >   
  13.                 < encoding > utf-8 </ encoding >   
  14.             </ configuration >   
  15.         </ plugin >   
  16.         < plugin >   
  17.             < groupId > org.apache.maven.plugins </ groupId >   
  18.             < artifactId > maven-resources-plugin </ artifactId >   
  19.             < configuration >   
  20.                 < encoding > UTF-8 </ encoding >   
  21.             </ configuration >   
  22.         </ plugin >   
  23.         < plugin >   
  24.             < groupId > org.mortbay.jetty </ groupId >   
  25.             < artifactId > jetty-maven-plugin </ artifactId >   
  26.             < version > 7.1.6.v20100715 </ version >   
  27.             < configuration >   
  28.                 < stopKey > stop </ stopKey >   
  29.                 < stopPort > 5599 </ stopPort >   
  30.                 < webAppConfig >   
  31.                     < contextPath > / </ contextPath >   
  32.                     < defaultsDescriptor > src/main/resources/webdefault.xml </ defaultsDescriptor >   
  33.                 </ webAppConfig >   
  34.                 < scanIntervalSeconds > 0 </ scanIntervalSeconds >   
  35.                 < connectors >   
  36.                     < connector   implementation = "org.eclipse.jetty.server.nio.SelectChannelConnector" >   
  37.                         < port > 80 </ port >   
  38.                         < maxIdleTime > 60000 </ maxIdleTime >   
  39.                     </ connector >   
  40.                 </ connectors >   
  41.             </ configuration >   
  42.         </ plugin >   
  43.         < plugin >   
  44.             < groupId > org.apache.maven.plugins </ groupId >   
  45.             < artifactId > maven-eclipse-plugin </ artifactId >   
  46.             < version > 2.7 </ version >   
  47.             < configuration >   
  48.                 < addVersionToProjectName > false </ addVersionToProjectName >   
  49.                 < useProjectReferences > false </ useProjectReferences >   
  50.                 < encoding > UTF-8 </ encoding >   
  51.                 < wtpmanifest > false </ wtpmanifest >   
  52.                 < wtpapplicationxml > true </ wtpapplicationxml >   
  53.                 < wtpversion > 1.5 </ wtpversion >   
  54.                 < additionalBuildcommands >   
  55.                     < buildcommand > org.eclipse.jdt.core.javabuilder </ buildcommand >   
  56.                     < buildcommand > org.eclipse.wst.common.project.facet.core.builder </ buildcommand >   
  57.                     < buildcommand > org.eclipse.wst.validation.validationbuilder </ buildcommand >   
  58.                 </ additionalBuildcommands >   
  59.   
  60.                 < additionalProjectnatures >   
  61.                     < nature > org.springframework.ide.eclipse.core.springnature </ nature >   
  62.                     < nature > org.maven.ide.eclipse.maven2Nature </ nature >   
  63.                     < nature > org.eclipse.wst.common.project.facet.core.nature </ nature >   
  64.                     < nature > org.eclipse.jdt.core.javanature </ nature >   
  65.                     < nature > org.eclipse.wst.common.modulecore.ModuleCoreNature </ nature >   
  66.                 </ additionalProjectnatures >   
  67.                 < classpathContainers >   
  68.                     < classpathContainer > org.eclipse.jdt.launching.JRE_CONTAINER </ classpathContainer >   
  69.                 </ classpathContainers >   
  70.             </ configuration >   
  71.         </ plugin >   
  72.         < plugin >   
  73.             < groupId > org.apache.maven.plugins </ groupId >   
  74.             < artifactId > maven-war-plugin </ artifactId >   
  75.             < version > 2.1-beta-1 </ version >   
  76.             < configuration >   
  77.                 < warName > webapp </ warName >   
  78.             </ configuration >   
  79.         </ plugin >   
  80.     </ plugins >   
  81. </ build >   
	<build>
		<finalName>webapp</finalName>
		<sourceDirectory>src/main/java/src</sourceDirectory>
		<testSourceDirectory>src/test</testSourceDirectory>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.0.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<encoding>utf-8</encoding>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<configuration>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>jetty-maven-plugin</artifactId>
				<version>7.1.6.v20100715</version>
				<configuration>
					<stopKey>stop</stopKey>
					<stopPort>5599</stopPort>
					<webAppConfig>
						<contextPath>/</contextPath>
						<defaultsDescriptor>src/main/resources/webdefault.xml</defaultsDescriptor>
					</webAppConfig>
					<scanIntervalSeconds>0</scanIntervalSeconds>
					<connectors>
						<connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
							<port>80</port>
							<maxIdleTime>60000</maxIdleTime>
						</connector>
					</connectors>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-eclipse-plugin</artifactId>
				<version>2.7</version>
				<configuration>
					<addVersionToProjectName>false</addVersionToProjectName>
					<useProjectReferences>false</useProjectReferences>
					<encoding>UTF-8</encoding>
					<wtpmanifest>false</wtpmanifest>
					<wtpapplicationxml>true</wtpapplicationxml>
					<wtpversion>1.5</wtpversion>
					<additionalBuildcommands>
						<buildcommand>org.eclipse.jdt.core.javabuilder</buildcommand>
						<buildcommand>org.eclipse.wst.common.project.facet.core.builder</buildcommand>
						<buildcommand>org.eclipse.wst.validation.validationbuilder</buildcommand>
					</additionalBuildcommands>

					<additionalProjectnatures>
						<nature>org.springframework.ide.eclipse.core.springnature</nature>
						<nature>org.maven.ide.eclipse.maven2Nature</nature>
						<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
						<nature>org.eclipse.jdt.core.javanature</nature>
						<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
					</additionalProjectnatures>
					<classpathContainers>
						<classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer>
					</classpathContainers>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.1-beta-1</version>
				<configuration>
					<warName>webapp</warName>
				</configuration>
			</plugin>
		</plugins>
	</build>


    此时,更新一下Maven依赖,它们就都自动下载到本地了,到这个过程结束,我们就可以在Eclipse中配置Debug运行了。配置很简单,如下。

    这是Debug模式运行,Run模式下是一样的,用Debug模式可以在Eclipse中断点运行程序,非常便于调试。下面我们就让它跑起来吧。运行命令 是jetty:run,Base directory配置是:${workspace_loc:/应用名},启动调试,看到如下信息,Jetty就成功启动了。

    这里我们使用了80端口,配置方式在pom.xml中,上面的代码已经体现了。在浏览器中访问地址如下:http://localhost/helloworld,之后,我们就看到了效果。

分享到:
评论

相关推荐

    Eclipse+maven+jetty开发环境搭建

    本教程将深入探讨如何使用Eclipse集成开发环境(IDE)、Maven项目管理和构建工具,以及Jetty轻量级服务器来搭建一个完整的Java Web开发环境。以下是详细步骤和相关知识点: 1. **Eclipse IDE**: Eclipse 是一个开源...

    maven集成jetty所需jar包maven-jetty-plugin,多版本

    Maven是一个项目管理工具,它可以帮助开发者管理和构建Java项目,而Jetty则是一个轻量级的嵌入式Servlet容器,常用于快速开发、测试以及部署Web应用。本文将详细讨论如何将Jetty与Maven进行集成,并介绍关键的`maven...

    java web开发部署神器--jetty插件

    本文将深入探讨"java web开发部署神器--jetty插件",带你领略Jetty在Java Web开发中的魅力。 Jetty是由Mortbay公司开发的一款高性能、小巧的HTTP服务器和Servlet容器。它以其高效的内存管理和快速的响应能力而著称...

    maven项目下用 jetty 启动热部署

    当我们使用Maven构建Java Web项目时,结合Jetty服务器,可以实现项目的热部署功能,即在开发环境中修改代码后无需重新启动服务器,改动就能实时生效,极大地提高了开发效率。 在Maven项目中启用Jetty热部署,主要...

    使用Eclipse构建Maven的Web项目用jetty启动.docx

    ### 使用Eclipse 构建 Maven 的 Web 项目并用 Jetty 启动 #### 一、直接建立 Maven 项目的方法 ##### 1.1 建立 Maven 项目 为了构建一个基于 Spring MVC 的 Web 项目,我们首先需要在 Eclipse 中创建一个 Maven ...

    Maven与Jetty

    总之,Maven和Jetty的集成为Java Web开发带来了很多便利,它简化了项目管理,加快了开发迭代速度,并提供了方便的调试和测试环境。通过合理配置Maven的POM文件和使用Jetty插件,开发者可以更专注于代码编写,而不必...

    Maven + Jetty Plugin

    "Maven + Jetty Plugin" 是一个用于快速开发和测试Java Web应用程序的组合,它结合了Maven构建工具和Jetty服务器。Maven是一个强大的项目管理工具,它简化了构建、管理和部署Java项目的过程,而Jetty则是一个轻量级...

    maven jetty

    总结来说,Maven与Jetty的结合使得Java Web应用的开发、测试流程更为高效。通过Maven Jetty插件,我们可以轻松地在本地环境中启动和调试应用,同时享受到热部署带来的便利。在"WebApp"目录下,开发者可以组织并管理...

    文件上传下载(maven + spring mvc + jetty)

    总结来说,"文件上传下载(maven + spring mvc + jetty)"项目是一个使用现代Java Web技术实现的简单示例,展示了如何利用Maven构建、Spring MVC处理HTTP请求和Jetty作为轻量级服务器。通过对这些技术的掌握,开发者...

    dwr+maven+jetty

    - 配置Jetty服务器,使其能够运行Maven构建的Web应用。 - 使用Maven的命令行工具(如`mvn jetty:run`)启动Jetty服务器并运行应用。 文件列表中的`pom.xml`是Maven项目的配置文件,包含了项目的信息和依赖项。`src`...

    用Maven和Jetty开发调试WEB应用程序

    ### 使用Maven和Jetty开发调试WEB应用程序 #### 前言 在现代软件开发过程中,集成工具如Maven和Jetty极大地提高了开发效率。Maven作为自动化构建工具,能够帮助开发者快速创建、管理和构建项目;而Jetty则是一款轻...

    IntelliJ+Maven+Jetty+Jrebel实现web项目java代码更改后热部署

    3. **Jetty**: Jetty是一个轻量级的Java Web服务器和Servlet容器,它可以快速地启动和停止,非常适合用于开发和测试阶段。通过Jetty,开发者可以在开发过程中实时查看和测试应用,而无需每次都重新编译和部署整个...

    Eclipse+_maven_+_jetty_开发web

    要使用Eclipse、Maven和Jetty进行Web开发,首先需要配置好开发环境。这包括安装JDK、Eclipse IDE、Maven以及Jetty。配置过程中,需要指定Maven的安装目录和环境变量,同时也要确保Eclipse中已安装了Maven和Jetty的...

    深入体验Java_Web开发内幕—核心基础 完整版 pdf

    《深入体验Java_Web开发内幕—核心基础》是一本针对Java Web开发的深度解析书籍,旨在帮助读者全面理解和掌握Java Web开发的核心技术。这本书涵盖了从基础到高级的多个主题,旨在提供一个完整的Java Web开发学习路径...

    用maven构建SpringMVC+JPA+Hibernate+Hsql+jetty的web项目

    【标题】"用maven构建SpringMVC+JPA+Hibernate+Hsql+jetty的web项目"涉及了多个核心的Java Web开发技术,这里我们将深入探讨这些技术以及如何将它们整合到一起。 1. Maven:Maven是Apache的一个开源项目,它是一个...

    自己构建微服务(springmvc+内嵌jetty+maven 环境配置)

    构建这样的微服务涉及到配置开发环境,包括安装Java Development Kit (JDK)、设置环境变量、配置Maven的pom.xml文件以声明依赖项,以及为Jetty和Spring MVC设置合适的配置文件。 6. **实践步骤**: - 首先,创建...

    Eclipse+Maven创建webapp项目集成jetty服务器

    1. **Eclipse**:Eclipse是一款强大的开源集成开发环境(IDE),尤其适合Java开发者。它提供了代码编辑、调试、版本控制等多种功能,是开发Java Web项目的首选工具之一。 2. **Maven**:Apache Maven是一个项目管理...

Global site tag (gtag.js) - Google Analytics