如何使用Gradle Publish插件将proGuard JAR发布为Maven构件

Question

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

我创建了一个简单的示例，展示了我在Github上的预期设置。

如果我运行/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变成下面的答案。

Answer 1

正如我对这个问题所做的编辑一样，我找到了一个解决方案，并相应地更新了Github项目。因为Stackoverflow喜欢本地信息，而不依赖于链接，所以我发布了工作构建。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'
}

Answer 2

添加分类器="proGuard"解决了这个问题，尽管我不熟悉proGuard来确定发布是否正确。

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

以下是为我发表的：

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

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

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"))
}