Gradle未生成在META-INF中嵌入pom.xml的Springboot Library Jar

mcdcgff0  于 2024-01-06  发布在  Spring
关注(0)|答案(2)|浏览(199)

我有Springboot多模块库项目，Gradle 7.4和Springboot 3.2如下所示

  1. buildscript {
  3.     dependencies {
  4.         classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.21.0"
  5.     }
  6. }
  7. plugins {
  8.     id "com.diffplug.spotless" version "6.8.0"
  9.     id 'io.spring.dependency-management' version '1.1.4'
  10.     id 'org.springframework.boot' version '3.2.0' apply false
  11.     id "org.openapi.generator" version "6.0.0"
  12.     id "org.hidetake.swagger.generator" version "2.19.2"
  13. }
  15. ext.versions = [
  16.         springBoot        : '3.2.0',
  17.         springCloud       : '2022.0.4',
  18.         micrometer        : '1.10.3',
  19.         commonLogging     : '1.2',
  20. ]
  22. allprojects {
  23.     apply plugin: 'io.spring.dependency-management'
  24.     group 'com.springboot.web.library'
  25.     version = '0.0.3-SNAPSHOT'
  27.     dependencyManagement {
  28.         imports {
  29.             mavenBom("org.springframework.boot:spring-boot-dependencies:${versions.springBoot}")
  30.             mavenBom("org.springframework.cloud:spring-cloud-dependencies:${versions.springCloud}")
  31.         }
  32.         dependencies {
  33.             //dependency group: 'io.micrometer', name: 'micrometer-registry-prometheus', version: versions.micrometer
  34.             dependency group: 'commons-logging', name: 'commons-logging', version: versions.commonLogging
  35.         }
  36.     }
  37. }
  39. subprojects {
  40.     apply plugin: 'java'
  41.     apply plugin: 'maven-publish'
  42.     apply plugin: "com.diffplug.spotless"
  44.     java {
  45.         toolchain {
  46.             languageVersion = JavaLanguageVersion.of(17)
  47.         }
  48.         withSourcesJar()
  49.     }
  51.     //https://dev.to/ankityadav33/standardize-code-formatting-with-spotless-2bdh
  52.     spotless {
  53.         java {
  54.             //googleJavaFormat("1.15.0")
  55.             target fileTree('.') {
  56.                 include '**/*.java'
  57.                 exclude '**/build/**', '**/build-*/**'
  58.             }
  59.             importOrder()
  60.             toggleOffOn()
  61.             palantirJavaFormat()
  62.             removeUnusedImports()
  63.             trimTrailingWhitespace()
  64.             endWithNewline()
  65.         }
  66.     }
  68.     afterEvaluate {
  69.         def spotless = tasks.findByName('spotlessApply')
  70.         if (spotless) {
  71.             tasks.withType(JavaCompile) {
  72.                 finalizedBy(spotless)
  73.             }
  75.         }
  76.     }
  78.     dependencies {
  79.         implementation 'org.springframework.boot:spring-boot-starter'
  80.         compileOnly 'org.projectlombok:lombok:1.18.22'
  81.         annotationProcessor 'org.projectlombok:lombok:1.18.22'
  82.         testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
  83.     }
  85.     repositories {
  86.         mavenLocal()
  87.         mavenCentral()
  88.     }
  90.     test {
  91.         useJUnitPlatform()
  92.     }
  93.     jar {
  94.         enabled = true
  95.         archiveClassifier=''
  96.     }
  97. }

字符串
下面是我的module-commons build.gradle文件

  1. plugins {
  2.     id 'java-library'
  3. }
  5. dependencies {
  6.     compileOnly 'com.fasterxml.jackson.core:jackson-databind:2.16.0'
  7.     compileOnly 'com.fasterxml.jackson.core:jackson-core:2.16.0'
  8.     compileOnly 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.16.0'
  9.     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
  10.     testImplementation 'org.mockito:mockito-core:5.8.0'
  11.     testImplementation 'org.projectlombok:lombok:1.18.30'
  12.     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
  13.     compileOnly 'org.projectlombok:lombok:1.18.30'
  14. }
  16. publishing {
  17.     publications {
  18.         mavenJava(MavenPublication) {
  19.             artifact jar
  20.         }
  21.     }
  22.     repositories {
  23.         mavenLocal()
  24.     }
  25. }

型
我在module-commons中有下面的类

  1. package com.springboot.web.library.commons.utils;
  2. import com.fasterxml.jackson.core.JsonProcessingException;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  5. public class JsonUtils {
  6.     public String serialize(Object object) throws JsonProcessingException {
  7.         ObjectMapper objectMapper = new ObjectMapper();
  8.         return objectMapper.writeValueAsString(object);
  9.     }
  10. }

型
我正在运行gradle build jar module-commons:publishToMavenLocal命令，以将该命令发布到本地maven repo。
我将在springboot-demo项目中导入module-commons库作为implementation 'com.springboot.web.library:module-commons:0.0.3-SNAPSHOT'，下面是springboot-demo项目build.gradle

  1. plugins {
  2.     id 'java'
  3.     id 'org.springframework.boot' version '3.2.0'
  4.     id 'io.spring.dependency-management' version '1.1.4'
  5. }
  7. group = 'com.springboot.web'
  8. version = '1.0-SNAPSHOT'
  10. repositories {
  11.     mavenLocal()
  12.     mavenCentral()
  13. }
  15. dependencies {
  16.     implementation 'org.projectlombok:lombok:1.18.28'
  17.     testImplementation platform('org.junit:junit-bom:5.9.1')
  18.     testImplementation 'org.junit.jupiter:junit-jupiter'
  19.     implementation 'org.springframework.boot:spring-boot-starter'
  20.     testImplementation 'org.springframework.boot:spring-boot-starter-test'
  22.     implementation 'com.springboot.web.library:module-commons:0.0.3-SNAPSHOT'
  24. }
  26. test {
  27.     useJUnitPlatform()
  28. }

型
我在springboot-demo项目中导入JsonUtils Main类如下

  1. package com.springboot.web.library.commons;
  3. import com.springboot.web.library.commons.utils.JsonUtils;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class Main {
  9.     @lombok.SneakyThrows
  10.     public static void main(String[] args) {
  11.         JsonUtils jsonUtils = new JsonUtils();
  12.         jsonUtils.serialize("test");
  13.         System.out.println("Hello world!");
  14.     }
  15. }

型
在运行Main类时，由于module-commons jar在META-INF目录中没有包含pom.xml的maven.com.springboot.web.library.module-commons目录，因此Gradle无法解析module-commons中引用的Jackson库，因此出现了编译器错误。我已经尝试了Github和Stackoverflow中提供的许多解决方案，但到目前为止都没有运气。我感谢任何人可以帮助解决这个问题。完整的项目可以在这里找到https://github.com/JavaSpringBooteer/springboot-gradle-library

  1. D:\Git\springboot-gradle-library\springboot-demo\src\main\java\com\springboot\web\library\commons\Main.java:12: error: cannot access JsonProcessingException
  2.         jsonUtils.serialize("test");
  3.                            ^
  4.   class file for com.fasterxml.jackson.core.JsonProcessingException not found

型
尝试Github和Stackoverflow的解决方案来调整build.gradle

spring-boot

2条答案

按热度按时间
carvr3hs

carvr3hs1#

你的项目应该是：

  1. [ Gradle Build System ]
  2.         |
  3.         |---[ module-commons Library ]
  4.         |        |---[ build.gradle ]
  5.         |        |---[ src ]
  6.         |        |---[ dependencies (Jackson, Lombok, etc.) ]
  7.         |
  8.         |---[ springboot-demo Project ]
  9.                  |---[ build.gradle ]
  10.                  |---[ src ]
  11.                  |---[ dependencies (including module-commons) ]

字符串
您需要修改您的module-commons构建脚本，以在发布的工件中包含依赖关系信息，这可以通过正确配置maven-publish plugin来实现。
你的module-commons/build.gradle是：

  1. publishing {
  2.     publications {
  3.         mavenJava(MavenPublication) {
  4.             from components.java
  5.             artifact sourcesJar
  7.             pom.withXml {
  8.                 def dependenciesNode = asNode().appendNode('dependencies')
  9.                 configurations.compileClasspath.allDependencies.each { dep ->
  10.                     def dependencyNode = dependenciesNode.appendNode('dependency')
  11.                     dependencyNode.appendNode('groupId', dep.group)
  12.                     dependencyNode.appendNode('artifactId', dep.name)
  13.                     dependencyNode.appendNode('version', dep.version)
  14.                 }
  15.             }
  16.         }
  17.     }
  18.     repositories {
  19.         mavenLocal()
  20.     }
  21. }

型
这将包括主Java组件（from components.java），它确保编译的类和资源是发布的一部分。
它还向生成的POM文件中添加了一个自定义部分，其中列出了所有编译类路径依赖项。
运行./gradlew module-commons:publishToMavenLocal命令。将更新后的module-commons工件发布到本地Maven存储库后，构建并运行springboot-demo项目。它现在应该正确解析依赖项。

  1. Duplicated tag: 'dependencies'

型
我假设您的build.gradle中的pom.withXml块正在将一个新的<dependencies>节点附加到现有的POM结构中，该结构已经定义了一个<dependencies>标记。
让我们修改module-commons/build.gradle中的pom.withXml块，以正确处理现有的<dependencies>标记。

  1. publishing {
  2.     publications {
  3.         mavenJava(MavenPublication) {
  4.             from components.java
  5.             artifact sourcesJar
  7.             pom.withXml {
  8.                 def pomNode = asNode()
  9.                 // Find or create the 'dependencies' node
  10.                 def dependenciesNode = pomNode.children().find { it.name() == 'dependencies' }
  11.                 if (dependenciesNode == null) {
  12.                     dependenciesNode = pomNode.appendNode('dependencies')
  13.                 }
  15.                 configurations.compileClasspath.allDependencies.each { dep ->
  16.                     if (dep.group != null && dep.version != null) {
  17.                         def dependencyNode = dependenciesNode.appendNode('dependency')
  18.                         dependencyNode.appendNode('groupId', dep.group)
  19.                         dependencyNode.appendNode('artifactId', dep.name)
  20.                         dependencyNode.appendNode('version', dep.version)
  21.                     }
  22.                 }
  23.             }
  24.         }
  25.     }
  26.     repositories {
  27.         mavenLocal()
  28.     }
  29. }

型
在追加依赖项之前，检查它们的group和version是否不为null，以避免包含无效条目，这很重要。
将更新后的脚本应用于module-commons/build.gradle，并运行./gradlew clean build以确保正确应用所有更改并清除旧工件。
执行./gradlew module-commons:publishToMavenLocal。发布后，检查本地Maven仓库中的pom.xml，以确保其格式正确，没有重复的标记。
运行您的springboot-demo项目以检查问题是否已解决。
作为替代方法，您可以考虑清除任何现有的<dependencies>节点并重新创建它，而不是追加新的<dependencies>节点或尝试查找和增强现有节点。这将确保不会发生重复。
你的module-commons/build.gradle是：

  1. publishing {
  2.     publications {
  3.         mavenJava(MavenPublication) {
  4.             from components.java
  5.             artifact sourcesJar
  7.             pom.withXml {
  8.                 def pomNode = asNode()
  9.                 // Remove existing 'dependencies' node if present
  10.                 def dependenciesNode = pomNode.children().find { it.name() == 'dependencies' }
  11.                 if (dependenciesNode != null) {
  12.                     dependenciesNode.replaceNode {}
  13.                 }
  14.                 // Re-create the 'dependencies' node
  15.                 dependenciesNode = pomNode.appendNode('dependencies')
  16.                 configurations.compileClasspath.allDependencies.each { dep ->
  17.                     if (dep.group != null && dep.version != null) {
  18.                         def dependencyNode = dependenciesNode.appendNode('dependency')
  19.                         dependencyNode.appendNode('groupId', dep.group)
  20.                         dependencyNode.appendNode('artifactId', dep.name)
  21.                         dependencyNode.appendNode('version', dep.version)
  22.                     }
  23.                 }
  24.             }
  25.         }
  26.     }
  27.     repositories {
  28.         mavenLocal()
  29.     }
  30. }

型

展开查看全部
赞(0）分享  回复(0）举报  2024-01-06
moiiocjp

moiiocjp2#

您的Gradle构建版本没有在您的module-commons项目的META-INF目录中使用嵌入的pom.xml生成Sping Boot 库示例。当您将示例发布到Maven存储库时，需要使用此嵌入的pom.xml来正确解析依赖项。若要生成此pom.xml，您需要为您的module-commons项目配置MavenPublication。
以下是如何修改module-commons build.gradle文件以包含MavenPublication所需的配置：

  1. plugins {
  2.     id 'java-library'
  3.     id 'maven-publish' // Add the Maven Publish plugin
  4. }
  6. dependencies {
  7.     // Your dependencies
  8. }
  10. publishing {
  11.     publications {
  12.         mavenJava(MavenPublication) {
  13.             from components.java // This will include the Java component
  14.             pom {
  15.                 // Customize the generated POM here if needed
  16.                 // For example, you can add dependencies or other metadata
  17.                 // Example:
  18.                 withXml {
  19.                     def dependenciesNode = asNode().appendNode('dependencies')
  20.                     dependenciesNode.appendNode('dependency')
  21.                             .appendNode('groupId', 'com.fasterxml.jackson.core')
  22.                             .appendNode('artifactId', 'jackson-databind')
  23.                             .appendNode('version', '2.16.0')
  24.                             .appendNode('scope', 'compile')
  25.                 }
  26.             }
  27.         }
  28.     }
  29.     repositories {
  30.         mavenLocal()
  31.     }
  32. }

字符串
在发布块中，我们配置一个名为mavenJava的MavenPublication，它包含项目的Java组件。在pom块中，您可以根据需要自定义生成的POM。在上面的示例中，我已经展示了如何为jackson-databind的POM添加依赖项，因为它是项目的编译依赖项。
在对module-commons build.gradle文件进行这些更改后，再次运行gradle build module-commons：jumshToMavenLocal，它应该会在META-INF目录中生成带有嵌入式pom.xml的xml。这应该会解决springboot-demo项目中的依赖问题。

展开查看全部
赞(0）分享  回复(0）举报  2024-01-06
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com