2020-03-14

maven

1.maven定义

1.1 maven解释

Maven是Apache旗下的一个开源项目，是一款用于管理和构建java项目的工具

官网：https://maven.apache.org/

Apache 软件基金会，成立于1999年7月，是目前世界上最大的最受欢迎的开源软件基金会，也是一个专门为支持开源项目而生的非盈利性组织。

开源项目：https://www.apache.org/index.html#projects-list

1.2 maven三大作用

1.2.1 方便的依赖管理

方便快捷的管理项目依赖的资源(jar包)，避免版本冲突问题

当使用maven进行项目依赖(jar包)管理，则很方便的可以解决这个问题。我们只需要在maven项目的pom.xml文件中，添加一段如下图所示的配置即可实现。

1.2.2 统一项目结构

1.2.3 标准的项目构建流程

maven提供了标准的、跨平台(Linux、Windows、MacOS) 的自动化项目构建方式

Maven提供了一套简单的命令来完成项目构建

2.maven安装

1.安装压缩包解压即可使用(避免中文路径)

2.配置环境(依靠于JAVA_HOME)
    2.1 添加MAVEN_HOME变量
    2.2 在path里面添加上面的变量

3.调试测试
    cmd输入 mvn -v

认识了Maven后，我们就要开始使用Maven了，那么首先我们要进行Maven的下载与安装。

2.1 下载

下载地址：https://maven.apache.org/download.cgi

2.2 安装步骤

Maven安装配置步骤：

解压安装
配置仓库
配置Maven环境变量

1、解压 apache-maven-3.6.1-bin.zip（解压即安装）

建议解压到没有中文、特殊字符的路径下。如课程中解压到 E:\develop 下。

解压缩后的目录结构如下：

bin目录：存放的是可执行命令。（mvn 命令重点关注）
conf目录：存放Maven的配置文件。（settings.xml配置文件后期需要修改）
lib目录：存放Maven依赖的jar包。（Maven也是使用java开发的，所以它也依赖其他的jar包）

2、配置本地仓库

2.1、在自己计算机上新一个目录（本地仓库，用来存储jar包）

2.2、进入到conf目录下修改settings.xml配置文件

1). 使用超级记事本软件，打开settings.xml文件，定位到53行

2). 复制标签，粘贴到注释的外面（55行）

3). 复制之前新建的用来存储jar包的路径，替换掉标签体内容

3、配置阿里云私服

由于中央仓库在国外，所以下载jar包速度可能比较慢，而阿里公司提供了一个远程仓库，里面基本也都有开源项目的jar包。

进入到conf目录下修改settings.xml配置文件：

1). 使用超级记事本软件，打开settings.xml文件，定位到160行左右

2). 在标签下为其添加子标签，内容如下：

<mirror>  
    <id>alimaven</id>  
    <name>aliyun maven</name>  
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>          
</mirror>

注意配置的位置，在 … 中间添加配置。如下图所示：

==注: 只可配置一个(另一个要注释!) ，不然两个可能发生冲突，导致jar包无法下载!!!!!!!==

4、配置环境变量

Maven环境变量的配置类似于JDK环境变量配置一样

1). 在系统变量处新建一个变量MAVEN_HOME

MAVEN_HOME环境变量的值，设置为maven的解压安装目录

2). 在Path中进行配置

PATH环境变量的值，设置为：%MAVEN_HOME%\bin

3). 打开DOS命令提示符进行验证，出现如图所示表示安装成功

mvn -v

3.仓库种类和关系

1. 本地仓库(默认本地仓库有jar包,没有就去中央仓库下载jar包)  ---自己计算机上的一个目录(用来存储jar包)
2. 远程仓库(私服)：如果没有可以从中央仓库和本地仓库上传  ---一般由公司团队搭建的私有仓库
3. 中央仓库(最大的几个T的jar包)：要使用必须有网！！  ---由Maven团队维护的全球唯一的。仓库地址：https://repo1.maven.org/maven2/

初次安装maven需要配置仓库和jar包

直接导入一个maven仓库解压

当项目中使用坐标引入对应依赖jar包后，首先会查找本地仓库中是否有对应的jar包

如果有，则在项目直接引用
如果没有，则去中央仓库中下载对应的jar包到本地仓库

如果还可以搭建远程仓库(私服)，将来jar包的查找顺序则变为：本地仓库 –> 远程仓库–> 中央仓库

4.maven标准目录结构

有规则的管理项目：

src/main/java目录     核心代码部分
src/main/resources    配置文件部分
src/test/java        测试代码部分(Junit单元测试)
src/test/resources   测试配置文件
src/main/webapps      页面资源(js css 图片等等)

5.maven常用命令

1. mvn clean      删除       target目录和内容(万一是别人项目 你先删除了编译信息在进行其他的)
2. mvn compile    进行编译   target目录下生成ServletTest的class文件
3. mvn test       进行测试   target目录下生成test测试类的文件
4. mvn package    进行打包   java工程执行package成jar包 web工程成war包
5. mvn install    进行安装   将上述的步骤整合之后将war包发布到本地仓库

6.maven生命周期

6.1 三套生命周期

Maven的生命周期就是为了对所有的构建过程进行抽象和统一。描述了一次项目构建，经历哪些阶段。

在Maven出现之前，项目构建的生命周期就已经存在，软件开发人员每天都在对项目进行清理，编译，测试及部署。虽然大家都在不停地做构建工作，但公司和公司间、项目和项目间，往往使用不同的方式做类似的工作。

Maven从大量项目和构建工具中学习和反思，然后总结了一套高度完美的，易扩展的项目构建生命周期。这个生命周期包含了项目的清理，初始化，编译，测试，打包，集成测试，验证，部署和站点生成等几乎所有构建步骤。

Maven对项目构建的生命周期划分为3套（相互独立）：

clean：清理工作。
default：核心工作。如：编译、测试、打包、安装、部署等。
site：生成报告、发布站点等。

三套生命周期又包含哪些具体的阶段呢, 我们来看下面这幅图:

我们看到这三套生命周期，里面有很多很多的阶段，这么多生命周期阶段，其实我们常用的并不多，主要关注以下几个：

• clean：移除上一次构建生成的文件

• compile：编译项目源代码

• test：使用合适的单元测试框架运行测试(junit)

• package：将编译后的文件打包，如：jar、war等

• install：安装项目到本地仓库

Maven的生命周期是抽象的，这意味着生命周期本身不做任何实际工作。在Maven的设计中，实际任务（如源代码编译）都交由插件来完成。

IDEA工具为了方便程序员使用maven生命周期，在右侧的maven工具栏中，已给出快速访问通道

生命周期的顺序是：clean –> validate –> compile –> test –> package –> verify –> install –> site –> deploy

我们需要关注的就是：clean –> compile –> test –> package –> install

说明：在同一套生命周期中，我们在执行后面的生命周期时，前面的生命周期都会执行。

思考：当运行package生命周期时，clean、compile生命周期会不会运行？

clean不会运行，compile会运行。因为compile与package属于同一套生命周期，而clean与package不属于同一套生命周期。

6.2 两种执行方式

在日常开发中，当我们要执行指定的生命周期时，有两种执行方式：

在idea工具右侧的maven工具栏中，选择对应的生命周期，双击执行
在DOS命令行中，通过maven命令执行

6.2.1 在idea中执行生命周期

选择对应的生命周期，双击执行

compile：

test：

package：

install：

clean：

6.2.2 在cmd命令行执行生命周期

1.进入到DOS命令行

7.maven概念模型图(三个部分)

项目对象模型 (Project Object Model)
依赖管理模型(Dependency)
构建生命周期/阶段(Build lifecycle & phases)

7.1 项目对象模型

以上图中紫色框起来的部分属于项目对象模型，就是将我们自己的项目抽象成一个对象模型，有自己专属的坐标，如下图所示是一个Maven项目：

坐标，就是资源(jar包)的唯一标识，通过坐标可以定位到所需资源(jar包)位置

7.2 依赖管理模型

以上图中紫色框起来的部分属于依赖管理模型，是使用坐标来描述当前项目依赖哪些第三方jar包

7.3 构建生命周期/阶段

以上图中紫色框起来的部分，就是用来完成标准化构建流程。当我们需要编译，Maven提供了一个编译插件供我们使用；当我们需要打包，Maven就提供了一个打包插件供我们使用等。

8.maven使用步骤

idea继承maven插件

1. 一定要在创建项目的地方更改

2. 第一步改配置的环境和xml文件

3. 加属性防止因为断网不能创建maven

使用骨架创建maven的java工程

1. 新建项目 –> maven –> 选择骨架的quickstart

2. 选择填写公司/项目名/版本信息

3. 确定信息

4. 然后进入之后第一次需要配置环境选择右下角第二个的自动导入的英文

5. 自己新建resources文件去右键更新为资源root

不使用骨架创建maven的java工程

1. 只是不选择骨架其他的都一样

2. 创建后直接有框架不需要更多的添加

使用骨架创建maven的web工程

1. 还是选择maven –> 选择webapp的骨架

2. 其他的和java步骤一样 –> 自己手动建立java文件并且右键改为source root

9.maven工程servlet实例

1. 更改java的配置让java也可以创建jsp文件

2. 新建servlet包 –> 新建servlet类 –> 配置路径

3. servlet报错需要导入jar包 –> pom配置相关的jar

4. 如果本地仓库没有就百度maven中央仓库 –> 找要的jar下载弹出界面拷贝里面的代码即可

5. 编写代码 –> 最右边列选择Maven –> 选择m的符号输入 tomcat:run执行tomcat

6. tomcat出现jar冲突 –> 添加scope范围让jsp和servlet的只是在写代码时候有用执行时使用tomcat插件

7. pom里面添加设置(设置成我们的tomcat7)

<build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>9999</port>
          <uriEncoding>UTF-8</uriEncoding>
        </configuration>
      </plugin>
    </plugins>
  </build>

8. pom给jdk添加配置(设置成我们的jdk1.8)

<plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-compiler-plugin</artifactId>
       <configuration>
         <target>1.8</target>
         <source>1.8</source>
         <encoding>UTF-8</encoding>
       </configuration>
     </plugin>

9. 类似于7和8的步骤可以创建模板

10.maven的jave工程取mysql数据

准备数据库

准备domain包的类去接里面的属性

public class Items {
    private Integer id;
    private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

pom里面写需要的mysql和junit的jar包

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

准备dao包和实现类impl包

dao层代码

1
2
3

public interface ItemsDao {
    public List<Items> findAll() throws Exception;
}

daoImpl层代码

public class ItemsDaoImpl implements ItemsDao {
    public List<Items> findAll() throws Exception{

        List<Items> list=new ArrayList<Items>(); //去接结果
        Connection connection=null;
        PreparedStatement pst=null;
        ResultSet rs=null;
        try{
           //1.加载驱动类
                Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
			    connection=DriverManager.getConnection("jdbc:mysql:///maven","root","njdxrjgc7777777.");
           //3.获取真正操作数据的对象
                pst=connection.prepareCall("select * from items");
           //4.执行数据库操作
                rs = pst.executeQuery();
           //5.查询结果转成java的list集合
           while(rs.next()){
               Items items=new Items();
               items.setId(rs.getInt("id"));
               items.setName(rs.getString("name"));
               list.add(items);
           }

        } catch (Exception e){
            e.printStackTrace();
        }finally{
            connection.close();
            pst.close();
            rs.close();
        }

        return list;
    }
}

准备test层代码

public class ItemsTest {
    @Test
    public void findAll() throws Exception {
        ItemsDao dao=new ItemsDaoImpl();   //面向接口编程
        List<Items> list=dao.findAll();  //得到结果给list集合
        for (Items items:list)
        { 
            System.out.println(items.getId());   //增强for循环输出结果
            System.out.println(items.getName());
        }

    }

}

11.总结

1.实现类必须要有的四要素：
    数据库驱动(看你用的oracle还是mysql)
    连接数据库的地址 url
    数据库用户名称 info
    数据库密码 password

    //1.加载驱动类
            Class.forName("com.mysql.jdbc.Driver");
     //2.获取连接对象
            connection=DriverManager.getConnection("jdbc:mysql:///maven","root","njdxrjgc7777777.");

2.相比于web开发其实就是利用maven更规格化。jar可以通过pom去直接映射的找(不用直接导入项目内)。直接利用maven的五个指令就可以操作。

12.依赖管理

12.1 依赖配置(4步)

依赖：指当前项目运行所需要的jar包。一个项目中可以引入多个依赖：

例如：在当前工程中，我们需要用到logback来记录日志，此时就可以在maven工程的pom.xml文件中，引入logback的依赖。具体步骤如下：

在pom.xml中编写标签
在标签中使用引入坐标
定义坐标的 groupId、artifactId、version

4.点击刷新按钮，引入最新加入的坐标

刷新依赖：保证每一次引入新的依赖，或者修改现有的依赖配置，都可以加入最新的坐标

注意事项：

如果引入的依赖，在本地仓库中不存在，将会连接远程仓库 / 中央仓库，然后下载依赖（这个过程会比较耗时，耐心等待）
如果不知道依赖的坐标信息，可以到mvn的中央仓库（https://mvnrepository.com/）中搜索

12.2 依赖传递

12.2.1 依赖具有传递性(默认有传递性)

我们现在使用了maven，当项目中需要使用logback-classic时，只需要在pom.xml配置文件中，添加logback-classic的依赖坐标即可。

在pom.xml文件中只添加了logback-classic依赖，但由于maven的依赖具有传递性，所以会自动把所依赖的其他jar包也一起导入。

依赖传递可以分为：

直接依赖：在当前项目中通过依赖配置建立的依赖关系
间接依赖：被依赖的资源如果依赖其他资源，当前项目间接依赖其他资源

例如:

12.2.2 排除依赖(加exclusions标签)

排除依赖：指主动断开依赖的资源。（被排除的资源无需指定版本）

12.3 依赖范围(默认任何位置)

在项目中导入依赖的jar包后，默认情况下，可以在任何地方使用。

12.3.1 限制依赖适用范围(加scope标签)

作用范围：

主程序范围有效（main文件夹范围内）
测试程序范围有效（test文件夹范围内）
是否参与打包运行（package指令范围内）

scope标签的取值范围(像修饰符一样)：

scope值	主程序	测试程序	打包（运行）	范例
compile（默认）	Y	Y	Y	log4j
test	-	Y	-	junit
provided	Y	Y	-	servlet-api
runtime	-	Y	Y	jdbc驱动

13. 分模块设计与开发(一个项目关联其他项目jar包)

分模块开发需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分

分模块设计我们在进行项目设计阶段，就可以将一个大的项目拆分成若干个模块，每一个模块都是独立的

针对之前的项目就可以拆分多个子项目完成，在通用组件pom.xml文件中引用即可

在各自项目内配置需要的依赖(pom.xml)，然后再通同组件内调用其他依赖

14.继承与聚合

Maven打包方式：

==jar：普通模块打包==，springboot项目基本都是jar包（内嵌tomcat运行）

==war：普通web程序打包==，需要部署在外部的tomcat服务器中运行

==pom：父工程/聚合工程==，该模块不写代码，仅进行依赖管理

14.1 继承(加parent标签)

将各个项目共同的依赖 –提取–> 父工程

概念:

继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承(==单一继承==)

作用：

==简化依赖配置、统一管理依赖==

实现:

<parent>
    <groupId>...</groupId>
    <artifactId>...</artifactId>
    <version>...</version>
    <relativePath>....</relativePath>    设定父工程的pom.xml文件位置[如果不指定，将从本地仓库/远程仓库查找该工程]
</parent>

14.1.1 步骤

1.创建父工程，在父工程的pom.xml文件中设置打包方式为pom(默认jar) –====

2.在子工程的pom.xml文件中，配置继承关系 –====和里面的====

【注意:当配置了父工程之后，子工程坐标的就可以删除，因为会自动继承父工程】

3.在父工程中配置各个工程共有的依赖(子工程会自动继承父工程的依赖【子工程可以删除】)

14.1.2 版本锁定(加dependencyManagemen标签)

在maven中，父工程pom.xml文件通过==标签==来==统一管理依赖版本==

思路：

各个项目不同的依赖，父工程pom.xml文件中通过dependencyManagement统一版本，并不会将这个依赖直接引入进来。子工程调用的时候就不用写version版本标签

要修改就在父工程区修改【但是子工程必须要调用，因为父工程只是统一版本了但是没有引入啊！！】

==版本锁定就是在继承(可以不调用，会自动继承父类的)的前提上，子工程必须调用(同一版本不引入依赖，只是管理)但是可以省略版本号就行==

14.1.3 自定义属性/引用属性（加自定义标签）

==集中的集中管理== –也可以在父工程中将版本号统一在properties标签内设定自定义标签lombok.version，然后在其他依赖引入的version位置加入

举例:

14.1.4 区别对比

文字对比

面试题：<dependencyManagement> 与 <dependencies> 的区别是什么?

<dependencies> 是直接依赖，在父工程配置了依赖，子工程会直接继承下来。

<dependencyManagement> 是统一管理依赖版本，不会直接依赖，还需要在子工程中引入所需依赖(无需指定版本)

14.2 聚合(加modules标签)

对所有聚合的子模块统一操作==快速构建项目==

聚合：

将多个模块组织成一个整体，同时进行项目的构建。
聚合工程：

一个不具有业务功能的“空”工程（有且仅有一个pom文件）【一般来说，继承关系中的父工程 == 聚合关系中的聚合工程】
作用：

快速构建项目（无需根据依赖关系手动构建，直接在聚合工程上构建即可）
实现：

<!--聚合其他模块-->
<modules>
    <module>../tlias-pojo</module>
    <module>../tlias-utils</module>
    <module>../tlias-web-management</module>
</modules>

在maven中，我们可以在聚合工程中通过 <modules> 设置当前聚合工程所包含的子模块的名称。

==那此时，我们要进行编译、打包、安装操作，就无需在每一个模块上操作了。只需要在聚合工程上，统一进行操作就可以了==

14.3 继承和聚合的对比

作用
- 聚合用于快速构建项目
- 继承用于简化依赖配置、统一管理依赖
相同点：
- 聚合与继承的pom.xml文件打包方式均为pom，通常将两种关系制作到同一个pom文件中
- 聚合与继承均属于设计型模块，并无实际的模块内容
不同点：
- 聚合是在聚合工程中配置关系，聚合可以感知到参与聚合的模块有哪些
- 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己