Java 如何使用GradlePublish插件将proguard JAR发布为Maven工件

我正试图将Gradle 6.0.1 ProGuard插件创建的模糊JAR发布到Maven存储库中。在过去的几天里，我学到了很多关于Gradle配置、变体和工件的知识，但我似乎无法做到这一点。我相信相关文件就是其中之一

我创造了一个新的世界

如果我在这个项目上运行

/gradlew publish

，我会得到以下错误

Execution failed for task ':publishMyLibraryPublicationToMyRepoRepository'.
> Failed to publish publication 'myLibrary' to repository 'myRepo'
   > Invalid publication 'myLibrary': multiple artifacts with the identical extension and classifier ('jar', 'null').

我还尝试了不推荐的

maven

插件。不幸的是，这个插件忽略了定制的ProGuard jar

有人能给我一些建议，告诉我如何用proguard任务中模糊的JAR替换JAR任务中原来的JAR吗

编辑： 我能够从中得出一个解决方案。Github上的最小示例包含修补版本。随便看看。我将把工作build.gradle放在下面的答案中。

添加

classifier=“proguard”

解决了这个问题，尽管我不熟悉proguard来确定发布是否正确

artifacts {
    proguard(new File(proguard.outJarFiles[0])) {
        builtBy(proguard)
        classifier = "proguard"
    }
}

以下是为我发布的内容：

我可以看到原来的JAR是592字节，而proguard是410字节，所以我假设它工作正常

此外，在调试您的问题时，我进行了重构，以使用我建议使用的

import proguard.gradle.ProGuardTask

plugins {
    `java-library`
    `maven-publish`
}

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath("net.sf.proguard:proguard-gradle:6.2.2")
    }
}

group = "org.example"
version = "1.0.0"

repositories {
    jcenter()
}

configurations {
    val implementation by this
    val runtimeOnly by this
    create("proguard") {
        isCanBeConsumed = false
        isCanBeResolved = false
        extendsFrom(implementation, runtimeOnly)
        attributes {
            attribute(Attribute.of("org.gradle.usage", String::class.java), Usage.JAVA_API)
            attribute(Attribute.of("org.gradle.category", String::class.java), Category.LIBRARY)
            attribute(Attribute.of("org.gradle.libraryelements", String::class.java), LibraryElements.JAR)
            attribute(Attribute.of("org.gradle.dependency.bundling", String::class.java), Bundling.EXTERNAL)
        }
    }
}

dependencies {
    api("org.apache.commons:commons-math3:3.6.1")
    implementation("com.google.guava:guava:23.0")
    testImplementation("junit:junit:4.12")
}

val proguard by tasks.registering(ProGuardTask::class) {
    description = "Optimizes and obfuscates the created distribution jar."
    dependsOn(tasks.named("jar"))
    verbose()

    injars("$buildDir/libs/${project.name}-${project.version}.jar")
    outjars("$buildDir/proguard/${project.name}-${version}.jar")

    if (System.getProperty("java.version").startsWith("1.")) {
        libraryjars("${System.getProperty("java.home")}/lib/rt.jar")
    } else {
        libraryjars(mapOf("jarfilter" to "!**.jar", "filter" to "!module-info.class"), "${System.getProperty("java.home")}/jmods/java.base.jmod")
    }

    libraryjars(configurations.named("runtimeClasspath").get().files)

    printmapping("out.map")

    keep("""
        public class * {
            public protected *;
        }
    """.trimIndent())

    keepclassmembers(mapOf("allowoptimization" to true), """
        enum * {
            public static **[] values();
            public static ** valueOf(java.lang.String);
        }
    """.trimIndent())

    keepclassmembers("""
        class * implements java.io.Serializable {
            static final long serialVersionUID;
            static final java.io.ObjectStreamField[] serialPersistentFields;
            private void writeObject(java.io.ObjectOutputStream);
            private void readObject(java.io.ObjectInputStream);
            java.lang.Object writeReplace ();
            java.lang.Object readResolve ();
        }
    """.trimIndent())

    overloadaggressively()
}


val javaComponent = project.components.findByName("java") as AdhocComponentWithVariants
javaComponent.addVariantsFromConfiguration(configurations.getByName("proguard")) {
    // I have no idea what I should do here and the documentation is very confusing
}

publishing {
    publications {
        create<MavenPublication>("myLibrary") {
            from(components["java"])
            artifact(proguard.get().outJarFiles[0]) {
                builtBy(proguard.get())
                classifier = "proguard"
            }
        }
    }

    repositories {
        maven {
            name = "myRepo"
            url = uri("file://${buildDir}/repo")
        }
    }
}

tasks.named("publish").configure {
    dependsOn(tasks.named("proguard"))
}

导入proguard.gradle.ProGuardTask
插件{
`java库`
`马文出版社`
}
构建脚本{
存储库{
jcenter（）
}
依赖关系{
类路径（“net.sf.proguard:proguard-gradle:6.2.2”）
}
}
group=“org.example”
version=“1.0.0”
存储库{
jcenter（）
}
配置{
val的实现由这个
val runtimeOnly由此
创建（“proguard”）{
isCanBeConsumed=false
isCanBeResolved=false
ExtendFrom（实现，仅限运行时）
属性{
属性（attribute.of（“org.gradle.usage”，String:：class.java），usage.java\u API）
属性（attribute.of（“org.gradle.category”，String:：class.java），category.LIBRARY）
属性（attribute.of（“org.gradle.libraryelements”，String:：class.java），libraryelements.JAR）
属性（attribute.of（“org.gradle.dependency.bundling”，String:：class.java），bundling.EXTERNAL）
}
}
}
依赖关系{
api（“org.apache.commons:commons-math3:3.6.1”）
实现（“com.google.guava:guava:23.0”）
测试实施（“junit:junit:4.12”）
}
val proguard by tasks.注册（ProGuardTask:：class）{
description=“优化并模糊创建的分发jar。”
dependsOn（tasks.named（“jar”））
冗长的
injars（$buildDir/libs/${project.name}-${project.version}.jar）
outjars（$buildDir/proguard/${project.name}-${version}.jar）
if（System.getProperty（“java.version”）.startsWith（“1”））{
libraryjars（${System.getProperty（“java.home”）}/lib/rt.jar）
}否则{
libraryjars（mapOf（“jarfilter”到“！**.jar”，“filter”到“！module info.class”），“${System.getProperty（“java.home”）}/jmods/java.base.jmod”）
}
libraryjars（configurations.named（“runtimeClasspath”）.get（）.files）
printmapping（“out.map”）
保持
公共课*{
受公众保护*；
}
“.trimIndent（））
keepclassmembers（将“allowoptimization”映射为true），“”“
枚举*{
公共静态**[]值（）；
公共静态**valueOf（java.lang.String）；
}
“.trimIndent（））
keepclassmembers（“”）
类*实现java.io.Serializable{
静态最终长SerialVersionId；
静态final java.io.ObjectStreamField[]serialPersistentFields；
私有void writeObject（java.io.ObjectOutputStream）；
私有void readObject（java.io.ObjectInputStream）；
java.lang.Object writeReplace（）；
对象readResolve（）；
}
“.trimIndent（））
()
}
val javaComponent=project.components.findByName（“java”）作为AdhocComponentWithVariants
javaComponent.addVariantsFromConfiguration（configurations.getByName（“proguard”））{
//我不知道我应该在这里做什么，文档非常混乱
}
出版{
出版物{
创建（“myLibrary”）{
来自（组件[“java”]）
工件（proguard.get（）.outJarFiles[0]）{
builtBy（proguard.get（））
分类器=“proguard”
}
}
}
存储库{
马文{
name=“myRepo”
url=uri（“文件：//${buildDir}/repo”）
}
}
}
tasks.named（“publish”）.configure{
dependsOn（tasks.named（“proguard”））
}

我已经在问题中找到了解决方案，并相应地更新了Github项目。因为Stackoverflow喜欢本地信息而不依赖链接，所以我在这里发布了工作build.gradle文件作为答案。Github项目的其余部分只是由

gradleinit

创建的Java库项目

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'net.sf.proguard:proguard-gradle:6.2.2'
        classpath 'net.sf.proguard:proguard-base:6.2.2'
    }
}

plugins {
    id 'java-library'
    id 'maven-publish'
}

group = 'org.example'
version = '1.0.0'

repositories {
    jcenter()
}

dependencies {
    api 'org.apache.commons:commons-math3:3.6.1'
    implementation 'com.google.guava:guava:23.0'
    testImplementation 'junit:junit:4.12'
}

task createObfuscated(type: proguard.gradle.ProGuardTask, dependsOn: 'jar') {
    description 'Optimizes and obfuscates the created distribution jar.'
    verbose

    injars  "${buildDir}/libs/${project.name}-${version}.jar"
    outjars "${buildDir}/obf/${project.name}-${version}.jar"

    if (System.getProperty('java.version').startsWith('1.')) {
        libraryjars "${System.getProperty('java.home')}/lib/rt.jar"
    } else {
        libraryjars "${System.getProperty('java.home')}/jmods/java.base.jmod", jarfilter: '!**.jar', filter: '!module-info.class'
    }
    libraryjars configurations.findByName('runtimeClasspath').getFiles()

    printmapping 'out.map'

    keep 'public class * { \
        public protected *; \
    }'

    keepclassmembers allowoptimization: true, 'enum * { \
        public static **[] values(); \
        public static ** valueOf(java.lang.String); \
    }'

    keepclassmembers 'class * implements java.io.Serializable { \
        static final long serialVersionUID; \
        static final java.io.ObjectStreamField[] serialPersistentFields; \
        private void writeObject(java.io.ObjectOutputStream); \
        private void readObject(java.io.ObjectInputStream); \
        java.lang.Object writeReplace(); \
        java.lang.Object readResolve(); \
     }'

     overloadaggressively
}

task copyObfuscated(type: Copy, dependsOn: createObfuscated) {
    from "${buildDir}/obf"
    into "${buildDir}/libs"
    include '*.jar'
}

task deleteObfuscated(type: Delete, dependsOn: copyObfuscated) {
    delete '${buildDir}/obf'
}

task proguard dependsOn deleteObfuscated

publishing {
    publications {
        myLibrary(MavenPublication) {
            from components.java
        }
    }

    repositories {
        maven {
            name = 'myRepo'
            url = "file://${buildDir}/repo"
        }
    }
}

publish.dependsOn proguard

wrapper {
    gradleVersion '6.0.1'
}

---

谢谢我明天查一下，如果它有效的话给你打勾。嗨。不幸的是，这不是我想要的解决方案。我并不是简单地希望模糊化的JAR与常规JAR并排出现，而是希望用模糊化的JAR覆盖常规JAR。我发现一个线程做了非常类似的事情，并且能够导出一个解决方案。