精华内容
下载资源
问答
  • maven聚合项目怎么打包
    千次阅读
    2018-05-30 17:17:59

    背景: 1、在eclipse下面创建maven聚合项目, 2、聚合项目的打包以及部署

    一、首先介绍eclipse下创建maven聚合项目

    1、创建父项目,按照常规创建maven项目一样,创建maven项目,后面在修改pom文件的打包方式,修改为pom形式,把其它文件夹都可以删掉。

    2、创建子项目,右键父项目,选择new-->other--->maven--->maven module 项目

    3、创建web子项目,在选择maven项目格式的时候选择webapp。

    二、聚合项目打包

    1、聚合项目的打包只需要maven父项目即可

    2、方法:右键---> run configurations --> clean package run  ,选择可以skip Tests这就是普通的打包


    三、项目怎么发布到本地仓库

    1、右键父项目: run as -->mvn install, 也可以用上面的 在输入框中添加 clean package install

    2、怎么打包成source.jar, 在pom文件中添加如下配置

    <build>
    	<plugins>
    		<plugin>
    			<groupId>org.apache.maven.plugins</groupId>
    			<artifactId>maven-source-plugin</artifactId>
    			<version>2.1.2</version>
    			<executions>
    				<execution>
    					<id>attach-sources</id>
    					<phase>verify</phase>
    					<goals>
    						<goal>jar-no-fork</goal>
    					</goals>
    				</execution>
    			</executions>
    		</plugin>
    	</plugins>
     </build>
    这样在本地仓库就可以看到自己打包的jar包和source.jar包


    更多相关内容
  • maven聚合项目打包

    2020-05-20 16:46:21
    1.在resource资源文件... xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/p

    1.在resource资源文件中添加一个 descriptor.xml,里面内容为:

    <assembly
            xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
        <id>assembly</id>
        <formats>
            <format>tar.gz</format>
        </formats>
        <includeBaseDirectory>true</includeBaseDirectory>
        <fileSets>
             <fileSet>
                <directory>${project.basedir}/src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <excludes>
                    <exclude>/assemble/**</exclude>
                    <exclude>/properties/**</exclude>
                    <exclude>/i18n/**</exclude>
                </excludes>
                <outputDirectory>config</outputDirectory>
            </fileSet> 
        </fileSets>
     
    	<!-- 依赖包打包 -->
        <dependencySets>
            <dependencySet>
                <outputDirectory>lib</outputDirectory>
                <excludes>
                    <exclude>org.apache.maven:*</exclude>
                    <exclude>org.codehaus.plexus:*</exclude>
                    <exclude>org.apache.maven.wagon:*</exclude>
                    <exclude>org.apache.maven.surefire:*</exclude>
                    <exclude>org.apache.maven.plugins:*</exclude>
                    <exclude>/assemble/**</exclude>
                    <exclude>/properties/**</exclude>
                    <exclude>/i18n/**</exclude>
                    <exclude>junit:*</exclude>
                </excludes>
            </dependencySet>
        </dependencySets>
    </assembly>
    

    2.在pom 文件中添加设置如下:

      <build>
            <finalName>MyDemo</finalName>
            <resources>
                <resource>
                    <directory>${basedir}/src/main/resources</directory>
                </resource>
            </resources>
            <plugins>
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <executions>  <!--执行器 mvn assembly:assembly -->
                        <execution>
                            <id>make-zip</id><!--名字任意 -->
                            <phase>package</phase><!-- 绑定到package生命周期阶段上 -->
                            <goals>
                                <goal>single</goal><!-- 只运行一次 -->
                            </goals>
                            <configuration>
                                <descriptors> <!--描述文件路径 -->
                                    <descriptor>src/main/resources/assemble/descriptor.xml</descriptor>
                                </descriptors>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
    
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.7</source>
                        <target>1.7</target>
                    </configuration>
                </plugin>
                <plugin>
    
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>2.2</version>
                    <configuration>
                        <excludes>
                            <exclude>**/log4j.properties</exclude>
                            <exclude>**/config/**</exclude>
                            <exclude>**/i18n/**</exclude>
                            <exclude>**/assemble/**</exclude>
                            <exclude>**/properties/**</exclude>
                            <exclude>**/script/**</exclude>
                            <exclude>**/spring/**</exclude>
                            <exclude>**/mapper/**</exclude>
                            <exclude>**/sql/**</exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    

    3.打包
    在这里插入图片描述

    展开全文
  • 包内喊有5个文档,包含maven本地搭建,私服搭设,于eclipse集成,创建web项目,创建聚合项目打包和问题解决说明
  • 导入别人项目时 哪怕是自己公司项目 每次必不可少都会遇到maven报错问题 关键是这些问题 百度都不知道怎么查,最近着手自己搭建了一个demo 终于把这些给理解了 首先一个比较低级的错误 一般有了开发经验不会犯 但是...

    导入别人项目或者自己搭建项目时,每次必不可少都会遇到maven报错问题 (当然有可能是别人的项目pom写的不规范 自信点可能不是你的问题 但我们需要学会解决)。 这些问题 百度都不知道怎么查,最近着手自己搭建了一个springcloud聚合工程的demo 应该算是比较有代表性了,当然 springboot也可差不多 主要是理解maven的使用, 终于把这些给理解了个大概。文章有点长 原创不易

    项目结构介绍: MySpringCloud为父模块,本文以红框内的模块举例, file为业务模块 调用了user-api工具模块,user-api引入了framework工具模块,两个工具模块被common模块管理
    在这里插入图片描述

    本文从多个层面分析maven综合报错问题:

    1. 首先一个比较低级的错误 一般有了开发经验不会犯 但是入门者可能会踩坑 要确保maven配置里面的maven仓库地址是可用的,典型错误:早期maven中央仓库是http传输的,后来改成了https, 网上可能还存在很多错误的mirrors配置 换句话说 仓库地址都是错误的 所以会导致所有依赖下载失败,此外 不同的仓库地址 某些依赖的groupId有可能会不同

    在这里插入图片描述

    1. 确保了地址是可用的 groupId 和 artifactId都是无误:

      maven遇到的主要错误 应该属以下几个

      .A  Cannot resolve xxxx 错误 
      .B  Could not find artifact 错误
      .C  must be "pom" but is "jar"错误
      .D  程序包XXX 不存在
      .E Unable to find main class
      

    解决方式:

    1. 低级错误1:找到本地maven仓库路径 查找 .lastUpdated 结尾的文件 全部删除 ,出现这种文件的情况可能由于网络不好,下载错误 并且它会阻止下次下载;
    2. 低级错误2:如果网络正常 且每次下载都是这个文件,那么很可能就是依赖版本号不正确,远程仓库根本没有这个包,所以一直都是 lastUpdated 。
      在这里插入图片描述
    3. 正文开始 用一个父子多模块maven项目 pom.xml文件实际举例 重点都在注释上面,顺便写了个英文版注释,因为xml比较容易乱码,项目几经周转很可能注释就乱了,这些注释就不复制出来了 研究这玩意 我累了。

    父pom

    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.4.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <!-- 子项目继承父项目pom文件时 父项目需要packing指定为pom
        daclare the packing:pom when child extends this moudule-->
        <packaging>pom</packaging>
        <groupId>com.demo</groupId>
        <artifactId>MySpringCloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>MySpringCloud</name>
        <description>Demo project for Spring Boot</description>
    
        <!-- 配置版本 version config 用于依赖管理版本号el表达式取值 
        act on dependencyManagement-dependencies-dependency-version by ${xxx.version}-->
        <properties>
            <java.version>1.8</java.version>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    
            <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
            <spring-cloud-alibaba.version>2.2.1.RELEASE</spring-cloud-alibaba.version>
    
            <nacos.version>1.3.0</nacos.version>
            <sentinel.version>1.8.2</sentinel.version>
            <openfeign.version>2.2.5.RELEASE</openfeign.version>
            <netflix-hystrix.version>2.2.5.RELEASE</netflix-hystrix.version>
    
            <fastjson.version>1.2.76</fastjson.version>
            <servlet.version>4.0.1</servlet.version>
        </properties>
    
        <!-- author by qkj-->
        <!-- 声明依赖及其版本 但不引入, 子模块进行引入 (但子模块无需声明版本 否则会使用声明的版本号)-->
        <!-- note: dependencyManagement only declare the dependency Id and version but not import,
        child moudule should import again without declare the version when need dependency  -->
    
        <!-- 注意:dependencyManagement与dependencies区别 如果在父模块使用dependencies,子模块都继承,不管用不用得上-->
        <!-- note: difference with dependencies:child moudule extends dependencies unconditional   -->
        <dependencyManagement>
    
            <dependencies>
               <!-- diff:cloud-dependencies and cloud-starter?
                dependencies only declare the version and download jar with starter -->
                <!-- cloud-dependencies and cloud-starter 的区别 一般带 dependencies 的 artifactId 都是声明版本
                点进去看就能发现 里面是声明的dependencyManagement, 而starter则是我们要下载具体的xxx-starter.jar包-->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <!-- 需要加上type 否则在阿里云可能下载不了
                    declare type:pom  or maybe download fall in alibaba maven
                    type pom: 已打包为pom工程-->
                    <!-- 同理 如果我们写了一个聚合工程 且把聚合工程当成基础包供其它项目使用 
                    其它项目把parent指定为基础包,并在依赖引入 声明type为pom即可 -->
                    <type>pom</type>
                </dependency>
    
                <!-- alibaba与cloud整合 -->
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                    <version>${spring-cloud-alibaba.version}</version>
                    <type>pom</type>
                    <!-- scope:import can only declare in dependencyManagement; resolve the problem of single extends -->
                    <!--<scope>import</scope> 只会在dependencyManagement中出现-->
                    <!-- 解决单继承问题 换句话说 加上import 可以使用spring-cloud-alibaba-dependencies面的dependencyManagement -->
                    <!-- such as spring-cloud-alibaba-dependencies already include spring-cloud-starter-alibaba-nacos-discovery
                      child module can declare spring-cloud-starter-alibaba-nacos-discovery without version-->
                    <scope>import</scope>
                </dependency>
    
    
    
                <!--lombok-->
                <dependency>
                    <groupId>org.projectlombok</groupId>
                    <artifactId>lombok</artifactId>
                    <optional>true</optional>
                    <version>${lombok.version}</version>
                </dependency>
    
                <!--fastjson 过低版本会有漏洞(建议关注新版) low version such as 1.2.71 before with remote bug-->
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>fastjson</artifactId>
                    <version>${fastjson.version}</version>
                </dependency>
    
                <!-- nacos注册中心客户端 内置ribbon-->
                <dependency>
                    <groupId>com.alibaba.nacos</groupId>
                    <artifactId>nacos-client</artifactId>
                    <version>${nacos.version}</version>
                </dependency>
    
    
                <!-- sentinel-->
                <dependency>
                    <groupId>com.alibaba.csp</groupId>
                    <artifactId>sentinel-core</artifactId>
                    <version>${sentinel.version}</version>
                </dependency>
    
                <!-- sentinel控制台-->
                <dependency>
                    <groupId>com.alibaba.csp</groupId>
                    <artifactId>sentinel-transport-simple-http</artifactId>
                    <version>${sentinel.version}</version>
                </dependency>
    
                <!--feign 依赖-->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-openfeign</artifactId>
                    <version>${openfeign.version}</version>
                </dependency>
    
                <!-- feign集成hystrix豪猪降级-->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
                    <version>${netflix-hystrix.version}</version>
                </dependency>
    
                <!-- servlet -->
                <dependency>
                    <groupId>javax.servlet</groupId>
                    <artifactId>javax.servlet-api</artifactId>
                    <version>${servlet.version}</version>
                </dependency>
                
               <!-- skywalking工具类:自定义链路追踪等-->
                <dependency>
                    <groupId>org.apache.skywalking</groupId>
                    <artifactId>apm-toolkit-trace</artifactId>
                    <!-- 与sw版本对应 -->
                    <version>${skywalking.version}</version>
                </dependency>
    
                <!-- skywalking和logback整合-->
                <dependency>
                    <groupId>org.apache.skywalking</groupId>
                    <artifactId>apm-toolkit-logback-1.x</artifactId>
                    <version>${skywalking.version}</version>
                </dependency>
    
            </dependencies>
        </dependencyManagement>
    
        <!-- 可以理解为声明子类(子模块) -->
        <modules>
            <module>common</module>
            <module>user</module>
            <module>file</module>
        </modules>
    
    	 <!--注意 子模块有工具类(没有main方法的模块)
    	  不能在父模块这里声明maven插件 子模块继承 会导致打包报错:找不到main方法(unalbe to find main class)  -->
    <!--    <build>-->
    <!--        <plugins>-->
    <!--            <plugin>-->
    <!--                <groupId>org.springframework.boot</groupId>-->
    <!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
    <!--                <configuration>-->
    <!--                    <excludes>-->
    <!--                        <exclude>-->
    <!--                            <groupId>org.projectlombok</groupId>-->
    <!--                            <artifactId>lombok</artifactId>-->
    <!--                        </exclude>-->
    <!--                    </excludes>-->
    <!--                </configuration>-->
    <!--                <version>2.3.4.RELEASE</version>-->
    <!--            </plugin>-->
    <!--        </plugins>-->
    <!--    </build>-->
    
    </project>
    
    
    

    子pom

    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.demo</groupId>
            <artifactId>MySpringCloud</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <!-- 因为file是我们的业务模块 通俗点说是一个小项目 到时候要打包java -jar运行的 所以打包方式为jar(可以不写 默认为jar) 而不是pom-->
        <packaging>jar</packaging>
        <groupId>com.qkj</groupId>
        <artifactId>file</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>file</name>
        <description>Demo project for Spring Boot</description>
        <properties>
            <java.version>1.8</java.version>
        </properties>
        <dependencies>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <!-- 父模块该依赖为pom 子模块该依赖也尽量定义为pom
                父模块该依赖未使用<scope>import</scope>:当前模块如果还有子模块必须声明为pom 没有则随意 -->
                <!-- 但是父模块该依赖使用了import 可以理解为继承了该依赖内置的dependencyManagement 必须使用pom 且声明版本号-->
                <!-- must declare type:pom when child module exist or parent module dependency declare scope:import;
                version should be declared if parent module dependency declare scope:import,else type could be default or other-->
                <!-- so shoule better declare the type: pom -->
                <version>${spring-cloud.version}</version>
                <type>pom</type>
            </dependency>
    
            <!-- alibaba与cloud整合 -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
            </dependency>
    
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
    
            <!--fastjson 注意过低版本会有漏洞 low version such as 1.2.71 before with remote bug-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>
    
            <!-- nacos注册中心客户端 内置ribbon-->
            <dependency>
                <groupId>com.alibaba.nacos</groupId>
                <artifactId>nacos-client</artifactId>
            </dependency>
    
            <!-- sentinel-->
            <dependency>
                <groupId>com.alibaba.csp</groupId>
                <artifactId>sentinel-core</artifactId>
            </dependency>
    
            <!-- sentinel控制台-->
            <dependency>
                <groupId>com.alibaba.csp</groupId>
                <artifactId>sentinel-transport-simple-http</artifactId>
            </dependency>
    
            <!--feign 依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
            <!-- 豪猪熔断-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>
    
    
            <!--Nacos Discovery-->
            <!-- 在spring-cloud-alibaba-dependencies里面声明了版本 又因为设置了scope:import 所以在我们自己写的父模块pom文件中 不能显式看到-->
            <!-- declare in spring-cloud-alibaba-dependencies-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <!--实现配置的动态变更-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            </dependency>
    
            <!-- skywalking工具类:自定义链路追踪等-->
            <dependency>
                <groupId>org.apache.skywalking</groupId>
                <artifactId>apm-toolkit-trace</artifactId>
            </dependency>
    
            <!-- skywalking和logback整合 print traceId in our logs-->
            <dependency>
                <groupId>org.apache.skywalking</groupId>
                <artifactId>apm-toolkit-logback-1.x</artifactId>
            </dependency>
            <dependency>
                <groupId>com.qkj</groupId>
                <artifactId>user-api</artifactId>
                <version>0.0.1-SNAPSHOT</version>
                <!-- scope :默认provided 没有传递性 ,compile具有传递性 换句话说就是会把jar包打进来,而runtime表示不作用在编译时 如JDBC驱动-->
                <!-- compile can pass on but provided(default) can't , runtime means not compile-->
                <scope>compile</scope>
            </dependency>
    
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.projectlombok</groupId>
                                <artifactId>lombok</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                    <version>2.3.4.RELEASE</version>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    
    
    
    

    工具类父pom :common.pom

    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.demo</groupId>
            <artifactId>MySpringCloud</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <packaging>pom</packaging>
    
        <groupId>com.qkj</groupId>
        <artifactId>common</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>common</name>
        <description>Demo project for Spring Boot</description>
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <modules>
            <module>file-api</module>
            <module>user-api</module>
            <module>framework</module>
        </modules>
    
    
        <!-- 注意工具类pom中 不能有maven打包插件 同理 不能写在最外层的父级模块中 否则子模块会继承-->
    </project>
    
    

    工具类子pom : user-api.pom

    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.qkj</groupId>
            <artifactId>common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <packaging>jar</packaging>
        <artifactId>user-api</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>user-api</name>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <!--feign 依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.qkj</groupId>
                <artifactId>framework</artifactId>
                <version>0.0.1-SNAPSHOT</version>
                <!-- scope :默认provided 没有传递性 ,compile具有传递性 换句话说就是会把jar包打进来,而runtime表示不作用在编译时 如JDBC驱动-->
                <!-- compile can pass on but provided(default) can't , runtime means not compile-->
                <scope>compile</scope>
    
            </dependency>
    
            <!-- 注意工具类pom中 不能有maven打包插件 同理 不能写在最外层的父级模块中 否则子模块会继承-->
        </dependencies>
    
    
    
    </project>
    
    

    工具类子pom: framework.pom

    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.qkj</groupId>
            <artifactId>common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <packaging>jar</packaging>
        <artifactId>framework</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>framework</name>
        <description>Demo project for Spring Boot</description>
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <!--feign 依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <!-- servlet -->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
            </dependency>
    
        </dependencies>
    
    
    </project>
    
    

    什么时候可以不写version?

    父pom dependencyManagement 里面声明了version, 而子pom继承了 父pom(parent 节点声明继承关系) ,子pom依赖不声明版本,则使用父pom依赖版本,这在多子模块项目中方便管理。 而整个pom不存在parent时,version是一定要写的,如果不写则会报错

    type: 默认为jar 因为我们的是聚合工程,所以父模块要声明为pom,否则会报must be “pom” but is "jar"错误

    总结:

    1. maven仓库地址有误或下载缓慢 网络不好 (推荐使用阿里仓库)
    2. 版本号错误 或缺少版本号
    3. 多模块项目中未正确声明父模块groupId artifactId
    4. pom工程中 未正确声明type
    5. 父模块中声明了maven打包插件 而子模块含有工具类模块
    展开全文
  • 聚合项目目录: 打war包不需要动父pom文件中的东西。找到你的启动类所在的子模块 我的启动类在dating-business模快中: 打开dating-business 模块的pom文件 ,在其中加入 <packaging>war</packaging>...

    聚合项目目录:
    在这里插入图片描述

    打war包不需要动父pom文件中的东西。找到你的启动类所在的子模块

    我的启动类在dating-business模快中:
    打开dating-business 模块的pom文件 ,在其中加入
    在这里插入图片描述

        <packaging>war</packaging>
    

    剩下的参考的:https://blog.csdn.net/publicv/article/details/104087496

    2、--------移除内置的tomcat :总工程的 pom 文件内,右键 Maven - Show dependencies 。找到 spring-boot-starter-tomcat —右键Exclude 排除掉

    在这里插入图片描述
    3、--------总工程的 pom 文件内添加 servlet 环境,因为tomcat 被移除了,里面的servlet 自然就无法使用了

     <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
             <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>4.0.1</version>
                <scope>provided</scope>
            </dependency>
    

    4、添加 war 包的启动类

    package com.jy.dating.business;
    
    import org.springframework.boot.builder.SpringApplicationBuilder;
    import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
    
    /**
     * @Description:   War启动类 继承SpringBootServletInitializer  初始化servlet 环境
     * @Author: leoYan
     * @Date: 2020/12/21 15:54
     */
    public class WarStartApplication extends SpringBootServletInitializer {
        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
            //  指向Application 这个启动类
            return builder.sources(DatingApp.class);
        }
    
    }
    
    

    5、然后在maven —clean —package 显示success就可以了。

    展开全文
  • 项目报错: Could not resolve dependencies for ... 原因: 我的mapper项目 依赖pojo项目,而mapper项目和pojo项目是manager聚合项目的子模块,只把pojo项目 maven install mapper项目在mave库中找不到pojo ...
  • 主要介绍了Idea创建多模块maven聚合项目的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • maven聚合项目 打包时候先整体install

    千次阅读 2017-01-18 15:25:11
    maven聚合项目 打包时候先整体install 以下比如下面的例子    [INFO] Reactor Summary: [INFO]  [INFO] bimatrix-main ..................................... SUCCESS [ 5.417 s] [INFO] bimatrix-main-common...
  • 使用eclipse创建maven项目 第一步:创建父工程hg-parent,如图; 右击空白处,new创建新maven工程: 搜索maven项目 父工程使用pom打包方式 第二步:创建子工程 右击父工程,创建mavenmodule工程: ...
  • maven项目打包部署

    2022-03-27 18:27:06
    maven项目打包 1.pom文件配置将项目打包成jar包 2.打包时跳过测试,执行指令:mvn install -DskipTests 3.运行项目:java -jar guns.jar
  • 比如单元测试 这样所有的子工程都能用到junit(单元测试) 那么接下来做啥呢 假如一切都写完了,我们是不是该打包了 我们这里着重看一下打包的一个流程 我们先把这个卖家的后台管理系统的项目打包 然后我们会发现...
  • Spring Boot 给聚合工程 打包部署,这里打jar包进行部署,首先等保证父子工程能正常运行,依赖都能加载,不会造成maven之间循环依赖等问题,如图 从上面的图来看,就会发生循环依赖的问题,这样子编译时就会发现...
  • 实现方式比较简单,只需在pom文件的build模块配置一个《maven-antrun-plugin插件》就可以实现,将所有架包指定到同一个文件夹目录存放,具体实现如下:
  • Maven聚合工程

    千次阅读 2022-04-01 23:07:37
    其实,maven除了可以通过pom坐标的方式去引入依赖,我们还可以通过maven聚合工程的方式去实现模块的复用。 一、单体项目 我们传统的项目,一般后端采样MVC的架构,会分层,分为dao层,service成,controller层,...
  • spring-boot-maven-plugin打包出来的jar是不可依赖的 我的项目的依赖关系 其中service依赖mapper 问题:在对service进行install安装依赖或package打包时间报错找不到mapper 原因: mapper中错误引入插件spring-...
  • <build> <plugins> <plugin>...org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <version>2.10</version>
  • spring boot项目在引入org.junit.Test 做单元测试后,maven不管是做package还是install一直报错,提示: Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.22.2:test 解决方法: pom文件...
  • maven打包:jar,war,pom jar:默认的打包方式,打包成jar用作jar包使用。例如hsweb-commons,它就是存放一些其他工程都会使用的类,工具类。我们可以在其他工程的pom文件中去引用它 war:将会打包成war,发布在...
  • MAVEN聚合工程的创建和打包操作

    千次阅读 2019-06-23 10:43:05
    Eclipsehttps://blog.csdn.net/erhei0317/article/details/52686837 Ideahttps://www.cnblogs.com/limn/p/9363416.html
  • Maven打包项目右键Run as-->Maven build...--> 出来下面的界面,注意红色部分的填写,Goals填写package表示打包,下面的Skip Tests表示打包时不执行单元测试。点击Run 就打包成功了,jar包在空间下/项目名/...
  • 一、Maven Module 项目 1、Maven Module :Maven 多模块项目,将... 如何理解Maven的聚合和继承.note) 2、Maven Module 聚合项目特点: 2.1、必须有父pom才能创建 Maven Module 项目 3、Eclipse中创建Maven Module项目
  • 方法如下: 修改后两个项目启动的时候就不会报端口已占用了 在打包得时候,发现子项目中的pom.xml报错了,提示找不到parent里继承的父项目,原因是父项目没有build就不会加入到maven仓库,所以子项在build的时候去...
  • 一、创建项目: https://blog.csdn.net/Timeguys/article/details/97934606 比如我想创建的项目结构如图: ——guli-parent(总父项目外壳) —— ——common(本地工具父项目外壳) —— —— ——common-...
  • maven项目如何打包

    千次阅读 2020-06-07 16:07:01
    (1)胖包:将maven项目中的依赖包和项目打为一个包 。 (2)瘦包:直接打包,不打包依赖包,仅打包项目中的代码到JAR包中。 1.打瘦包 2.打胖包 第一种:只打胖包 快捷键:Alt+shirt+ctrl+s 定入口函数和胖包的...
  • Maven聚合工程打包问题项目场景:问题描述:原因分析:解决方案: 详细讲解:https://www.cnblogs.com/lenve/p/11156340.html 项目场景: 使用Maven的聚合工程开发SpringCloud项目打包时报错 问题描述: ...
  • maven的web聚合项目打包 1.首先将相关项目install 然后进入到maven的仓库中查看打包好的项目 打包路径可以看install中的信息(很清楚),当然也可以根据你所使用的maven的仓库路径,如下图 2.解读打包好的包的...
  • 最近建了一个新的maven聚合工程,provider依赖于api模块,打包的时候一直提示缺少api中的类,但是编译器查看却是完全正常的,没有报红。 解决 在建api的时候勾选了lombok,idea自动添加了此依赖,并且添加了如下...
  • Maven聚合项目多模块打包,打不进其他工程包 1、比如:Zuul项目里面引用Common公共工程,打包报错找不到这个公共工程里面某些方法,解决方案如下: 在Common工程的Pom里面添加上下面这段代码 <build> <...
  • 一般用于分模块开发,最后整体打包发布,聚合项目一定是父子工程,而父子工程不一定是聚合工程。 为什么要使用聚合? 将多个工程拆分为模块后,需要手动逐个安装到仓库后依赖才能够生效。修改源码后也需要逐个手动...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,788
精华内容 4,315
关键字:

maven聚合项目怎么打包