Maven构建工具学习

maven作用：
1.管理jar
    i. 增加第三方jar
    ii. 管理jar之间的依赖关系
2.将项目拆分成若干的模块

maven概念： 基于java平台的自动化构建工具

清理：删除编译的结果（为了重新编译 ）
编译：java->class
测试：针对项目的关键点进行测试，，也可以用项目中的测试代码，去测试开发代码
报告：测试的结果 显示
打包：将项目的多个文件，压缩成一个文件，用于安装部署（java--jar   web---war）
安装：将打好的包，放到本地仓库，供其他项目使用
部署：是将打好的包，放到服务器上，准备运行 ---类似于eclipse的打war包

自动化构建工具maven: 将原材料（java js css html jpg...）-> 产品（可发布项目）
本地仓库：有的话 先去本地下（没有就去远程仓库下）
中央仓库：本地没有，联网去中央下
中央仓库镜像：对中央仓库的分流操作
私服：也是远程仓库，如果有私服，本地没有就先到私服去下，还没有，去中央仓库下（一般私服是一个公司或一个合作项目搭建一个  一般通过nexus搭建）

maven使用：
约定优于配置（默认值）
maven的约定目录结构：
    -src
        --main                             程序功能代码
            ---java                        java代码
            ---resources                资源代码
        --test                            测试代码
            ---java                        java代码  ---测试类写法 @Junit...
            ---resources                资源代码

    -pom.xml                            项目对象模型（将项目看成节点、对象）
    -target                                源码编译的结果（自己生成）

pom.xml
    g a v  确定唯一的模块（在仓库的坐标  路径 （相当于 包名/类名/版本号  对应本地仓库的文件路径））
    <groupId>域名反转.大的项目名（子项目的总项目名）</groupId>  //
    <artifactId>子模块名</artifactId>
    <version>版本号(0.0.1-SNAPSHOT 快照)</version>
    <name>一般和子模块名一致</name>
        
    <dependencies>
        <dependency> //依赖   需要用到其他类   配置好之后，会自动去本地仓库寻找，没有的话去中央仓库下载
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
---------------------------------
dom.xml配置成功 放到src中
-----------------------------------    
执行maven：必须在pom.xml 所在目录执行
    1.dos  cmd-----切到当前dom.xml'路径
    2. 在当前dom.xml路径 输入cmd
    
    3. 执行 mvn compile 
    （找需要依赖的包，---去本地仓库找---没有--去中央）
    （一般第一次编译 会下载 maven的一些基础组件 用来执行mvn命令）
    （源码编译（只编译main目录）的结果放入 target目录）
    4.mvn test 测试
    （一般第一次编译 会下载 maven的一些基础组件 用来执行mvn命令）
    5.mvn package  打包（注意  项目不能出错）
    6.mvn install 将开发的模块放入 本地仓库 供其他模块使用（放入的位置由g a v决定）
    7.mvn clean 清除target（编译结果）---不能清空本地仓库
-------------------------------------------

依赖：
    pom.xml配置
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
                <version>4.2.0.Final</version>
    </dependency>
    </dependencies>
依赖的范围（有效性）：可以不写<scope>test或provided</scope>
    1.compile（不写 是默认值）
    2.test
    3.provided
                            compile       test        provided
主程序（main）        √                ×                √
测试程序（test）      √                √                √
部署（运行）            √                ×                ×
    这是jar包的生效范围 ，默认全生效，test是只在test时生效（例如juint.jar 编译用不到 部署也用不到） ，provided是只有部署不生效（例如servlet-api.jar 因为部署时，tomcat自带了这个jar就不需要生效了）

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

------------------------------------------
在eclipse中创建maven项目（打勾simple）
    创建之前需要配置maven（本地仓库、setting文件）
    编写完pom.xml依赖后，maven-update
    
    执行pom.xml 右键maven build... 输入 goals  --- clean
    第二次maven build 默认执行上一次的build... 的操作

maven生命周期：
 阶段中如果分5步命令： a b c d e 
    如果执行命令e 会将之前的命令a-d都执行
 
 maven生命周期包含三个阶段：
    eg：执行 mvn clean  则 pre-clean  clean都会执行
clean lifecycle生命周期  :清理
    pre-clean 之前  clean 清理 post-clean 之后 
    eg：执行 mvn clean  则 pre-clean  clean都会执行
default lifecycle 生命周期 :默认（常用）
    有很多，常见的有：
        install   test   test-compile    package    compile
site lifecycle 生命周期 :站点
    pre-site之前  site生成站点     post-site之后  site-deploy部署 

-----------------------------------------------------
依赖排除：
    假设A.jar依赖于B.jar 引用A会自动引用B（一般只是A部分方法会用到依赖B）
    如果不想用到B.jar 该怎么排除？
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.7.RELEASE</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-beans</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
依赖的传递性：
    如果 A.jar 依赖于  B.jar  且  B.jar 依赖于  C.jar
        要使  A.jar 依赖于  C.jar 
        当且仅当  B.jar 依赖于 C.jar 的范围是compile
    这样会自动导入相应的依赖包，否则无法依赖

两个maven项目整合：    
1.第一个 mvn install  生成jar 到本地仓库
2.第二个项目通过pom.xml 依赖配置,之后就可以使用了

//maven中 包名一致，就不需要导包（不同项目也是？ 和groupId有关联吗）

依赖原则：（为了防止依赖的包冲突）
    a.路径长度不同，最短优先原则
    b.路径长度相同
        i.在同一个pom.xml中，有两个相同的依赖（版本不同）：后声明的依赖会覆盖之前的依赖
        ii.在不同的pom.xml中，有两个相同的依赖：则先声明的依赖包含的依赖会覆盖后边声明的依赖中包含的重复依赖

直接改jdk版本：build path 删除、添加    或者      右键项目 属性-java compiler 改 jave version
通过maven统一jdk版本：两种都可以
    <profiles>
        <profile>
            <id>jdk-1.8</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.compileVersion>1.8</maven.compiler.compileVersion>
            </properties>
        </profile>
    </profiles>
    -----------------------------------------
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source> <!-- 源代码使用的开发版本 -->
                    <target>1.8</target> <!-- 需要生成的目标class文件的编译版本 -->
                    <!-- 一般而言，target与source是保持一致的，但是，有时候为了让程序能在其他版本的jdk中运行(对于低版本目标jdk，源代码中需要没有使用低版本jdk中不支持的语法)，会存在target不同于source的情况 -->
                    <encoding>UTF8</encoding>
                    <!--windows默认使用GBK编码，java项目经常编码为utf8，也需要在compiler插件中指出，否则中文乱码可能会出现编译错误 -->
                </configuration>
            </plugin>
        </plugins>
        <finalName>HelloWorld</finalName><!-- 项目名 -->
    </build>
-------------------------------------------

使用配置该版本号：（更直观）
<properties>
        <!-- 统一编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 配置 统一版本  名字随便起-->
        <wht.junit.version>4.0</wht.junit.version>
    </properties>
<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <!-- 使用自定义的配置版本 -->
            <version>${wht.junit.version}</version>
            <scope>test</scope>
        </dependency>
------------------------------------------------------------

继承：（方便通过父工程 统一管理版本号）
    区别于传递依赖，若 A继承 B   ， A-> B
    无论B中的依赖范围是compile还是test还是provided 都会继承
    实现步骤：
    1.新建一个父类maven项目 打包方式为pom：
    2.写依赖（多一级包装 dependencyManagement）
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.0</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>    
    3.子工程pom配置
        <artifactId>HelloWorld</artifactId>
    <!-- 给当前工程 继承一个父工程：1.加入父工程坐标gav 2.加入当前工程pom.xml到父工程的pom.xml相对路径，
        如果子类的a v 与父类相同 就不用写了
     -->
    <parent>
        <groupId>org.wht.maven</groupId>
        <artifactId>helloparent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../helloparent/pom.xml</relativePath>
    </parent>
    4.子工程需要在dependency中声明需要引用父工程中需要的依赖
    （因为父类可能有非常多依赖）
    只需要ga 声明即可 不需要v 和scope <!-- v 和 scope 属性 按继承的 使用 -->
    <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <!-- v 和 scope 属性 按继承的 使用 -->
            </dependency>
-------------------------------------------------------

聚合：
    新建maven1，新建maven2
      之前 要使maven2依赖maven1需要 先install maven1生成jar在本地仓库 之后在maven2    中配置依赖maven1
      现在只需要配置聚合即可，可同时引入多个项目
      
      聚合的使用：一般在总工程中配置
      配置modules  （只能配置在pom方式的项目中）
          <modules>
        <!-- 写项目根路径  不需要关注顺序 会自动识别顺序-->
        <module>../maven1</module>
        <module>../maven2</module>
    </modules>
    只要操作总工程，会同时操作子工程
    -------------------------------------------------------------
    
maven web项目：
    新建maven项目 选web
    需要建WEB-INF 以及 web.xml
    部署可以打war包（正规用法）
           可以直接加入tomcat
           可以通过pom配置，直接部署运行----需要用到一个命令 deploy
           <plugin>
            <!-- 启动web工程所依赖的 服务器（tomcat）插件 -->
                <groupId>org.codehaus.cargo</groupId>
                <artifactId>cargo-maven2-plugin</artifactId>
                <version>1.4.9</version>
                <configuration>
                    <container>
                        <containerId>tomcat8x</containerId>
                        <home>F:\JAVA\eclipse-tomcat\apache-tomcat-8.5.29</home>
                    </container>
                    <configuration>
                        <!-- 校验 -->
                        <type>existing</type>
                        <home>F:\JAVA\eclipse-tomcat\apache-tomcat-8.5.29</home>
                        <!-- 默认值8080 -->
                        <properties>
                            <cargo.servlet.port>8080</cargo.servlet.port>
                        </properties>
                    </configuration>
                </configuration>
                <executions>
                    <execution>
                        <id>cargo-run</id>
                        <!-- 阶段 -->
                        <phase>install</phase>
                        <goals>
                            <!-- 执行 -->
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            (实际开发不推荐pom配置，一般是dos开发或linux开发用，使用cargo插件自动部署)