We Keep Coding

Java Webapp modules

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.

maven multi module build with a shared utility project

Hi I am converting a ear project to Maven. Below is the structure
-projA-ear
-projA-static
-projA-web
-shared-util
The shared util is shared by multiple unrelated projects handled by our team. Currently my deployment assembly is handled by eclipse and the shared-util.jar is automatically built inside the projA-web.war's WEB-INF/lib directory
When I convert my setup to Maven project, I am reading that I need multi module aggregator setup, and need to define shared-util as a module, and then define the aggregator POM as the parent to my modules. The problem is I cannot define projA-mvn as parent in the shared-util project as the other projects would be using it too as a module(when they decide to move to maven). Can someone please suggest a solution?

1) Make shared-util as a separate standalone Maven project.
2) Put projA-ear, projA-web and projA-static under a separate parent Maven project.
3) Declare shared-util jar as a dependency in your projA-web pom.

Maven combine two project

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

Maven multi-module project and webapp project

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).

difference between MutliModule and EAR

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.