多模块Maven项目

Question

I'm trying to get a Maven setup going. My project layout is simple:

+
+--- libA
+--- libB
+--- projX
+--- projY

libA and libB (actually, about 5 of them) are shared code among the projects. projX and projY (actually, about 10) are standalone applications with a Main each.

My requirements are simple:

1) Be able to run projX and projY in Eclipse
2) Compile standalone JARs (with dependencies) for projX and projY with single commands each
3) DRY

I current have a working setup from my predecessor. It has a pom.xml file per library, which is fine, but two pom.xml files per project, which is not. One of them does not even compile , but is needed by the other for compile assembly:single . The two files are almost duplicates of eachother, and adding a new library to a project requires changes in 3-4 different places.

I have tried various things. Surprisingly, adding a super-parent pom.xml in the root was the easiest. That took care of project-wide settings such as UTF-8 source file encoding and whatnot. What did not work was everything else. Between POMs not being able to refer to eachother unless certain modifications are made, refusing to compile source folders when they are, insisting on a local repository which is ever-empty or requiring absolute paths otherwise, I was not able to meet the requirements I listed. This is despite reading the official documentation and scouring for examples online.

Can anyone help?

Answer 1

You will need 3 pom.xml files one for parent project and one for each child project. You will have 3 separate projects. In parent project you will have only dependencies for jars which are same for the child projects. for eg.

Parent pom.xml

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.multimodule</groupId>
    <artifactId>multimodule</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>model</module>
        <module>presentation</module>
    </modules>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

child pom.xml

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.multimodule</groupId>
        <artifactId>multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>presentation</artifactId>
    <packaging>war</packaging>
    <dependencies>

    <dependency>
        <groupId>com.multimodule</groupId>
        <artifactId>model</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>

another child pom.xml

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.multimodule</groupId>
    <artifactId>multimodule</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>model</artifactId>
</project>...

This sample is used for web application where you have separately model and presentation layer. Multimodule project can be easily created via Eclipse or Intellij Idea.

Answer 2

Normally, this shouldn't be too complicated with Maven. The main idea is to put most of the redundant information in the parent (for the sake of simplicity we'll use only one parent) and then have the child modules reference the parent.

This brings the advantage of having most of the "configurable" settings in one place and limit the amount of redundancy.

See this link for information regarding the different forms of inheritance in Maven

The structure of your projects should be something like this:

+
     pom.xml (root)
+--- libA
     +--- src
         +---main
             +---java
             +---resources
     pom.xml
+--- libB
     +--- src
         +---main
             +---java
             +---resources
     pom.xml
+--- projX
     +--- src
         +---main
             +---java
             +---resources
     pom.xml
+--- projY
     +--- src
         +---main
             +---java
             +---resources
     pom.xml

See this link regarding standard Maven layout

You'll have 3 types of pom.xml (1 per project/library)

1. The parent root project (listing all the 'modules' and providing all inheritable settings like dependency versions, plugin versions and configuration, properties, etc...)

---

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.foo.bar</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <compiler.source>1.6</compiler.source>
        <compiler.target>1.6</compiler.target>
        <source.encoding>UTF-8</source.encoding>
        <resource.encoding>UTF-8</resource.encoding>
    </properties>

    <modules>
        <module>libA</module>
        <module>projX</module>
    </modules>
    <dependencyManagement>
        <dependencies>
            <!-- Here put all the dependencies of all your project with groupId/artifactId/version-->
        </dependencies>
    </dependencyManagement>
    <build>
        <pluginManagement>
            <!-- Here put all your plugins with groupId/artifactId/version and configuration -->
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>${compiler.source}</source>
                        <target>${compiler.target}</target>
                        <encoding>${source.encoding}</encoding>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>2.5</version>
                    <configuration>
                        <encoding>${resource.encoding}</encoding>
                    </configuration>
                </plugin>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>2.5.3</version>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <executions>
                        <execution>
                            <id>build-resources</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

2. One pom.xml per library (libA, libB, etc...)

---

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.foo.bar</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>libA</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <!-- Here list all the actual dependencies but only groupId and artifactId 
            (versions are all put in the parent) -->
        <dependency>
            <groupId>...</groupId>
            <artifactId>...</artifactId>
        </dependency>
    </dependencies>
</project>

3. One pom.xml per project (projX, projY, etc...) and here we'll also add the maven-assembly to the build

---

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.foo.bar</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>projX</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <!-- Here list all the actual dependencies but only groupId and artifactId (versions are all put in the parent) -->
        <dependency>
            <groupId>com.foo.bar</groupId>
            <artifactId>libA</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin> 
                <groupId>org.apache.maven.plugins</groupId> 
                <artifactId>maven-assembly-plugin</artifactId> 
            </plugin> 
        </plugins>
    </build>
</project>

In this configuration, maven-assembly is attached to the phase "package" which means that by calling mvn package in your root project, you will have all jar's and jar-with-dependencies build in one go.