Artifactory + 以编程方式自定义 Gradle 插件 (2022)

Question

我正在尝试创建一个自定义 gradle 插件（100% java），它将自动配置 Artifactory，从而避免需要以下 DSL：

artifactory {
contextUrl = "${artifactory_contextUrl}"   //The base Artifactory URL if not overridden by the publisher/resolver
publish {
    repository {
        contextUrl = "${artifactory_contextUrl}"
        repoKey = 'android-dev'
        username = "${artifactory_user}"
        password = "${artifactory_password}"
        maven = true

    }
}
resolve {
    repository {
        contextUrl = "${artifactory_contextUrl}"
        repoKey = 'android-dev-distributions'
        username = "${artifactory_user}"
        password = "${artifactory_password}"
        maven = true

    }
}
}

我正在尝试重新创建 @agrosner 自己的解决方案（来自 https://stackoverflow.com/a/25669431/1880280），但我缺少“ArtifactoryAction”。我到处都找不到。

@agrosner 发布的非工作版本是以下代码：

// Set up plugins so we never need to add them to a build.gradle
    project.getPlugins().apply(MAVEN);
    project.getPlugins().apply(ARTIFACTORY);
    project.setGroup(GROUP);

    // Add Artifactory repo to the repositories
    project.getRepositories().maven(new ArtifactoryAction(contextUrl + ARTIFACTORY_REPO_ENDPOINT, user, pass));

    // We will define the plugin convention here so all of our libraries do not need to
    // declare the artifactory closure manually
    ArtifactoryPluginConvention pluginConvention =
            ArtifactoryPluginUtil.getArtifactoryConvention(project);
    pluginConvention.setContextUrl(contextUrl);

    PublisherConfig publisherConfig = new PublisherConfig(pluginConvention);
    publisherConfig.setContextUrl(contextUrl);
    pluginConvention.setPublisherConfig(publisherConfig);

    // Use reflection to access private field
    PublisherConfig.Repository repository = null;

    Field[] fields = PublisherConfig.class.getDeclaredFields();
    for(Field field : fields) {
        if(field.getName().equalsIgnoreCase("repository")) {
            try {
                field.setAccessible(true);
                repository = (PublisherConfig.Repository) field.get(publisherConfig);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    if(repository != null) {
        repository.setPassword(pass);
        repository.setUsername(user);
        repository.setRepoKey(PUBLISHER_REPO_KEY);
        repository.setMavenCompatible(true);
    }

    GradleArtifactoryClientConfigUpdater.update(pluginConvention.getClientConfig(), project.getRootProject());

任何人都可以提供更新的 100% java 版本吗？

另外，下面的 DSL 会怎么样？

artifactory {
publish {
    repository {
        repoKey =  'default-gradle-dev-local' // The Artifactory repository key to publish to
        username = "${artifactory_user}" // The publisher user name
        password = "${artifactory_password}" // The publisher password
        maven       = true
    }
    defaults {
        publications('mavenJava')
        publishArtifacts = true
        publishPom = true
    }
}}

提前致谢

塞萨尔

ps。在@agrosner question thread 上发布的 DSL 版本对我没有用。我需要一个 Java 版本。

Answer 1

对于您与ArtifactoryAction 相关的第一个问题：这既不是 Gradle API 也不是 Artifactory 插件相关的 api，但很可能是响应作者自己实现的自定义类，作为声明他的自定义 Artifactory maven repo 的快捷方式。

见this API，用于声明maven仓库：

MavenArtifactRepository maven​(Action<? super MavenArtifactRepository> action)

所以你可以使用：

project.getRepositories().maven( mavenArtifactRepository -> {
     mavenArtifactRepository.setUrl(contextUrl + MAVEN_PUBLIC_REPO);
     mavenArtifactRepository.getCredentials().setUsername("user");
     mavenArtifactRepository.getCredentials().setPassword("password");
});

或将操作代码包装到 Action<? super MavenArtifactRepository> 的自定义实现中：

project.getRepositories().maven( new ArtifactoryAction(contextUrl + MAVEN_PUBLIC_REPO, "user", "password")        );

[...]
// custom action class, defined somewhere else
class ArtifactoryAction implements Action<MavenArtifactRepository> {
    private final String url, userName, password;

    ArtifactoryAction(String url, String userName, String password) {
        this.url = url; this.userName = userName; this.password = password;
    }

    @Override
    public void execute(MavenArtifactRepository target) {
        target.setUrl(url);
        target.getCredentials().setUsername(userName);
        target.getCredentials().setPassword(password);
    }
}

关于 artifactory { } DSL 的 java 翻译的另一个问题：请参阅下面的完整示例，其中包含一些内联 cmets。 （未经测试，但从我的 kotlin 实现翻译，效果很好）

import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
import org.jfrog.gradle.plugin.artifactory.ArtifactoryPlugin;
import org.jfrog.gradle.plugin.artifactory.ArtifactoryPluginUtil;
import org.jfrog.gradle.plugin.artifactory.dsl.ArtifactoryPluginConvention;
import org.jfrog.gradle.plugin.artifactory.dsl.PublisherConfig;

public class CustomArtifactoryPlugin implements Plugin<Project> {

    private static String MAVEN_PUBLIC_REPO = "/maven-public";
    private String contextUrl = "MY_CUSTOM_REPO_BASE_URL";

    @Override
    public void apply(Project project) {

        // Base gradle publishing plugin
        //  - maven plugin for pulishing java artefacts
        //  - ivy plugin if for publishing other type of artefacts: rpms, archives, ..
        project.getPluginManager().apply(MavenPublishPlugin.class);
        // project.getPluginManager().apply(IvyPublishPlugin.class);

        // Apply the Artifactory plugin
        project.getPluginManager().apply(ArtifactoryPlugin.class);

        // Add Artifactory repo to the repositories
        project.getRepositories().maven(new ArtifactoryAction(contextUrl + MAVEN_PUBLIC_REPO, "user", "password"));

        // Configure artifactory plugin - using 'withPlugin' ensures that plugin has already been applied
        project.getPluginManager().withPlugin("com.jfrog.artifactory", appliedPlugin -> {
            // artifactory {
            ArtifactoryPluginConvention pluginConvention = ArtifactoryPluginUtil.getArtifactoryConvention(project);
            //    contextUrl = "${contextUrl}"
            pluginConvention.setContextUrl(contextUrl);
            //    publish {
            PublisherConfig publisherConfig = new PublisherConfig(pluginConvention);
            pluginConvention.setPublisherConfig(publisherConfig);
            //      repository {
            pluginConvention.getPublisherConfig().repository(repository -> {
                //      repoKey =  'default-gradle-dev-local'  ...
                repository.setRepoKey("default-gradle-dev-local"); // The Artifactory repository key to publish to
                repository.setUsername("${artifactory_user}"); // The publisher user name
                repository.setPassword("${artifactory_password}"); // The publisher password
                repository.setMavenCompatible(true);
            });
            //      defaults {
            pluginConvention.getPublisherConfig().defaults(artifactoryTask -> {
                //      publications('mavenJava')
                artifactoryTask.publications("mavenJava");
                artifactoryTask.setPublishArtifacts("true");
                artifactoryTask.setPublishPom("true");
            });

        });
    }

}

EDIT对于发布配置，可以如下操作：

        // create maven publication
        project.getExtensions().configure(PublishingExtension.class, publishingExtension -> {
            publishingExtension.publications(publications -> {
                publications.create("mavenPublication", MavenPublication.class, mavenPublication -> {
                    mavenPublication.setVersion("1.0.0");
                    mavenPublication.setGroupId("groupId");
                    mavenPublication.from(project.getComponents().findByName("java"));
                });
            });
        });