精华内容
下载资源
问答
  • Maven中可以通过继承父模块pom,来实现pom.xml配置的继承和传递,便于各种Maven插件以及程序依赖的统一管理。通过将子类模块的公共配置,抽象聚合生成父类模块,能够避免pom.xml的重复配置。由于父类模块本身并不...

    前言

    Maven中可以通过继承父模块pom,来实现pom.xml配置的继承和传递,便于各种Maven插件以及程序依赖的统一管理。通过将子类模块的公共配置,抽象聚合生成父类模块,能够避免pom.xml的重复配置。由于父类模块本身并不包含除了POM之外的项目文件,也就不需要src/main/java之类的文件夹了。每当需要对多个子模块进行相同的配置时,只需要在父类模块的pom中进行配置,而子类中声明使用此配置即可,当然子类pom中也可以自定义配置,并覆盖父类中的各项配置,和Java中类的继承类似。


    可继承的POM元素

    1) groupId:项目组ID,项目坐标的核心元素

    2) version:项目版本,项目坐标的核心元素

    3) description:项目的表述信息

    4) organization:项目的组织信息

    5) inception Year:项目的创始年份

    6) url:项目的URL地址

    7) developers:项目的开发者信息

    8) contributors:项目的贡献者信息

    9) distributionManagement:项目的部署管理

    10) issueManagement:项目的缺陷和跟踪系统信息

    11) ciManagement:项目的持续集成信息系统

    12) scm:项目的版本控制系统信息

    13) mailingLists:项目的邮件列表信息

    14) properties:自定义的Maven属性

    15) dependencies:项目的依赖属性

    16) dependencyManagement:项目的依赖管理配置

    17) repositories:项目的仓库配置

    18) build:包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等

    19) reporting:包括项目的报告输出目录配置、报告插件配置等


    POM继承中的依赖管理和插件管理

    Maven提供的dependencyManagementpluginManagement元素用于帮助POM继承过程中的依赖管理和插件管理。在父类POM下,此两个元素中的声明的依赖或配置并不会引入实际的依赖或是造成实际的插件调用行为,不过它们能够约束子类POM中的依赖和插件配置的声明。只有当子类POM中配置了真正的dependencyplugin,并且其groupIdartifactId与父类POM中dependencyManagementpluginManagement相对应时,才会进行实际的依赖引入或插件调用,当然子类中也能够进行自定义配置去覆盖父类,或是额外声明自己的配置


    POM继承示例

    1) 在父类POM中使用dependencyManagementpluginManagement,声明子类POM中可能用到的依赖和插件

        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.tomandersen</groupId>
        <artifactId>HadoopCustomModules</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>flume</module>
            <module>log-collector</module>
        </modules>
    
        <!--事先声明版本属性-->
        <properties>
            <slf4j.version>1.7.20</slf4j.version>
            <logback.version>1.0.7</logback.version>
        </properties>
    
    
        <!--在父类Maven中使用dependencyManagement声明依赖便于子类Module继承使用,也便于进行依赖版本控制-->
        <dependencyManagement>
            <dependencies>
                <!--阿里巴巴开源json解析框架-->
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>fastjson</artifactId>
                    <version>1.2.51</version>
                </dependency>
    
                <!--日志生成框架-->
                <dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                    <version>${logback.version}</version>
                </dependency>
    
                <dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                    <version>${logback.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
    
        <build>
            <!--在父类Maven中使用pluginManagement管理插件便于子类Module继承使用,也便于进行依赖版本控制-->
            <pluginManagement>
                <plugins>
                    <!--配置Maven项目compiler插件-->
                    <!--此工具不会打包依赖-->
                    <plugin>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>2.3.2</version>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                        </configuration>
                    </plugin>
    
    				<!--配置Maven项目assembly插件-->
                	<!--此工具会将全部依赖打包-->
                    <plugin>
                        <artifactId>maven-assembly-plugin</artifactId>
                        <configuration>
                            <descriptorRefs>
                                <descriptorRef>jar-with-dependencies</descriptorRef>
                            </descriptorRefs>
                            <archive>
                                <manifest>
                                    <!--子类Maven通过mainClass标签设置成主类的全类名FQCN-->
                                    <!--<mainClass></mainClass>-->
                                </manifest>
                            </archive>
                        </configuration>
                        <executions>
                            <execution>
                                <id>make-assembly</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>single</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
    
                </plugins>
            </pluginManagement>
    
        </build>
    

    2) 在子类POM中声明父类POM,并配置实际使用的dependencyplugin,只需要通过声明groupIdartifactId就可以避免配置各种依赖和插件的详细配置,当然也可以自己覆盖父类配置信息

        <!--声明父类POM-->
        <parent>
            <artifactId>HadoopCustomModules</artifactId>
            <groupId>com.tomandersen</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
        <!--子类POM信息-->
        <groupId>com.tomandersen</groupId>
        <artifactId>log-collector</artifactId>
    
        <dependencies>
            <!--阿里巴巴开源json解析框架-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
            </dependency>
    
            <!--日志生成框架-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <!--自定义Maven项目编译器compiler插件相关配置-->
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                </plugin>
    
                <!--自定义Maven项目汇编assembly插件相关配置-->
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <configuration>
                        <archive>
                            <manifest>
                                <!--此处设置成主类的全名-->
                                <mainClass>com.tomandersen.appclient.AppMain</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    

    更多详细内容可以查阅《Maven实战》


    End~

    展开全文
  • 使用maven时,如果pom.xml不在项目目录下,在src下怎么办,在哪里配置pom.xml的位置
  • 什么是pom.xml?有什么作用?--pom.xml详解

    万次阅读 多人点赞 2018-10-08 10:59:36
    POM是项目对象模型(Project Object Model)的简称,它是Maven项目中的文件,使用XML表示,名称叫做pom.xml。作用类似ant的build.xml文件,功能更强大。该文件用于管理:源代码、配置文件、开发者的信息和角色、问题...

    什么是POM?

    POM是项目对象模型(Project Object Model)的简称,它是Maven项目中的文件,使用XML表示,名称叫做pom.xml。作用类似ant的build.xml文件,功能更强大。该文件用于管理:源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。事实上,在Maven世界中,project可以什么都没有,甚至没有代码,但是必须包含pom.xml文件。

    概览

    下面是一个POM项目中的pom.xml文件中包含的元素。注意,其中的modelVersion是4.0.0,这是当前仅有的可以被Maven2&3同时支持的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>

    复制代码

    一,基本配置

    1.1 maven的协作相关属性

      一个最简单的pom.xml的定义必须包含modelVersion、groupId、artifactId和version这四个元素,当然这其中的元素也是可以从它的父项目中继承的。在Maven中,使用groupId、artifactId和version组成groupdId:artifactId:version的形式来唯一确定一个项目:

    复制代码

    <?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/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <!-- 
            含义:组织标识,定义了项目属于哪个组,风向标,坐标,或者说若把本项目打包
            用途:此名称则是本地仓库中的路径,列如:otowa.user.dao,在M2_REPO目录下,将是: otowa/user/dao目录
            命名规范:项目名称,模块,子模块
        -->
        <groupId>otowa.user.dao</groupId>
        <!-- 
            含义:项目名称也可以说你所模块名称,定义当面Maven项目在组中唯一的ID
            用途:例如:user-dao,在M2_REPO目录下,将是:otowa/user/dao/user-dao目录
            命名规范:唯一就好
        -->
        <artifactId>user-dao</artifactId>
        <!-- 
            含义:项目当前的版本号
            用途:例如:0.0.1-SNAPSHOT,在M2_REPO目录下,将是:otowa/user/dao/user-dao/0.0.1-SNAPSHOT目录
        -->
        <version>0.0.1-SNAPSHOT</version>
        <!-- 打包的格式,可以为:pom , jar , maven-plugin , ejb , war , ear , rar , par -->
        <packaging>war</packaging>
        <!-- 元素声明了一个对用户更为友好的项目名称 -->
        <name>maven</name>
    </project>

    复制代码

    1.2 POM之间的关系,继承、聚合与依赖

      我们知道Maven在建立项目的时候是基于Maven项目下的pom.xml进行的,我们项目依赖的信息和一些基本信息都是在这个文件里面定义的。那如果当我们有多个项目要进行,这多个项目有些配置内容是相同的,有些是要彼此关联的,那如果按照传统的做法的话我们就需要在多个项目中都定义这些重复的内容。这无疑是非常耗费时间和不易维护的。好在Maven给我们提供了一个pom的继承和聚合的功能。

           对于使用java的人而言,继承这个词大家应该都不陌生。要继承pom就需要有一个父pom,在Maven中定义了超级pom.xml,任何没有申明自己父pom.xml的pom.xml都将默认继承自这个超级pom.xml。

      位置:

        在Maven 2.xxx版本中,比如maven-2.0.9-uber.jar,打开此Jar文件后,在包包org.apache.maven.project下会有pom-4.0.0.xml的文件。
        但是到了3.xxx版本之后在: aven安装目录下的:/lib/maven-model-builder-version.jar中 \org\apache\maven\mode目录中的pom-4.0.0.xml。

          先来看一下这个超级pom.xml的定义:

    复制代码

    <?xml version="1.0" encoding="UTF-8"?>
    
    <!--
    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements.  See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership.  The ASF licenses this file
    to you under the Apache License, Version 2.0 (the
    "License"); you may not use this file except in compliance
    with the License.  You may obtain a copy of the License at
    
        http://www.apache.org/licenses/LICENSE-2.0
    
    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied.  See the License for the
    specific language governing permissions and limitations
    under the License.
    -->
    
    <!-- START SNIPPET: superpom -->
    <project>
      <modelVersion>4.0.0</modelVersion>
    
      <repositories>
        <repository>
          <id>central</id>
          <name>Central Repository</name>
          <url>https://repo.maven.apache.org/maven2</url>
          <layout>default</layout>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>
        </repository>
      </repositories>
    
      <pluginRepositories>
        <pluginRepository>
          <id>central</id>
          <name>Central Repository</name>
          <url>https://repo.maven.apache.org/maven2</url>
          <layout>default</layout>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>
          <releases>
            <updatePolicy>never</updatePolicy>
          </releases>
        </pluginRepository>
      </pluginRepositories>
    
      <build>
        <directory>${project.basedir}/target</directory>
        <outputDirectory>${project.build.directory}/classes</outputDirectory>
        <finalName>${project.artifactId}-${project.version}</finalName>
        <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
        <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
        <scriptSourceDirectory>${project.basedir}/src/main/scripts</scriptSourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
        <resources>
          <resource>
            <directory>${project.basedir}/src/main/resources</directory>
          </resource>
        </resources>
        <testResources>
          <testResource>
            <directory>${project.basedir}/src/test/resources</directory>
          </testResource>
        </testResources>
        <pluginManagement>
          <!-- NOTE: These plugins will be removed from future versions of the super POM -->
          <!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->
          <plugins>
            <plugin>
              <artifactId>maven-antrun-plugin</artifactId>
              <version>1.3</version>
            </plugin>
            <plugin>
              <artifactId>maven-assembly-plugin</artifactId>
              <version>2.2-beta-5</version>
            </plugin>
            <plugin>
              <artifactId>maven-dependency-plugin</artifactId>
              <version>2.8</version>
            </plugin>
            <plugin>
              <artifactId>maven-release-plugin</artifactId>
              <version>2.3.2</version>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    
      <reporting>
        <outputDirectory>${project.build.directory}/site</outputDirectory>
      </reporting>
    
      <profiles>
        <!-- NOTE: The release profile will be removed from future versions of the super POM -->
        <profile>
          <id>release-profile</id>
    
          <activation>
            <property>
              <name>performRelease</name>
              <value>true</value>
            </property>
          </activation>
    
          <build>
            <plugins>
              <plugin>
                <inherited>true</inherited>
                <artifactId>maven-source-plugin</artifactId>
                <executions>
                  <execution>
                    <id>attach-sources</id>
                    <goals>
                      <goal>jar</goal>
                    </goals>
                  </execution>
                </executions>
              </plugin>
              <plugin>
                <inherited>true</inherited>
                <artifactId>maven-javadoc-plugin</artifactId>
                <executions>
                  <execution>
                    <id>attach-javadocs</id>
                    <goals>
                      <goal>jar</goal>
                    </goals>
                  </execution>
                </executions>
              </plugin>
              <plugin>
                <inherited>true</inherited>
                <artifactId>maven-deploy-plugin</artifactId>
                <configuration>
                  <updateReleaseInfo>true</updateReleaseInfo>
                </configuration>
              </plugin>
            </plugins>
          </build>
        </profile>
      </profiles>
    
    </project>
    <!-- END SNIPPET: superpom -->

    复制代码

      对于一个pom.xml来说有几个元素是必须定义的,一个是project根元素,然后就是它里面的modelVersion、groupId、artifactId和version。由上面的超级pom.xml的内容我们可以看到pom.xml中没有groupId、artifactId和version的定义,所以我们在建立自己的pom.xml的时候就需要定义这三个元素。和java里面的继承类似,子pom.xml会完全继承父pom.xml中所有的元素,而且对于相同的元素,一般子pom.xml中的会覆盖父pom.xml中的元素,但是有几个特殊的元素它们会进行合并而不是覆盖。这些特殊的元素是:

    • dependencies
    • developers
    • contributors
    • plugin列表,包括plugin下面的reports
    • resources

    1.2.1 继承

    1.2.1.1 被继承项目与继承项目是父子目录关系

           现在假设我们有一个项目projectA,它的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/maven-v4_0_0.xsd">  
      <modelVersion>4.0.0</modelVersion>  
      <groupId>com.tiantian.mavenTest</groupId>  
      <artifactId>projectA</artifactId>  
      <packaging>jar</packaging>  
      <version>1.0-SNAPSHOT</version>  
    </project>  

    复制代码

      然后我们有另一个项目projectB,而且projectB是跟projectA的pom.xml文件处于同一个目录下,这时候如果projectB需要继承自projectA的话我们可以这样定义projectB的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/maven-v4_0_0.xsd">  
      <parent>  
        <groupId>com.tiantian.mavenTest</groupId>  
        <artifactId>projectA</artifactId>  
        <version>1.0-SNAPSHOT</version>  
      </parent>  
      <modelVersion>4.0.0</modelVersion>  
      <groupId>com.tiantian.mavenTest</groupId>  
      <artifactId>projectB</artifactId>  
      <packaging>jar</packaging>  
      <version>1.0-SNAPSHOT</version>  
    </project>  

    复制代码

      由projectB的pom.xml文件的定义我们可以知道,当需要继承指定的一个Maven项目时,我们需要在自己的pom.xml中定义一个parent元素,在这个元素中指明需要继承项目的groupId、artifactId和version。

    1.2.1.2 被继承项目与继承项目的目录结构不是父子关系

      当被继承项目与继承项目的目录结构不是父子关系的时候,我们再利用上面的配置是不能实现Maven项目的继承关系的,这个时候我们就需要在子项目的pom.xml文件定义中的parent元素下再加上一个relativePath元素的定义,用以描述父项目的pom.xml文件相对于子项目的pom.xml文件的位置。

      假设我们现在还是有上面两个项目,projectA和projectB,projectB还是继承自projectA,但是现在projectB不在projectA的子目录中,而是与projectA处于同一目录中。这个时候projectA和projectB的目录结构如下:

      ------projectA

        ------pom.xml

      ------projectB

        ------pom.xml

      这个时候我们可以看出projectA的pom.xml相对于projectB的pom.xml的位置是“../projectA/pom.xml”,所以这个时候projectB的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/maven-v4_0_0.xsd">  
      <parent>  
        <groupId>com.tiantian.mavenTest</groupId>  
        <artifactId>projectA</artifactId>  
        <version>1.0-SNAPSHOT</version>  
           <relativePath>../projectA/pom.xml</relativePath>  
      </parent>  
      <modelVersion>4.0.0</modelVersion>  
      <groupId>com.tiantian.mavenTest</groupId>  
      <artifactId>projectB</artifactId>  
      <packaging>jar</packaging>  
      <version>1.0-SNAPSHOT</version>  
    </project>  

    复制代码

    1.2.2 聚合

           对于聚合这个概念搞java的人应该都不会陌生。先来说说我对聚合和被聚合的理解,比如说如果projectA聚合到projectB,那么我们就可以说projectA是projectB的子模块, projectB是被聚合项目,也可以类似于继承那样称为父项目。对于聚合而言,这个主体应该是被聚合的项目。所以,我们需要在被聚合的项目中定义它的子模块,而不是像继承那样在子项目中定义父项目。具体做法是:

    • 修改被聚合项目的pom.xml中的packaging元素的值为pom
    • 在被聚合项目的pom.xml中的modules元素下指定它的子模块项目

    对于聚合而言,当我们在被聚合的项目上使用Maven命令时,实际上这些命令都会在它的子模块项目上使用。这就是Maven中聚合的一个非常重要的作用。假设这样一种情况,你同时需要打包或者编译projectA、projectB、projectC和projectD,按照正常的逻辑我们一个一个项目去使用mvn compile或mvn package进行编译和打包,对于使用Maven而言,你还是这样使用的话是非常麻烦的。因为Maven给我们提供了聚合的功能。我们只需要再定义一个超级项目,然后在超级项目的pom.xml中定义这个几个项目都是聚合到这个超级项目的。之后我们只需要对这个超级项目进行mvn compile,它就会把那些子模块项目都进行编译。

    1.2.2.1 被聚合项目和子模块项目在目录结构上是父子关系

      还拿上面定义的projectA和projectB来举例子,现在假设我们需要把projectB聚合到projectA中。projectA和projectB的目录结构如下所示:

      ------projectA

        ------projectB

          -----pom.xml

        ------pom.xml

      这个时候projectA的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.tiantian.mavenTest</groupId>  
      <artifactId>projectA</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>pom</packaging>  
      <modules>  
           <module>projectB</module>  
      </modules>  
    </project>  

    复制代码

      由上面的定义我们可以看到被聚合的项目的packaging类型应该为pom,而且一个项目可以有多个子模块项目。对于聚合这种情况,我们使用子模块项目的artifactId来作为module的值,表示子模块项目相对于被聚合项目的地址,在上面的示例中就表示子模块projectB是处在被聚合项目的子目录下,即与被聚合项目的pom.xml处于同一目录。这里使用的module值是子模块projectB对应的目录名projectB,而不是子模块对应的artifactId。这个时候当我们对projectA进行mvn package命令时,实际上Maven也会对projectB进行打包。

    1.2.2.2 被聚合项目与子模块项目在目录结构上不是父子关系

      那么当被聚合项目与子模块项目在目录结构上不是父子关系的时候,我们应该怎么来进行聚合呢?还是像继承那样使用relativePath元素吗?答案是非也,具体做法是在module元素中指定以相对路径的方式指定子模块。我们来看下面一个例子。

      继续使用上面的projectA和projectB,还是需要把projectB聚合到projectA,但是projectA和projectB的目录结构不再是父子关系,而是如下所示的这种关系:

      ------projectA

        ------pom.xml

      ------projectB

        ------pom.xml

      这个时候projectA的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.tiantian.mavenTest</groupId>  
      <artifactId>projectA</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>pom</packaging>  
      <modules>  
           <module>../projectB</module>  
      </modules>  
    </project>  

    复制代码

      注意看module的值是“../projectB”,我们知道“..”是代表当前目录的上层目录,所以它表示子模块projectB是被聚合项目projectA的pom.xml文件所在目录(即projectA)的上层目录下面的子目录,即与projectA处于同一目录层次。注意,这里的projectB对应的是projectB这个项目的目录名称,而不是它的artifactId

    1.2.2.3 聚合与继承同时进行

           假设有这样一种情况,有两个项目,projectA和projectB,现在我们需要projectB继承projectA,同时需要把projectB聚合到projectA。然后projectA和projectB的目录结构如下:

           ------projectA

                  ------pom.xml

           ------projectB

                  ------pom.xml

           那么这个时候按照上面说的那样,projectA的pom.xml中需要定义它的packaging为pom,需要定义它的modules,所以projectA的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.tiantian.mavenTest</groupId>  
      <artifactId>projectA</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>pom</packaging>  
      <modules>  
           <module>../projectB</module>  
      </modules>  
    </project>  

    复制代码

      而projectB是继承自projectA的,所以我们需要在projectB的pom.xml文件中新增一个parent元素,用以定义它继承的项目信息。所以projectB的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>  
      <parent>  
           <groupId>com.tiantian.mavenTest</groupId>  
           <artifactId>projectA</artifactId>  
           <version>1.0-SNAPSHOT</version>  
           <relativePath>../projectA/pom.xml</relativePath>  
      </parent>  
      <groupId>com.tiantian.mavenTest</groupId>  
      <artifactId>projectB</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>jar</packaging>  
    </project>  

    复制代码

    1.2.3 依赖关系:依赖关系列表(dependency list)是POM的重要部分

           项目之间的依赖是通过pom.xml文件里面的dependencies元素下面的dependency元素进行的。一个dependency元素定义一个依赖关系。在dependency元素中我们主要通过依赖项目的groupId、artifactId和version来定义所依赖的项目。

           先来看一个简单的项目依赖的示例吧,假设我现在有一个项目projectA,然后它里面有对junit的依赖,那么它的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.tiantian.mavenTest</groupId>  
      <artifactId>projectB</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>jar</packaging>  
       
      <dependencies>  
        <dependency>  
          <groupId>junit</groupId>  
          <artifactId>junit</artifactId>  
          <version>3.8.1</version>  
          <scope>test</scope>  
          <optional>true</optional>  
        </dependency>  
      </dependencies>  
    </project>  

    复制代码

    groupId, artifactId, version:描述了依赖的项目唯一标志。

    type:对应于依赖项目的packaging类型,默认是jar。

    scope:用于限制相应的依赖范围、传播范围。scope的主要取值范围如下(还有一个是在Maven2.0.9以后版本才支持的import,关于import作用域将在后文《Dependency介绍》中做介绍):

    • test:在测试范围有效,它在执行命令test的时候才执行,并且它不会传播给其他模块进行引入,比如 junit,dbunit 等测试框架。
    • compile(default 默认):这是它的默认值,这种类型很容易让人产生误解,以为只有在编译的时候才是需要的,其实这种类型表示所有的情况都是有用的,包括编译和运行时。而且这种类型的依赖性是可以传递的。
    • runtime:在程序运行的时候依赖,在编译的时候不依赖。
    • provided:这个跟compile很类似,但是它表示你期望这个依赖项目在运行时由JDK或者容器来提供。这种类型表示该依赖只有在测试和编译的情况下才有效,在运行时将由JDK或者容器提供。这种类型的依赖性是不可传递的。比如 javaee:

      • eclipse开发web环境中是没有javaee必须要手动添加。
      • myeclipse新建web项目会有JavaEE(servlet-api.jar,jsp-api.jar...)web容器依赖的jar包,一般都是做开发的时候才使用。但是myeclipse不会把这些 jar包发布的,lib下你是找不到javaee引入的jar包,因为myeclipse发布项目的时候会忽略它。为什么?因为tomcat容器bin/lib已经存在了这个jar包了。
    • system:这种类型跟provided类似,唯一不同的就是这种类型的依赖我们要自己提供jar包,这需要与另一个元素systemPath来结合使用。systemPath将指向我们系统上的jar包的路径,而且必须是给定的绝对路径。
      • systemPath:上面已经说过了这个元素是在scope的值为system的时候用于指定依赖的jar包在系统上的位置的,而且是绝对路径。该元素必须在依赖的 jar包的scope为system时才能使用,否则Maven将报错。
      • optional:当该项目本身作为其他项目的一个依赖时标记该依赖为可选项。假设现在projectA有一个依赖性projectB,我们把projectB这个依赖项设为optional,这表示projectB在projectA的运行时不一定会用到。这个时候如果我们有另一个项目projectC,它依赖于projectA,那么这个时候因为projectB对于projectA是可选的,所以Maven在建立projectC的时候就不会安装projectB,这个时候如果projectC确实需要使用到projectB,那么它就可以定义自己对projectB的依赖。当一个依赖是可选的时候,我们把optional元素的值设为true,否则就不设置optional元素。
      • exclusions:考虑这样一种情况,我们的projectA依赖于projectB,然后projectB又依赖于projectC,但是在projectA里面我们不需要projectB依赖的projectC,那么这个时候我们就可以在依赖projectB的时候使用exclusions元素下面的exclusion排除projectC。这个时候我们可以这样定义projectA对projectB的依赖:

        复制代码

        <dependencies>  
             <dependency>  
                    <groupId>com.tiantian.mavenTest</groupId>  
                    <artifactId>projectB</artifactId>  
                    <version>1.0-SNAPSHOT</version>  
                    <exclusions>  
                           <exclusion>  
                                  <groupId>com.tiantian.mavenTest</groupId>  
                                  <artifactId>projectC</artifactId>  
                           </exclusion>  
                    </exclusions>  
             </dependency>  
        </dependencies>

        复制代码

    1.3 属性

    在pom.xml文件中我们可以使用${propertyName}的形式引用属性。是值的占位符,类似EL,类似ant的属性,比如${X},可用于pom文件任何赋值的位置。有以下分类:

    • env.propertyName:这种形式表示引用的是环境变量,比如我们需要引用当前系统的环境变量PATH的时候,就可以使用${env.PATH}。
    • project.propertyName:这种形式表示引用的是当前这个pom.xml中project根元素下面的子元素的值。比如我们需要引用当前project下面的version的时候,就可以使用${project.version}。
    • settings.propertyName:这种形式引用的是Maven本地配置文件settings.xml或本地Maven安装目录下的settings.xml文件根元素settings下的元素。比如我们需要引用settings下的本地仓库localRepository元素的值时,我们可以用${settings.localRepository}
    • Java System Properties:java的系统属性,所有在java中使用java.lang.System.getProperties()能够获取到的属性都可以在pom.xml中引用,比如${java.home}。
    • 自定义:pom.xml中properties元素下面的子元素作为属性。假如在pom.xml中有如下一段代码<properties><hello.world>helloWorld</hello.world></properties>,那么我们就可以使用${hello.world}引用到对应的helloWorld。
    展开全文
  • 使用SpringMVC框架虽然使用注解可以免去我们很多的配置,但是光使用注解是不能完全取代所有的配置问价的,使用SpringMVC主要有三种配置文件,pom.xml、web.xml、springmvc.xml三种,下面我们分别说一下三种配置文件...

    前言:
    使用SpringMVC框架虽然使用注解可以免去我们很多的配置,但是只使用注解是不能完全取代所有的配置文件的,使用SpringMVC框架构建一个项目主要有三种配置文件,pom.xml、web.xml、springmvc.xml三种,而就我本人而言,之前关于SpringMVC的种种配置,总是傻傻分不清楚让我配置的东西到底应给放到哪个配置文件中,下面我们分别说一下三种配置文件主要配置哪些内容。

    1、pom.xml文件:

    书面语:pom.xml主要描述了项目的maven坐标,依赖关系,开发者需要遵循的规则,缺陷管理系统,组织和licenses,以及其他所有的项目相关因素,是项目级别的配置文件。

    我的理解: pom.xml文件严格来说应该说是Maven的配置文件,该配置文件主要的目的是通过配置依赖的形式来让maven管理jar包,让maven来自动导入我们所需要的包的,所以pom.xml配置文件的内容主要是配置一些依赖。

    例: 下面是配置SpringMVC的依赖,我只是举个例子,随着项目功能的增多,依赖会越来越多。
    点击了解:pom.xml配置文件的详解

    <dependencies>
    	<dependency>
    		<groupId>org.springframework</groupId>
    		<artifactId>spring-webmvc</artifactId>
    		<version>3.2.8.RELEASE</version>
    	</dependency>
    </dependencies>
    

    2、web.xml文件:
    首先 web.xml 是java web 项目的一个重要的配置文件,但是web.xml文件并不是Java web工程必须的。web.xml是我们创建maven项目以后自己点击java EE Tools手动生成的,它在项目根目录下的/WEB-INF/web.xml的位置,web.xml文件是用来配置:欢迎页、servlet、filter等。当你的web工程没用到这些时,你可以不用web.xml文件来配置你的web工程。

    例: 下面是web.xml的一些基本配置:点解了解:关于web.xml文件的详解

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns="http://java.sun.com/xml/ns/javaee"
    	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    	version="2.5">
    	<display-name>Demo</display-name>
    	<welcome-file-list>
    		<welcome-file>index.html</welcome-file>
    		<welcome-file>index.htm</welcome-file>
    		<welcome-file>index.jsp</welcome-file>
    		<welcome-file>default.html</welcome-file>
    		<welcome-file>default.htm</welcome-file>
    		<welcome-file>default.jsp</welcome-file>
    	</welcome-file-list>
    
    	<!-- 配置HTML访问过滤器 -->
    	<filter>
    		<filter-name>HtmlAccessFilter</filter-name>
    		<filter-class>cn.tedu.store.filter.HtmlAccessFilter</filter-class>
    	</filter>
    
    	<filter-mapping>
    		<filter-name>HtmlAccessFilter</filter-name>
    		<url-pattern>*.html</url-pattern>
    	</filter-mapping>
    
    	<!-- 配置字符集编码过滤器 -->
    	<filter>
    		<filter-name>CharacterEncodingFilter</filter-name>
    		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    		<init-param>
    			<param-name>encoding</param-name>
    			<param-value>utf-8</param-value>
    		</init-param>
    	</filter>
    	<filter-mapping>
    		<filter-name>CharacterEncodingFilter</filter-name>
    		<url-pattern>/*</url-pattern>
    	</filter-mapping>
    
    	<!-- 配置DispatcherServlet -->
    	<servlet>
    		<servlet-name>DispatcherServlet</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		<!-- 1.配置spring的配置文件 -->
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:spring-*.xml</param-value>
    		</init-param>
    		<!-- 2.启动Tomcat时即初始化该Servlet -->
    		<load-on-startup>1</load-on-startup>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>DispatcherServlet</servlet-name>
    		<url-pattern>*.do</url-pattern>
    	</servlet-mapping>
    </web-app>
    

    3、springmvc.xml文件:

    a. springmvc.xml配置文件是(建议)配置在src/main/resources下的,它的名称不是官方提供的(也可以自己定义其它的名称),也可以根据自己的需求定义多个该配置文件。点解了解:配置文件的位置和命名

    例子: 下面是我的项目中的一下简单的配置:配置了多个xml的配置文件。
    在这里插入图片描述
    b. springmvc.xml主要是针对SpringMVC框架的一些配置,其中主要的的配置有组件扫描、视图解析器、注解驱动、拦截器等,以及Dao层的读取配置文件、配置数据源、配置接口文件等,总之都是针对SpringMVC自己框架的一些配置。具体的配置可以简单的参考一下这篇文章

    上面大部分都是我自己的理解,如果有问题评论告诉我以便及时更正,如果对你有帮助,别忘了点了赞哦,笔芯。

    展开全文
  • maven配置总结(pom.xml和settings.xml)

    万次阅读 2019-10-24 23:01:07
    maven配置总结一、pom.xml配置1、自定义参数2、依赖包版本管理3、depoly发布路径配置4、设定远程仓库下载路径,按设定顺序依次下载5、环境变量配置(一般用于打包控制配置)二、setting.xml配置1、配置镜像(可以理解...

    一、pom.xml配置

    1、自定义参数

    	<properties>
           <slf4j.version>1.7.5</slf4j.version>
    	   <logback.version>1.2.3</logback.version>
    	</properties>
    

    2、依赖包版本管理

    <dependencyManagement>
            <dependencies>
               <dependency>
    				<groupId>org.slf4j</groupId>
    				<artifactId>slf4j-api</artifactId>
    				<version>${slf4j.version}</version>
    			</dependency>
    			<dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                    <version>${logback.version}</version>
                </dependency>
            </dependencies>
    </dependencyManagement>
    

    3、depoly发布路径配置

        <distributionManagement>
    		<repository>
    			<id>maven-releases</id>
    			<url>http://xxx/maven-releases/</url>
    		</repository>
    		<snapshotRepository>
    			<id>maven-snapshots</id>
    			<url>http://xxx/repository/maven-snapshots/</url>
    		</snapshotRepository>
    	</distributionManagement>
    

    4、设定远程仓库下载路径,按设定顺序依次下载

        <repositories>
            <-- 需要密码的到setting中找密码 -->
            <repository>
                <id>nexus-repos</id>
                <name>releases</name>
                <url>http://xxx/nexus/content/groups/public</url>
            </repository>  
            
            <repository>
                <id>oschina-repos</id>
                <name>Oschina Releases</name>
                <url>http://maven.oschina.net/content/groups/public</url>
            </repository>
        </repositories>
        <-- 插件下载路径 -->
       <pluginRepositories>
    	    <pluginRepository>
    	      <id>maven-net-cn</id>
    	      <name>Maven China Mirror</name>
    	      <url>http://maven.net.cn/content/groups/public/</url>
    	      <releases>
    	        	<enabled>true</enabled>
    	      </releases>
    	      <snapshots>
    	        	<enabled>false</enabled>
    	      </snapshots>    
    	    </pluginRepository>
      </pluginRepositories>
    

    5、环境变量配置(一般用于打包控制配置)

    <profiles>
    		<profile>
    			<id>dev</id>
    				<activation>
    					<activeByDefault>true</activeByDefault>   #指定默认环境变量为dev
    				</activation>
    			<build>
    				<resources>
    					<resource>
    						<directory>src/main/exchange-robot/env-dev</directory>   #指定资源文件路径
    						<filtering>false</filtering>
    					</resource>
    				</resources>
    			</build>
    			<properties>  
    	            <project.release.version>0.1</project.release.version>   #打包时覆盖原来的版本属性
    	        </properties>
    		</profile>
    </profiles>
    

    二、setting.xml配置

    1、配置镜像(可以理解为代理)

      <mirrors>
        <mirror>
    		<id>alimaven</id>
    
    		<name>aliyun maven</name>
    
    		<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    
    		<mirrorOf>central</mirrorOf> 
    	    # maven中有个顶级pom指定了中央仓库为central,只需要将这个仓库镜像到阿里云即可;也可以配置 *,!maven-releases,!maven-snapshots
        </mirror>
      </mirrors>
    

    2、配置服务密码

    <servers>
    	<server>
    		<id>maven-releases</id>
    		<username>admin</username>
    		<password>xxx</password>
    	</server>
    	<server>
    		<id>maven-snapshots</id>
    		<username>admin</username>
    		<password>xxx</password>
    	</server>
    </servers>
    

    3、配置统一远程仓库

    避免源代码中配置仓库,由于setting中不支持repositories标签,远程仓库默认需要到pom中配置。这里通过统一profils设置

    <profiles>
        <profile>
          <id>dev</id>
    	    <repositories>
    	        <repository>
    	            <id>nexus-repos</id>
    	            <name>releases</name>
    	            <url>http://xxx/nexus/content/groups/public</url>
    	        </repository>  
    	        <repository>
    	            <id>oschina-repos</id>
    	            <name>Oschina Releases</name>
    	            <url>http://maven.oschina.net/content/groups/public</url>
    	        </repository>
    	    </repositories>    </profile>
      </profiles>
      <activeProfiles>
        <activeProfile>dev</activeProfile>
      </activeProfiles>
    
    展开全文
  • maven 工程 pom.xml 中 relativePath 的作用

    万次阅读 2019-06-30 14:29:33
    默认值为../pom.xml 查找顺序:relativePath元素中的地址–本地仓库–远程仓库 设定一个空值将始终从仓库中获取,不从本地路径获取。 如 <relativePath/> 转自:...
  • 参考文章: metawerx web.xml web.xml 文件详解 web.xml 中加载顺序 maven pom.xml
  • 小解析spring-bean.xml , spring-mvc.xml , pom.xml导包的联系
  • maven的pom.xml和setting.xml

    千次阅读 2018-07-19 11:00:40
    世界上任何一个构件都可以使用Maven...pom.xml和settings.xml是maven中重要的两个配置文件 1.pom.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="...
  • settings.xml与pom.xml 配置maven自动下载依赖时,会涉级读取三个配置文件,分别是项目下的pom.xml 文件 、家目录下的.m2/settings.xml 与 maven 全局配置settings.xml ,后面两者不难理解,就像linux下的用户一样...
  • pom.xml配置添加依赖失败,用mvn install命令,报错“Non-resolvable import POM...”解决方法 对pom.xml文件进行“mvn install”命令报如下错误: [ERROR] [ERROR] Some problems were encountered while ...
  • Maven项目:pom.xml出现web.xml is missing and <failOnMissingWebXml> is set to true解决方案
  • 在主pom.xml中引入的依赖没有在其他pom.xml中使用那么依赖的jar是不会下载到本地仓库的 主pom.xml文件主要是用来规范和定义版本的,供其他子模块或者其他项目的pom.xml来应用...
  • IDEA工具代码不提示,无法自动识别pom.xml文件 解决办法: 1、打开idea工具找到设置Settings 2、找到Compiler–>右边勾选Build project automatically 3、应用保存退出。 这样就可以了。 如果还是不行...
  • Maven项目中遇到一个问题:项目A无法引用到其兄弟项目B下的类,所以考虑是该项目B应该...项目执行install pom.xml -e -f或者clean pom.xml -e -f 后,有了如下报错: "C:\Program Files\Java\jdk1.8.0_152\bin\jav...
  • 建立maven项目后,pom.xml在显示红叉,鼠标放上去,显示Execution default-testResources of goal org.apache.maven.plugins:maven-resources-plugin:2.4.3错误。 二、原因分析 缺少maven-resources-plugin-2.4.3....
  • pom.xml解析

    千次阅读 2020-07-19 18:27:09
    pom.xml pom.xml文件是Maven进行工作的主要配置文件。在这个文件中我们可以配置Maven项目的groupId、artifactId和version等Maven项目必须的元素;可以配置Maven项目需要使用的远程仓库;可以定义Maven项目打包的形式...
  • pom.xml中的java.home变量(eclipse默认的java.home变量)原文地址:http://www.blogjava.net/wangxunhua/archive/2016/01/11/429000.aspx pom.xml详解:http://blog.csdn.net/adeyi/article/details/17259479 ...
  • 配置文件的理解(pom.xml、web.xml)

    千次阅读 2018-12-18 18:27:55
    一、pom.xml 1、项目坐标,用于信息的描述 2、引入jar包 3、构建项目 详见https://blog.csdn.net/wangb_java/article/details/54170143 二、web.xml 相当于一个容器,将 spring(dao、service、transaction)....
  • (1)修改pom.xml文件,引入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.or
  • 1.聚合:n多个项目聚合在一个pom.xml文件中,对这个pom进行test,package等mav命令时,n多个项目会同时执行这些命令,不用每个项目分别执行这些命令。 聚合pom.xml必须,方法1和2都要有的 <modelVersion>4.0.0...
  • sts中的maven项目,之前用着都挺正常,有段时间没管,今天打开时突然就抛出好多错,pom.xml直接小红叉,这谁能忍。一看problems视图,进本全都是jar包引入的异常信息,但是maven dependencies里面是有相应jar包的。 ...
  • 本博文着重讲一下,关于net.sf.json-lib-2.4-jdk15.jar包依赖一直...小编将json-lib-2.4-jdk15.jar以及其相关的依赖架包的正确配置给出【pom.xml文件】:&lt;!-- json所需要的所有jar包 --&gt; &lt;d...
  • pom.xml详解

    千次阅读 2019-04-10 14:32:18
    pom.xml详解 什么是POM? POM是项目对象模型(Project Object Model)的简称,它是Maven项目中的文件,使用XML表示,名称叫做pom.xml。作用类似ant的build.xml文件,功能更强大。该文件用于管理:源代码、配置文件、...
  • Maven之(七)pom.xml配置文件详解

    万次阅读 多人点赞 2016-05-24 09:53:25
    鉴于CSDN对**版权保护的不作为**以及落后的运营手段,本博客将于近期关闭,并清空全部文章。 原有文章将会经过再次的校对、整理,转移至本人在**简书**的[博客空间](https://www.jianshu.com/u/3ec23ef9a408)... ...
  • maven项目pom.xml中parent标签的使用

    万次阅读 多人点赞 2018-07-12 11:07:16
    使用maven是为了更好的帮项目管理包依赖,maven的核心就是pom.xml。当我们需要引入一个jar包时,在pom文件中加上&lt;dependency&gt;&lt;/dependency&gt;就可以从仓库中依赖到相应的jar包。现在有...
  • Maven之pom.xml与setting.xml配置文件详解

    千次阅读 2018-01-23 12:36:48
    一.pom.xml详解     1.概述     pom中节点如下分布 project xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation=...
  • pom.xml标识不是m

    2020-07-20 14:01:13
    pom.xml 前面是红色的<>标识,不是m 解决办法: 是选中pom.xml文件,右键-" add as maven project
  • What is parent.relativePath used in maven pom.xml
  • Ignored pom.xml

    千次阅读 2021-03-06 21:36:25
    重新创建一个新的同名module会让IDEA误以为是之前被删除掉的module,所以才自动将这个pom.xml文件忽略了 解决办法 1.点击file > Setting进入设置 2.找到lgnored file,把右边已选中的选项取消勾选,然后点击 ok ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,421
精华内容 40,168
关键字:

pom.xml