第一章 为什么要学习Maven？

　　1. 添加第三方jar包

　　JavaEE开发中需要使用大量的jar包，使用这些jar包需将jar包添加到WEB-INF/lib目录下，造成每次新建一项工程需要将有大量的jar包复制到工程下，让我们的工程很臃肿。而使用 Maven 后每个 jar 包本身只在本地仓库中保存一份，需要 jar 包的工程只需要以坐标的方式简单的引用一下就可以了。不仅极大的节约了存储空间，让项目更轻巧，更避免了重复文件太多而造成的混乱。

　　2. jar包之间的依赖关系
　　jar 包往往不是孤立存在的，很多 jar 包都需要在其他 jar 包的支持下才能够正常工作，我们称之为jar 包之间的依赖关系。当你的项目中需要用到上百个 jar 包时，你还会人为的，手工的逐一确认它们依赖的其他 jar 包吗？而引入 Maven 后， Maven 就可以替我们自动的将当前 jar 包所依赖的其他所有 jar 包全部导入进来，无需人工参与，节约了我们大量的时间和精力。

 

　　3. 获取第三方jar包

　　使用 Maven 我们可以享受到一个完全统一规范的 jar 包管理体系。 你只需要在你的项目中以坐标的方式依赖一个 jar 包， Maven 就会自动从*仓库进行下载，并同时下载这个 jar 包所依赖的其他 jar 包。

　　4. 将项目拆分成多个工程模块

　　将项目拆分成多个工程协同开发。多个模块工程中有的是 Java 工程，有的是 Web 工程。那么工程拆分后又如何进行互相调用和访问呢？这就需要用到 Maven 的依赖管理机制。

 

第二章 什么是Maven

　　1. Maven的概述：Maven是Apache软件基金会组织维护的一款专门为Java项目提供构建和依赖管理支持的工具。

　　2. Maven的作用

　　（1）maven对项目的第三方构件（jar包）进行统一管理。向工程中加入jar包不要手工从其它地方拷贝，通过maven定义jar包的坐标，自动从maven仓库中去下载到工程中。

　　(2) maven提供一套对项目生命周期管理的标准，开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理：编译、测试、打包、部署 、运行。

　　(3) maven对工程分模块构建，提高开发效率。

　　3. Maven仓库

　　(1) 本地仓库：相当于缓存，工程第一次会从远程仓库（互联网）去下载jar 包，将jar包存在本地仓库（在程序员的电脑上）。第二次不需要从远程仓库去下载。先从本地仓库找，如果找不到才会去远程仓库找。

　　(2) *仓库：就是远程仓库，仓库中jar由专业团队（maven团队）统一维护。*仓库的地址：http://repo1.maven.org/maven2/

　　(3) 远程仓库：在公司内部架设一台私服，其它公司架设一台仓库，对外公开。比如阿里云远程仓库地址：http://maven.aliyun.com/nexus/content/repositories/central/

 

 

 

 

 

第三章 Maven的下载和安装

　　1. 下载Apache Maven(***)

　　　　下载地址：https://archive.apache.org/dist/maven/maven-3/

　　　　下载后直接解压即可。

　　2. 配置本地仓库

　　将文件夹Repository复制到Maven的解压缩路径下（建议，本地仓库可以放在任意路径下），在conf目录中对象settings.xml文件进行配置。（注意：路径不能有中文、空格、特殊字符）

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
   <!--配置本地仓库的路径,千万不要配置错误 -->
   <localRepository>D:\software\Develop\Java\apache-maven-3.5.3\repository</localRepository>

　　3. 配置阿里云远程仓库

 1   <mirrors>
 2           <!--
 3             配置的是远程仓库的地址，配置的阿里云，国内的服务器
 4             没有的jar包，从远程仓库中下载
 5             没有这个配置，自动从*仓库下载jar (国外)
 6        -->
 7         <mirror>
 8             <id>alimaven</id>
 9             <name>aliyun maven</name>
10             <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
11             <mirrorOf>central</mirrorOf>
12         </mirror>


15     <!-- mirror20     <mirror>
21       <id>mirrorId</id>
22       <mirrorOf>repositoryId</mirrorOf>
23       <name>Human Readable Name for this Mirror.</name>
24       <url>http://my.repository.com/repo/path</url>
25     </mirror>
26      -->
27   </mirrors>

第四章 IDEA创建Maven工程

1. IDEA绑定Maven软件

　　注意：在idea软件外面的Configure —> setting(里面的setting配置只对当前项目有效)

 

（1）配置Maven、setting.xml、repository

　　选择Maven、Maven里面的setting.xml的路径，repostory的路径会自己带出来。

　　不选择则是idea默认的存放路径（${user.home}/.m2/repository）

（2）为Maven添加启动参数：-DarchetypeCatalog=local ，禁止Maven远程下载骨架

 

 

 

 （3）配置Maven自动加载依赖，idea推出2020 版本以后 ，取消了maven 原本的自动加载依赖的设置

　　2020版本之前：勾选Import Maven projects automatically

　　2020版本之后：修改pom.xml文件，点击图标，maven会自动加载依赖

 

2. 创建javaSE项目

 

 

 

 

 

3. pom.xml文件

　　POM：Project Object Model，项目对象模型，是Maven的核心配置文件。主要配置的是项目中的信息：比如依赖的jar包，项目的编译环境，测试环境，项目的打包部署方式，其它第三方插件等等，非常重要。

 

 

 

4. 创建JavaEE项目（带骨架）

 

 

 5. 发布Web项目到Tomcat服务器

　　和普通的JavaWeb项目一至，配置一下配置一下Tomcat就可

 

 

 

 1.6 创建无骨架项目

 

 

 

注意：Maven的编译环境默认的编译环境是jdk1.5,不支持注解写在重写接口的抽象方法上

 1 public class MainTest implements Runnable {
 2     public static void main(String[] args) {
 3         new HashMapDemo().hash();
 4     }
 5     //Maven的编译环境默认的编译环境是jdk1.5,不支持注解写在重写接口的抽象方法上
 6 　　//@Override
 7     public void run() {
 8 
 9     }
10 }

插入知识点：CurrentHashMap集合

　　ConcurrentHahsMap是Map接口的实现类，是HashMap集合的变种

　　　　线程一半安全，一半不安全

　　　　集合操作不改变原有键值对，线程不安全

 1 package com.atguigu.map;
 2 
 3 import java.util.concurrent.ConcurrentHashMap;
 4 
 5 public class HashMapDemo {
 6     public void hash(){
 7         /*
 8             ConcurrentHahsMap是Map接口的实现类，是HashMap集合的变种
 9             线程一半安全，一半不安全
10             集合操作不改变原有键值对，线程不安全
11         * */
12         ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<String, String>();
13         hashMap.put("a","a");
14         String a = hashMap.get("a");
15         System.out.println("a = " + a);
16     }
17 }

第五章Maven的依赖错标

1. maven编写jar包依赖

　　（1）标签介绍

　　　　dependencies：依赖，所需要用的jar包标签配置多个jar包使用

　　　　dependency：配置单个jar包的标签

　　　　groupId：jar包公司名，或者组织名

　　　　artifactId：jar包的项目名

　　　　version：jar包的版本号

　　　　scope：jar包的作用域

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

　　（2）定义jar包坐标的简单方式

　　记住jar包名就可以 连接池 德鲁伊 druid.jar

<!--
      导入依赖jar servlet.jar
      写该jar包的坐标，本地仓库目录的jar包的文件夹

      定义jar包坐标的简单方式
      记住jar包名就可以 连接池 德鲁伊 druid.jar
    -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.6</version>
    </dependency>

注意：新建servlet需要导入servlet依赖的jar包（javax.servlet-api）

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>

2. 从远程仓库下载jar包

　　需要导入的jar包，在本地仓库中并不存在，可以到Maven的*仓库中去查询：https://mvnrepository.com/，直接搜索需要的jar包即可，选择版本好，并复制左边，Maven就会自动从远程仓库中下载jar包本地仓库。

 

3. maven依赖传递

 　　引入的jar包会有依赖传递问题，Maven具有依赖传递功能，当引入A.jar包，此时Maven自动会引入A.jar包所依赖的B.jar包，这就是依赖传递

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>

 

 4. 依赖排除

　　当A依赖B，B依赖C而且C可以传递到A的时候，但是A不想要C，需要在A里面把C排除掉。而往往这种情况都是为了避免jar包之间的冲突。

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.6.RELEASE</version>
      <!--配置依赖排除，不要jar包-->
      <exclusions>
        <exclusion>
          <groupId>org.springframework</groupId>
          <artifactId>spring-expression</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

5. jar包依赖范围

依赖范围	编译有效	测试有效	运行有效	例子
compile	√	√	√
test		√		junit.jar
provided	√	√		servlet.jar，jsp.jar
runtime		√	√	mysql驱动

 

<!--
        jar包的依赖范围作用域
        compile 编译时，在程序编译时有效，测试时有效，运行时有效（默认配置）
        test 测试时，只有在测试时才有效，例子junit.jar
        provoided  提供者，编译程序有效，测试程序有效，运行时期无效 例子 servlet.jar,jsp.jar
                          在运行时期，Tomcat引擎提供
        runtime 运行时，编译期无效，测试程序有效，运行程序有效 mysql驱动.jar
    -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

 

 6. Maven的插件机制

　　Maven是一个核心引擎，提供了基本的项目处理能力和建设过程的管理，以及一系列的插件是用来执行实际建设任务。maven插件可以完成一些特定的功能。

　　插件的完整写法：build -> plugins -> plugin

<build>
        <plugins>
            <!--tomcat服务插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

 

（1）编译插件

　　集成jdk插件可以方便修改项目的编译环境

　　　　　　<plugin>
               <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <!--编译插件，配置信息-->
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>

（2）tomcat插件

　　无需安装tomcat服务器就可以运行tomcat进行项目的发布与测试。

<!--tomcat服务插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                </configuration>
            </plugin>

 

7. properties标签

　　pom.xml中的统一版本控制标签。在一个项目中，jar包的数量会非常多，就导致了pom文件的量非常大，如果要修改某一jar包的版本不是很方便，因此可以使用properties标签进行版本的总控

<properties>
  <mysql.version>5.1.46</mysql.version>
</properties>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
</dependency>

 

8. 无骨架项目变web项目

　　（1）补充知识：

　　　　javaSE项目，打包方式jar(默认)

　　　　javaEE项目，打包方式war

　　（2）分析：

　　　　无骨架项目 ——> javaSE项目 ——> 打包方式：jar

　　　　web项目 ——> javaEE项目 ——> 打包方式：war

　　　　所以只需修改无骨架项目的打包方式为：war

　　（3）具体操作：

　　　　第一步：在java文件夹的同级目录下新建一个webapp文件夹

 

 

　　　　第二步：修改项目的打包方式，<packaging>war</packaging>

 

 　　　　第三步：选中项目，点击刷新即可

 

 

 

第六章 Maven常用的命令

1.  clean命令

　　清除编译产生的target文件夹内容，可以配合相应命令一起使用，如mvn clean package， mvn clean test

2. complie命令

　　该命令可以对src/main/java目录的下的代码进行编译

3.  test命令

4.  package命令

　　打包后的项目会在target目录下找到，JavaSE项目的打包方式为jar，JavaEE项目的打包方式为war

5.  install命令

　　mvn install，打包后将其安装在本地仓库

第七章 Maven的子父工程

　　Maven中的子父工程，非常适合于团队开发，子工程的jar包含全部继承自付项目。

　　项目地址：

1. 创建父项目

（1）创建父项目无骨架

　　1.1 创建一个无骨架项目

　　1.2 配置pom.xml文件

　　　　1.2.1 配置父项目的打包方式为：pom

1 <!--修改父项目的打包方式pom打了一个配置文件-->
2     <packaging>pom</packaging>

　　　　1.2.2 引入依赖

<!--引入依赖-->
    <dependencies>
        <!--junit包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--连接数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <!--druid工具包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>
        <!--DBUtils-->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <!--lombook包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--beanutils-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.2</version>
        </dependency>
    </dependencies>

 

（2）创建子项目

　　2.1 创建无骨架项目的dao模块

　　2.2 创建无骨架项目的service模块

　　2.3 创建javaWeb项目的controller模块

（3）补充知识点

　　3.1 子项目中的jar依赖近者优先原则

　　子项目引入和父项目相同的依赖（版本不同，优先使用子项目优先使用自己引入的依赖版本）；如下图所示，子项目中额外引入mysql5.1.46版本，不适用父项目mysql5.1.49的版本。

 

 

 

　　3.2 jar包的依赖管理器标签

　　依赖管理标签，父项目使用该标签的目的是对子项目中使用的jar进行版本控制；定义在管理器中的jar包标签，子项目不能继承，子项目能引入该标签的依赖无需指定版本号

 

　　父项目

<properties>
        <mybatis.version>3.5.3</mybatis.version>
    </properties>

    <!--
        依赖管理器 dependencyManagement
        定义jar的依赖坐标
        定义在管理器中的jar包错标，子项目不能继承
        配合标签properties
        作用：
            对子项目的jar包进行版本控制的
            子项目可以使用maybatis.jar,无需指定版本号

    -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

　　子项目

　　　　<dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>

 

（4）分模块架构功能

　　4.1 编写dao模块

　　　　4.1.1 导入druid.properties、JDBCUtils文件

　　　　4.1.2 编写Soldier实体类

　　　　4.1.3 编写dao层，SoldierDao接口、SoldierDaoImpl实现类

　　

 

 

　　4.2 编写service模块

　　　　4.2.1 编写SoldierService接口、SoldierServerImpl实现类

　　　　注意：pom.xml文件需要引入dao层依赖

　

 

 

 　　4.3 编写controller模块

　　　　4.3.1 编写SoldierServlet、

　　　　4.3.2 导入dao层、service层依赖，配置tomcat插件(注意servlet依赖范围以tomcat冲突)

 

@WebServlet(urlPatterns = "/soldier")
public class SoldierServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        Soldier soldier = new Soldier();
        Map<String, String[]> map = request.getParameterMap();
        try {
            BeanUtils.populate(soldier,map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        SoldierService service = new SoldierServerImpl();
        service.insertSoldier(soldier);
        response.getWriter().write("添加成功");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}

 

（5）项目聚合

　　直接对父项目install。