Question

I’m currently in the midst of converting a large multi-module project (~100 sub-modules) to use Maven. Currently we use Ant + Ivy.

So far no major issues have cropped up and I’m comfortable that Maven is still a good fit. However, I wonder if there is a better way to handle native dependencies.

So far I have come to the following conclusions.

1. It’s best to install each native dependency into the maven repo either as a standalone library or an archived package containing multiple dependencies.

2. Rather than get lost in declaring each and every dependency with the Maven dependency plugin, I opted to give each a classifier (e.g. natives-win32) and use the following in the parent POM:

           <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-dependency-plugin</artifactId>
           <version>2.4</version>
           <executions>
               <execution>
                   <id>copy</id>
                   <phase>compile</phase>
                   <goals>
                       <goal>copy-dependencies</goal>
                   </goals>
                   <configuration>
                       <includeScope>runtime</includeScope>
                       <includeClassifiers>natives-win32</includeClassifiers>
                       <outputDirectory>${project.build.directory}/natives</outputDirectory>
                   </configuration>
               </execution>
           </executions>
       </plugin>
   

So far this seems to be a simple all-round solution that doesn’t require too much messing about to add new native dependencies. It also offers me a simple all-round solution for managing natives. The only thing I must do is ensure that my /natives/ directory is defined on java.library.path.

One thing that bothers me (a little) about this approach is that all my native dependencies get copied around to each sub-module that expresses a transitive dependency on them, whilst my happy jar libraries are added to the classpath referenced to where they sit in my local repository (no copy required).

Is there no way to be smarter about this and have my natives referenced from withing their repository location (assuming I don’t have them archived, i.e. dll). That would save a bunch of unnecessary copying about.

Are there any other potential gotchas’ that I should be concerned about with the above approach?

Answer 1

I ended up using the maven natives plugin and dealing with the fact that I have redundant copies of the native libraries around the place. The reason for this was primarily due to the simplicity that the plugin offers and the fact that it also has a related eclipse plugin that sets up natives in developers eclipse environment without intervention.