This is one of the methods to create a Maven project. But in this rather than creating a project outside Eclipse and then importing it to Eclipse, we will directly create a maven project into Eclipse.

Step 1: Open your Eclipse and Go to File > New > Others.

Step 2: Select Maven Project and click on Next.

Step 3: Un-check the ‘Use default Workspace location’ and with the help of the Browse button choose your workspace where you would like to set up your Maven project.

Step 4: Select the archetype, for now just select the ‘maven-aechetype-quickstart’ and click on Next.

Step 5: Enter the Group Id & Artifact Id and click on Finish button.

Step 6: Go to the project location to see the newly created maven project. Now open the pom.xml file, which resides in the project folder. By default the POM is generated as below screenshot:

Step 7: Look at the default folder structure of the Maven project.

Step 8: Modify POM.xml with the latest Junit and other required dependencies and save the POM.xml

The post How to create a Maven project in Eclipse appeared first on ProdSens.live.

Summary

Apache Maven is a popular open source software to build and manage projects of Java (and also other programming languages), licensed under Apache-2.0.

With Devuan 5 Daedalus based on Debian 12 bookworm, it is easy to use it thanks to their packages management. However, it is not always the latest. Actually, Maven Debian 12 offers is currently 3.8 instead of 3.9. Well, is it a big problem ? Probably, no.

In my previous post, I installed OpenJDK 21, the latest, manually on Devuan 5. Here, I will show how to install Maven manually, too.
Of course, it is easier to run apt install maven

Environment

• OS: Devuan 5 Daedalus
  • based on Debian 12
• App Engine: OpenJDK 21
• Project Build and Management: Apache Maven 3.9.5

Tutorial

Suppose that your PATH includes Java 21 bin which appears before those of other Java versions such as 17 (the previous LTS).

Get Apache Maven package

Visit: https://maven.apache.org/download.cgi

Get the binary with the command line, for example:

$ curl -LO https://dlcdn.apache.org/maven/maven-3/3.9.5/binaries/apache-maven-3.9.5-bin.tar.gz

You can verify the download by comparing the checksums between the server and the local. Use the command lines below, for example:

$ echo "$(curl -s https://downloads.apache.org/maven/maven-3/3.9.5/binaries/apache-maven-3.9.5-bin.tar.gz.sha512) apache-maven-3.9.5-bin.tar.gz" | 
      sha512sum -c
apache-maven-3.9.5-bin.tar.gz: OK

It means it was confirmed that the server checksum was equal to the local one:

$ # checksum of the downloaded file
$ sha512sum apache-maven-3.9.5-bin.tar.gz
4810523ba025104106567d8a15a8aa19db35068c8c8be19e30b219a1d7e83bcab96124bf86dc424b1cd3c5edba25d69ec0b31751c136f88975d15406cab3842b  apache-maven-3.9.5-bin.tar.gz

Place files

Extract it:

$ tar xzf apache-maven-3.9.5-bin.tar.gz

The result is as below:

$ ls {.,apache-maven-3.9.5}
.:
apache-maven-3.9.5/            apache-maven-3.9.5-bin.tar.gz
(...)

apache-maven-3.9.5:
bin/  boot/  conf/  lib/  LICENSE  NOTICE  README.txt

Now you have apache-maven-3.9.5 directory which contains bin etc.

Set environment variables

Update PATH to include Maven bin:

$ # case bash
$ export PATH=$(readlink -f ./apache-maven-3.9.5/bin):$PATH
$ # case fish
$ #set -x PATH $(readlink -f ./apache-maven-3.9.5/bin/):$PATH

Conclusion

Now Apache Maven is in your hands:

$ mvn --version
Maven home: /(...)/apache-maven-3.9.5
Java version: 21, vendor: Oracle Corporation, runtime: /(...)/jdk-21
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "6.1.0-13-amd64", arch: "amd64", family: "unix"

Let’s create an example project named “maven-example-01” and run it:

$ # create a project
$ mvn archetype:generate 
      -DarchetypeArtifactId=maven-archetype-quickstart 
      -DinteractiveMode=false 
      -DgroupId=com.myexample.app 
      -DartifactId=maven-example-01

$ # files are generated
$ cat src/main/java/com/myexample/app/App.java
package com.myexample.app;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
    }
}

$ # build it
$ mvn package

$ # run
$ java -cp 
      target/maven-example-01-1.0-SNAPSHOT.jar 
      com.myexample.app.App
Hello World!

Yay

The post Maven on Java 21 and Devuan 5 (Debian 12): Install manually appeared first on ProdSens.live.

Maven is a popular build automation tool used primarily for Java projects. It is designed to manage a project’s build process, including the managing dependencies, packaging, deployment and generating reports.

Maven uses an XML file called a Project Object Model pom.xml to define the project’s configuration, including its dependencies, plugins, and other settings.

The POM file is typically stored in the project’s root directory.

Why Use Maven?

Maven is a popular build tool for Java projects that provides a number of benefits, including:

1. Dependency management: Maven makes it easy to manage dependencies for your project, including downloading and including libraries from remote repositories.

2. Build automation: Maven automates the build process, including compiling the code, running tests, and packaging the application into a distributable format.

3. Consistent project structure: Maven provides a standard project structure that makes it easy to organize your code and resources.

4. Plugin system: Maven has a powerful plugin system that can be used to extend the functionality of the build process, such as generating documentation or deploying the application to a server.

5. Easy project setup: Maven provides archetypes that can be used to quickly set up a new project with a predefined structure and dependencies.

6. Reproducible builds: Maven provides a way to create reproducible builds, which means that the build process is consistent across different machines and environments.

7. Integration with IDEs: Maven integrates with popular Java IDEs, such as Eclipse and IntelliJ, making it easy to import and work with Maven projects.

Overall, Maven can help improve the productivity of developers and make it easier to manage complex Java projects by automating common tasks and providing a standardized way to structure and build projects.

Project Identifiers in Maven?

Maven projects are identified by 3 main identifiers/coordinates:

1. Group Id: Unique identifier for the organization. Typically, this is a reversed domain name.
2. Artifact Id: Used to generate the biluild (JAR /WAR) files.
3. Version: A version number e.g 1.0.0

Maven uses a centralised repository to manage project dependencies. The Maven Repository is divided into three types: Local, Central and Remote.

1. Maven Local Repository
The local repository is a directory on the developer’s machine where all the dependencies for a specific project are stored.

The local repository in Maven is usually located in the user’s home directory under the .m2 folder.

2. Central Maven Repository
This is the default remote repository used by Maven maintained by Apache Community.

It contains a vast collection of open-source libraries and dependencies, making it a one-stop shop for most projects.

Browse here: https://repo1.maven.org/maven2/.

3. Remote Repository is a repository of dependencies located on a remote server, typically managed by third party organizations.

Here’s an example of how to use a remote Maven repository in a Java project:

    
        central
        Central Repository
        https://repo.maven.apache.org/maven2
    
    
        jcenter
        JCenter
        https://jcenter.bintray.com
    

For every dependency defined in pom.xml file, it first search dependency in the local repository, followed by the remote repositories in the same order as defined in the pom.xml file.

If the dependency is not found in any of the remote repositories, Maven reports a build error.

Creating Maven Java Project using CommandLine

1. Create a new project directory:
   Create a new directory for your project. For example, you can create a directory called “my-maven-project”.

mkdir my-maven-project

1. Navigate to the project directory:
   Navigate to the newly created directory.

cd my-maven-project

1. Create a new Maven project:
   Create a new Maven project using the mvn archetype:generate command. This command generates a new Maven project based on a template or archetype.

mvn archetype:generate 
    -DgroupId=com.example.app 
    -DartifactId=my-app 
    -DarchetypeArtifactId=maven-archetype-quickstart 
    -DinteractiveMode=false

By the way, you don’t have to remember each of these parameters provided above. Just use the interactiveMode=true, so that Maven asks for all the required parameters.

In this command, the groupId and artifactId are the unique identifiers for your project. The archetypeArtifactId specifies the archetype to use, which in this case is the maven-archetype-quickstart archetype, which creates a simple Java project with a main class.

Learn more about Maven build process, repository and build profiling here.

c01-Introduction to Maven

c02-Install and configure Maven on Windows

c03-Install and configure Maven on macOS?

c04-Maven Repository Introduction

c05-Creating Maven Java Project using CommandLine

c06-Understanding Maven Project and Dependencies

c07-Maven Build Lifecycles

c08-Popular Maven Commands

c09-Working with Profiles in Maven

Conclusion and Wrap Up

Whether you’re a beginner or an experienced developer, this articles will help you to up to speed with Maven.

The post Getting Started with Maven: A Beginner’s Guide to Java Build Automation appeared first on ProdSens.live.

Apache Maven is a build automation tool used primarily for Java projects. Based on the concept of a Project Object Model (POM), Maven can manage a project’s build, reporting, and documentation from a central piece of information.

Maven’s objectives

Maven’s primary goal is to allow a developer to comprehend the complete state of a development effort in the shortest period of time. Maven adheres to the principle of “convention over configuration” that helps building Maven projects with very little configuration. Systems, libraries, and frameworks should assume reasonable defaults, and systems should “just work” without requiring unnecessary configuration. In order to attain this goal, there are several areas of concern that Maven attempts to deal with:

• Making the build process easy
• Providing a uniform build system
• Providing quality project information
• Providing guidelines for best practices development
• Allowing transparent migration to new features

The configuration of a Maven project is done by creating a file called pom.xml located at the root of the project. This file is referred to as the POM file. Each POM file inherits from a global Super POM that defined common properties for all Maven projects.

More information

• Maven Releases History, with documentation
• Apache Maven Wikipedia Article

Free Maven Books

• Better Builds with Maven
• Sonatype eBooks

The post In One Minute : Maven appeared first on ProdSens.live.

Summary

In this post I’ll demonstrate how quickly a simple Maven plugin can be created.

Reason

Normally in Maven project you do not need to create own plugins as there likely exists a plugin which covers common scenarios. However, there are edge cases or project specific needs where having own plugin would make sense.

What do we need

• Installed Maven (I used 3.6.3)
• Java 11+ (for lower Java version sample POM needs to be adjusted)
• Your favorite text editor

Naming

Every project starts from its name. The plugin naming convention is -maven-plugin. In sample I’ll use struggzard-maven-plugin.

Project POM

Create project directory struggzard-maven-plugin and add pom.xml file with content bellow:

    4.0.0

    dev.stuggzard.tutorial
    struggzard-maven-plugin
    1.0-SNAPSHOT
    maven-plugin

    A Simple Maven Plugin

    
        11
        ${java.version}
        ${java.version}
    

    
        
            org.apache.maven
            maven-plugin-api
            3.0
        

        
        
            org.apache.maven.plugin-tools
            maven-plugin-annotations
            3.4
            provided
        
    

At this point maven build will likely fail as there no Mojo defined.

Add Mojo

The “Mojo” in Maven terminology is a simple class which represents one plugin goal (e.g. print message).

package dev.struggzard.tutorial;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;

/**
 * A Mojo which accepts parameter and prints it.
 */
@Mojo(name = "print")
public class MessagePrinterMojo extends AbstractMojo {

    @Parameter( property = "print.text", defaultValue = "Default text" )
    private String textParameter;

    public void execute() throws MojoExecutionException, MojoFailureException {
        getLog().info(textParameter);
    }
}

Running from CLI

Maven plugin can be invoked directly from CLI using following pattern:
mvn groupId:artifactId:version:goal

Run plugin:
mvn dev.stuggzard.tutorial:struggzard-maven-plugin:1.0-SNAPSHOT:print

Output:

[INFO] Scanning for projects...
[INFO] 
[INFO] ---< dev.stuggzard.tutorial:struggzard-maven-plugin >---
[INFO] Building A Simple Maven Plugin 1.0-SNAPSHOT
[INFO] ---[ maven-plugin ]---
[INFO] 
[INFO] --- struggzard-maven-plugin:1.0-SNAPSHOT:print (default-cli) @ struggzard-maven-plugin ---
[INFO] Default text
[INFO] -----------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] -----------------------------------------------------------------------
[INFO] Total time:  0.390 s
[INFO] Finished at: 2020-06-21T17:29:28+03:00
[INFO] ------------------------------------------------------------------------

As no parameter was passed [INFO] Default text was printed.

Now try passing text parameter:
mvn dev.stuggzard.tutorial:struggzard-maven-plugin:1.0-SNAPSHOT:print -"Dprint.text=Sample Text"

Output:

[INFO] Scanning for projects...
[INFO] 
[INFO] ---< dev.stuggzard.tutorial:struggzard-maven-plugin >---
[INFO] Building A Simple Maven Plugin 1.0-SNAPSHOT
[INFO] ---[ maven-plugin ]---
[INFO] 
[INFO] --- struggzard-maven-plugin:1.0-SNAPSHOT:print (default-cli) @ struggzard-maven-plugin ---
[INFO] Sample Text
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.346 s
[INFO] Finished at: 2020-06-21T17:33:08+03:00
[INFO] ------------------------------------------------------------------------

With passed parameter text was printed accordingly [INFO] Sample Text.

Adding plugin in other Maven project

In most cases plugins are created for integration into another maven project. Here some sample Maven project POM:

    4.0.0

    dev.struggzard.tutorial
    sample-module
    1

    
        11
        ${java.version}
        ${java.version}
    

    
        
            
                dev.stuggzard.tutorial
                struggzard-maven-plugin
                1.0-SNAPSHOT
                
                    
                        validate
                        
                            print
                        
                    
                
                
                    Sample text
                
            
        
    

By invoking mvn clean install on maven project Maven plugin goal print will be triggered with configured text parameter.

Resources

• Plugin source code – https://github.com/struggzard/struggzard-maven-plugin
• Maven plugin guide – http://maven.apache.org/guides/plugin/guide-java-plugin-development.html

The post Create a Simple Maven Plugin appeared first on ProdSens.live.

The Apache Maven Shade Plugin is perhaps the easiest way to produce a jar-with-dependencies, a single jar file containing everything your Java application needs to run, including all of its dependencies. These are sometimes also referred to as “uber jars” or “fat jars.” There are some issues that may arise though if you are not careful in how you configure it. For example, if your project uses Java Platform Module System (JPMS) modules, then if you are not careful you may end up with a jar-with-dependencies that doesn’t function for those who wish to consume it in their projects.

My intention in this post is not to encourage the use of such uber jars. Ideally, consumers of your library should use a tool for dependency management, such as build tools like Maven (or Gradle) that handles importing transitive dependencies. However, for those that don’t use a dependency management tool, offering them a jar-with-dependencies provides a convenient option to ensure that they download everything they need. Another scenario where I see a potential benefit is for applications, where distributing your application as a single jar file simplifies things for your users.

Table of Contents: The remainder of this post is organized as follows:

• Basic Configuration
• Configuration if You Use JPMS Modules
• Live Example from one of my projects on GitHub
• Where You Can Find Me

Basic Configuration

This is not a general tutorial on Maven. I’m assuming that you know the basics of configuring your Maven pom.xml. Here is a minimal example of configuring the Maven Shade Plugin to build a jar-with-dependencies during the package phase. Someplace inside of and insert the following:

    org.apache.maven.plugins
    maven-shade-plugin
    3.3.0
    
        true
        jar-with-dependencies
    
    
        
            package
            
                shade
            
        
    

Now whenever you run mvn package or any other command that includes the package phase, in addition to the regular jar, you will get a jar-with-dependencies.

Configuration if You Use JPMS Modules

First, be aware that if your project uses JPMS modules that the resulting jar-with-dependencies will only be usable on the classpath. In fact, to get it to work, we need to filter out the module-info.class of our library, as well as the module-info.class of every dependency. Why? There is a one-to-one mapping of JPMS module to jar file. The JPMS specification doesn’t allow a single jar to contain multiple JPMS modules. If we attempt to use the configuration in the previous section above, our jar-with-dependencies will include one module-info.class file, either from our library (or application) or from one of its dependencies. We’ll essentially end up with whichever module-info.class is the last that the Maven Shade Plugin attempts to include.

The problem with having an arbitrarily chosen module-info.class is that it controls what Java packages are exported from the module, as well as what Java packages are required by the module. To deal with this, we need to configure the Maven Shade Plugin to exclude all of the module-info.class files. The Maven Shade Plugin provides a filtering feature that we can use to accomplish this. So adjust the configuration to use a filter to exclude the module-info.class file from all artifacts that you are combining into the jar-with-dependencies with the following.

    org.apache.maven.plugins
    maven-shade-plugin
    3.3.0
    
        true
        jar-with-dependencies
        
            
                *:*
                
                    module-info.class
                
            
        
    
    
        
            package
            
                shade
            
        
    

With the above, the jar-with-dependencies can be used by consumers of our library on the classpath in a non-JPMS project. The regular jar file is not affected by this, and will continue to include the module-info.class that defines our JPMS module, enabling appropriate use within JPMS projects.

Live Example

To see a live example, you can consult the pom.xml of one of my projects. Here is the GitHub repository:

cicirello
/
Chips-n-Salsa

A Java library of Customizable, Hybridizable, Iterative, Parallel, Stochastic, and Self-Adaptive Local Search Algorithms

Chips-n-Salsa

Copyright (C) 2002-2022 Vincent A. Cicirello.

Website: https://chips-n-salsa.cicirello.org/

API documentation: https://chips-n-salsa.cicirello.org/api/

Publications About the Library
Packages and Releases
Build Status
JaCoCo Test Coverage
Security
DOI
License
Support

How to Cite

If you use this library in your research, please cite the following paper:

Cicirello, V. A., (2020). Chips-n-Salsa: A Java Library of Customizable, Hybridizable, Iterative, Parallel, Stochastic, and Self-Adaptive Local Search Algorithms. Journal of Open Source Software, 5(52), 2448, https://doi.org/10.21105/joss.02448 .

Overview

Chips-n-Salsa is a Java library of customizable, hybridizable, iterative, parallel, stochastic, and self-adaptive local search algorithms. The library includes implementations of several stochastic local search algorithms, including simulated annealing, hill climbers, as well as constructive search algorithms such as stochastic sampling. Chips-n-Salsa now also includes genetic algorithms as well as evolutionary algorithms more generally. The library very extensively supports simulated annealing. It includes several classes for representing solutions to a variety of optimization problems. For…

View on GitHub

Where You Can Find Me

Follow me here on DEV:

Vincent A. CicirelloFollow

Researcher and educator in A.I., algorithms, evolutionary computation, machine learning, and swarm intelligence

Follow me on GitHub:

cicirello
/
cicirello

My GitHub Profile

Vincent A Cicirello

Sites where you can find me or my work
Web and social media
Software development
Publications

If you want to generate the equivalent to the above for your own GitHub profile,
check out the cicirello/user-statistician
GitHub Action.

View on GitHub

Or visit my website:

Vincent A. Cicirello – Professor of Computer Science

Vincent A. Cicirello – Professor of Computer Science at Stockton University – is a
researcher in artificial intelligence, evolutionary computation, swarm intelligence,
and computational intelligence, with a Ph.D. in Robotics from Carnegie Mellon
University. He is an ACM Senior Member, IEEE Senior Member, AAAI Life Member,
EAI Distinguished Member, and SIAM Member.

cicirello.org

The post How to Use the Maven Shade Plugin if Your Project Uses Java Platform Module System appeared first on ProdSens.live.