 ------
 ${project.name}
 ------
 Hervé Boutemy
 ------
 2010-04-25
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/guides/mini/guide-apt-format.html

${project.name}

 <<<${project.artifactId}>>> is an archetype which generates a simplified sample J2EE application:

+----+

project
|-- pom.xml
|-- ear
|   |-- pom.xml
|   `-- src
|       |-- main
|       |   `-- java
|       `-- test
|           `-- java
|-- ejbs
|   |-- pom.xml
|   `-- src
|       |-- main
|       |   |-- java
|       |   `-- resources
|       |       `-- META-INF
|       |           `-- ejb-jar.xml
|       `-- test
|           `-- java
|-- primary-source
|   |-- pom.xml
|   `-- src
|       |-- main
|       |   `-- java
|       `-- test
|           `-- java
|-- projects
|   |-- pom.xml
|   `-- logging
|       |-- pom.xml
|       `-- src
|           |-- main
|           |   `-- java
|           `-- test
|               `-- java
`-- servlets
    |-- pom.xml
    `-- servlet
        |-- pom.xml
        `-- src
            |-- main
            |   `-- java
            |-- webapp
            |   |-- WEB-INF
            |   |   `-- web.xml
            |   `-- index.jsp
            `-- test
                `-- java

+----+

* Usage

 To generate a new project from this archetype, type:

+----+

mvn archetype:generate -DarchetypeGroupId=${project.groupId} -DarchetypeArtifactId=${project.artifactId} -DarchetypeVersion=${project.version}

+----+
