{"id":62987,"date":"2022-03-17T09:00:29","date_gmt":"2022-03-17T09:00:29","guid":{"rendered":"https:\/\/www.cryptocabaret.com\/?p=62987"},"modified":"2022-03-17T09:00:29","modified_gmt":"2022-03-17T09:00:29","slug":"use-maven-to-manage-your-java-dependencies","status":"publish","type":"post","link":"https:\/\/www.cryptocabaret.com\/?p=62987","title":{"rendered":"Use Maven to manage your Java dependencies"},"content":{"rendered":"

Use Maven to manage your Java dependencies<\/span>
\nSeth Kenlon<\/a><\/span>
\nThu, 03\/17\/2022 – 03:00<\/span><\/p>\n

\n
Up<\/div>\n
Register<\/a> or Login<\/a> to like.<\/div>\n<\/div>\n
\n

As an open source enthusiast, I’ve used dozens (hundreds?) of libraries that are well beyond my skill or interest as a programmer. For a lot of people, including me, the available libraries are one of the things that makes a particular programming language worth using.<\/p>\n

An open source library represents hours and days you don’t have to work on a problem that’s either not central to your project or, conversely, so<\/em> central that your project would be otherwise out of reach. Better still, it’s code you don’t have to maintain\u2014unless it’s so important to you that you decide to contribute to it.<\/p>\n

Because open source libraries are a vital component of open source programming, most programming languages have a convenient way to ensure they’re easy to include in your codebase.<\/p>\n

There are several ways to manage libraries in Java, but the one I use is Maven.<\/p>\n

Maven<\/a> is a code management framework that helps you keep track of dependencies, build targets, reporting, and documentation, all from a central location. That central location is a Project Object Model (POM) file, which is written in XML to describe the requirements and expectations of your project.<\/p>\n

When you decide to update a library, you can update just your pom.xml<\/code> file.<\/p>\n

Should you add a debug build to your project, add it as a target in pom.xml<\/code>.<\/p>\n

When you upgrade to a new Java Virtual Machine (JVM), do it in pom.xml<\/code>.<\/p>\n

If that sounds easy, you’ll be pleased to know that it’s just as easy to get started.<\/p>\n<\/p>\n

\n
More on Java<\/div>\n
\n
What is enterprise Java programming?<\/a><\/div>\n
Red Hat build of OpenJDK<\/a><\/div>\n
Java cheat sheet<\/a><\/div>\n
Free online course: Developing cloud-native applications with microservices arc\u2026<\/a><\/div>\n
Fresh Java articles<\/a><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

Install Maven<\/h2>\n

Maven is available on most Linux distributions from your package manager.<\/p>\n

On Fedora, Mageia, and similar distributions:<\/p>\n

\n$ <\/span>sudo<\/span> dnf install<\/span> maven<\/code><\/span><\/pre>\n
On Elementary, Mint, and other Debian-based distributions:<\/p>\n
\n$ <\/span>sudo<\/span> apt install<\/span> maven<\/code><\/span><\/pre>\n
On Windows, use Chocolatey<\/a>.<\/p>\n
Configuring<\/h2>\n
On most systems, Maven is already configured after installation.<\/p>\n
If you have a complex Java setup, however, with different versions installed for different projects, you may need to set your JAVA_HOME<\/code> environment variable<\/a>.<\/p>\n
If you don’t know what that is, read my article about finding and setting your JAVA_HOME<\/a>.<\/p>\n
First, verify that Maven is installed and is using the version of Java you intend:<\/p>\n
\n
$ mvn -version<\/span>
\nApache Maven x.y.z
\nMaven home: \/<\/span>usr\/<\/span>share\/<\/span>maven
\nJava version: X.Y.Z, vendor: Red Hat, Inc.,
\nruntime: \/<\/span>usr\/<\/span>lib\/<\/span>jvm\/<\/span>java-XX-openjdk-XX<\/div><\/div><\/pre>\n
Your first POM file<\/h2>\n
Maven bases everything it does on a project’s POM file. You can think of pom.xml<\/code> as Maven’s equivalent of Autotool’s Makefile<\/a> or CMake’s CMakeLists.txt<\/a> file. You put instructions that are meaningful to Maven in pom.xml<\/code>, and it executes those instructions when prompted.<\/p>\n
A good IDE<\/a>, like Eclipse<\/a> or NetBeans, might provide a boilerplate pom.xml<\/code> file when creating a Maven project.<\/p>\n
Depending on how comfortable you are in XML, this process might look more complex than it actually is. There’s a distinct advantage to using XML here, so have a look even if you’re not familiar with the language.<\/p>\n
\n
version<\/span>=\"1.0\"<\/span> encoding<\/span>=\"UTF-8\"<\/span>?><\/span><\/span>
xmlns<\/span>=\"http:\/\/maven.apache.org\/POM\/4.0.0\"<\/span><\/project><\/span>
xmlns:xsi<\/span>=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/span><\/span>
xsi:schemaLocation<\/span>=\"http:\/\/maven.apache.org\/POM\/4.0.0<\/span>
http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\"<\/span>><\/span><\/span>
\n\u00a0 \u00a0 ><\/modelversion><\/span><\/span><\/span>4.0.0><\/span><\/span><\/span>
\n\u00a0 \u00a0 ><\/groupid><\/span><\/span><\/span>com.example><\/span><\/span><\/span>
\n\u00a0 \u00a0 ><\/artifactid><\/span><\/span>example4Maven><\/span><\/span><\/span>
\n\u00a0 \u00a0 ><\/version><\/span><\/span>1.0><\/span><\/span><\/span>
\n\u00a0 \u00a0 ><\/packaging><\/span><\/span>jar><\/span><\/span><\/span>
\n\u00a0 \u00a0 ><\/properties><\/span><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 ><\/project.build.sourceencoding><\/span><\/span>UTF-8><\/span><\/span><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 ><\/maven.compiler.source><\/span><\/span>11><\/span><\/span><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 ><\/maven.compiler.target><\/span><\/span>11><\/span><\/span><\/span>
\n\u00a0 \u00a0 ><\/span><\/span><\/span>
><\/span><\/span><\/span><\/div><\/div><\/pre>\n
The first elements (<\/code> and <\/project><\/code>) contain information about the file itself, identifying the document as XML written in accordance with the Maven POM schema. The next group of elements corresponds to the Maven schema used and the project settings I provided to NetBeans.<\/p>\n
The <\/packaging><\/code> element specifies that this project is meant to be packaged as a JAR file.<\/p>\n
The <\/properties><\/code> element tells Maven about the (as-yet non-existent) source code in my project. It’s written in UTF-8 encoding for OpenJDK version 11.<\/p>\n
All of that was autogenerated by NetBeans for me when I created an example project.<\/p>\n
If you don’t use an IDE that integrates with Maven, or you simply prefer to write yours from scratch, you can find the skeleton outline of a POM file at maven.apache.org\/pom.html#Quick_Overview<\/a>. It’s clearly commented and has the XML declarations already populated.<\/p>\n
Adding a dependency to your POM<\/h2>\n
Long ago, when you wrote a Java application and decided to use an external library, you could download a JAR of the library, save it to your codebase, then use an import<\/code> statement to reference it in your Java code. It was a manual system, and while it worked as well as using, say, a C or C++ library, it could be a lot of work to maintain.<\/p>\n
Maven uses repositories, much like Linux uses repositories for software installation<\/a>, and Python uses pip<\/a>. The default repository is Sonatype’s Central Repository<\/a>, which you can search from search.maven.org<\/a>. From Central, you can find libraries and the appropriate metadata you need to fill in the required dependency fields for Maven. In practice, however, most Java libraries provide that information in their README files or documentation.<\/p>\n
Suppose you have a simple Java script that lists files in a directory, but you decide you want it to list only files ending in jpg<\/code> or png<\/code>. The Apache fileUtils<\/code> library offers a filename filter for precisely that kind of operation, but it’s not included in the Java distribution.<\/p>\n
\n
package<\/span> com.example.example4maven<\/span>;<\/span>

import<\/span> java.io.File<\/span>;<\/span>
import<\/span> java.util.Iterator<\/span>;<\/span>
import<\/span> java.util.List<\/span>;<\/span>
\/\/ external libs<\/span>
import<\/span> org.apache.commons.io.FileUtils<\/span>;<\/span>

public<\/span> class<\/span> Main {<\/span>
\n\u00a0 \u00a0 private<\/span> static<\/span> final<\/span> File<\/span><\/a> myDir =<\/span> new<\/span> File<\/span><\/a>(<\/span>\"\/home\/tux\/img\"<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 private<\/span> static<\/span> final<\/span> String<\/span><\/a>[<\/span>]<\/span> ext =<\/span> new<\/span> String<\/span><\/a>[<\/span>]<\/span> {<\/span> \"jpg\"<\/span>,\"png\"<\/span> }<\/span>;<\/span>

\n\u00a0 \u00a0 public<\/span> static<\/span> void<\/span> main(<\/span>String<\/span><\/a>[<\/span>]<\/span> args)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 ListFile><\/span> images =<\/span> (<\/span>ListFile><\/span>)<\/span> FileUtils.listFiles<\/span>(<\/span>myDir, ext, false<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 for<\/span> (<\/span>IteratorFile><\/span> i =<\/span> images.iterator<\/span>(<\/span>)<\/span>;<\/span> i.hasNext<\/span>(<\/span>)<\/span>;<\/span>)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>i.next<\/span>(<\/span>)<\/span>.getName<\/span>(<\/span>)<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 }<\/span>
\n\u00a0 \u00a0 }<\/span>
}<\/span><\/span><\/span><\/span><\/div><\/div><\/pre>\n
You could search Central for the library, or you can visit the project’s website<\/a> and get the dependency info there.<\/p>\n
Dependency information looks like this:<\/p>\n
\n
><\/dependency><\/span><\/span>
\n\u00a0 ><\/groupid><\/span><\/span>commons-io><\/span><\/span><\/span>
\n\u00a0 ><\/artifactid><\/span><\/span>commons-io><\/span><\/span><\/span>
\n\u00a0 ><\/version><\/span><\/span>2.11.0><\/span><\/span><\/span>
><\/span><\/span><\/span><\/div><\/div><\/pre>\n
Enter that between <\/dependencies><\/code> and <\/code> tags in your pom.xml<\/code> file, and you’ve added the Apache commons.io<\/code> library to your project.<\/p>\n
\n
<\/span>xml version=<\/span>\"1.0\"<\/span> encoding=<\/span>\"UTF-8\"<\/span>?><\/span>
project xmlns=<\/span>\"http:\/\/maven.apache.org\/POM\/4.0.0\"<\/span> 
\nxmlns:<\/span>xsi=<\/span>\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/span> 
\nxsi:<\/span>schemaLocation=<\/span>\"http:\/\/maven.apache.org\/POM\/4.0.0 <\/span>
\nhttp:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\"<\/span>><\/span>
\n\u00a0 \u00a0 modelVersion><\/span>4.0.0<\/span>modelVersion><\/span>
\n\u00a0 \u00a0 groupId><\/span>com.example<\/span><\/span>groupId><\/span>
\n\u00a0 \u00a0 artifactId><\/span>example4Maven<\/span>artifactId><\/span>
\n\u00a0 \u00a0 version><\/span>1.0<\/span><\/span>version><\/span>
\n\u00a0 \u00a0 packaging><\/span>jar<\/span>packaging><\/span>
\n\u00a0 \u00a0 properties><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 project.build<\/span>.sourceEncoding<\/span>><\/span>UTF-<\/span>8<\/span><\/span>project.build<\/span>.sourceEncoding<\/span>><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 maven.compiler<\/span>.source<\/span>><\/span>11<\/span><\/span>maven.compiler<\/span>.source<\/span>><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 maven.compiler<\/span>.target<\/span>><\/span>11<\/span><\/span>maven.compiler<\/span>.target<\/span>><\/span>
\n\u00a0 \u00a0 <\/span>properties><\/span>
\n\u00a0 \u00a0 dependencies><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 dependency><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 groupId><\/span>commons-<\/span>io<\/span>groupId><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 artifactId><\/span>commons-<\/span>io<\/span>artifactId><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 version><\/span>2.11.0<\/span>version><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 type><\/span>jar<\/span>type><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 <\/span>dependency><\/span>
\n\u00a0 \u00a0 <\/span>dependencies><\/span>
<\/span>project><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/div><\/div><\/pre>\n
Now when you build your project, Maven can automatically download any libraries you don’t have in your local codebase.<\/p>\n
Build a JAR with Maven<\/h2>\n
You can create JAR files with tools like fastjar or gjar<\/a>, but Maven has plugins that enable it to perform common build tasks, including packaging. For a standard JAR package, which contains your source code, you can use maven-jar-plugin<\/code>.<\/p>\n
To have Maven create an “Uber JAR”\u00a0for you, which contains your code plus all the dependent libraries your code requires, you can use maven-assembly-plugin<\/code>. The two plugins are similar in both purpose and configuration, and they’re both build plugins, so they’re entered into a <\/build><\/code> section of your pom.xml<\/code>.<\/p>\n
As with libraries, Maven metadata for plugins is available from the plugin’s homepage. You include maven-assembly-plugin<\/code> by listing its groupId<\/code>, artifactId<\/code>, and version<\/code> between <\/plugin><\/code> tags.<\/p>\n
There are additional configuration options, including:<\/p>\n
On macOS, use MacPorts<\/a> or Homebrew<\/a>.<\/p>\n