maven_maven3 - CSDN
maven 订阅
Maven项目对象模型(POM),可以通过一小段描述信息来管理项目的构建,报告和文档的项目管理工具软件。Maven 除了以程序构建能力为特色之外,还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性,所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法,许多 Apache Jakarta 项目发文时使用 Maven,而且公司项目采用 Maven 的比例在持续增长。Maven这个单词来自于意第绪语(犹太语),意为知识的积累,最初在Jakata Turbine项目中用来简化构建过程。当时有一些项目(有各自Ant build文件),仅有细微的差别,而JAR文件都由CVS来维护。于是希望有一种标准化的方式构建项目,一个清晰的方式定义项目的组成,一个容易的方式发布项目的信息,以及一种简单的方式在多个项目中共享JARs。 [1] 展开全文
Maven项目对象模型(POM),可以通过一小段描述信息来管理项目的构建,报告和文档的项目管理工具软件。Maven 除了以程序构建能力为特色之外,还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性,所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法,许多 Apache Jakarta 项目发文时使用 Maven,而且公司项目采用 Maven 的比例在持续增长。Maven这个单词来自于意第绪语(犹太语),意为知识的积累,最初在Jakata Turbine项目中用来简化构建过程。当时有一些项目(有各自Ant build文件),仅有细微的差别,而JAR文件都由CVS来维护。于是希望有一种标准化的方式构建项目,一个清晰的方式定义项目的组成,一个容易的方式发布项目的信息,以及一种简单的方式在多个项目中共享JARs。 [1]
信息
本    质
项目对象模型
定    义
项目构建管理
分    类
java
中文名
麦文
外文名
Maven
Maven特点
那么,Maven 和 Ant 有什么不同呢?在回答这个问题以前,首先要强调一点:Maven 和 Ant 针对构建问题的两个不同方面。Ant 为 Java 技术开发项目提供跨平台构建任务。Maven 本身描述项目的高级方面,它从 Ant 借用了绝大多数构建任务。因此,由于 Maven 和 Ant代表两个差异很大的工具,所以接下来只说明这两个工具的等同组件之间的区别,如表 1 所示。 [1]  Maven是一个项目管理工具,它包含了一个项目对象模型 (Project Object Model),一组标准集合,一个项目生命周期(Project Lifecycle),一个依赖管理系统(Dependency Management System),和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。当你使用Maven的时候,你用一个明确定义的项目对象模型来描述你的项目,然后Maven可以应用横切的逻辑,这些逻辑来自一组共享的(或者自定义的)插件。Maven 有一个生命周期,当你运行 mvn install 的时候被调用。这条命令告诉 Maven 执行一系列的有序的步骤,直到到达你指定的生命周期。遍历生命周期旅途中的一个影响就是,Maven 运行了许多默认的插件目标,这些目标完成了像编译和创建一个 JAR 文件这样的工作。此外,Maven能够很方便的帮你管理项目报告,生成站点,管理JAR文件,等等。
收起全文
  • Maven项目管理实战

    2020-06-01 13:11:29
    Maven作为一个非常优秀的项目构建工具,在项目开发中得到了广泛的应用。在实际的应用开发中,我们基本不可能找到一个没有采用Maven技术来构建的项目。Maven这个工具的作用,说的最简单一点,就是它能够自动帮你下载...
  • 课程目标:帮助学员快速掌握Maven入门到进阶内容:1.坐标仓库私服 2.插件测试 3.项目原型 4.属性配置 课程亮点:以笔记为导向,一条笔记至少包含一个知识点,200多条笔记帮助学员快速掌握Maven200多个知识点 课程...
  • maven详解

    2018-10-14 13:39:14
    什么是Maven 优势 约定优于配置 使用简单 支持测试 构建简单 CI 插件丰富 下载安装 下载很简单,主要讲一下如何配置环境变量 配置MAVEN_HOME为Maven安装目录 Path中添加 ;%MAVEN_HOME%\bin; Maven加载settings...

    什么是Maven

    优势

    • 约定优于配置
    • 使用简单
    • 支持测试
    • 构建简单
    • CI
    • 插件丰富

    下载安装

    下载很简单,主要讲一下如何配置环境变量

    • 配置MAVEN_HOME为Maven安装目录
    • Path中添加 ;%MAVEN_HOME%\bin;

    Maven加载settings顺序

    maven会加载settings.xml文件,可定义在多处,它的加载优先级如下:

    1. 用户目录下 .m2/settings.xml
    2. maven安装目录conf/settings.xml (里面有很多推荐配置)

    新建Maven项目结构

    在这里插入图片描述

    Maven结构

    setting.xml元素

    <?xml version="1.0" encoding="UTF-8"?>
    <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>/path/to/local/repo</localRepository>
      
    
      <pluginGroups>
        <pluginGroup>com.your.plugins</pluginGroup>
      </pluginGroups>
    
     
      <servers>
        <server>
          <id>deploymentRepo</id>
          <username>repouser</username>
          <password>repopwd</password>
        </server>
      </servers>
     
      <mirrors>
    	<mirror>
          <id>alimaven</id>
          <name>aliyun maven</name>
          <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
          <mirrorOf>central</mirrorOf>        
        </mirror> 
      </mirrors>
    
        
      <profiles>
        <profile>
          <id>jdk-1.4</id>
    
          <activation>
            <jdk>1.4</jdk>
          </activation>
    
          <repositories>
            <repository>
              <id>jdk14</id>
              <name>Repository for JDK 1.4 builds</name>
              <url>http://www.myhost.com/maven/jdk14</url>
              <layout>default</layout>
              <snapshotPolicy>always</snapshotPolicy>
            </repository>
          </repositories>
        </profile>
      </profiles>
    
      <activeProfiles>
        <activeProfile>alwaysActiveProfile</activeProfile>
        <activeProfile>anotherAlwaysActiveProfile</activeProfile>
      </activeProfiles>
      
    </settings>
    
    
    

    localRepository

    定义repository下载的目录

    pluginGroups

    用于注册自定义插件

    servers

    配置私服的用户名和密码

    mirrors

    配置下载maven jar包的镜像

    profiles

    用于切换开发、测试、部署的环境

    mvn -p dev 启用dev环境

    pom.xml元素

    新建的默认pom.xml文件:

    <?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.learn</groupId>
        <artifactId>maven-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
    </project>
    

    modelVersion

    指定了当前Maven模型的版本号,对于Maven2和Maven3来说,它只能是4.0.0

    groupId

    类似package,公司名倒过来

    artifactId

    groupId下一个功能的命名,或者说是项目名

    version

    版本号,SNAPSHOT意为快照,说明该项目还在开发中,是不稳定的版本。

    结构为:
    主版本号.次版本号.增量版本号-<里程碑版本>

    groupId、artifactId、version三个元素生成了一个Maven项目的坐标

    packaging

    打包类型:jar、war、rar、ear、pom

    description

    描述,通常用于版权说明

    properties

    定义一些变量,可以在dependency中引用

    dependencyManagement

    一般只出现在父pom里面

    用于帮助管理chidren的dependencies,统一版本号

    dependencyManagement下面所依赖的jar包,不会被children所依赖,但是可以管理children所依赖的版本

    dependency

    Type

    默认jar

    Scope

    定义在哪个阶段使用,以及会不会打到包(jar包,war包等)里面去

    • compile 编译(默认)
      表示被依赖项目需要参与当前项目的编译,还有后续的测试,运行周期也参与其中,是一个比较强的依赖。打包的时候通常需要包含进去
    • test 测试
      依赖项目仅仅参与测试相关的工作,包括测试代码的编译和执行,不会被打包,例如:junit
    • provided
      打包的时候可以不用包进去,别的设施会提供。事实上该依赖理论上可以参与编译,测试,运行等周期。相当于compile,但是打包阶段做了exclude操作
    • runtime
      表示被依赖项目无需参与项目的编译,不过后期的测试和运行周期需要其参与。与compile相比,跳过了编译而已。例如JDBC驱动,适用运行和测试阶段
    • system
      从参与度来说,和provided相同,不过被依赖项不会从maven仓库下载,而是从本地文件系统拿。需要添加systemPath的属性来定义路径

    依赖传递

    • A–>B–>C。当前项目为A,A依赖于B,B依赖于C

    • 当C是test或者provided时,C直接被丢弃,A不依赖C; 否则A依赖C

    依赖仲裁

    • 最短路径原则
      A->B->C->common1.1.jar
      A->common1.0.jar

      那么A最终会依赖common1.0.jar

    • 加载先后原则
      A->B
      A->C
      B->common1.0.jar
      C->common1.1.jar

      A同时依赖B和C,那么B和C谁先加载,就依赖谁的common.jar

    排除依赖传递

    解决jar包冲突,比如spring-core排除commons-loggoing

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
      <exclusions>
        <exclusion>
          <artifactId>commons-logging</artifactId>
          <groupId>commons-logging</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    

    生命周期

    一个完整的项目构建过程通常包括清理、编译、测试、打包、集成测试、验证、部署等步骤,Maven从中抽取了一套完善的、易扩展的生命周期。
    Maven的生命周期是抽象的,其中的具体任务都交由插件来完成。Maven为大多数构建任务编写并绑定了默认的插件,如针对编译的插件:maven-compiler-plugin。用户也可自行配置或编写插件。

    在这里插入图片描述

    Maven定义了三套生命周期:clean、default、site,每个生命周期都包含了一些阶段(phase)。三套生命周期相互独立,但各个生命周期中的phase却是有顺序的,
    且后面的phase依赖于前面的phase。执行某个phase时,其前面的phase会依顺序执行,但不会触发另外两套生命周期中的任何phase。

    比如执行package,前面的test、comiple等 会运行

    clean生命周期

    1. pre-clean :执行清理前的工作;
    2. clean :清理上一次构建生成的所有文件(target);
    3. post-clean :执行清理后的工作

    default生命周期

    default生命周期是最核心的,它包含了构建项目时真正需要执行的所有步骤。

    • process-resources :复制和处理资源文件到target目录,准备打包;
    • compile :编译项目的源代码;
    • test-compile :编译测试源代码;
    • test :运行测试代码;
    • package :打包成jar或者war或者其他格式的分发包;
    • install :将打好的包安装到本地仓库,供其他项目使用;
    • deploy :将打好的包安装到远程仓库,供其他项目使用;

    site生命周期

    1. pre-site
    2. site :生成项目的站点文档;
    3. post-site
    4. site-deploy :发布生成的站点文档

    常用命令

    运行方式 mvn 命令

    compile

    编译,会下载相关jar包

    执行的插件:maven-compiler-plugin:3.1:compile (default-compile)

    clean

    删除target

    执行的插件: maven-clean-plugin:2.5:clean (default-clean)

    test

    运行测试代码,比如JUnit写的测试
    执行的插件:maven-surefire-plugin:2.18.1:test (default-test)

    package

    打包
    执行的插件: maven-resources-plugin:2.7:resources (default-resources)

    install

    将打好的包安装到本地仓库(repository),供其他项目使用;
    在多模块开发环境下,改了代码要执行下install,不然其他模块看不到最新的修改。

    执行的插件:maven-install-plugin:2.5.2:install (default-install)

    deploy

    把本地jar包发送到远程仓库(私服)。

    执行的插件:maven-deploy-plugin:2.8.2:deploy

    插件

    常用插件

    findbugs

    静态代码检查

    <build>
           <plugins>
               <plugin>
                  <groupId>org.codehaus.mojo</groupId>
                  <artifactId>findbugs-maven-plugin</artifactId>
                  <version>2.5.1</version>
                  <configuration>
                      <!-- <configLocation>${basedir}/springside-findbugs.xml</configLocation> -->
                      <threshold>High</threshold>
                      <effort>Default</effort>
                      <findbugsXmlOutput>true</findbugsXmlOutput>
                       <!-- findbugs xml输出路径-->         <findbugsXmlOutputDirectory>target/site</findbugsXmlOutputDirectory>
                  </configuration>
               </plugin>
           </plugins>
        </build>
    
    

    versions

    统一升级父子模块版本号

    <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>versions-maven-plugin</artifactId>
        <version>2.3</version>
    </plugin>
    
    

    使用方法

    mvn versions:set -DnewVersion=1.1

    source

    提供项目自动将源码打包并发布的功能

    <!-- Source attach plugin -->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>2.3</version>
        <executions>
            <execution>
                <id>attach-sources</id>
                <phase>install</phase>
                <goals>
                    <goal>jar-no-fork</goal>
                </goals>
            </execution>
        </executions>
    </plugin>
    

    assembly

    把java工程打包成为一个可执行的jar包

    <plugin>
      <artifactId>maven-assembly-plugin</artifactId>
      <version>3.0.0</version>
      <configuration>
    	<archive>
    	  <manifest>
    		<mainClass>com.learn.MyApp</mainClass>
    	  </manifest>
    	</archive>
    	<descriptorRefs>
    	  <descriptorRef>jar-with-dependencies</descriptorRef>
    	</descriptorRefs>
      </configuration>
    </plugin>
    

    执行mvn clean compile assembly:single

    tomcat

    有时候你不想安装并在ide中配置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>
    

    插件的目标

    一个插件通常可以完成多个任务,每一个任务就叫做插件的一个目标。如执行mvn install命令时,调用的插件和执行的插件目标如下:

    在这里插入图片描述

    将插件绑定到生命周期

    Maven的生命周期是抽象的,实际需要插件来完成任务,这一过程是通过将插件的目标(goal)绑定到生命周期的具体阶段(phase)来完成的。如:将maven-compiler-plugin插件的compile目标绑定到default生命周期的compile阶段,完成项目的源代码编译:

    在这里插入图片描述

    自定义插件

    1. 新建项目
      <groupId>com.learn</groupId>
      <artifactId>maven-project</artifactId>
      <version>1.0-SNAPSHOT</version>
      
    2. 修改pom.xml,添加<packaging>maven-plugin</packaging>
    3. 添加dependency
      <dependency>
              <groupId>org.apache.maven</groupId>
              <artifactId>maven-plugin-api</artifactId>
              <version>3.5.0</version>
          </dependency>
          <dependency>
              <groupId>org.apache.maven.plugin-tools</groupId>
              <artifactId>maven-plugin-annotations</artifactId>
              <version>3.5</version>
              <scope>provided</scope>
          </dependency>
      
    4. 添加代码
      新建类MyMojo
    @Mojo(name="learn",defaultPhase = LifecyclePhase.PACKAGE)
    public class MyMojo extends AbstractMojo {
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            System.out.println("start plugin...");
        }
    }
    

    这里挂载的phase是package

    执行mvn clean install

    1. 其他项目中使用
    <plugin>
    				<groupId>com.learn</groupId>
             <artifactId>maven-project</artifactId>
             <version>1.0-SNAPSHOT</version>
    </plugin>
    

    执行mvn project:learn

    执行日志如下:

    [INFO]
    [INFO] ------------------------------------------------------------------------
    [INFO] Building spring-cloud-config-client 0.0.1-SNAPSHOT
    [INFO] ------------------------------------------------------------------------
    [INFO]
    [INFO] --- maven-project:1.0-SNAPSHOT:learn (default-cli) @ spring-cloud-config-client ---
    start plugin...
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    
    

    可以看到我们的插件生效了

    但是如果我们直接执行mvn install时是看不到这条打印的,说明没有生效。
    需要添加executions

    <plugin>
    				<groupId>com.learn</groupId>
                    <artifactId>maven-project</artifactId>
                    <version>1.0-SNAPSHOT</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>learn</goal>
                            </goals>
                        </execution>
                    </executions>
    			</plugin>
    

    然后再执行mvn install,可以看到:

    [INFO] --- maven-project:1.0-SNAPSHOT:learn (default) @ spring-cloud-config-client ---
    start plugin...
    
    

    profile

    在这里插入图片描述

    在项目中定义三个环境

    修改xml:

    
      <profiles>
        <profile>
          <id>dev</id>
          <properties>
            <profiles.active>dev</profiles.active>
          </properties>
          <activation>
            <activeByDefault>true</activeByDefault>
          </activation>
        </profile>
        <profile>
          <id>test</id>
          <properties>
            <profiles.active>test</profiles.active>
          </properties>
        </profile>
        <profile>
          <id>pro</id>
          <properties>
            <profiles.active>pro</profiles.active>
          </properties>
        </profile>
      </profiles>
    
      <build>
    
        <resources>
          <resource>
            <directory>${basedir}/src/main/resources</directory>
            <excludes>
              <exclude>conf/**</exclude>
            </excludes>
          </resource>
          <resource>
            <directory>src/main/resources/conf/${profiles.active}</directory>
          </resource>
        </resources>
     </build>
    
    

    执行mvn clean install -P pro

    在这里插入图片描述

    可以看到target中app.properties是pro的

    搭建私服

    待补充

    archetype

    模板化脚手架

    自定义模板

    新建一个普通maven项目,添加一些包和类

    ①在项目目录下执行 mvn archetype:create-from-project

    ②cd 到"target\generated-sources\archetype"

    执行mvn install

    此时,我们的脚手架已经生成成功了

    在这里插入图片描述

    根据上图的操作引用它

    如果上面的生成工程失败,可以通过mvn archetype:generate -DarchetypeCatalog=local命令来生成,选择我们的archetype即可

    E:\workspace\idea_java>mvn archetype:generate -DarchetypeCatalog=local
    [INFO] Scanning for projects...
    [INFO]
    [INFO] ------------------------------------------------------------------------
    [INFO] Building Maven Stub Project (No POM) 1
    [INFO] ------------------------------------------------------------------------
    [INFO]
    [INFO] >>> maven-archetype-plugin:3.0.1:generate (default-cli) > generate-sources @ standalone-pom >>>
    [INFO]
    [INFO] <<< maven-archetype-plugin:3.0.1:generate (default-cli) < generate-sources @ standalone-pom <<<
    [INFO]
    [INFO] --- maven-archetype-plugin:3.0.1:generate (default-cli) @ standalone-pom ---
    [INFO] Generating project in Interactive mode
    [INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
    Choose archetype:
    1: local -> com.learn:maven-plugin-archetype (maven-plugin-archetype)
    Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 1
    Define value for property 'groupId': com.learn
    Define value for property 'artifactId': archetype-demo
    Define value for property 'version' 1.0-SNAPSHOT: :
    Define value for property 'package' com.learn: :
    Confirm properties configuration:
    groupId: com.learn
    artifactId: archetype-demo
    version: 1.0-SNAPSHOT
    package: com.learn
     Y: :
    [INFO] ----------------------------------------------------------------------------
    [INFO] Using following parameters for creating project from Archetype: maven-plugin-archetype:1.0-SNAPSHOT
    [INFO] ----------------------------------------------------------------------------
    [INFO] Parameter: groupId, Value: com.learn
    [INFO] Parameter: artifactId, Value: archetype-demo
    [INFO] Parameter: version, Value: 1.0-SNAPSHOT
    [INFO] Parameter: package, Value: com.learn
    [INFO] Parameter: packageInPathFormat, Value: com/learn
    [INFO] Parameter: package, Value: com.learn
    [INFO] Parameter: version, Value: 1.0-SNAPSHOT
    [INFO] Parameter: groupId, Value: com.learn
    [INFO] Parameter: artifactId, Value: archetype-demo
    [WARNING] Don't override file E:\workspace\idea_java\archetype-demo\.idea\inspectionProfiles\Project_Default.xml
    [INFO] Project created from Archetype in dir: E:\workspace\idea_java\archetype-demo
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 28.770 s
    [INFO] Finished at: 2018-10-14T13:13:19+08:00
    [INFO] Final Memory: 14M/245M
    [INFO] ------------------------------------------------------------------------
    

    然后可以看到,生成的项目中有我们脚手架模板里面的类

    父子工程

    模块

    展开全文
  • 什么是Maven? 如今我们构建一个项目需要用到很多第三方的类库,如写一个使用Spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们瞠目结舌,并且Jar包之间的关系错综复杂,一个Jar包往往又会...

    什么是Maven?

    如今我们构建一个项目需要用到很多第三方的类库,如写一个使用Spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们瞠目结舌,并且Jar包之间的关系错综复杂,一个Jar包往往又会引用其他Jar包,缺少任何一个Jar包都会导致项目编译失败。

    以往开发项目时,程序员往往需要花较多的精力在引用Jar包搭建项目环境上,而这一项工作尤为艰难,少一个Jar包、多一个Jar包往往会报一些让人摸不着头脑的异常。

    而Maven就是一款帮助程序员构建项目的工具,我们只需要告诉Maven需要哪些Jar 包,它会帮助我们下载所有的Jar,极大提升开发效率。

    安装Maven 和 Maven的Eclipse插件

    http://blog.csdn.net/qjyong/article/details/9098213

    Maven规定的目录结构

    若要使用Maven,那么项目的目录结构必须符合Maven的规范,其目录结构如下:

    Maven基本命令

    1. -v:查询Maven版本

      本命令用于检查maven是否安装成功。

      Maven安装完成之后,在命令行输入mvn -v,若出现maven信息,则说明安装成功。

    2. compile:编译

      将java源文件编译成class文件

    3. test:测试项目

      执行test目录下的测试用例

    4. package:打包

      将项目打成jar包

    5. clean:删除target文件夹

    6. install:安装

      将当前项目放到Maven的本地仓库中。供其他项目使用

    什么是Maven仓库?

    Maven仓库用来存放Maven管理的所有Jar包。分为:本地仓库 和 中央仓库。

    • 本地仓库:Maven本地的Jar包仓库。
    • 中央仓库: Maven官方提供的远程仓库。

    当项目编译时,Maven首先从本地仓库中寻找项目所需的Jar包,若本地仓库没有,再到Maven的中央仓库下载所需Jar包。

    什么是“坐标”?

    在Maven中,坐标是Jar包的唯一标识,Maven通过坐标在仓库中找到项目所需的Jar包。

    如下代码中,groupId和artifactId构成了一个Jar包的坐标。

    <dependency>
        <groupId>cn.missbe.web.search</groupId>
        <artifactId>resource-search</artifactId>
        <packaging>jar</packaging>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    • groupId:所需Jar包的项目名
    • artifactId:所需Jar包的模块名
    • version:所需Jar包的版本号

    传递依赖 与 排除依赖

    • 传递依赖:如果我们的项目引用了一个Jar包,而该Jar包又引用了其他Jar包,那么在默认情况下项目编译时,Maven会把直接引用和简洁引用的Jar包都下载到本地。
    • 排除依赖:如果我们只想下载直接引用的Jar包,那么需要在pom.xml中做如下配置:(将需要排除的Jar包的坐标写在中)
    <exclusions>
        <exclusion>
            <groupId>cn.missbe.web.search</groupId>
            <artifactId>resource-search</artifactId>
            <packaging>pom</packaging>
            <version>1.0-SNAPSHOT</version>
        </exclusion>
    </exclusions>

    依赖范围scope

    在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
    - compile :默认范围,用于编译      
    - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
    - runtime: 在执行时需要使用      
    - test:    用于test任务时使用      
    - system: 需要外在提供相应的元素。通过systemPath来取得      
    - systemPath: 仅用于范围为system。提供相应的路径      
      - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用

    依赖冲突

    若项目中多个Jar同时引用了相同的Jar时,会产生依赖冲突,但Maven采用了两种避免冲突的策略,因此在Maven中是不存在依赖冲突的。

    • 短路优先
    本项目——>A.jar——>B.jar——>X.jar
    本项目——>C.jar——>X.jar
    
    1. 本项目——>A.jar——>B.jar——>X.jar

    2. 本项目——>C.jar——>X.jar

    若本项目引用了A.jar,A.jar又引用了B.jar,B.jar又引用了X.jar,并且C.jar也引用了X.jar。

    在此时,Maven只会引用引用路径最短的Jar。

    • 声明优先

      若引用路径长度相同时,在pom.xml中谁先被声明,就使用谁。

    聚合

    1. 什么是聚合?

      将多个项目同时运行就称为聚合。

    2. 如何实现聚合?

      只需在pom中作如下配置即可实现聚合:

    <modules>
        <module>web-connection-pool</module>
        <module>web-java-crawler</module>
    </modules>

    继承

    1. 什么是继承?

      在聚合多个项目时,如果这些被聚合的项目中需要引入相同的Jar,那么可以将这些Jar写入父pom中,各个子项目继承该pom即可。

    2. 如何实现继承?

    • 父pom配置:将需要继承的Jar包的坐标放入标签即可。

    <dependencyManagement>
        <dependencies>
              <dependency>
                <groupId>cn.missbe.web.search</groupId>
                <artifactId>resource-search</artifactId>
                <packaging>pom</packaging>
                <version>1.0-SNAPSHOT</version>
              </dependency> 
        </dependencies>
    </dependencyManagement>
    • 子pom配置:
    <parent>
            <groupId>父pom所在项目的groupId</groupId>
            <artifactId>父pom所在项目的artifactId</artifactId>
            <version>父pom所在项目的版本号</version>
    </parent>
     <parent>
            <artifactId>resource-search</artifactId>
            <groupId>cn.missbe.web.search</groupId>
            <version>1.0-SNAPSHOT</version>
    </parent>

    使用Maven构建Web项目

    1. New Maven项目:选择WebApp:

    2. 若使用JSP,需添加Servlet依赖:

      注:Servlet依赖只在编译和测试时使用!

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.0.1</version>
        <!-- 只在编译和测试时运行 -->
        <scope>provided</scope>
    </dependency>
    1. 在Bulid Path中设置resource输出目录:

    2. 勾选:Dynamic Web Module

    3. 删掉测试目录

    4. 在pom中加入jetty的插件,并设置JDK版本:

    <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
    
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.3.10.v20160621</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                    </execution>
                </executions>
            </plugin>
    </plugins>
    1. 运行项目:

    2. 输入:jetty:run

    3. 访问127.0.0.1:8080

      若出现如下界面,表示成功!

    pom.xml详解

    pom.xml是Maven的核心,你的项目需要什么Jar包就在pom.xml里面配置。当编译项目时Maven读取该文件,并从仓库中下载相应的Jar包。

    <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.0http://maven.apache.org/maven-v4_0_0.xsd">     
        <!--父项目的坐标。如果项目中没有规定某个元素的值,
    那么父项目中的对应值即为项目的默认值。 
    坐标包括group ID,artifact ID和 version。-->    
        <parent>    
         <!--被继承的父项目的构件标识符-->    
         <artifactId/>    
         <!--被继承的父项目的全球唯一标识符-->    
         <groupId/>    
         <!--被继承的父项目的版本-->    
         <version/>      
     </parent>    
     <!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,
    但它仍然是必不可少的,这是为了当Maven引入了新的特性或者其他模型变更的时候,
    确保稳定性。-->       
        <modelVersion>4.0.0</modelVersion>     
        <!--项目的全球唯一标识符,通常使用全限定的包名区分该项目和其他项目。
    并且构建时生成的路径也是由此生成, 如com.mycompany.app生成的相对路径为:
    /com/mycompany/app-->     
        <groupId>cn.missbe.web</groupId>     
        <!-- 构件的标识符,它和group ID一起唯一标识一个构件。换句话说,
    你不能有两个不同的项目拥有同样的artifact ID和groupID;在某个 
    特定的group ID下,artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西,
    Maven为项目产生的构件包括:JARs,源码,二进制发布和WARs等。-->     
        <artifactId>search-resources</artifactId>     
        <!--项目产生的构件类型,例如jar、war、ear、pom。插件可以创建
    他们自己的构件类型,所以前面列的不是全部构件类型-->     
        <packaging>war</packaging>     
        <!--项目当前版本,格式为:主版本.次版本.增量版本-限定版本号-->     
        <version>1.0-SNAPSHOT</version>     
        <!--项目的名称, Maven产生的文档用-->     
        <name>search-resources</name>     
        <!--项目主页的URL, Maven产生的文档用-->     
        <url>http://www.missbe.cn</url>     
        <!-- 项目的详细描述, Maven 产生的文档用。  当这个元素能够用HTML格式描述时
    (例如,CDATA中的文本会被解析器忽略,就可以包含HTML标 签), 
    不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面,
    你应该修改你自己的索引页文件,而不是调整这里的文档。-->     
        <description>A maven project to study maven.</description>     
        <!--描述了这个项目构建环境中的前提条件。-->    
     <prerequisites>    
      <!--构建该项目或使用该插件所需要的Maven的最低版本-->    
        <maven/>    
     </prerequisites>      
        
      <!--构建项目需要的信息-->    
        <build>    
         <!--该元素设置了项目源码目录,当构建项目的时候,
    构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->    
      <sourceDirectory/>    
      <!--该元素设置了项目脚本源码目录,该目录和源码目录不同:
    绝大多数情况下,该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的,而不是被编译的)。-->    
      <scriptSourceDirectory/>    
      <!--该元素设置了项目单元测试使用的源码目录,当测试项目的时候,
    构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->    
      <testSourceDirectory/>    
      <!--被编译过的应用程序class文件存放的目录。-->    
      <outputDirectory/>    
      <!--被编译过的测试class文件存放的目录。-->    
      <testOutputDirectory/>    
      <!--使用来自该项目的一系列构建扩展-->    
      <extensions>    
       <!--描述使用到的构建扩展。-->    
       <extension>    
        <!--构建扩展的groupId-->    
        <groupId/>    
        <!--构建扩展的artifactId-->    
        <artifactId/>    
        <!--构建扩展的版本-->    
        <version/>    
       </extension>    
      </extensions>    
      
      <!--这个元素描述了项目相关的所有资源路径列表,例如和项目相关的属性文件,
    这些资源被包含在最终的打包文件里。-->    
      <resources>    
       <!--这个元素描述了项目相关或测试相关的所有资源路径-->    
       <resource>    
        <!-- 描述了资源的目标路径。该路径相对target/classes目录(例如${project.build.outputDirectory})。举个例 子,如果你想资源在特定的包里(org.apache.maven.messages),你就必须该元素设置为org/apache/maven /messages。
    然而,如果你只是想把资源放到源码目录结构里,就不需要该配置。-->    
        <targetPath/>    
        <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性,
    文件在filters元素里列出。-->    
        <filtering/>    
        <!--描述存放资源的目录,该路径相对POM路径-->    
        <directory/>    
        <!--包含的模式列表,例如**/*.xml.-->    
        <includes/>    
        <!--排除的模式列表,例如**/*.xml-->    
        <excludes/>    
       </resource>    
      </resources>    
      <!--这个元素描述了单元测试相关的所有资源路径,例如和单元测试相关的属性文件。-->    
      <testResources>    
       <!--这个元素描述了测试相关的所有资源路径,参见build/resources/resource元素的说明-->    
       <testResource>    
        <targetPath/><filtering/><directory/><includes/><excludes/>    
       </testResource>    
      </testResources>    
      <!--构建产生的所有文件存放的目录-->    
      <directory/>    
      <!--产生的构件的文件名,默认值是${artifactId}-${version}。-->    
      <finalName/>    
      <!--当filtering开关打开时,使用到的过滤器属性文件列表-->    
      <filters/>    
      <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。
    给定插件的任何本地配置都会覆盖这里的配置-->    
      <pluginManagement>    
       <!--使用的插件列表 。-->    
       <plugins>    
        <!--plugin元素包含描述插件所需要的信息。-->    
        <plugin>    
         <!--插件在仓库里的group ID-->    
         <groupId/>    
         <!--插件在仓库里的artifact ID-->    
         <artifactId/>    
         <!--被使用的插件的版本(或版本范围)-->    
         <version/>    
         <!--是否从该插件下载Maven扩展(例如打包和类型处理器),由于性能原因,
    只有在真需要下载时,该元素才被设置成enabled。-->    
         <extensions/>    
         <!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。-->    
         <executions>    
          <!--execution元素包含了插件执行需要的信息-->    
          <execution>    
           <!--执行目标的标识符,用于标识构建过程中的目标,或者匹配继承过程中需要合并的执行目标-->    
           <id/>    
           <!--绑定了目标的构建生命周期阶段,如果省略,目标会被绑定到源数据里配置的默认阶段-->    
           <phase/>    
           <!--配置的执行目标-->    
           <goals/>    
           <!--配置是否被传播到子POM-->    
           <inherited/>    
           <!--作为DOM对象的配置-->    
           <configuration/>    
          </execution>    
         </executions>    
         <!--项目引入插件所需要的额外依赖-->    
         <dependencies>    
          <!--参见dependencies/dependency元素-->    
          <dependency>    
           ......    
          </dependency>    
         </dependencies>         
         <!--任何配置是否被传播到子项目-->    
         <inherited/>    
         <!--作为DOM对象的配置-->    
         <configuration/>    
        </plugin>    
       </plugins>    
      </pluginManagement>    
      <!--使用的插件列表-->    
      <plugins>    
       <!--参见build/pluginManagement/plugins/plugin元素-->    
       <plugin>    
        <groupId/><artifactId/><version/><extensions/>    
        <executions>    
         <execution>    
          <id/><phase/><goals/><inherited/><configuration/>    
         </execution>    
        </executions>    
        <dependencies>    
         <!--参见dependencies/dependency元素-->    
         <dependency>    
          ......    
         </dependency>    
        </dependencies>    
        <goals/><inherited/><configuration/>    
       </plugin>    
      </plugins>    
     </build>    
     <!--模块(有时称作子项目) 被构建成项目的一部分。
    列出的每个模块元素是指向该模块的目录的相对路径-->    
     <modules/>    
        <!--发现依赖和扩展的远程仓库列表。-->     
        <repositories>     
         <!--包含需要连接到远程仓库的信息-->    
            <repository>    
             <!--如何处理远程仓库里发布版本的下载-->    
             <releases>    
              <!--true或者false表示该仓库是否为下载某种类型构件(发布版,快照版)开启。 -->    
        <enabled/>    
        <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是:always(一直),daily(默认,每日),interval:X(这里X是以分钟为单位的时间间隔),或者never(从不)。-->    
        <updatePolicy/>    
        <!--当Maven验证构件校验文件失败时该怎么做:ignore(忽略),fail(失败),或者warn(警告)。-->    
        <checksumPolicy/>    
       </releases>    
       <!-- 如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置,
    POM就可以在每个单独的仓库中,为每种类型的构件采取不同的 策略。
    例如,可能有人会决定只为开发目的开启对快照版本下载的支持。
    参见repositories/repository/releases元素 -->    
       <snapshots>    
        <enabled/><updatePolicy/><checksumPolicy/>    
       </snapshots>    
       <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库-->    
       <id>banseon-repository-proxy</id>     
       <!--远程仓库名称-->    
                <name>banseon-repository-proxy</name>     
                <!--远程仓库URL,按protocol://hostname/path形式-->    
                <url>http://192.168.1.169:9999/repository/</url>     
                <!-- 用于定位和排序构件的仓库布局类型-可以是default(默认)或者legacy(遗留)。Maven 2为其仓库提供了一个默认的布局;然 而,Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default(默认)还是legacy(遗留)。-->    
                <layout>default</layout>               
            </repository>     
        </repositories>    
        <!--发现插件的远程仓库列表,这些插件用于构建和报表-->    
        <pluginRepositories>    
         <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->    
      <pluginRepository>    
       ......    
      </pluginRepository>    
     </pluginRepositories>    
    
        <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。
    它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->     
        <dependencies>     
            <dependency>    
       <!--依赖的group ID-->    
                <groupId>org.apache.maven</groupId>     
                <!--依赖的artifact ID-->    
                <artifactId>maven-artifact</artifactId>     
                <!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。-->    
                <version>3.8.1</version>     
                <!-- 依赖类型,默认类型是jar。它通常表示依赖的文件的扩展名,但也有例外
    。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应,
     尽管这也有例外。一些类型的例子:jar,war,ejb-client和test-jar。
    如果设置extensions为 true,就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。-->    
                <type>jar</type>    
                <!-- 依赖的分类器。分类器可以区分属于同一个POM,但不同构建方式的构件。
    分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成 JAR,
    一个使用Java 1.4编译器,另一个使用Java 6编译器,你就可以使用分类器来生成两个单独的JAR构件。-->    
                <classifier></classifier>    
                <!--依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
                    - compile :默认范围,用于编译      
                    - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
                    - runtime: 在执行时需要使用      
                    - test:    用于test任务时使用      
                    - system: 需要外在提供相应的元素。通过systemPath来取得      
                    - systemPath: 仅用于范围为system。提供相应的路径      
                    - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用-->     
                <scope>test</scope>       
                <!--仅供system范围使用。注意,不鼓励使用这个元素,
    并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。
    需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如${java.home}。-->    
                <systemPath></systemPath>     
                <!--当计算传递依赖时, 从依赖构件列表里,列出被排除的依赖构件集。
    即告诉maven你只依赖指定的项目,不依赖项目的依赖。此元素主要用于解决版本冲突问题-->    
                <exclusions>    
                 <exclusion>     
                        <artifactId>spring-core</artifactId>     
                        <groupId>org.springframework</groupId>     
                    </exclusion>     
                </exclusions>       
                <!--可选依赖,如果你在项目B中把C依赖声明为可选,你就需要在依赖于B的项目(例如项目A)中显式的引用对C的依赖。可选依赖阻断依赖的传递性。-->     
                <optional>true</optional>    
            </dependency>    
        </dependencies>    
       
      
     <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,
    而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息),
    如果group ID和artifact ID以外的一些信息没有描述,
    则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。-->    
     <dependencyManagement>    
      <dependencies>    
       <!--参见dependencies/dependency元素-->    
       <dependency>    
        ......    
       </dependency>    
      </dependencies>    
     </dependencyManagement>       
        <!--项目分发信息,在执行mvn deploy后表示要发布的位置。
    有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。-->     
        <distributionManagement>    
            <!--部署项目产生的构件到远程仓库需要的信息-->    
            <repository>    
             <!--是分配给快照一个唯一的版本号(由时间戳和构建流水号)?
    还是每次都使用相同的版本号?参见repositories/repository元素-->    
       <uniqueVersion/>    
       <id>banseon-maven2</id>     
       <name>banseon maven2</name>     
                <url>file://${basedir}/target/deploy</url>     
                <layout/>    
      </repository>    
      <!--构件的快照部署到哪里?如果没有配置该元素,默认部署到repository元素配置的仓库,
    参见distributionManagement/repository元素-->     
      <snapshotRepository>    
       <uniqueVersion/>    
       <id>banseon-maven2</id>    
                <name>Banseon-maven2 Snapshot Repository</name>    
                <url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>     
       <layout/>    
      </snapshotRepository>    
      <!--部署项目的网站需要的信息-->     
            <site>    
             <!--部署位置的唯一标识符,用来匹配站点和settings.xml文件里的配置-->     
                <id>banseon-site</id>     
                <!--部署位置的名称-->    
                <name>business api website</name>     
                <!--部署位置的URL,按protocol://hostname/path形式-->    
                <url>     
                    scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web      
                </url>     
            </site>    
      <!--项目下载页面的URL。如果没有该元素,用户应该参考主页。
    使用该元素的原因是:帮助定位那些不在仓库里的构件(由于license限制)。-->    
      <downloadUrl/>  
      <!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素,
    因为这是工具自动更新的。有效的值有:none(默认),
    converted(仓库管理员从 Maven 1 POM转换过来),partner(直接从伙伴Maven 2仓库同步过来),deployed(从Maven 2实例部 署),verified(被核实时正确的和最终的)。-->    
      <status/>           
        </distributionManagement>    
        <!--以值替代名称,Properties可以在整个POM中使用,也可以作为触发条件(见settings.xml配置文件里activation元素的说明)。格式是<name>value</name>。-->    
        <properties/>    
    </project>

    参考原文:Maven使用详解

    展开全文
  • Maven是一种帮助我们快速构建项目的小工具,它可以解决我们在项目过程中手动导包造成的版本不一致的问题,以及找包困难等问题,同时通过Maven创建的项目都有固定的目录格式,使得约定优于配置,我们通过固定的目录...

    Maven是一种帮助我们快速构建项目的小工具,它可以解决我们在项目过程中手动导包造成的版本不一致的问题,以及找包困难等问题,同时通过Maven创建的项目都有固定的目录格式,使得约定优于配置,我们通过固定的目录格式快速掌握项目

    一.首先介绍项目的目录结构

    .settings文件暂时不讲

    Src目录由名字可知其主要存放的是源代码文件,源代码的文件目录中可以发现有两个文件目录,分别是以下

    其中main存放的是我们经常存放用于运行项目的代码,main再下一级的目录就是各种package,而test则是存放用于用于测试项目的测试代码,同时都拥有resource资源文件

    target目录下的class目录则是存放编译后的代码

    pom.xml文件便是资源文件,确定该项目需要使用哪些jar包的坐标,并通过该坐标在中央仓库进行自动下载。

    • 使用Maven插件的前提

    在使用maven插件的时候,先要确定jdk和maven是否已经安装,可以通过以下命令确定

      通过java -version确定JDK是否安装

     通过mvn -version确定maven是否安装

    若JDK或者Maven没有安装,安装也很简单,在计算机的Path环境下,设置两个环境变量,分别是JAVAHome和MavenHome,分别指向JDK和Maven的安装目录即代表安装成功这时可以通过以下指令,查找是否有对环境变量进行设置

    在之后就是尝试访问maven的中央仓库,若无法访问则说明不能自动下载jar包,

    通过指令ping repol.maven.org确定是否能访问,若不能则需要设置http代理

    在maven的安装包的setting.xml文件中设置代理

     

    • Maven安装目录分析

     Maven的目录如下:

    其中bin存放的是maven的启动文件,包括两种,一种是直接启动,另一种是通过debug模式下启动,发现它们之间的差距就差一条指令而已

    Boot存放的是一个类加载器框架,它不依赖于eclipse的类加载器

    Conf 主要存放的是全局配置文件setting.xml,通过它进行配置的时候,即所有仓库都拥有的配置,仓库自身也拥有setting.xml这个为私有配置,一般推荐使用私有配置,因为全局配置是存在于maven的安装目录中,当进行Maven升级的时候,便要进行重新的配置

    lib存放的是maven运行需要的各种jar包

    License是Maven的软件使用许可证书

    NOTICE 是Maven包含的第三方软件

    README.txt是Maven的简单介绍以及安装说明

     

    有些公司不允许访问中央服务器下载jar包,而是提供一个代理的网站,通过这个代理ip去下载jar包,这个设置是在setting.xml文件上进行设置,具体设置如下(备注:在proxies上可以设置多个代理即《proxy》多个,只有第一个被激活的生效

      <proxy>

          <id>optional</id>    //代理Id

          <active>true</active>   //是否要激活

          <protocol>http</protocol>  //采用协议

          <username>proxyuser</username>   //如果代理需要认证就需要账号密码

          <password>proxypass</password>

          <host>proxy.host.net</host>  // ip

          <port>80</port>   //端口

          <nonProxyHosts>local.net|some.host.com</nonProxyHosts>  //不需要代理的主机ip用户|隔开,例如里面的some.host.com,即所有对这个网站的访问都不需要代理

    </proxy>

     

     

    为什么有时候在Eclipse上使用maven building时候会出错,因为Eclipse默认运行在JRE上面了,而maven building需要使用到jdk的功能所以会出错,将Eclipse设置默认运行在JDK上就可以了

     

    运行Maven 命令其实就是运行java命令,所以maven的使用,需要用的jdk环境,有时候需要设置JVM参数的的时候,可以在mvn.bat等执行脚本上修改,但这样太麻烦了,一旦升级的时候就得设置,这时候可以把Jvm参数设置在环境变量MAVEN_OPTS中,其设置方式跟设置MAVEN_HOME是一样的

     

      关于setting.xml的问题,一般可以分成两类,一类是公共配置setting.xml,它是存放在maven的安装目录上的conf中,一种是私有配置,存放在.m2的仓库中,里面存放的都是maven的配置,一般来说推荐公共配置在安装目录中,私有配置在仓库中存放,如果是使用私有配置的话,maven升级就不会影响到自己之前的配置了,所以优先使用私有配置

     

    使用eclipse内嵌的maven容易出现不稳定的情况,可以手动安装外部的maven,在eclipse上的preferences上的maven选项里的Installation,点击add,选择你下载的maven安装包

     

     

    四.手写Maven项目:

    1. 编写pom文件

    <project          //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>   //指定当前pom模型的版本,maven2 和3都是4

      <groupId>com.juvenxu.mvnbook</groupId>   //定义项目是哪个公司哪个部门组(项目)的

      <artifactId>hello-world</artifactId>  //组内的唯一id(例如项目中的哪个组件)

      <version>0.0.1-SNAPSHOT</version>   //项目当前版本,SNAPSHOT为不稳定版本,该项目依旧处于快速开发中

      <name>Maven Hello World Project</name>  //项目别名,不一定用,用于方便对外交流

    </project>

    Pom文件可以用于解耦,最大程度区分项目与项目之间的区别

     

    1. 编写主代码

    Maven项目的主代码一般是位于/src/main/java目录中,我们遵循Maven的规定,创建类HelloWorld.java

    关于JAVA代码编写的两个注意点:

    1.默认将代码存放到src/main/java中,Maven会自动在该目录上搜索主代码

    2.包名的命名格式要遵循groupid + arafitid的格式,这样更清晰,更符合逻辑

     

    1. 代码编写完后在项目的根目录上使用MAVEN进行编译,在根目录上使用命令

    mvn clean compile

     

    在这里clean是清除当前目录的target/目录,然后编译项目的主代码,target/存放着maven项目的主输出,,先执行clean后再执行compile,编译好的字节码文件存放在target/classes目录中

     

    1. 编写测试代码

    为了将测试代码和主代码区分开,其应该存放在不同的的目录,主代码是存放在src/main/java,而测试代码是存放在src/test/java的目录中,所以在编写代码之前应该是先创建目录

    在这里是使用单元测试junit测试,所以要往项目添加junit的依赖包,在pom中添加这几行代码

    <dependencies>

          <dependency>

               <groupId>junit</groupId>

               <artifactId>junit</artifactId>

               <version>4.7</version>

               <scope>test</scope>

          </dependency>

      </dependencies>

    <dependencies></dependencies>中存放着所有依赖包的描述,<dependency>是对单个依赖包的信息描述,也就是提供下载的坐标,maven通过该坐标在中央仓库中下载该Jar包,中央仓库的位置在setting.xml中有进行配置,通过这种配置我们就能轻松下载的jar包junit-4.7.jar,在这里我们注意到多了一个标签是<scope>,该标签是来注明Jar包使用的范围,在这里写test的话,则在测试代码中使用import Junit是可以的,在主代码中使用会,会出现找不到该jar包的提示信息,若不写这个标签,则默认使用范围是compile,则测试代码和主代码都可以使用该代码

     

    开始写测试代码:测试主代码中的HelloWorld类的sayHello方法,检查其返回值是否为Hello World,所以在src/test/java下创建测试文件,编写好的测试文件如下

     

    使用junit需要注意的是所有测试方法都是用test作为开头,同时都要添加注解@Test

     

    运行测试代码,使用命令 mvn clean test ,在这里测试成功了,结果如下

     

     

    备注

    在这里的mvn clean test包含两个命令,分别是mvn clean和 mvn test,test又分为两个命令,一个是mvn compile:testCompile 和 mvn surefire : test,测试后发现 mvn surefire:test是可用的,另一个命令没法用,以后再分析

     

    1. 将项目进行打包,主代码打包后的名字为hello-world-1.0-SNAPSHOT.jar文件,该文件依旧存放在target中,所以target存放着项目的所有输出,使用的命令是mvn clean package,执行结果如下

     

    可以在项目的target文件中查看到该jar包

     

    当然可以使用finalName来重新定义jar包的名称,具体操作自行百度,有了该jar包后,,可以啊添加到其他项目的classpath中直接使用,而如何让其他maven项目能快速使用呢?这里就可以用到一个命令是mvn install,将jar包安装在Maven的本地仓库中,使用到的指令是mvn clean install,通过日志可以发现该jar已经发送到本地仓库那里了

     

     

    在这里先做一下总结:在执行test命令之前,Maven会默认执行compile命令,,在执行package之前,maven会默认先执行test命令,在执行install时,mvn会先执行package命令

    到这里基本的mevan操作可以说是完成了,但你没发现这些jar包都是没法运行的,但我的helloWorld类是有main()类、,如果我希望我的jar包可运行应该是如何。

    具体操作如下:为了生成了执行的jar文件,需要借助maven -shade-plugin,需要在pom.xml文件下进行配置,配置该插件的位置应该在<project> <build> <plugins>下面,配置的代码如下:

    <build>

        <plugins>

          <plugin>

            <groupId>org.apache.maven.plugins</groupId>

            <artifactId>maven-shade-plugin</artifactId>

            <version>2.4.3</version>

            <executions>

              <execution>

                <phase>package</phase>

                <goals>

                  <goal>shade</goal>

                </goals>

                <configuration>

                  <transformers>

                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">

                      <mainClass>org.sonatype.haven.HavenCli</mainClass>

                    </transformer>

                  </transformers>

                </configuration>

              </execution>

            </executions>

          </plugin>

        </plugins>

      </build>

    原生的jar文件无法执行是因为打包后的jar文件里面的META-INF/MANIFEST.FE文件无法看到Main-Class一行,采用这个插件就可以添加这一行,生成后会出现两个文件

     

    没加originald的就是可执行文件jar,original是原来的不可执行文件

     

    然后我们现在尝试执行jar包看看结果

    使用java指令

    java -jar target\hello-world-0.0.1-SNAPSHOT.jar

    运行结果如下

     

     

    到这里,基本的maven项目存放的文件规范基本清楚了,一个maven项目有src目录存放代码,和pom.xml文件,如果每次使用maven项目,都需要这样创建就很麻烦了,maven提供了一个快速创建Maven目录结构的指令

    使用指令 mvn archetype:generate 该指令能快速生成maven项目,在创建的过程会询问你要填写的项目信息,例如 groupId   artifactId 等

     

    关于在Eclipse上如何使用指令:对着项目点击右键run,里面就有着好几个maven指令,当我们找不到需要使用的指令,便可以通过maven build来执行我们想要执行的Maven指令

     

     

     

     

    Maven包通过坐标来定义jar包的位置,间接依赖是指依赖的jar包内部依赖其他jar,在导入依赖jar包的时候,会再导入其他依赖的jar,至于依赖链,我感觉不太需要就不做分析

     

     

    Maven仓库

     在Maven世界中,任何一个依赖、插件或者项目构建的输出都可以称为一个构件,在以前的项中,我们往往会将项目依赖的jar包都存放在项目的lib文件夹,如果多个项目都有相同的jar,会大大增加磁盘的浪费,而maven中使用的jar包依赖方式,都是基于坐标,所以Maven会为所有的本地maven项目建一个仓库,该仓库的位置存放在setting.xml上面,当maven项目需要使用到这些jar包时,通过jar包的坐标,在本地仓库中查找到该jar包,在编译时使用到它

    jar在本地仓库存放的路径一般是groupId + artafitID ,jar包名字为araftId + version +package

     

    仓库分类

    加入jar在本地仓库中找不到的时候,就在远程仓库查找,若还是找不到,就会自动报错,仓库分两种,一种是中央仓库,所有人都可以使用,一种是私服仓库,是在局域网中搭建,用其代理从中央仓库下载jar包,也可以支持项目部署到上面

     

    本地仓库分析

    一般仓库存放的路径是user目录下的.m2的repository下面,若修改位置就在settin.xml上的loaclrepository中,在这里我们可以将我们的项目发布到本地项目上,通过mvn clean install就可以,然后在其他项目中想要使用它就可以通过坐标去下载它

     

    中央仓库:中央仓库便是若是在本地找不到jar包,Maven便会在中央仓库查找,每一个Maven都至少有一个中央仓库,其位置是在lib中

     

     

    可以在自己的项目的pom.xml文件中设置要访问的远程仓库

     

     

    Maven生命周期

     

    什么是Maven生命周期?

    对项目构建过程进行抽象,其中就包括了项目的清理 初始化 编译 测试 打包 集成测试 验证 部署和 站点生成等所有构建步骤,Maven的生命周期模型本身是不做任何实际的工作,其各种各样的实现任务都是由插件实现,这种设计思想与模板设计模式十分相似,,在父类中定义了算法的总体架构,而算法细节由插件负责实现

     

    Maven的任何功能都是由插件构成的,它的生命周期有三个,分别是clean site defautlt,这三个生命周期都是由插件完成工作, 当我们使用maven的使用感觉好像没使用插件,是因为这些插件是内置的,我们无法看到

    展开全文
  • Maven简介和Maven私服

    2019-03-20 21:51:30
    更多精彩技术分享请浏览本人博客:... 目录 1. Maven简介 1.1. 简述 1.2. Maven实现的核心价值 1.3. 定义与缩略语 1.4. 项目构建 1.5. 依赖管理 1.6. maven目录说明 1.7. maven坐标 ...

    更多精彩技术分享请浏览本人博客:https://blog.csdn.net/wohiusdashi

     

    目录

    1. Maven简介    
      1.1. 简述    
      1.2. Maven实现的核心价值    
      1.3. 定义与缩略语    
      1.4. 项目构建    
      1.5. 依赖管理    
      1.6. maven目录说明    
      1.7. maven坐标    
    2. Maven私服    
      2.1.私服简介    
      2.2.仓库简介    
      2.3.私服配置    
      2.4.将本地项目发布到私服    
      2.5.查看私服仓库    


    1. MAVEN简介


    1.1.    简述


    Maven是基于项目对象模型(POM),可以通过一小段描述信息来管理项目的构建,报告和文档的软件项目管理工具。
    Maven是一个项目管理工具,它包含了一个项目对象模型 (Project Object Model),一组标准集合,一个项目生命周期(Project Lifecycle),一个依赖管理系统(Dependency Management System),和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。当你使用Maven的时候,你用一个明确定义的项目对象模型来描述你的项目,然后Maven可以应用横切的逻辑,这些逻辑来自一组共享的(或者自定义的)插件。
    Maven是优秀的依赖管理工具,能轻松地解决繁杂的Java类库的依赖关系
    Maven是标准化的构建流程。Maven暴露了一组一致、简洁的操作接口,能帮助团队成员从原来的高度自定义的、复杂的构建系统中解脱出来,使用maven现有的成熟的、稳定的组件也能简化构建系统的复杂度。
    Maven是项目信息管理工具,能有效管理原本分散在项目中各个角落的项目信息,包括项目描述、开发者列表、版本控制系统地址等。另外还能通过Maven自动生成项目站点、项目文档、测试报告等非常具有价值的项目信息。


    1.2.    Maven实现的核心价值


      1.简单:使用简洁、一致的操作接口,进行快速的项目构建,随时随地的地从源代码构建出最终的产品。
      2.促进团队成员的交流与反馈:与版本控制系统结合后,所有人都能执行最新的构建并快速得到反馈。自动生成的项目报告也能帮助成员了解项目的状态,促进团队的交流。
      3.测试驱动开发(TDD):测试是Maven生命周期中最重要的组成部分之一,并且Maven有现成的成熟插件支持业界流行的测试框架,如Junit和TestNG。
      4.持续集成(CI):CI的前提是源码管理系统和构建系统,使用Maven后,持续集成会变得更加方便。
      5.富有信息的工作区:使用Maven发布的项目报告站点,并配置你需要的项目报告,如测试覆盖率报告,都能帮你把信息推送到开发者眼前。


    1.3.    定义与缩略语


    名称    含义
    TDD    test drive develop
    POM    project object model
    CI    continuous integration


    1.4.    项目构建


    项目构建是一个项目从编写源代码到编译、测试、运行、打包、部署、运行的过程。
    清理阶段对应maven的命令:clean,清理输出的class文件。
    编译阶段对应maven的命令:compile,将java代码编译成class文件。
    打包阶段对应maven的命令:package,工程打成jar包、war包。


    1.5.    依赖管理


    什么是依赖?一个java项目可能要使用一些第三方的jar包才可以运行,那边我们说这个java项目依赖了这些第三方的jar包。
    什么是依赖管理?maven依赖管理就是统一管理jar包之间的依赖关系。


    1.6.    maven目录说明


    1.7.    maven坐标


    在平面几何中坐标(x,y)可以标识平面中唯一的一点。在我们开发Maven项目的时候,需要为其定义适当的坐标,这是Maven强制要求的。在这个基础上,其他Maven项目才能应用该项目生成的构件。 
    Maven坐标详解:
    groupId:组织标识(包名)
    artifactId:项目名称
    version:项目的当前版本
    packaging:项目的打包方式,最为常见的jar和war两种,默认jar

    样例:

    2.    MAVEN私服


    2.1.    私服简介


    私服是一种特殊的远程仓库,它是架设在局域网内的仓库服务,私服代理广域网上的远程仓库,供局域网内的用户使用。当Maven需要下载构件的时候,它从私服请求,如果 私服上不存在该构件,则从外部远程仓库下载,缓存在私服上之后,再为Maven的下载请求提供服务。
    私服的好处:
    a、节省自己的外网带宽
    b、加速Maven构建
    c、部署自己内部的第三方构件
    d、提高稳定性,增强控制
    e、降低中央仓库的负荷。


    2.2.    仓库简介


     
    如上图所示:
    对于Maven来说,仓库只分为两类:本地仓库和远程仓库。
    当Maven根据坐标寻找构件的时候,它首先会查看本地仓库,如果 本地仓库存在此构件,则直接使用;如果本地仓库不存在此构件,Maven就会去远程仓库查找,发现需要的构件,下载到本地仓库再使用。如果本地仓库和远程仓库都没有,Maven就会报错。


    2.3.    私服配置


    2.3.1、配置镜像地址
    在settings.xml 文件的 mirrors 内添加以下镜像地址
         <mirror>
            <id>nexus</id>
            <mirrorOf>*</mirrorOf>
            <url>http://localhost:8081/repository/maven-public/</url>
        </mirror>

    2.3.2、配置认证信息
    Nexus的仓库对于匿名用户是只读的。为了能够部署构件,还需要在setting.xml中的servers配置认证信息。
        <server>
            <id>nexus_release</id>
            <username>admin</username>
            <password>admin123</password>
        </server>
        <server>
            <id>nexus_snapshots</id>
            <username>admin</username>
            <password>admin123</password>
        </server>

    2.3.3、配置Profile
    在profiles内添加以下Profile 配置
    <profile>
          <id>nexus</id>
          <!--Enable snapshots for the built in central repo to direct -->
          <!--all requests to nexus via the mirror -->
          <repositories>
            <repository>
              <id>central</id>
              <url>http://central</url>
              <releases><enabled>true</enabled></releases>
              <snapshots><enabled>true</enabled></snapshots>
            </repository>
          </repositories>
          <pluginRepositories>
            <pluginRepository>
              <id>central</id>
              <url>http://central</url>
              <releases><enabled>true</enabled></releases>
              <snapshots><enabled>true</enabled></snapshots>
            </pluginRepository>
          </pluginRepositories>
        </profile>

    2.3.4、配置activeProfile
    在settings内添加以下配置
      <activeProfiles>
        <activeProfile>nexus</activeProfile>
      </activeProfiles>

    2.3.5、IDEA配置maven
    打开IDEA,按 Ctrl + Alt + S 打开配置界面,在搜索栏中输入maven找到maven配置位置,如下图:
     
    2.3.6、配置自动部署构件
    在pom.xml 中的 project 内添加自动部署构件配置
     <distributionManagement>
        <repository>
            <id>nexus_release</id>
            <name>release</name>
            <url>http://localhost:8081/repository/maven-releases/</url>
        </repository>
        <snapshotRepository>
            <id>nexus_snapshots</id>
            <name>snapshots</name>
            <url>http://localhost:8081/repository/maven-snapshots/</url>
        </snapshotRepository>
    </distributionManagement>

    2.4.    将本地maven项目发布到私服

    在IDEA中打开maven菜单,双击deploy按钮
    如下图:

    2.5.    查看私服仓库


    2.5.1、在浏览器中打开 http://localhost:8081/ ,点击左边的Browser按钮,再点击右边的Maven-public ,如下图:

    2.5.2、在右边的目录中找到刚刚发布的项目,如我发布的为NexusTest

    2.5.3、点击左边的Jar文件可以在右边看到相应的依赖地址,可以添加pom.xml文件
    中下载相应的依赖,如下图:

     

     更多精彩技术分享请浏览本人博客:https://blog.csdn.net/wohiusdashi

    展开全文
  • Maven安装

    2019-04-20 16:41:34
    下载地址:http://maven.apache.org/download.cgi ...MAVEN_HOME : D:\ProgramFiles\apache-maven-3.6.1 (压缩所在的路径) PATH:%MAVEN_HOME%\bin 修改setting.xml配置文件(在压缩路径的conf文件夹下) <loc...
  • Maven的使用教程

    2020-08-03 18:08:40
    打个广告,帮朋友卖点东西,东西超便宜的哟【衣服鞋子等】,厂家直接出货,绝对低于市场价!!!一般都比市场价便宜3—7折【都是牌子货】,如果您感兴趣,可以扫描屏幕下方的二维码,感谢关注!...
  • Maven简介

    2018-06-17 20:24:44
    一、什么是Maven? Maven是一个项目管理和综合工具。Maven提供了开发人员构建一个完整的生命周期框架。开发团队可以自动完成项目的基础工具建设,Maven使用标准的目录结构和默认构建生命周期。二、Maven是干什么的...
  • 在eclipse中配置maven环境,在android studio使用gradle导入第三方库。对maven和gradle两种构建工具进行介绍和比较
  • 我们从是什么,为什么,干什么来阐述Maven 文章目录1:为什么要有Maven?2:Maven可以干什么?3:Maven是什么? 1:为什么要有Maven? 上图是完成一个SSM(Spring+SpringBoot+Mybatis)项目必须的步骤流程,大家会...
  • Maven的安装与配置

    2020-07-06 10:44:40
    Maven超详细的安装与配置步骤
  • IDEA Maven 使用教程

    2019-07-05 10:16:11
    Maven 工具日益成为 Java 开发人员喜爱的开发工具之一,随着很多公司对 Maven 的青睐,初识 Maven 的开发者应该会有很多疑惑,而百度出的内容又缺乏系统的指导意义。笔者最初学习 Maven 时也相当迷糊,最终经过一段...
  • eclipse使用maven教程

    2020-04-26 17:17:12
    eclipse使用maven教程eclipse使用maven教程 什么是maven maven下载与安装与配置 1下载 2安装 3配置环境变量 在eclipse中配置 1 m2eclipse安装 2配置eclipse 3创建一个maven项目 1项目的结构 2Eclipse中maven常用的命...
  • maven使用教程

    2013-11-07 00:21:56
    一、Maven介绍 我们在开发项目的过程中,会使用一些开源框架、第三方的工具等等,这些都是以jar包的方式被项目所引用,并且有些jar包还会依赖其他的jar包,我们同样需要添加到项目中,所有这些相关的jar包都会作为...
  • Maven 仓库使用 选择左侧 Artifacts ,选择自己需要上传的 Maven 仓库,点击Set Me Up 在弹出的设置框中点击
  • 在javaWeb中,遇到的一个烦恼,每次都要导jar包,忘记了就会很麻烦,随着项目会变大,jar包管理变的及其麻烦,所以Maven应运而生,Maven并不是最早的管理项目的工具。 核心思想:约定大于配置 Maven会给你规定好...
  • 使用eclipse自带的maven插件 首先,现在下载Eclipse Mars之后的版本,基本上都自带了maven插件,无需自己再安装maven. 有几个注意点: 1.默认的本地仓库的目录是在C:\Users\viruser.v-desktop\.m2\repository\ ...
  • IntelliJ IDEA使用教程MAVEN的集成与使用
  • eclipse集成mavenmaven使用教程 网上看了很多eclipse 和maven集成的教程,对于懂maven的人来说一眼都能看懂,但对于新手来说还是有困难,说以些了这篇教程分享一下 1、打开eclipse的Help--》Eclipse Marketplace...
1 2 3 4 5 ... 20
收藏数 51,265
精华内容 20,506
关键字:

maven