Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ecabrerar/barcampsti2013-maven
Ejemplos básico de Maven para la charla realizada en el BarCamp STI 2013
https://github.com/ecabrerar/barcampsti2013-maven
proyecto-maven proyecto-web
Last synced: about 1 month ago
JSON representation
Ejemplos básico de Maven para la charla realizada en el BarCamp STI 2013
- Host: GitHub
- URL: https://github.com/ecabrerar/barcampsti2013-maven
- Owner: ecabrerar
- Created: 2013-11-06T03:51:39.000Z (about 11 years ago)
- Default Branch: master
- Last Pushed: 2023-12-05T22:07:35.000Z (about 1 year ago)
- Last Synced: 2024-04-16T07:54:25.485Z (8 months ago)
- Topics: proyecto-maven, proyecto-web
- Language: Java
- Homepage:
- Size: 51.8 KB
- Stars: 2
- Watchers: 3
- Forks: 2
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
## BarCampSTI 2013
Pagina Oficial:
http://barcamp.org.do
Ejemplos básicos de maven con motivo de mi charla [Primeros Pasos con Maven](http://www.slideshare.net/eudris/primeros-pasos-con-maven) impartida en el BarCamp STI 2013
#### Requisitos:
Para mejor entendiemiento es recomendable conocimientos básicos de Java
#### Requerimientos
* Java 1.7+
### Instalar Maven
* Descargar y descomprimir instalador desde http://maven.apache.org/download.html
* Asegúrese de que la variable de entorno JAVA_HOME está en apuntando al directorio del JDK
* Añadir a la variable de entorno PATH
Ejemplo:
#### Linux
```bash
export MAVEN_HOME=~/apache-maven-3.1.0
export PATH=$PATH:$MAVEN_HOME/bin
```
#### Windows
```bash
set M2_HOME=:\Program Files\apache-maven-3.1.0
set PATH=%PATH%;%M2_HOME%\bin
```
### Comprobar instalación
Desde la línea de comandos
Escribir `mvn -version` y debe obtener como resultado la versión instalada y la ruta de la variable de entorno `MAVEN_HOME`
### Ejercicio I: Crear un proyecto maven simple
Desde la línea de comando crear un proyecto maven simple usando el artefacto `maven-archetype-quickstart`
Ejecutar comando :
```bash
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart
```
* Llenar información requerida para el proyecto maven
Ejemplo
groupId: org.ecabrerar.barcampsti
artifactId: simple-project (nombre del proyecto)
version: dejar version por defecto
package: org.ecabrerar.barcampsti.
### Ejercicio II : Personalizar un proyecto maven
#### Parte I:
Desde la línea de comando crear un proyecto maven simple usando el siguiente comando
```bash
mvn archetype:generate -DgroupId=org.ecabrerar.barcampsti \
-DartifactId=simple-custom-project \
-Dpackage=org.ecabrerar.barcampsti.examples \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DinteractiveMode=false \
-Dversion=1.0
```
#### Parte II:
Modificar el archivo pom.xml y agregar configuración del compilador
```xml
org.apache.maven.plugins
maven-compiler-plugin
2.3.2
1.7
1.7
```
Personalizar información del proyecto
```xml
Apache 2
http://www.apache.org/licenses/LICENSE-2.0.txt
repo
A business-friendly OSS license
```
Agregar información de la institución
```xml
Barcamp STI
http://www.barcamp.org.do
```
Agregar información del equipo de trabajo
```xml
ecabrerar
Eudris Cabrera
[email protected]
https://github.com/ecabrerar
Barcamp STI
http://www.barcamp.org.do
developer
-4
```
Agregar información sobre el control de versiones
```xml
scm:git:[email protected]:BarcampSTI/BarCampSTI2013-Maven.git
scm:git:[email protected]:BarcampSTI/BarCampSTI2013-Maven.git
scm:git:[email protected]:BarcampSTI/BarCampSTI2013-Maven.git
```
Modificar el archivo pom.xml y agregar información sobre la distribucion
```xml
releases
Eudris Cabrera Release Repository
https://repository-ecabrerar.forge.cloudbees.com/release/
snapshots
Eudris Cabrera Snapshots Repository
https://repository-ecabrerar.forge.cloudbees.com/snapshot/
```
#### Parte III: Correr un ejemplo simple java usando Maven
Al crear nuestro proyecto maven se crea un paquete por defecto para el código fuente (debajo de `src/main/java`) y otro paquete para las pruebas unitarias( debajo de `src/test/java`).
Por lo regular el paquete creado en `src/main/java` y en `src/test/java` se llaman iguales, en nuestro caso `org.ecabrerar.barcampsti.examples`.
Dentro de cada paquete se crea una clase java simple `App.java` y `AppTest.java` en el paquete para las pruebas unitarias.
```java
package org.ecabrerar.barcampsti.examples;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
}
```
Para correr este ejemplo simple ejecutamos los siguientes comandos en la lína de comandos.
```bash
mvn install
mvn exec:java -Dexec.mainClass=org.ecabrerar.barcampsti.examples.App
```
#### Parte IV: Generar documentación del proyecto en formato html
Desde la línea de comandos ejecutar `mvn site` en el directorio donde se encuentra el archivo `pom.xml` para generar
un sitio `html` con toda la información de nuestro proyecto.
Ir al directorio `target/site` para comprobar que se haya generado la documentación y abrir el archivo `index.hml` con nuestro navegador
### Ejercicio III : Crear una aplicación web simple
#### Parte I
Desde la línea de comando crear un proyecto maven web simple usando el artefacto `maven-archetype-webapp`
Ejecutar comando :
```bash
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp
```
Llenar información requerida para el proyecto maven
Ejemplo:
groupId: org.ecabrerar.barcampsti
artifactId: webapp-simple-project (nombre del proyecto)
version: dejar version por defecto
package: org.ecabrerar.barcampsti.examples
#### Parte II
Modificar el archivo `pom.xml` y agregar el plugin para el servidor jetty (http://www.eclipse.org/jetty)
```xml
org.mortbay.jetty
jetty-maven-plugin
8.0.0.M3
10
/
10
STOP
8005
8080
```
#### Parte III
Compilar y empaquetar los archivos compilados.
mvn clean compile package
Lanzar aplicacion
mvn jetty:run
### Ejercicio IV : Crear un proyecto multi-módulo
Un proyecto de varios módulos (multi-modulo) se define por un POM padre haciendo referencia
a uno o más submódulos(proyectos descendientesdel padre).
Para crear nuestro proyecto padre ejecutamos el siguiente comando:
```bash
mvn archetype:generate -DarchetypeGroupId=org.codehaus.mojo.archetypes -DarchetypeArtifactId=pom-root -D archetypeVersion=RELEASE
```
Dentro del proyecto padre, podemos ejecutar los comandos para crear los sub-módulos.
El comando ejecutado dependerá del tipo de proyecto que queremos crear.
Por ejemplo:
Crear un proyecto web
```bash
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp
```
Una librería, un proyecto web service, etc
```bash
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart
```
Para nuestra demostración vamos a crear un proyecto multi-módulo que combina los ejercicios II y III.
El ejercicio II, un proyecto Java simple y el ejercicio III, un proyecto web simple.
#### Paso I: Crear Proyecto Padre (POM padre)
Ejecutar en la línea de comando:
```bash
mvn archetype:generate -DarchetypeGroupId=org.codehaus.mojo.archetypes -DarchetypeArtifactId=pom-root -D archetypeVersion=RELEASE
```
Información general del proyecto
groupId: org.ecabrerar.barcampsti
artifactId: multi-module-project (nombre del proyecto)
version: dejar version por defecto
package: dejar paquete por defecto
POM padre
```xml
4.0.0
org.ecabrerar.barcampsti
multi-module-project
1.0-SNAPSHOT
pom
multi-module-project
```
Al igual que los proyectos maven anteriores, el POM padre posee la misma estructura de groupId, artifactId, version, etc..
La diferencia con otros tipos de proyectos está en la coordenada `packaging`, en lugar de tener un formato de archivo (jar, war,ear, etc.) como vimos anteriormente,
el valor para este tipo de proyecto es `pom`.
#### Paso II: Definir sub-modulos.
Anteriormente creamos los ejercicios II y III, en esta oportunidad no vamos a volver a crearlos, vamos a copiar ambos proyectos dentro del proyecto multi-modulo.
Si deseas crearlos desde cero, recuerde ejecutar los comandos para crear los sub-módulos dentro del proyecto padre.
Para el ejercicio II
```bash
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart
```
Para el Ejercicio III
```bash
mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp
```
Estructura del proyecto multi-modulo
multi-module-project
simple-custom-project
webapp-simple-project
pom.xml
#### Paso III: Agregar dependencias
Modificar el archivo `pom.xml` del proyecto padre y agregar los dos sub-módulos
```xml
simple-custom-project
webapp-simple-project
```
Modificar el archivo `pom.xml` de cada sub-módulo para:
Remover la siguiente coordenada
org.ecabrerar.barcampsti
Luego agregar la referencia del proyecto padre
```xml
org.ecabrerar.barcampsti
multi-module-project
1.0-SNAPSHOT
```
Luego de hacer las modificaciones anteriores podemos compilar el proyecto para comprobar que las modificaciones se realizaron de la forma correcta.
```bash
mvn clean install
```
En su resultado final debe aparecer una salida similar a la siguiente
```bash
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] multi-module-project .............................. SUCCESS [5.300s]
[INFO] simple-custom-project ............................. SUCCESS [25.091s]
[INFO] webapp-simple-project Maven Webapp ................ SUCCESS [8.364s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 39.732s
[INFO] Finished at: Tue Dec 10 18:35:06 EST 2013
[INFO] Final Memory: 16M/183M
[INFO] ------------------------------------------------------------------------
```
Ahora podemos correr cada módulo de forma independiente.
Desde el directorio raíz ir al proyecto correspondiente al ejercicio II
```bash
cd simple-custom-project
mvn install
mvn exec:java -Dexec.mainClass=org.ecabrerar.barcampsti.examples.App
```
Desde el directorio raíz ir al proyecto correspondiente al ejercicio III
```bash
cd webapp-simple-project
mvn clean compile package
mvn jetty:run
```
Hasta este punto, tenemos un proyecto multi-módulo simple con pocas funcionalidades, la idea principal es mostrar las características de Maven para proyectos de este tipo.
Todavía nos falta re-estructurar los poms para eliminar las duplicaciones de dependencias.
#### Paso IV: Re-estructurar POMs.
* Mover dependencias al POM padre.
* Eliminar las duplicadas.
* Mover otras informaciones relevantes(tipo de licencia, control de versiones, etc) al pom padre.
### Ejercicio V : Correr pruebas unitarias con Maven
El proyecto `simple-test-project` es un ejemplo básico de jUnit.
La idea es poder leer las actualizaciones del portal del ministerio de industrica y comercio sobre los combustibles.
Para esto leemos los feeds del rss http://www.seic.gov.do/rss/combustibles.aspx y los parseamos usando la librería jdom.
```java
package org.ecabrerar.barcampsti.combustible.mic;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CombustibleParser {
Logger logger = LoggerFactory.getLogger(CombustibleParser.class);
public Combustible parse(InputStream inputStream) throws Exception {
Combustible combustible = new Combustible();
logger.debug("Creating XML Reader");
SAXReader xmlReader = createXmlReader();
Document doc = xmlReader.read(inputStream );
logger.info( "Parsing XML Response" );
combustible.setGasolinaPremium(doc.valueOf("/rss/channel/item/gas95"));
combustible.setGasolinaRegular(doc.valueOf("/rss/channel/item/gas89"));
combustible.setGasoilPremium(doc.valueOf("/rss/channel/item/gasoilp"));
combustible.setGasoilRegular(doc.valueOf("/rss/channel/item/gasoilr"));
combustible.setGlp(doc.valueOf("/rss/channel/item/glp"));
combustible.setGnv(doc.valueOf("/rss/channel/item/gnv"));
combustible.setKerosene(doc.valueOf("/rss/channel/item/kerosene"));
return combustible;
}
private SAXReader createXmlReader() {
Map uris = new HashMap();
uris.put( "y", "http://www.seic.gov.do/rss/combustibles.aspx" );
DocumentFactory factory = new DocumentFactory();
factory.setXPathNamespaceURIs( uris );
SAXReader xmlReader = new SAXReader();
xmlReader.setDocumentFactory( factory );
return xmlReader;
}
}
```
Se crearon varias pruebas usando jUnit para validar que el archivo se está parseando correctamente.
```java
package org.ecabrerar.barcampsti.combustible.mic;
import java.io.InputStream;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest extends TestCase
{
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName )
{
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite()
{
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
* @throws Exception
*/
public void testApp() throws Exception
{
InputStream nyData =
getClass().getClassLoader().getResourceAsStream("combustible.xml");
Combustible comb = new CombustibleParser().parse( nyData );
assertEquals( "247.40", comb.getGasolinaPremium() );
assertEquals( "232.80", comb.getGasolinaRegular() );
assertEquals( "219.70", comb.getGasoilPremium() );
assertEquals( "213.00", comb.getGasoilRegular() );
assertEquals( "194.20", comb.getKerosene() );
assertEquals( "108.50", comb.getGlp() );
assertEquals( "30.50", comb.getGnv() );
}
}
```
Para realizar la prueba ejecutamos los siguientes comandos:
```bash
cd simple-test-project
mvn test
```
#### Author
* [Eudris Cabrera](https://github.com/ecabrerar)
* [](https://coderwall.com/ecabrerar)
[](https://bitdeli.com/free "Bitdeli Badge")