Dependency Management with Apache Ivy

Dependency Management with Apache Ivy

Planning regardless a fundamental dependence the board instrument? The mix of Ant and Ivy is a solid proposal in this space, and this toolset may save you something past time. Stephen B. Morris gives a couple of experiences.

Java Code Dependencies

Two well known decisions in the dependence the executives space are Maven and Ant/Ivy. Both toolsets have their advantages, yet in this article we’ll look at the Ant/Ivy mix.

How frequently have you battled with Eclipse or some other IDE, attempting to dispose of the aggregation mistake markers in your Java records? This issue is frequently brought about by absent (or mistaken) reliance blunders. Somewhat later in this article, we’ll take a gander at a solid Eclipse model that shows the key job programmed reliance management can play in fixing these knotty issues. We’ll additionally look at the work process for utilizing Internet vaults, for example, Maven Central.

Overseeing code conditions for the most part comes down to a straightforward decision: manual or programmed. In the event that, similar to me, you want to apply a great deal of authority over your code conditions, at that point the manual way is appealing, in any event at first. Nonetheless, a direct inclines toward come when reliance management actually should be robotized.

At the point when you consider it, complex reliance issues don’t have a great deal to do with plan and coding, so it’s normal to consider utilizing an apparatus for this frequently dull errand.

As your code develops, it obtains what’s known as a tree of conditions. We should take a gander at this next.

The Tree of Dependencies

Any Java task of sensible multifaceted nature has a non-unimportant arrangement of conditions comprising of JAR records with the inside assets expected to fabricate, convey, and run an application. Sounds basic, however these conditions can turn crazy. How about we investigate this with a model.

Adding a New Facility to Your Code

Suppose, for instance, you read my prior article “Java Data Validation Using Hibernate Validator,” and you’ve chosen to include an outsider validation instrument to your application. Validation is regularly included late in a venture, and frequently software engineers will pick to make their own bespoke arrangements. Be that as it may, we should accept you choose to go with an open source arrangement.

One fair decision in this space is Hibernate Validator. To make this somewhat more solid, how about we accept that you as of now have a current Ant construct document. Adding Hibernate Validator then adds up to just introducing Ivy and the option of a solitary Ant focus to bring the conditions. It’s a comparative story in the event that you use Maven for reliance the executives; you simply make a little expansion to your metadata file pom.xml. Since I utilized Maven in the previous article, we can look at the two methodologies.

Posting 1 represents the necessary Ivy arrangement for bringing the conditions from the Maven Central Repository.

Listing 1—Adding an Ivy dependency.

<target name="maven2-namespace-deps-validator" depends="init-ivy" description="-->
 install module with dependencies from maven2 repo using namespaces">
<ivy:install settingsRef="advanced.settings" organisation="hibernate"
 module="hibernate-validator" revision="5.2.2.Final" from="${from.resolver}"
 to="${to.resolver}" transitive="true"/>

Try not to stress over the subtleties in Listing 1 for the occasion. Posting 1 is essentially similar to a little program that exists to satisfy our necessary reliance. The key part is the accompanying area:

module=”hibernate-validator” revision=”5.2.2.Final” from=”${from.resolver}” to=”${to.resolver}” transitive=”true”/>

This line determines that we need to introduce a version of a given curio; for this situation, Hibernate Validator version 5.2.2.Final. Likewise, we need to utilize a particular source store (from.resolver) and introduce the module in our goal archive (to.resolver). The two stores are determined as Ant properties; for this situation, separately, Maven Central Repository (from) and a neighborhood document based Ivy vault (to).

Transitive Dependencies

The conceivably frightening part in the above line is the setting for the transitive property. What are transitive dependencies? Well, transitive is a numerical term that just methods on the off chance that module A has a reliance on module B, at that point the two modules An and B will be downloaded. At the end of the day, the transitive relationship is construed by Ivy, and the proper antiquities are obtained consequently. Unmistakably, module B can likewise rely upon C, etc.

When transitive dependencies are indicated thusly, at that point every single related antique will be downloaded for you. Setting transitive to true means that all our necessary dependencies will be downloaded. Sounds guiltless, isn’t that right? So what happens when we run this objective? Indeed, we get a major bundle of documents added to the nearby record based vault, as delineated in Figure 1.

Dependency Management with Apache Ivy
Figure 1 Our new set of dependencies.

Figure 1 Our new set of dependencies.
Figure 1 illustrates the furthest envelope for each downloaded reliance. The indulgent purpose of this conversation is that the choice to include the required Hibernate Validator antiquity isn’t without costs. What may those expenses be?

For a certain something, the sent application currently needs to incorporate these reliant modules. This requires plate space. At runtime, as the assets in the conditions are utilized, there will be a related memory necessity.

Contingent upon your arrangement environment, a portion of these conditions may as of now be accessible; for instance, in a JEE situation. Nonetheless, in case you’re running a JSE application, you may well need the entirety of the conditions in Figure 1

Unmistakably, programmed reliance the board is an extremely incredible asset!

The abrupt increment in conditions that can come about because of including a relic, for example, Hibernate Validator can strike dread into the hearts of venture group pioneers. The subsequent conceivably complex trap of conditions is likewise, one might say, a statement of how far open source improvement has come. Such a large number of valuable utilities are accessible that you can basically add them to your code as opposed to creating them without any preparation. The flipside is that such code may haul in other undesirable conditions.

I as of late read that something like 88% of all code (exactly 5 billion dollars’ worth [1]) is currently accessible as existing open source. In this specific circumstance, the activity of the developer is frequently one of arranging existing devices and systems, as opposed to composing bunches of new code.

It’s imperative to be cautious with the conditions you include. Adding expected relics to your Ant or Maven metadata documents may be basic, however it additionally may bring about a spaghetti of pointless conditions. Then again, composing your own approval code additionally has issues. Handy reliance the board is a perplexing exercise in careful control.

Reliance Bloat and Versioning

A more subtle weight in Figure 1 is the future need to deal with the forming of the conditions. This issue is generally observed in codebases that have been around for a couple of years, where developers utilize a given adaptation of a library, for example, log4j. Afterward, another software engineer tags along and utilizes a refreshed form of log4j. Unfortunately, our subsequent software engineer doesn’t refresh or erase the previous code and its reliance.

The outcome is that we are currently blundered with two conditions at the cost of one. The fundamental code may likewise be superfluously enlarged, and without rules for taking care of this kind of issue, the circumstance is just prone to deteriorate.

On the off chance that you choose to include another reliance, it’s consistently a decent propensity to check whether any more established conditions can be resigned. This may require some code changes if a developer has composed against a particular variant of a library.

Ivy and Maven Port Use

Numerous associations prohibit the utilization of Internet code archives, and in light of current circumstances. Expert Central goes back double records to customers, which isn’t without chance. One approach to improve—yet not wipe out—the danger of paired document download is by utilizing advanced marks. Returning to Figure 1, in the event that we double tap multiple times into the apache folder, this carries us to the actual JAR file and the advanced marks in Figure 2.

Dependency Management with Apache Ivy
Figure 2 The artifact folder with the digital signatures.

Notice the mark records in Figure 2. This permits us to check that the twofold log4j JAR file matches the MD5 and SHA1 signature documents. The nearness of mark documents doesn’t ensure that the records have not been tampered with, yet it’s one defend.

Running a Java Project After Dependency Acquisition

How about we make a straightforward Java venture that requires the Hibernate Validator conditions we downloaded before.

Posting 2 outlines a case of a Hibernate Validator use case in a straightforward space substance class. The model code depends on that at the Hibernate Validator site.

Posting 2—An element space class.

open class DomainClass {@NotNullprivate String manufacturer;@NotNull@Size(min = 2, max = 14)private String licensePlate;@Min(2)private int seatCount;public DomainClass(String producer, String licensePlate, int seatCount) {this.manufacturer = manufacturer;this.licensePlate = licensePlate;this.seatCount = seatCount;}public static void main(String[] args) {DomainClass domainObject = new DomainClass(null, invalid, 10);ValidatorFactory industrial facility = Validation.buildDefaultValidatorFactory();Validator validator = factory.getValidator();Set<ConstraintViolation<DomainClass>> constraintViolations = validator.validate(domainObject);assertEquals(2, constraintViolations.size());assertEquals(“may not be invalid”, constraintViolations.iterator().next().getMessage());}


In the event that we essentially download the Hibernate Validator JAR file and add it to the Eclipse venture construct way, we’ll run into a somewhat antagonistic special case, for example, the one in Listing 3.

Posting 3—Dependency-related special case.

Special case in string “primary” java.lang.NoClassDefFoundError: javax/approval/ParameterNameProviderat org.hibernate.validator.HibernateValidator.createGenericConfiguration( javax.validation.Validation$GenericBootstrapImpl.configure( javax.validation.Validation.buildDefaultValidatorFactory( validator.DomainClass.main(

Brought about by: java.lang.ClassNotFoundException: javax.validation.ParameterNameProviderat$ Source)at$ Source)at Method)at Source)at java.lang.ClassLoader.loadClass(Unknown Source)at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)at java.lang.ClassLoader.loadClass(Unknown Source)… 4 more

Fixing this issue is a genuine agony on the off chance that you settle on manual reliance the board. This special case can be settled by utilizing Maven, or, as for our situation, Apache Ivy. When the conditions have been downloaded as in Figure 1, we would then be able to refresh the Eclipse fabricate way and re-run the application. Subsequent to applying the conditions, we should see a fruitful application run, as showed in Listing 4.

Posting 4—An effective run.

Exemption in string “fundamental” java.lang.AssertionError: expected:<1> however was:<2>at org.junit.Assert.failNotEquals( org.junit.Assert.assertEquals( org.junit.Assert.assertEquals( org.junit.Assert.assertEquals( validator.DomainClass.main(


The exemption in Listing 4 identifies with the application rationale, as opposed to a reliance issue. As it were, we can escape from arrangement and return to coding.

Programming Without Automatic Dependency Management

Despite the fact that it very well may be tedious pursuing down conditions physically, this model is as yet utilized by numerous associations. Shockingly, the time you spend unraveling transitive reliance issues is time detracted from plan and coding. Paradoxically, getting set up with Ivy has a once-just time cost, and from that point reliance the board is dealt with consequently.

Building a Simple Ivy Setup

The initial step is to download Ivy. I won’t copy the great substance on the Ivy site. Getting going with Ivy isn’t excessively troublesome. A simple ivy.xml file, for example, coming up next is adequate to download two antiques (Commons lang and Commons cli, individually) from Maven Central:

<ivy-module version=”2.0″><info organisation=”apache” module=”hello-ivy”/><dependencies><dependency org=”commons-lang” name=”commons-lang” rev=”2.0″/><dependency org=”commons-cli” name=”commons-cli” rev=”1.0″/></dependencies>


A key required strategy in Ivy.Maven dependency the board is figuring out how to utilize Maven Central. How about we view this now.

Utilizing the Maven Central Repository

Suppose you need to find a given ancient rarity, for example, the Hibernate Validator, utilizing Maven Central. The initial step is to visit the Search Engine for the Central Repository. Next, type in the necessary antique name, and you should see something like the extract in Figure 3.

Dependency Management with Apache IvyFigure 3 Maven Central.

Snap the nonexclusive connection for 5.2.2.Final to the privilege of hibernate-validator-parent under “Most recent Version.” (different connections identify with OSGI curios—a to some degree more particular region.) This carries us to another screen, outlined in Figure 4.

Dependency Management with Apache IvyFigure 4 Artifact details.

In Figure 4, notice the connections under the heading “Reliance Information.” This extremely helpful part mentions to you what metadata to determine so as to get the ancient rarity consequently. The metadata is provided for POM (Maven), Ivy, and so on. You select the Ivy setting, duplicate the metadata, and add it to your Ivy arrangement. For this situation, you would duplicate the accompanying line:

<dependency org=”org.hibernate” name=”hibernate-validator-parent” rev=”5.2.2.Final”/>

Simply drop this reliance into your ivy.xml file, run ant, and the arrangement of curios will be downloaded. It’s that straightforward.

Other Dependency Management Tools

Expert and Ivy are only two among a scope of famous reliance the executives devices. Gradle is another, alluded to as a polyglot build apparatus. I haven’t utilized Gradle, however it is by all accounts appropriate to numerous language environments.


Fabricate apparatuses and reliance the board devices are firmly related. Expert is a case of both. Subterranean insect and Ivy are independent instruments—one for fabricates and the other for conditions.

As codebases become bigger and more intricate, utilizing a reliance chief is standard. Actually, it’s generally fitting, as pursuing down conditions can get tedious. This kind of issue is seen when you include another open source office, for example, Hibernate Validator to your codebase. The necessary conditions can be shockingly huge.

Furnished that you’re content with the tree of conditions, you can utilize Ivy to fix some entirely knotty reliance issues, which now and then are almost too complex to even consider fixing by hand.

Getting set up with Ivy is straightforward, and if your association permits Maven Central access, your movement ought to be moderately effortless.

A key aptitude in utilizing either Ivy or Maven is making sense of the metadata for your necessary conditions. The Maven Central Repository gives simple instruments to this errand. Removing a given reliance generally sums to close to replicating a line of metadata into your local ivy.xml file.

It’s critical to take note of that the reliance the board field has a decent not many contenders. For instance, Gradle is useful for multi-language situations. It is anything but a one-horse race!

Leave a Reply

Your email address will not be published. Required fields are marked *