精华内容
下载资源
问答
  • maven模块 相互依赖 打jar包流程及注意事项
    千次阅读
    2020-08-14 09:36:11
    1. 创建maven多模块项目,编写代码,添加子模块相互依赖;
    2. 举例来说,父项目为cloud-maven-learn,子项目为learn-server(springcloud 的服务治理和服务发现项目,集成eureka),learn-product(springcloud业务模块项目,产品项目,集成ribbon和feign),learn-user(springcloud业务模块项目,用户项目,集成ribbon和feign);
    3. 可以使用如下代码添加子模块之间的依赖:
    <dependency>
        <groupId>com.jianxin</groupId>
        <artifactId>learn-user</artifactId>
        <version>${project.version}</version>
    </dependency>
    
    1. 打包,首先打包learn-server项目,因为此项目为服务治理项目,其他项目打包时会TESTS,测试运行,会向该项目注册;
    2. 打包时,learn-server的pom中添加如下build依赖:
    <packaging>jar</packaging>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    
    1. maven窗口—clean—package,即可在target中找到打好的jar包。可以在cmd窗口中,使用java -jar learn-server.jar来运行项目。
    2. 然后打learn-product和learn-user项目为可运行的jar包,因为learn-product依赖learn-user项目,所以在打learn-product包之前,需要先将learn-user项目安装到本地maven仓库中。具体步骤为:
      7.1 在父项目cloud-maven-learn中clean,清理所有项目中的编译文件;
      7.2 在父项目cloud-maven-learn的pom中添加如下打包插件,并通过modules将子项目组织起来:
    <modules>
        <!-- 服务发现和治理模块 -->
        <module>learn-server</module>
        <!-- 产品服务模块 -->
        <module>learn-product</module>
        <!-- 用户服务模块 -->
        <module>learn-user</module>
    </modules>
        
    <build>
        <plugins>
            <!-- maven 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    

    7.3 注销learn-user项目中spring-boot-maven-plugin打包插件:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    

    7.4 点击learn-user的maven窗口的install,安装成功即可,并查看本地maven仓库是否有了learn-user相应的jar包;
    7.5 如果learn-user安装install正常,点击learn-product项目maven窗口的package,进行打包,注意此时learn-product项目的pom中需要有spring-boot-maven-plugin的打包插件,此时learn-product项目打包成功,其jar包内部含有learn-user的jar包依赖。
    8. 如果需要将learn-user项目打包为可执行jar包,需要在learn-user项目的pom中添加spring-boot-maven-plugin的插件依赖,然后clean—package,即可获得可运行的jar包。如果lean-user依赖于其他项目(如learn-product),在lean-user打包时,需要按第7点,先把被依赖项目(如learn-product)的spring-boot-maven-plugin的插件进行注销,install到本地仓库,lean-user再去package才可以。
    9. 总结一下:
    9.1 maven多模块项目打包,需要在父项目中添加:

    <build>
        <plugins>
            <!-- maven 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build> 
    

    9.2 子项目如果没有依赖,添加如下插件,进行clean—package:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    

    9.3 子项目之间有依赖,需要先把被依赖项目注销掉spring-boot-maven-plugin,install安装到本地maven仓库,然后依赖的项目进行clean —package;被依赖项目本身打可运行jar包,需要添加spring-boot-maven-plugin插件才可以。
    10. 项目示例见:https://gitee.com/manongfaner/cloud-maven-learn
    2021.10.09 续
    11. 如果报错为 IllegalState Found multiple @SpringBoot… 类似信息,理解为,依赖模块中,有多个@SpringbootApplication ,解决方式有:可以把@SpringBootTest 注解类注销掉,再重新install。
    12. 如果报错为:Could not find artifact com.cmcc.ict:community-corrections:pom:1.0-SNAPSHOT ,也就是没有发现父模块的jar包,可以在右侧maven窗口—》父模块项目—》Lifecycle—>clean---->install ,也就是安装父模块。
    13. 安装父模块过程中如果报错为,无法找到符号,无法找到包com.cmcc.ict.service等类似的报错,在使用了feign的前提下,考虑feign对打包的影响,可以将feign依赖模块中的service接口类,转义到其他模块中,如果common模块(common模块依赖feign即可)。
    14. 再次clean—》install,即可成功安装父模块 community-corrections。
    15. 安装成功父模块后,再重新尝试安装子模块,如gateway模块,即可,安装过程中,参考以上第7点添加maven编译插件和注销相关插件。

    更多相关内容
  • Maven本地子模块互相依赖

    千次阅读 2020-01-06 09:10:16
    很多时候,我们自己的项目有许多的子模块,之间互相有依赖,但是我们没有私服来发布打好的jar包. 最常见的就是本地有一个Util包, 随手写的其他项目想要引用, 却苦于没有私服. 把代码扔到同一个项目, 强迫症有忍不住. 这...

    很多时候,我们自己的项目有许多的子模块,之间互相有依赖,但是我们没有私服来发布打好的jar包.

    最常见的就是本地有一个Util包, 随手写的其他项目想要引用, 却苦于没有私服. 把代码扔到同一个项目, 强迫症有忍不住.

    这个问题Maven是有解决方案的.本质上还是打包发布,只是不再发布到远端的Maven仓库,而是打包完成之后, 将这个jar包安装到本地的maven即可.

    首先,在你的util子模块下执行下列命令.

    # 打包
    mvn clean package
    # 安装到本地mvn
    mvn install:install-file -Dfile=your_jar_file_path.jar -DgroupId=your_groupId -DartifactId=your_artifactId -Dversion=your_version
    # 检查是否安装成功
    ll ~/.m2/your_groupId/your_artifactId/
    

    之后, 在需要引入这个jar包的项目的pom.xml文件中,按照正常使用添加即可.

        <dependency>
            <groupId>your_groupId</groupId>
            <artifactId>your_artifactId</artifactId>
            <version>your_version</version>
        </dependency>
    

    当mvn需要引入的时候,会自动从本地仓库去加载的.


    完。





    联系我

    最后,欢迎关注我的个人公众号【 呼延十 】,会不定期更新很多后端工程师的学习笔记。
    也欢迎直接公众号私信或者邮箱联系我,一定知无不言,言无不尽。

    以上皆为个人所思所得,如有错误欢迎评论区指正。

    欢迎转载,烦请署名并保留原文链接。

    联系邮箱:huyanshi2580@gmail.com

    更多学习笔记见个人博客或关注微信公众号 <呼延十 >------>呼延十

    展开全文
  • 直接在父pom文件引入如下插件将会导致Maven打的微服务Jar包不会将外部依赖导入其中,且其他模块依赖模块的时候可能出现找不到类的报错。即无法通过 java -jar xxx.jar 命令来启动服务。 <build> <...

    场景

    最近在学习使用Jenkins自动化部署分布式微服务的时候,需要将微服务打成Jar包发送到服务器制作成镜像供Jenkins拉取运行,了解到 spring-boot-maven-plugin 插件可以完成Maven工程的打包任务。

    问题

    直接在父pom文件引入如下插件将会导致Maven打的微服务Jar包不会将外部依赖导入其中,且其他模块在依赖本模块的时候可能出现找不到类的报错。即无法通过 java -jar xxx.jar 命令来启动服务。

    <build>
    
        <plugins>
    
            <plugin>
    
                <groupId>org.springframework.boot</groupId>
    
                <artifactId>spring-boot-maven-plugin</artifactId>
    
            </plugin>
    
        </plugins>
    
    </build>
    

    原因

    spring-boot-maven-plugin 打出来的Jar包默认是不可依赖的,需要进行一些额外的配置。
    比如一个微服务工程中,往往会抽取出来一个 common 公共模块,在 common 公共模块中使用了 spring-boot-maven-plugin 的默认配置build,其他依赖了 common 模块的比如 provider 或者 order 在使用打包命令进行打包时就会出错,错误是在 provider 或者 order 中找不到 common 中的类,原因就是此插件默认默认打包出来的Jar是不可依赖的。

    解决方案

    在父工程pom文件和公共模块pom文件做一些修改

    <!-- 父pom -->
    
    <build>
    
        <plugins>
    
            <!-- 资源文件拷贝插件 -->
    
            <plugin>
    
                <groupId>org.apache.maven.plugins</groupId>
    
                <artifactId>maven-resources-plugin</artifactId>
    
                <configuration>
    
                    <encoding>UTF-8</encoding>
    
                </configuration>
    
            </plugin>
    
            <!-- Java编译插件 -->
    
            <plugin>
    
                <groupId>org.apache.maven.plugins</groupId>
    
                <artifactId>maven-compiler-plugin</artifactId>
    
                <configuration>
    
                    <source>1.8</source>
    
                    <target>1.8</target>
    
                    <encoding>UTF-8</encoding>
    
                </configuration>
    
            </plugin>
    
            <!-- maven打包插件 -->
    
            <plugin>
    
                <groupId>org.springframework.boot</groupId>
    
                <artifactId>spring-boot-maven-plugin</artifactId>
    
                <executions>
    
                    <execution>
    
                        <goals>
    
                            <goal>repackage</goal>
    
                        </goals>
    
                    </execution>
    
                </executions>
    
            </plugin>
    
        </plugins>
    
    </build>
    
    
    
    <!-- common pom -->
    
    <build>
    
        <plugins>
    
            <plugin>
    
                <groupId>org.springframework.boot</groupId>
    
                <artifactId>spring-boot-maven-plugin</artifactId>
    
                <!-- 这个属性为可执行jar包的名字后缀 -->
    
                <configuration>
    
                    <classifier>exec</classifier>
    
                </configuration>
    
            </plugin>
    
        </plugins>
    
    </build>
    
    <!-- 其余子模块会继承父模块 -->
    

    配置完后在进行 mvn clean package 或者 mvn clean install 命令打包服务后,可用 java -jar xxx.jar 正常启动。

    其他细节

    在使用 spring-boot-maven-plugin 插件进行打包操作的时候强烈建议指明JDK版本,不然可能在使用了一些Java8新特性的时候可能受到类似不识别Lambda,请使用Resource8这样的错误。

    <properties>
    
        <java.version>1.8</java.version>
    
        <maven.compiler.source>1.8</maven.compiler.source>
    
        <maven.compiler.target>1.8</maven.compiler.target>
    
    </properties>
    

    原文参考:
    https://blog.csdn.net/DamonREN/article/details/85091900

    展开全文
  • Idea + Maven(多个模块) Spring+SpringMVC + MyBatis WebSocket Mybatis发电机 Redis 四郎 二维码 HttpURLConnection Spring预定 ExtJS集成失败 项目建造 创建Maven项目 添加模块 使用方式一添加ssmArtifact-...
  • 现研发经理要求将所有工程进行整合和规范化,所以抽出一个parent父工程,base基础模块(包含一些公用的实体类和工具类等),以及其他子模块(Module A、 Module B …)。Module A 以及Module B工程都需要依赖base工程。 ...

    场景:

    因为之前用到的是,基于springboot框架所搭建的maven工程,而且都是相互独立的。现研发经理要求将所有工程进行整合和规范化,所以抽出一个parent父工程,base基础模块(包含一些公用的实体类和工具类等),以及其他子模块(Module A、 Module B …)。Module A 以及Module B工程都需要依赖base工程。
    问题:

    在对Module A进行打包时,出现问题:Module A中所依赖的base工程的util程序包不存在。即使能打包成功,用java -jar启动jar包也会报Class Not Found,依赖的base工程的类找不到。
    解决方案:

    未解决之前在base工程的pom.xml中maven插件的配置如下:

        <build>  
            <plugins>  
                <plugin>  
                    <groupId>org.springframework.boot</groupId>  
                    <artifactId>spring-boot-maven-plugin</artifactId>  
                </plugin>  
            </plugins>  
        </build>  
    

    解决base工程的pom.xml的maven配置如下:

        <build>  
            <plugins>  
                <plugin>  
                    <groupId>org.springframework.boot</groupId>  
                    <artifactId>spring-boot-maven-plugin</artifactId>  
                    <configuration>  
                        <classifier>exec</classifier>  
                    </configuration>  
                </plugin>  
            </plugins>  
        </build>  
    

    原因分析:

    spring-boot-maven-plugin打包出来的jar是不可依赖的

    我们现在整合后的maven项目有一个parent工程,打包类型为pom,下面多个spring-boot工程作为它的module,分别为base和moduleA,moduleB。假如moduleA依赖于base。如果你在base中使用了spring-boot-maven-plugin的默认配置build,或者在parent工程中使用spring-boot-maven-plugin的默认配置build。那么在clean package的时候会发现moduleA找不到base中的类。原因就是默认打包出来的jar是不可依赖的。

    解决方案:

        官方告诉我们,你如果不想移代码,好吧,我这样来给你解决,给你打两个jar包,一个用来直接执行,一个用来依赖。于是,你需要指定一个属性classifier,这个属性为可执行jar包的名字后缀。比如我设置<classifier>exec</classifier>,原项目名为Vehicle-business。那么会得到两个jar:Vehicle-business.jar和Vehicle-bussiness-exec.jar
    
         官方文档位置:84.5 Use a Spring Boot application as a dependency
    
         总结:回到聚合maven上,如果你在parent工程中使用了spring-boot-maven-plugin作为builder,那么你的依赖module一定要用解决方案二来设置。否则你不在parent工程中用spring-boot-maven-plugin作为builder,而在需要打包的module上使用。
    

    一般parent工程的maven插件配置如下:

        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                     <configuration>
                  		<source>1.8</source>
                  		<target>1.8</target>
                	</configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    

    被依赖的maven子模块的maven插件配置如下(其余maven子模块就不需要配置):

         <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <classifier>exec</classifier>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    

    其他的坑:

    1.jdk8一定要指明

         不指明的话在开发工具里运行没有一点问题,如果你没有用到java8的特性打包也没有问题。一旦你用到了java8的特性,而且使用spring-boot-maven-plugin作为builder,一定要指明jdk版本。不然你会收到类似不识别Lambda,请使用resource8这样的错误。
    
    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
      </properties>
    

    2.BOOT-INF陷阱

          这个问题就很恶心了。这个时候你已经打包成功,你会发现运行jar的时候报错为file not found,而且不告诉你是什么文件。你打开jar去看,发现需要的lib,配置文件,class一样也不缺。
    
          其实这里要说一个概念,spring-boot在打包后,会把文件拷贝到BOOT-INF/Classes之下,这个时候你原来定义的扫描包路径将失效。而这个问题官方文档根本没讲,还是我没有看到。
    
          这个陷阱在你使用packages定义扫描路径的时候等着你。或者获取工程下文件的时候。对于获取文件的话,可以在原路径前加上classes,当然你要区分开发环境或生产环境的话,你可以使用profile或者conditional来解决。如果是扫描包路径就恶心了,因为你加上classes之后,不报file not found了。而是不报错,只是警告你找不到hibernate的某些xml。但是你很可能根本没有使用hibernate。
    

    参考博客:https://blog.csdn.net/guduyishuai/article/details/60968728

    parent工程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 http://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>1.5.6.RELEASE</version>
        </parent>
     
        <groupId>com.demo</groupId>
        <artifactId>demo-parent</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
     
        <modules>
            <module>demo-base</module>
            <module>demo-sync</module>
            <module>demo-pattern</module>
        </modules>
     
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
            <springboot.version>1.5.6</springboot.version>
        </properties>
     
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
            <!--WEB层-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
     
            <!--测试-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-ribbon</artifactId>
            </dependency>
     
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <!-- framework启动器 模板引擎 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-freemarker</artifactId>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
                <version>1.3.7.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </dependency>
            <!-- Mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.2.8</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.2</version>
            </dependency>
     
            <!--fastjson-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.8</version>
            </dependency>
            <!-- 分页助手 -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>3.7.5</version>
            </dependency>
            <dependency>
                <groupId>com.github.jsqlparser</groupId>
                <artifactId>jsqlparser</artifactId>
                <version>0.9.1</version>
            </dependency>
            <!-- 通用Mapper -->
            <dependency>
                <groupId>com.github.abel533</groupId>
                <artifactId>mapper</artifactId>
                <version>2.3.4</version>
            </dependency>
            <!-- MySql连接驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <!-- 连接池 -->
            <dependency>
                <groupId>com.jolbox</groupId>
                <artifactId>bonecp-spring</artifactId>
                <version>0.8.0.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
                <exclusions>
                    <exclusion> <!-- exclude掉spring-boot的默认log配置 -->
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <!-- log4j日志 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-log4j2</artifactId>
            </dependency>
     
            <!-- 有其他jar依赖log4j -->
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-1.2-api</artifactId>
                <version>2.8.2</version>
            </dependency>
     
            <dependency>
                <groupId>com.lmax</groupId>
                <artifactId>disruptor</artifactId>
                <version>3.3.6</version>
            </dependency>
            
    		<!-- https://mvnrepository.com/artifact/org.dom4j/dom4j -->
    		<dependency>
    		    <groupId>org.dom4j</groupId>
    		    <artifactId>dom4j</artifactId>
    		    <version>2.1.0</version>
    		</dependency>
     
            <!--在线文档-->
            <!--swagger本身不支持spring mvc的,springfox把swagger包装了一下,让他可以支持springmvc-->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>2.6.1</version>
            </dependency>
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger-ui</artifactId>
                <version>2.6.1</version>
            </dependency>
        </dependencies>
     
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Camden.SR7</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <build>
            <plugins>
                <!-- 资源文件拷贝插件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <configuration>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                <!-- java编译插件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
     
    </project>
    

    base工程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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     
        <artifactId>demo-base</artifactId>
        <modelVersion>4.0.0</modelVersion>
     
        <parent>
            <groupId>com.demo</groupId>
            <artifactId>demo-parent</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
     
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    				<configuration>
    					<classifier>exec</classifier>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    	
    </project>
    

    sync的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">
     
      <artifactId>demo-sync</artifactId>
      <modelVersion>4.0.0</modelVersion>
     
      <parent>
        <groupId>com.demo</groupId>
        <artifactId>demo-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
      </parent>
      
      <dependencies>
      	<dependency>
      		<groupId>com.demo</groupId>
      		<artifactId>demo-base</artifactId>
      		<version>1.0-SNAPSHOT</version>
      	</dependency>
      </dependencies>
      
    </project>
    
    展开全文
  • 想在 eclipse 中创建一个拥有子模块maven 工程,因为在实际项目中用到的就是多模块工程,原谅我不知道这个工程是如何创建的,因为以前没有接触过,在这里记录下创建工程。 创建父 maven 工程: 打开 eclipse...
  • 转载:... 场景: 因为之前用到的是,基于springboot框架所搭建的maven工程,而且都是相互独立的。现研发经理要求将所有工程进行整合和规范化,所以抽...
  • maven模块之间的互相依赖问题

    千次阅读 2020-02-25 18:48:34
    处理模块之间的依赖关系(模块之间不能有循环依赖) Error:java: Annotation processing is not supported for module cycles. Please ensure that all modules from cycle [basic_core,basic_util,crm_common,crm_...
  • 本来应该是开发包可以单边引用产品基础包的,由于开发不规范最终导致产品基础包和开发包存在了相互引用。针对当时我们的项目我考虑了两种方案:方案一、将产品基础包和开发包整合成一个源码包,再重构为Maven项目。...
  • maven模块之间的依赖关系

    万次阅读 2018-05-11 15:12:42
    Guns项目改项目名和包名出错:1、JDK版本,maven默认使用1.52、模块之间的依赖关系,即&...,但是出错,clean和install不能解决3、修改了子模块对父模块引用&lt;relativePath&gt;出错...
  • 最近在学习spring cloud的时候,发现一个问题,就是在模块打包的时候,有一个依赖公共模块的部分,总是在打包的时候提示找不到公共模块依赖,导致打包出错,下面是模块结构.WeChat Screenshot_20190610145243.png首先...
  • 假设有一个父maven项目project,有三个子模块producer,consumer和common,其中producer依赖common,consumer也依赖于common,也就是producer,consumer的pom.xml文件中导入了common模块 第一种方式:使用idea...
  • 问题描述: 项目有多个模块,然后把一些公共的抽取出来(比如说实体类,Service等)单独为一个模块,然后再...很简单,对父工程进行 clean install,然后再对想要打包的子模块进行 clean package 即可! 例如: ...
  • 最近项目上使用的是idea ide的多模块话,需要模块之间的依赖,比如说系统管理模块依赖授权模块进行认证和授权,而认证授权模块需要依赖系统管理模块进行,然后,我就开始相互依赖,然后出现这样的问题: “Could ...
  • 如图,左侧是一个父子工程,其中子模块 api 已经 install 右侧是个单独工程,引入 api的maven依赖,找不到
  • maven项目模块之间的互相依赖问题

    千次阅读 2020-04-14 17:44:24
    报错信息: Error:java: Annotation processing is not supported for module cycles. Please ensure that all modules from cycle [模块A,模块B,模块C] are excluded from annotation ...maven項目在分模块进行...
  • 子模块的pom.xml中配置了依赖后,另一个子模块却不能自动导入这些依赖? 问题分析: 子模块的pom.xml:这里主要看这两个用于test单元测试的依赖包! 子模块:由于没有导入到这些依赖包,所以程序报红. 通过查阅...
  • 关于Maven依赖冲突

    2021-11-25 00:08:21
    文章目录Maven依赖冲突场景场景1-重构同包同名类场景2-同包同名类与环境兼容性场景3-同包同名类内部逻辑不同综上Maven依赖传递Maven依赖传递包选择逻辑-仲裁机制Maven scope属性Maven冲突处理工具Maven依赖树命令...
  • maven项目子模块相互引用无效

    万次阅读 2018-09-17 15:36:36
    搭建maven项目的时候,dao模块引用beans模块的pojo,发现没有效果 dao模块是新建的模块,都没配置什么怎么会引用不到 叫大佬过来演示排错了一波 ...1.子模块依赖重复,因为之前创建了几次dao,IDEA父项目自动...
  • Maven模块间循环依赖的解决方案以及分析 问题重现 在coding中Maven各个模块之间经常会有互相引用的问题,当A模块中需要用B模块的功能,而B模块很有可能也需要用到A模块中的功能,这样就会存在A模块中引入了B,而B...
  • 在对Module A进行打包时,出现问题:Module A中所依赖子模块工程的util程序包不存在。即使能打包成功,用java -jar启动jar包也会报Class Not Found,依赖子模块工程的类找不到。 错误如下: maven-
  • 需求:idea上搭建maven项目 moduleA,moduleA 依赖moduleB 和 moduleC,moduleC 依赖moduleB .其中moduleB 和moduleC中只有serve层到数据库层的文件方式一,moduleA引用moduleB和moduleC的jar形式。...
  • 先把你添加的其他依赖全部去掉,只剩下单纯的B-A,B-C的依赖,然后先 maven install父项目,把父子关系建立起来,父项目A中要包括duimaven插件的引用,例如: &lt;build&gt;  &lt;plugins&gt;  ....
  • 通过执行mvn -pl 模块名 -am实现存在相互依赖模块打包
  • Maven模块相互打包问题

    千次阅读 2020-08-14 16:44:48
    本人最近转java,用Maven+SpringBoot搭建了一个多模块的基础框架,在打包的时候,总是出错,没处理好各模块相互之间的依赖关系,折腾了一个下午,终于解决了。 项目中一共有3个模块,如下: ![在这里插入图片描述]...
  • 正常情况下,循环依赖是...但子模块A需要用到子模块core中定义的一些接口,反过来,子模块core启动时,需要把子模块A实现的逻辑加入,造成子模块A依赖子模块core,core依赖于A的循环依赖问题。 2. 解决方案 bui...
  • SpringBoot+Maven模块环境, 模块AdminWeb:AdminLoginController.class 模块AdminLogin:AdminLoginService.class AdminLoginController中依赖了AdminLoginService 当maven包引入了,使用@Autowired时,未正确...
  • 场景是,一个maven父项目,两个module,其中一个module是conmon包,另外一个module是业务包(例如系统管理相关的),然后业务包要依赖common包,然后启动 业务包的时候,提示:“程序包不存在”,然后看了半天博客...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,652
精华内容 3,060
关键字:

maven子模块相互依赖