Proyecto Maven EAR

De ChuWiki
Saltar a: navegación, buscar

Veamos un ejemplo sencillo de un proyecto maven para generar un ficheor ear que tenga un módulo ejb que a su vez depende de librerías java normales. Puedes ver la estructura del proyecto completa en EAR_Project

Tres proyectos

Para generar todo esto necesitamos estrictamente dos proyectos maven:

  • Un proyecto maven con nuestro código, que sea capaz de generar un jar/war con nuestros EJBs. Este proyecto tendrá dependencias de librerías java normales, que para nuestro ejemplo pondremos la primera que se nos ocurra, como apache-commons-coded.jar. Llamaremos a este proyecto ejb-module.
  • Un proyecto maven que generará el fichero ear para desplegar en nuestro servidor de aplicaciones. Este fichero ear tendrá dentro el jar con nuestra aplicación (el ejb-module) y los jar de las distintas librerías de las que depende (apache-commons-codec.jar en nuestro ejemplo). Llamaremos a este proyecto ear-module.

Sin embargo, para facilitar el proceso de compilado, meteremos estos dos proyectos maven como proyectos hijo de un proyecto maven padre, al que llamaremos ear-project-example. De esta forma, compilando el proyecto maven padre, se compilarán los dos proyectos hijos, primero nuestra aplicación ejb-module, y luego el ear-module que genererá el ear con todo.

El ejb-module

El pom.xml de nuestro proyecto ejb-module (nuestra aplicación), puede ser como el 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>
	<parent>
		<groupId>com.chuidiang.examples</groupId>
		<artifactId>ear-project-example</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<artifactId>ejb-module</artifactId>
	<packaging>ejb</packaging>

	<dependencies>
		<dependency>
			<groupId>org.jboss.spec</groupId>
			<artifactId>jboss-javaee-6.0</artifactId>
			<version>3.0.3.Final</version>
			<type>pom</type>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>1.10</version>
			<scope>compile</scope>
		</dependency>

	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-ejb-plugin</artifactId>
				<version>2.5.1</version>
				<configuration>
					<ejbVersion>3.1</ejbVersion>
					<archive>
						<manifest>
							<addClasspath>true</addClasspath>
							<classpathPrefix>lib/</classpathPrefix>
						</manifest>
					</archive>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<properties>
		<maven.compiler.target>1.7</maven.compiler.target>
		<maven.compiler.source>1.7</maven.compiler.source>
	</properties>
</project>

Puesto que vamos a generar un jar que es un módulo de EJBs, el packaging será <packaging>ejb</packaging> y necesitamos añadir el <artifactId>maven-ejb-plugin</artifactId>

En el plugin maven-ejb-plugin configuramos el fichero de manifiesto para que incluya el Class-Path y que buque las librerías en el subdirectorio lib <classpathPrefix>lib/</classpathPrefix>

Hemos puesto dos dependencias.

  • Una de jboss-javaee-6.0 con scope provided. De esta forma, nuestro proyecto maven tendrá disponibles todas las librerías de JEE que proporcione jboss-javaee-6.0, pero no las incluirá en el Class-Path al ser provided. Nuestro contenedor jboss (o el que sea) nos las proporcionrá directamente sin necesidad de incluirlas en ningún sitio. Fíjate que se ha puesto <type>pom</type>, puesto que la dependencia que nos proporciona jboss es de tipo pom. Es una práctica habitual generar una dependencia de tipo pom para traer de un solo golpe varios jar, sin necesidad de ir poniéndolos uno a uno.
  • La otra dependencia es una librería nomral, apache-commons-codec. Esta tiene scope compile para que sí sea incluida en el Class-Path y luego dentro del ear.

Nada más respecto a este proyecto ejb-module. Si lo compilamos con maven generará un jar y dentro de él un fichero META-INF/MANFIFEST.MF que debería tener una línea así

Class-Path:lib/apache-comoons-codec-1.10.jar

El ear-module

El proyecto ear-module es el encargado de generar el fichero ear. Aquí no hay código ni se compila nada. El pom.xml puede ser como este

<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>
	<parent>
		<groupId>com.chuidiang.examples</groupId>
		<artifactId>ear-project-example</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<artifactId>ear-module</artifactId>
	<packaging>ear</packaging>

	<dependencies>
		<dependency>
			<groupId>com.chuidiang.examples</groupId>
			<artifactId>ejb-module</artifactId>
			<version>0.0.1-SNAPSHOT</version>
			<type>ejb</type>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-ear-plugin</artifactId>
				<version>2.10.1</version>
				<configuration>
					<defaultLibBundleDir>lib</defaultLibBundleDir>
					<modules>
						<ejbModule>
							<groupId>com.chuidiang.examples</groupId>
							<artifactId>ejb-module</artifactId>
						</ejbModule>
					</modules>

				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

Como vamos a generar un ear, nuestro packaging es ear y debemos añadir el maven-ear-plugin.

En la configuración de maven-ear-plugin, indicamos que queremos las librerías (los jar normales) dentro del directorio lib con <defaultLibBundleDir>lib</defaultLibBundleDir>.

Indicamos también cual el módulo de nuestra aplicación. Como era un jar de EJBs, lo ponemos como módulo <ejbModule> y sólo tenemos que indicar el groupId y el artifactId. En las dependencias debemos añadir dependencia de nuestro móudlo ejb-module. Ahí sí debemos añadir la versión y es importante añadir el <type>ejb</type>, para indicar que es un jar de EJBs.

Y ya está, no necesitamos nada más. El comando mvn package (o mvn install) generará en el directorio target el fichero ear con todo dentro. Ojo, para poder hacer esto, es necesario compilar ( mvn install ) previamente el ejb-module.

El proyecto padre

Para tener que evitar dos comandos, un mvn install para ejb-module y luego un mvn package (o mvn install) para generar el ear, hemos metido estos proyectos debajo de un proyecto maven padre, cuyo fichero pom.xml es el 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.chuidiang.examples</groupId>
  <artifactId>ear-project-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <modules>
  	<module>ejb-module</module>
  	<module>ear-module</module>
  </modules>
</project>

Para indicar que es un proyecto maven padre de otros, su packaging es pom. Y para indicar de qué proyectos es padre, se ponen tags <module> indicando los nombres de los subdirectorios en los que están los proyectos hijos.

Fíjate en los pom.xml de los proyectos hijo que se les ha puesto <parent>, con el groupId, artifactId y version de este proyecto padre.

Con esto, simplemente un mvn package en el proyecto padre compilará primero ejb-module, y luego ear-module. En el subdirectorio ear-module/target aparecerá el fichero ear con todo lo necesario para ser desplegado.

El ear por dentro

Con todo esto, el ear debería quedar de la siguiente forma

+-META-INF
|   +-MANIFEST.MF
|   +-application.xml
|
+-lib
|   +-apache-commons-code-1.10.jar
|
+-ejb-module-0.0.1-SNAPSHOT.jar