Maven

感谢尚硅谷！！！！

1、为什么使用Maven

1. Maven提供了便捷管理Jar包的功能 -- 第三方jar包的添加 -- 第三方jar包的获取 -- 可以自动处理jar包依赖关系 -- 自动的处理jar包之间的冲突

2. Maven对项目进行模块化管理功能 -- Maven可以自动化的对项目进行拆分管理

   -- 把每个模块进行jar打包

2、什么是Maven

1. 一个自动化构建管理项目的神器，可以帮你直接进行编译打包部署测试

3、如何使用Maven

1. 先解压，配环境变量

2. 配置Maven本地仓库和阿里云镜像

   在此路径下：E:\maven\apache-maven-3.5.4\conf\settings.xml

   本地仓库：

   阿里云镜像：

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

3. 把Maven集成到idea上面

    

上述必配

---

 

上述可配可不配

-- 如果以上配置完后，重新打开IDEA依然生效的是默认的配置参考一下步骤解决 点我

---

4、如何在idea使用Maven

1. 先建一个空项目

2. 建立一个Maven模块

3. 接下来会详细说，第一个是组id第二个是项目名第三个是版本号

4. 目录结构

     -- src
                    -- main
                       -- java
                       -- resources
                    -- test
                       -- java
                 -- pom.xml

   pom.xml详细概述：

        <!--当前Maven模块的坐标信息-->
        <groupId>com.mingren</groupId>
        <artifactId>Hello</artifactId>
        <version>1.0-SNAPSHOT</version>
    ​
        <!--添加依赖，可在下一个标签中添加多个依赖-->
        <dependencies>
            <!--会在我们所设置的本地仓库中寻找，如果找不到，则回去阿里云镜像中央仓库去寻找-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.0</version>
                <!--决定当前依赖的生效范围（main和test）如果不写为compile-->
                <scope>test</scope>
            </dependency>
        </dependencies>

5. -- IDEA中对Maven工程的基本命令操作 -- clean 清理工作 -- compile 编译主程序代码 -- test 编译当前模块的所有程序代码以及执行测试代码 -- package 打包操作 -- install 将打好的包安装到本地仓库

5、Maven核心概念

1. POM 项目对象模型抽象的概念，具体体现就是一个用pom.xml文件来描述整个模块的一种思想。

2. 现在JavaEE开发领域普遍认同一个观点：约定>配置>编码。意思就是能用配置解决的问题就不编码，能基于约定的就不进行配置。而Maven正是因为指定了特定文件保存的目录才能够对我们的Java工程进行自动化构建。

3. 坐标：

      -- Maven中的坐标它就是体现当前Maven工程的唯一性，而且也是将来引用此jar包的
               唯一路径
      -- Maven中坐标的命名规范
           （1）groupId：公司或组织的域名倒序+当前项目名称
           （2）artifactId：当前项目的模块名称
           （3）version：当前模块的版本

4. 依赖管理

   1. 项目与项目之间可以相互依赖

   2. 依赖的范围:

               -- compile（默认就是这个范围）
                       （1）main目录下的Java代码可以访问这个范围的依赖
                       （2）test目录下的Java代码可以访问这个范围的依赖
                       （3）部署到Tomcat服务器上运行时要放在WEB-INF的lib目录下
                       例如：对Hello的依赖。主程序、测试程序和服务器运行时都需要用到。
                       
                 -- test 
                       （1）test目录下的Java代码可以访问这个范围的依赖
                       （2）部署到Tomcat服务器上运行时不会放在WEB-INF的lib目录下
                       例如：对junit的依赖。仅仅是测试程序部分需要。
                       
                 -- provided
                       （1）main目录下的Java代码可以访问这个范围的依赖
                       （2）test目录下的Java代码可以访问这个范围的依赖
                       （3）部署到Tomcat服务器上运行时不会放在WEB-INF的lib目录下
                       例如：servlet-api在服务器上运行时，Servlet容器会提供相关API，
                       所以部署的时候不需要。
               (服务器自带的才会使用provided，使用compile时还是要在服务器上部署)

   3. 依赖的传递性

      1. 如果b依赖a，c依赖b，那么c也会依赖a 但是是否能够传递还要取决于被传递者的使用范围

      2. 直接依赖 ：a,b;b,c 间接依赖：a,c;

   4. 依赖的原则：

      当相同的jar包版本冲突时，选择依赖时按照这两个原则：

      1、路径最短者优先 2、如果路径相同声明者优先

   5. 依赖(jar包)的排除

       <!--当b依赖于a时，想要排除a的某一些jar包-->
       <dependency>
           <!--依赖排除-->
           <groupId>com.atguigu.maven</groupId>
           <artifactId>OurFriends</artifactId>
           <version>1.0-SNAPSHOT</version>
       ​
           <exclusions>
               <!--里面放置a的依赖-->
               <exclusion>
                   <groupId>commons-logging</groupId>
                   <artifactId>commons-logging</artifactId>
               </exclusion>
           </exclusions>
       </dependency>
       ​

   6. 依赖版本的统一管理

       <!--统一管理当前模块的jar包的版本-->
       <!--自定义标签-->
       <properties>
           <spring.version>4.0.0.RELEASE</spring.version>
       </properties>
       ​
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <!--自定义的标签如何访问：${spring.version}-->
           <version>${spring.version}</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>${spring.version}</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>${spring.version}</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-orm</artifactId>
           <version>${spring.version}</version>
       </dependency>
       ​

   7. 仓库

            -- 本地仓库：为当前本机上所有的maven工程项目
            -- 远程仓库
               a. Maven私服（一般在真实开发中实现）
                   在公司的局域网上架上一台服务器里面配置maven本地仓库，公司的职员连接到这台服务器上，可以缓解个人本地仓库的压力
               b. 中央仓库
               c. 中央仓库的镜像

   8. 生命周期

      Maven有三套相互独立的生命周期，分别是： 
      	Clean Lifecycle在进行真正的构建之前进行一些清理工作。
      	Default Lifecycle构建的核心部分，编译，测试，打包，安装，部署等等。
      		部署我们几乎不会用，无序管它，只需知到概念就ok
      	Site Lifecycle生成项目报告，站点，发布站点。
      

   9. 插件和目标

      -- Maven中具体实现功能是通过提供好的插件完成的，每一个插件都对应多个目标（功能）。
      

6、Maven的继承

1. 为什么需要继承？

   当不同的工程导入相同的依赖时但依赖的版本却不一样，我们去统一管理可以建一个父工程在父工程里面进行相应的版本控制，则子工程导入依赖时无需在乎版本问题

   即，父工程是为了统一管理子工程才出现的

2. 如何实现继承

   第一种方法：
   <!--首先创建一个父工程module把打包方式改为pom-->
   	<groupId>com.mingren</groupId>
       <artifactId>parent1</artifactId>
       <version>1.0-SNAPSHOT</version>
   	<!--打包方式分为pom(父项目就是这个)war(web工程的打包方式)，默认为jar的打包方式-->
       <packaging>pom</packaging>
   <!--然后在其子项目里面 实现继承-->
   	<parent>
           <!--放置坐标定位-->
           <groupId>com.mingren</groupId>
           <artifactId>parent1</artifactId>
           <version>1.0-SNAPSHOT</version>
           <!--配置相对于子工程的父工程路径pom.xml文件-->        
           <relativePath>../parent1/pom.xml</relativePath>
       </parent>
           
   ·	<!--如果仅仅管理版本号的话，使用下述标签，然后在子工程里面删除相应依赖的版本号-->
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>junit</groupId>
                   <artifactId>junit</artifactId>
                   <version>4.0</version>
                   <scope>test</scope>
               </dependency>
           </dependencies>
       </dependencyManagement>
   	
   	
   	<!--如果在子工程中连依赖都不想写，直接使用下述标签-->
       <dependencies>
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.0</version>
               <scope>test</scope>
           </dependency>
       </dependencies>
   
   第二种方式：（自动完成创建）
   	 创建一个父module在其父module下直接创建相应的子module会自动进行继承
   

7、聚合

1. 什么是聚合

   概念：在Maven管理项目的前提下，并且建立好父子工程结构下，我们通常在父工程中将子工程聚集到一起，进行统一的管理操作。最终实现一键式管理多个Maven的项目的目的。

2. 如何实现聚合？

   <!--在父工程的pom.xml中实现聚合-->
   <modules>
   	<!--下面写该父工程下属的子工程-->
       <module>../hello</module>
       <module>../hello1</module>
   </modules>