Develop Reference

How to add local jars folder in class path using POM

There are almost 10 local jars (these jars are required to build my application) in my Java application. I want them to add to the classpath using POM. How can I do that?

You can add the dependency as system scope and refer to it by its full path. Consider that the JAR is located in /lib. Then add the dependency in your pom.xml file as following:
<dependency>
<groupId>com.abc.pqr</groupId>
<artifactId>sample-app</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${basedir}/lib/your_jar.jar</systemPath>
</dependency>
${basedir} represents the directory containing pom.xml.

Using maven versions plugin to handle dependency version

I have the a project pom and a parent pom. The parent pom defines a dependency as follows:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.mycode/groupId>
<artifactId>common</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
My project pom inherits the parent and defines the dependency.
<parent>
<groupId>au.com.truelocal</groupId>
<artifactId>truelocal-parent</artifactId>
<version>develop</version>
</parent>
<dependencies>
<dependency>
<groupId>com.mycode</groupId>
<artifactId>common</artifactId>
</dependency>
</dependencies>
I used to build with Maven this way without issue.
I now want to start having a different version in parent, common and project.
I am going to use the maven versions plugin to set my version.
I am setting the parent version and version successfully however, maven keeps looking for the wrong version of common. E.g. if my project is building as version 1.0.0-4 then it looks for common-1.0.0-4 but I actually need it to get the latest version of common instead which could be for example 1.0.0-23.
Can i use the versions plugin to adjust my dependency version? How do I make it only apply to common and not other dependencies I may have?

mvn versions:set (I guess this is what you've done) sets the version of your project, respectively the project versions which are part of a multi module project.
It doesn't touch the versions of the dependencies, either they are configured in a parent pom within <dependencyManagement> or within <dependencies>.
You can adjust the dependency versions by several ways: mvn versions:display-dependency-updates , mvn versions:use-latest-releases , mvn versions:use-latest-snapshots.
Use mvn versions:help or mvn versions:help -Ddetail=true -Dgoal=use-latest-snapshots to get more informations.

how to move multi-module projects to maven

We are attempting to move several multi-module applications to maven, and having some problems.
Each module is stored independently in cvs. We have manifest files for each application, which list the modules required for that application (and optionally the version). Not all modules are in maven form.
So application 'customer_care' has the following manifest:
<manifest>
<module id="MY_api"/>
<module id="custcare_webapp"/>
</manifest>
Similarly, the application 'core batch' has a manifest like this:
<manifest>
<module id="MY_api"/>
<module id="core"/>
<module id="batch"/><!--NB this is a non-maven module -->
</manifest>
I have started 'mavenising' our code, so the MY_api project has a pom.xml with dependencies defined, including one on another internal code module 'central_config'. I have specified version RELEASE.
The problem
This all works fine, until I need to create a frozen manifest. I can specify a version for each module:
<manifest>
<module id="MY_api" version="0.123.0"/>
<module id="core" version="0.456.0"/>
<module id="batch" version="0.789.0"/><!--NB this is a non-maven module -->
</manifest>
BUT this build is not reproducible, because the version of the 'centralconfig' dependency in MY_api is 'RELEASE'. So if someone releases a new version of 'centralconfig', then next time we build this frozen manifest, it's different.
So why don't we use hard-coded versions of dependencies like central-config? Because then, we would have to update perhaps 10 or 20 pom files every time someone updates centralconfig to a new version. Everything which depends on central config, and everything which depends on that, would need its pom.xml updating and to be re-released. Not only is this lots of work, I don't know how I could programmatically and reliably identify every module which declares a dependency on central config.
A possible solution?
Could I define 'centralconfig.version' in one place, and then refer to it in all my modules? If so, where should I do this? I don't know much about parent poms but I feel they might provide a solution.
Update
It seems that using a parent pom is the way to go. But according to this question: Can maven projects have multiple parents? , it's not possible for a maven child project to have multiple parents.
So then how can the MY_api module be a child of both custcare_webapp and core_batch?
Update
I've concluded that maven doesn't meet my requirements, and we've gone back to using our 12-year old home-grown solution build using ant and CVS.

One other option that is often better than a parent-structure for managing versions is to import dependencies.
To illustrate how this works you create one project that only contain a pom specifying the versions to use for all your modules:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>test</groupId>
<artifactId>module-versions</artifactId>
<packaging>pom</packaging>
<version>1.0</version>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>test</groupId>
<artifactId>a</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>foo</groupId>
<artifactId>bar</artifactId>
<version>2</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
Then, in all your projects that need to have dependencies to anyhing that you have hard coded versions for you import this project in the following manner:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>test</groupId>
<artifactId>module-versions</artifactId>
<version>1.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
This way you only have to change the module-versions project anytime you release a new version of anything you have a dependency to.
This way you can have multiple "module-versions"-projects to split things up a bit.
Of course, you still have the problem that all project's that want to use the new version must also be released in turn, but that is the cost of using released dependencies in Maven.

I think you do need a parent POM. That is a top-level pom.xml that is solely a POM module and has no associated code. You build the entire project by running the mvn command on this pom.xml.
The POM should be in the directory above all the module directories. That is, each of your modules will be in a subdirectory of the directory that holds the master pom.xml
This POM's <packaging> type will be pom. That means it's a POM-only project with no code of its own. It will also have a <modules> tag containing one <module> element for each of your modules. That way, when you run the mvn command, Maven will know to build each of these modules as well. A decent sample parent POM is here.
Set all your dependencies in this POM, using the standard <dependencies> tag. The module POMs will inherit them. (Update: see comments below, is definitely worth exploring the <dependencyManagement> tag instead for the parent POM.)
Finally, each of your module POMs should refer back to the master POM. That way, if you run mvn in one of the module directories (i.e you are just building one module), it will look to the parent for dependencies. You do this with a <parent> tag, which will hold the <groupid> and <artifactid> of the master POM. A good example of a <parent> tag, as well as a good overall review of multi-module projects, is here.

Maven build - dependancy on core classes

I have two projects I am working on which share some common code - I am putting this common code in to a new project called Core.
Both my projects use maven to build, and my core classes will also use maven. In Eclipse how do I configure maven to do a maven build of the core classes and then use these in the build for my two other applications?
Is there some prebuilt rule I need to specify - for example build this project, however, go build core first and use the output of that for this.
Hope that makes some sort of sense.

You can add a dependency to Core artifact in your project.
If you use M2E Eclipse plug-in, workspace artifacts are quite easy to reference in the Maven editor.
The only condition for this kind of dependency to work is that dependent artifact must be retrievable from a maven repository (eventually putting it to the local maven repository through install goal).

You could add a parent pom, with modules
<project>
<groupId>com.mypackage</groupId>
<artifactId>parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<name>parent</name>
<packaging>pom</packaging>
...
<modules>
<module>Core</module>
<module>MyModuleA</module>
<module>MyModuleB</module>
</modules>
...
</project>
And then just add your dependency in MyModuleA and MyModuleB like a normal dependency
<dependency>
<groupId>com.mypackage</groupId>
<artifactId>Core</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>

How do you reference a maven profile in a dependency?

I have a jar file that is built only as a profile. How do I reference that in a <dependency/> block? Let's say it's groupId is com.mycompany, artifactId is test-jar, version is 2.0 and profile is customBuild.

From the project you are building run mvn install, which will install the jar locally in your .m2 directory. Then you can reference it as a regular dependency using
<dependency>
<groupId>com.mycompany</groupId>
<artifactId>test-jar</artifactId>
<version>2.0</version>
</dependency>
in your dependent projects.