maven

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

Maven-项目构建技术(工具)

 

今天的主要安排:

1. maven的概述(为什么要使用MavenMaven是什么)

2. 快速入门(配置、名词解释、使用命令行来构建)

3. 插件的快速入门使用(配置、使用插件构建项目-java项目和web项目)

4. 应用详解:

1) 仓库---是什么?能干什么?分类

2) POM配置详解

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

4) sshPOM参考

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 项目(工程)生命周期—从开发角度来说

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

插件(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包:

 

解压mavenzip包 (注意解压的路径,建议不要有中文、空格、特殊符号)

 

bin目录:

 

boot目录

 

conf目录

 

 

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

 

2.2. Maven的配置

配置JDK环境:

 

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

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

 

配置maven的环境变量:

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

 

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文件夹。

同时将mavensetting文件也拷贝到该目录下。

 

 

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

 

新建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文件位于每个工程的根目录中。

 

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

 

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

 

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

 

Ø PluginMaven是由插件组成的,它的每一个工程都是由插件提供的。插件提供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

 

 

mvnmvn的命令

archetype:create:创建工程

-DgroupId:组id(包名)

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

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

-DarchetypeArtifactId=maven-archetype-quickstartjavase的项目的骨架(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命令-组合命令:

编译命令 mvn compile

 

作用:在工程目录生成target目录,将源码(\src\main)编译为class文件,存放在target/classes目录。

提示:如果对测试代码编译,需要执行mvn test-compiletarget/test-classes生成class文件 ,结果:

 

清除命令 mvn clean

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

测试命令 mvn test

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

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

打包命令 mvn package

作用:Java项目 自动打成 jar包;Web项目自动打成war包。

结果:

 

提示:该文件名的名字为:工程名字(其实是artifactID-版本-版本性质.jarSNAPSHOT表示开发版本。

另外:如果打包的时候不想执行测试(跳过测试),可以执行:

mvn package -Dmaven.test.skip=true

 

安装命令 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">

  <modelVersion>4.0.0</modelVersion>

 

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

  <artifactId>helloworld</artifactId>

  <version>1.0-SNAPSHOT</version>

  <packaging>jar</packaging>

 

  <name>helloworld</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>

</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     将包安装至本地仓库,以让其它项目依赖。

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

 

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

 

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

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

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

 

【示例】

将helloworldmaven项目转换为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是一款便捷使用mavenEclipse插件。

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

 

3.2. 下载安装

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

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

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

 

如何安装插件:

演示:如果是eclipse3.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插件所在位置,在相应菜单进行配置。

 

必须需要配置两个地方:

一个maven的安装目录

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

 

第一个地方:指定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项目(使用骨架和不使用骨架)

本节,我们使用两种方式建立mavenweb项目:

使用webapp骨架创建项目

不使用骨架创建项目(使用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的端口号

<plugins>

     <plugin>

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

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

     <version>1.1</version>

     <configuration>

     <port>8088</port>

     </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项目管理,依赖于两大类仓库(三种仓库):

 

 

 

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

 

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

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

n 远程仓库:网络上仓库(分两种)

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

远程公用仓库

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

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

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

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

 

查看仓库:

打开Maven仓库视图:

 

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

 

对本地仓库建立索引:

 

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

 

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

 

 

4.2. POM配置详解

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

查看POM的内容

可以通过EclipsePOM Editor来查看:

 

提示:这个编辑器eclipse有。

 

4.2.1.  POM的全景图

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

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

 

大致分下面几类:

坐标(Coordinates): groupIdartifactIdversion

聚合(Aggregation):modules(一个项目可以分N个模块)

继承(Inheritance):parentdependencyManagement

依赖(Dependences):dependences 

项目工程信息(Project Information):namedescriptionurl

构建配置(Build Settings):propertiespackaging(打包方式)、build(构建信息)、reporting(报告)

环境信息(Environment):

 

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

自定义的POM(最小POM)就是用户创建的工程中的那个POM文件,内容较少;

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

有效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.xmlMaven项目的核心配置文件,位于每个工程的根目录,指示Maven工作的元数据文件。

 

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

n <project > :文件的根节点。(固定的)

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

 

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

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

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

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

 

n <packaging > :打包类型,一般有jarwarpom

 

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

jar-------简单java项目

war-----  web项目

pom -----父项目,提供pom被子项目继承

 

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

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

 

 

问题:关于artifactIdname、工程名是否必须一致?

三者可以不一致!

其作用区别是什么?

 

通过两个测试:

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

l 在项目编译打包、安装部署(packageinstall命令,还是使用artifactId属性

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

 

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

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

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

4.3.1. 通过坐标导入jar

坐标主要三个元素:

1groupId:组ID

2artifactId:项目ID

3version:版本号

例如:

<dependencies>

    <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>3.8.1</version>

      <scope>test</scope>

    </dependency>

  </dependencies>

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

 

引入依赖的思路原理:

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

 

【示例】 在项目导入struts2spring的需要jar包。

思考:要导入jar,首先要得到其坐标,那么怎么得到坐标呢

两种方式:

方法一:使用网站搜索

1http://search.maven.org/

2http://mvnrepository.com/

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

 

 

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

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

如:http://mvnrepository.com/

比如搜索spring的核心jar

 

列出所有版本:

 

选择一个版本,如4.2.4,点击进去:(Release Candidate:发布候选版

 

<dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-context</artifactId>

   <version>4.2.4.RELEASE</version>

  </dependency>

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

 

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

  <dependencies>

   <dependency>

<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,但会导入这么多?

原因是:这个corejar包会依赖其他jar,其本身的项目中的POM会描述其依赖的jar

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

查看仓库:

 

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

 

 

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

 

通过编辑器的依赖树视图(dependency hierarchy)功能,查看项目依赖关系

 

 

【示例】导入struts2json插件

 

引入的jar

 

 

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

 

坐标对应的jar包。

 

【扩展】

为什么上面1.2.15jar,而1.2.161.2.17bundle呢?

 

log4j.log4j.1.2.15

 

log4j.log4j.1.2.16

 

jarbundle:显示jarmaven认为标准的打包了。bundlemaven认为打的jar不标准,不推荐使用。所以大家导入的时候导入jar

 

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

 

 

【示例】导入aspectJjar

 

坐标对应的jar

 

 

 

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

 

4.3.2. 依赖的相关配置

完整的dependency 配置如下:

 

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

l type:依赖的类型,对应坐标packaging方式,(它通常表示依赖的文件的扩展名),默认为jar

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

exclusions:排除传递依赖,即某些依赖项目不想导入进来。(主要用来解决版本冲突问题)

 

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

 

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

 

Ok后,点击保存。效果如下:

 

查看pom.xml文件。

 

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

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

 

依赖范围: scope

 

2

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

详细解释:

Ø compile :编译需要,打包需要 (大多数的jar都是这种)-默认值

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

 

Ø provided :编译需要,不会被打包 (servletjsp

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

 

坐标对应的jar包:

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

 

Ø runtime: 编译不需要,打包运行时需要(jdbc驱动)

 

坐标对应的jar包文件

 

Oraclejar

 

Ø test: 参与测试,不会打包 (junit

【示例】新建一个junit测试用例,导入junitjar

 

坐标对应的jar包:

 

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

 

Ø system 指向本地系统jar包 (不推荐 )

 

例如:

<!-- 导入lucene需要的IK分词器,这个maven网址(http://mvnrepository.com/)上,无法下载,可以下载好jar包,然后使用本地路径 -->

<dependency>

<groupId>IK</groupId>

<artifactId>IK</artifactId>

<version>1.0</version>

<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-pluginjar,该jar会依赖于spring

 

坐标对应的jar

 

 

将插件调换位置,到Spring-context4.2.4版本之前,发现,spring的版本号都变了:

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

 

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

 

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

 

那么maven是如何选择版本的呢?(maven的依赖调节策略

 

例如:配置

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

对于spring-corejar包,得到的结果是:

 

从上图可以看出,对于corejar,两个路径相同,谁先声明加载(谁在上面),就用谁的版本。

 

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

 

方案一:解决间接依赖最好方式,就是直接依赖(直接依赖优先 间接依赖

如,直接导入3.0.5版本的spring-corejar

 

方案二: 锁定版本。

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

 

对应的pom文件的代码:

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

 

 

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

1. 排除(项目)版本

2. 锁定版本

3. 直接依赖

 

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

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

第一步 :使用<propeties>属性,定义版本

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

 

  <!--定义本地属性-->

  <properties>

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

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

  </properties>

  <dependencies>

  

   <dependency>

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

   <artifactId>struts2-core</artifactId>

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

   </dependency>

    <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文件)

导入springspring 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)

导入hibernatehibernate core(5.0.11)

导入struts2struts2 core(2.3.24)struts2 jsonjson插件)(2.3.24)struts2 spring struts2整合spring(2.3.24)
   导入日志相关:slf4j-log4j(1.7.2), log4jslf4j整合log4j的包)(1.2.15)(如果存在,可以不导入)

导入连接池:c3p0(0.9.1.2)

导入数据库驱动:mysqlmysql驱动)(5.1.18),oracle驱动

导入缓存:ehcache(1.5.0)

导入servlet-api2.5jsp-api2.1、(注意scope的范围是provided)、jstl1.2

导入junit:(注意scope的范围test)(4.9)

 

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

  <modelVersion>4.0.0</modelVersion>

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

  <artifactId>itcastcrmMaven</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <packaging>war</packaging>

  <name>itcastcrmMaven</name>

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

  

  <properties>

   <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>

  

  <dependencies>

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-core</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-aspects</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-web</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-test</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-orm</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

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

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

   </dependency>

 

   <dependency>

   <groupId>org.hibernate</groupId>

   <artifactId>hibernate-core</artifactId>

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

   </dependency>

 

   <dependency>

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

   <artifactId>struts2-core</artifactId>

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

   </dependency>

 

   <dependency>

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

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

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

   </dependency>

 

   <dependency>

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

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

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

   </dependency>

 

   <dependency>

   <groupId>org.slf4j</groupId>

   <artifactId>slf4j-log4j12</artifactId>

   <version>1.7.2</version>

   </dependency>

 

   <dependency>

   <groupId>log4j</groupId>

   <artifactId>log4j</artifactId>

   <version>1.2.15</version>

   </dependency>

 

   <dependency>

   <groupId>c3p0</groupId>

   <artifactId>c3p0</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>mysql</groupId>

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

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

   </dependency>

 

   <dependency>

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

   <artifactId>ehcache</artifactId>

   <version>1.5.0</version>

   </dependency>

 

   <dependency>

   <groupId>javax.servlet</groupId>

   <artifactId>servlet-api</artifactId>

   <version>2.5</version>

        <scope>provided</scope>

   </dependency>

 

   <dependency>

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

   <artifactId>jsp-api</artifactId>

   <version>2.1</version>

        <scope>provided</scope>

   </dependency>

 

   <dependency>

   <groupId>javax.servlet</groupId>

   <artifactId>jstl</artifactId>

   <version>1.2</version>

   </dependency>

 

   <dependency>

   <groupId>junit</groupId>

   <artifactId>junit</artifactId>

   <version>4.9</version>

        <scope>test</scope>

   </dependency>

  </dependencies>

 

第三步: 复制项目代码

java代码 --- src/main/java

 

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

注意:hbm属于配置文件 ,放入src/main/resources 

 

 

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

WEB-INF --- WEB-INF (但不要复制 libclasses

 

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

@Override

public TgetModel() {

return c;

}

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

 

方案一:

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

 

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

  <build>

   <plugins>

   <plugin>

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

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

   <version>2.3.2</version>

   <configuration>

  <target>1.7</target>

  <source>1.7</source>

  </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. 直接依赖

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

 

生成的代码:

   <dependency>

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

   <artifactId>struts2-core</artifactId>

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

   <exclusions>

  <exclusion>

  <artifactId>javassist</artifactId>

  <groupId>javassist</groupId>

  </exclusion>

  </exclusions>

   </dependency>

问题解决。

6.  多模块和继承重点

 

多模块解决: maven项目分解,为了统一管理和开发方便;

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

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

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

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

 

6.1. 概念

多模块

 

 

n  继承

 

6.2. 构建示例和项目分解

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

目标:构建一个父工程,两个子工程,让父工程管理子工程。

 

 

第一步:建立父工程(这里Packagingpom

 

提示:打包方式必须为pom

 

生成的工程:

 

查看crm_parentpom.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>cn.itcast.maven</groupId>

  <artifactId>crm_parent</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <packaging>pom</packaging>

  <name>crm_parent</name>

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

</project> 

提示:父工程的作用:就是用来操作子工程的,用来被继承的子工程可以使用

 

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

导入配置文件

<properties>

   <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>

  

  <dependencies>

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-core</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-aspects</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-web</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-test</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-orm</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>org.springframework</groupId>

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

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

   </dependency>

 

   <dependency>

   <groupId>org.hibernate</groupId>

   <artifactId>hibernate-core</artifactId>

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

   </dependency>

 

   <dependency>

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

   <artifactId>struts2-core</artifactId>

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

   <exclusions>

   <exclusion>

   <artifactId>javassist</artifactId>

   <groupId>javassist</groupId>

   </exclusion>

   </exclusions>

   </dependency>

 

 

   <dependency>

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

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

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

   </dependency>

 

   <dependency>

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

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

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

   </dependency>

 

   <dependency>

   <groupId>org.slf4j</groupId>

   <artifactId>slf4j-log4j12</artifactId>

   <version>1.7.2</version>

   </dependency>

 

   <dependency>

   <groupId>log4j</groupId>

   <artifactId>log4j</artifactId>

   <version>1.2.15</version>

   </dependency>

 

   <dependency>

   <groupId>c3p0</groupId>

   <artifactId>c3p0</artifactId>

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

   </dependency>

 

   <dependency>

   <groupId>mysql</groupId>

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

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

   </dependency>

 

 

   <dependency>

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

   <artifactId>ehcache</artifactId>

   <version>1.5.0</version>

   </dependency>

 

   <dependency>

   <groupId>javax.servlet</groupId>

   <artifactId>servlet-api</artifactId>

   <version>2.5</version>

   <scope>provided</scope>

   </dependency>

 

 

   <dependency>

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

   <artifactId>jsp-api</artifactId>

   <version>2.1</version>

   <scope>provided</scope>

   </dependency>

 

 

   <dependency>

   <groupId>javax.servlet</groupId>

   <artifactId>jstl</artifactId>

   <version>1.2</version>

   </dependency>

 

   <dependency>

   <groupId>junit</groupId>

   <artifactId>junit</artifactId>

   <version>4.9</version>

   <scope>test</scope>

   </dependency>

  </dependencies>

  

  

  <build>

   <plugins>

   <plugin>

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

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

   <version>2.3.2</version>

   <configuration>

   <target>1.7</target>

   <source>1.7</source>

   </configuration>

   </plugin>

   </plugins>

  </build>

 

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

 

选择Maven Module

 

创建工程,跳跃骨架,模块名称为crm_entity(表示实体)

 

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

 

根据项目的包结构,可以抽取以下项目:

 

同理,依次创建

crm_utils:存放工具类(jar工程)

crm_exceptions:存放异常(jar工程)

crm_dao:存放DAOjar工程)

crm_service:存放Servicejar工程)

crm_action:存放Actionwar工程)

 

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

分析:

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

Dao依赖于crm_entity

Service依赖于crm_dao

Action依赖于crm_service

1Dao依赖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文件。

<!-- 导入其他applicationContext文件使用通配符*maven的多模块开发中不支持,需要分开-->

<!-- <import resource="classpath:applicationContext-*.xml"/> -->

<import resource="classpath:applicationContext-action.xml"/>

<import resource="classpath:applicationContext-biz.xml"/>

<import resource="classpath:applicationContext-dao.xml"/>

第六步:运行

方案一:对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文件的内容。

  <modules>

   <module>crm_entity</module>

   <module>crm_utils</module>

   <module>crm_exceptions</module>

   <module>crm_dao</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,这个的cleanClean生命周期的一个阶段。有Clean生命周期,也有clean阶段。Clean生命周期一共包含了三个阶段:

 

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

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

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

mvn clean 中的clean就是上面的clean,在一个生命周期中,运行某个阶段的时候,它之前的所有阶段都会被运行,也就是说,mvn clean 等同于 mvn pre-clean clean,如果我们运行mvn post-clean,那么pre-cleanclean都会被运行。这是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>

   <plugins>

   <plugin>

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

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

   <version>2.3.2</version>

   <configuration>

   <source>1.7</source>

   <target>1.7</target>

   </configuration>

   </plugin>

   </plugins>

</build>

 

命令:mvn compile

作用:统一jdk的版本

 

8.2. tomcat-maven-plugin编译插件

  <build>

    <finalName>mavenDemo3</finalName>

    <plugins>

     <plugin>

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

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

     <version>1.1</version>

     <configuration>

     <port>8088</port>

     </configuration>

     </plugin>

    </plugins>

  </build>

 

命令:tomcat:run

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

 

8.3. maven-surefire-plugin测试插件

主要功能:

1、输出日志和报告

2、解决中文乱码问题

 

可解决两个问题:

1.中文乱码问题

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

<build>

   <plugins>

   <plugin>

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

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

<version>2.7.1</version>

<configuration>

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

</configuration>

</plugin>

   </plugins>

  </build>

修改mavenDemo1的代码:

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

  <dependencies>

    <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>4.9</version>

      <scope>test</scope>

    </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>

   <plugins>

   <plugin>

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

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

   <version>2.7.1</version>

   <configuration>

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

   </configuration>

   </plugin>

  

   </plugins>

  </build>

问题解决

 

2.跳过测试

 

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

 

 

 

测试失败仍然执行。

<testFailureIgnore>true</testFailureIgnore>

 

8.4. tomcat-maven-plugin使用 tomcat

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

 

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

如何修改端口?

添加插件:

 

修改mavenDemo3的项目进行演示。

<build>

    <finalName>mavenDemo3</finalName>

    <plugins>

     <plugin>

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

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

     <version>1.1</version>

     <configuration>

     <port>8088</port>

     </configuration>

     </plugin>

    

    </plugins>

  </build>

执行mvn的命令:tomcat:run

 

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

 

使用utf-8

 

 

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

【第一步】配置tomcat7

         <plugin>

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

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

     <version>2.1</version>

     <configuration>

     <charset>utf-8</charset>

     <port>8088</port>

     </configuration>

     </plugin>

【第二步】运行

 

所以默认的端口还是8080

 

需要使用tomcat7:run才可以

 

 

 

查看控制台:

 

 

 

 

 

小结:

1. 理解maven的思想,以及几个相关的概念

2. 应用上的一些概念

1) 仓库(本地和远程(中央和私服))

2) Pom.xml各种配置

3) 依赖导入jar,排除jar、解决传递性依赖(直接依赖、锁定版本)、同一版本控制。

 

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

 

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

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

 

 

原创粉丝点击