JavaWeb开发之Maven

作者: 平安喜乐698 | 来源:发表于2018-04-29 01:06 被阅读149次

目录

1. 框架简介

Maven:跨平台的项目管理工具,可以
      项目构建
       【清理项目】→【编译项目】→【测试项目】→【生成测试报告】→【打包项目】→【部署项目】
      依赖管理
        自动下载项目所需要的jar包，管理依赖关系

配置maven环境（MAC）

http://maven.apache.org/download.cgi 下载Maven

Maven文件夹（放到Lib下）
    bin：含有mvn运行的脚本
    boot：含有plexus-classworlds类加载器框架
    conf：含有settings.xml配置文件
    lib：含有Maven运行时所需要的java类库
    LICENSE.txt, NOTICE.txt, README.txt针对Maven版本，第三方软件等简要介绍

终端
    vim ~/.bash_profile    修改环境变量
        export MAVEN_PATH=/Library/maven3.5.3
        export PATH=$PATH:$MAVEN_PATH/bin
    source ~/.bash_profile        保存立刻生效
    mvn -v  查看是否安装成功

Maven仓库：用来统一存储所有Maven共享构建的位置
    每个构建在仓库中唯一存储路径（根据Maven坐标定义）大致为：groupId/artifactId/version/artifactId-version.packaging

仓库分类
    本地仓库（从Maven中心仓库下载到本地的jar包的）
          每个用户只有一个本地仓库，默认是在~/.m2/repository/，~代表的是用户目录
          修改位置
            maven文件夹|conf文件夹|settings.xml文件的<setting>下+ 修改jar包下载位置
            <localRepository>/Users/cx/Workspaces/repository</localRepository>
    远程仓库
          1、中央仓库：Maven默认的远程仓库，URL地址：http://search.maven.org/
          2、私服：是一种特殊的远程仓库，它是架设在局域网内的仓库

Maven坐标
    在平面几何中，坐标（x,y）可以标识平面中唯一的一点。在开发中，坐标可以唯一确定一个项目
    Maven坐标（便于管理使用）主要组成
      groupId：组织标识（包名）
      artifactId：项目名
      version：项目的当前版本
      packaging：项目的打包方式，最为常见的jar和war两种

生命周期

Maven生命周期就是为了对所有的构建过程(项目清理，初始化，编译，打包，测试，部署)进行抽象和统一.

Maven有三套相互独立(可组合使用)的生命周期
    1. Clean Lifecycle     在构建之前进行清理工作。
    2. Default Lifecycle   构建的核心部分(编译，测试，打包，部署等等)。
    3. Site Lifecycle      生成项目报告，站点，发布站点。

Clean生命周期共三个阶段：
    1. pre-clean 执行一些需要在clean之前完成的工作
    2. clean 移除所有上一次构建生成的文件
    3. post-clean 执行一些需要在clean之后立刻完成的工作
    mvn clean"中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，"mvn clean"等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。

Site生命周期共三个阶段：
    1. site 生成项目的站点文档
    2. post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
    3. site-deploy 将生成的站点文档部署到特定的服务器上
　　
Default生命周期（最重要的一个，做绝大部分工作）常用的阶段：
    validate
    generate-sources
    process-sources
    generate-resources
    process-resources 复制并处理资源文件，至目标目录，准备打包。
    compile 编译项目的源代码。
    process-classes
    generate-test-sources
    process-test-sources
    generate-test-resources
    process-test-resources 复制并处理资源文件，至目标测试目录。
    test-compile 编译测试源代码。
    process-test-classes
    test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
    prepare-package
    package 接受编译好的代码，打包成可发布的格式，如 JAR 。
    pre-integration-test
    integration-test
    post-integration-test
    verify
    install 将包安装至本地仓库，以让其它项目依赖。
    deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
　　 运行任何一个阶段的时候，它前面的所有阶段都会被运行，这也就是为什么我们运行mvn install 的时候，代码会被编译，测试，打包。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。

基础

项目目录（约定好的）

MavenProjectRoot(项目根目录)
   |----src
   |     |----main
   |     |         |----java ——存放项目的.java文件
   |     |         |----resources ——存放项目资源文件，如spring, hibernate配置文件
   |     |----test
   |     |         |----java ——存放所有测试.java文件，如JUnit测试类
   |     |         |----resources ——存放项目资源文件，如spring, hibernate配置文件
   |----target ——项目输出位置（编译自动生成）
   |----pom.xml ----用于标识该项目是一个Maven项目

pom.xml

pom(project object model).xml
    包含了项目构建的信息，包括项目的信息、项目的依赖等。
    继承:子模块的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>com.mycompany.app</groupId>
  <artifactId>my-WebApp</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>my-WebApp Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>my-WebApp</finalName>
  </build>
</project>

说明：
<project>　　　　　　pom顶级节点（写法固定）
<modelVersion>　　　pom版本（对Maven2和3只能是4.0.0）
<groupId>　　　　　　创建项目的组织标识符（一般是域名倒写）
<artifactId>　　　　项目名（组织下的唯一标识）
<version>　　　　　 项目版本（SNAPSHOT表示是快照版本）
<packaging>　　　　 打包的方式（有jar、war、ear等）
<name>　　　　　　　 项目名称
<url>　　　　　　　　项目地址
<properties>　　　　属性配置
<dependencies>　　 构建项目所依赖的jar

由groupId、artifactId和version唯一的确定了一个项目。

依赖配置（使用jar包）

pom.xml中+
   <dependencies>
        <!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
       <!--项目要使用到Hello.jar包，所以在这里添加Hello.jar包的依赖-->
        <dependency>
            <groupId>com.sst.cx.maven</groupId>
            <artifactId>Hello</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>    
    </dependencies>

使用
    import com.sst.cx.maven.Hello;


scope（依赖范围）
    用来控制依赖和编译，测试，运行的classpath的关系.
    主要的是三种依赖关系如下：
　　　　1.compile： 默认编译依赖范围。对于编译，测试，运行三种classpath都有效
　　　　2.test：测试依赖范围。只对于测试classpath有效
　　　　3.provided：已提供依赖范围。对于编译，测试的classpath都有效，但对于运行无效。因为由容器已经提供，例如servlet-api
　　　　4.runtime:运行时提供。例如:jdbc驱动
    传递性依赖
    　　MakeFriends.jar直接依赖于HelloFriends.jar，而HelloFriends.jar又直接依赖于Hello.jar，那么MakeFriends.jar也依赖于Hello.jar，这就是传递性依赖，只不过这种依赖是间接依赖

Maven插件

    1. Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。
    2. 每个插件都能实现多个功能，每个功能就是一个插件目标。
    3. Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务，例如compile就是插件maven-compiler-plugin的一个插件目标。

聚合

用于构建多个项目

 <modules>
       <module>../Hello</module>  
       <module>../HelloFriend</module>        
       <module>../MakeFriends</module>
</modules>

继承

继承为了消除重复，我们把很多相同的配置提取出来，例如：grouptId，version等

<parent>  
          <groupId>com.sst.cx.maven</groupId>
          <artifactId>ParentProject</artifactId>
          <version>0.0.1-SNAPSHOT</version>
          <relativePath>../ParentProject/pom.xml</relativePath>  
</parent>

自动生成项目

mvn archetype:create或者mvn archetype:generate　　 固定写法
　　-DgroupId　　　　　　　　　　　　　　　　　　　　　　 组织标识（包名）
　　-DartifactId　　　　　　　　　　　　　　　　　　　　 项目名称
　　-DarchetypeArtifactId　　  　　　　　　　　　　　　指定ArchetypeId，maven-archetype-quickstart，创建一个Java Project；maven-archetype-webapp，创建一个Web Project
　　-DinteractiveMode　　　　　　　　　　　　　　　　　 是否使用交互模式

DarchetypeArtifactId是可用的mvn项目骨架，目前可以使用的骨架有：
  * maven-archetype-archetype
  * maven-archetype-j2ee-simple
  * maven-archetype-mojo
  * maven-archetype-portlet
  * maven-archetype-profiles (currently under development)
  * maven-archetype-quickstart  （Java 项目）
  * maven-archetype-simple (currently under development)
  * maven-archetype-site
  * maven-archetype-site-simple
  * maven-archetype-webapp  （JavaWeb 项目）

手动创建Maven项目

新建文件夹MavenTest(结构同上,约定)

新建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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.sst.cx.maven</groupId>
  <artifactId>MavenTest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>MavenTest</name>
  
    <!--添加依赖的jar包-->
    <dependencies>
        <!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
        </dependency>        
    </dependencies>
</project>

新建com文件夹|sst文件夹|cx文件夹|Hello.java

package com.sst.cx.maven;
public class Hello {
    public String sayHello(String name){
        return "Hello "+name+"!";
    }
}

终端
    进入项目根目录
    mvn compile 编译

编译成功后根目录下自动出现
    target文件夹
        classes文件夹（编译成功后生成的.class）


其他终端命令
    mvn clean     清除编译
    mvn test      测试项目  （target下多了一个test-classes文件夹，classes文件夹下多了一个类Test.class）
    mvn package   打包（target下多了一个类名-0.0.1-SNAPSHOT.jar）
    mvn install  （最常用）【清理】→【编译】→【测试】→【打包】-> 【部署项目到仓库】

    组合命令    
    mvn clean compile
    mvn clean test
    mvn clean package
    mvn clean install

5 快速生成Java项目

生成

方式一
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
方式二(有点问题)
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

mvn clean compile   编译
mvn clean test      测试
mvn clean package   打包（会先编译测试）
mvn clean install   安装（会先编译测试打包）

运行jar包
java -cp target\myapp-1.0-SNAPSHOT.jar com.mycompany.app.App

6 快速生成JavaWeb项目

生成

方式一
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-WebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
方式二
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=myWebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

创建好的JavaWeb项目中目前只有src/main/resources目录，因此还需要手动添加src/main/java、src/test/java、src/test/resources

打包发布

mvn package
    Target目录下生成war包，放在Tomcat/webapps下即可访问

或者


或者
<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>com.mycompany.app</groupId>
  <artifactId>myWebApp</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>myWebApp Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>myWebApp</finalName>
     <pluginManagement>
        <!--配置Jetty-->
          <plugins>
            <plugin>
             <groupId>org.mortbay.jetty</groupId>   
             <artifactId>maven-jetty-plugin</artifactId>
            </plugin>
          </plugins>
    </pluginManagement>
  </build>
</project>

mvn jetty:run

示例（继承与聚合）

聚合用来构建项目，继承用来消除重复

例：
父项目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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sst.cx.maven</groupId>
    <artifactId>Parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <name>Parent</name>
    <url>http://maven.apache.org</url>
    
    <!-- 对Hello、Hello2 这2个项目进行聚合 -->
    <modules>
        <module>../Hello</module>
        <module>../Hello2</module>
    </modules>
    
    <!-- 定义属性 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>4.9</junit.version>
        <maven.version>0.0.1-SNAPSHOT</maven.version>
    </properties>

    <!-- 用dependencyManagement进行jar包依赖管理 -->
    <dependencyManagement>
        <!-- 配置jar包依赖 -->
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <!-- 访问junit.version属性 -->
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>com.sst.cx.maven</groupId>
                <artifactId>Hello</artifactId>
                <!-- 访问maven.version属性 -->
                <version>${maven.version}</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>com.sst.cx.maven</groupId>
                <artifactId>Hello2</artifactId>
                <!-- 访问maven.version属性 -->
                <version>${maven.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

Hello项目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/xsd/maven-4.0.0.xsd">
  
  <modelVersion>4.0.0</modelVersion>
  <artifactId>Hello</artifactId>
  
      <!-- 继承Parent项目中的pom.xml配置 -->
       <parent>  
          <groupId>com.sst.cx.maven</groupId>
          <artifactId>Parent</artifactId>
          <version>0.0.1-SNAPSHOT</version>
          <!-- 使用相对路径 -->
          <relativePath>../Parent/pom.xml</relativePath>  
       </parent>
    
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>
</project>

Hello2项目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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <artifactId>Hello2</artifactId>
    <name>Hello2</name>
    
    <!-- 继承Parent项目中的pom.xml配置 -->
    <parent>
        <groupId>com.sst.cx.maven</groupId>
        <artifactId>Parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../Parent/pom.xml</relativePath>
    </parent>
    <dependencies>
        <dependency>
            <!-- Parent项目的pom.xml文件配置中已经指明了要使用的Junit的版本号，因此在这里添加junit的依赖时，
            可以不指明<version></version>和<scope>test</scope>，会直接从Parent项目的pom.xml继承 -->
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!-- Hello2项目中使用到了Hello项目中的类，因此需要添加对Hello.jar的依赖 
        Hello.jar的<version>和<scope>也已经在Parent项目的pom.xml文件配置中已经指明了，因此这里也可以省略不写了
        -->
        <dependency>
            <groupId>com.sst.cx.maven</groupId>
            <artifactId>Hello</artifactId>
        </dependency>
    </dependencies>
</project>

MyEclipse
    选中Parent项目的pom.xml文件→【Run As】→【Maven install】
    Maven就会一次性同时构建Parent、Hello、Hello2这3个项目

MyEclipse

导入已有项目

右键|Import|Import|Existing Maven Projects|找导入Maven项目

新建Maven项目

右键|New|Project|Maven Project
勾选Create a simple project则不能选择archetype

4-2

运行Maven项目

选中pom.xml | 右键 | Run As

或者

选中项目 | 右键 | Run As
选中项目 | 右键 | Run As | build（第3个）可以执行组合命令

部署项目

pom.xml第一行报错
Help | Sites | 
name=mavenAch
url=http://repo1.maven.org/maven2/.m2e/connectors/m2eclipse-mavenarchiver/0.17.2/N/LATEST/

使用自己安装的Maven

设置 | MyEclipse | Installations | Add | 找到下载好的Maven路径

使用自己安装的Maven

更换JDK

设置 | java | Installation JREs 
    必须1.6以上

更换JDK

修改User Settings

将maven文件夹下 | conf文件夹下 | settings.xml 复制到本地仓库下
设置 | MyEclipse | Maven | UserSettings 选择仓库下的settings.xml

修改User Settings

搭建nexus Maven私服

有些公司不提供外网给项目组人员，不能使用maven访问远程的仓库地址,解决：
    在局域网里找一台有外网权限的电脑，搭建nexus私服。开发人员通过这台电脑访问maven的远程仓库。

1.下载nexus（放到Lib下）
    https://www.sonatype.com/download-nexus-repository-trial
    nexus文件夹含2个子文件夹
        nexus-3.10.0-04文件夹包含了nexus的运行环境和应用程序
        sonatype-work文件夹包含了自己的配置和存储构件的地方
        nexus-3.10.0-04/conf/nexus.properties中可以修改端口信息以及工作区的路径

2.启动
    /Library/nexus3.1/nexus-3.10.0-04/bin/nexus start
    浏览器输入http://127.0.0.1:8081检验是否启动成功

修改环境变量
    vi ~/.bash_profile
        export NEXUS_PATH=/Library/nexus3.1/nexus-3.10.0-04/bin
        export PATH=$PATH:$MAVEN_PATH/bin:$NEXUS_PATH
    source ~/.bash_profile
直接nexus start启动

3. 
登陆 默认账号admin，密码admin123

nexus默认是关闭远程索引下载

实际开发（多模块（多层））

进行分层开发便于维护，一般会分为
    domain（域模型层）
    dao（数据库访问层）
    service（业务逻辑层）
    web（表现层）

项目结构
    system-parent
    　　　　|----pom.xml
    　　　　|----system-domain
        　　　　　　　　|----pom.xml
    　　　　|----system-dao
        　　　　　　　　|----pom.xml
    　　　　|----system-service
        　　　　　　　　|----pom.xml
    　　　　|----system-web
        　　　　　　　　|----pom.xml

1. 创建system-parent

cd Desktop
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-parent -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

桌面上出现system-parent文件夹
    删除其下src文件夹
    pom.xml中将<packaging>jar</packaging>修改为<packaging>pom</packaging>，pom表示它是一个被继承的模块

2. 创建system-domain

cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-domain -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在system-parent目录中的pom.xml文件自动添加了
    <modules>
        <module>system-domain</module>
    </modules>
修改system-domain目录中的pom.xml文件
    把(注意不是parent下的)groupId和version、dependencies去掉，(注意不是加在parent下)加上<packaging>jar</packaging>

3. 创建system-dao

cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-dao -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在system-parent目录中的pom.xml文件自动添加了
    <modules>
        <module>system-dao</module>
    </modules>
修改system-dao目录中的pom.xml文件
    把(注意不是parent下的)groupId和version去掉，(注意不是加在parent下)加上<packaging>jar</packaging>，添加
     <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
      <dependencies>
      <!--system-dao需要使用到system-domain中的类，所以需要添加对system-domain模块的依赖-->
      <dependency>
        <groupId>com.sst.cx</groupId>
        <artifactId>system-domain</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies>

4. 创建system-service

cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-service -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在system-parent目录中的pom.xml文件自动添加了
    <modules>
        <module>system-service </module>
    </modules>
修改system-service目录中的pom.xml文件
    把(注意不是parent下的)groupId和version去掉，(注意不是加在parent下)加上<packaging>jar</packaging>，添加
     <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
      <dependencies>
      <!--system-dao需要使用到system-domain中的类，所以需要添加对system-domain模块的依赖-->
      <dependency>
        <groupId>com.sst.cx</groupId>
        <artifactId>system-dao</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies>

5. 创建system-web

cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-web -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

在system-parent目录中的pom.xml文件自动添加了
    <modules>
        <module>system-web</module>
    </modules>
修改system-web目录中的pom.xml文件
    把(注意不是parent下的)groupId和version去掉，(注意不是加在parent下)加上<packaging>war</packaging>，添加
     <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
      <dependencies>
      <!--system-dao需要使用到system-domain中的类，所以需要添加对system-domain模块的依赖-->
      <dependency>
        <groupId>com.sst.cx</groupId>
        <artifactId>system-service</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies>
    <build>
        <finalName>system-web</finalName>
        <plugins>
            <!--配置Jetty插件-->
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

6. 编译运行项目

cd system-parent
mvn clean install
在system-web目录下多出了target目录，里面有了system-web.war

cd system-web/
mvn jetty:run
浏览器输入http://localhost:8080/system-web/出现Hello World！即成功

7. 导入MyEclipse

选择system-parent文件夹

JavaWeb开发之Maven

1. 框架简介

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaEE