JavaWeb开发之Maven
2018-04-29 本文已影响149人
平安喜乐698
目录
1. 框架简介
Maven:跨平台的项目管理工具,可以
项目构建
【清理项目】→【编译项目】→【测试项目】→【生成测试报告】→【打包项目】→【部署项目】
依赖管理
自动下载项目所需要的jar包，管理依赖关系
- 配置maven环境（MAC）
http://maven.apache.org/download.cgi 下载Maven
Maven文件夹（放到Lib下）
bin：含有mvn运行的脚本
boot：含有plexus-classworlds类加载器框架
conf：含有settings.xml配置文件
lib：含有Maven运行时所需要的java类库
LICENSE.txt, NOTICE.txt, README.txt针对Maven版本，第三方软件等简要介绍
终端
vim ~/.bash_profile 修改环境变量
export MAVEN_PATH=/Library/maven3.5.3
export PATH=$PATH:$MAVEN_PATH/bin
source ~/.bash_profile 保存立刻生效
mvn -v 查看是否安装成功
Maven仓库：用来统一存储所有Maven共享构建的位置
每个构建在仓库中唯一存储路径（根据Maven坐标定义）大致为：groupId/artifactId/version/artifactId-version.packaging
仓库分类
本地仓库（从Maven中心仓库下载到本地的jar包的）
每个用户只有一个本地仓库，默认是在~/.m2/repository/，~代表的是用户目录
修改位置
maven文件夹|conf文件夹|settings.xml文件的<setting>下+ 修改jar包下载位置
<localRepository>/Users/cx/Workspaces/repository</localRepository>
远程仓库
1、中央仓库：Maven默认的远程仓库，URL地址：http://search.maven.org/
2、私服：是一种特殊的远程仓库，它是架设在局域网内的仓库
Maven坐标
在平面几何中，坐标（x,y）可以标识平面中唯一的一点。在开发中，坐标可以唯一确定一个项目
Maven坐标（便于管理使用）主要组成
groupId：组织标识（包名）
artifactId：项目名
version：项目的当前版本
packaging：项目的打包方式，最为常见的jar和war两种
- 生命周期
Maven生命周期就是为了对所有的构建过程(项目清理，初始化，编译，打包，测试，部署)进行抽象和统一.
Maven有三套相互独立(可组合使用)的生命周期
1. Clean Lifecycle 在构建之前进行清理工作。
2. Default Lifecycle 构建的核心部分(编译，测试，打包，部署等等)。
3. Site Lifecycle 生成项目报告，站点，发布站点。
Clean生命周期共三个阶段：
1. pre-clean 执行一些需要在clean之前完成的工作
2. clean 移除所有上一次构建生成的文件
3. post-clean 执行一些需要在clean之后立刻完成的工作
mvn clean"中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，"mvn clean"等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。
Site生命周期共三个阶段：
1. site 生成项目的站点文档
2. post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
3. site-deploy 将生成的站点文档部署到特定的服务器上
Default生命周期（最重要的一个，做绝大部分工作）常用的阶段：
validate
generate-sources
process-sources
generate-resources
process-resources 复制并处理资源文件，至目标目录，准备打包。
compile 编译项目的源代码。
process-classes
generate-test-sources
process-test-sources
generate-test-resources
process-test-resources 复制并处理资源文件，至目标测试目录。
test-compile 编译测试源代码。
process-test-classes
test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
prepare-package
package 接受编译好的代码，打包成可发布的格式，如 JAR 。
pre-integration-test
integration-test
post-integration-test
verify
install 将包安装至本地仓库，以让其它项目依赖。
deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
运行任何一个阶段的时候，它前面的所有阶段都会被运行，这也就是为什么我们运行mvn install 的时候，代码会被编译，测试，打包。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。
- 基础
项目目录（约定好的）
MavenProjectRoot(项目根目录)
|----src
| |----main
| | |----java ——存放项目的.java文件
| | |----resources ——存放项目资源文件，如spring, hibernate配置文件
| |----test
| | |----java ——存放所有测试.java文件，如JUnit测试类
| | |----resources ——存放项目资源文件，如spring, hibernate配置文件
|----target ——项目输出位置（编译自动生成）
|----pom.xml ----用于标识该项目是一个Maven项目
pom.xml
pom(project object model).xml
包含了项目构建的信息，包括项目的信息、项目的依赖等。
继承:子模块的pom.xml继承于父模块的pom.xml
例：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.mycompany.app</groupId>
<artifactId>my-WebApp</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>my-WebApp Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>my-WebApp</finalName>
</build>
</project>
说明：
<project> pom顶级节点（写法固定）
<modelVersion> pom版本（对Maven2和3只能是4.0.0）
<groupId> 创建项目的组织标识符（一般是域名倒写）
<artifactId> 项目名（组织下的唯一标识）
<version> 项目版本（SNAPSHOT表示是快照版本）
<packaging> 打包的方式（有jar、war、ear等）
<name> 项目名称
<url> 项目地址
<properties> 属性配置
<dependencies> 构建项目所依赖的jar
由groupId、artifactId和version唯一的确定了一个项目。
依赖配置（使用jar包）
pom.xml中+
<dependencies>
<!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!--项目要使用到Hello.jar包，所以在这里添加Hello.jar包的依赖-->
<dependency>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
</dependencies>
使用
import com.sst.cx.maven.Hello;
scope（依赖范围）
用来控制依赖和编译，测试，运行的classpath的关系.
主要的是三种依赖关系如下：
1.compile： 默认编译依赖范围。对于编译，测试，运行三种classpath都有效
2.test：测试依赖范围。只对于测试classpath有效
3.provided：已提供依赖范围。对于编译，测试的classpath都有效，但对于运行无效。因为由容器已经提供，例如servlet-api
4.runtime:运行时提供。例如:jdbc驱动
传递性依赖
MakeFriends.jar直接依赖于HelloFriends.jar，而HelloFriends.jar又直接依赖于Hello.jar，那么MakeFriends.jar也依赖于Hello.jar，这就是传递性依赖，只不过这种依赖是间接依赖
Maven插件
1. Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。
2. 每个插件都能实现多个功能，每个功能就是一个插件目标。
3. Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务，例如compile就是插件maven-compiler-plugin的一个插件目标。
聚合
用于构建多个项目
<modules>
<module>../Hello</module>
<module>../HelloFriend</module>
<module>../MakeFriends</module>
</modules>
继承
继承为了消除重复，我们把很多相同的配置提取出来，例如：grouptId，version等
<parent>
<groupId>com.sst.cx.maven</groupId>
<artifactId>ParentProject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<relativePath>../ParentProject/pom.xml</relativePath>
</parent>
自动生成项目
mvn archetype:create或者mvn archetype:generate 固定写法
-DgroupId 组织标识（包名）
-DartifactId 项目名称
-DarchetypeArtifactId 指定ArchetypeId，maven-archetype-quickstart，创建一个Java Project；maven-archetype-webapp，创建一个Web Project
-DinteractiveMode 是否使用交互模式
DarchetypeArtifactId是可用的mvn项目骨架，目前可以使用的骨架有：
* maven-archetype-archetype
* maven-archetype-j2ee-simple
* maven-archetype-mojo
* maven-archetype-portlet
* maven-archetype-profiles (currently under development)
* maven-archetype-quickstart （Java 项目）
* maven-archetype-simple (currently under development)
* maven-archetype-site
* maven-archetype-site-simple
* maven-archetype-webapp （JavaWeb 项目）
- 手动创建Maven项目
新建文件夹MavenTest(结构同上,约定)
新建pom.xml（项目根目录下）
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.sst.cx.maven</groupId>
<artifactId>MavenTest</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>MavenTest</name>
<!--添加依赖的jar包-->
<dependencies>
<!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
</dependency>
</dependencies>
</project>
新建com文件夹|sst文件夹|cx文件夹|Hello.java
package com.sst.cx.maven;
public class Hello {
public String sayHello(String name){
return "Hello "+name+"!";
}
}
终端
进入项目根目录
mvn compile 编译
编译成功后根目录下自动出现
target文件夹
classes文件夹（编译成功后生成的.class）
其他终端命令
mvn clean 清除编译
mvn test 测试项目 （target下多了一个test-classes文件夹，classes文件夹下多了一个类Test.class）
mvn package 打包（target下多了一个类名-0.0.1-SNAPSHOT.jar）
mvn install （最常用）【清理】→【编译】→【测试】→【打包】-> 【部署项目到仓库】
组合命令
mvn clean compile
mvn clean test
mvn clean package
mvn clean install
5 快速生成Java项目
生成
方式一
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
方式二(有点问题)
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
mvn clean compile 编译
mvn clean test 测试
mvn clean package 打包（会先编译测试）
mvn clean install 安装（会先编译测试打包）
运行jar包
java -cp target\myapp-1.0-SNAPSHOT.jar com.mycompany.app.App
6 快速生成JavaWeb项目
生成
方式一
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-WebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
方式二
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=myWebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
创建好的JavaWeb项目中目前只有src/main/resources目录，因此还需要手动添加src/main/java、src/test/java、src/test/resources
打包发布
mvn package
Target目录下生成war包，放在Tomcat/webapps下即可访问
或者
或者
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.mycompany.app</groupId>
<artifactId>myWebApp</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>myWebApp Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>myWebApp</finalName>
<pluginManagement>
<!--配置Jetty-->
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
mvn jetty:run
- 示例（继承与聚合）
聚合用来构建项目，继承用来消除重复
例：
父项目pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<name>Parent</name>
<url>http://maven.apache.org</url>
<!-- 对Hello、Hello2 这2个项目进行聚合 -->
<modules>
<module>../Hello</module>
<module>../Hello2</module>
</modules>
<!-- 定义属性 -->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<junit.version>4.9</junit.version>
<maven.version>0.0.1-SNAPSHOT</maven.version>
</properties>
<!-- 用dependencyManagement进行jar包依赖管理 -->
<dependencyManagement>
<!-- 配置jar包依赖 -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<!-- 访问junit.version属性 -->
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Hello</artifactId>
<!-- 访问maven.version属性 -->
<version>${maven.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Hello2</artifactId>
<!-- 访问maven.version属性 -->
<version>${maven.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
Hello项目pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>Hello</artifactId>
<!-- 继承Parent项目中的pom.xml配置 -->
<parent>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 使用相对路径 -->
<relativePath>../Parent/pom.xml</relativePath>
</parent>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
</dependencies>
</project>
Hello2项目pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>Hello2</artifactId>
<name>Hello2</name>
<!-- 继承Parent项目中的pom.xml配置 -->
<parent>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<relativePath>../Parent/pom.xml</relativePath>
</parent>
<dependencies>
<dependency>
<!-- Parent项目的pom.xml文件配置中已经指明了要使用的Junit的版本号，因此在这里添加junit的依赖时，
可以不指明<version></version>和<scope>test</scope>，会直接从Parent项目的pom.xml继承 -->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<!-- Hello2项目中使用到了Hello项目中的类，因此需要添加对Hello.jar的依赖
Hello.jar的<version>和<scope>也已经在Parent项目的pom.xml文件配置中已经指明了，因此这里也可以省略不写了
-->
<dependency>
<groupId>com.sst.cx.maven</groupId>
<artifactId>Hello</artifactId>
</dependency>
</dependencies>
</project>
MyEclipse
选中Parent项目的pom.xml文件→【Run As】→【Maven install】
Maven就会一次性同时构建Parent、Hello、Hello2这3个项目
- MyEclipse
导入已有项目
右键|Import|Import|Existing Maven Projects|找导入Maven项目
1
2
3
新建Maven项目
右键|New|Project|Maven Project
勾选Create a simple project则不能选择archetype
1
2
3
4
4-2
运行Maven项目
选中pom.xml | 右键 | Run As
或者
选中项目 | 右键 | Run As
选中项目 | 右键 | Run As | build（第3个）可以执行组合命令
1
2
部署项目
pom.xml第一行报错
Help | Sites |
name=mavenAch
url=http://repo1.maven.org/maven2/.m2e/connectors/m2eclipse-mavenarchiver/0.17.2/N/LATEST/
使用自己安装的Maven
设置 | MyEclipse | Installations | Add | 找到下载好的Maven路径
使用自己安装的Maven
更换JDK
设置 | java | Installation JREs
必须1.6以上
更换JDK
修改User Settings
将maven文件夹下 | conf文件夹下 | settings.xml 复制到本地仓库下
设置 | MyEclipse | Maven | UserSettings 选择仓库下的settings.xml
修改User Settings
- 搭建nexus Maven私服
有些公司不提供外网给项目组人员，不能使用maven访问远程的仓库地址,解决：
在局域网里找一台有外网权限的电脑，搭建nexus私服。开发人员通过这台电脑访问maven的远程仓库。
1.下载nexus（放到Lib下）
https://www.sonatype.com/download-nexus-repository-trial
nexus文件夹含2个子文件夹
nexus-3.10.0-04文件夹包含了nexus的运行环境和应用程序
sonatype-work文件夹包含了自己的配置和存储构件的地方
nexus-3.10.0-04/conf/nexus.properties中可以修改端口信息以及工作区的路径
2.启动
/Library/nexus3.1/nexus-3.10.0-04/bin/nexus start
浏览器输入http://127.0.0.1:8081检验是否启动成功
修改环境变量
vi ~/.bash_profile
export NEXUS_PATH=/Library/nexus3.1/nexus-3.10.0-04/bin
export PATH=$PATH:$MAVEN_PATH/bin:$NEXUS_PATH
source ~/.bash_profile
直接nexus start启动
3.
登陆 默认账号admin，密码admin123
nexus默认是关闭远程索引下载
- 实际开发（多模块（多层））
进行分层开发便于维护，一般会分为
domain（域模型层）
dao（数据库访问层）
service（业务逻辑层）
web（表现层）
项目结构
system-parent
|----pom.xml
|----system-domain
|----pom.xml
|----system-dao
|----pom.xml
|----system-service
|----pom.xml
|----system-web
|----pom.xml
1. 创建system-parent
cd Desktop
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-parent -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
桌面上出现system-parent文件夹
删除其下src文件夹
pom.xml中将<packaging>jar</packaging>修改为<packaging>pom</packaging>，pom表示它是一个被继承的模块
2. 创建system-domain
cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-domain -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
在system-parent目录中的pom.xml文件自动添加了
<modules>
<module>system-domain</module>
</modules>
修改system-domain目录中的pom.xml文件
把(注意不是parent下的)groupId和version、dependencies去掉，(注意不是加在parent下)加上<packaging>jar</packaging>
3. 创建system-dao
cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-dao -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
在system-parent目录中的pom.xml文件自动添加了
<modules>
<module>system-dao</module>
</modules>
修改system-dao目录中的pom.xml文件
把(注意不是parent下的)groupId和version去掉，(注意不是加在parent下)加上<packaging>jar</packaging>，添加
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!--system-dao需要使用到system-domain中的类，所以需要添加对system-domain模块的依赖-->
<dependency>
<groupId>com.sst.cx</groupId>
<artifactId>system-domain</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
4. 创建system-service
cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-service -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
在system-parent目录中的pom.xml文件自动添加了
<modules>
<module>system-service </module>
</modules>
修改system-service目录中的pom.xml文件
把(注意不是parent下的)groupId和version去掉，(注意不是加在parent下)加上<packaging>jar</packaging>，添加
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!--system-dao需要使用到system-domain中的类，所以需要添加对system-domain模块的依赖-->
<dependency>
<groupId>com.sst.cx</groupId>
<artifactId>system-dao</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
5. 创建system-web
cd system-parent
mvn archetype:generate -DgroupId=com.sst.cx -DartifactId=system-web -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
在system-parent目录中的pom.xml文件自动添加了
<modules>
<module>system-web</module>
</modules>
修改system-web目录中的pom.xml文件
把(注意不是parent下的)groupId和version去掉，(注意不是加在parent下)加上<packaging>war</packaging>，添加
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!--system-dao需要使用到system-domain中的类，所以需要添加对system-domain模块的依赖-->
<dependency>
<groupId>com.sst.cx</groupId>
<artifactId>system-service</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
<build>
<finalName>system-web</finalName>
<plugins>
<!--配置Jetty插件-->
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
</plugin>
</plugins>
</build>
6. 编译运行项目
cd system-parent
mvn clean install
在system-web目录下多出了target目录，里面有了system-web.war
cd system-web/
mvn jetty:run
浏览器输入http://localhost:8080/system-web/出现Hello World！即成功
7. 导入MyEclipse
选择system-parent文件夹
