以编程方式从 Maven 中心检索依赖项的最简单的 Ivy 代码

Question

我发现 Ivy API 非常复杂。

使用 Ivy 100% 以编程方式（没有 Ant，没有 Xml 文件，...）从 Maven Central 将工件检索到特定本地目录中的最简单的 sn-p 是什么？

举例来说，将 commons-logging:commons-logging:1.1:jar 检索到 /my/destination 中。

Answer 1

我一直致力于使用 Ivy 从 Maven 存储库中远程解析工件（和依赖项）。这是一个下载一个工件（无依赖项）的代码示例。

如果需要依赖，需要适配依赖描述符。

一些注意事项：

1. Ivy 使用缓存来存储以前检索到的工件及其“ivy 翻译”（您会在缓存中找到源自 Maven 工件的 ivy 模块）

2. 一般概念是您以编程方式创建一个 Ivy 模块，该模块依赖于存储“伪模块”的 Maven 存储库（即，解析器实现了底层映射 - 我相信）。

3. 一般来说一个很好的起点，如果你想知道如何以编程方式使用 Ivy，主类是org.apache.ivy.Main。

        public static void main(String[] args) throws Exception {

        String groupId = "org.springframework";
        String artifactId = "spring-context-support";
        String version = "4.0.2.RELEASE";
        File   out = new File("out");

        // create an ivy instance
        IvySettings ivySettings = new IvySettings();
        ivySettings.setDefaultCache(new File("ivy/cache"));

        // use the biblio resolver, if you consider resolving 
        // POM declared dependencies
        IBiblioResolver br = new IBiblioResolver();
        br.setM2compatible(true);
        br.setUsepoms(true);
        br.setName("central");

        ivySettings.addResolver(br);
        ivySettings.setDefaultResolver(br.getName());

        Ivy ivy = Ivy.newInstance(ivySettings);

        // Step 1: you always need to resolve before you can retrieve
        //
        ResolveOptions ro = new ResolveOptions();
        // this seems to have no impact, if you resolve by module descriptor (in contrast to resolve by ModuleRevisionId)
        ro.setTransitive(true);
        // if set to false, nothing will be downloaded
        ro.setDownload(true);

        // 1st create an ivy module (this always(!) has a "default" configuration already)
        DefaultModuleDescriptor md = DefaultModuleDescriptor.newDefaultInstance(
            // give it some related name (so it can be cached)
            ModuleRevisionId.newInstance(
                groupId, 
                artifactId+"-envelope", 
                version
            )
        );

        // 2. add dependencies for what we are really looking for
        ModuleRevisionId ri = ModuleRevisionId.newInstance(
            groupId, 
            artifactId,
            version
        );
        // don't go transitive here, if you want the single artifact
        DefaultDependencyDescriptor dd = new DefaultDependencyDescriptor(md, ri, false, false, false);

        // map to master to just get the code jar. See generated ivy module xmls from maven repo
        // on how configurations are mapped into ivy. Or check 
        // e.g. http://lightguard-jp.blogspot.de/2009/04/ivy-configurations-when-pulling-from.html
        dd.addDependencyConfiguration("default", "master");
        md.addDependency(dd);

        // now resolve
        ResolveReport rr = ivy.resolve(md,ro);
        if (rr.hasError()) {
            throw new RuntimeException(rr.getAllProblemMessages().toString());
        }

        // Step 2: retrieve
        ModuleDescriptor m = rr.getModuleDescriptor();

        ivy.retrieve(
            m.getModuleRevisionId(),
            out.getAbsolutePath()+"/[artifact](-[classifier]).[ext]",
            new RetrieveOptions()
                // this is from the envelop module
                .setConfs(new String[]{"default"})
        );
    }

Answer 2

检索工件（及其依赖项）的最简单方法是 use ivy from the command-line

java -jar ivy.jar -dependency commons-logging commons-logging 1.1 -retrieve "/my/destination/[artifact](-[classifier]).[ext]"

这会将文件检索到目录“/my/destination”中。

其他例子：

• using IVY dependencies manager programmatically
• Using Maven to download dependencies to a directory on the command line