What is the difference between maven multimodule project(pom packaging) and ear packaging.
As i know Ear is used to package a group of related Module (EJB, JPA, JSF).
After reading maven documentation i found that multimodule project is used for the same thing.
Are they the same? Can i use multimodule project instead of EAR? can mutlimodule project be deployed to application servers?
A multi-module project (packaging of pom) is a way of defining a parent pom that has child modules. This is convenient for many reasons. For one, you can just build the parent pom with mvn compile and it will build all of its modules, too. Without the parent pom, you'd have to go into each pom and manually type mvn compile otherwise.
Not only that, but using modules gives you other really important features. See the answer to this question. To summarize, imagine you have a continuous integration server that just installed in the middle of you building locally. By using module, you ensure that you compile against your local code instead of the continuous integration server's code. This will prevent a lot of heisenbugs(sp?).
Now the packaging of ear is not directly related to this first multi-module concept. That packaging just determines the binary output. It will output an ear file. In the maven-ear-plugin plugin, you can include other modules like wars/jars/ejbs, but it won't do any of the things I've described in the first paragraph. For example, typing mvn compile in the directory of the ear's pom.xml file will not compile the war file it depends on.
Also, you don't have to include other maven modules in your ear. Another completely unrelated project may install an ejb and you can use that ejb in your ear just as a dependency.
multi module is just a way of organising your project into modules/components.the packaging need not be ear always.it can be for instance a war project that has all its server side content as a jar file in one of its module.
in short,multi module organisation can be opted for a ear project but the converse that mutli module is always a ear project is not true.
The two are not the same. A multi-module project just builds all sub modules, it does not produce an artifact.
Related
I have a core webapp and want to extended it by several optional modules (jar files).
These modules can contain Servlets, Filters etc.
Development:
Since the modules are optional I think that using maven modules with a parent is not the way to go,
because the parent always contains all modules and I do not want to have a parent per deployment scenario.
So a normal maven project per optional webapp module... But how do I manage that the core and the module always use the same dependencies?
Do I have to create a parent pom for both which contains all the dependencies and other shared settings (Java version etc)?
Deployment:
What is the recommendation here? Always repackage the war? Copy the module jar into the exploded WEB-INF/lib?
Could it deployed at runtime too?
It sounds like you are looking to configure and build all the possible configurations seperately instead of using or making some truly dynamic module loading system.
In that case the simplest way is to have a war-project per configuration:
You should have a module pom-project that does nothing but build all other projects. This could be the parent project, but I would use a seperate project. EDIT: I would place this project in the root of your repository and place all other projects in sub-folders. That goes well with IDEs and release tools.
You should have a parent pom-project that does Maven <dependencyManagement> for managing all dependency versions in all projects and has any general build configuration that all other projects need. All other projects except the module project has this as parent.
You will probably need a common jar-project for common code used in many modules.
You should have a jar-project for your core application.
You should have a jar-project for each module.
For each configuration you need a war-project that is nothing but a pom-file declaring the needed dependencies and mayby some property files. They will build your products.
If you want to have special configuration for the war-projects (deployment, test etc.) you can make an intermediary parent for them. It should have the general parent as parent.
Now you can build everything with the module project and end up with a war-file for each configuration.
How can i combine two maven projects. One is webapp, and other is some javascript library (also webapp) which i want to combine with others project.
Or, would be better, how to add some outside folder with js files to maven project that can be deployed on testing server and then build to war.
Have a look at overlays in the Maven WAR Plugin documentation. This explains how Maven merges resources from different web projects into a single WAR.
In a nutshell, you create several WAR files of all the dependencies (usually, you already have this but you can even do this if they aren't real working web projects). Then you can pull these in as dependencies. The important part here is to specify the type of the dependency (<type>war</type>); otherwise Maven will try to add the JAR.
The WAR plugin will notice the additional WARs in the list of dependencies and merge them.
You can create One parent project and Two modul project. You will have 3 pom.xml files.
modul projects extendens dependencies from parent project. Maven parent pom vs modules pom, Multimodule project
Maven WAR Overlays could solve the problem. If you have two maven web projects, and one of your Web Project depends on the other's you could declare the dependent project as a dependency and do an overlay.
Reference:
http://maven.apache.org/plugins/maven-war-plugin/overlays.html
I have two questions about maven project structure:
1) I am creating a maven multi-module project and would like to know if I can put all the common dependencies of the modules in the parent pom? Is that the right way to do?
2) If I am creating a maven webapp project that contains all web.xml and JSP files, where should the web controllers, listeners and model objects be residing? In a separate maven jar project or in the same webapp project?
1) Read up on the difference between dependencyManagement and dependencies. Putting all common dependencies in the parent POM will work, but it's likely to cause spurious dependencies when you add a new module.
dependencyManagement is recommended. You can specify all versions and exclusions in a central place, and then it's enough to specify groupId and artifactId for each dependency of each module.
2) Java sources directly related to the web layer usually go into the war module (unless you want to reuse them for a different project, then it's better to factor them out into a separate jar).
I would like to ask these questions related to pom.xml files in Maven projects.
What is a reason to have multiple pom.xml for all dependency libraries instead of having all dependencies in one single pom.xml?
Where should be these pom.xml files in Maven project placed?
This is an example of pom.xml for Spring framework - http://search.maven.org/remotecontent?filepath=org/springframework/spring-core/3.2.5.RELEASE/spring-core-3.2.5.RELEASE.pom
What is a reason to have multiple pom.xml for all dependency libraries instead of having all dependencies in one single pom.xml?
A maven project can be made of many artifacts. One artifact may be a String manipulation library. Another may be a webapp that uses that String manipulation library.
Here's why you shouldn't put all your dependencies in one pom: Your String manipulation library should not have a reference to the servlets.jar just because an unrelated pom is a webapp. Each artifact should have only what it needs in its classpath.
(You may be interested to learn about the dependencyManagement tag, but it does not directly relate to your question.)
Where should be these pom.xml files in Maven project placed?
As #MariuszS linked to, here's the Standard Directory Layout.
At the top level files descriptive of the project: a pom.xml file (and any properties, maven.xml or build.xml if using Ant). In addition, there are textual documents meant for the user to be able to read immediately on receiving the source: README.txt, LICENSE.txt, etc.
This depends on your project, if project is small and product of this project (artifact) is only one then one pom is enough. But if your project have many artifacts (libraries, WARs, EARs etc) then for every artifact pom is required (generally).
Maven concept is that one project definition (POM) generate only one artifact (there are exceptions). Every project should have separate directory with pom.xml inside and source directories if needed.
One maven project can build two diffrent apps (for example desktop and webapp). This diffrent applications has diffrents dependencies.
Sample multimodule project structure: https://github.com/peter-lawrey/Java-Chronicle
Read more
Introduction to the Standard Directory Layout
Guide to Working with Multiple Modules
Maven by Example
Chapter 6. A Multi-module Project
its regarding building an existing EAR using maven which contains multiple modules .
we have a EAR project which contains web and jar projects in it total of 8 projects.
ear was built using RAD and hence currently non of the project is having POM files .
now i want to use maven for project.
i want to use m2eclipse for creating POM's and build.
plannig to creat a parent project and create modules under it, which includes ear project and others as well.
so effective structure should be as below
workspace
>parent proj
>ear project
>web proj
>jar1 proj
>jar2 proj
but i have ear file containing all the projects and if i import ear in work space it create flate structure for all the projects as below
workspace
>web proj
>jar1 proj
>jar2 proj
concern is becuase of RAD project setup and .metadata files created by it in workspace.
if i create parent project in workspace and then import ear in parent its a problem.
please advise how can i do following
1> add indirection of parent project and below it have all the projects in ear
2>how to add ear project under parent which hold all the modules at build time
hope my situation and requirment is clear
please advise on it
Thanks
narayan
You shouldn't have to import the ear into the parent project, the parent should just reference the ear as a module in its pom, and appear as a subdirectory within the parent.
Perhaps I'm unclear of what you mean by import.
The order that the modules are declared in the parent pom is the order in which they are built, so the ear should be the last module in the list as it has jar1, jar2 and web modules as dependencies.
web should be the second last module in the list because it presumably depends on jar1 or jar2 or both.
M2Eclipse has the ability to import a multi-module project structure that you described above as separate projects within the workspace, choosing this option prevents you from having to work on each individual module through the parent project and expanding all the way down.
This does not change the nested structure on disk, it merely presents the modules each as their own project, and the module directories are also visible in the parent project.
It also allows each module to be built individually, or a complete build can be performed by building the parent project.
Read about maven reactor in this question.
I suggest that before you tackle your main project try out a quick archetype, see http://docs.codehaus.org/display/MAVENUSER/Archetypes+List
The appfuse archetypes by Matt Raible are really good examples to work from, try the command below to create a skeleton structure:
mvn org.apache.maven.plugins:maven-archetype-plugin:2.0:generate -DgroupId=com.test.archetest -DartifactId=archetest -DarchetypeArtifactId=appfuse-modular-jsf -DarchetypeGroupId=org.appfuse.archetypes
Have a look at the general project structure, and then import it using M2Eclipse which will generate the eclipse project files..
You could also do this through mvn eclipse:eclipse, but that won't give you the separate modules in your workspace.
Some project choose not to commit the eclipse project files, and rather have then generated from the pom through either of the methods mentioned above.
If you use the structure from the archetype given above, then you'll need to add an ear module to the parent project, this can be done through M2Eclipse.
thanks #crowne
instead of hierarchical structure i can use module approach.
to wrap all the existing projects, create a maven project of packaging type pom in same workspace
then existing projects can be added as modules as below
../module1
../module2
../module3
path specified are alway relative to location of pom in which modules are declared.