Archive

Posts Tagged ‘maven’

Aplicación multi-modulo “Hola Mundo” con Maven

November 1st, 2009
5 comments

Acá muestro un ejemplo de una aplicación multi-modulo usando maven.

El ejemplo esta basado en este articulo: Chapter 7. Multi-module Enterprise Project

Descripción

Básicamente este ejemplo es solo una aplicación que muestra un el texto “Hola Mundo”.

Esta aplicación esta compuesta por dos módulos: ‘my-webapp’, que define una sevlet que imprime un mensaje y ‘my-module’ que contiene un servicio que devuelve el mensaje que imprime la servlet.

Esta es la estructura de directorios y archivos:

multiapp/
¦   pom.xml
+---my-module
¦   ¦   pom.xml
¦   +---src
¦       +---main
¦           +---java
¦                   HelloWorldService.java
+---my-webapp
    ¦   my-webapp.iml
    ¦   pom.xml
    +---src
        +---main
            +---java
            ¦       HelloWorldServlet.java
            +---webapp
                ¦   index.jsp
                +---WEB-INF
                        web.xml

Archivos pom.xml

pom.xml principal
?View Code XML
<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>edu.renan</groupId>
    <artifactId>multiapp</artifactId>
    <packaging>pom</packaging>
    <version>1.0</version>
    <name>Test Modules App</name>
    <modules>
        <module>my-module</module>
        <module>my-webapp</module>
    </modules>
    <dependencies>
        <dependency>
            <groupId>net.sourceforge.openutils</groupId>
            <artifactId>openutils-testing-testng</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>multiapp</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

La parte importante en el pom.xml principal es que se definen los módulos: my-webapp y my-module dentro de la etiqueta <modules>

También hay que tomar en cuenta que el packaging es definido como ‘pom’

pom.xml - my-module
?View Code XML
<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/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>edu.renan</groupId>
		<artifactId>testmodules</artifactId>
		<version>1.0</version>
	</parent>
	<artifactId>my-module</artifactId>
	<packaging>jar</packaging>
	<name>my-module</name>
</project>

Acá estamos definiendo cual sera el modulo padre usando la etiqueta ≷parent> y el packaging como ‘jar’. Utilice jar por que este modulo generara un jar file.

pom.xml - my-webapp
?View Code XML
<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>edu.renan</groupId>
        <artifactId>testmodules</artifactId>
        <version>1.0</version>
    </parent>
    <artifactId>my-webapp</artifactId>
    <packaging>war</packaging>
    <version>1.0</version>
    <name>my-webapp</name>
    <dependencies>
        <dependency>
            <groupId>servletapi</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.4</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>edu.renan</groupId>
            <artifactId>my-module</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>mywebapp</finalName>
    </build>
</project>

Acá definimos un parent lo mismo que el anterior, pero para el packaging usamos ‘war’, por que este modulo generara una aplicación web.

Classes java y web.xml

HelloWorldService
?View Code JAVA
public class HelloWorldService {
    public String sayHello(){
        return "Hola Mundo";
    }
}

Como verán es solo una clase con un método con un método que retorna el mensaje “Hola Mundo”.

HelloWorldServlet
?View Code JAVA
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
 
public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HelloWorldService helloWorldService = new HelloWorldService();
        response.getWriter().println(helloWorldService.sayHello());
    }
}

Esta servlet solo llama al servicio definido anteriormente.

web.xml
?View Code XML
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
     version="2.4">
 
    <display-name>My Web App</display-name>
    <servlet>
        <servlet-name>helloWorldServlet</servlet-name>
        <servlet-class>HelloWorldServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>helloWorldServlet</servlet-name>
        <url-pattern>/helloWorld</url-pattern>
    </servlet-mapping>
 
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Espero este ejemplo les sirva mucho, si quieren mas recursos acá tienen algunos que encontré:

El código fuente lo pueden encontrar aquí.

Renan Huanca maven

Ejemplo TestNG

October 31st, 2009
No comments

Hola amigos,

Acá comparto un ejemplo simple de como usar el TestNG.

El ejemplo se basa en una clases para realizar la operación suma.

Clase a Testear

?View Code JAVA
public class Calc {
    public int add(int a, int b){
        return a + b;
    }
}

Clase de Testeo

?View Code JAVA
import org.testng.annotations.Test;
 
@Test
public class CalcTest {
    public void sumarTest(){
        Calc calc = new Calc();
        assert 2 == calc.add(1,1);
    }
}

Archivo pom.xml

?View Code XML
    ...
    <dependencies>
        <dependency>
            <groupId>net.sourceforge.openutils</groupId>
            <artifactId>openutils-testing-testng</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>
    ...
    <build>
        <finalName>test</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

Para usar las anotaciones es necesario utilizar java 1.5+

Renan Huanca TestNG ,

Como configurar una aplicacion basica Spring 2.5 con Maven 2

February 28th, 2009
No comments

Hola java adictos,

Esta vez mostrare como crear una aplicación Spring con Maven :)

Descripción del Ejemplo

Se creara una aplicación que simplemente mostrar “Hello World with Spring :) “. El mensaje sera obtenido de un bean llamado Greeting.

Vamos asumir que ya tienen instalado maven2, y java :), no sera necesario que bajen Spring ya que el mismo maven lo hara por ustedes.

A grandes rasgos, los pasos serán los siguientes:

  • Crear aplicación base con maven.
  • Editar pom.xml para adicionar dependencia base de Spring.
  • Crear el bean Greeting.
  • Crear archivo de contexto de aplicación de Spring.
  • Modificar clase App y para probar funcionalidad.

Crear aplicación base con maven

Para esto vamos a hechar mano del comando mvn archetype:create. Nos posicionaremos en el folder donde deseemos trabajar y ejecutamos el siguiente comando:

mvn archetype:create -DgroupId=com.sumasoftware.hellospring -DartifactId=HelloSpring

Con la ejecución del anterior comando se creara un folder llamado HelloSpring

con la respectiva estructura de directorios de maven.

(Justo vi un post en otro blog sobre este aspecto, asi que pueden verlo para mas detalles)

Editar pom.xml para adicionar dependencia base de Spring

Ingresamos al folder llamado HelloSpring y editamos el archivo con cualquier editor a disposición.

Sera algo parecido a esto:

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sumasoftware.hellospring</groupId>
    <artifactId>HelloSpring</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>HelloSpring</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Dentro del tag <dependencies> adicionamos:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
</dependency>

Como verán solo vamos a utilizar el core de spring, osea la base. Esto es suficiente para lo que necesitamos ahora. Por supuesto para una aplicación mas compleja necesitaríamos adicionar mas dependencias (ej.: spring-context, spring-tx, spring-web, etc…)

Crear el bean Greeting

Ok. ahora vamos al código. por fin!:) pero es algo fácil. Vamos a crear el siguiente bean Greeting en el folder HelloSpring/src/main/java/com/sumasoftware/hellospring. (Ojo, que com/sumasoftware/hellospring es el paquete de la clase :))

package com.sumasoftware.hellospring;
public class Greeting {
    public void sayHello(){
        System.out.println("Hello World with Spring :)");
    }
}

Ahora ejecutamos en la consola el comando:

mvn package

Con esto se verifica que no hay errores de sintaxis y se aprovecha de bajar las dependencias.

Crear archivo de contexto de aplicacion de Spring

Ahora vamos con spring, eeeh!!! :). Para esto vamos a crear el archivo appContext.xml dentro de un folder nuevo llamado resources que estara dentro de HelloSpring/src/main. Entonces el path del archivo sera HelloSpring/src/main/resources/appContext.xml.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="greeting" class="com.sumasoftware.hellospring.Greeting"/>
</beans>

Modificar clase App y para probar funcionalidad

Por defecto, cuando maven crea una aplicacion, crea la clase App que solo tiene un Hello World vamos a modificar la clase, para que cargue el contexto de spring, obtenga el bean y llame al metodo sayHello().

package com.sumasoftware.hellospring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("classpath:appContext.xml");
        Greeting greeting = (Greeting) context.getBean("greeting");
        greeting.sayHello();
    }
}

Mas referencia acerca de como crear o instanciar el factory lo encuentra en la documentación de Spring

Listo ya terminamos, ahora como lo ejecutamos :)? bueno yo lo hice con idea. justo maven tiene un otro plugin que se llama idea que te ayuda a crear el archivo de projecto configurado con las dependencias. Solo se tiene que escribir en la linea de comando mvn idea:idea, maven crea el archivo de proyecto, abrimos el proyecto configuramos la clase main y listo. (Lo mismo hay para eclipse)

Claro te también se puede ejecutar desde linea de comando. Solo que es mas trabajoso, ustedes elijan el que mas les guste.

Una vez ejecutada la clase App, esta despliega en consola lo siguiente:

Feb 28, 2009 1:19:19 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32fb4f: display name [org.springframework.context.support.ClassPathXmlApplicationContext@32fb4f]; startup date [Sat Feb 28 01:19:19 BOT 2009]; root of context hierarchy
Feb 28, 2009 1:19:19 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [appContext.xml]
Feb 28, 2009 1:19:19 AM org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
INFO: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@32fb4f]: org.springframework.beans.factory.support.DefaultListableBeanFactory@16a786
Feb 28, 2009 1:19:19 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@16a786: defining beans [greeting]; root of factory hierarchy
Hello World with Spring :)

Espero este tutorial sirva de mucha ayuda. Acá esta el código fuente. Comentarios son bien recibidos.

Hasta la proxima ;)

Renan Huanca Spring, maven ,