一个小时学会Maven

1、总体概述
   * maven的介绍
   * maven的安装配置
   * 创建maven工程
   * M2Eclipse插件--在eclipse中创建maven工程
   * maven的核心概念
       - 坐标、依赖管理、生命周期、插件、继承、聚合
   * maven的仓库管理

2、maven的介绍
   * 以前的java工程都是动态web工程，以后都是maven工程
   * 什么是maven
       - Maven是基于POM（工程对象模型），通过一小段描述来对项目的代码、报告、文件进行管理的工具。
       - Maven是一个跨平台的【项目管理工具】，它是使用java开发的，它要依赖于jdk1.6及以上
       - Maven主要有两大功能：【依赖管理、项目构建】。
           ** 依赖指的就是jar包。
           ** 什么是构建：编译、打包、部署
   * 项目构建的方式
       - 使用eclipse进行项目构建，相对来说，步骤比较零散，不好操作
       - Ant：它是一个专门的项目构建工具，它可以通过一些配置来完成项目构建，这些配置要明确地告诉ant，源码包在哪？
          目标class文件应该放在哪？资源文件应该在哪？
       - maven：它是一个项目管理工具，也是一个项目构建工具，通过使用maven，可以对项目进行快速简单的构建，
          它不需要告诉maven很多信息，但是需要按照maven的规范去进行代码的开发。
          也就是说maven是有约束的。

3、maven的安装和配置
   * 下载maven：官方网站：http://maven.apache.org
   * 本课程使用的maven的版本为3.0.5
   * Maven是使用java开发，需要安装jdk1.6以上，推荐使用1.7

   * 以后的IDE一般都自带maven，但是我们要知道，如果IDE没有自带maven，应该如果操作
   * 安装maven
       - 第一步：安装JDK1.6及以上
       - 第二步：下载maven压缩包，解压
       - 第三步：配置maven的环境变量PATH
       - 第四步：测试 mvn -v
   * 配置maven
       - 在maven中有两个配置文件：用户配置、全局配置（默认）
       - 全局配置
           ** 在maven安装目录的conf里面有一个settings.xml文件，这个文件就是maven的全局配置文件。
               该文件中配置maven本地仓库的地址
           ** 本地仓库默认为：系统的用户目录下的~/.m2/repository。（~表示用户目录）
       - 用户配置
           ** 用户配置文件的地址：~/.m2/settings.xml，该文件默认是没有，需要将全局配置文件拷贝一份到该目录下。
           ** 重新指定本地仓库地址，如果不指定，则默认是~/.m2/repository目录，如果用户配置文件不存在，
               则使用全局配置文件的配置。
               <localRepository>D:\javadevelop\maven\repository</localRepository>

4.创建maven工程（手动创建）
   * maven工程结构（规范）
      Project
       |--src（源码包）
           |--main（正常的源码包）
               |--java（.java文件的目录）
               |--resources（资源文件的目录）
           |--test（测试的源码包）
               |--java
               |--resources
       |--target（class文件、报告等信息存储的地方）
       |--pom.xml（maven工程的描述文件）

   * 第一步：根据maven的目录结构创建helloMaven工程
   * 第二步：创建HelloWorld.java
       package com.itheima.maven;
       public class HelloWorld {
           public String sayHello(String name) {
               return "hello " + name;
           }
       }
   * 第三步：创建TestHelloWorld.java
       package com.itheima.maven;
       import org.junit.Test;
       import static junit.framework.Assert.*;
       public class TestHelloWorld {
           @Test
           public void testSayHello() {
               HelloWorld hw = new HelloWorld();
               String result = hw.sayHello("zs");
               assertEquals("hello zs",result);
           }
       }
   * 第四步：配置pom.xml
       <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.itheima.maven</groupId>
       
       <artifactId>HelloWorld</artifactId>
       
       
       <version>0.0.1</version>
       
       <name>Hello</name>

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

       </dependencies>
       </project>

5.maven命令的使用
   * maven的命令要在pom.xml所在目录中去执行

   * mvn compile:编译
   * mvn clean:清除命令，清除已经编译好的class文件，具体说清除的是target目录中的文件
   * mvn test:测试命令，该命令会将test目录中的源码进行编译
   * mvn package:打包命令
   * mvn install:安装命令，会将打好的包安装到本地仓库

   * 组合命令
       - mvn clean compile:先清空再编译
       - mvn clean test命令
           cmd 中录入 mvn clean test命令
           组合指令，先执行clean，再执行test，通常应用于测试环节

       - mvn clean package命令
           cmd 中录入 mvn clean package命令
           组合指令，先执行clean，再执行package，将项目打包，通常应用于发布前
           执行过程：
               清理————清空环境
               编译————编译源码
               测试————测试源码
               打包————将编译的非测试类打包

       - mvn clean install命令
           cmd 中录入 mvn clean install 查看仓库，当前项目被发布到仓库中
               组合指令，先执行clean，再执行install，将项目打包，通常应用于发布前
               执行过程：
                   清理————清空环境
                   编译————编译源码
                   测试————测试源码
                   打包————将编译的非测试类打包
                   部署————将打好的包发布到资源仓库中

6.M2Eclipse的安装和配置
   * 低版本的eclipse没有集成M2Eclipse插件，需要自己安装
   * 高版本的eclipse自带了该插件
   * 安装方法：将文件夹m2e和m2e-extras复制到eclipse的dropins目录
   * 然后可以通过eclipse--window--preferences查看是否有maven
   * eclipse配置maven
       - preferences--maven--installaions,添加本地maven
       - 将本用户的settings.xml文件剪切到本地仓库同级目录下，并在preperences--maven--user settings下配置
          本用户的settings.xml的地址，记得update settings

7.使用eclipse骨架创建maven工程
   * 创建maven工程前，先确定maven配置是否正确
       - preferences查看user settings，是否设置使用自己安装的maven
       - user settings设置本地配置文件为：C:\Users\oy\.m2\settings.xml
       - 本地配置文件settings.xml中配置了本地仓库<localRepository>D:\javadevelop\maven\repository</localRepository>
       - 本地仓库的地址D:\javadevelop\maven\repository

   * 在eclipse--new--maven--maven project，next，指定maven工程的location，点击下一步，
      如果此时已联网，会要求select an archetype(选择骨架)，java工程选择maven-archetype-quickstart，
      web工程选择maven-archetype-webapp，点击next，填写GAV坐标，比如groupId=com.itheima.maven,artifactId=hellojava,
      version=0.0.1-SNAPSHOT;包名默认是 groupId+artifactId，一般可以删除artifactId

   * 默认没有resources目录，需要自己手动添加
   * 默认添加了junit 3.8.1，需要自己手动在pom.xml中修改为4.12
   * 选中maven项目(或pom.xml)，右键run as，选中maven命令
   * 右键run as--maven build...，在弹框中，Goals文本框中输入命令，省略mvn，比如:compile，而不是mvn compile

8.通过非骨架创建maven工程
   * 若没有联网，在eclipse--new--maven--maven project，next之后，选中create a simple project(skip archetype selection)
   * 打包方式jar创建普通java工程，打包方式为war则创建web工程
   * 默认有resources目录
   * 包需要自己创建

   * 如果想要使用自己之前打包的jar
       - 首先之前打包的jar要install，添加到本地仓库
       - 然后可以在maven的pom.xml文件中添加依赖，然后就可以在本项目中使用
       <dependencies>
           
           <dependency>
               
               <groupId>junit</groupId>
               
               <artifactId>junit</artifactId>
               
               <version>4.12</version>
               
               <scope>test</scope>
           </dependency>

           <dependency>
               <groupId>com.itheima.maven</groupId>
               <artifactId>hellojava</artifactId>
               <version>0.0.1-SNAPSHOT</version>
           </dependency>

       </dependencies>

9.maven核心概念--坐标
   * maven世界有大量构建，需要一个唯一标识来标识构建
   *    GAV：
       
       <groupId>junit</groupId>
       
       <artifactId>junit</artifactId>
       
       <version>4.12</version>
       
       <scope>test</scope>

10.依赖管理
   * 依赖范围 <scope>compile|test|provided|runtime</scope>默认是compile
       - 依赖范围scope:用来控制依赖和编译，测试，运行的classpath的关系
       - scope的取值：
           1）compile：默认编译依赖范围。对于编译，测试，运行三种classpath都有效
           2）test：测试依赖范围。只对于测试classpath有效
           3）provided：已提供依赖范围。对于编译，测试的classpath都有效，但对于运行无效（即不会将该依赖打包到jar）。因为由容器已经提供，例如servlet-api
           4）runtime:运行时提供。例如:jdbc驱动

   * 依赖传递
       - <scope>compile</scope>的依赖会一直传递
       - 总结，见word文档
           当第二依赖的范围是compile的时候，传递性依赖的范围与第一直接依赖的范围一致。
           当第二直接依赖的范围是test的时候，依赖不会得以传递。
           当第二依赖的范围是provided的时候，只传递第一直接依赖范围也为provided的依赖，且传递性依赖的范围同样为 provided；
           当第二直接依赖的范围是runtime的时候，传递性依赖的范围与第一直接依赖的范围一致，但compile例外，此时传递的依赖范围为runtime；

   * 依赖冲突
       - 在maven中存在两种冲突方式：一种是跨pom文件的冲突，一致是同一个pom文件中的冲突。
       - 跨pom文件的冲突
           ** MavenThird依赖MavenSecond，MavenSecond依赖MavenFirst，MavenFirst的pom文件中依赖来junit的4.9版本，
              如果MavenSecond中重新依赖junit的4.8版本，那么MavenSecond和MavenThird中都是使用了4.8本，这体现来依赖的就近使用原则。
       - 同一个pom文件的冲突：下面是例子，pom文件按照就近原则，越下面的也近（可以理解为下面的把上面的覆盖）
           <dependencies>
               <dependency>
                   <groupId>junit</groupId>
                   <artifactId>junit</artifactId>
                   <version>4.9</version>
               </dependency>
               <dependency>
                   <groupId>junit</groupId>
                   <artifactId>junit</artifactId>
                   <version>4.8</version>
               </dependency>
           </dependencies>

   * 可选依赖
       - Optional标签标示该依赖是否可选，默认是false。可以理解为，如果为true，则表示该依赖不会传递下去，如果为false，则会传递下去。
           <groupId>com.itheima.maven</groupId>
           <artifactId>hellojava</artifactId>
           <version>0.0.1-SNAPSHOT</version>
           <optional>默认false，表示该依赖会传递下去</optional>

   * 排除依赖
       - Exclusions标签可以排除依赖
           <dependencies>
               <groupId>com.itheima.maven</groupId>
               <artifactId>MavenSecond</artifactId>
               <version>0.0.1-SNAPSHOT</version>

               <exclusions>
                   <exclusion>
                       <groupId>com.itheima.maven</groupId>
                       <artifactId>MavenFirst</artifactId>
                   <exclusion>
               </exclusions>
           </dependencies>

11.生命周期
   * Maven有三个生命周期：clean生命周期、default生命周期、site生命周期
   * clean生命周期：分三个阶段
       pre-clean 执行一些需要在clean之前完成的工作
       【clean】移除所有上一次构建生成的文件
       post-clean 执行一些需要在clean之后立刻完成的工作
   * 在maven中，只要在同一个【生命周期】，你执行后面的【阶段】，那么前面的阶段也会被执行

   * default生命周期（重点）
       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 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。

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

12.插件
   * 插件（plugin），每个插件都能实现一个阶段的功能。Maven的核心是生命周期，生命周期指定了maven命令执行的流程顺序，
      但没有真正实现流程的功能，功能是由插件来实现的。
   * 比如：compile就是一个插件maven-compile-plugin实现的功能。

   * 编译插件
       <build>与</dependencies>标签同级
           <plugins>
               <plugin>   编译插件，编译用的jdk版本
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <configuration>
                       <source>1.7</source>
                       <target>1.7</target>
                       <encoding>UTF-8</encoding>
                   </configutation>
               </plugin>
           </plugins>
       </build>

   * tomcat插件
       - 创建maven的web工程
           ** 先创建一个web工程，注意：打包方式选择war
           ** 点击finish创建maven工程；然后，在webapp目录下创建WEB-INF及web.xml文件
           ** 在webapp下创建index.jsp文件
       - 使用tomcat插件运行web工程
           ** 默认输入tomcat:run去使用tomcat插件来启动web工程，但是默认的tomcat插件使用的tomcat版本是tomcat6
           ** 而目前主流的tomcat，是使用的tomcat7，需要手动配置tomcat插件,使用tomcat7来运行web工程，
              它的命令是：tomcat7:run
       <build>
           <plugins>
               <plugin>   tomcat7插件的配置
                   <groupId>org.apache.tomcat.maven</groupId>
                   <artifactId>tomcat7-maven-plugin</artifactId>
                   <configuration>
                       <port>8080</port>
                       <path>/</path>
                   </configuration>
               </plugin>
           </plugins>
       </build>

13.继承
   * 在maven中继承，指的是pom文件的继承
   * 创建父工程
       - 父工程打包方式必须是：pom
   * 创建子工程：创建子工程有两种方式：一种是创建一个新的工程为子工程，另一种是修改老的工程为子工程。
       子工程继承父工程的标识：在子工程的GAV上面写有配置
       <parent>
           <groupId>
           <artifactId>
           <version>
       </parent>

   * 父工程统一依赖jar包
       - 在父工程中对jar包进行依赖，在子工程中都会继承此依赖。

   * 父工程统一管理版本号
       - dependencyManagement标签管理的依赖，其实没有真正依赖，它只是管理依赖的版本。
       父工程的pom文件：
           <dependencyManagement>
               <dependencies>
                   <dependency>
                       <groupId>junit</groupId>
                       <artifactId>junit</artifactId>
                       <version>4.9</version>
                   </dependency>
               </dependencies>
           </dependencyManagement>
       子工程的pom文件：在子工程中使用父工程管理的版本号，此时不需指定version
           <dependencies>
               <dependency>
                   <groupId>junit</groupId>
                   <artifactId>junit</artifactId>
               </dependency>
           </dependencies>

   * 父工程抽取版本号
       <properties>
           <junit.version>4.9</junit.version>   //<junit.version>这个标签名自己指定的
       </properties>

       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>junit</groupId>
                   <artifactId>junit</artifactId>
                   <version>${junit.version}</version>
               </dependency>
           </dependencies>
       </dependencyManagement>

14.聚合
   * 在真实项目中，一个项目有表现层、业务层、持久层，对于业务层和持久层，
      它们可以在多个工程中被使用，所以一般会将业务层和持久单独创建为java工程，为其他工程依赖。

   * 第一步：创建一个Maven Project作为聚合工程，即作为父工程；使用pom打包方式
   * 第二步：先选中父工程，然后new，创建Maven Module作为子工程，该子工程继承父工程
       业务层、持久层使用jar打包
       表现层使用war打包
   * 第三步：在聚合工程中配置tomcat7的插件，运行tomcat

15.Maven仓库管理
   * 什么是Maven仓库？
       - 用来统一存储所有Maven共享构建的位置就是仓库。根据Maven坐标定义每个构建在仓库中唯一存储路径
          大致为：groupId/artifactId/version/artifactId-version.packaging
   * 本地仓库
       - 默认在~/.m2/repository，如果在用户配置中有配置，则以用户配置的地址为准
   * 中央仓库
       - http://repo1.maven.org/maven2
   * 私服

16.Maven私服
   * Nexus
       - 为所有来自中央仓库的构建安装提供本地缓存。
       - 下载网站：http://nexus.sonatype.org/
       - 安装版本：nexus-2.7.0-06.war
   * Nexus安装步骤
       * 第一步：安装tomcat
       * 第二步：将nexus的war包拷贝到tomcat的webapps下
       * 第三步：第三步：启动tomcat
       * 第四步：nexus的本地目录为：本地用户下sonoatype-work

   * 访问Nexus
           访问URL: http://localhost:8080/nexus-2.7.0-06/
           默认账号:
           用户名： admin
           密码： admin123
   * Nexus的仓库和仓库组介绍:
       - 3rd party: 一个策略为Release的宿主类型仓库，用来部署无法从公共仓库获得的第三方发布版本构建
       - Apache Snapshots: 一个策略为Snapshot的代理仓库，用来代理Apache Maven仓库的快照版本构建
       - Central: 代理Maven中央仓库
       - Central M1 shadow: 代理Maven1 版本中央仓库
       - Codehaus Snapshots: 一个策略为Snapshot的代理仓库，用来代理Codehaus Maven仓库的快照版本构件
       - Releases: 一个策略为Release的宿主类型仓库，用来部署组织内部的发布版本构件
       - Snapshots: 一个策略为Snapshot的宿主类型仓库，用来部署组织内部的快照版本构件
       - 【Public Repositories】:该仓库组将上述所有策略为Release的仓库聚合并通过一致的地址提供服务

   * 点击Central，然后修改configuration--download remote indexes=true
   * 配置Public Repositories

   * 配置所有构建均从私服下载
       在本地仓库的setting.xml中配置如下：
       <mirrors>
           <mirror>
               
               <id>nexus</id>
               <mirrorOf>*</mirrorOf>
               <url>http://localhost:8080/nexus-2.7.0-06/content/groups/public/</url>
           </mirror>
       </mirrors>

   * 配置：部署构建到Nexus
       - 第一步：Nexus的访问权限控制
           在本地仓库的setting.xml中配置如下：
               <server>
                   <id>releases</id>
                   <username>admin</username>
                   <password>admin123</password>
               </server>
               <server>
                   <id>snapshots</id>
                   <username>admin</username>
                   <password>admin123</password>
               </server>
       - 第二步：配置pom文件
           在需要构建的项目中修改pom文件
           <distributionManagement>
                   <repository>
                       <id>releases</id>
                       <name>Internal Releases</name>
                       <url>http://localhost:8080/nexus-2.7.0-06/content/repositories/releases/</url>
                   </repository>
                   <snapshotRepository>
                       <id>snapshots</id>
                       <name>Internal Snapshots</name>
                       <url>http://localhost:8080/nexus-2.7.0-06/content/repositories/snapshots/</url>
                   </snapshotRepository>
               </distributionManagement>

       - 第三步：执行maven的deploy命令

posted on 2020-04-28 19:01 wenbin_ouyang 阅读(230) 评论(0) 编辑收藏举报

刷新页面返回顶部

木心

导航

公告

一个小时学会Maven