Apache 之Ivy 简介信息

一、What is Apache Ivy™ ?

Apache Ivy™ is a powerful dependencies manager with transitive dependencies support and much more features.

With Apache Ivy you define the dependencies of your module in an xml file, called an ivy-file. Then you usually ask Apache Ivy to retrieve your dependencies to a local lib dir, and it does it for you by locating the artifacts of your dependencies in repositories, such as a maven2 repository for instance.

The agile dependency manager

Apache Ivy™ is a popular dependency manager focusing on flexibility and simplicity.

Find out more about its unique enterprise features, what people say about it,

and how it can improve your build system!

Ivy是一个免费基于Java的依赖管理器。它提供了一些强大的功能包括依赖传递，ant集成, maven存储库兼容，持续集成，html报告等。

Apache Ivy是一个优秀的管理（记录、跟踪、解析和报告）项目依赖的工具，可与Apache Ant紧密集成。

 

 

 

Apache Ivy™ is a very powerful dependency manager oriented toward Java™ dependency management, although it can be used to manage dependencies of any kind.

 

 二、Ivy Features

Integrated with Apache Ant™

Apache Ivy is integrated with Apache Ant, the most popular Java build management system, so Apache Ivy follows Apache Ant design principles. If you have Apache Ant skills, you already have Apache Ivy skills! The plugin mechanism in Apache Ivy follows the Apache Ant model. Also like Apache Ant, Apache Ivy supports macrodefs and file imports from configuration.

Since Apache Ivy is a subproject of Apache Ant, we even share the same development community!

 

Simple to use

For simple cases, Apache Ivy is easy to use. Declare your dependencies, and that's all. See the quick start tutorial to check yourself, it should take less than 5 minutes!

Apache Ivy brings the dependency management advantages of Apache Maven™ to Apache Ant build files, for those who already use Apache Ant and don't want to migrate to Apache Maven. But Apache Ivy does not stop there, it provides many more great features!

 

Clean dependency reports

Apache Ivy produces two primary report types: HTML reports and graph reports. HTML reports give a good understanding of what Apache Ivy did, and of a project's immediate dependencies. The graph reports provide a good overview of a project's transitive dependencies (see below) and conflicts.

 

Non intrusive

Apache Ivy is most commonly used to resolve dependencies and copy them to the lib directory of a project. After dependencies have been copied, a build no longer depends on Apache Ivy. Therefore, existing builds may easily be migrated to Apache Ivy using the lib directory pattern. Also, dependencies can be delivered with a project so that the build file need not depend on Apache Ivy.

 

Extremely flexible

In most cases, Apache Ivy will conform to your existing environment.

Apache Ivy comes with many default values that work out of the box, and most can be changed. For example, you can change the way Apache Ivy finds the latest dependency versions, you can change the conflict manager, you can choose if you want Apache Ivy to copy dependencies to your project libs or use them directly from the cache, etc.

 

Easily extensible

When Apache Ivy does not do what you want out of the box, you can often extend it to solve your problem. For instance, you can plug your own repository. But you can also define your own latest strategy and your own conflict manager. See how to extend Ivy in the reference doc.

You can even define your own metadata on your modules, with extra attributes.

 

High performance

The Apache Ivy project has always emphasized performance. For example, Apache Ivy uses a cache to avoid duplicate dependency downloads. Also, all settings and ivy files are parsed using SAX for maximum performance.

 

Transitive dependencies

Imagine a component that's often reused by a software team, and that this component has dependencies of its own. Without a good dependency management tool, each time this component is reused, all its dependencies must be repeated. With Apache Ivy, it's different: simply write a dependency file once for the component, and benefit from the work already done anytime this component is reused.

This model is even more powerful as the component's own dependencies change over time. In this case, without Apache Ivy, the resulting ripple effect can disrupt your project. With Apache Ivy, you update the ivy file of the component and that's it!

 

Strong conflict management

Transitive dependencies can cause confusion over exactly which version of a dependency gets bundled, because several modules require it in different versions. Apache Ivy provides a strong and flexible conflict management engine, which allows choosing the version to be evicted or kept in each case.

Apache Ivy also implements transitive dependencies management, which means that conflicts are solved for each dependency before being solved for your whole module. This ensures that problematic conflicts will only need to be solved in the dependency where they are encountered.

 

Out of the box maven repository support

The public maven repository has many advantages: a lot of modules available, easy search with mvnrepository.com, etc. With Apache Ivy, you benefit from this repository out of the box thanks to maven2 metadata compatibility.

 

Continuous Integration Ready

Are you working in a continuous integration (CI) environment? No? You should be ;-)

If you are working in a CI environment, and if you have many projects that depend one on each other, then you might be experiencing the dependency management nightmare. Fortunately, Apache Ivy can help you!

With Apache Ivy you can declare that a component depends on the latest version of another component. Knowing that, Apache Ivy will search for the latest version of the dependency whenever you ask it to do so. This latest version is computed either by checking the date of the dependency versions or by comparing versions as text (either lexicographically or with an algorithm close to the one used in php version_compare function).

 

Publication handling

Apache Ivy helps you publish your projects to your repository. This simplifies the management of multi-project environments.

 

Pluggable module descriptor parsers

Apache Ivy is able to use ivy-files as module descriptors, but also maven2 POMs, or even your own module descriptors! This can help you move softly from an existing repository of modules to an Ivy-managed one.

 

Unique enterprise features

Apache Ivy is the only dependency management tool to support powerful features such as repository namespace and building through the install task. A tutorial is dedicated to this feature which shows how to build your own repository by importing data from a public one, and how to convert heterogeneous repositories into a stable and homogeneous one.

 

Heavily tested

Apache Ivy benefits from a lot of unit tests checked at each code modification. It is also heavily tested by the community itself, and we pay a lot of attention to bug fixing and code stability.

 

Free and open source

Apache Ivy is an Apache project, which means that it's fully open sourced, with a business-friendly Apache license.

Since it's open source, you can even modify it for your own needs, and let the community benefit from your enhancements if you like.

 

Extensively documented

Not only is Apache Ivy free and open source, but you also have access to very detailed tutorial and reference documentation.

 

Self contained

The core engine which enables most Apache Ivy features is provided as a single jar with no dependency other than JRE 1.4 or greater. This means that you can very easily use Apache Ivy to bootstrap your build system, or to embed in your own tool. Apache Ant support is provided only as a thin wrapper over the Apache Ivy engine so that you can do everything in embedded or standalone mode.

 

 

三、Why should  use a dependencies manager ?

Without a dependencies manager, two solutions are often used to store the dependencies of a project: a project lib dir or direct access to a shared repository.

The major drawback of the project lib dir is that the same dependencies are stored in multiple location if you have several projects using the same dependencies. Moreover, we often see project where dependencies revisions are not documented, which can cause problems for maintenance.

With the shared repository the problem is often to maintain the list of dependencies of the project. This list is often lost within the build file, which does not help maintenance. Moreover, this solution often requires a download of the whole repository, unless home made dependencies management solution has been used.

Another major drawback of these solutions is that they do not use transitive dependencies. Transitive dependencies are the dependencies of your dependencies. Managing transitive dependencies let you declare dependencies only on what you really need, and not what the module you use themselves need. This not only eases your dependencies declaration, but it also improves a lot the maintenability of your project, especially in multi-project environment. Imagine you develop a component used in several other projects. Then each time your component needs a new dependency, without transitive dependencies, you have to update all the projects using your component ! And this could really take a lot of time !

 

四、Why should  use Apache Ivy ?

If you are convinced of using a dependencies manager, you may wonder why using Apache Ivy and not another tool. We are not able to answer this question without being biased, but have a look at Apache Ivy features and the product comparison we provide, and you will certainly see that Apache Ivy is one of the best dependencies manager currently available ;-)