Maven

1、目前掌握的技术

2、目前的技术在开发中存在的问题[why]

1一个项目就是一个工程
如果项目非常庞大，就不适合继续使用package来划分模块。最好是每一个模块对应一个项目，利于分工协作。
借助于maven就可以将一个项目拆分成多个工程。

2项目中需要的jar包必须手动“复制”、”粘贴” 到WEB-INF/lib 项目下
带来的问题：同样的jar包文件重复出现在不同的项目工程中，一方面浪费存储空间，另外也让工程比较臃肿。
借助Maven，可以将jar包仅仅保存在“仓库”中，有需要使用的工程“引用”这个文件，并不需要重复复制。

3jar包需要别人替我们准备好，或到官网下载
所有知名框架或第三方工具jar包已经按照统一规范放在了Maven的中央仓库中。

4一个jar包依赖的其他jar包需要自己手动加到项目中
Maven会自动将被依赖的jar包导入进来。

3、Maven是什么[what]

1Maven 是 Apache 软件基金会组织维护的一款自动化构建工具，专注服务于 Java 平台的项目构建和依赖管理 。Maven 这个单词的本意是：专家，内行。读音是[‘meɪv(ə)n]或[‘mevn]。
构建工具的发展：Make→Ant→Maven→Gradle

2构建：就是以我们编写的Java代码、框架配置文件、国际化等其他资源文件、jsp页面和图片等静态资源作为“原材料”，去“生产”出一个可以运行的项目的过程。

eclipse中的项目与tomcat中编译结果对比：

只要将项目的源文件按maven要求的规范组织，并提供pom.xml文件，开发者依然可以用使用Maven来编译项目，运行项目，甚至可以使运行测试用例，打包项目。Maven的主要约定有以下几条：

1.源代码应该位于${basedir}/src/main/java路径下；

2.资源文件应该位于${basedir}/src/main/resuorses路径下；

3.测试代码应该位于${basedir}/src/test路径下；

4.编译生成的class文件应该位于${basedir}/target/classes路径下;

5.项目应该会产生一个jar文件，并生成的jar包放在${basedir}/target路径下。

3构建过程中的几个主要环节
①清理：删除以前的编译结果，为重新编译做好准备。
②编译：将Java源程序编译为字节码文件。
③测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
④报告：将每一次测试后以标准的格式记录和展示测试结果。
⑤打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java工程对应jar包，Web工程对象war包。
⑥安装：在Maven环境下特指将打包的结果——Jar包或War包安装到本地仓库中。
⑦部署：将打包的结果部署到远程仓库或将war包部署到服务器上运行。

4自动化构建
程序员一天的工作：

能否将这些程式化的工作交给机器自动完成呢？——当然可以！这就是自动化构建。

此时 Maven 的意义就体现出来了，它可以自动的从构建过程的起点一直执行到终点：

4、安装Maven核心程序

1检查JAVA_HOME环境变量

C:\Users\zxm>echo %JAVA_HOME%
D:\Program Files\Java\jdk1.8.0_111
2解压Maven核心程序的压缩包，放在一个非中文、无空格 的路径下

D:\ProgramData\apache-maven-3.2.2
3配置Maven相关的环境变量
①MAVEN_HOME 或 M2_HOME

②path

验证：运行 mvn -v 命令查看Maven版本

C:\Users\zxm>mvn -v
Apache Maven 3.2.2 (45f7c06d68e745d05611f7fd14efb6594181933e; 2014-06-17T21:51:42+08:00)
Maven home: D:\ProgramData\apache-maven-3.2.2
Java version: 1.8.0_111, vendor: Oracle Corporation
Java home: D:\Program Files\Java\jdk1.8.0_111\jre
Default locale: zh_CN, platform encoding: GBK
OS name: “windows 10”, version: “10.0”, arch: “amd64”, family: “dos”

升级Maven

Maven一直进行着版本更新，如果用户需要更新Maven来获得新特性，在Windows上升级Maven是非常简单的。只要下载新的Maven安装文件，解压至本地某个目录下，然后更新M2_HOME环境变量即可。
  降级也是同理，不做过多介绍。

Mac下安装配置maven
Mac下安装maven步骤如下：
一、确定java环境是否搭建完成，安装的jdk的版本号是多少

安装Maven的版本不同对JDK的版本要求也不同

确认java环境以及版本的命令：
$ java -version
$ javac -version
二、下载Maven并解压至要安装的路径下
下载maven， http://maven.apache.org/download.cgi 下载

我们选择binary zip archive 的类型 。
三、配置Maven
1、之前有教程说直接改系统的profile文件，但由于文件属于只读，并且修改系统文件存在一定的风险性，我们不直接在里面修改，而是新建一个文件

$ touch ~/.bash_profile
$ vim ~/.bash_profile
2、编辑文件，输入以下内容配置Maven

M2_HOME=/Users/zeng/Documents/Maven/apache-maven-3.3.9
PATH=$PATH:$M2_HOME/bin

export M2_HOME
export PATH

我创建好这个文件后，惊喜的发现之前Java的路径也是在这里面配置的。

3、配置好后保存退出，执行以下命令

$ source ~/.bash_profile (不会有输出反应)
4、检测Maven路径是否配置成功

$ echo $M2_HOME (配置成功会输出之前配置的路径)

5、重启终端，检测Maven是否安装成功

$ mvn -version
安装成功

我们看到maven安装并设置ok了。接下来可以使用maven构建应用了。

配置本地maven仓库、创建远程仓库镜像
1.仓库的概念
所谓的仓库就是用于存放项目需要的jar包的。
maven采用一个仓库，多个项目的方式，让多个项目共享一个仓库里的相同jar包。
2.仓库的默认位置
打开
D:\software\apache-maven-3.5.0\conf\settings.xml
可以看到，在倒数第四行我注释掉的那句表示制定了仓库的位置是${user.home}/.m2/repository。
对应我的机器就是
C:\Users\X7TI.m2\repository

<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>
  -->

3.默认下载路径
maven 会默认从maven官方提供的服务器下载jar包。
而官方服务器在国外，因为大家都知道的原因，网速很慢，而且容易卡断。 为了便于快速下载相关jar包，可以使用国内maven 阿里云的下载地址，使用方法为：
打开
D:\software\apache-maven-3.5.0\conf\settings.xml
修改在mirrors下新加一个阿里云的镜像地址：

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

4.修改仓库位置
仓库默认位置 是 C:\Users\X7TI.m2\repository，放在C盘有一点不好，重装系统就都没有了。所以通常我会把仓库的位置修改为：d:/maven/repository
d:/maven/repository

5、Maven的核心概念

1约定的目录结构
2POM
3坐标
4依赖
5仓库
6生命周期/插件/目标
7继承
8聚合

6、第一个Maven工程

1创建约定的目录结构

pom.xml文件为Maven工程的核心配置文件

2为什么要遵循约定的目录结构呢？
我们在开发中如果需要让第三方工具或框架知道我们自己创建的资源在哪，那么基本上就是两种方式：
①以配置文件的方式明确告诉框架 如 < param-value>classpath:spring-context.xml < /param-value>
②遵循框架内部已经存在的约定 如log4j的配置文件名规定必须为 log4j.properties 或 log4j.xml ；Maven 使用约定的目录结构

3背景
背景

在Maven出现之前，Java 项目的目录结构都没有一个统一的标准，配置文件到处都是，单元测试代码到底应该放在哪里，没有一个权威的规范。而Maven对项目的目录结构、测试用例命名方式等内容都做了规定。使用Maven管理的项目必须满足这些规则。用户在不同项目间切换的时候，免去了额外学习成本，即约定优于配置（Convention Over Configuration）。

4目录结构和解读

在项目的顶层有：src、target、pom.xml文件、文本文档（readme.txt、license.txt、NOTICE.txt等），此外，‘.gitignore’是git的忽略配置文件一般也放在顶层。

这个结构只有两个子目录：src和target。这里唯一需要的其他目录是元数据，如cvs，.git或.svn，以及多项目构建中的任何子项目（每个子项目都将如上所述）。

如果工程的构建还有其他贡献源，那么它们将位于其他子目录下：例如，src/main/antlr将包含antlr语法定义文件。（这句话应该可以解释，为啥项目中有其他目录。）

7、Maven常用命令

1注意：执行与构建过程相关的Maven命令，必须进入pom.xml 所在的目录。
2常用命令
【1】mvn clean : 清理
【2】mvn compile : 编译主程序
【3】mvn test-compile : 编译测试程序
【4】mvn test : 执行测试
【5】mvn package : 打包
【6】mvn install ： 安装
【7】mvn site ：生成站点
8、关于联网问题

1Maven 的核心程序中仅仅定义了抽象的生命周期，但是具体的工作必须有特定的插件来完成。而插件本身不包含在Maven核心程序中。
2当我们执行的Maven命令需要用到某些插件时，Maven核心程序会首先到本地仓库中查找。
3本地仓库的默认位置：[系统登陆用户的家目录] \ .m2\repository
4Maven核心程序如果在本地仓库中找不到需要的插件，那么它会自动连接外网，到中央仓库下载。
5如果此时无法连接外网，则构建失败。
6修改默认本地仓库的位置可以让Maven核心程序到我们事先准备好的目录下查找插件
①找到Maven解压目录\conf\settings.xml
②在setting.xml 文件中找到 localRepository 标签
③将 < localRepository>/path/to/local/repo< /localRepository>从注释中取出
④将标签体内容修改为自定义的Maven仓库目录

9、POM

含义：Project Object Model 项目对象模型
DOM ：Document Object Model 文档对象模型

pom.xml 对于 Maven工程是核心配置文件，与构建过程相关的一切设置都在这个文件中进行配置。
重要程度相当于web.xml 对于动态web工程

1介绍POM
Maven之前的构建工具有Make和Ant，其中Make依赖构建脚本Makefile，Ant依赖构建脚本build.xml。同理，Maven项目也依赖构建脚本。
  POM（Project Object Model，项目对象模型）是Maven 项目中的基本单元，它是一个 xml 文件，被放在工程根目录下。该xml 文件的名字，在Maven 1中叫做project.xml，在Maven 2和Maven 3中重命名为pom.xml。在pom.xml中定义了Maven项目的基本信息、描述项目如何构建、声明项目的依赖等。

执行任务或目标时，Maven会在当前目录中查找POM。它读取POM，获取所需的配置信息，然后执行目标。

应该如何书写pom.xml文件呢？ Maven的官方网址上给出了POM文件的一般结构：

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!-- The Basics -->
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
  <packaging>...</packaging>
  <dependencies>...</dependencies>
  <parent>...</parent>
  <dependencyManagement>...</dependencyManagement>
  <modules>...</modules>
  <properties>...</properties>

  <!-- Build Settings -->
  <build>...</build>
  <reporting>...</reporting>

  <!-- More Project Information -->
  <name>...</name>
  <description>...</description>
  <url>...</url>
  <inceptionYear>...</inceptionYear>
  <licenses>...</licenses>
  <organization>...</organization>
  <developers>...</developers>
  <contributors>...</contributors>

  <!-- Environment Settings -->
  <issueManagement>...</issueManagement>
  <ciManagement>...</ciManagement>
  <mailingLists>...</mailingLists>
  <scm>...</scm>
  <prerequisites>...</prerequisites>
  <repositories>...</repositories>
  <pluginRepositories>...</pluginRepositories>
  <distributionManagement>...</distributionManagement>
  <profiles>...</profiles>
</project>

2编写POM
根据Maven的官方给出POM文件结构。可以写一个非常简单的pom.xml文件，用于讲解pom.xml中基本元素的含义。在任意目录下新建一个pom.xml文件，用notepad++打开（代码可以高亮显示），输入如下内容：

<?xml version ="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yonyou.dst</groupId>
    <artifactId>WEB-OP</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Hello_Maven</name>
    <description>My First Maven Project</description>

	<！ - 库依赖关系 - >
	  
	  <dependencies> 
	    <dependency>
	    
	      <！ - 所需库的坐标 - >
	      
	      <groupId> junit </ groupId> 
	      <artifactId> junit </ artifactId> 
	      <version> 3.8.1 </ version>
	      
	      <！ - 此依赖关系仅用于运行和编译测试 - >
	      
	      <scope> test </ scope>
	      
	    </ dependency> 
	  </ dependencies> 

<project>

pom.xml中第一行代码是XML头，指明该xml文档的版本和编码方式。其他元素详解如下：

<dependency…/>元素可接受以下子元素：

<groupId…/>:指定依赖框架或库所属的组织；

<artifactId…/>:指定依赖框架或库的项目名；

<version…/>：指定依赖框架或库的版本号；

<scope…/>:指定依赖库起得作用范围（可接受：compile,provided,test,system,runtime,import）；

<type…/>:指定。。。类型（默认jar,可以指定：war,ejb-client,test-jar）;

注意：每个项目有且仅有一个POM文件。其中， groupId、artifactId和version，是非常重要的三个元素，也是必不可少的元素。因为他们定义了整个项目在Maven世界中的坐标。在Maven的世界中，任何jar、pom、war都是基于这些坐标来进行定位和区分的。强烈建议，创建一个POM之前，应该要先决定groupId、artifactId和version的值。

3超级POM

所有的 POM 都继承自一个父 POM（无论是否显式定义了这个父 POM）。父 POM 也被称作 Super POM，它包含了一些可以被继承的默认设置。

10、坐标

1数学中的坐标：
①在平面中，使用X,Y坐标可以唯一的定位平面中任何一个点。
②在空间中，使用X,Y，Z三个向量可以唯一的定位空间中的任何一个点。

2Maven的坐标：
使用下面三个向量在仓库中唯一定位一个Maven工程

①groupid:公司或组织域名倒序+项目名

< groupid>com.atguigu.maven< /groupid>
②artifactid:模块名

< artifactid>Hello< /artifactid>
③version：版本

< version>1.0.0< /version>
3Maven 工程的坐标与仓库中路径的对应关系，以spring为例

< groupId>org.springframework< /groupId>
< artifactId>spring-core< /artifactId>
< version>4.0.0.RELEASE< /version>
org/springframework/spring-core/4.0.0.RELEASE/spring-core-4.0.0.RELEASE.jar
注意：我们自己的 Maven 工程必须执行安装操作才会进入仓库。安装的命令是：mvn install

11、仓库

1仓库的分类
①本地仓库：当前电脑上部署的仓库目录，为当前电脑上所有Maven工程服务
②远程仓库
（1）私服：搭建在局域网环境中，为局域网范围内的所有Maven工程服务

（2）中央仓库：假设在Internet上，为全世界所有Maven工程服务
（3）中央仓库镜像：为了分担中央仓库流量，提升用户访问速度

2仓库中保存的内容：Maven工程
①Maven自身所需要的插件
②第三方框架或工具的jar包
③我们自己开发的Maven工程

不管是什么样的 jar 包，在仓库中都是按照坐标生成目录结构，所以可以通过统一的方式查询或依赖。

12、依赖

1当 A jar 包用到了 B jar 包中的某些类时，A 就对 B 产生了依赖，这是概念上的描述。Maven解析依赖信息时会到仓库中查找被依赖的jar包。
对于我们自己开发的Maven工程，要使用mvn install 命令安装后就可以进入仓库。

2依赖的范围
①从项目结构角度理解compile和test的区别

compile范围依赖
》对主程序是否有效：有效
》对测试程序是否有效：有效
》是否参与打包：参与
》是否参与部署：参与
》典型例子：spring-core

test范围依赖
》对主程序是否有效：无效
》对测试程序是否有效：有效
》是否参与打包：不参与
》是否参与部署：不参与
》典型例子：Junit

②从开发和运行这两个阶段理解compile 和 provided 的区别

》对主程序是否有效：有效
》对测试程序是否有效：有效
》是否参与打包：不参与
》是否参与部署：不参与
》典型例子：Servlet-api.jar

③有效性总结

3依赖的传递性
A依赖B，B依赖C，A能否使用C呢？要看B依赖C的范围是不是compile

4依赖的排除
如果我们当前工程中引入了一个依赖是A，而A又依赖了B，那么Maven会自动将A依赖的B引入当前工程，但是个别情况下B有可能是一个不稳定版本，或对当前工程有不良影响。这时我们可以在引入A的时候将B排除。

①情景举例

②配置方式

<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>HelloFriend</artifactId>
<version>0.0.1-SNAPSHOT</version>
<type>jar</type>
<scope>compile</scope>
<exclusions>
    < exclusion>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
    </ exclusion> 
</exclusions>
</dependency>

③排除后的效果

5统一管理所依赖 .jar 包的版本
对同一个框架的一组jar包最好使用相同的版本。为了方便升级架构，可以将jar包的版本信息统一提取出来

①统一声明版本号

其中 atguigu.spring.version 部分是自定义标签。

②引用前面声明的版本号

③其他用法

6依赖的原则，解决jar包冲突
①路径最短者优先

②路径相同时先声明者优先

13、生命周期

1.各个构建环节执行的顺序：不能打乱顺序，必须按照既定的正确顺序来执行。
2.Maven的核心程序中定义了抽象的生命周期，生命周期中各个阶段的具体任务是由插件来完成的。
3.Maven核心程序为了更好的实现自动化构建，按照这一特点执行生命周期中各个阶段：不论现在要执行生命周期中的哪一阶段，都是从这个生命周期最初的位置开始执行。
4.Maven有三套相互独立的生命周期，分别是：
①Clean Lifecycle 在进行真正的构建之前进行一些清理工作。
②Default Lifecycle 构建的核心部分，编译、测试、打包、安装、部署等等。
③Site Lifecycle 生成项目报告，站点，发布站点。

他们相互独立。也可以直接运行 mvn clean install site 运行所有这三套生命周期。

每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行 mvn clean，这个 clean 是 Clean 生命周期的一个阶段。有 Clean 生命周期，也有 clean 阶段。

5.Clean声明周期
①pre-clean 执行一些需要在clean之前完成的工作
②clean 移除所有上一次构建生成的文件
③post-clean 执行一些需要在clean 之后立刻完成的工作

6.Default声明周期
Default 生命周期是 Maven 生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：
validate
generate-sources
process-sources
generate-resources
process-resources 复制并处理资源文件，至目标目录，准备打包。
compile 编译项目的源代码。
process-classes
generate-test-sources
process-test-sources
generate-test-resources
process-test-resources 复制并处理资源文件，至目标测试目录。
test-compile 编译测试源代码。
process-test-classes
test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
prepare-package
package 接受编译好的代码，打包成可发布的格式，如 JAR。
pre-integration-test
integration-test
post-integration-test
verify
install 将包安装至本地仓库，以让其它项目依赖。
deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享或部署到服务器上运行。

7.Site生命周期
①pre-site 执行一些需要在生成站点文档之前完成的工作
②site 生成项目的站点文档
③post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
④site-deploy 将生成的站点文档部署到特定的服务器上

这里经常用到的是 site 阶段和 site-deploy 阶段，用以生成和发布 Maven 站点，这可是 Maven 相当强大的功能，Manager 比较喜欢，文档及统计数据自动生成，很好看。

8.插件和目标
Maven的核心仅仅定义了抽象的声明周期，具体的任务都是交由插件完成的。
每个插件都实现多个功能，每个功能就是一个插件目标
Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务。
可以将目标看做“调用插件功能的命令”

例如：compile 就是插件 maven-compiler-plugin 的一个目标；pre-clean 是插件 maven-clean-plugin 的一个目标。

14、在Eclipse中使用Maven
Maven作为一种工具，可以创建标准化的Maven风格Java项目。 但是在实际工作中，很少有机会直接通过Maven 命令行来做到这一点。 通常都是在Eclipse或者IDEA中，通过集成Maven的方式来创建

1Maven插件Eclipse已经内置。

现在主流的IDE（如Eclipse、MyEclipse、IDEA等）中都集成了Maven，但不建议使用内嵌的Maven。原因有三：第一、内嵌的Maven可能版本较旧。第二、内嵌Maven版本可能太新，不太稳定。第三、内嵌的Maven和我们安装的Maven版本不一致，当采用IDE和命令行两种方式构建项目时，容易造成构件行为不一致。

2Maven插件的设置： Window->Preferences->Maven
①installations : 指定Maven核心程序的位置。默认是插件自带的Maven程序，改为我们自己解压的那个。

②user settings : 指定Maven核心程序中 conf/settings.xml 文件的位置，进而获取本地仓库的位置。
菜单->Window->Preferences->Maven->User Settings->
Global Settings 和 User Settings都使用：
D:\software\apache-maven-3.5.0\conf\settings.xml

点击一下Reindex,确保 local Repository为：
d:/maven/repository

3基本操作
①创建Maven版的Java工程
菜单->File->New->Other->Maven->Maven Project
创建时勾选上 Create a simple project(skip archetype selection)

这里选择默认的maven-archetype-quickstart, 和命令行创建maven项目中的项目类型一致的

这一步填写如图所示的信息
Group Id： 填写包名
Artifact Id: 填写j2se
然后点击Finish

创建的Maven工程默认使用的是JDK1.5，打开Maven核心程序settings.xml文件，找到profiles标签，加入如下配置，即可更改

   <profile>
    <id>jdk-1.7</id>
    <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.7</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <maven.compiler.compilerVersion>1.7</maven.compiler.compilerVersion>
    </properties>
</profile>

②创建Maven版的Web工程
1、New Maven project时，Packaging 选择 war

2、调整web目录结构，在项目上点右键 -> properties->Project Facets -> 把Dynamic Web Module 勾选去掉，并Apply -> 将Dynamic Web Module 重新勾选 -> 点击Further configuration available -> 修改 Content directory为src/main/webapp -> Apply 即在Maven工程上生成动态Web目录结构
3、新建jsp文件发现报错：The superclass “javax.servlet.http.HttpServlet” was not found on the Java Build Path
因为缺少Tomcat 运行时环境
以Maven方式添加：
在pom.xml文件中添加

4、jsp写入EL表达式时发现报错：javax.servlet.jsp cannot be resolved to a type
将JSPAPI导入
在pom.xml文件中添加

注意：scope一定要是provided，不然jar包冲突，运行时会报空指针异常

③执行Maven命令
选中pom.xml 右键 Run As->Maven build…->Goals->输入 compile ->点击 run

IDEL+maven+JavaWeb+tomcat+mysql
在intellij中的使用：

1).优势

1.一切都是module：IntelliJ IDEA借鉴的Maven的概念，不在采取Eclipse里Project的概念，一切都是Module。无论是否使用Maven，你的项目都是一个独立 的Module。并且你可以混搭使用Maven Module和普通的Java Module，两者可以和谐共存。

2.更方便的生命周期操作：比起Eclipse通通放进右键菜单的行为，IntelliJ IDEA有着单独的窗口可以完成Maven的操作。你可以针对不同Module进行 Clean Compile Package Install等操作，各个Plug-in的操作也一清二楚。

3.完美的依赖管理：由于Maven会把所有依赖的包放在本机的一个目录下，所以实际上是脱离Project本身存在的。IntelliJ IDEA引入了一个External Library的概念，所有的Maven依赖性都会放在这里，和项目自带的库区分开。并且Module之间会智能的判断，你不需要Maven Install来进行引用代码的更新。

4.动态更新： 每当Maven相关的设置更改时，例如修改了pom的依赖性，添加删除Module，IntelliJ IDEA会提示你进行更新。这种更新实际上就是运行了Maven，所以你不许要手动运行Maven Compile来进行更新，也不会像Eclipse里遇到莫名其妙的问题。
第一步：去Maven官网下载maven 、配置环境变量，配置本地仓库路径和远程仓库镜像。看前面！

第二步：IDEA 中新建Maven工程（这边推荐使用JDK1.8，JDK1.9不兼容，之后会报错）


因为是maven项目，所以需要项目的Groupid, ArtifactId, Version 这是Maven项目的坐标，必填.
GroupId:实际对应JAVA的包的结构，是main目录里java的目录结构。
ArtifactID:就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称。

选择本地maven安装路径，正常情况下其他参数不用修改，填写本地的maven环境，这里可以选择自己本地的环境，也可以用idea自带的maven3.0.5。配置相应的配置文件，idea自带的maven是没有配置文件的，需要单独配置的可以在相应的目录中添加setting.xml文件，例如需要配置jdk版本或者maven mirror的。但是这样会比较慢，有时候如果网速不好，就会卡的比较久，这是因为maven这个骨架会从远程仓库加载archetype元数据，但是archetype又比较多，所以比较卡，这时候可以加个属性 archetypeCatelog = internal，表示仅使用内部元数据，点击右边的蓝色“+”号。

由于maven骨架和一些jar需要去maven的仓库下载，所以创建项目的时候速度会非常慢（外国的服务器你懂得），因此我们可以直接访问http://repo1.maven.org/maven2/archetype-catalog.xml，把这个xml下载下来放到本地的maven目录中，然后在添加一个参数archetypeCatalog=internal就可以了。
next 填写项目名称，finish即可。

输入Project name，输入project name 后，我们会发现下面的Module name跟上面一样，但有时候我们的项目比较大，会分好几个module，这时候可以输入自己的module name，当然也可以不改。

单击Finish， 项目会去配置的仓库中下载对应的构件和依赖.

这时候已经完成大部分了，不过我们还需要新建几个目录文件，因为maven项目的文件结构是 src-main-Java / resources，src-test-java/resources，
创建完成后要为每个资源目录文件选择资源类型：
src/main/java : 　　　　Sources
src/main/resources ：　Resources
src/test/java ：　　　　Tests
src/test/resources：　　Test Resources


同样在main下新建test测试文件夹,再在此文件夹下新建Java测试源码文件夹和resource测试资源文件夹

也可以右键项目-选择Open Module Settings打开项目配置页面更改

项目创建完成后，src-main下建立java目录后，是无法在该目录下创建新的包和java类等文件的。在idea中需要对目录进行标注。

标注完后，建立如下的目录。

别忘记配置信息

第三步：maven工程
新建后需要点击右下角的Enabled Auto Import,等待些许分钟

当pom.xml文件更新出dependencies,就好了。

第四步：使用Maven——添加架包

1.进入网站：http://mvnrepository.com/ 输入我们需要的的架包（例如：mysql）

2.选择合适的架包和版本（一般是项目小组提前说好的，如果不知道，就选用的人多的）

3.复制代码，在中添加pom.xml文件，一开始复制过来，代码可能会红，这时只需等待几分钟，架包就下载好了

更新完pom.xml文件后，idea应该会自动下载相应的jar包（可能需要vpn），如果没有自动下载的话，可以点击“Reimport All Maven Projects”按钮进行项目的重新载入。如图所示。

4.下载完成后，我们可以在左侧架构看到，加载好的架包

第五步：配置插件（例如：tomcat）
servlet容器的配置和运行
servlet容器有两种配置方式。
配置本地的tomcat服务器
配置maven插件

配置本地的tomcat服务器
https://img-blog.csdn.net/20160723203403338
根据上图配置tomcat服务器，如果用这种方法，本地需要下载tomcat并配置好环境变量。

主要有以下几个要点

1.选择本地的tomcat容器。
2.可以选择修改访问路径。
3.On Update action 当我们按 Ctrl + F10 进行容器更新的时候，可以根据我们配置的这个事件内容进行容器更新。其中我选择的 Update classes and resources 事件是最常用的，表示我们在按 Ctrl + F10 进行容器更新的时候，我们触发更新编译的类和资源文件到容器中。
4.默认 Tomcat 的 HTTP 端口是 8080，如果你需要改其端口可以在这里设置。
5.在 Deployment 选项卡中添加了 Artifact。

部署项目到Tomcat

配置maven插件

maven插件的话有tomcat和jetty，两者都是servlet的容器。我这里配置的是jetty。插件已经在pom.xml中配置完成了。

org.eclipse.jetty jetty-maven-plugin 9.3.10.v20160621 再在idea中配置jetty。

https://img-blog.csdn.net/20160723204202624

又有一篇教程！
在pom.xml中

添加

第六步：运行

1.在右上角部分点击，选择Edit

2.在左上角选择绿色的加号，添加maven

3.配置信息，如果在Command line中敲入to,没有提示，说明插件没有配好

4.运行

在下方运行中有：

点击进入：如果出现UNknown request，说明端口被占用，去pom.xml配置tomcat的部分中，重新配置一个端口就可以

正常页面出现：

配置别的！
配置web.xml

maven默认生成的web.xml版本是2.3的，所以有些配置节点idea会识别不出来，因此我们重新添加一个3.0的。

<?xml version="1.0" encoding="UTF-8"?>

index.jsp

<!--配置springmvc DispatcherServlet-->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <!--Sources标注的文件夹下需要新建一个spring文件夹-->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

接收到的http请求通过DispatcherServlet进行分发。

配置contextConfigLocation文件

<?xml version="1.0" encoding="UTF-8"?>

context:annotation-config/

<!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
<context:component-scan base-package="com.zjut.ssm.controller">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--HandlerMapping 无需配置，springmvc可以默认启动-->

<!--静态资源映射-->
<!--本项目把静态资源放在了WEB-INF的statics目录下，资源映射如下-->
<mvc:resources mapping="/css/**" location="/WEB-INF/statics/css/"/>
<mvc:resources mapping="/js/**" location="/WEB-INF/statics/js/"/>
<mvc:resources mapping="/image/**" location="/WEB-INF/statics/image/"/>

<!--但是项目部署到linux下发现WEB-INF的静态资源会出现无法解析的情况，但是本地tomcat访问正常，因此建议还是直接把静态资源放在webapp的statics下，映射配置如下-->
<!--<mvc:resources mapping="/css/**" location="/statics/css/"/>-->
<!--<mvc:resources mapping="/js/**" location="/statics/js/"/>-->
<!--<mvc:resources mapping="/image/**" location="/statics/images/"/>-->

<!-- 配置注解驱动 可以将request参数与绑定到controller参数上 -->
<mvc:annotation-driven/>

<!-- 对模型视图名称的解析，即在模型视图名称添加前后缀(如果最后一个还是表示文件夹,则最后的斜杠不要漏了) 使用JSP-->
<!-- 默认的视图解析器 在上边的解析错误时使用 (默认使用html)- -->
<bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
    <property name="prefix" value="/WEB-INF/views/"/><!--设置JSP文件的目录位置-->
    <property name="suffix" value=".jsp"/>
</bean>

<!-- springmvc文件上传需要配置的节点-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="20971500"/>
    <property name="defaultEncoding" value="UTF-8"/>
    <property name="resolveLazily" value="true"/>
</bean>

配置log4j.properties

日志文件是debug中一个必不可少的工具，因此添加了log4j日志包。配置文件如下。

#配置根Logger 后面是若干个Appender
log4j.rootLogger=DEBUG,A1,R
#log4j.rootLogger=INFO,A1,R

ConsoleAppender 输出

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n

File 输出 一天一个文件,输出路径可以定制,一般在根路径下

log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File=log.txt
log4j.appender.R.MaxFileSize=500KB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n
controller和view的编写
在controller下新建一个“HomeController”。编写如下代码。

package com.zjut.ssm.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**

• @author Chingyu Mo

• @create 2016-07-23-20:20
  */
  // 注解标注此类为springmvc的controller，url映射为"/home"
  @Controller
  @RequestMapping("/home")
  public class HomeController {
  //添加一个日志器
  private static final Logger logger = LoggerFactory.getLogger(HomeController.class);

  //映射一个action
  @RequestMapping("/index")
  public String index(){
  //输出日志文件
  logger.info(“the first jsp pages”);
  //返回一个index.jsp这个视图
  return “index”;
  }
  }
  在views文件夹下建立一个jsp文件，名为“index.jsp”

基本的代码编写就完成了。
以上就是一个简单的Spring MVC应用在idea中的创建方式。

15、继承

1现状
Hello依赖的Junit：4.0
HelloFriend依赖的Junit：4.0
MakeFriends依赖的Junit：4.9

由于test范围的依赖不能传递，所以必然会分散在各个模块工程中，很容易造成版本不一致。

2需求：统一管理各个模块工程中对Junit依赖的版本。

3解决思路：将Junit依赖统一提取到“父”工程中，在子工程中声明Junit依赖是不指定版本，以父工程中统一设定的为准。同时也便于修改。

操作步骤：
①创建一个Maven工程作为父工程。注意：打包方式为pom

②在子工程中声明对父工程的引用

③将子工程的坐标中与父工程坐标中重复的内容删除

④在父工程中统一管理Junit的依赖

⑤在子工程中删除Junit依赖的版本号部分

注意：配置集成后，执行安装命令时要先安装父工程。

16、聚合

1作用：一键安装各个模块工程。
2配置方式：在一个“总的聚合工程”中配置各个参与聚合的模块

3使用方式：在聚合工程的pom.xml 上点右键->run as->maven install

17、Maven_Web工程的自动部署

在pom.xml 中添加如下配置：

  <!--配置当前工程构建过程中的特殊设置   -->
  <build>
    <finalName>AtguiguWeb</finalName>
    <!-- 配置构建过程中需要使用的插件 -->
    <plugins>
        <plugin>
            <!-- cargo是一家专门从事启动Servlet容器的组织 -->
            <groupId>org.codehaus.cargo</groupId>
            <artifactId>cargo-maven2-plugin</artifactId>
            <version>1.2.3</version>
            <!-- 针对插件进行的配置 -->
            <configuration>
                <!-- 配置当前系统中容器的位置 -->
                <container>
                    <containerId>tomcat6x</containerId>
                    <home>D:\DevInstall\apache-tomcat-6.0.39</home>
                </container>
                <configuration>
                    <type>existing</type>
                    <home>D:\DevInstall\apache-tomcat-6.0.39</home>
                    <!-- 如果Tomcat端口为默认值8080则不必设置该属性 -->
                    <properties>
                        <cargo.servlet.port>8989</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>

执行mvn deploy 命令

18、Maven 酷站

我们可以到 http://mvnrepository.com/搜索需要的 jar 包的依赖信息。

笔记：
我们在使用MAC时，Finder栏默认只显示当前浏览的文件夹名称，而没有显示访问路径，这个问题该怎么解决呢？
操作步骤：

打开“终端”（应用程序-》实用工具），输入以下两条命令：

defaults write com.apple.finder _FXShowPosixPathInTitle -bool TRUE;killall Finder

你看完整的路径地址出来了吧。

如何恢复默认状态呢？

打开“终端”（应用程序-》实用工具），输入以下两条命令：

defaults delete com.apple.finder _FXShowPosixPathInTitle;killall Finder

这就是如何在Finder栏上显示当前浏览文件的访问路径的方法，有需要或是有兴趣的用户，可以尝试下这种方法。