Maven学习笔记

2019-01-11 技术收录开发工具 0 评论字数统计:3279字阅读时长:7分

maven官网

maven的作用

管理Jar
- 增加第三方Jar (commons-fileupload. jarcommons- io. jar)
- jar包之间的依赖关系(commons-fileupload. jar自动关联下载所有依赖的Jar,并且不会冲突)
将项目拆分成若干个模块

Maven概念:

是一个基于Java平台的自动化构建工具 make- ant- -maven- gradle

清理:删除编译的结果，为重新编译做准备。

编译: java->class

测试: 针对于项目中的关键点进行测试，亦可用项目中的测试代码去测试开发代码;

报告:将测试的结果进行显示

打包: 将项目中包含的多个文件压缩成一个文件，用于安装或部署。（Java项目–jar web项目–war）

安装:将打成的包放到本地仓库。

部署:将打成的包放到服务器上准备运行。将java js jsp等文件进行筛选，变成直接进行的项目

-Eclipse中部署的web项目可以运行

-将Eclipse中的项目，复制到tomcat/webapps中则不能运行

-项目可以在webappas中直接运行

Eclipse中的项目，在部署时会生成一个对应的部署项目(在wtpwebapps中)，

区别在于:部署项目没有源码文件src（java文件），只有编译后的class文件和jsp文件

因为二者目录结构不一致因此tomcat无法直接运行eclipse中赋值过来的项目（因为要在tomcat中运行一个项目必须严格遵循tomcat的目录）

要将eclipse项目部署到tomcat中只需要右键项目导出war包放到webapps中 tomcat会直接进行解压不需要自己解压

startup.bat 和shutdown.bat是运行tomca和结束tomcat的快捷键

自动化构建工具maven:将原材料(java、 js、css、html、图片) ->产品(可发布项目)

编译-打包-部署-测试-->自动构建

部署maven

检查配置JAVA-HOME

配置

MAVEN_HOME:D:\RJ\tomcat\jar\apache-maven-3.6.2-bin\apache-maven-3.6.2

配置path
```
%MAVEN_HOME%\bin
```
验证
```
cmd mvn -v
```

本地仓库

maven目录/conf/settings.xml

默认本地仓库：

    <!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->

user.home：C:\Users

修改本地仓库

<localRepository>D:/RJ/tomcat/mvnrep</localRepository>

使用maven

约定优于配置

硬编码方式: job. setPath(" d: \\abc") ;

配置方式:

    job
    conf. xml
    <path>d:\\abc</path>

约定:使用默认值d:\\abc
    job

maven约定的目录结构

main主函数执行项目

test测试项目

项目
    -src
        -main       :程序代码
            -java   ：java代码
            -resource   ：资源代码、配置代码
        -test           ：测试代码
            --java
            -resource
        target:
    pom.xml             :项目对象模型  与src同级

<groupId>域名翻转.大项目名</ groupId>
<groupId>org.lanqiao.maven</ groupId>

<artifactId>子模块名</artifactId>
<artifactId>HelloWorld</artifactId>

<version>版本号</version>
<version>0.0.1-SNAPSHOT</version>

依赖:

commons- fileupload. jar --> commons-io. jar

A中的某些类需要使用B中的某些类，则称为A依赖于B

在maven项目中，如果要使用一个当时存在的Jar或模块，则可以通过依赖实现(去本地仓库、中央仓库去寻找)

执行mvn: 必须在pom. xml所在目录中执行

利用cmd进入目录或者直接在地址框打cmd

maven常见命令：

第一次时因为需要下载执行该命令的基础环境，因此会从中央仓库中下载该环境到本地仓库所以会比较慢

mvn compile:只编译main目录下的文件

mvn test：执行test目录下的文件

mvn package    打包命令 jar/war

mvn install  将开发的模块放入本地仓库供其他项目使用（放入的位置通过gav决定）

mvn clean       删除target目录（删除编译后的文件目录）

运行mvn命令必须在pom.xml目录下

仓库：依次向下寻找资源

本地仓库
私服nexus
中央仓库
中央仓库镜像
远程仓库

依赖:

A jar->Bjar

<dependency>
    < groupId> junit</ groupId>
    <artifactId> junit</artifactId>
    <version>4.0</version>
    < scope> test</ scope>  依赖的范围
</dependency>

依赖的范围、依赖的有效性：

compile(默认)   test  provided

依赖排除在依赖里面添加

<exclusions>
    <exclusion>
        <groupId>org. springframework</ groupId>
        <artifactId>spring- beans</artifactId>
    </exclusion>
    <exclusion>
        <groupId>org. springframework</ groupId>
        <artifactId>spring- beans</artifactId>
    </exclusion>
    <exclusion>
        <groupId>org. springframework</ groupId>
        <artifactId>spring- beans</artifactId>
    </exclusion>
</exclusions>

依赖的传递性

A. jar-B. jar->C. jar

要使A. jar ->C. jar:当且仅当B. jar依赖于C. jar的范围是compile

依赖原则

最短路径优先
```
a->b->c.2

a->c.1
```
那么a会引入c.1
路径长度相同
- 在同一个pom.xml文件中有2个相同的依赖:后面声明的依赖会覆盖前面声明的依赖（严禁在同一个pom声明两个版本不同的依赖）
- 如果是不同的pom. xml中有2个相同的依赖:则先声明的依赖，会覆盖后声明的依赖（引入的依赖的顺序决定）
( JDK只能够识别source folder中的源码) 普通的folder需要右键bilid path
```
			compile			  test			     provided
编译			V				x					V
测试			V				v					v
部署(运行)	    V				x					x
```

Maven在编译、测试、运行项目时，各自使用-套 classpath

在eclipse创建maven项目

配置本地仓库

window preferences 搜索maven

installation配置maven版本
usersetting配置本地仓库  打开pom.xml文件

在eclipse中配置完pom.xml后需要

右键maven项目 maven update project

执行右键pom.xml run as maven build...

maven build执行上一次

package:打包命令会执行以下

resources
compile
test
package

maven生命周期

生命周期和构建的关系

a   b   c   d   e

执行c命令会将之前的命令全部执行一遍

生命周期包含的三个阶段：

clean lifecycle :清理
            pre-clean    clean      post-clearn

default lifecycle :默认   最常用

site lifecycle: 站点  
            pre-site    site    post-site site-deploy

下载jar包直接搜…mvn 复制下面的maven里面的dependency

测试

 package org.lanqiao . maven;
 import org. junit. Test;
 public class HelloWorldTest{
	@Test//导包
	public void testHello( ){
		HelloWorld hello = new HelloWorld( );
		String result = hello. sayHello("zs");
		assertEquals("Hello zs" ,result); //断言
	}
 }
依赖
< dependency>
	<groupId>junit</ groupId>
	<artifactId> junit</ artifactId>
	<version>4.0< /version>
	<scope>test</ scope>
</ dependency>

统一项目的jdk:

build path:删除旧版本，增加新版本

右键项目-属性-Project Factors -java version 改版本 (之前存在要改的版本)

通过maven统一jdk版本:

<profiles>
	<profile>
		<id>jdk-18</id>
		<activation>
			<activeByDefault>true</activeByDefault>
			<jdk>1.8</jdk>
		</activation>
		<properties>
			<maven.compiler.source>1.8</maven.compiler.source>
			<maven.compiler.target>1.8</maven.compiler.target>
			<maven.compiler. compilerVersion>1.8</maven. compiler.compilerVersion>
		</ properties>
	</profile>
</profiles>|

统一jar的版本

//统一jar的版本
<properties>
	<project.build.sourceEncoding>UTF-8</ project.build.sourceEncoding>
	<!--统一版本-->
	<lanqiao.World.Jjunit.version>4.0k/lanqiao.World.junit.version>变量值
</ properties>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>$ {lanqiao.World.junit. version}</version>    引用变量
	<scope>test</scope>
</dependency>

继承：

a继承b 则a继承b的所有依赖

建立父工程：父工程用pom

在父工程的pom.xml中编写依赖

<!--父工程，父工程的依赖需要写在-->
<dependencyManagement> 

	<dependencies>
		<dependency></ dependency>
	</ dependencies>

</dependencyManagement>

子类

<!-- 给当前工程继承一个父工程 

1加入父工程坐标gav 

2当前工程的Pom.xml到父工程的Pom.xml之间的相对路径-->

<parent>
<!-- 1加入父工程坐标gav -->
	< groupId>org.lanqiao . maven</ groupId>
	<artifactId>B</artifactId>
	<version>0.0.1- SNAPSHOT</version>
<!-- 2当前工程的Pom. xml到父工程的Pom. xml之间的相对路径-->
<relativePath>. . /B/ pom. xml</relativePath>
</parent>
		子类的g和v如果与父类的gv相同的话可以省略

在子类中需要声明：使用哪些父类的依赖

<dependency>
<! --声明:需要使用到父类的junit (只需要ga)-->
	<groupId>junit</ groupId>
	<artifactId>junit</artifactId>
</dependency>

聚合

Maven项目能够识别的:

自身包含、本地仓库中的

Maven2依赖于Maven1, 则在执行时:必须先将Maven1加入到本地仓库(install), 之后才能执行Maven2 以上前置工程的install操作，可以交由“聚合”一次性搞定。。。

聚合的使用：

在一个总工程中使用(聚合的配置只能配置在打包方式pom方式的Maven工程中)

<!--配置聚合，避免前置工程的install操作-->
<modules>
	<!--项目的根路径   可以不用设置顺序-->
	<module>. . /Maven1< /module>
	<module>. . /Maven2< , module>
</ modules>

注意: clean命令是删除target目录，并不是清理install存放入的本地仓库

配置完聚合之后，以后只要操作总工程，则会自动操作改聚合中配置过的工程

清理本地仓库需要手动进入仓库进行删除

聚合:

Maven将一一个大 工程拆分成若干个子工程(子模块)

聚合可以将拆分的多个子工程合起来

继承:

父->子工程，可以通过父工程

统一管理依赖的版本

部署web工程

需要在webapp下建立META-INF文件夹和web.xml文件

<build>
	<fina lName >MavenWebProject</finalName>
	<plugins>
		<plugin>
			<!--启动tomcat-->
			<groupId>org. codehaus .cargok/ groupId>
			<artifactId>cargo-maven2-plugin</artifactId>
			<version>1.4.9</version>
			
			<!--配置tomcat-->
			<configuration>
				< container>
				< containerId>tomcat8-5-30</ containerId>
				<home>D: \study\apache-tomcat-8.5.30</home>
				</container>
				< configuration>
				<type>existing</type>
				<home>D: \study\apache-tomcat8x< /home>
				<!--默认值8080-- >
					< properties>
						<cargo.servlet .port>8888</ cargo. servlet . port>
					</ properties>
				</ configuration>
			</ configuration>
			<executions>
				<execution>
				<！--阶段-->
					<id>cargo-run</id>
					<phase>install</phase>
					<goals>
					<goal>run</goal>
					</goals>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

命令：deploy

实际开发中，开发人员将自己的项目开发完毕后打成war包交给实施人员去部署;

package

本文链接: https://mumulx.github.io/2019/01/maven%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/

License：CC BY 4.0 CN

木木就是两个木木木

愿生活不太拥挤，愿笑容不必刻意。