maven

来源：互联网发布：windows10 mac地址编辑：程序博客网时间：2024/06/16 01:50

Maven-项目构建技术（工具）

今天的主要安排：

1． maven的概述（为什么要使用Maven，Maven是什么）

2．快速入门（配置、名词解释、使用命令行来构建）

3．插件的快速入门使用（配置、使用插件构建项目-java项目和web项目）

4．应用详解：

1）仓库---是什么？能干什么？分类

2） POM配置详解

3）依赖（讲解如何去自动依赖其他的项目---jar）

4） ssh的POM参考

5．多模块（聚合）和继承

6．插件

学习目标：如何创建项目、如何导入jar、如何进行其他配置、如果管理生命周期

1. Maven的概述和技术简介

1.1. 项目开发中的问题

1、我的项目依赖一些jar包，我把他们放在哪里？直接拷贝到项目的lib文件夹中?

如果我开发的第二个项目还是需要上面的那些jar包，再把它们复制到我当前项目lib中？

那如果现在是第三次了，再复制一次吗？

-----这样真的好吗？这样子操作会引起什么样的问题？

2、我写了一个数据库相关的通用类，并且推荐给了其他项目组，现在已经有5个项目组使用它了，今天我发现了一个bug，并修正了它，我会把jar包通过邮件发给其他项目组。

---那如果有新的bug出现，还要改呢？

带着这些问题，我们开始学习maven。

1.2. 什么是maven

简而言之：maven通过配置管理软件项目

Maven的概念：

几个概念：

n POM 项目对象模型：

n 标准集合（标准的规范约定）-骨架

n 项目（工程）生命周期—从开发角度来说

n 依赖管理系统（开发项目工程需要依赖其他的项目--jar）

n 插件（maven的具体功能，是靠插件完成）（本身核心很小—想用它，需要用一些依赖的东西）

Maven的核心思想：

约定优于配置

每个公司都有自己的开发规范（打包规范、编译环境），这其实就是一种约定。

使用maven进行统一项目管理，很多环节内容是约定好的。可以更好的敏捷开发。

maven的作用：

Maven是面向技术层面，针对java开发的项目管理工具，它提供了构建工具所提供的功能，除了构建功能之外，maven还可以管理项目结构、管理依赖关系、生成报告、生成Web站点、有助于团队成员之间的协作。

学习过程中参考图书：

Maven管理项目的周期：

2. Maven的快速入门

2.1. Maven的下载安装

官方网站：http://maven.apache.org/

下载页面：http://maven.apache.org/download.cgi

官网的系列版本：

版本选择问题：

本课程选用3.1.1

Windows环境请下载maven zip包：

解压maven的zip包（注意解压的路径，建议不要有中文、空格、特殊符号）

bin目录：

boot目录

conf目录

提示：maven本身的包很小，要想实现功能是通过插件来使用的。

2.2. Maven的配置

配置JDK环境：

我们所使用的3.1.1系列版本最低的jdk要求是1.5或以上。

因此，我们要确认系统中安装的jdk版本，并且将JAVA_HOME/bin加入到环境变量path中。

配置maven的环境变量：

l MAVEN_HOME=maven压缩包解压目录。

l 在path环境变量中，增加%MAVEN_HOME%\bin

测试是否配置成功：

重新打开cmd窗口，运行：mvn-v（等同于mvn --version）

出现下图的信息，说明环境配置正确且生效了：

2.3. Maven仓库配置

什么是仓库？

仓库就是一个目录，这个目录被用来存储我们项目的所有依赖（插件的jar包还有一些其他的文件），简单的说，当你build一个Maven项目的时候，所有的依赖文件都会放在本地仓库里，仓库供所有项目使用

Mvn所有的jar包都是从中央仓库下载。

http://mvnrepository.com/

仓库的位置是通过maven的核心配置文件（settings.xml）来配置的。

打开settings.xml文件

发现：默认的仓库位置是在当前登录用户的home目录下：

名称为repository文件夹。

同时将maven的setting文件也拷贝到该目录下。

修改默认仓库位置为自定义的仓库位置：

新建repository文件夹：

因为mvn会通过互联网的中央仓库自动下载jar包，但是比较慢，这里不做下载，使用老师给大家提供的仓库即可

解压：

然后拷贝到D:\apache-maven-3.1.1\repository的仓库中

在核心配置文件setting.xml中，将仓库存放的位置设置成“D:\apache-maven-3.1.1\repository”。

settings.xml的其他配置（参考）

2.4. 本地仓库的建立

使用Maven，需要一些插件和jar（插件是一些开发完成的项目打成的jar包，使用插件就可以操作对应项目中的功能，但是项目不一定是插件）来支持，这些插件需要联网下载（而且，是自动下载的，但是必须联网，然后缓存到本地仓库。）

maven会优先从本地仓库中寻找，如果没有则上网下载。而且会将互联网中的jar缓存到本地仓库。

如果没有网络，可以将下发 “本地仓库”中的已经下载好的仓库内容，解压到仓库文件夹：

注意：注意解压文件的目录层次！

扩展：里面目录是很多可以依赖项目（jar）和一些插件。

2.5. Maven名词解释（预备知识）

Ø Project：任何你想build的事物，maven都可以认为他们是工程，这些工程被定义为工程对象模型(POM:Project Object Model)一个工程可以依赖其他的工程，一个工程也可以有多个子工程构成。

Ø POM：就是xml文件，是maven的核心文件，它是Maven如何工作的元数据文件。POM文件位于每个工程的根目录中。

Ø GroupId：groupId是一个工程在全局唯一的标识符，一般，他就是包名。GroupId有利于使用一个完整的包名，将一个工程从其他有类似名称的工程里区别出来。

Ø Artifact：artifact是工程将要产生或者需要使用的文件，他可以是jar文件、源文件、二进制文件、war文件、甚至是pom文件。每个artifact都有groupId和artifactId组合的标识符唯一识别。需要被使用（依赖）的artifact都要放在仓库（见Repository）中，否则Maven无法找到他们。

Ø Dependency：为了能够bulid或者运行，一个典型的java工程会依赖其他的包。在Maven中，这些被依赖的包就被称为dependency。Dependency一般是其他工程的jar。

Ø Plugin：Maven是由插件组成的，它的每一个工程都是由插件提供的。插件提供goal，并根据在POM中找到的元数据去完成工作。主要的Maven插件都是由java写成的，但是也支持用Beanshell或者Ant脚本写的插件。

Ø Repository：仓库。

相关概念的关系：

新建maven工程称之为project，每个maven工程都包含pom.xml描述文件（maven工程的核心配置文件）

Ø 一个工程区分其它工程的方式，是通过groupId（组）和ArtifactId（唯一标识）来区分的。

Ø 一个工程可以通过dependency（依赖的jar包）依赖其它工程

2.6. 构建helloworld工程项目（命令行方式）

新建一个目录用来存放maven工程：

在E盘创建一个mvnproject文件夹，用来存放maven项目

打开cmd窗口，可使用Maven Archetype插件的create命令创建maven项目：

mvn archetype:create -DgroupId=cn.itcast.maven.quickstart -DartifactId=helloworld -DarchetypeArtifactId=maven-archetype-quickstart

mvn：mvn的命令

archetype:create：创建工程

-DgroupId：组id（包名）

cn.itcast.maven.quickstart：自定义包名

-DartifactId=helloworld：工程的名字为helloworld

-DarchetypeArtifactId=maven-archetype-quickstart：javase的项目的骨架（maven的插件）

执行命令：会在当前目录下生成helloworld的工程：

包名为cn.itcast.maven.quickstart

命令参数解释：

groupId 组名（默认为java包名）

artifactId 唯一标识（默认情况下为项目名称，我们这里叫helloworld）

archetypeArtifactId 骨架（用来决定项目结构，选择什么骨架，就会生成什么样的项目结构，骨架一般都是现成的固定好的，我们这里的骨架叫maven-archetype-quickstart）

分析一下项目结构：

1、Maven Archtype插件创建了一个与artifactId匹配的目录-----helloworld。这是项目的基础目录。

2、每个项目在文件pom.xml里有它的项目对象模型（POM）。这个文件描述了这个项目，配置了插件，声明了依赖。

3、项目的源码资源文件被放在了src/main目录下面。

4、项目的测试用例放在src/test下。

Maven项目结构是标准的：

l pom.xml 位于工程根目录，对项目进行配置，任何一个maven项目都有。

l src/main/java 存放项目源码（源码和测试代码是分开的）

l src/test/java 存放项目测试代码

提示：只要使用相同的骨架，则生成的项目的结构都是一样的。

测试：再建立一个helloworld2的项目后，发现项目目录结构是一致的。

2.7. 操作项目工程（命令行方式）

常用的Maven命令行指令：

想要执行mvn命令，需要进入工程所在目录（即进入到pom.xml所在目录）

注意：所有的mvn命令都必须针对pom.xml运行！

【示例】常用的maven命令-组合命令：

n 编译命令 mvn compile

作用：在工程目录生成target目录，将源码（\src\main）编译为class文件，存放在target/classes目录。

提示：如果对测试代码编译，需要执行mvn test-compile在target/test-classes生成class文件，结果：

n 清除命令 mvn clean

作用：清除编译后的结果，会删除target目录及相关文件。

n 测试命令 mvn test

作用：运行测试，会先对代码自动编译，生成target目录和测试报告。

提示：Maven会自动先编译再自动运行测试。

n 打包命令 mvn package

作用：Java项目自动打成 jar包；Web项目自动打成war包。

结果：

提示：该文件名的名字为：工程名字（其实是artifactID）-版本-版本性质.jar，SNAPSHOT表示开发版本。

另外：如果打包的时候不想执行测试（跳过测试），可以执行：

mvn package -Dmaven.test.skip=true

n 安装命令 mvn install

作用：将项目打包后，安装到仓库（repository）中

查看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">

<groupId>cn.itcast.maven.quickstart</groupId>

<artifactId>helloworld</artifactId>

<version>1.0-SNAPSHOT</version>

<name>helloworld</name>

<url>http://maven.apache.org</url>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

</project>

看出：安装到的仓库目录是有一定规律的，是固定的，格式如下：

${仓库根目录}/groupId/artifactId/version/xxx.jar

可以再次安装helloworld2来测试查看结构情况。

构建Maven项目生命周期（完整）

l validate

l generate-sources

l process-sources

l generate-resources

l process-resources 复制并处理资源文件，至目标目录，准备打包。

l compile 编译项目的源代码。

l process-classes

l generate-test-sources

l process-test-sources

l generate-test-resources

l process-test-resources 复制并处理资源文件，至目标测试目录。

l test-compile 编译测试源代码。

l process-test-classes

l test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。

l prepare-package

l package 接受编译好的代码，打包成可发布的格式，如JAR 。

l pre-integration-test

l integration-test

l post-integration-test

l verify

l install 将包安装至本地仓库，以让其它项目依赖。

l deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。

提示：生命周期从上到下执行，如果执行后面命令，自动执行之前项目构建步骤。

2.8. Maven项目转化为其它项目—了解

目标：将maven项目导入到开发工具环境中，如Eclipse等。

Maven提供了一些向常用开发工具转换的命令参数：

【示例】

将helloworld的maven项目转换为eclipse项目：

mvn eclipse:eclipse

打印的日志：

说明：这是调用的maven的一个插件，插件的名字叫：maven-eclipse-plugin

注意：转换的时候，需要相关的转换eclipse插件（本地仓库中已经有了）。

将转换后的项目导入到eclipse中：

提示：如果要导入到myeclipse中，java工程基本没问题，但web工程有些问题。可以参考：

【示例】

清除eclipse的项目信息：

mvn eclipse:clean

如何了解一个插件的详细用法呢？

【示例】了解显示插件的详细信息（命令参数等）

mvn help:describe -Dplugin=eclipse //简单一些帮助

mvn help:describe -Dplugin=eclipse -Ddetail//更详细的帮助

Maven的核心配置文件Setting和工程的pom文件的区别？

Setting文件：是Maven这个管理工具的全局整体配置，比如配置仓库的位置等。

POM.xml文件：是某个具体的maven工程的配置描述。

3. m2Eclipse快速入门

3.1. m2Eclipse是什么

m2Eclipse是一款便捷使用maven的Eclipse插件。

安装该插件的目的是让eclipse直接支持maven的开发。

3.2. 下载安装

该插件可以到官网下载：http://eclipse.org/m2e/

但新版的Eclipse都默认内置安装了该插件（Eclipse3.7之前的没有），因此几乎不需要安装。

而MyEclipse也内置了自己的一个插件叫Maven4MyEclipse，功能和m2eclipse差不多一样。

如何安装插件：

演示：如果是eclipse的3.7的版本，是没有maven插件，下载并安装maven插件

如果是eclipse3.7以下的版本，如何安装maven相关插件（不讲，但是大家要知道在企业中如何安装插件）

第一步：下载eclipse版本，

http://www.eclipse.org/downloads/eclipse-packages/

下载页面

或者到http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/heliossr2,下载对应的版本。然后解压。

第二步：安装eclipse的maven插件m2eclipse,

上官网http://m2eclipse.sonatype.org/installing-m2eclipse.html

上面介绍了两种安装方法的。

第一种方法过程如下：

1.选择help菜单> Install New Software.然后弹出安装的对话框；

2。复制http://m2eclipse.sonatype.org/sites/m2e到名为“Work with”的输入框，然后回车，显示

如下图

3.点击下一步，就可以安装了，然后点击next，勾选同意Licence，安装，最后重启eclipse。

第二种安装方法

具体步骤是这样的，

获得zest,m2e和m2e-extras三件文件夹。

进入到eclipse中的dropins目录下，新建三个txt文件（zest.txt,m2e.txt,m2e-extras.txt）。其中每个文件内容如下:

如图：

其中文件分别为：

path=D:\\pluginsNew\\maven\\m2e

path=D:\\pluginsNew\\maven\\m2e-extras

path=D:\\pluginsNew\\maven\\GEF-zest-3.7.1

其中D:\\pluginsNew\\maven表示将3个插件放置到的URL路径

（需将红色的路径修改你本机的实际插件的路径地址）

文件夹下必须存在eclipse的目录：

成功后看到如下画面：

点击window--属性，可以看到maven

检查插件是否安装好，检查Eclipse中的配置（在菜单栏点击Window->Preferences，打开参数配置窗口）中是否有如下菜单：

Eclipse

MyEclipse

3.3. 插件配置

本节，我们以Eclipse为例进行讲解（和myeclipse差不多一致）。

首先：找到Eclipse的配置中的maven插件所在位置，在相应菜单进行配置。

必须需要配置两个地方：

l 一个maven的安装目录

l 一个是当前用户的核心配置文件的位置

第一个地方：指定maven的安装位置--installations

提示：里面有个默认内置的，这里我们使用自己解压的maven。

第二个地方：指定maven配置文件（setting.xml）的位置—User Setting

提示：默认这个文件的位置是指向当前用户的目录下的文件位置。

注意：配置完成后一定要点击“update settings”按钮来更新配置，然后点击“Reindex” 按钮对仓库中项目重建索引（用于搜索）

另外，对插件的配置上的一个优化，可参考下图：

详细eclipse的使用，请参考《Eclipse相关配置.docx》。

3.4. 构建工程项目（使用插件）

下面，我们分别使用maven插件建立简单java项目和web项目。

3.4.1. 使用quickstart骨架建立简单java项目

新建一个maven项目：

下一步：

提示：我们本次准备使用的quickstart骨架，因此，这里不能选择跳过骨架选择！

下一步：骨架选择

提示1：如果第一次加载这个页面会比较慢。

提示2：打开后默认选中的骨架就是quickstart骨架。

下一步：配置maven工程的参数：

点击finish完成工程创建。

提示：如果跳出来一个错误，基本上会是你的仓库中没有这个骨架和相关插件，请检查你的仓库是否配置正确！当然，如果能联网，会自动下载相应的插件。

建立起来的工程目录结果—简单的java项目结构：

要看到工程中所有的文件，可以通过导航视图来查看：

提示：eclipse下，当工程保存的时候，会自动编译。

右键run as 查看能够使用maven命令

通过手动输入命令，来执行mvn package命令：

注意：这里不需要输入mvn了！

查看打出来的jar：

3.4.2. 建立web项目(使用骨架和不使用骨架)

本节，我们使用两种方式建立maven的web项目：

l 使用webapp骨架创建项目

l 不使用骨架创建项目(使用maven的内置的默认的约定)

第一种方式：使用webapp骨架创建项目

新建maven项目，不跳过骨架选择，

选择webapp骨架

下一步：

点击finish完成项目创建，结构如下：

提示：

目录结构遵循的约定梳理：

l src/main/resources 存放项目中配置文件 log4j.xml,applicationContext.xml等

l src/main/java 存放源码

l src/main/webapp 相当于之前的WebRoot

注意：如果你没有这个目录，那你就新建出这些目录.

发现index.jsp报错：原因没有导入servlet运行的环境。

第一步：添加服务器的运行环境，windows--Preferences

第二步：选择项目mavenDemo2，选择属性，添加Tomcat支持的jar包

运行web项目：使用maven内置的tomcat插件（tomcat-maven-plugin）。

运行命令：tomcat:run

提示：

该tomcat是内置的，和外面的tomcat没有关系。是内置运行的，每个tomcat都是独立运行的。它会在target中临时生成本次运行的tomcat的环境：

测试访问：

附件功能：改变内置tomcat的端口号

<groupId>org.codehaus.mojo</groupId>

<artifactId>tomcat-maven-plugin</artifactId>

</configuration>

</plugin>

</plugins>

第二种方式：不使用骨架创建项目。即跳过骨架选择，自动生成maven项目的目录结构（几乎完整-常用）

新建maven项目，选择跳过骨架选择：

下一步，配置项目信息：

点击finish完成项目创建。

效果：

提示：这种方法创建的项目目录结构很完整，但就缺少了一个web.xml文件，可以从别的项目中复制过来。

分析：生成的项目目录结构的约定：

l src/main/java 存放项目源码

l src/main/resources 存放项目配置文件

l src/test/java 存放测试源码

l src/test/resources 存放测试配置文件

l src/main/webapp存放页面代码

执行tomcat:run，启动服务器，查看结果：

缺点：没有web.xml ,但是可以复制一个进去

补充：如果用myeclipse2014或者你用新版的eclipse开发，连WEB-INF都没有。

测试：创建一个主页index.jsp，启动tomcat进行测试。

【如何选择哪种方式？】

推荐使用跳过骨架选择方式，这样生成目录结

构最完整！

4. maven应用详解

友情提示：本节概念原理较多，需要注意理解。

Maven核心概念：

1、仓库

2、坐标

3、依赖

4、多模块&继承

5、生命周期

6、插件

4.1. 仓库

maven项目管理，依赖于两大类仓库（三种仓库）:

n 本地仓库：在之前的maven核心配置文件settings.xml配置指定

可以将网络上项目缓存到本地仓库（当本地项目依赖网络上项目的时候，会自动下载缓存到本地仓库）

可以将自己开发项目也部署到本地仓库使用mvn install的命令

n 远程仓库：网络上仓库（分两种）

l 中央仓库（当本地项目依赖其它项目，而依赖的项目本地没有，maven就会自动到网络上的中央仓库去找）

远程公用仓库

Maven内置了远程公用仓库：http://repo1.maven.org/maven2

这个公共仓库是由Maven自己维护，里面有大量的常用类库，并包含了世界上大部分流行的开源项目构件。目前是以java为主。

l 公司内部搭建服务器--私服（可以快速下载仓库，还可以存放公司内部私密的一些项目）

扩展提示：中央仓库虽然是最大网络远程仓库，但里面管理jar包，也并不是企业开发全部（有些jar包需要到厂商的私服中下载，如JBOSS私服、Spring私服等）

查看仓库：

打开Maven仓库视图：

可以查看到本地仓库和远程仓库的树形列表：

对本地仓库建立索引：

提示：建议大家都重建一下索引，后面在使用的时候会用到。

如果不想从中央仓库自动获取索引，可以将其禁用：

4.2. POM配置详解

可以理解为：pom.xml就是用来管理我们的maven项目。

查看POM的内容

可以通过Eclipse的POM Editor来查看：

提示：这个编辑器eclipse有。

4.2.1. POM的全景图

Pom.xml文件是maven工程项目的核心配置文件。

它的所有配置和环境都在这张图上：

大致分下面几类：

坐标（Coordinates）： groupId、artifactId、version

聚合（Aggregation）：modules（一个项目可以分N个模块）

继承（Inheritance）：parent、dependencyManagement

依赖（Dependences）：dependences

项目工程信息（Project Information）：name、description、url…

构建配置（Build Settings）：properties、packaging（打包方式）、build（构建信息）、reporting（报告）

环境信息（Environment）：…

【关于POM的三个概念】：自定义POM、超级POM、有效POM

l 自定义的POM（最小POM）就是用户创建的工程中的那个POM文件，内容较少；

l 超级POM位于maven的内部，拥有POM的所有默认配置。

l 有效POM=自定义POM+超级POM

所有自定义的pom.xml都默认继承 “超级POM文件”（maven内置的），成为有效的POM。

【了解】超级POM的位置：

%MAVEN_HOME% /lib/maven-model-builder-3.0.4.jar中的\org\apache\maven\model\pom-4.0.0.xml，它是所有Maven POM的父POM，所有Maven项目继承该配置。

查看有效POM的内容。

提示：超级POM默认指向的是中央仓库。+

pom-4.0.0.xml文件内容

问题：有效POM的内容可以更改么？

可以！通过自定义POM，可以覆盖超级POM的内容。

4.2.2. POM核心配置说明

pom.xml是Maven项目的核心配置文件，位于每个工程的根目录，指示Maven工作的元数据文件。

我们先掌握和了解几个基本的核心配置。

n <project > ：文件的根节点。（固定的）

n <modelversion > ：pom.xml使用的对象模型版本（一般也都是4.0.0版本）

n <groupId > ：创建项目的组织或团体的唯一Id，指定包名。

n <artifactId > ：项目的唯一Id,可视为项目名。

n <version > ：产品的版本号。

注意：这三个称之为项目坐标，因为这三个组合在一起可以唯一锁定项目在仓库中的位置，因此，如果要寻找一个项目，先要获得其项目坐标，格式：仓库/groupId/artifactId/version/项目包(jar、war)

n <packaging > ：打包类型，一般有jar、war、pom等

Maven构建项目默认提供常见三种打包类型：

l jar包-------简单java项目

l war包----- web项目

l pom -----父项目，提供pom被子项目继承

n <name > ：项目的显示名，常用于 Maven生成的文档。

n <description > ：项目描述，常用于 Maven生成的文档

问题：关于artifactId、name、工程名是否必须一致？

三者可以不一致！

其作用区别是什么？

通过两个测试：

l 如果使用tomcat:run 运行项目，访问项目通过 artifactId 属性

l 在项目编译打包、安装部署（package、install命令），还是使用artifactId属性

通过测试发现：name属性只是用来生成文档中显示，不会影响到工程发布和打包等，写什么都无所谓。而工程本身的名字也对工程发布和打包没有影响，也无所谓。

4.3. 构建依赖 (dependencies)（重点）

什么是依赖构建，就是在项目之间，通过配置，可以进行自动依赖构建。

提示：依赖项目可以是第三方的，也可以是自己编写的。

4.3.1. 通过坐标导入jar包

；

坐标主要三个元素：

1：groupId：组ID

2：artifactId：项目ID

3：version：版本号

例如：

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

引入依赖的方法：在pom.xml中通过配置<dependencies> 来引入依赖。

引入依赖的思路原理：

坐标决定项目在仓库中唯一位置，我们就可以通过坐标来导入依赖项目，即可以理解为：可以通过坐标导入jar包。

【示例】在项目导入struts2和spring的需要jar包。

思考：要导入jar，首先要得到其坐标，那么怎么得到坐标呢？

两种方式：

方法一：使用网站搜索

1：http://search.maven.org/

2：http://mvnrepository.com/

方法二：适应maven插件的搜索功能，Maven Repository视图

方法一：（如果本地仓库没有足够的jar，就会报错，所以为了防止错误发生，电脑要联网）

在网站搜索项目，获取对应坐标。

如：http://mvnrepository.com/

比如搜索spring的核心jar：

列出所有版本：

选择一个版本，如4.2.4，点击进去：（Release Candidate:发布候选版）

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>4.2.4.RELEASE</version>

</dependency>

将依赖的这段坐标文字复制到pom.XML中后，保存，即可看到效果：

提示：所有的依赖都必须放到<dependencies>标签元素中，即一个项目可以依赖多个其他项目。如下图：

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>4.2.4.RELEASE</version>

</dependency>

</dependencies>

Spring官方的：

可以看到spring也是提倡使用maven来进行jar包的管理。

方法二：通过本地索引加入坐标。（struts2的依赖包）

这里也有两种操作方式打开添加依赖的菜单：

在工程上右击，或者在POM.xml文件上右击，都会出现下面的菜单：

提示：前提是必须建立索引（本地索引）

提示1：优先会找本地仓库，本地仓库找不到再去中央仓库找，如果中央仓库索引被禁用，则不会去中央仓库找。

提示2：如果有的jar不完整，没有下载完的，导入的时候会报错。（如果你联网的话，导入任何的可以索引到的项目，（如果本地仓库没有）都自动从网络上获取。下载的网站在超级pom中定义。）

点击OK后：

思考：为什么只导入核心core一个jar，但会导入这么多？

原因是：这个core的jar包会依赖其他jar，其本身的项目中的POM会描述其依赖的jar。

优势在于：如果手动的导入jar包，如果依赖的jar包忘记导入了，会报错。

查看仓库：

引入struts2的核心包，相当于引入以下jar包

因此：只需要导入struts2core坐标，struts2又会依赖其它项目，会自动导入其它项目jar包。

通过编辑器的依赖树视图（dependency hierarchy）功能，查看项目依赖关系

【示例】导入struts2的json插件

引入的jar包

【示例】将spring等框架需要的log4j的jar通过本地索引导入进来：

坐标对应的jar包。

【扩展】

为什么上面1.2.15是jar，而1.2.16和1.2.17是bundle呢？

log4j.log4j.1.2.15

log4j.log4j.1.2.16

jar、bundle：显示jar是maven认为标准的打包了。bundle，maven认为打的jar不标准，不推荐使用。所以大家导入的时候导入jar包

这里注意：如果发现存在-lastUpdated的文件，说明该文件没有下载完全，就断网了，所以该jar包是不能被使用的。

【示例】导入aspectJ的jar

坐标对应的jar包

提示：如果本地仓库没有相应版本的jar，会自动到中央仓库去找，然后自动下载，并缓存到本地。如将asepectj的版本换成本地没有的1.7.0，会自动下载并替换原来的版本。

4.3.2. 依赖的相关配置

完整的dependency 配置如下：

l groupId、artifactId、version是依赖的基本坐标，“缺一不可”，其它两个坐标元素不指定时将采用默认值（找到jar的位置）（当version没有的情况下，会自动使用依赖默认的版本）

l type：依赖的类型，对应坐标packaging方式，（它通常表示依赖的文件的扩展名），默认为jar。

l optional：标记依赖是否可选。A->B->C，那么当A依赖于C时就可以设为可选。一般不配置。

l exclusions：排除传递依赖，即某些依赖项目不想导入进来。（主要用来解决版本冲突问题）

【示例】排除log4j依赖的mail.jar

在依赖视图中，找到mail，点击右键：选择Exclude Maven Artifact..

Ok后，点击保存。效果如下：

查看pom.xml文件。

应用场景：当两个依赖项目都依赖于另外一个项目的不同版本的时候，就可以通过排除依赖，将不要的版本排除掉。

maven依赖有个特性：如果你依赖一个项目的两个版本，maven只会导入一个版本的项目。

l 依赖范围： scope

提示：可以通过有效pom来查看默认值。

详细解释：

Ø compile ：编译需要，打包需要（大多数的jar都是这种）-默认值

【示例】对mavenDemo3进行打包操作，查看包内应该有所有的jar。

Ø provided ：编译需要，不会被打包（servlet、jsp）

【示例】mavenDemo3，需导入servletjar，但只需要在编译的时候用，不需要打包。

坐标对应的jar包：

对mavenDemo3进行打包操作，查看包内应该有所有的jar。还是17个jar包，没有servlet-api-2.5.jar，可见编译时会可见，但是不会被打包。

Ø runtime：编译不需要，打包运行时需要（jdbc驱动）

坐标对应的jar包文件

Oracle的jar包

Ø test：参与测试，不会打包（junit）

【示例】新建一个junit测试用例，导入junit的jar

坐标对应的jar包：

对mavenDemo3进行打包package的操作，发现junit包并没有被打包：

Ø ~~system ：~~指向本地系统~~jar包（不推荐）~~

例如：

<scope>system</scope>

<systemPath>D:\apache-maven-3.1.1\repository\IKAnalyzer.jar</systemPath>

</dependency>

Maven坐标对应的jar包：

【scope小结】

4.3.3. 传递性依赖和统一版本管理

什么是传递性依赖？

传递性依赖也称之为间接依赖。

问题：如果两个jar，同时依赖与另外一个jar的不同版本，就可能导致jar冲突问题。这就是传递依赖的Jar版本冲突问题。

Struts2整合Spring需要struts2-spring-plugin的jar，该jar会依赖于spring。

坐标对应的jar包

将插件调换位置，到Spring-context的4.2.4版本之前，发现，spring的版本号都变了：

spring-context在前，struts2-spring-plugin在后

struts2-spring-plugin在前，spring-context在后

提示：依赖是有顺序的！谁依赖的版本在前面，项目就使用哪个版本的jar包。

那么maven是如何选择版本的呢？（maven的依赖调节策略）

例如：配置

spring-context在前，struts2-spring-plugin在后

对于spring-core的jar包，得到的结果是：

从上图可以看出，对于core的jar，两个路径相同，谁先声明加载（谁在上面），就用谁的版本。

解决传递依赖的问题的方案：

方案一：解决间接依赖最好方式，就是直接依赖（直接依赖优先间接依赖）

如，直接导入3.0.5版本的spring-core的jar：

方案二：锁定版本。

在需要的版本上，点击右键，选择锁定。

对应的pom文件的代码：

使用了<dependencyManagement>对依赖的版本进行锁定。

小结：解决版本冲突问题的方案：

1．排除（项目）版本

2．锁定版本

3．直接依赖

关于版本的另一个知识点：统一维护版本

好处：方便后期项目使用的框架版本的升级

第一步：使用<propeties>属性，定义版本

第二步：<version>中使用${}

<struts2-version>2.3.15.2</struts2-version>

<spring-version>4.2.4.RELEASE</spring-version>

</properties>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-core</artifactId>

<version>${struts2-version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring-version}</version>

</dependency>

</dependencies>

5. maven构建ssh项目

目标：使用maven整合SSH，可将crm系统重构。

步骤参考：

1) 通过坐标导入ssh框架开发jar包

2) 根据maven约定项目结构编写代码

3) 通过tomcat-maven-plugin运行项目

第一步：新建maven项目mavencrm，使用跳过骨架

第二步：通过maven坐标完成SSH整合（由于有传递依赖的情况，我们按一定顺序导入。可参考课前资料提供的pom文件）

导入spring：spring context（4.2.8），spring aspectj（4.2.8），spring web（4.2.8），spring test（4.2.8），spring orm（整合hibernate）（4.2.8），spring context support(缓存使用的)（4.2.8）

导入hibernate：hibernate core（5.0.11）

导入struts2：struts2 core（2.3.24），struts2 json（json插件）（2.3.24），struts2 spring （struts2整合spring）（2.3.24）
导入日志相关：slf4j-log4j（1.7.2）， log4j（slf4j整合log4j的包）（1.2.15）（如果存在，可以不导入）

导入连接池：c3p0（0.9.1.2）

导入数据库驱动：mysql（mysql驱动）（5.1.18），oracle驱动

导入缓存：ehcache（1.5.0）

导入servlet-api（2.5）、jsp-api（2.1）、（注意scope的范围是provided）、jstl（1.2）

导入junit：（注意scope的范围是test）（4.9）

统一维护版本：pom.xml文件的内容

<groupId>cn.itcast.maven</groupId>

<artifactId>itcastcrmMaven</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>itcastcrmMaven</name>

<description>使用Maven整合SSH项目</description>

<spring.version>4.2.8.RELEASE</spring.version>

<hibernate.version>5.0.11.Final</hibernate.version>

<struts2.version>2.3.24</struts2.version>

<mysql.version>5.1.18</mysql.version>

<c3p0.version>0.9.1.2</c3p0.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-orm</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-core</artifactId>

<version>${hibernate.version}</version>

</dependency>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-core</artifactId>

<version>${struts2.version}</version>

</dependency>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-json-plugin</artifactId>

<version>${struts2.version}</version>

</dependency>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-spring-plugin</artifactId>

<version>${struts2.version}</version>

</dependency>

</dependency>

</dependency>

<version>${c3p0.version}</version>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>${mysql.version}</version>

</dependency>

<groupId>net.sf.ehcache</groupId>

<artifactId>ehcache</artifactId>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet.jsp</groupId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet</groupId>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

第三步：复制项目代码

java代码 --- src/main/java

配置文件 ---- src/main/resources

注意：hbm属于配置文件，放入src/main/resources

WebRoot下页面 ---- src/main/webapp

WEB-INF --- WEB-INF （但不要复制 lib、classes）

第四步： java代码的错误原因分析：

@Override

public TgetModel() {

return c;

}

Maven默认使用的编译环境是1.5，而@override注解需要使用在1.6以上环境中

方案一：

选择项目-->properties属性-->Java Build Path。

方案二：使用maven的编译插件

<build>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

选择项目，执行Update Project操作，问题解决。

第五步：修改db.properties文件，改连接数据库的配置。

第六步：tomcat:run 运行项目

测试：tomcat:run

访问：http://localhost:8080/itcastcrmMaven/views/login.jsp

第六步：发现项目中有这样的问题，由于传递性依赖，导致jar包冲突

存在2个版本的jar包

分别是：

javassist-3.18.1-GA.jar

javassist-3.11.0.GA.jar

解决方案：有三种

1．排除（项目）版本

2．锁定版本

3．直接依赖

排除项目版本，使用高版本的

生成的代码：

<groupId>org.apache.struts</groupId>

<artifactId>struts2-core</artifactId>

<version>${struts2.version}</version>

<artifactId>javassist</artifactId>

<groupId>javassist</groupId>

</exclusion>

</exclusions>

</dependency>

问题解决。

6. 多模块和继承（重点）

多模块解决：将maven项目分解，为了统一管理和开发方便；

继承解决：使用pom配置，为了复用和整合的问题；

提示：两者虽然概念不同，但在企业中会一起使用。

多模块：将一个大工程分成几个小的工程便于开发。

继承：多个模块之间有关系，主要是指子模块和父工程之间的继承关系。即可以将公用的jar包放置到父工程下，子工程继承就可以使用。

6.1. 概念

n 多模块

n 继承

6.2. 构建示例和项目分解

【示例】使用eclipse工具进行父子工程构建

目标：构建一个父工程，两个子工程，让父工程管理子工程。

第一步：建立父工程（这里Packaging为pom）

提示：打包方式必须为pom

生成的工程：

查看crm_parent的pom.xml文件（打包方式发生改变）：

<groupId>cn.itcast.maven</groupId>

<artifactId>crm_parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>crm_parent</name>

<description>crm的父工程</description>

</project>

提示：父工程的作用：就是用来操作子工程的，用来被继承的，子工程可以使用。

第二步：导入ssh项目依赖的jar，放置到crm_parent中的pom.xml

导入配置文件

<spring.version>4.2.8.RELEASE</spring.version>

<hibernate.version>5.0.11.Final</hibernate.version>

<struts2.version>2.3.24</struts2.version>

<mysql.version>5.1.18</mysql.version>

<c3p0.version>0.9.1.2</c3p0.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-orm</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-core</artifactId>

<version>${hibernate.version}</version>

</dependency>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-core</artifactId>

<version>${struts2.version}</version>

<artifactId>javassist</artifactId>

<groupId>javassist</groupId>

</exclusion>

</exclusions>

</dependency>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-json-plugin</artifactId>

<version>${struts2.version}</version>

</dependency>

<groupId>org.apache.struts</groupId>

<artifactId>struts2-spring-plugin</artifactId>

<version>${struts2.version}</version>

</dependency>

</dependency>

</dependency>

<version>${c3p0.version}</version>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>${mysql.version}</version>

</dependency>

<groupId>net.sf.ehcache</groupId>

<artifactId>ehcache</artifactId>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet.jsp</groupId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet</groupId>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

<build>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

【第三步】建立子模块项目，引用父工程。

选择Maven Module

创建工程，跳跃骨架，模块名称为crm_entity（表示实体）

这里Packaging为jar包的形式，因为实体生成jar包被使用即可。

根据项目的包结构，可以抽取以下项目：

同理，依次创建

crm_utils：存放工具类（jar工程）

crm_exceptions：存放异常（jar工程）

crm_dao：存放DAO（jar工程）

crm_service：存放Service（jar工程）

crm_action：存放Action（war工程）

【第四步】构建依赖，哪些子模块需要依赖其他模块，目的是把几个工程关联起来。

分析：

crm_entity,crm_utils,crm_exceptions三个模块相对独立。

Dao依赖于crm_entity。

Service依赖于crm_dao。

Action依赖于crm_service。

1：Dao依赖crm_entity,crm_utils,crm_exceptions。

Service依赖crm_dao。

Action依赖crm_service。

查看crm_action的依赖树，可以看到：它包含了crm_service,crm_dao,crm_entity,crm_utils,crm_exceptions。

【第五步】配置文件的配置，将 itcastcrmMaven项目进行分解。

crm_utils

crm_execeptions

crm_entity

crm_dao

crm_service

crm_action

包括：类，资源文件，jsp页面。

在applicationContext.xml中导入其他applicationContext文件。

第六步：运行

方案一：对crm_action，执行tomcat:run

报错：

[ERROR] Failed to execute goal on project crm_action:Could not resolve dependencies for project cn.itcast.maven:crm_action:war:0.0.1-SNAPSHOT: Could not find artifact cn.itcast.maven:crm_service:jar:0.0.1-SNAPSHOT -> [Help 1]

[ERROR]

不能找到cn.itcast.maven下的crm_service.jar包，因为工程没有安装到本地仓库，这样的错误很常见，需要把几个工程安装到本地仓库上。需要执行install，但是选择6个工程，每一个都需要执行install吗？不需要，因为我们使用了多模块聚合（modules），所以只需要对crm_parent执行install即可。

查看：crm_parent中的pom文件的内容。

<module>crm_entity</module>

<module>crm_utils</module>

<module>crm_exceptions</module>

<module>crm_service</module>

<module>crm_action</module>

</modules>

访问：localhost:8080/crm_action/views/login.jsp，可以查看。

方案二：直接对crm_parent执行tomcat:run。

访问：localhost:8080/crm_action/views/login.jsp，可以查看。

方案三：将crm_action直接发布到tomcat上（不常用）

启动tomcat

这里注意：主要把crm_parent,crm_utils,crm_exceptions,crm_entity,crm_dao,crm_service安装到本地仓科。

访问：localhost:8080/crm_action/views/login.jsp，可以查看。

7. 生命周期-了解

Maven有三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”，这三套生命周期分别是：

Clean Lifecycle 在进行真正的构建之前进行一些清理工作。

Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。

Site Lifecycle 生成项目报告，站点，发布站点。

再次强调一下它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行mvn clean install site 运行所有这三套生命周期。

Clean Lifecycle:

clean生命周期每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：

pre-clean 执行一些需要在clean之前完成的工作

clean移除所有上一次构建生成的文件

post-clean 执行一些需要在clean之后立刻完成的工作

mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean，如果我们运行mvn post-clean，那么pre-clean，clean都会被运行。这是Maven很重要的一个规则，可以大大简化命令行的输入。

Default Lifecycle:

Default生命周期Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：

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的生命周期的，因此理解生命周期至关重要。

Site Lifecycle:

Site生命周期

pre-site 执行一些需要在生成站点文档之前完成的工作

site 生成项目的站点文档

post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备

site-deploy 将生成的站点文档部署到特定的服务器上

这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。

例如：在cmd下执行：

总结：所谓的maven一步构建，就是如果执行mvn install，就会执行install之前的所有命令。

8. 插件

因此：在maven整个生命周期的全过程，每个环节都是通过插件来完成的。

8.1. maven-compiler-plugin编译插件

<build>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

命令：mvn compile

作用：统一jdk的版本

8.2. tomcat-maven-plugin编译插件

<build>

<finalName>mavenDemo3</finalName>

<groupId>org.codehaus.mojo</groupId>

<artifactId>tomcat-maven-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

命令：tomcat:run

作用：使用maven的方式启动tomcat，并改变tomcat的端口号为8088

8.3. maven-surefire-plugin测试插件

主要功能：

1、输出日志和报告

2、解决中文乱码问题

可解决两个问题：

1．中文乱码问题

解决方法：通过覆盖超级pom的默认配置来增加一个配置属性

<build>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-surefire-plugin</artifactId>

<argLine>-Dfile.encoding=UTF-8</argLine>

</configuration>

</plugin>

</plugins>

</build>

修改mavenDemo1的代码：

第一步：添加junit4.9版本的测试包

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

第二步：在src/test/java下，添加测试类MyTest.java

public class MyTest {

@Test

public void test1(){

System.out.println("hello world!传智播客1");

}

@Test

public void test2(){

System.out.println("hello world!传智播客2");

}

@Test

public void test3(){

System.out.println("hello world!传智播客3");

}

运行test命令

出现乱码

第三步：解决方案，在pom.xml中使用maven-surefire-plugin插件

<build>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-surefire-plugin</artifactId>

<argLine>-Dfile.encoding=UTF-8</argLine>

</configuration>

</plugin>

</plugins>

</build>

问题解决

2．跳过测试

方案二：使用test -Dmaven.test.skip=true，也可以忽略测试步骤

测试失败仍然执行。

8.4. tomcat-maven-plugin使用 tomcat

8.4.1. 修改maven内置的tomcat端口号

使用tomcat:run 命令，默认使用 tomcat-maven-plugin:1.1 运行，使用8080端口

如何修改端口？

添加插件：

修改mavenDemo3的项目进行演示。

<build>

<finalName>mavenDemo3</finalName>

<groupId>org.codehaus.mojo</groupId>

<artifactId>tomcat-maven-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

执行mvn的命令：tomcat:run。

<charset>表示字符集强制编码，默认是ISO-8859-1

使用utf-8

8.4.2. 不使用maven内置的tomcat，自己配置tomcat7

【第一步】配置tomcat7

<groupId>org.apache.tomcat.maven</groupId>

<artifactId>tomcat7-maven-plugin</artifactId>

</configuration>

</plugin>

【第二步】运行

所以默认的端口还是8080

需要使用tomcat7:run才可以

查看控制台：

小结：

1．理解maven的思想，以及几个相关的概念

2．应用上的一些概念

1）仓库（本地和远程（中央和私服））

2） Pom.xml各种配置

3）依赖—导入jar，排除jar、解决传递性依赖（直接依赖、锁定版本）、同一版本控制。

作业：案例：参考ssh整合好的pom.xml---将原来的仓库的项目移植到maven的项目中。

3．多模块和继承：父子关系、通过父模块操作子模块、子模块可以继承工程的依赖等等。案例做一做

4.插件了解---知道命令中使用的插件都对应哪些？如何覆盖插件的参数，比如tomcat端口。

阅读全文

0 0