java left logo
java middle logo
java right logo
 

Home arrow Java Libraries arrow Build Systems arrow Ivy
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4088
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
Ivy E-mail
User Rating: / 13
PoorBest 

Ivy is a free java based dependency manager, with powerful features such as transitive dependencies, ant integration, maven repository compatibility, continuous integration, html reports and many more.

Integrated with ant

For sure, Ivy is integrated with the most popular build management system for java projects.

Simple to use

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

Ivy can thus be used to bring the dependency management feature of maven to ant build files, for those of you who already use ant and who do not want to setup a maven project. But Ivy does not stop here, and provides much more great features !

Clean dependency reports

Ivy is able to produce mainly two kind of reports: html reports and graph reports. HTML reports gives you a good understanding of what ivy did, and which dependencies your project depends upon. The graph reports let you have a good overview of the transitive dependencies (see below) and conflicts in your project.

Non intrusive

Ivy most common use is to resolve dependencies and copy them in the lib dir of your project. Once copied, your build does not depend on ivy any more. Thus you can easily migrate existing builds using the lib dir pattern to store dependencies. Moreover, you can easily deliver your project with its dependencies so that the build file does not depend on ivy.

Extremely flexible

With Ivy, you usually do not have to adapt your project to ivy structure, it's ivy which can be adapted to your environment.

Even if Ivy comes with a lots of default values to work out of the box, you can change many things in ivy. For sure, the dependencies repositories possibilities covers a lot of uses (file system, url based, repository chaining, ...). But that's not all. You can change the way ivy finds latest versions of your dependencies, you can change of conflict manager, you can choose if you want ivy to copy deps in your project libs or to use them directly from ivy cache, ...

Easily extensible

When ivy does not what you want out of the box, you can often extend it to solve your problem. For instance, you can plug your own repository (like scott haug did for a svn repository now available in ivy tools). But you can also defines your own latest strategy and your own conflict manager. See how to extend ivy in the reference doc.

High performances

In Ivy, performances have been taken in consideration from the beginning. It uses a cache to avoid downloading twice a dependency, its strong conflict management system has been thought to avoid downloading a dependency if not necessary, all configuration and ivy file parsing are done using SAX for maximum performance, and so on...

Transitive dependencies

Imagine you have a component that you often reuse in your software developments. Imagine that this component has itself dependencies. Then with classical dependencies management, each time you use this component in your software you have to declare it as a dependency, but also all its dependencies.

With ivy it's different: you simply write a dependency file once for the component, declaring its own dependencies, then anytime you want to use this component you simply have to declare a dependency on it.

And this is even more powerful if the component your software depends on changes of dependencies during its own development. Then, without ivy, you have to maintain all your components dependencies declaration each time the dependencies of this component change. With ivy, you update the ivy file of the component and that's it !

If you want to quickly start using this feature or simply see it in action with real world examples, check the official repository: ivyrep

Strong conflict management

The problem with transitive dependencies is that it's sometimes difficult to know exactly which version of a dependency you get, because several modules are depending on it in different versions. Ivy provides a strong and flexible conflict management engine, which let you easily choose which version should be evicted or kept if its default behaviour does not fit your needs.

It is also fully integrated with transitive dependencies management, which means that conflicts are solved for each dependency before being solved for your whole module. This ensures that problematics conflicts will only need to solved in the dependency they are encountered.

Out of the box ibiblio repository support

Maven users all know this repository, where you can find a lot of java projects artifacts. With ivy, you benefit from this repository out of the box. But you even benefit from more, since Ivy also uses its own repository for dependencies metadata, leveraging the power of transitive dependencies.

Continuous Integration Ready

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

If you are working in a continuous integration environment, and if you have many projects that depend one on each other, then you are maybe experiencing the dependency management nightmare... Fortunately, ivy is there to help !

With ivy you can declare that a component depends on the latest version of another component. Knowing that, ivy will search for the latest version of the dependency whenever you ask it to do so. This latest version is computed by ivy simply 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

Ivy handles for you the publication of your projects to your repository, as defined in ivy. This simplifies a lot the management of multi-project environment.

Heavily tested

Ivy benefits from a lot of unit tests checked at each change. It is also under heavy tests by the community itself, and bugs reported by the community are often fixed in only a few days.

Supported by several tools

A growing number of tools support ivy, see the links page for details.

Free and open source

All the power of Ivy is available for free: its BSD license let you use it in both open source and commercial projects !

Being open source, you can even modify it for your own needs, and make the community benefit from your enhancements if you like.

Professional support

Even if Ivy is an open source project, it is backed by jayasoft, a software company ensuring the constant quality of the product and providing professional support for it.

Have a look at what we propose, we can help you improve your development environment and thus improve your development team productivity !

URL: http://jayasoft.org/ivy
Licence: BSD License


 Related Tips

 
< Prev   Next >

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.