Maven02 -学习总结&学习文档 -踩坑123

1. maven在开发中的作用
   1. 　　①自动添加第三方 jar 包

      在今天的 JavaEE 开发领域，有大量的第三方框架和工具可以供我们使用。要使用这些 jar 包最简单的方法就是复制粘贴到 WEB-INF/lib 目录下。但是这会导致每次创建一个新的工程就需要将 jar 包重复复制到 lib 目录下，从而造成工作区中存在大量重复的文件，让我们的工程显得很臃肿。

      而使用 Maven 后每个 jar 包本身只在本地仓库中保存一份，需要 jar 包的工程只需要以坐标的方式简单的引用一下就可以了。不仅极大的节约了存储空间，让项目更轻巧，更避免了重复文件太多而造成的混乱。

      ②解决jar 包之间的依赖关系

      jar 包往往不是孤立存在的，很多 jar 包都需要在其他 jar 包的支持下才能够正常工作，我们称之为jar 包之间的依赖关系。最典型的例子是：commons-fileupload-1.3.jar 依赖于 commons-io-2.0.1.jar，如果没有 IO 包，FileUpload 包就不能正常工作。

   2. ③获取第三方 jar 包

      JavaEE 开发中需要使用到的 jar 包种类繁多，几乎每个 jar 包在其本身的官网上的获取方式都不尽相同。为了查找一个 jar 包找遍互联网，身心俱疲，没有经历过的人或许体会不到这种折磨。不仅如此， 费劲心血找的 jar 包里有的时候并没有你需要的那个类，又或者又同名的类没有你要的方法——以不规范的方式获取的 jar 包也往往是不规范的。

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

      ——规范、完整、准确！一次性解决所有问题！

      ---

2. maven的定义及标准开发流程
   1. 　　Maven 是Apache 软件基金会组织维护的一款自动化构建工具，专注服务于 Java 平台的项目构建和依赖管理。Maven 这个单词的本意是：专家，内行。读音是['meɪv(ə)n]或['mevn]。

   2. 构建过程的几个主要环节

      ①清理：删除以前的编译结果，为重新编译做好准备。

      ②编译：将 Java 源程序编译为字节码文件。

      ③测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性;自动调用junit程序.

      ④报告：在每一次测试后以标准的格式记录和展示测试结果。

      ⑤打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包，Web 工程对应war 包。

      ⑥安装：在 Maven 环境下特指将打包的结果——jar 包或war 包,安装到本地仓库中。

      ⑦部署：将打包的结果部署到远程仓库或将 war 包部署到服务器上运行。

      ---

3. IDEA 开发maven工程 的那些坑
   1. 在总的聚合工程中使用 modules/module 标签组合，指定模块工程的相对路径即可
   2. 这样可以在idea中将所有关联的模块,放到一个页面
   3. 

   4. 在总的聚合工程中使用 modules/module 标签组合，指定模块工程的相对路径即可

      <modules>
      <module>../Hello</module>
      <module>../HelloFriend</module>
      <module>../MakeFriends</module>
      </modules>

   5.强烈推荐:  使用IDEA创建maven父子工程项目

   - 父子工程中子工程为Maven的web项目
   1. 　CSDN博客    https://www.cnblogs.com/tibit/p/6185704.html
   2. 统一管理所依赖 jar 包的版本 -- 自定义标签管理版本号

   1. 依赖的原则：解决 jar 包冲突

      [1] 路径最短者优先

      [2] 路径相同时先声明者优先

      ---

4. maven资源站
   1. 　　

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

      ---

5. maven不重要的点
   1. 　　Web工程自动部署 ,直接编译器启动多好
      

      ---

6. [尚硅谷封捷]_Maven02操作指南
   1. 　完整操作　

      1.解压部署Maven核心程序
          ①检查JAVA_HOME环境变量
              C:\Windows\System32>echo %JAVA_HOME%
              D:\DevInstall\jdk1.7.0_07
          ②解压Maven的核心程序
              将apache-maven-3.2.2-bin.zip解压到一个非中文无空格的目录下。例如：
                  D:\DevInstall\apache-maven-3.2.2
          ③配置环境变量
              M2_HOME D:\DevInstall\apache-maven-3.2.2
              path    D:\DevInstall\apache-maven-3.2.2\bin
          ④查看Maven版本信息验证安装是否正确
              C:\Windows\System32>mvn -v
              Apache Maven 3.2.2 (45f7c06d68e745d05611f7fd14efb6594181933e; 2014-06-17T21:51:42+08:00)
              Maven home: D:\DevInstall\apache-maven-3.2.2\bin\..
              Java version: 1.7.0_07, vendor: Oracle Corporation
              Java home: D:\DevInstall\jdk1.7.0_07\jre
              Default locale: zh_CN, platform encoding: GBK
              OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"
      2.修改本地仓库
          ①默认本地仓库位置：~\.m2\repository
              ~表示当前用户的家目录，例如：C:\Users\[你当前登录系统的用户名]
          ②指定本地仓库位置的配置信息文件：apache-maven-3.2.2\conf\settings.xml
          ③在根标签settings下添加如下内容：<localRepository>[本地仓库路径，也就是RepMaven.zip的解压目录]</localRepository>
      3.第一个Maven工程
          ①目录结构
              Hello
              |---src
              |---|---main
              |---|---|---java
              |---|---|---resources
              |---|---test
              |---|---|---java
              |---|---|---resources
              |---pom.xml
      
          ②POM文件内容
      <?xml version="1.0" ?>
      <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.atguigu.maven</groupId>
          <artifactId>Hello</artifactId>
          <version>0.0.1-SNAPSHOT</version>
      
          <name>Hello</name>
      
          <dependencies>
              <dependency>
                  <groupId>junit</groupId>
                  <artifactId>junit</artifactId>
                  <version>4.0</version>
                  <scope>test</scope>
              </dependency>
          </dependencies>
      </project>
          ③编写主程序代码
              在src/main/java/com/atguigu/maven目录下新建文件Hello.java，内容如下
              package com.atguigu.maven;
              public class Hello {
                  public String sayHello(String name){
                      return "Hello "+name+"!";
                  }
              }
          ④编写测试代码
              在/src/test/java/com/atguigu/maven目录下新建测试文件HelloTest.java
              package com.atguigu.maven;
              import org.junit.Test;
              import static junit.framework.Assert.*;
              public class HelloTest {
                  @Test
                  public void testHello(){
                      Hello hello = new Hello();
                      String results = hello.sayHello("litingwei");
                      assertEquals("Hello litingwei!",results);
                  }
              }
          ⑤运行几个基本的Maven命令前,一定要进入pom.xml文件所在的目录！
              mvn compile 编译
              mvn clean    清理
              mvn test    测试
              mvn package 打包
              ※注意：运行Maven命令时一定要进入pom.xml文件所在的目录！
          ⑥ 关于联网的问题
              1.Maven的核心程序中仅仅定义了抽象的生命周期,但是具体的工作是由特定的
      
      4.第二个Maven工程
          ①工程名：HelloFriend
          ②目录结构与第一个Maven工程相同
          ③POM文件
      <?xml version="1.0" ?>
      <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.atguigu.maven</groupId>
          <artifactId>HelloFriend</artifactId>
          <version>0.0.1-SNAPSHOT</version>
          <name>HelloFriend</name>
      
          <dependencies>
              <dependency>
                  <groupId>junit</groupId>
                  <artifactId>junit</artifactId>
                  <version>4.0</version>
                  <scope>test</scope>
              </dependency>        
      
              <dependency>
                  <groupId>com.atguigu.maven</groupId>
                  <artifactId>Hello</artifactId>
                  <version>0.0.1-SNAPSHOT</version>
                  <scope>compile</scope>
              </dependency>
      
          </dependencies>
      </project>
          ④主程序：在src/main/java/com/atguigu/maven目录下新建文件HelloFriend.java
              package com.atguigu.maven;
              import com.atguigu.maven.Hello;
              public class HelloFriend {
                  public String sayHelloToFriend(String name){
                      Hello hello = new Hello();
                      String str = hello.sayHello(name)+" I am "+this.getMyName();
                      System.out.println(str);
                      return str;
                  }
                  public String getMyName(){
                      return "John";
                  }
              }
          ⑤测试程序：在/src/test/java/com/atguigu/maven目录下新建测试文件HelloFriendTest.java
              package com.atguigu.maven;
              import static junit.framework.Assert.assertEquals;
              import org.junit.Test;
              import com.atguigu.maven.Hello;
      
              public class HelloFriendTest {
                  @Test
                  public void testHelloFriend(){
                      HelloFriend helloFriend = new HelloFriend();
                      String results = helloFriend.sayHelloToFriend("litingwei");
                      assertEquals("Hello litingwei! I am John",results);
                  }
              }
          ⑥运行Maven命令
              mvn install    安装
      5.第三个Maven工程
          ①设置通过Maven创建的工程的JDK版本——一劳永逸
              [1]打开settings.xml文件
              [2]找到profiles标签
              [3]加入如下配置
                  <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>
          ②工程坐标
              groupId：com.atguigu.maven
              ArtifactId：MakeFriends
              Package：com.atguigu.maven
          ③在src/main/java中新建类com.atguigu.maven.MakeFriends
              public String makeFriends(String name){
                  HelloFriend friend = new HelloFriend();
                  friend.sayHelloToFriend("litingwei");
                  String str = "Hey,"+friend.getMyName()+" make a friend please.";
                  System.out.println(str);
                  return str;
              }
          ④在src/test/java中新建类com.atguigu.maven.MakeFriendsTest
              package com.atguigu.maven;
              import static junit.framework.Assert.assertEquals;
              import org.junit.Test;
              public class MakeFriendsTest {
                  @Test
                  public void testMakeFriends(){
                      MakeFriends makeFriend = new MakeFriends();
                      String str = makeFriend.makeFriends("litingwei");
                      assertEquals("Hey,John make a friend please.",str);
                  }
              }
          ⑤添加依赖信息
              <dependency>
                  <groupId>junit</groupId>
                  <artifactId>junit</artifactId>
                  <version>4.9</version>
                  <scope>test</scope>
              </dependency>
              <dependency>
                  <groupId>com.atguigu.maven</groupId>
                  <artifactId>HelloFriend</artifactId>
                  <version>0.0.1-SNAPSHOT</version>
                  <type>jar</type>
                  <scope>compile</scope>
              </dependency>
          ⑥在Eclipse环境下执行Maven命令：右击pom.xml选择run as 中的命令执行即可
      6.测试依赖的范围对传递性的影响
          ①在Hello中添加对spring-core的依赖
              <dependency>
                  <groupId>org.springframework</groupId>
                  <artifactId>spring-core</artifactId>
                  <version>4.0.0.RELEASE</version>
                  <scope>compile</scope>
              </dependency>
          ②在HelloFriend中查看spring-core是否被加入了运行时环境
          ③将Hello中对spring-core的依赖范围修改为test，再到HelloFriend中检查
          ④将Hello中对spring-core的依赖范围修改为provided，再到HelloFriend中检查
          ⑤结论：非compile范围的依赖不能传递，必须在有需要的工程中单独加入
      7.测试依赖原则
          ①路径最短者优先
              [1]在Hello中依赖log4j-1.2.17
                  <dependency>
                      <groupId>log4j</groupId>
                      <artifactId>log4j</artifactId>
                      <version>1.2.17</version>
                  </dependency>
      
              [2]在HelloFriend中依赖log4j-1.2.14
                  <dependency>
                      <groupId>log4j</groupId>
                      <artifactId>log4j</artifactId>
                      <version>1.2.14</version>
                  </dependency>
              [3]查看MakeFriends中自动引入的log4j是哪个版本
      
          ②路径相同时先声明者优先
              [1]创建OurFriends工程，依赖log4j-1.2.17
              [2]让MakeFriends依赖OurFriends
              [3]测试MakeFriends中，HelloFriend和OurFriends依赖的先后顺序和引入的log4j版本之间的关系
      8.创建Web工程
          ①ServletAPI依赖
              <dependency>
                  <groupId>javax.servlet</groupId>
                  <artifactId>servlet-api</artifactId>
                  <version>2.5</version>
                  <scope>provided</scope>
              </dependency>
          ②JSPAPI依赖
              <dependency>
                  <groupId>javax.servlet.jsp</groupId>
                  <artifactId>jsp-api</artifactId>
                  <version>2.1.3-b06</version>
                  <scope>provided</scope>
              </dependency>
      9.Web工程自动部署
          <build>
              <finalName>AtguiguWeb</finalName>
              <plugins>
                  <plugin>
                      <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>
      10.继承
          ①创建Parent工程，打包方式为pom
          ②收集所有非compile范围的依赖信息，使用dependencyManagement标签统一管理
              <dependencyManagement>
                  <dependencies>
                      <dependency>
                          <groupId>junit</groupId>
                          <artifactId>junit</artifactId>
                          <version>4.9</version>
                          <scope>test</scope>
                      </dependency>
                  </dependencies>
              </dependencyManagement>
          ③在各个子工程中引用父工程
              <parent>
                  <groupId>com.atguigu.maven</groupId>
                  <artifactId>Parent</artifactId>
                  <version>0.0.1-SNAPSHOT</version>
      
                  <!-- 以当前文件为基准查找父工程中pom.xml文件的相对路径 -->
                  <relativePath>../Parent/pom.xml</relativePath>
              </parent>
          ④删除子工程中的重复信息
              groupId
              artifactid
          ⑤在子工程中找到被父工程管理的依赖信息，删除版本号部分
          ⑥在父工程中统一修改已管理的依赖信息的版本号，看是否能够控制所有子工程
      11.聚合
          在总的聚合工程中加入如下信息
          <modules>
              <module>../Hello</module>
              <module>../HelloFriend</module>
              <module>../MakeFriends</module>
          </modules>