Develop Reference

How can I make an existing maven project as a part of multi module maven project?

My goal is to turn an existing maven project (char-counter) into a module of my multi-module maven project. How can I do this? I use Eclipse 4.16.0.
Here is the structure of my projects.

You can include the sub-modules inside your parent maven project in following way.
Inside your multi-module-project pom.xml
<modules>
<module>char-counter</module>
</modules>
See here: Maven Multiple module

Assuming that you want to convert your char-counter project to multi-module-project.
You need to have following in your multi-module-project pom.
<groupId>com.parent</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>Anagram<module>
<module>Calculator<module>
</modules
And then in Anagram project's pom :
<parent>
<groupId>com.parent</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<groupId>com.child</groupId>
<artifactId>Anagram</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>jar</packaging>
And in Calculator project's pom:
<parent>
<groupId>com.parent</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<groupId>com.child</groupId>
<artifactId>Calcultor</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>jar</packaging>
Also you need to add dependency of one module to other,in which you want to use the code from other module and then you need to deploy the artifact(module) which has dependency included in it and has starting point to run (like main).

Company Maven POM nested structure

Well I'm working on a company POM Maven structure. I want a structure like the example below. Now I have two questions!
Is this possible for a project to call the parent pom? (considering
that they are all installed in the local Maven repository).
If I adda License block to the Company POM, do I have to add to the
project POM a new License block?
All feedback, suggestions etc are welcome. Thank you in advance!
Company
Company POM
Contains organization information, not to much.
<groupId>org.company</groupId>
<artifactId>company</artifactId>
<version>1</version>
<modules>
<module>company-parent</module>
</modules>
Company Parent POM
Defines for all the projects basic dependencies/plugins (management).
<parent>
<groupId>org.company</groupId>
<artifactId>company</artifactId>
<version>1</version>
</parent>
<artifactId>company-parent</artifactId>
Project
Project POM
Project based organization information (developers etc).
<parent>
<groupId>org.company</groupId>
<artifactId>company-parent</artifactId>
<version>1</version>
</parent>
<groupId>org.company.project</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<modules>
<module>project-parent</module>
</modules>
Project Parent POM
Defines for the current project used dependencies/plugins (management).
<parent>
<groupId>org.company.project</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
</parent>
<artifactId>project-parent</artifactId>
<modules>
<module>company-module-1</module>
<module>company-module-2</module>
<module>company-module-3</module>
</modules>
Project Module POM's
The modules with each his own buid, dependencies and stuff.
Module 1
<parent>
<groupId>org.company.project</groupId>
<artifactId>project-parent</artifactId>
<version>1.0</version>
</parent>
<artifactId>project-module-1</artifactId>
Module 2
<parent>
<groupId>org.company.project</groupId>
<artifactId>project-parent</artifactId>
<version>1.0</version>
</parent>
<artifactId>project-module-2</artifactId>
Module 3
<parent>
<groupId>org.company.project</groupId>
<artifactId>project-parent</artifactId>
<version>1.0</version>
</parent>
<artifactId>project-module-3</artifactId>

A Maven child project does not "call" a parent project. The POM is declarative, not imperative. Similar to Java class inheritance the child gets the parent's settings and can override them or add new ones. See Maven, POM Reference, 2.2.2. Inheritance.
So, no, you don't have to declare the parent project's licence settings in the child project once again if they are supposed to be the same there.

Multi-module Spring Boot and start-class

I have made my application multi-module with the plan of eventually splitting them into multiple repos.
I'm having problems figuring out how to make mvn spring-boot:run work with my layout (which may be the problem).
actually directory structure is
xenoterracide/
rpf/
rpf-application/
when I run mvn test from xenoterracide that passes fine, and when I start my Application class that works fine.
if I cd into rpf-application and run mvn compile it tells me that it can't find the dependencies, I'm guessing this is because things are meant to be run from the repository root.
[INFO] ------------------------------------------------------------------------
[INFO] Building rpf-application 0.1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[WARNING] The POM for com.xenoterracide:security-rbac-jpa:jar:0.1.0-SNAPSHOT is missing, no dependency information available
[WARNING] The POM for com.xenoterracide:http:jar:0.1.0-SNAPSHOT is missing, no dependency information available
[WARNING] The POM for com.xenoterracide:rpf-domain:jar:0.1.0-SNAPSHOT is missing, no dependency information available
[WARNING] The POM for com.xenoterracide:rpf-liquibase:jar:0.1.0-SNAPSHOT is missing, no dependency information available
if I try to set the start-class in the xenoterracide/pom.xml it tells me it can't find the class (because of course it's in rpf-application).
rpf-application/pom.xml
<parent>
<artifactId>rpf</artifactId>
<groupId>com.xenoterracide</groupId>
<version>0.1.0-SNAPSHOT</version>
<relativePath>../rpf/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>rpf-application</artifactId>
<properties>
<start-class>com.xenoterracide.RpfApplication</start-class>
</properties>
<dependencies>
<!-- internal -->
<dependency>
<groupId>com.xenoterracide</groupId>
<artifactId>security-rbac-jpa</artifactId>
<version>0.1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.xenoterracide</groupId>
<artifactId>http</artifactId>
<version>0.1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.xenoterracide</groupId>
<artifactId>rpf-domain</artifactId>
<version>0.1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.xenoterracide</groupId>
<artifactId>rpf-liquibase</artifactId>
<version>0.1.0-SNAPSHOT</version>
</dependency>
...
rpf/pom.xml
<parent>
<artifactId>xenoterracide</artifactId>
<groupId>com.xenoterracide</groupId>
<version>0.1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>rpf</artifactId>
<packaging>pom</packaging>
<modules>
<module>../rpf-domain</module>
<module>../rpf-application</module>
<module>../rpf-liquibase</module>
</modules>
pom.xml
<modelVersion>4.0.0</modelVersion>
<groupId>com.xenoterracide</groupId>
<artifactId>xenoterracide</artifactId>
<packaging>pom</packaging>
<version>0.1.0-SNAPSHOT</version>
<modules>
<module>util</module>
<module>http</module>
<module>security-rbac-api</module>
<module>security-rbac-jpa</module>
<module>hibernate</module>
<module>entity-jpa</module>
<module>rpf</module>
<module>test-repositories</module>
<module>entity-api</module>
</modules>
<properties>
<!-- use UTF-8 for everything -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<parent>
<groupId>io.spring.platform</groupId>
<artifactId>platform-bom</artifactId>
<version>1.1.2.RELEASE</version>
</parent>
how can I make mvn spring-boot:run work from either the root of the repository (xenoterracide) or from rpf-application?

I also have a multi-project Spring Boot app and you can't do it from the parent since there could be multiple modules and it would not know which to run. You can do it from the child module if you first install the rest of the project to local Maven repository. So from your xenoterracide run:
mvn install
Assuming that works it will put your SNAPSHOT versions into your local repository. You can then change to your rpf-application and then run:
mvn spring-boot:run
I've never really used this as a way to run it so maybe you can explain what your need is and we can see if there is another way that may be better. I did do it with my project and it works but you have to be conscious of where the working directory is for your environment specific configuration files.

Move project from Ant to Maven and break it up

I have an existing web project which currently uses Ant. I have tasks that:
create the jar based on only certain packages for other applications which use this project as a dependency
create the war file for the app
and a lot of others.
Separately I have a webservice project which uses the jar built by the previous application. This project uses Maven.
Now what I want to achieve is to move the first project to Maven, break it into core and web, and then move the webservice project into the first one.
So the result will be a multi-module project:
core
ui
webservice
Is it possible to move the sources that deal with the web delivery mechanism into the ui module (which will be a war in Maven), or I need to keep the sources in the core?
What would the best approach to do this be?
Should I look into Maven profiles?
I am a novice with Maven, so I am unsure on how to approach this.

Yes you can achieve what you want with Maven. I would break the modules like this:
Core:
<groupId>com.myapp</groupId>
<artifactId>core</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
UI:
<groupId>com.myapp</groupId>
<artifactId>ui</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<!-- Dependends on core -->
<dependency>
<groupId>com.myapp</groupId>
<artifactId>core</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
Web service:
<groupId>com.myapp</groupId>
<artifactId>ws</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<!-- Also Dependends on core -->
<dependency>
<groupId>com.myapp</groupId>
<artifactId>core</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
Main Project:
<groupId>com.myapp</groupId>
<artifactId>myapp</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>core</module>
<module>ui</module>
<module>ws</module>
</modules>
Then, in Core / UI and Web service you declare myapp as the parent:
<parent>
<groupId>com.myapp</groupId>
<artifactId>myapp</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
For further info refer to:
Introduction to the POM: Particularly: Inheritance and Project Aggregation
Maven by Example: Chapter 6. A Multi-module Project: For a sample project
Multi-modules projects: For the folder structure

how to make maven build dependent project

I have project with several dependencies on other project.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>group1</groupId>
<artifactId>artifact1<artifactId>
<name>RealtyRegistry</name>
<packaging>war</packaging>
<version>1.0.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>group1</groupId>
<artifactId>artifact2</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>group1</groupId>
<artifactId>artifact3</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
All of them developed by me simultaniously. I add edition to files of all of project and i need to build main project together with dependent ones. How to do that for projects without tree structure?
There can be 2 or more covering trees for projects hierachy, for example: A depends on B,C; D depends on C,E; A and D are independent.

You can build multiple projects together using "Modules". Normally, you would do this by creating a "mother" project with <packaging>pom</packaging> and adding your real project as modules using the <modules> tag. Then, when you build the "mother" project, all modules are automatically built in the right order.
Here is an example from the Maven by Example book:
<groupId>org.sonatype.mavenbook.multi</groupId>
<artifactId>simple-parent</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<modules>
<module>simple-weather</module>
<module>simple-webapp</module>
</modules>
Note that this requires you to have your modules in subfolders that are named accordingly. For example, you would have the "mother" pom in some folder:
/.../my-project/
and the modules in:
/.../my-project/simple-weather/
/.../my-project/simple-webapp/
For more information, read Chapter 6. A Multi-module Project of the book, it's freely available on the Sonatype website.