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/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">
<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 将包安装至本地仓库,以让其它项目依赖。 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的端口号
<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项目管理,依赖于两大类仓库(三种仓库):
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:版本号
例如:
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
引入依赖的方法:在pom.xml中 通过配置<dependencies> 来引入依赖。
引入依赖的思路原理:
坐标决定项目在仓库中唯一位置,我们就可以通过坐标来导入依赖项目,即可以理解为:可以通过坐标导入jar包。
【示例】 在项目导入struts2和spring的需要jar包。
思考:要导入jar,首先要得到其坐标,那么怎么得到坐标呢?
两种方式:
方法一:使用网站搜索
方法二:适应maven插件的搜索功能,Maven Repository视图
方法一:(如果本地仓库没有足够的jar,就会报错,所以为了防止错误发生,电脑要联网)
在网站搜索项目,获取对应坐标。
比如搜索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,但会导入这么多?
原因是:这个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
2
提示:可以通过有效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包 (不推荐 )
例如:
<!-- 导入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-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>中使用${}
<!--定义本地属性-->
<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文件)
导入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文件的内容
<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 (但不要复制 lib、classes)
第四步: 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 多模块
n 继承
6.2. 构建示例和项目分解
【示例】使用eclipse工具进行父子工程构建
目标:构建一个父工程,两个子工程,让父工程管理子工程。
第一步:建立父工程(这里Packaging为pom)
提示:打包方式必须为pom
生成的工程:
查看crm_parent的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</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(表示实体)
这里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文件。
<!-- 导入其他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,这个的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> <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端口。