Question

If the question title can’t make it clear, take me explain here in more detail. Suppose the production jar of one of my Maven applications needs to be used into my other Maven web-application. Adding that jar to my second application Maven dependency doesn’t add its transitive dependencies. Also, the jar in itself is an application.

One way is to look at the POM of the first application and add those in the POM of the other application. But then, how do central Maven jars add their own transitive dependencies when added to some project.

In other words, if I add commons-io.jar Maven dependency to my project, it automatically adds its transitive dependencies. But when I add myjar.jar as a Maven dependency (scope->system) then it doesn’t automatically adds its transitive dependencies.

I think that I should develop my first application as some other archetype which can be used in such a case. Please advise me how to proceed further.

Sorry for this newbie question. Actually, I’m new to Maven and I’ve started using Netbeans-embedded-maven to create applications. I really like the way Maven simplifies the job.

edited

Seems like I should explain in more detail. So here is it.

Suppose I wrote a program/application that used A.jar,B.jar,C.jar and my production output was X.jar (which obviously doesn’t contain other jars within as per maven default build). The above A,B,C jars are present in maven central repository and were added as dependency to my project. The project build jar is X.jar

Now I write another application in which I added X.jar as a system dependency, now what I want is that A.jar, B.jar, C.jar added automatically to the project since they are transitive dependencies for X.jar

Hope so I’ve explained it clear this time. Please forgive me for my writing style in case you didn’t understand earlier.

One solution is to build X.jar containing all dependencies within it using something like this

 <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.nitinsurana.mlmmaven.Start</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-my-jar-with-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

But I’m looking for something that automatically adds transitive dependencies of a system dependency.

Answer 1

I had gone through the link provided by @Sean and it seems like what I want is not possible.

Shall I vote to delete this question ?

Although the answer is IT CAN’T BE DONE and heres’ why :

Project-A -> Project-B

The diagram above says that Project-A depends on Project-B. When A declares B as an optional dependency in its POM, this relationship remains unchanged. Its just like a normal build where Project-B will be added in its classpath.

Project-X -> Project-A

But when another project(Project-X) declares Project-A as a dependency in its POM, the optional dependency takes effect. You’ll notice that Project-B is not included in the classpath of Project-X; you will need to declare it directly in your POM in order for B to be included in X's classpath.

Taken from Official Documentation