Estructura de carpetas de un proyecto Java con Maven

Como adelantabamos en el anterior post, Creación de un proyecto Java desde Maven , vamos a hablar de la estructura que tiene un proyecto base. Como comentabamos en Introducción a Maven, una de las principales características de Maven es que sigue el patrón de convención sobre configuración. Esto significa que debemos situar nuestras clases, tests o recursos en un lugar en concreto, para que luego Maven sea capaz de tratarlos correctamente.

Maven tiene cuatro carpetas fuente por defecto:

• src/main/java : donde guardaremos nuestras clases java fuente. Debajo de esta carpeta situaremos nuestras clases en distintos paquetes.
• src/main/resources : aquí almacenaremos los recursos (ficheros xml, ficheros de propiedades, imagenes, …) que pueda necesitar las clases java de nuestro proyecto. Igualmente aquí tienen que ir los ficheros de configuración de Spring o Hibernate por ejemplo.
• src/test/java : en dicha carpeta se guardan las clases de test que se encargarán de probar el correcto funcionamiento de nuestra aplicación. Aquí por ejemplo podemos guardar nuestros test unitarios de JUnit.
• src/test/resources : en esta carpeta guardamos los recursos que usan los recursos.

Podemos ver una estructura ejemplo en el siguiente proyecto que hemos creado en Eclipse:

Si vemos el fichero pom.xml de nuestro proyecto recién creado vemos lo siguiente.

<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.hop2croft.examples</groupId>
	<artifactId>example-post</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>EjemploMaven</name>
	<description>Ejemplo de proyecto con Maven</description>
</project>

El fichero pom.xml está practicamente vacío, ¿cómo sabe entonces Maven que tiene que usar el contenido de las cuatro carpetas para construir el proyecto?. El fichero pom.xml que nos enseña el editor de Eclipse, no es el fichero pom real (llamado pom efectivo) que usa nuestro proyecto. Nuestro fichero pom.xml hereda una serie de propiedades de un fichero pom padre o super pom en él que viene indicado las propiedades estándar que usa Maven. Si queremos podemos ver su contenido desde consola con el siguiente comando.

mvn help:effective-pom

Por suerte el editor integrado en Eclipse nos permite ver el contenido de este pom efectivo. En este pom efectivo podemos ver las dependencias, plugins o las propiedades de construcción por defecto de Maven. En la siguiente captura podemos ver la parte de construcción ():

 
<build>
    <sourceDirectory>/Users/hop/example-post/src/main/java</sourceDirectory>
    <scriptSourceDirectory>/Users/hop/example-post/src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>/Users/hop/example-post/src/test/java</testSourceDirectory>
    <outputDirectory>/Users/hop/example-post/target/classes</outputDirectory>
    <testOutputDirectory>/Users/hop/example-post/target/test-classes</testOutputDirectory>
    <resources>
      <resource>
        <directory>/Users/hop/example-post/src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>/Users/hop/example-post/src/test/resources</directory>
      </testResource>
    </testResources>
    <directory>/Users/hop/example-post/target</directory>
    <finalName>example-post-0.0.1-SNAPSHOT</finalName>
    <pluginManagement>
... 
</build>

Si nos fijamos podemos ver como vienen indicadas las carpetas donde Maven buscará las clases y recursos de nuestro proyecto. Además vienen indicadas las carpeta de salida (carpeta target de nuestro proyecto) donde se guardarán las clases compiladas.

Vamos utilizar un proyecto de ejemplo con Hibernate para ver cómo se distribuirian los distintos ficheros una vez creados y compilados. En la siguiente imagen vemos como se distribuyen las clases en nuestro proyecto.

En la parte de carpetas fuentes vemos que tenemos un paquete donde guardamos las entidades, los daos, otro para los servicios, … . Para los test nos hemos creado un paquete que contiene una clases que prueba uno de nuestros daos. En la carpeta de recursos podemos ver los ficheros de configuración para Hibernate.

Una vez compilado nuestro proyecto (y ejecutados nuestros test). Podemos ver que se ha creado nuevas carpetas dentro del directorio target de nuestro proyecto. En la carpetas classes se generarán las clases compiladas (en la segunda imagen adjunta podemos ver la carpeta classes creada). También podemos ver como se nos crea un test-classes donde está la clase de nuestro test. Hay otra serie de carpetas como surefire-reports. Surefire es un plugin de Maven que entre otras cosas genera reportes de nuestro proyecto. Por último podemos ver como se ha generado un jar de nuestro proyecto.

hop-e105bb50cb:Hibernate hop$ cd target/classes/
hop-e105bb50cb:classes hop$ ls -lah
total 16
drwxr-xr-x  6 hop  staff   204B 28 abr 23:03 .
drwxr-xr-x  9 hop  staff   306B 28 abr 23:03 ..
drwxr-xr-x  3 hop  staff   102B 28 abr 23:03 META-INF
drwxr-xr-x  3 hop  staff   102B 28 abr 23:03 com
-rw-r--r--  1 hop  staff   922B 28 abr 23:03 hibernate-jpa.cfg.xml
-rw-r--r--  1 hop  staff   842B 28 abr 23:03 hibernate.cfg.xml
hop-e105bb50cb:classes hop$ cd com/hibernate/
daos/         entities/     otros/        servicesImpl/