Dos Ideas. - Contribuciones del usuario [es]

Metricas Agiles

2011-10-06T12:26:21Z

201.251.185.130: /* ¿ Cómo obtener la información necesaria para el tablero ? */

Hay distintas métricas en los proyectos de desarrollo:

* de productividad y resultados del proyecto
* de situación financiera
* de riesgos
* de calidad

== Productividad y resultados del proyecto ==

Muchos de los problemas detectados y disfuncionalidades de la organización seguramente existen desde antes de utilizar una gestión ágil de proyectos como [[Scrum]]. Esos problemas no son el resultado de aplicar las métricas sino que por el contrario nos aporta:

* transparencia a los resultados del proyecto
* ayuda a priorizar el trabajo
* permite tomar decisiones entre las personas involucradas al proyecto

==== ¿ Cuáles son las métricas que elegimos para medir productividad en nuestros proyectos ? ====

* requisitos completados respecto al total de requisitos
* valor que le dan al cliente los requisitos completados
* la velocidad con qué se aporta valor al negocio
* cambios y requisitos añadidos

==== ¿ Qué hacer con estas métricas ? ====

Estamos en condiciones de generar un tablero o cuadro de control de nuestro proyecto para que todos los involucrados estén informados y puedan tomar decisiones de su rol.

El equipo de desarrollo podrá evaluar su propia velocidad, planificar y tomar compromisos.

El cliente podrá replantear las prioridades que está eligiendo para sus requerimientos, y así con cada persona involucrada.

Esta info a lo largo del tiempo muestra tendencias.

==== ¿ Cómo obtener la información necesaria para el tablero ? ====

Esta info surge de las herramientas de [[Scrum]]: backlog priorizado, burn down, burn up. Y un buen momento para actualizar el tablero es al finalizar cada iteración. Es conveniente compartir puntos destacados del proyecto, riesgos y próximos pasos en el mismo tablero.

==== ¿ Cuál es la métrica más importante en un proyecto ágil ? ====

El valor de negocio que se le está dando al cliente.

En ocasiones escuchamos hablar de ROI o Retorno de Inversión. ROI es una fórmula financiera tal que ROI = (ingreso - costo)/costo. Por ejemplo, podemos decir que si un producto genera un ingreso anual de 2500 $ y el costo anual de mantener ese producto es de 1000 $ entonces ese negocio nos deja un 50 % de ganancia anual sobre la inversión generada.

Podemos no conocer la rentabilidad específica de un producto que desarrollamos y si podemos asumir que alguien analizó que ese producto genera una rentabilidad positiva para la compañia.

Entonces, podemos trabajar junto al dueño de producto para orientarnos a que obtenga su máximo valor de negocio lo antes posible.

==== ¿ Por qué es importante considerar el valor de negocio ? ====

El cliente puede conocer la velocidad con que retorna su inversión y cuando ya no es necesario seguir con el proyecto por que lo que resta hacer tiene un retorno que no compensa el costo.

[[Archivo:Contrato-agil-change-for-free.gif]]

Algunos consejos para el ROI:

* usar un valor tangible para medir el retorno: dinero, personas, tiempo
* no tomar requisitos tan pequeños si el usuario no se siente representado

== Ejemplo de tablero de productividad y resultados del proyecto ==

[[Archivo:TableroDelProyecto.jpg]]

==Ver también==

* [http://www.proyectosagiles.org/metricas-agiles-cuadro-mandos-balanceado-scrum Métricas ágiles y cuadro de mandos integral para Scrum]
* [http://www.proyectosagiles.org/contrato-agil-scrum Un contrato ágil para Scrum]
* [http://www.proyectosagiles.org/priorizacion-requisitos-valor-coste Priorización de los requisitos por valor y coste]
* [[Historia de usuario]]
* [[Backlog Del Producto]]
* [[Gráfico de Burn-Down]]
* [[Gráfico de Burn-Up]]
* [[Velocidad Trabajo Tiempo]]
* [[Hudson]]

[[Category:Scrum]]
[[Category: Métricas]]

Metricas Agiles

2011-10-06T12:25:52Z

201.251.185.130: /* ¿ Cómo obtener la información necesaria para el tablero ? */

Hay distintas métricas en los proyectos de desarrollo:

* de productividad y resultados del proyecto
* de situación financiera
* de riesgos
* de calidad

== Productividad y resultados del proyecto ==

Muchos de los problemas detectados y disfuncionalidades de la organización seguramente existen desde antes de utilizar una gestión ágil de proyectos como [[Scrum]]. Esos problemas no son el resultado de aplicar las métricas sino que por el contrario nos aporta:

* transparencia a los resultados del proyecto
* ayuda a priorizar el trabajo
* permite tomar decisiones entre las personas involucradas al proyecto

==== ¿ Cuáles son las métricas que elegimos para medir productividad en nuestros proyectos ? ====

* requisitos completados respecto al total de requisitos
* valor que le dan al cliente los requisitos completados
* la velocidad con qué se aporta valor al negocio
* cambios y requisitos añadidos

==== ¿ Qué hacer con estas métricas ? ====

Estamos en condiciones de generar un tablero o cuadro de control de nuestro proyecto para que todos los involucrados estén informados y puedan tomar decisiones de su rol.

El equipo de desarrollo podrá evaluar su propia velocidad, planificar y tomar compromisos.

El cliente podrá replantear las prioridades que está eligiendo para sus requerimientos, y así con cada persona involucrada.

Esta info a lo largo del tiempo muestra tendencias.

==== ¿ Cómo obtener la información necesaria para el tablero ? ====

Esta info surge de las herramientas de [[Scrum]]: backlog priorizado, burn down, burn up. Y el momento para actualizar el tablero es al finalizar cada iteración. Es conveniente compartir puntos destacados del proyecto, riesgos y próximos pasos en el mismo tablero.

==== ¿ Cuál es la métrica más importante en un proyecto ágil ? ====

El valor de negocio que se le está dando al cliente.

En ocasiones escuchamos hablar de ROI o Retorno de Inversión. ROI es una fórmula financiera tal que ROI = (ingreso - costo)/costo. Por ejemplo, podemos decir que si un producto genera un ingreso anual de 2500 $ y el costo anual de mantener ese producto es de 1000 $ entonces ese negocio nos deja un 50 % de ganancia anual sobre la inversión generada.

Podemos no conocer la rentabilidad específica de un producto que desarrollamos y si podemos asumir que alguien analizó que ese producto genera una rentabilidad positiva para la compañia.

Entonces, podemos trabajar junto al dueño de producto para orientarnos a que obtenga su máximo valor de negocio lo antes posible.

==== ¿ Por qué es importante considerar el valor de negocio ? ====

El cliente puede conocer la velocidad con que retorna su inversión y cuando ya no es necesario seguir con el proyecto por que lo que resta hacer tiene un retorno que no compensa el costo.

[[Archivo:Contrato-agil-change-for-free.gif]]

Algunos consejos para el ROI:

* usar un valor tangible para medir el retorno: dinero, personas, tiempo
* no tomar requisitos tan pequeños si el usuario no se siente representado

== Ejemplo de tablero de productividad y resultados del proyecto ==

[[Archivo:TableroDelProyecto.jpg]]

==Ver también==

* [http://www.proyectosagiles.org/metricas-agiles-cuadro-mandos-balanceado-scrum Métricas ágiles y cuadro de mandos integral para Scrum]
* [http://www.proyectosagiles.org/contrato-agil-scrum Un contrato ágil para Scrum]
* [http://www.proyectosagiles.org/priorizacion-requisitos-valor-coste Priorización de los requisitos por valor y coste]
* [[Historia de usuario]]
* [[Backlog Del Producto]]
* [[Gráfico de Burn-Down]]
* [[Gráfico de Burn-Up]]
* [[Velocidad Trabajo Tiempo]]
* [[Hudson]]

[[Category:Scrum]]
[[Category: Métricas]]

Metricas Agiles

2011-10-06T12:24:08Z

201.251.185.130: /* Productividad y resultados del proyecto */

Hay distintas métricas en los proyectos de desarrollo:

* de productividad y resultados del proyecto
* de situación financiera
* de riesgos
* de calidad

== Productividad y resultados del proyecto ==

Muchos de los problemas detectados y disfuncionalidades de la organización seguramente existen desde antes de utilizar una gestión ágil de proyectos como [[Scrum]]. Esos problemas no son el resultado de aplicar las métricas sino que por el contrario nos aporta:

* transparencia a los resultados del proyecto
* ayuda a priorizar el trabajo
* permite tomar decisiones entre las personas involucradas al proyecto

==== ¿ Cuáles son las métricas que elegimos para medir productividad en nuestros proyectos ? ====

* requisitos completados respecto al total de requisitos
* valor que le dan al cliente los requisitos completados
* la velocidad con qué se aporta valor al negocio
* cambios y requisitos añadidos

==== ¿ Qué hacer con estas métricas ? ====

Estamos en condiciones de generar un tablero o cuadro de control de nuestro proyecto para que todos los involucrados estén informados y puedan tomar decisiones de su rol.

El equipo de desarrollo podrá evaluar su propia velocidad, planificar y tomar compromisos.

El cliente podrá replantear las prioridades que está eligiendo para sus requerimientos, y así con cada persona involucrada.

Esta info a lo largo del tiempo muestra tendencias.

==== ¿ Cómo obtener la información necesaria para el tablero ? ====

Esta info surge de las herramientas de Scrum: backlog priorizado, burn down, burn up. Y el momento para actualizar el tablero es al finalizar cada iteración. Es conveniente compartir puntos destacados del proyecto, riesgos y próximos pasos en el mismo tablero.

==== ¿ Cuál es la métrica más importante en un proyecto ágil ? ====

El valor de negocio que se le está dando al cliente.

En ocasiones escuchamos hablar de ROI o Retorno de Inversión. ROI es una fórmula financiera tal que ROI = (ingreso - costo)/costo. Por ejemplo, podemos decir que si un producto genera un ingreso anual de 2500 $ y el costo anual de mantener ese producto es de 1000 $ entonces ese negocio nos deja un 50 % de ganancia anual sobre la inversión generada.

Podemos no conocer la rentabilidad específica de un producto que desarrollamos y si podemos asumir que alguien analizó que ese producto genera una rentabilidad positiva para la compañia.

Entonces, podemos trabajar junto al dueño de producto para orientarnos a que obtenga su máximo valor de negocio lo antes posible.

==== ¿ Por qué es importante considerar el valor de negocio ? ====

El cliente puede conocer la velocidad con que retorna su inversión y cuando ya no es necesario seguir con el proyecto por que lo que resta hacer tiene un retorno que no compensa el costo.

[[Archivo:Contrato-agil-change-for-free.gif]]

Algunos consejos para el ROI:

* usar un valor tangible para medir el retorno: dinero, personas, tiempo
* no tomar requisitos tan pequeños si el usuario no se siente representado

== Ejemplo de tablero de productividad y resultados del proyecto ==

[[Archivo:TableroDelProyecto.jpg]]

==Ver también==

* [http://www.proyectosagiles.org/metricas-agiles-cuadro-mandos-balanceado-scrum Métricas ágiles y cuadro de mandos integral para Scrum]
* [http://www.proyectosagiles.org/contrato-agil-scrum Un contrato ágil para Scrum]
* [http://www.proyectosagiles.org/priorizacion-requisitos-valor-coste Priorización de los requisitos por valor y coste]
* [[Historia de usuario]]
* [[Backlog Del Producto]]
* [[Gráfico de Burn-Down]]
* [[Gráfico de Burn-Up]]
* [[Velocidad Trabajo Tiempo]]
* [[Hudson]]

[[Category:Scrum]]
[[Category: Métricas]]

Diagrama de despliegue

2011-09-29T13:08:41Z

201.251.185.130: Página creada con 'El diagrama de despliegue es un diagrama de UML que se utiliza para modelar el hardware utilizado en las implementaciones de sistemas y las relaciones entre sus componentes. Es…'

El diagrama de despliegue es un diagrama de UML que se utiliza para modelar el hardware utilizado en las implementaciones de sistemas y las relaciones entre sus componentes.

Este diagrama muestra las relaciones físicas entre los componentes de hardware y software en el sistema final. Describe la topología del sistema: la estructura de los elementos de hardware y el software que ejecuta cada uno de ellos.

== Elementos del diagrama ==

=== Nodos ===
Los nodos son objetos físicos que existen en tiempo de ejecución y que representan algún tipo de recurso (capacidad de memoria, procesamiento, dispositivos).

=== Asociaciones ===
Las asociaciones son las conexiones que unen los nodos y representan la comunicación entre los nodos.

=== Componentes ===
Los componentes son las aplicaciones que se ejecutan en los nodos.

=== Artefactos ===
Un artefacto es un producto del proceso de desarrollo de software.

== Ejemplo ==

[[Archivo:UML-diagrama_de_despliegue_-_ejemplo.JPG]]

Diagrama de componentes

2011-09-20T20:09:43Z

201.251.185.130: Página creada con 'Los diagramas de componentes muestran las relaciones entre los componentes de software, sus dependencias, comunicación, ubicación y otras condiciones. === Una guía para cons…'

Los diagramas de componentes muestran las relaciones entre los componentes de software, sus dependencias, comunicación, ubicación y otras condiciones.

=== Una guía para construir un diagrama de componentes===

#Pensar en un único diagrama que unifique los componentes de software que utilizaremos en la solución
#Dentro de la estructura de proyecto en [[UML]] generar un paquete con todos los componentes a utilizar
#Añadir al diagrama todos los componentes anteriormente creados
#Definir las relaciones que hay entre los componentes
#Definir que interfaces requeridas o expuestas habrá

== Ejemplo ==

[[Archivo:UML-diagrama de secuencia.jpg]]

Como siempre, el objetivo de estos diagramas es servir como una herramienta para entender al sistema. Si el diagrama no resulta claro, no estaremos cumpliendo con uno de los motivos por el cual estamos modelando. Es una buena práctica discutir los diagramas entre los que estén modelando el sistema.

== Ver también ==
* [[Diseño Por Contrato]]
* [[Patrones De Diseño]]
* [[Interfaces De Usuario]]
* [[UML]]

[[Category: Diseño De Software]]

UML

2011-09-20T19:58:34Z

201.251.185.130: /* Diagramas */

[[Category:Diseño De Software]]
Lenguaje Unificado de Modelado (UML, por sus siglas en inglés, Unified Modeling Language) es el lenguaje de modelado de sistemas de software más conocido y utilizado en la actualidad; está respaldado por el OMG (Object Management Group). Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema de software. UML ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos conceptuales tales como procesos de negocios y funciones del sistema, y aspectos concretos como expresiones de lenguajes de programación, esquemas de bases de datos y componentes de software reutilizables.

==Diagramas==
En UML 2.0 hay 13 tipos diferentes de diagramas.

Los '''Diagramas de Estructura''' enfatizan en los elementos que deben existir en el sistema modelado:

*[[Diagrama de dominio]]
*[[Diagrama de clases]]
*[[Diagrama de componentes]]
*Diagrama de estructura compuesta (UML 2.0)
*Diagrama de despliegue
*Diagrama de paquetes

Los '''Diagramas de Comportamiento''' enfatizan en lo que debe suceder en el sistema modelado:

*Diagrama de actividades
*[[Diagrama de casos de uso]]
*Diagrama de estados

Los '''Diagramas de Interacción''' son un subtipo de diagramas de comportamiento, que enfatiza sobre el flujo de control y de datos entre los elementos del sistema modelado:

*[[Diagrama de secuencia]]
*Diagrama de colaboración
*Diagrama de tiempos (UML 2.0)
*Diagrama de vista de interacción (UML 2.0)

==Ver también==
* [[Diseño De Software]]
* [http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado UML en la Wikipedia ]
* [http://case-tools.org/uml.html Listado de herramientas UML]

REST con Spring

2011-09-07T13:49:14Z

201.251.185.130: /* Manejo de errores */

[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple.

== Un ejemplo ==
Vamos a realizar una aplicación que responda a las siguientes URL:

/persona/todos : devuelve todas las personas
/persona/123 : devuelve la persona cuyo id es 123

Tendremos que seguir 3 pasos:
# Configurar el servlet de Spring
# Crear la clase que atenderá y resolverá estas peticiones
# Configurar Spring

=== El servlet de Spring ===
Lo primero es configurar el servlet de Spring que se encargará de tomas las peticiones y redireccionarla a las clases correspondientes. La clase que se encarga de esto es ''org.springframework.web.servlet.DispatcherServlet''. Un archivo web.xml de ejemplo sería:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>json-con-spring-mvc</display-name>

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<servlet>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
WEB-INF/applicationContext-clasico.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<url-pattern>/app/*</url-pattern>
</servlet-mapping>

<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
</code>

En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app".

=== El controller ===
La clase que toma las peticiones HTTP es una clase Java anotada con @Controller. Esta clase asocia las URL con métodos. Los objetos que devuelven los métodos son luego procesador por conversores, que representan la respuesta de distinta manera (XML, JSON, etc.)

Para esto, creamos una clase de la siguiente forma:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping(value="/persona")
public class PersonaController {

@RequestMapping(value="/{id}")
public @ResponseBody Persona get(@PathVariable Long id) {
Persona p = new Persona("Invasor " + id, "Zim " + id);
return p;
}

@RequestMapping(value="/todos")
public @ResponseBody Collection<Persona> getTodos() {
Collection<Persona> personas = new ArrayList<Persona>();
for (int i = 0; i < 10; i++) {
Persona p = new Persona("Invasor " + i, "Zim" + i);
personas.add(p);
}

return personas;
}
}
</code>

El objeto Persona es un POJO que tiene dos atributos: nombre y apellido. Los tags @RequestMapping se encargan de asociar la clase y cada uno de sus métodos con una URL en particular.

=== La configuración ===
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet):

<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />

</beans>
</code>

El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados.

Más aún, la configuración predeterminada se encarga de realizar [http://en.wikipedia.org/wiki/Content_negotiation negociación de contenido]: la respuesta se formatea de acuerdo a las capacidades del cliente. Por ejemplo, si en el classpath tenemos agregado las librerías de Jackson (un parser JSON), se habilitará el soporte JSON correspondiente. Si están agregadas las librerías de JAXB2, se habilitará el soporte XML.

=== Probando ===
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.io.IOException;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpClient;
import org.junit.Test;
import static org.junit.Assert.*;

public class HttpTest {

@Test
public void personaTodosJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("[{\""));
}

@Test
public void personaPorIdJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("{\""));
assertTrue(resultado.contains("34421"));
}

@Test
public void personaPorIdXML() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/xml");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));
assertTrue(resultado.contains("34421"));
}

}
</code>

== Manejo de errores ==
Es posible personalizar las excepciones para que devuelvan códigos de estado HTTP personalizados, usando la anotación @ResponseStatus en la excepción lanzada.

<code java5>
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="No se encontró el recurso pedido")
public class NotFoundException extends RuntimeException { ... }

.....
@Controller
@RequestMapping(value="/persona")
public class PersonaController {
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}
}

</code>
Otra forma de personalizar las excepciones, es interceptar las excepciones del controller(@Controller) y personalizarla en el mismo controller.
Para esto debemos crear un método handleException por cada excepción que deseemos personalizar.

<code java5>
@Controller
@RequestMapping(value="/persona")
public class PersonaController {
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}

@ResponseStatus(HttpStatus.NOT_FOUND)
@ExceptionHandler(NotFoundException.class)
@ResponseBody
public Map<String, String> handleException(NotFoundException exception) {
return Collections.singletonMap("message", "No se encontró el recurso pedido");
}
}
</code>

Y agregar lo siguiente en el applicationContext.xml
<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>
</beans>
</code>
Al utilizar este interceptor se debe personalizar las excepciones en todos los controladores, caso contrario la excepción no es customizada y retorna un status code 500.
La propiedad "messageConverters", define que conversor utilizar en el ResponseBody, en nuestro caso lo estamos pasando a Json.

En caso de que se quiera utilizar los 2 métodos, el de @ResponseStatus y el de @ExceptionHandler, se deben registrar los 2 Handler en el applicationContext.xml con el orden de ejecución.
<code xml>
...
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="order" value="1"/>
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>

<bean class="org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver" >
<property name="order" value="2"/>
</bean>
...
</code>

== Manejo de la respuesta ==
La anotación @ResponseStatus puede usarse para personalizar el código HTTP de cualquier respuesta, al ubicarla en el método.
Por ejemplo, los métodos que devuelven void pueden usar esta anotación para indicar que no hay contenido (es útil si, por ejemplo, se parsea el contenido con algunas librerías como [[JQuery]]).

<code java5>
@RequestMapping(value="/delete/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void delete(@PathVariable long id) {
contactService.delete(id);
}
</code>

=== Descargar un proyecto de ejemplo ===
Les dejamos para [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap descargar un proyecto de ejemplo de REST con Spring MVC] donde tienen todos los fuentes necesarios para abrir y ejecutar el ejemplo de esta página.

== Ver también ==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]
* [http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=springRestJson Spring + REST + JSON = SOAUI]
* [http://www.jpalace.org/docs/spring/rest.html Sprint REST Tutorial]

REST con Spring

2011-09-07T13:47:25Z

201.251.185.130: /* Manejo de errores */

[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple.

== Un ejemplo ==
Vamos a realizar una aplicación que responda a las siguientes URL:

/persona/todos : devuelve todas las personas
/persona/123 : devuelve la persona cuyo id es 123

Tendremos que seguir 3 pasos:
# Configurar el servlet de Spring
# Crear la clase que atenderá y resolverá estas peticiones
# Configurar Spring

=== El servlet de Spring ===
Lo primero es configurar el servlet de Spring que se encargará de tomas las peticiones y redireccionarla a las clases correspondientes. La clase que se encarga de esto es ''org.springframework.web.servlet.DispatcherServlet''. Un archivo web.xml de ejemplo sería:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>json-con-spring-mvc</display-name>

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<servlet>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
WEB-INF/applicationContext-clasico.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<url-pattern>/app/*</url-pattern>
</servlet-mapping>

<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
</code>

En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app".

=== El controller ===
La clase que toma las peticiones HTTP es una clase Java anotada con @Controller. Esta clase asocia las URL con métodos. Los objetos que devuelven los métodos son luego procesador por conversores, que representan la respuesta de distinta manera (XML, JSON, etc.)

Para esto, creamos una clase de la siguiente forma:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping(value="/persona")
public class PersonaController {

@RequestMapping(value="/{id}")
public @ResponseBody Persona get(@PathVariable Long id) {
Persona p = new Persona("Invasor " + id, "Zim " + id);
return p;
}

@RequestMapping(value="/todos")
public @ResponseBody Collection<Persona> getTodos() {
Collection<Persona> personas = new ArrayList<Persona>();
for (int i = 0; i < 10; i++) {
Persona p = new Persona("Invasor " + i, "Zim" + i);
personas.add(p);
}

return personas;
}
}
</code>

El objeto Persona es un POJO que tiene dos atributos: nombre y apellido. Los tags @RequestMapping se encargan de asociar la clase y cada uno de sus métodos con una URL en particular.

=== La configuración ===
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet):

<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />

</beans>
</code>

El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados.

Más aún, la configuración predeterminada se encarga de realizar [http://en.wikipedia.org/wiki/Content_negotiation negociación de contenido]: la respuesta se formatea de acuerdo a las capacidades del cliente. Por ejemplo, si en el classpath tenemos agregado las librerías de Jackson (un parser JSON), se habilitará el soporte JSON correspondiente. Si están agregadas las librerías de JAXB2, se habilitará el soporte XML.

=== Probando ===
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.io.IOException;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpClient;
import org.junit.Test;
import static org.junit.Assert.*;

public class HttpTest {

@Test
public void personaTodosJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("[{\""));
}

@Test
public void personaPorIdJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("{\""));
assertTrue(resultado.contains("34421"));
}

@Test
public void personaPorIdXML() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/xml");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));
assertTrue(resultado.contains("34421"));
}

}
</code>

== Manejo de errores ==
Es posible personalizar las excepciones para que devuelvan códigos de estado HTTP personalizados, usando la anotación @ResponseStatus en la excepción lanzada.

<code java5>
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="No se encontró el recurso pedido")
public class NotFoundException extends RuntimeException { ... }

.....
@Controller
@RequestMapping(value="/persona")
public class PersonaController {
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}
}

</code>
Otra forma de personalizar las excepciones, es interceptar las excepciones del controller(@Controller) y personalizarla en el mismo controller.
Para esto debemos crear un método handleException por cada excepción que deseemos personalizar.

<code java5>
@Controller
@RequestMapping(value="/persona")
public class PersonaController {
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}

@ResponseStatus(HttpStatus.NOT_FOUND)
@ExceptionHandler(NotFoundException.class)
@ResponseBody
public Map<String, String> handleException(NotFoundException exception) {
return Collections.singletonMap("message", "No se encontró el recurso pedido");
}
}
</code>

Y agregar lo siguiente en el applicationContext.xml
<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>
</beans>
</code>
Al utilizar este interceptor se debe personalizar las excepciones en todos los controladores, caso contrario la excepción no es customizada y retorna un status code 500.
La propiedad "messageConverters", define que conversor utilizar en el ResponseBody, en nuestro caso lo estamos pasando a Json.

En caso de que se quiera utilizar los 2 métodos, el de @ResponseStatus y el de @ExceptionHandler, se deben registrar los 2 Handler en el applicationContext.xml con el orden de ejecucion.
<code xml>
...
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="order" value="1"/>
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>

<bean class="org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver" >
<property name="order" value="2"/>
</bean>
...
</code>

== Manejo de la respuesta ==
La anotación @ResponseStatus puede usarse para personalizar el código HTTP de cualquier respuesta, al ubicarla en el método.
Por ejemplo, los métodos que devuelven void pueden usar esta anotación para indicar que no hay contenido (es útil si, por ejemplo, se parsea el contenido con algunas librerías como [[JQuery]]).

<code java5>
@RequestMapping(value="/delete/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void delete(@PathVariable long id) {
contactService.delete(id);
}
</code>

=== Descargar un proyecto de ejemplo ===
Les dejamos para [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap descargar un proyecto de ejemplo de REST con Spring MVC] donde tienen todos los fuentes necesarios para abrir y ejecutar el ejemplo de esta página.

== Ver también ==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]
* [http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=springRestJson Spring + REST + JSON = SOAUI]
* [http://www.jpalace.org/docs/spring/rest.html Sprint REST Tutorial]

REST con Spring

2011-09-07T13:43:46Z

201.251.185.130: /* Manejo de errores */

[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple.

== Un ejemplo ==
Vamos a realizar una aplicación que responda a las siguientes URL:

/persona/todos : devuelve todas las personas
/persona/123 : devuelve la persona cuyo id es 123

Tendremos que seguir 3 pasos:
# Configurar el servlet de Spring
# Crear la clase que atenderá y resolverá estas peticiones
# Configurar Spring

=== El servlet de Spring ===
Lo primero es configurar el servlet de Spring que se encargará de tomas las peticiones y redireccionarla a las clases correspondientes. La clase que se encarga de esto es ''org.springframework.web.servlet.DispatcherServlet''. Un archivo web.xml de ejemplo sería:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>json-con-spring-mvc</display-name>

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<servlet>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
WEB-INF/applicationContext-clasico.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<url-pattern>/app/*</url-pattern>
</servlet-mapping>

<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
</code>

En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app".

=== El controller ===
La clase que toma las peticiones HTTP es una clase Java anotada con @Controller. Esta clase asocia las URL con métodos. Los objetos que devuelven los métodos son luego procesador por conversores, que representan la respuesta de distinta manera (XML, JSON, etc.)

Para esto, creamos una clase de la siguiente forma:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping(value="/persona")
public class PersonaController {

@RequestMapping(value="/{id}")
public @ResponseBody Persona get(@PathVariable Long id) {
Persona p = new Persona("Invasor " + id, "Zim " + id);
return p;
}

@RequestMapping(value="/todos")
public @ResponseBody Collection<Persona> getTodos() {
Collection<Persona> personas = new ArrayList<Persona>();
for (int i = 0; i < 10; i++) {
Persona p = new Persona("Invasor " + i, "Zim" + i);
personas.add(p);
}

return personas;
}
}
</code>

El objeto Persona es un POJO que tiene dos atributos: nombre y apellido. Los tags @RequestMapping se encargan de asociar la clase y cada uno de sus métodos con una URL en particular.

=== La configuración ===
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet):

<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />

</beans>
</code>

El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados.

Más aún, la configuración predeterminada se encarga de realizar [http://en.wikipedia.org/wiki/Content_negotiation negociación de contenido]: la respuesta se formatea de acuerdo a las capacidades del cliente. Por ejemplo, si en el classpath tenemos agregado las librerías de Jackson (un parser JSON), se habilitará el soporte JSON correspondiente. Si están agregadas las librerías de JAXB2, se habilitará el soporte XML.

=== Probando ===
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.io.IOException;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpClient;
import org.junit.Test;
import static org.junit.Assert.*;

public class HttpTest {

@Test
public void personaTodosJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("[{\""));
}

@Test
public void personaPorIdJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("{\""));
assertTrue(resultado.contains("34421"));
}

@Test
public void personaPorIdXML() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/xml");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));
assertTrue(resultado.contains("34421"));
}

}
</code>

== Manejo de errores ==
Es posible personalizar las excepciones para que devuelvan códigos de estado HTTP personalizados, usando la anotación @ResponseStatus en la excepción lanzada.

<code java5>
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="No se encontró el recurso pedido")
public class NotFoundException extends RuntimeException { ... }

.....
@Controller
@RequestMapping(value="/persona")
public class PersonaController {
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}
}

</code>
Otra forma de personalizar las excepciones, es interceptar las excepciones del controller(@Controller) y personalizarla en el mismo controller.
Para esto debemos crear un método handleException por cada excepción que deseemos personalizar.

<code java5>
@Controller
@RequestMapping(value="/persona")
public class PersonaController {
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}

@ResponseStatus(HttpStatus.NOT_FOUND)
@ExceptionHandler(NotFoundException.class)
@ResponseBody
public Map<String, String> handleException(NotFoundException exception) {
return Collections.singletonMap("message", "No se encontró el recurso pedido");
}
}
</code>

Y agregar lo siguiente en el applicationContext.xml
<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>
</beans>
</code>
Al utilizar este interceptor se debe personalizar las excepciones en todos los controladores, caso contrario la excepción no es customizada y retorna un status code 500.
La propiedad "messageConverters", define que conversor utilizar en el ResponseBody, en nuestro caso lo estamos pasando a Json.

En caso de que se quiera utilizar los 2 métodos, el de @ResponseStatus y el de @ExceptionHandler, se debe registrar los 2 Handler en el applicationContext con el orden de ejecucion.
<code xml>
...
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="order" value="1"/>
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>

<bean class="org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver" >
<property name="order" value="2"/>
</bean>
...
</code>

== Manejo de la respuesta ==
La anotación @ResponseStatus puede usarse para personalizar el código HTTP de cualquier respuesta, al ubicarla en el método.
Por ejemplo, los métodos que devuelven void pueden usar esta anotación para indicar que no hay contenido (es útil si, por ejemplo, se parsea el contenido con algunas librerías como [[JQuery]]).

<code java5>
@RequestMapping(value="/delete/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void delete(@PathVariable long id) {
contactService.delete(id);
}
</code>

=== Descargar un proyecto de ejemplo ===
Les dejamos para [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap descargar un proyecto de ejemplo de REST con Spring MVC] donde tienen todos los fuentes necesarios para abrir y ejecutar el ejemplo de esta página.

== Ver también ==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]
* [http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=springRestJson Spring + REST + JSON = SOAUI]
* [http://www.jpalace.org/docs/spring/rest.html Sprint REST Tutorial]

REST con Spring

2011-09-07T13:40:35Z

201.251.185.130: /* Manejo de errores */

[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple.

== Un ejemplo ==
Vamos a realizar una aplicación que responda a las siguientes URL:

/persona/todos : devuelve todas las personas
/persona/123 : devuelve la persona cuyo id es 123

Tendremos que seguir 3 pasos:
# Configurar el servlet de Spring
# Crear la clase que atenderá y resolverá estas peticiones
# Configurar Spring

=== El servlet de Spring ===
Lo primero es configurar el servlet de Spring que se encargará de tomas las peticiones y redireccionarla a las clases correspondientes. La clase que se encarga de esto es ''org.springframework.web.servlet.DispatcherServlet''. Un archivo web.xml de ejemplo sería:

<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>json-con-spring-mvc</display-name>

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<servlet>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
WEB-INF/applicationContext-clasico.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
<url-pattern>/app/*</url-pattern>
</servlet-mapping>

<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
</code>

En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app".

=== El controller ===
La clase que toma las peticiones HTTP es una clase Java anotada con @Controller. Esta clase asocia las URL con métodos. Los objetos que devuelven los métodos son luego procesador por conversores, que representan la respuesta de distinta manera (XML, JSON, etc.)

Para esto, creamos una clase de la siguiente forma:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping(value="/persona")
public class PersonaController {

@RequestMapping(value="/{id}")
public @ResponseBody Persona get(@PathVariable Long id) {
Persona p = new Persona("Invasor " + id, "Zim " + id);
return p;
}

@RequestMapping(value="/todos")
public @ResponseBody Collection<Persona> getTodos() {
Collection<Persona> personas = new ArrayList<Persona>();
for (int i = 0; i < 10; i++) {
Persona p = new Persona("Invasor " + i, "Zim" + i);
personas.add(p);
}

return personas;
}
}
</code>

El objeto Persona es un POJO que tiene dos atributos: nombre y apellido. Los tags @RequestMapping se encargan de asociar la clase y cada uno de sus métodos con una URL en particular.

=== La configuración ===
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet):

<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />

</beans>
</code>

El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados.

Más aún, la configuración predeterminada se encarga de realizar [http://en.wikipedia.org/wiki/Content_negotiation negociación de contenido]: la respuesta se formatea de acuerdo a las capacidades del cliente. Por ejemplo, si en el classpath tenemos agregado las librerías de Jackson (un parser JSON), se habilitará el soporte JSON correspondiente. Si están agregadas las librerías de JAXB2, se habilitará el soporte XML.

=== Probando ===
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio:

<code java5>
package com.dosideas.jsonconspringmvc;

import java.io.IOException;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpClient;
import org.junit.Test;
import static org.junit.Assert.*;

public class HttpTest {

@Test
public void personaTodosJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("[{\""));
}

@Test
public void personaPorIdJSON() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/json");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("{\""));
assertTrue(resultado.contains("34421"));
}

@Test
public void personaPorIdXML() throws IOException {
HttpClient httpclient = new HttpClient();
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");
method.addRequestHeader("accept", "application/xml");

httpclient.executeMethod(method);
String resultado = method.getResponseBodyAsString();
System.out.println(resultado);

assertNotNull(resultado);
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));
assertTrue(resultado.contains("34421"));
}

}
</code>

== Manejo de errores ==
Es posible personalizar las excepciones para que devuelvan códigos de estado HTTP personalizados, usando la anotación @ResponseStatus en la excepción lanzada.

<code java5>
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="No se encontró el recurso pedido")
public class NotFoundException extends RuntimeException { ... }

.....

@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}
</code>
Otra forma de personalizar las excepciones, es interceptar las excepciones del controller(@Controller) y personalizarla en el mismo controller.
Para esto debemos crear un método handleException por cada excepción que deseemos personalizar.

<code java5>
@RequestMapping(value="/id/{id}")
public @ResponseBody Persona findById(@PathVariable long id) {
Contact contact = personaService.findById(id);
if (contact == null) {
throw new NotFoundException();
} else {
return contact;
}
}

@ResponseStatus(HttpStatus.NOT_FOUND)
@ExceptionHandler(NotFoundException.class)
@ResponseBody
public Map<String, String> handleException(NotFoundException exception) {
return Collections.singletonMap("message", "No se encontró el recurso pedido");
}
</code>

Y agregar lo siguiente en el applicationContext.xml
<code 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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="com.dosideas.jsonconspringmvc"/>

<mvc:annotation-driven />
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>
</beans>
</code>
Al utilizar este interceptor se debe personalizar las excepciones en todos los controladores, caso contrario la excepción no es customizada y retorna un status code 500.
En caso de que se quiera utilizar los 2 métodos, el de @ResponseStatus y el de @ExceptionHandler, se debe registrar los 2 Handler en el applicationContext con el orden de ejecucion.
<code xml>
...
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
<property name="order" value="1"/>
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>

<bean class="org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver" >
<property name="order" value="2"/>
</bean>
...
</code>

== Manejo de la respuesta ==
La anotación @ResponseStatus puede usarse para personalizar el código HTTP de cualquier respuesta, al ubicarla en el método.
Por ejemplo, los métodos que devuelven void pueden usar esta anotación para indicar que no hay contenido (es útil si, por ejemplo, se parsea el contenido con algunas librerías como [[JQuery]]).

<code java5>
@RequestMapping(value="/delete/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void delete(@PathVariable long id) {
contactService.delete(id);
}
</code>

=== Descargar un proyecto de ejemplo ===
Les dejamos para [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap descargar un proyecto de ejemplo de REST con Spring MVC] donde tienen todos los fuentes necesarios para abrir y ejecutar el ejemplo de esta página.

== Ver también ==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]
* [http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=springRestJson Spring + REST + JSON = SOAUI]
* [http://www.jpalace.org/docs/spring/rest.html Sprint REST Tutorial]

UML

2011-09-02T14:51:17Z

201.251.185.130: /* Diagramas */

[[Category:Diseño De Software]]
Lenguaje Unificado de Modelado (UML, por sus siglas en inglés, Unified Modeling Language) es el lenguaje de modelado de sistemas de software más conocido y utilizado en la actualidad; está respaldado por el OMG (Object Management Group). Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema de software. UML ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos conceptuales tales como procesos de negocios y funciones del sistema, y aspectos concretos como expresiones de lenguajes de programación, esquemas de bases de datos y componentes de software reutilizables.

==Diagramas==
En UML 2.0 hay 13 tipos diferentes de diagramas.

Los '''Diagramas de Estructura''' enfatizan en los elementos que deben existir en el sistema modelado:

*[[Diagrama de dominio]]
*Diagrama de clases
*Diagrama de componentes
*Diagrama de estructura compuesta (UML 2.0)
*Diagrama de despliegue
*Diagrama de paquetes

Los '''Diagramas de Comportamiento''' enfatizan en lo que debe suceder en el sistema modelado:

*Diagrama de actividades
*[[Diagrama de casos de uso]]
*Diagrama de estados

Los '''Diagramas de Interacción''' son un subtipo de diagramas de comportamiento, que enfatiza sobre el flujo de control y de datos entre los elementos del sistema modelado:

*[[Diagrama de secuencia]]
*Diagrama de colaboración
*Diagrama de tiempos (UML 2.0)
*Diagrama de vista de interacción (UML 2.0)

==Ver también==
* [[Diseño De Software]]
* [http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado UML en la Wikipedia ]
* [http://case-tools.org/uml.html Listado de herramientas UML]

Test de javascript con QUnit

2011-08-31T15:13:36Z

201.251.185.130:

== ¿Qué es QUnit? ==

QUnit es una potente herramienta para testear javascript.

== Escribir test unitarios con QUnit ==

Lo primero que se debe hacer es configurar el ambiente de test.

Para utilizar QUnit se deben usar los siguientes archivos: qunit.js y qunit.css. El qunit.js es un script con la libreria, y el qunit.css es una hoja de estilo y es opcional.

<code xml="xml">
<link rel="stylesheet" type="text/css" href="http://github.com/jquery/QUnit/raw/master/QUnit/QUnit.css" media="all" />
<script type="text/javascript" src="http://github.com/jquery/QUnit/raw/master/QUnit/QUnit.js"></script>
</code>

Además de estos archivos, nuestras aplicaciones tienen que contar con una serie de etiquetas HTML donde se mostrarán los resultados de nuestros tests:

<code xml="xml">
<h1 id="QUnit-header">QUnit Test Suite</h1>
<h2 id="QUnit-banner"></h2>
<div id="QUnit-testrunner-toolbar"></div>
<h2 id="QUnit-userAgent"></h2>
<ol id="QUnit-tests"></ol>
</code>

A continuación se deja un ejemplo completo de un html donde se incluyen los archivos y las etiquetas html que necesita QUnit.

<code xml="xml">

<!DOCTYPE html>
<html>
<head>
<title>Dos Ideas - QUnit</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
<script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>

<script type="text/javascript" src="dosIdeas.js"></script>


<script type="text/javascript" src="dosIdeasTest.js"></script>

</head>
<body>
<h1 id="qunit-header">QUnit example</h1>
<h2 id="qunit-banner"></h2>
<div id="qunit-testrunner-toolbar"></div>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>


<div id="qunit-fixture">test markup, will be hidden</div>
</body>
</html>

</code>

El codigo que se va a testear debe estar en dosIdeas.js y los test en dosIdeasTest.js. Para correr los test simplemente se debe abrir el html en el browser.

El archivo dosIdeasTest.js:

<code xml="xml">

$(document).ready(function(){

module("dosIdeasTest");

test('probando validarImporte()', function() {
ok(validarImporte("1112"),'El importe es 1112');
ok(!validarImporte("11A12"),'El importe es 11A12');
ok(!validarImporte("A1112"),'El importe es A1112');
ok(!validarImporte("1112A"),'El importe es 1112A');
})

test('probando extraerSubCadena()', function() {
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
equal(extraerSubCadena("dosIdeas",3,5),'deas');
})

});

</code>

<br> El archivo dosIdeas.js:

<code xml="xml">

function validarImporte(importe) {

if (importe.length == 0) {
return false;
} else {
if (!/^[1-9][0-9]*(?:\.)?[0-9]?[0-9]?$/.test(importe.replace(',','.'))) {
return false;
}
}
return true;
}

function extraerSubCadena(cadena, posicionInicial, longitud)
{
return cadena.substr(posicionInicial, longitud);
}

</code>

El resultado de los test quedan de la siguiente manera:

[[Image:DosIdeasQUnitResultado.jpg]]

== Asserts ==

Qunit nos provee de una serie de asserts para nuestros test. En el ejemplo anterior se hace mención de ok y equal. A continuación vamos a dar más detalle de los mismos y de nuevos.

'''ok''':
Es para validar resultado booleanos (es el equivalente a assertTrue de JUnit).

La sintaxis es la siguiente: ok(estado, mensaje).

estado: es una expresión booleana a evaluar.

mensaje: es el mensaje a mostrar cuando finaliza el assert.

Ejemplo:
<code xml>
ok(validarImporte("1112"),'El importe es 1112');
</code>

'''equal''':
Valida que el resultado obtenido es igual al esperado (es similiar al assertEqual de JUnit).

La sintaxis es la siguiente: equal(actual, esperado, mensaje)

actual: es el objeto a evaluar.

esperado: es el resultado esperado.

mensaje: es el mensaje a mostrar cuando finaliza el assert.

Ejemplo:
<code xml>
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
</code>

==Integracion continua con Jenkins==

Qunit-test-runner (QTR) es un proyecto que te permite integrar tus test de QUnit mediante una simple tarea ant.

QTR provee un entorno de JavaScript dentro de una JVM para la ejecucion de los test de QUnit y el reporte de los resultados en un formato JUnit XML standard.
Por lo tanto, QTR permite una fácil integracion con los sistemas de CI (Integracion Continua) como Jenkins/Hudson, dando visibilidad inmediata de los test de QUnit junto a los test de JUnit.

* Bajar la libreria [http://code.google.com/p/qunit-test-runner/downloads/list qunit-test-runner-0.0.1-SNAPSHOT-jar-with-dependencies.jar] y agregarla en el classpath de Run Test (en Netbeans) del proyecto.

* Generar un '''<nombre del Test>Recipe.js''' con la funcion loadFiles utilizada por QTR.

Ejemplo: pagoConTarjetaTestRecipe.js

<code javascript>
loadFiles([
"../../siteApache/home/js/jquery-1.3.2.js",
"../../siteApache/home/js/validate.js",
"../../siteApache/home/js/pagoConTarjeta.js",
"pagoConTarjetaTest.js"
])
</code>

* Agregar las siguientes tareas ant al build.xml del proyecto.

<code xml>
<target name="qunit" depends="init">
<path id="qunit-test-runner.path">
<fileset dir="${basedir}">
<include name="${file.reference.qunit-test-runner-0.0.1-SNAPSHOT-jar-with-dependencies.jar}" />
</fileset>
</path>
<taskdef classpathref="qunit-test-runner.path" resource="tasks.properties"/>
</target>

<target name="report-jstest-pnt" depends="qunit">
<mkdir dir="${report.dir}" />
<qunit basedirectory="${basedir}/${test.javascript.dir}"
reportdirectory="${report.dir}">
</qunit>


<mkdir dir="${report.dir}/html" />
<junitreport todir="${report.dir}/html">
<fileset dir="${report.dir}">
<include name="TEST-qunit-*.xml"/>
</fileset>
<report format="frames" todir="${report.dir}/html"/>
</junitreport>
</target>
</code>

* Activar en el proyecto de Jenkins, la opcion publish HTML reports y apuntar al directorio donde se generan los reportes HTML a la pagina index.html

== Ver también ==
[http://docs.jquery.com/Qunit Página de QUnit]
[http://code.google.com/p/qunit-test-runner/ Página de QTR (proyecto Qunit-test-runner)]

Test de javascript con QUnit

2011-08-31T15:11:52Z

201.251.185.130:

== ¿Qué es QUnit? ==

QUnit es una potente herramienta para testear javascript.

== Escribir test unitarios con QUnit ==

Lo primero que se debe hacer es configurar el ambiente de test.

Para utilizar QUnit se deben usar los siguientes archivos: qunit.js y qunit.css. El qunit.js es un script con la libreria, y el qunit.css es una hoja de estilo y es opcional.

<code xml="xml">
<link rel="stylesheet" type="text/css" href="http://github.com/jquery/QUnit/raw/master/QUnit/QUnit.css" media="all" />
<script type="text/javascript" src="http://github.com/jquery/QUnit/raw/master/QUnit/QUnit.js"></script>
</code>

Además de estos archivos, nuestras aplicaciones tienen que contar con una serie de etiquetas HTML donde se mostrarán los resultados de nuestros tests:

<code xml="xml">
<h1 id="QUnit-header">QUnit Test Suite</h1>
<h2 id="QUnit-banner"></h2>
<div id="QUnit-testrunner-toolbar"></div>
<h2 id="QUnit-userAgent"></h2>
<ol id="QUnit-tests"></ol>
</code>

A continuación se deja un ejemplo completo de un html donde se incluyen los archivos y las etiquetas html que necesita QUnit.

<code xml="xml">

<!DOCTYPE html>
<html>
<head>
<title>Dos Ideas - QUnit</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
<script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>

<script type="text/javascript" src="dosIdeas.js"></script>


<script type="text/javascript" src="dosIdeasTest.js"></script>

</head>
<body>
<h1 id="qunit-header">QUnit example</h1>
<h2 id="qunit-banner"></h2>
<div id="qunit-testrunner-toolbar"></div>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>


<div id="qunit-fixture">test markup, will be hidden</div>
</body>
</html>

</code>

El codigo que se va a testear debe estar en dosIdeas.js y los test en dosIdeasTest.js. Para correr los test simplemente se debe abrir el html en el browser.

El archivo dosIdeasTest.js:

<code xml="xml">

$(document).ready(function(){

module("dosIdeasTest");

test('probando validarImporte()', function() {
ok(validarImporte("1112"),'El importe es 1112');
ok(!validarImporte("11A12"),'El importe es 11A12');
ok(!validarImporte("A1112"),'El importe es A1112');
ok(!validarImporte("1112A"),'El importe es 1112A');
})

test('probando extraerSubCadena()', function() {
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
equal(extraerSubCadena("dosIdeas",3,5),'deas');
})

});

</code>

<br> El archivo dosIdeas.js:

<code xml="xml">

function validarImporte(importe) {

if (importe.length == 0) {
return false;
} else {
if (!/^[1-9][0-9]*(?:\.)?[0-9]?[0-9]?$/.test(importe.replace(',','.'))) {
return false;
}
}
return true;
}

function extraerSubCadena(cadena, posicionInicial, longitud)
{
return cadena.substr(posicionInicial, longitud);
}

</code>

El resultado de los test quedan de la siguiente manera:

[[Image:DosIdeasQUnitResultado.jpg]]

== Asserts ==

Qunit nos provee de una serie de asserts para nuestros test. En el ejemplo anterior se hace mención de ok y equal. A continuación vamos a dar más detalle de los mismos y de nuevos.

'''ok''':
Es para validar resultado booleanos (es el equivalente a assertTrue de JUnit).

La sintaxis es la siguiente: ok(estado, mensaje).

estado: es una expresión booleana a evaluar.

mensaje: es el mensaje a mostrar cuando finaliza el assert.

Ejemplo:
<code xml>
ok(validarImporte("1112"),'El importe es 1112');
</code>

'''equal''':
Valida que el resultado obtenido es igual al esperado (es similiar al assertEqual de JUnit).

La sintaxis es la siguiente: equal(actual, esperado, mensaje)

actual: es el objeto a evaluar.

esperado: es el resultado esperado.

mensaje: es el mensaje a mostrar cuando finaliza el assert.

Ejemplo:
<code xml>
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
</code>

==Integracion continua con Jenkins==

Qunit-test-runner (QTR) es un proyecto que te permite integrar tus test de QUnit mediante una simple tarea ant.

QTR provee un entorno de JavaScript dentro de una JVM para la ejecucion de los test de QUnit y el reporte de los resultados en un formato JUnit XML standard.
Por lo tanto, QTR permite una fácil integracion con los sistemas de CI (Integracion Continua) como Jenkins/Hudson, dando visibilidad inmediata de los test de QUnit junto a los test de JUnit.

* Bajar la libreria [http://code.google.com/p/qunit-test-runner/downloads/list qunit-test-runner-0.0.1-SNAPSHOT-jar-with-dependencies.jar] y agregarla en el classpath de Run Test (en Netbeans) del proyecto.

* Generar un <nombre del Test>Recipe.js con la funcion loadFiles utilizada por QTR.

Ejemplo: pagoConTarjetaTestRecipe.js
<code javascript>
loadFiles([
"../../siteApache/home/js/jquery-1.3.2.js",
"../../siteApache/home/js/validate.js",
"../../siteApache/home/js/pagoConTarjeta.js",
"pagoConTarjetaTest.js"
])
</code>

* Agregar las siguientes tareas ant al build.xml del proyecto.

<code xml>
<target name="qunit" depends="init">
<path id="qunit-test-runner.path">
<fileset dir="${basedir}">
<include name="${file.reference.qunit-test-runner-0.0.1-SNAPSHOT-jar-with-dependencies.jar}" />
</fileset>
</path>
<taskdef classpathref="qunit-test-runner.path" resource="tasks.properties"/>
</target>

<target name="report-jstest-pnt" depends="qunit">
<mkdir dir="${report.dir}" />
<qunit basedirectory="${basedir}/${test.javascript.dir}"
reportdirectory="${report.dir}">
</qunit>


<mkdir dir="${report.dir}/html" />
<junitreport todir="${report.dir}/html">
<fileset dir="${report.dir}">
<include name="TEST-qunit-*.xml"/>
</fileset>
<report format="frames" todir="${report.dir}/html"/>
</junitreport>
</target>
</code>

* Activar en el proyecto de Jenkins, la opcion publish HTML reports y apuntar al directorio donde se generan los reportes HTML a la pagina index.html

== Ver también ==
[http://docs.jquery.com/Qunit Página de QUnit]
[http://code.google.com/p/qunit-test-runner/ Página de QTR (proyecto Qunit-test-runner)]

Tablas Externas

2011-08-19T12:18:28Z

201.251.185.130: Deshecha la edición 6080 de 200.4.200.130 (disc.)

[[Category:Oracle]]
Las tablas externas de [[Oracle]] permiten consultar datos de un archivo plano como si fuera una tabla dentro de la [[Base De Datos]] [[Oracle]]. Vamos a ver a continuación una breve introducción al tema.

En [[Oracle9i]], solo se pueden realizar operaciones de lectura, pero en [[Oracle10g]], ya se pueden escribir datos a una tabla externa, aunque no se puede escribir a un archivo existente.

Las external tables son un reemplazo natural del sql*loader en su función de lectura de archivos plano.

=Ejemplo=
Supongamos el archivo ''D:\ejemplo\external_table\empleados.txt''

001,Perez,Carlos,21446992, cperez@dosideas.com
002,Garcia,Alicia,19436951, agarcia@dosideas.com
003,Lopez,Pablo,11446663, plopez@dosideas.com
004,Gomez,Valeria,22222222, vgomez@dosideas.com
005,Gonzalez,Diego,16446987, dgonzalez@dosideas.com
006,Torres,Guillermo,23444999, gtorres@dosideas.com

==Creación de la tabla externa==

connect system/password

create or replace directory extdata_dir as ‘D:\ejemplo\external_table’;
grant read, write on directory extdata_dir to cbarbiero;

connect usuario/password

CREATE TABLE empleados_ext
( emp_id number(3),
apellido varchar2(30),
nombre varchar2(30),
documento number,
mail varchar2(50)
)
Organization external
(
default directory extdata_dir
access parameters (records delimited by newline
fields terminated by ‘,’)
location (‘empleados.txt’)
);

==Query de ejemplo==
SQL> select * from empleados_ext;

EMP_ID APELLIDO NOMBRE DOCUMENTO MAIL
--------- ---------- ---------- ---------- ------------------------------
1 Perez Carlos 21446992 cperez@dosideas.com
2 Garcia Alicia 19436951 agarcia@dosideas.com
3 Lopez Pablo 11446663 plopez@dosideas.com
4 Gomez Valeria 22222222 vgomez@dosideas.com
5 Gonzalez Diego 16446987 dgonzalez@dosideas.com
6 Torres Guillermo 23444999 gtorres@dosideas.com

6 rows selected.

=Sintaxis=
CREATE TABLE tabla
( columna1 ....,
columna2 ....,
..........
)
ORGANIZATION EXTERNAL
(
TYPE ORACLE_LOADER
DEFAULT DIRECTORY directorio
ACCESS PARAMETERS (records delimited by newline
fields terminated by ','
[NOBADFILE | BADFILE directorio:'archivo.bad']
[NODISCARDFILE | DISCARDFILE directorio:'archivo.dis']
[NOLOGFILE | LOGFILE directorio:'archivo.log'])
LOCATION ([directorio]:'archivos,...')
);

Las posibilidades de definición en ACCESS PARAMETERS son mucho más amplias que las cubiertas en esta nota. Para una referencia completa ir al manual Oracle9i Database Utilities.

=Reglas y Restricciones=
==Si se puede==

Ya que los datos de una tabla externa, residen en el sistema operativo, necesitamos que el/los archivos asociados a la misma estén unicados en un lugar donde Oracle tenga acceso.

Por lo tanto el primer paso es crear un directorio dentro de la base asociado a un directorio en el sistema operativo y dar permisos de acceso al mismo.

create or replace directory extdata_dir as ‘D:\ejemplo\external_table’;
grant read, write on directory extdata_dir to cbarbiero;

El usuario de S.O. dueño de los binarios de Oracle, debe tener acceso al directorio del S.O. y este directorio no puede ser un link simbólico.

Hay que poner el archivo plano que contiene los datos en este directorio.

D:\ejemplo\external_table\empleados.txt
001,Perez,Carlos,21446992, cperez@dosideas.com
002,Garcia,Alicia,19436951, agarcia@dosideas.com
003,Lopez,Pablo,11446663, plopez@dosideas.com
004,Gomez,Valeria,22222222, vgomez@dosideas.com
005,Gonzalez,Diego,16446987, dgonzalez@dosideas.com
006,Torres,Guillermo,23444999, gtorres@dosideas.com

El siguiente paso es crear la tabla. La sentencia CREATE TABLE de una tabla externa tiene 2 partes.

La primer parte, como para una tabla normal, tiene el nombre de la tabla y la especificación de las columnas.

Esta es seguida por un bloque de sintánxis específica para las tablas externas, la cual le indica a Oracle como interpretar los datos del archivo externo.

CREATE TABLE empleados_ext
( emp_id number(3),
apellido varchar2(30),
nombre varchar2(30),
documento number,
mail varchar2(50)
)
Organization external
(
default directory extdata_dir
access parameters (records delimited by newline
fields terminated by ‘,’)
location (‘empleados.txt’)
);

Con la creación de la tabla, Oracle no intenta cargar los datos, ni siquiera intenta chequear la validez de los valores de los parámetros especificados. La sentencia CREATE TABLE será exitosa aunque el archivo todavía no exista en el directorio.

Con la sentencia de CREATE sólo hemos creado un metadata en el diccionario de datos que instruye a Oracle cómo debe el driver ORACLE_LOADER parsear los datos del archivo.

Recién se valida la información y se accede al archivo en el momento de consultar la tabla.

SQL> select * from empleados_ext;

EMP_ID APELLIDO NOMBRE DOCUMENTO MAIL
--------- ---------- ---------- ---------- ------------------------------
1 Perez Carlos 21446992 cperez@dosideas.com
2 Garcia Alicia 19436951 agarcia@dosideas.com
3 Lopez Pablo 11446663 plopez@dosideas.com
4 Gomez Valeria 22222222 vgomez@dosideas.com
5 Gonzalez Diego 16446987 dgonzalez@dosideas.com
6 Torres Guillermo 23444999 gtorres@dosideas.com

6 rows selected.

SQL> select * from empleados_ext where apellido like ‘G%’;

EMP_ID APELLIDO NOMBRE DOCUMENTO MAIL
--------- ---------- ---------- ---------- ------------------------------
2 Garcia Alicia 19436951 agarcia@dosideas.com
4 Gomez Valeria 22222222 vgomez@dosideas.com
5 Gonzalez Diego 16446987 dgonzalez@dosideas.com

3 rows selected.

Oracle usa el dirver ORACLE_LOADER para procesar el archivo, y como la herramienta SQL*Loader, crea un archivo de log en el directorio definido como default al crear la tabla. El nombre usado por default es <nombre de tabla>_ospid.log

D:\ejemplo\external_table\empleados_ext_452_2828.txt

LOG file opened at 12/27/06 16:17:19

Field Definitions for table EMPLEADOS_EXT
Record format DELIMITED BY NEWLINE
Data in file has same endianness as the platform
Rows with all null fields are accepted

Fields in Data Source:
EMP_ID CHAR (255)
Terminated by ","
Trim whitespace same as SQL Loader
APELLIDO CHAR (255)
Terminated by ","
Trim whitespace same as SQL Loader
NOMBRE CHAR (255)
Terminated by ","
Trim whitespace same as SQL Loader
DOCUMENTO CHAR (255)
Terminated by ","
Trim whitespace same as SQL Loader
MAIL CHAR (255)
Terminated by ","
Trim whitespace same as SQL Loader

Lo mismo sucede con los archivos “bad” y “discard” en el caso de que necesiten generarse.

Si se desea se puede configurar directorios separados y nombres específicos para cada uno de estos archivos. Lo que debe recordarse es que debemos tener permiso de READ para el directorio donde están los datos y permisos de WRITE donde se generan los archivos de losg, bad y discard.

Se puede usar un ALTER TABLE para modificar los parámetros sin necesidad de borrar y redefinir toda la tabla.

connect system/password

create or replace directory extlog_dir as ‘D:\ejemplo\external_table\log’;
grant write on directory extlog_dir to cbarbiero;

connect cbarbiero/password

ALTER TABLE empleados_ext
( access parameters (records delimited by newline
logfile extlog_dir:’empleados_ext.log’
badfile extlog_dir:’empleados_ext.bad’
discardfile extlog_dir:’empleados_ext.dis’
fields terminated by ‘,’ );

Tambien podríamos setear que la tabla no genere ninguno de estos archivos y muchas otras opciones de configuración mas, que pueden consultarlas en el manual Oracle 9i Utilities.

==No se puede==

Aunque las external tables pueden ser consultadas, no pueden ser usadas como una tabla regular de Oracle.

Las tablas externas son read-only. No se puede realizar ninguna operación de DML ni crear índices sobre una tabla externa.

Otra cosa que debemos considerar es no terminar el ultimo registro del archivo de datos con un newline, ya que seguramente esto generará un error.

=Casos prácticos de uso=

El principal uso de las external tables es como medio/herramienta para cargar datos dentro de una tabla real en la base de datos. Luego de crear una tabla externa, se puede hacer:

CREATE TABLE <tabla real> AS SELECT … <tabla externa> …
INSERT INTO <tabla real> AS SELECT … <tabla externa> …

Cuando la tabla externa es accedida por una sentencia SQL, los campos de la tabla externa pueden usarse como cualquier campo de una tabla normal. En particular, los campos pueden ser usados como argumentos de cualquier función SQL, función PL/SQL o función java.

Esto permite una manipulación más amplia de los datos de la fuente externa en el momento de carga, si lo comparamos con la herramienta SQL*Loader.

También podemos hacer joins contra los datos de una tabla externa.

Y muy importante en los casos de carga masiva y volúmenes importantes, podemos paralelizar el proceso de carga creando la tabla externa con el degree de paralelismo deseado.

==Reemplazo SQL*Loader==

En la mayoría de las implementaciones podemos reemplazar el uso del SQL*Loader con tablas externas, evitando de esta manera la necesidad de crear una tabla de interface para cargar los datos, ahorrando espacio dentro de la base de datos.

==Data Warehouse==

Las tablas externas son interesantes en un ambiente data warehouse durante el proceso ETL (Extraction Transformation Loading). Evita la necesidad de crear tablas temporales a ser creadas durante las etapas de Extracción y Transformación, reduciendo el espacio alocado y el riesgo de aborto durante todo el proceso.

=Ver también=
* [[Oracle]]

Oracle BPM 11g

2011-08-17T14:06:48Z

201.251.185.130:

[[Oracle BPM 11g]] es la una versión de [[Oracle BPM]], que permite instalar aplicaciones basadas en [[BPM]].

== Instalación ==
Para instalar Oracle BPM 11g hay que seguir varios pasos e instaladores. Pueden seguir un [http://blog.lebrijo.com/?p=330&language=es paso-a-paso para instalarlo].

Los pasos simplificados son:
# Instalar base de datos Oracle Express 10g
# Ejecutar los siguientes ALTER en el equema:
alter system reset sessions scope=spfile sid='*';
alter system set processes=200 scope=spfile;
# Instalar el RCU. Si se usa Oracle Express, es necesario setear una variable de entorno ANTES de ejecutar el RCU (ver la documentación en el [http://www.oracle.com/technetwork/middleware/bpm/downloads/downloads-097443.html Centro de Descargas])
# Descomprimir soa_generic_11.1.1.2.0, y sobre el Disk1 ejecutar bin/setup
# Descomprimir soa_generic_11.1.1.3.0, y sobre el Disk1 ejectuar bin/setup
# Sobre el dominio instalado de SOA (Oracle_SOA1) ejecutar Oracle_SOA1\common\bin>config.cmd
# Instalar JDeveloper 11g.
# En JDeveloper 11g, ir a las actualizaciones e instalar los componentes SOA y BPM.

== Ver también ==
* [http://st-curriculum.oracle.com/obe/fmw/obpm/11g/r1/firstProcess/firstprocess_obpm11g.htm Guía para construir una primera aplicación con Oracle BPM 11g]
* [http://blog.lebrijo.com/?p=330&language=es Instalando Oracle SOA Suite 11g]
* [http://st-curriculum.oracle.com/obe/jdev/obe11jdev/bulldog/deploysoaapp/deployment.htm Instalación de Oracle SOA y ALTERs necesarios]
* [http://www.oracle.com/technetwork/middleware/bpm/downloads/downloads-097443.html Centro de descargas de Oracle BPM Suite]

[[Category: Oracle]]

Oracle BPM 11g

2011-08-17T14:02:42Z

201.251.185.130: /* Ver también */

[[Oracle BPM 11g]] es la una versión de [[Oracle BPM]], que permite instalar aplicaciones basadas en [[BPM]].

== Instalación ==
Para instalar Oracle BPM 11g hay que seguir varios pasos e instaladores. Pueden seguir un [http://blog.lebrijo.com/?p=330&language=es paso-a-paso para instalarlo].

Los pasos simplificados son:
# Instalar base de datos Oracle Express 10g
# Ejecutar los siguientes ALTER en el equema:
alter system reset sessions scope=spfile sid='*';
alter system set processes=200 scope=spfile;
# Instalar el RCU
# Descomprimir soa_generic_11.1.1.2.0, y sobre el Disk1 ejecutar bin/setup
# Descomprimir soa_generic_11.1.1.3.0, y sobre el Disk1 ejectuar bin/setup
# Sobre el dominio instalado de SOA (Oracle_SOA1) ejecutar Oracle_SOA1\common\bin>config.cmd
# Instalar JDeveloper 11g.
# En JDeveloper 11g, ir a las actualizaciones e instalar los componentes SOA y BPM.

== Ver también ==
* [http://st-curriculum.oracle.com/obe/fmw/obpm/11g/r1/firstProcess/firstprocess_obpm11g.htm Guía para construir una primera aplicación con Oracle BPM 11g]
* [http://blog.lebrijo.com/?p=330&language=es Instalando Oracle SOA Suite 11g]
* [http://st-curriculum.oracle.com/obe/jdev/obe11jdev/bulldog/deploysoaapp/deployment.htm Instalación de Oracle SOA y ALTERs necesarios]
* [http://www.oracle.com/technetwork/middleware/bpm/downloads/downloads-097443.html Centro de descargas de Oracle BPM Suite]

[[Category: Oracle]]

Test de javascript con QUnit

2011-08-15T19:55:18Z

201.251.185.130:

QUnit es una potente herramienta para testear javascript.

Para utilizar QUnit, se tiene que incluir los archivos qunit.js, qunit.css y un HTML para mostrar los resultados de las pruebas.

Como escribir test unitarios con QUnit:

Lo primero que se debe hacer es hacer el ambiente de test.

<code xml>

<!DOCTYPE html>
<html>
<head>
<title>Dos Ideas - QUnit</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
<script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>

<script type="text/javascript" src="dosIdeas.js"></script>


<script type="text/javascript" src="dosIdeasTest.js"></script>

</head>
<body>
<h1 id="qunit-header">QUnit example</h1>
<h2 id="qunit-banner"></h2>
<div id="qunit-testrunner-toolbar"></div>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>


<div id="qunit-fixture">test markup, will be hidden</div>
</body>
</html>

</code>

El codigo que se va a testear debe estar en dosIdeas.js y los test en dosIdeasTest.js. Para correr los test simplemente se debe abrir el html en el browser.

El archivo dosIdeasTest.js:

<code xml>

$(document).ready(function(){

module("dosIdeasTest");

test('probando validarImporte()', function() {
ok(validarImporte("1112"),'El importe es 1112');
ok(!validarImporte("11A12"),'El importe es 11A12');
ok(!validarImporte("A1112"),'El importe es A1112');
ok(!validarImporte("1112A"),'El importe es 1112A');
})

test('probando extraerSubCadena()', function() {
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
equal(extraerSubCadena("dosIdeas",3,5),'deas');
})

});

</code>

El archivo dosIdeas.js:

<code xml>

function validarImporte(importe) {
esImporteValido = true;

if (importe.length == 0) {
mensajeError = 'Ingresá el importe a pagar.';
esImporteValido = false;
} else {
if (!/^[1-9][0-9]*(?:\.)?[0-9]?[0-9]?$/.test(importe.replace(',','.'))) {
mensajeError = "El importe a pagar debe ser numérico, mayor a cero con hasta 2 decimales.";
esImporteValido = false;
}
}
return esImporteValido;
}

function extraerSubCadena(cadena, posicionInicial, longitud)
{
return cadena.substr(posicionInicial, longitud);
}

</code>

[[Image:DosIdeasQUnitResultado.jpg]]

Test de javascript con QUnit

2011-08-15T19:51:49Z

201.251.185.130:

QUnit es una potente herramienta para testear javascript.

Para utilizar QUnit, se tiene que incluir a los archivos qunit.js, qunit.css y un HTML para mostrar los resultados de las pruebas.

[[Image:EjemploQUnit.jpg]]

Como escribir test unitarios con QUnit:

Lo primero que se debe hacer es hacer el ambiente de test.

<code xml>

<!DOCTYPE html>
<html>
<head>
<title>Dos Ideas - QUnit</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
<script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>

<script type="text/javascript" src="dosIdeas.js"></script>


<script type="text/javascript" src="dosIdeasTest.js"></script>

</head>
<body>
<h1 id="qunit-header">QUnit example</h1>
<h2 id="qunit-banner"></h2>
<div id="qunit-testrunner-toolbar"></div>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>


<div id="qunit-fixture">test markup, will be hidden</div>
</body>
</html>

</code>

El codigo que se va a testear debe estar en dosIdeas.js y los test en dosIdeasTest.js. Para correr los test simplemente se debe abrir el html en el browser.

El archivo dosIdeasTest.js:

<code xml>

$(document).ready(function(){

module("dosIdeasTest");

test('probando validarImporte()', function() {
ok(validarImporte("1112"),'El importe es 1112');
ok(!validarImporte("11A12"),'El importe es 11A12');
ok(!validarImporte("A1112"),'El importe es A1112');
ok(!validarImporte("1112A"),'El importe es 1112A');
})

test('probando extraerSubCadena()', function() {
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
equal(extraerSubCadena("dosIdeas",3,5),'deas');
})

});

</code>

El archivo dosIdeas.js:

<code xml>

function validarImporte(importe) {
esImporteValido = true;

if (importe.length == 0) {
mensajeError = 'Ingresá el importe a pagar.';
esImporteValido = false;
} else {
if (!/^[1-9][0-9]*(?:\.)?[0-9]?[0-9]?$/.test(importe.replace(',','.'))) {
mensajeError = "El importe a pagar debe ser numérico, mayor a cero con hasta 2 decimales.";
esImporteValido = false;
}
}
return esImporteValido;
}

function extraerSubCadena(cadena, posicionInicial, longitud)
{
return cadena.substr(posicionInicial, longitud);
}

</code>

Test de javascript con QUnit

2011-08-15T19:50:25Z

201.251.185.130:

QUnit es una potente herramienta para testear javascript.

Para utilizar QUnit, se tiene que incluir a los archivos qunit.js, qunit.css y un HTML para mostrar los resultados de las pruebas.

[[Image:EjemploQUnit.jpg]]

Como escribir test unitarios con QUnit:

Lo primero que se debe hacer es hacer el ambiente de test.

<code xml>

<!DOCTYPE html>
<html>
<head>
<title>Dos Ideas - QUnit</title>
<script src="http://code.jquery.com/jquery-latest.js"></script>
<link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
<script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>

<script type="text/javascript" src="dosIdeas.js"></script>


<script type="text/javascript" src="dosIdeasTest.js"></script>

</head>
<body>
<h1 id="qunit-header">QUnit example</h1>
<h2 id="qunit-banner"></h2>
<div id="qunit-testrunner-toolbar"></div>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>


<div id="qunit-fixture">test markup, will be hidden</div>
</body>
</html>

</code>

El codigo que se va a testear debe estar en dosIdeas.js y los test en dosIdeasTest.js. Para correr los test simplemente se debe abrir el html en el browser.

El archivo dosIdeasTest.js es de la siguiente forma:

<code xml>

$(document).ready(function(){

module("dosIdeasTest");

test('probando validarImporte()', function() {
ok(validarImporte("1112"),'El importe es 1112');
ok(!validarImporte("11A12"),'El importe es 11A12');
ok(!validarImporte("A1112"),'El importe es A1112');
ok(!validarImporte("1112A"),'El importe es 1112A');
})

test('probando extraerSubCadena()', function() {
equal(extraerSubCadena("dosIdeas",3,5),'Ideas');
equal(extraerSubCadena("dosIdeas",3,5),'deas');
})

});

</code>

Test de javascript con QUnit

2011-08-15T19:44:17Z

201.251.185.130:

Test de javascript con QUnit

2011-08-15T19:39:55Z

201.251.185.130:

JavaScript

2011-08-11T17:37:16Z

201.251.185.130: /* Ver también */

[[Category:JavaScript]]
[[JavaScript]] es un lenguaje de programación interpretado, es decir, que no requiere compilación, utilizado principalmente en páginas web, con una sintaxis semejante a la del lenguaje Java y el lenguaje C.

Al igual que [[Java]], [[JavaScript]] es un lenguaje orientado a objetos propiamente dicho, ya que dispone de Herencia, si bien esta se realiza siguiendo el paradigma de programación basada en prototipos, ya que las nuevas clases se generan clonando las clases base (prototipos) y extendiendo su funcionalidad.

Todos los navegadores modernos interpretan el código [[JavaScript]] integrado dentro de las páginas web. Para interactuar con una página web se provee al lenguaje [[JavaScript]] de una implementación del DOM.

==Frameworks==
[[JavaScript]] cuenta con infinidad de frameworks y librerias que otorgan diversa funcionalidad. Entre los más conocidos:
* [[JQuery]], un framework de aplicación base, sumamente extensible.
* [[Prototype]], un framework de aplicación base que permite definir clases, muy usado.
* [[Rico]], un framework de componentes de presentación [AJAX].
* [[Concurrent Thread Javascript]], librería para manejo de hilos.

==Ver también==
* [http://es.wikipedia.org/wiki/JavaScript JavaScript en la Wikipedia]
* [http://www.theserverside.com/tt/articles/article.tss?l=OOJavaScriptDemonstrated Conceptos y operaciones básicas]
* [[Test de javascript con QUnit]]

SoapUI

2011-08-10T20:40:32Z

201.251.185.130:

[[Categoría: Web Service]]
[[SoapUI]] es una herramienta de [[Software Libre]] gráfica, está basada en [[Java]] y sirve para el testeo de [[Web Service]] y generación de [[Clientes De Web Service]].

SoapUI permite testear web services de forma facil, ver los resultados. Además, permite facilitar el uso de herramientas comunes para la generación de clientes, como [[Axis]].

Trabajando con web services, y sin interfase gráfica en la aplicación, esta herramienta nos permite automatizar fácilmente las pruebas funcionales y así asegurar la calidad en nuestros proyectos.

Las pruebas funcionales de los web services podrían usarse para más de un propósito:

*Pruebas unitarias: para validar que cada operación de los servicios funciona como se definió.
*Prueba de aceptación: para validar que el servicio retorna resultados aceptables según los requerimientos.
*Pruebas de proceso: para validar que una sucesión de invocaciones del servicio cumple con el proceso de negocio definido.
*Pruebas de manejo de datos: para validar el comportamiento con las entradas de datos externos al sistema (bases de datos, otros sistemas, uso de otros web services).
*[http://es.wikipedia.org/wiki/Pruebas_de_regresi%C3%B3n/ Pruebas de regresión]: para validar el comportamiento post cambios.

==Un paso a paso==

1. Tener instalada la última versión bajada de la [http://www.soapui.org/ Web oficial de SoapUI].

2. Crear un nuevo proyecto [[SoapUI]] para el proyecto a probar. Donde configurar la url que contiene el WSDL del proyecto.
{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Creacion-De-Proyecto.jpg|center|Creacion de un proyecto
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

3. Por cada operacion del servicio a probar, crear una peticion. Cada peticion requiere el ingreso de valores para los parámetros definidos. Agregar valores en el XML que nos propone el wizard de la herramienta.
{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Agregar-Peticion.jpg|center|Agregar Peticion
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}
{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Parametros-Peticion.jpg|center|Editar Parametros Peticion
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

4. El proyecto se persiste en un script XML, que podemos resguardar en el repositorio en el que tengamos el código fuente del proyecto. Y así todo el equipo podrá hacer crecer la prueba funcional automática del proyecto, y de un modo ágil.

5. Con los pasos dados hasta acá, logramos obtener una prueba funcional del proyecto y su documentación.

6. Esta herramienta maneja el concepto de TestSuite, TestCase, TestStep, como lo manejan [[JUnit]], [[JMeter]], etc. Un TestSuite sirve para contener un número arbitrario de casos de prueba (TestCases) que pueden ejecutarse secuencialmente o en paralelo. Los TestSteps sirven para ejecutar TestCases secuencialmente.
Una vez creadas las peticiones, es posible generar una TestSuite y así automatizar las pruebas funcionales, con el valor agregado de tener [[pruebas de regresión]].

{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Agregar-Caso-Prueba.jpg|center|Agregar Peticion a un Caso de Prueba
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

7. Por cada TestCase es posible hacer validaciones automáticas de los resultados. Entonces, por cada petición, verificar si la respuesta es un fault, o no lo es, o contiene determinado valor, o no lo contiene. Es una buena práctica, en el manejo de web services, que los errores inesperado del sistema (Runtime Exception) viajen en un tag “fault”. Distinto a una respuesta normal del servicio.

{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Agregar-Aserciones.jpg|center|Agregar una asercion a la respuesta de una peticion
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Tipos-Aserciones.jpg|center|Tipos de Aserciones
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Asercion-Contenido.jpg|center|Agregar una asercion de contenido
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

8. Con las peticiones agregadas a los casos de prueba, se puede realizar una ejecución masiva utilizando la opción Launch TestRunner.

{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Ejecutar-Casos.jpg|center|Configurar y Ejecutar Casos de Prueba
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

Mientras se ejecutan los casos de prueba, se pueden visualizar los pasos de ejecución y un resumen global.
En el directorio físico configurado, se genera un archivo por cada caso de prueba con la nomenclatura conteniendo el TestSuite que lo ejecutó, el nombre del caso de prueba, y el resultado de la prueba.

==Derechos reservados==

==Transferencia de datos entre peticiones==

En un TestSuite podemos tener un TestCase con Steps, donde cada Step puede ser un request de una operación diferente del web service. Y el valor devuelto en un Step puede ser el valor de entrada en el próximo Step. Más en el [http://www.soapui.org/userguide/functional/propertytransfers.html#The_PropertyTransfer_Editor tutorial de soapUI]

{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-TestSuite2ConTransfer.jpg|center|Transferencia de datos entre peticiones
default [[SoapUI]]
desc none
</imagemap>
<p align="center" style="font-size:large"></p>
|}

==Conclusión==

*Es fácil y rápido crear, ejecutar y guardar los casos de prueba funcional que quieras. Se pueden adaptar y expandir en cualquier momento.
*Es fácil hacer aserciones. También con expresiones regulares.

==Algo más==

*Se puede agregar MockService cuando el web service todavía no está listo.
*Load Tests permite medir performance sobre los tests funcionales creados.
*Esta nota está basada en una [http://www.soapui.org/userguide/functional/index.html guia] y en un [http://www.soapui.org/movies/sample_project/sample_project.html video] de la [http://www.soapui.org/ página oficial de SoapUI].

== Ver también ==
* [[Web Service]]
* [[Clientes De Web Service]]
* [[SoapUI Con JUnit]]
* [[Mock de un web service con SoapUI]]
* [http://www.soapui.org/ Web oficial de SoapUI]
* [http://www.dosideas.com/foros/5-ascensor-a-ningun-lugar/658-web-service-minimo-para-pruebas-de-desarrollo.html Foro de Ayuda para Simular un Web Service en Desarrollo]

[[Category:Web Service]]
[[Category:ATDD]]

HTML

2011-07-08T20:48:55Z

201.251.185.130:

[[HTML]] es un lenguaje de marcas para dar formato a datos en la web.

== Ver también ==
* [[Tablas en HTML]]

Tablas en HTML

2011-07-08T20:46:28Z

201.251.185.130:

En [[HTML]], ¿cuándo usar Tablas y cuando no usarlas? A mi parecer, se generó un odio extraño hacia las tablas en html, y este odio creo yo, viene desde los [[IDE]]s visuales de paginas html en sus principios de la web como el FrontPage o el DreamWeaver, donde uno arrastraba controles sobre una 'hoja' y creaba una página web, pero el html que generaba por detrás era realmente desastroso. Porque era desastroso?, la realidad es que el IDE desconocía lo que intentábamos formar, solo agrupaba los elementos de forma tal que se vieran como lo quisiéramos y esto lo hacía creando tablas, entre muchas otras cosas, para poder estructurar la pagina.

Habría que pensarlo de otra manera, ni las tablas, ni los divs, ni los ul, ni cualquier otro contenedor sirve para cualquier cosa. Cada elemento fue creado con un propósito, el punto principal es entender cual es el propósito de cada uno y utilizarlo de esa manera.

Las tablas fueron creadas para visualizar grillas. Si vamos a diseñar la estructura de una página web el elemento table no es la respuesta, si vamos a mostrar una lista de elementos enumerados usamos un UL, si vamos a agurpar elementos usaremos un div, etc. pero si necesitamos mostrar una '''grilla''', usamos un '''table'''.

El mejor ejemplo que se me ocurre en este momento es una factura. Supongamos que tenemos que mostrar una factura, la misma está compuesta por un Encabezado, Productos y Pie. El encabezado tiene la información del consumidor, no es una grilla por lo que utilizaremos otro contenedor, pero para el detalle de productos si tenemos una grilla de 4 columnas: Cantidad, Detalle de Producto, Precio unitario y Precio total. Eso si es una grilla y utilizar una tabla es la solución.

Algo a tener en cuenta en las tablas, es que pueden o no tener un encabezado y un pie también, lo que nos puede ayudar a aplicar estilos [[CSS]].

Estructura simple de una tabla con header:

<code xml>

<table>
<tr>
<th>Cantidad</th>
<th>Detalle de Producto</th>
<th>Precio Unitario</th>
<th>Precio Total</th>
</tr>
<tr>
<td>1</td>
<td>Microprocesador Sempron 2.2 Ghz</td>
<td>200</td>
<td>200</td>
</tr>
<tr>
<td>2</td>
<td>Memorias RAM 4Gb</td>
<td>140</td>
<td>280</td>
</tr>
</table>

</code>

Donde vamos a tener Filas (TR) y Celdas (TD). También se puede encontrar el elemento TH y se utiliza para decirle al browser que esa celda es un header. Por lo que en la primer Fila TR si utilizamos el elemento TH para las celdas vamos a notar que algunos browsers van a identificarlo como un header automáticamente haciendo el texto con negrita.

De esta manera, utilizamos el control para crear una grilla, para lo que fue creado y al momento de darle estilos, vamos a notar fácilmente que es mucho más ordenado, por ejemplo:

<code css>

table
{
width:600px;
border-collapse:collapse;
border:solid 1px silver;
font-family: Verdana;
}

table th
{
font-weight:bold;
color: black;
font-size:11pt;
border:solid 1px silver;
background-color:#A9F5F2;
text-align:center;
padding:5px;
}

table tr td
{
color: Black;
font-size:10pt;
border:solid 1px silver;
background-color:#CEECF5;
padding:3px;
}

table tr:hover td
{
background-color:#A9D0F5;
cursor:pointer;
}

</code>

Hay mucho mas sobre tablas, pero mi objetivo es poder mostrar la facilidad que nos deja al momento de trabar con grillas y a no confundir, hablo de '''grillas''', hay muchos tags mas en html, no todo es un table y depende que se intenta hacer el elemento a usar.

== Pruebas en linea ==

Les dejo un [http://jsfiddle.net/pjnovas/Xsuzp jsFiddle] para que vean el ejemplo en vivo y puedan hacer pruebas.

Tablas en HTML

2011-07-08T20:45:18Z

201.251.185.130: Página creada con '¿Cuándo usar Tablas y cuando no usarlas? A mi parecer, se generó un odio extraño hacia las tablas en html, y este odio creo yo, viene desde los IDEs visuales de paginas html…'

¿Cuándo usar Tablas y cuando no usarlas? A mi parecer, se generó un odio extraño hacia las tablas en html, y este odio creo yo, viene desde los IDEs visuales de paginas html en sus principios de la web como el FrontPage o el DreamWeaver, donde uno arrastraba controles sobre una 'hoja' y creaba una página web, pero el html que generaba por detrás era realmente desastroso. Porque era desastroso?, la realidad es que el IDE desconocía lo que intentábamos formar, solo agrupaba los elementos de forma tal que se vieran como lo quisiéramos y esto lo hacía creando tablas, entre muchas otras cosas, para poder estructurar la pagina.

Habría que pensarlo de otra manera, ni las tablas, ni los divs, ni los ul, ni cualquier otro contenedor sirve para cualquier cosa. Cada elemento fue creado con un propósito, el punto principal es entender cual es el propósito de cada uno y utilizarlo de esa manera.

Las tablas fueron creadas para visualizar grillas. Si vamos a diseñar la estructura de una página web el elemento table no es la respuesta, si vamos a mostrar una lista de elementos enumerados usamos un UL, si vamos a agurpar elementos usaremos un div, etc. pero si necesitamos mostrar una '''grilla''', usamos un '''table'''.

El mejor ejemplo que se me ocurre en este momento es una factura. Supongamos que tenemos que mostrar una factura, la misma está compuesta por un Encabezado, Productos y Pie. El encabezado tiene la información del consumidor, no es una grilla por lo que utilizaremos otro contenedor, pero para el detalle de productos si tenemos una grilla de 4 columnas: Cantidad, Detalle de Producto, Precio unitario y Precio total. Eso si es una grilla y utilizar una tabla es la solución.

Algo a tener en cuenta en las tablas, es que pueden o no tener un encabezado y un pie también, lo que nos puede ayudar a aplicar estilos CSS.

Estructura simple de una tabla con header:

<code xml>

<table>
<tr>
<th>Cantidad</th>
<th>Detalle de Producto</th>
<th>Precio Unitario</th>
<th>Precio Total</th>
</tr>
<tr>
<td>1</td>
<td>Microprocesador Sempron 2.2 Ghz</td>
<td>200</td>
<td>200</td>
</tr>
<tr>
<td>2</td>
<td>Memorias RAM 4Gb</td>
<td>140</td>
<td>280</td>
</tr>
</table>

</code>

Donde vamos a tener Filas (TR) y Celdas (TD). También se puede encontrar el elemento TH y se utiliza para decirle al browser que esa celda es un header. Por lo que en la primer Fila TR si utilizamos el elemento TH para las celdas vamos a notar que algunos browsers van a identificarlo como un header automáticamente haciendo el texto con negrita.

De esta manera, utilizamos el control para crear una grilla, para lo que fue creado y al momento de darle estilos, vamos a notar fácilmente que es mucho más ordenado, por ejemplo:

<code css>

table
{
width:600px;
border-collapse:collapse;
border:solid 1px silver;
font-family: Verdana;
}

table th
{
font-weight:bold;
color: black;
font-size:11pt;
border:solid 1px silver;
background-color:#A9F5F2;
text-align:center;
padding:5px;
}

table tr td
{
color: Black;
font-size:10pt;
border:solid 1px silver;
background-color:#CEECF5;
padding:3px;
}

table tr:hover td
{
background-color:#A9D0F5;
cursor:pointer;
}

</code>

Hay mucho mas sobre tablas, pero mi objetivo es poder mostrar la facilidad que nos deja al momento de trabar con grillas y a no confundir, hablo de '''grillas''', hay muchos tags mas en html, no todo es un table y depende que se intenta hacer el elemento a usar.

Les dejo un [http://jsfiddle.net/pjnovas/Xsuzp jsFiddle] para que vean el ejemplo en vivo y puedan hacer pruebas.

Spring Integration

2011-07-07T14:13:59Z

201.251.185.130: /* Adaptadores */

[http://www.springsource.org/spring-integration Spring Integration] es un producto relativamente desconocido del Spring.
Brinda una extensión a Spring para soportar los [http://www.eaipatterns.com/ Patrones de Integración Corporativos] en pocas palabras es un [http://en.wikipedia.org/wiki/Enterprise_service_bus ESB] liviano montado sobre el contenedor de Spring e independiente del Servidor de aplicaciones. Permite utilizar mensajería dentro de una aplicación Spring, y se integra con sistemas externos a través de adaptadores. Se basa en el concepto de "mensajes" para intercambiar datos entre distintos componentes.

==Conceptos y componentes básicos==

===Conceptos===

* '''Channel (MessageChannel)''', representa un canal lógico por donde se reciben o se envían mensajes.

* '''Channel-adapter''', representa el adaptador entre el canal lógico y una implementación física de ese canal.

* '''Bridge''', se encarga de redireccionar todos los mensajes del canal de entrada hacia un canal de salida.

* '''Router''', se encarga de redireccionar los mensajes que llegan a un canal de entrada hacia uno o varios canales de salida, dependiendo de ciertas condiciones.

* '''Splitter''', se encarga de separar el contenido de un mensaje en muchos mensajes.

* '''Transformer''', se encarga de transformar el formato del contenido del mensaje.

===Componentes===

* '''Message''', esta compuesto por una cabecera (headers) y por un cuerpo (Payload).

* '''MessageChannel''', provee métodos para enviar y recibir.

* '''MessageEndpoint''', Conecta un Handler a un MessageChannel de entrada o/y a uno de salida.

* '''MessageHandler''', interfaz que permite transformer, rutear y en general “tartar” cualquier mensaje de Entrada.

* '''Channel Adapters''', se usan para enviar y recibir mensajes a sistemas externos.

==Adaptadores==

* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ip TCP y UDP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#http HTTP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#feed RSS/ATOM]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ws Web Services]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#mail Mail (POP3, IMAP, SMTP)]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jms JMS]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jdbc JDBC]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jmx JMX]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#rmi RMI]

== Taller ==

{{curso|url=http://www.dosideas.com/cursos/course/view.php?id=12|nombre=Introducción a Spring Integration}}

== Ejemplos ==

=== Configuración de canales ===
[[Spring Integration]] se basa en ''canales'', lugares en donde se consumen o envian mensajes. Estos canales pueden ser colas [[JMS]] u otros medios, como clases propias. La siguiente definición de canales se usa en los ejemplos que siguen.

<code xml>
<integration:channel id="QueueChanneIn"/>

<jms:message-driven-channel-adapter connection-factory="PruebaQueueConnectionFactory"
destination-name="jms/Queue-in" destination-resolver="jmsDestinationResolver"
channel="QueueChanneIn" acknowledge="auto" concurrent-consumers="1"/>

<integration:channel id="QueueChanneOut1"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut1" channel="QueueChanneOut1"/>

<integration:channel id="QueueChanneOut2"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut2" channel="QueueChanneOut2"/>
</code>

===stdout-channel-adapter===
Podemos consumir un mensaje de una cola y mostrarlo por consola. Para esto es necesario configurar un '''stdout-channel-adapter''', el cual se encargará de procesar los mensajes. Luego, se crea un '''bridge''' que asocia un canal de entrada con este adaptador.

<code xml>
<stream:stdout-channel-adapter id="stdout" append-newline="true"/>
<integration:bridge id="echo" input-channel="QueueChanneIn" output-channel="stdout"/>
</code>

===recipient-list-router===
Podemos consumir un mensaje de una cola y enviarlo a una lista fija de canales de destino. En este ejemplo creamos un '''recipient-list-router''', el cual consume mensajes de un canal de entrada y los envia a dos canales de destino distintos. Entonces, cada mensaje que llegue al canal de entrada será derivado a dos canales de destino.

<code xml>
<integration:recipient-list-router input-channel="QueueChanneIn" apply-sequence="true">
<integration:recipient channel="QueueChanneOut1"/>
<integration:recipient channel="QueueChanneOut2"/>
</integration:recipient-list-router>
</code>

===header-value-router===
Podemos consumir un mensaje de una cola y enviarlo a una cola especifica dependiendo del valor de un atributo del header del mensaje. De esta manera, configuramos un '''header-value-router''', el cual contiene el canal de entrada y el nombre del atributo del encabezado que se comprobará. Luego, se realiza el mapeo entre los posibles valores de este encabezado y algún canal de destino. Si llega un mensaje que coincida este mapeo, será enviado a ese canal de destino.

<code xml>
<integration:header-value-router input-channel="QueueChanneIn"
header-name="springintegration_jms_type">
<integration:mapping value="Out1" channel="QueueChanneOut1"/>
<integration:mapping value="Out2" channel="QueueChanneOut2"/>
</integration:header-value-router>
</code>

===router===
Podemos consumir un mensaje de una cola y enviarlo a una lista de colas de salida utilizando un pojo para determinar a que colas enviarlo. En este ejemplo, creamos un '''router''' que será implementado por la clase "MultiDestino". Esta clase devuelve una lista de nombres de canales hacia donde se derivará el mensaje.

<code xml>
<integration:router input-channel="QueueChanneIn" ref="multiDestino"/>
<bean id="multiDestino" class="com.dosideas.springintegration.MultiDestino"/>
</code>

<code java>
public class MultiDestino {

@Router
public List<String> resolverChannel(GenericMessage message) throws JMSException {

List<String> list = new ArrayList<String>();
if(message.getHeaders().get("springintegration_jms_type").equals("Out1")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");

}
else if(message.getHeaders().get("springintegration_jms_type").equals("Out2")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut2");
}
else if(message.getHeaders().get("springintegration_jms_type").equals("Multi")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");
list.add("QueueChanneOut2");
}

return list;
}
}
</code>

==Ver también==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=29%3Ap Descargar un proyecto con varios ejemplos de Spring Integration]
* [http://static.springsource.org/spring-integration/reference/htmlsingle/spring-integration-reference.html Manual de referencia de Spring Integration]

[[Category:Spring Framework]]
[[Category:JMS]]

Spring Integration

2011-07-07T14:11:12Z

201.251.185.130: /* Aplicaciones demo */

[http://www.springsource.org/spring-integration Spring Integration] es un producto relativamente desconocido del Spring.
Brinda una extensión a Spring para soportar los [http://www.eaipatterns.com/ Patrones de Integración Corporativos] en pocas palabras es un [http://en.wikipedia.org/wiki/Enterprise_service_bus ESB] liviano montado sobre el contenedor de Spring e independiente del Servidor de aplicaciones. Permite utilizar mensajería dentro de una aplicación Spring, y se integra con sistemas externos a través de adaptadores. Se basa en el concepto de "mensajes" para intercambiar datos entre distintos componentes.

==Conceptos y componentes básicos==

===Conceptos===

* '''Channel (MessageChannel)''', representa un canal lógico por donde se reciben o se envían mensajes.

* '''Channel-adapter''', representa el adaptador entre el canal lógico y una implementación física de ese canal.

* '''Bridge''', se encarga de redireccionar todos los mensajes del canal de entrada hacia un canal de salida.

* '''Router''', se encarga de redireccionar los mensajes que llegan a un canal de entrada hacia uno o varios canales de salida, dependiendo de ciertas condiciones.

* '''Splitter''', se encarga de separar el contenido de un mensaje en muchos mensajes.

* '''Transformer''', se encarga de transformar el formato del contenido del mensaje.

===Componentes===

* '''Message''', esta compuesto por una cabecera (headers) y por un cuerpo (Payload).

* '''MessageChannel''', provee métodos para enviar y recibir.

* '''MessageEndpoint''', Conecta un Handler a un MessageChannel de entrada o/y a uno de salida.

* '''MessageHandler''', interfaz que permite transformer, rutear y en general “tartar” cualquier mensaje de Entrada.

* '''Channel Adapters''', se usan para enviar y recibir mensajes a sistemas externos.

==Adaptadores==

* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ip TCP y UDP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#http HTTP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#feed RSS/ATOM]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ws Web Services]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#mail Mail (POP3, IMAP, SMTP)]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jms JMS]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jdbc JDBC]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jmx JMX]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#rmi RMI]

== Ejemplos ==

=== Configuración de canales ===
[[Spring Integration]] se basa en ''canales'', lugares en donde se consumen o envian mensajes. Estos canales pueden ser colas [[JMS]] u otros medios, como clases propias. La siguiente definición de canales se usa en los ejemplos que siguen.

<code xml>
<integration:channel id="QueueChanneIn"/>

<jms:message-driven-channel-adapter connection-factory="PruebaQueueConnectionFactory"
destination-name="jms/Queue-in" destination-resolver="jmsDestinationResolver"
channel="QueueChanneIn" acknowledge="auto" concurrent-consumers="1"/>

<integration:channel id="QueueChanneOut1"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut1" channel="QueueChanneOut1"/>

<integration:channel id="QueueChanneOut2"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut2" channel="QueueChanneOut2"/>
</code>

===stdout-channel-adapter===
Podemos consumir un mensaje de una cola y mostrarlo por consola. Para esto es necesario configurar un '''stdout-channel-adapter''', el cual se encargará de procesar los mensajes. Luego, se crea un '''bridge''' que asocia un canal de entrada con este adaptador.

<code xml>
<stream:stdout-channel-adapter id="stdout" append-newline="true"/>
<integration:bridge id="echo" input-channel="QueueChanneIn" output-channel="stdout"/>
</code>

===recipient-list-router===
Podemos consumir un mensaje de una cola y enviarlo a una lista fija de canales de destino. En este ejemplo creamos un '''recipient-list-router''', el cual consume mensajes de un canal de entrada y los envia a dos canales de destino distintos. Entonces, cada mensaje que llegue al canal de entrada será derivado a dos canales de destino.

<code xml>
<integration:recipient-list-router input-channel="QueueChanneIn" apply-sequence="true">
<integration:recipient channel="QueueChanneOut1"/>
<integration:recipient channel="QueueChanneOut2"/>
</integration:recipient-list-router>
</code>

===header-value-router===
Podemos consumir un mensaje de una cola y enviarlo a una cola especifica dependiendo del valor de un atributo del header del mensaje. De esta manera, configuramos un '''header-value-router''', el cual contiene el canal de entrada y el nombre del atributo del encabezado que se comprobará. Luego, se realiza el mapeo entre los posibles valores de este encabezado y algún canal de destino. Si llega un mensaje que coincida este mapeo, será enviado a ese canal de destino.

<code xml>
<integration:header-value-router input-channel="QueueChanneIn"
header-name="springintegration_jms_type">
<integration:mapping value="Out1" channel="QueueChanneOut1"/>
<integration:mapping value="Out2" channel="QueueChanneOut2"/>
</integration:header-value-router>
</code>

===router===
Podemos consumir un mensaje de una cola y enviarlo a una lista de colas de salida utilizando un pojo para determinar a que colas enviarlo. En este ejemplo, creamos un '''router''' que será implementado por la clase "MultiDestino". Esta clase devuelve una lista de nombres de canales hacia donde se derivará el mensaje.

<code xml>
<integration:router input-channel="QueueChanneIn" ref="multiDestino"/>
<bean id="multiDestino" class="com.dosideas.springintegration.MultiDestino"/>
</code>

<code java>
public class MultiDestino {

@Router
public List<String> resolverChannel(GenericMessage message) throws JMSException {

List<String> list = new ArrayList<String>();
if(message.getHeaders().get("springintegration_jms_type").equals("Out1")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");

}
else if(message.getHeaders().get("springintegration_jms_type").equals("Out2")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut2");
}
else if(message.getHeaders().get("springintegration_jms_type").equals("Multi")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");
list.add("QueueChanneOut2");
}

return list;
}
}
</code>

==Ver también==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=29%3Ap Descargar un proyecto con varios ejemplos de Spring Integration]
* [http://static.springsource.org/spring-integration/reference/htmlsingle/spring-integration-reference.html Manual de referencia de Spring Integration]

[[Category:Spring Framework]]
[[Category:JMS]]

Spring Integration

2011-07-07T14:09:55Z

201.251.185.130: /* Adaptadores */

[http://www.springsource.org/spring-integration Spring Integration] es un producto relativamente desconocido del Spring.
Brinda una extensión a Spring para soportar los [http://www.eaipatterns.com/ Patrones de Integración Corporativos] en pocas palabras es un [http://en.wikipedia.org/wiki/Enterprise_service_bus ESB] liviano montado sobre el contenedor de Spring e independiente del Servidor de aplicaciones. Permite utilizar mensajería dentro de una aplicación Spring, y se integra con sistemas externos a través de adaptadores. Se basa en el concepto de "mensajes" para intercambiar datos entre distintos componentes.

==Conceptos y componentes básicos==

===Conceptos===

* '''Channel (MessageChannel)''', representa un canal lógico por donde se reciben o se envían mensajes.

* '''Channel-adapter''', representa el adaptador entre el canal lógico y una implementación física de ese canal.

* '''Bridge''', se encarga de redireccionar todos los mensajes del canal de entrada hacia un canal de salida.

* '''Router''', se encarga de redireccionar los mensajes que llegan a un canal de entrada hacia uno o varios canales de salida, dependiendo de ciertas condiciones.

* '''Splitter''', se encarga de separar el contenido de un mensaje en muchos mensajes.

* '''Transformer''', se encarga de transformar el formato del contenido del mensaje.

===Componentes===

* '''Message''', esta compuesto por una cabecera (headers) y por un cuerpo (Payload).

* '''MessageChannel''', provee métodos para enviar y recibir.

* '''MessageEndpoint''', Conecta un Handler a un MessageChannel de entrada o/y a uno de salida.

* '''MessageHandler''', interfaz que permite transformer, rutear y en general “tartar” cualquier mensaje de Entrada.

* '''Channel Adapters''', se usan para enviar y recibir mensajes a sistemas externos.

==Adaptadores==

* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ip TCP y UDP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#http HTTP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#feed RSS/ATOM]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ws Web Services]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#mail Mail (POP3, IMAP, SMTP)]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jms JMS]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jdbc JDBC]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jmx JMX]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#rmi RMI]

== Aplicaciones demo ==

[http://dosideas-aplicaciones-modelo.googlecode.com/svn/spring-integration-demo/trunk Descarga] con svn nuestra demo, es un proyecto Maven con ejemplos de algunos de los adaptadores más utilizados.

{{curso|url=http://www.dosideas.com/cursos/course/view.php?id=12|nombre=Introducción a Spring Integration}}

== Ejemplos ==

=== Configuración de canales ===
[[Spring Integration]] se basa en ''canales'', lugares en donde se consumen o envian mensajes. Estos canales pueden ser colas [[JMS]] u otros medios, como clases propias. La siguiente definición de canales se usa en los ejemplos que siguen.

<code xml>
<integration:channel id="QueueChanneIn"/>

<jms:message-driven-channel-adapter connection-factory="PruebaQueueConnectionFactory"
destination-name="jms/Queue-in" destination-resolver="jmsDestinationResolver"
channel="QueueChanneIn" acknowledge="auto" concurrent-consumers="1"/>

<integration:channel id="QueueChanneOut1"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut1" channel="QueueChanneOut1"/>

<integration:channel id="QueueChanneOut2"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut2" channel="QueueChanneOut2"/>
</code>

===stdout-channel-adapter===
Podemos consumir un mensaje de una cola y mostrarlo por consola. Para esto es necesario configurar un '''stdout-channel-adapter''', el cual se encargará de procesar los mensajes. Luego, se crea un '''bridge''' que asocia un canal de entrada con este adaptador.

<code xml>
<stream:stdout-channel-adapter id="stdout" append-newline="true"/>
<integration:bridge id="echo" input-channel="QueueChanneIn" output-channel="stdout"/>
</code>

===recipient-list-router===
Podemos consumir un mensaje de una cola y enviarlo a una lista fija de canales de destino. En este ejemplo creamos un '''recipient-list-router''', el cual consume mensajes de un canal de entrada y los envia a dos canales de destino distintos. Entonces, cada mensaje que llegue al canal de entrada será derivado a dos canales de destino.

<code xml>
<integration:recipient-list-router input-channel="QueueChanneIn" apply-sequence="true">
<integration:recipient channel="QueueChanneOut1"/>
<integration:recipient channel="QueueChanneOut2"/>
</integration:recipient-list-router>
</code>

===header-value-router===
Podemos consumir un mensaje de una cola y enviarlo a una cola especifica dependiendo del valor de un atributo del header del mensaje. De esta manera, configuramos un '''header-value-router''', el cual contiene el canal de entrada y el nombre del atributo del encabezado que se comprobará. Luego, se realiza el mapeo entre los posibles valores de este encabezado y algún canal de destino. Si llega un mensaje que coincida este mapeo, será enviado a ese canal de destino.

<code xml>
<integration:header-value-router input-channel="QueueChanneIn"
header-name="springintegration_jms_type">
<integration:mapping value="Out1" channel="QueueChanneOut1"/>
<integration:mapping value="Out2" channel="QueueChanneOut2"/>
</integration:header-value-router>
</code>

===router===
Podemos consumir un mensaje de una cola y enviarlo a una lista de colas de salida utilizando un pojo para determinar a que colas enviarlo. En este ejemplo, creamos un '''router''' que será implementado por la clase "MultiDestino". Esta clase devuelve una lista de nombres de canales hacia donde se derivará el mensaje.

<code xml>
<integration:router input-channel="QueueChanneIn" ref="multiDestino"/>
<bean id="multiDestino" class="com.dosideas.springintegration.MultiDestino"/>
</code>

<code java>
public class MultiDestino {

@Router
public List<String> resolverChannel(GenericMessage message) throws JMSException {

List<String> list = new ArrayList<String>();
if(message.getHeaders().get("springintegration_jms_type").equals("Out1")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");

}
else if(message.getHeaders().get("springintegration_jms_type").equals("Out2")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut2");
}
else if(message.getHeaders().get("springintegration_jms_type").equals("Multi")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");
list.add("QueueChanneOut2");
}

return list;
}
}
</code>

==Ver también==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=29%3Ap Descargar un proyecto con varios ejemplos de Spring Integration]
* [http://static.springsource.org/spring-integration/reference/htmlsingle/spring-integration-reference.html Manual de referencia de Spring Integration]

[[Category:Spring Framework]]
[[Category:JMS]]

Spring Integration

2011-07-07T13:55:43Z

201.251.185.130:

[http://www.springsource.org/spring-integration Spring Integration] es un producto relativamente desconocido del Spring.
Brinda una extensión a Spring para soportar los [http://www.eaipatterns.com/ Patrones de Integración Corporativos] en pocas palabras es un [http://en.wikipedia.org/wiki/Enterprise_service_bus ESB] liviano montado sobre el contenedor de Spring e independiente del Servidor de aplicaciones. Permite utilizar mensajería dentro de una aplicación Spring, y se integra con sistemas externos a través de adaptadores. Se basa en el concepto de "mensajes" para intercambiar datos entre distintos componentes.

==Conceptos y componentes básicos==

===Conceptos===

* '''Channel (MessageChannel)''', representa un canal lógico por donde se reciben o se envían mensajes.

* '''Channel-adapter''', representa el adaptador entre el canal lógico y una implementación física de ese canal.

* '''Bridge''', se encarga de redireccionar todos los mensajes del canal de entrada hacia un canal de salida.

* '''Router''', se encarga de redireccionar los mensajes que llegan a un canal de entrada hacia uno o varios canales de salida, dependiendo de ciertas condiciones.

* '''Splitter''', se encarga de separar el contenido de un mensaje en muchos mensajes.

* '''Transformer''', se encarga de transformar el formato del contenido del mensaje.

===Componentes===

* '''Message''', esta compuesto por una cabecera (headers) y por un cuerpo (Payload).

* '''MessageChannel''', provee métodos para enviar y recibir.

* '''MessageEndpoint''', Conecta un Handler a un MessageChannel de entrada o/y a uno de salida.

* '''MessageHandler''', interfaz que permite transformer, rutear y en general “tartar” cualquier mensaje de Entrada.

* '''Channel Adapters''', se usan para enviar y recibir mensajes a sistemas externos.

==Adaptadores==

* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ip TCP y UDP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#http HTTP]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#feed RSS/ATOM]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#ws Web Services]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#mail Mail (POP3, IMAP, SMTP)]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jms JMS]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jdbc JDBC]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#jmx JMX]
* [http://static.springsource.org/spring-integration/docs/2.0.4.RELEASE/reference/htmlsingle/#rmi RMI]

{{curso|url=http://www.dosideas.com/cursos/course/view.php?id=12|nombre=Introducción a Spring Integration}}

== Ejemplos ==

=== Configuración de canales ===
[[Spring Integration]] se basa en ''canales'', lugares en donde se consumen o envian mensajes. Estos canales pueden ser colas [[JMS]] u otros medios, como clases propias. La siguiente definición de canales se usa en los ejemplos que siguen.

<code xml>
<integration:channel id="QueueChanneIn"/>

<jms:message-driven-channel-adapter connection-factory="PruebaQueueConnectionFactory"
destination-name="jms/Queue-in" destination-resolver="jmsDestinationResolver"
channel="QueueChanneIn" acknowledge="auto" concurrent-consumers="1"/>

<integration:channel id="QueueChanneOut1"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut1" channel="QueueChanneOut1"/>

<integration:channel id="QueueChanneOut2"/>
<jms:outbound-channel-adapter jms-template="jmsQueueTemplateOut2" channel="QueueChanneOut2"/>
</code>

===stdout-channel-adapter===
Podemos consumir un mensaje de una cola y mostrarlo por consola. Para esto es necesario configurar un '''stdout-channel-adapter''', el cual se encargará de procesar los mensajes. Luego, se crea un '''bridge''' que asocia un canal de entrada con este adaptador.

<code xml>
<stream:stdout-channel-adapter id="stdout" append-newline="true"/>
<integration:bridge id="echo" input-channel="QueueChanneIn" output-channel="stdout"/>
</code>

===recipient-list-router===
Podemos consumir un mensaje de una cola y enviarlo a una lista fija de canales de destino. En este ejemplo creamos un '''recipient-list-router''', el cual consume mensajes de un canal de entrada y los envia a dos canales de destino distintos. Entonces, cada mensaje que llegue al canal de entrada será derivado a dos canales de destino.

<code xml>
<integration:recipient-list-router input-channel="QueueChanneIn" apply-sequence="true">
<integration:recipient channel="QueueChanneOut1"/>
<integration:recipient channel="QueueChanneOut2"/>
</integration:recipient-list-router>
</code>

===header-value-router===
Podemos consumir un mensaje de una cola y enviarlo a una cola especifica dependiendo del valor de un atributo del header del mensaje. De esta manera, configuramos un '''header-value-router''', el cual contiene el canal de entrada y el nombre del atributo del encabezado que se comprobará. Luego, se realiza el mapeo entre los posibles valores de este encabezado y algún canal de destino. Si llega un mensaje que coincida este mapeo, será enviado a ese canal de destino.

<code xml>
<integration:header-value-router input-channel="QueueChanneIn"
header-name="springintegration_jms_type">
<integration:mapping value="Out1" channel="QueueChanneOut1"/>
<integration:mapping value="Out2" channel="QueueChanneOut2"/>
</integration:header-value-router>
</code>

===router===
Podemos consumir un mensaje de una cola y enviarlo a una lista de colas de salida utilizando un pojo para determinar a que colas enviarlo. En este ejemplo, creamos un '''router''' que será implementado por la clase "MultiDestino". Esta clase devuelve una lista de nombres de canales hacia donde se derivará el mensaje.

<code xml>
<integration:router input-channel="QueueChanneIn" ref="multiDestino"/>
<bean id="multiDestino" class="com.dosideas.springintegration.MultiDestino"/>
</code>

<code java>
public class MultiDestino {

@Router
public List<String> resolverChannel(GenericMessage message) throws JMSException {

List<String> list = new ArrayList<String>();
if(message.getHeaders().get("springintegration_jms_type").equals("Out1")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");

}
else if(message.getHeaders().get("springintegration_jms_type").equals("Out2")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut2");
}
else if(message.getHeaders().get("springintegration_jms_type").equals("Multi")) {
System.out.println(message.getHeaders().get("springintegration_jms_type"));
list.add("QueueChanneOut1");
list.add("QueueChanneOut2");
}

return list;
}
}
</code>

==Ver también==
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=29%3Ap Descargar un proyecto con varios ejemplos de Spring Integration]
* [http://static.springsource.org/spring-integration/reference/htmlsingle/spring-integration-reference.html Manual de referencia de Spring Integration]

[[Category:Spring Framework]]
[[Category:JMS]]

Mock de un servidor de correo smtp con Wiser

2011-07-06T12:16:47Z

201.251.185.130: /* El test con JUnit y Wiser */

En el siguiente ejemplo de código se muestra una clase que envía un mail usando la API de JavaMail. Luego, un Test de [[JUnit]] prueba esta clase levantando el servidor de mail [[Wiser]] en memoria y verificando que el mail haya llegado correctamente.

== La clase que manda mails ==

<code java="java">
package com.dosideas.smtp;

import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
* Clase que envía un email.
*/
public class MandaMail {

public void enviarMail(String mailOrigen, String mailDestinatario, String asunto, String textoMensaje)
throws AddressException, MessagingException {

//se puede poner en true para ver la interaccion del protocolo smtp por stdout.
boolean debug = false;

//setea el host y puerto donde esta el servidor de mail.
Properties props = new Properties();
props.put("mail.smtp.host", "localhost");
props.put("mail.smtp.port", 25);

Session session = Session.getDefaultInstance(props, null);
session.setDebug(debug);

// create a message
Message msg = new MimeMessage(session);

// set the from and to address
InternetAddress addressFrom = new InternetAddress(mailOrigen);
msg.setFrom(addressFrom);

InternetAddress addressTo = new InternetAddress(mailDestinatario);
msg.setRecipient(Message.RecipientType.TO, addressTo);

// Setting the Subject and Content Type
msg.setSubject(asunto);
msg.setContent(textoMensaje, "text/plain");
Transport.send(msg);
}
}

</code>

== El test con JUnit y Wiser ==

El siguiente test utiliza la clase anterior para maquetar el [[Servidor SMTP]].

<code java="java">
package com.dosideas.smtp;

import javax.mail.internet.MimeMessage;
import org.subethamail.wiser.WiserMessage;
import org.subethamail.wiser.Wiser;
import java.util.Iterator;
import org.junit.Test;
import static org.junit.Assert.*;

/**
* Test de envio de mail con Junit y Dumbster
*/
public class MandaMailTest {

private Wiser smtpServer;

@Before
public void startSmtpServer() {
smtpServer = new Wiser();
smtpServer.setPort(25);
smtpServer.start();
}

@After
public void stopSmtpServer() {
smtpServer.stop();
}

@Test
public void testEnviarMail() throws Exception {

MandaMail instance = new MandaMail();

String mailDestinatario = "destinatario@dosideas.com";
String mailOrigen = "origen@dosideas.com";
String asunto = "Asunto del mail de prueba";
String textoMensaje = "Este es un mail para probar el servidor de Wiser";

try {
//envia el mail.
instance.enviarMail(mailOrigen, mailDestinatario, asunto, textoMensaje);
} catch (Exception e) {
e.printStackTrace();
fail("Unexpected exception: " + e);
}

//verifica que se obtenga el mail y que tenga los datos enviados.
assertTrue(smtpServer.getMessages().size() == 1);
Iterator emailIter = smtpServer.getMessages().iterator();
WiserMessage email = (WiserMessage) emailIter.next();
MimeMessage mmessage = email.getMimeMessage();
assertTrue(mmessage.getSubject().equals(asunto));
assertTrue(email.getEnvelopeSender().equals(mailOrigen));
assertTrue(email.getEnvelopeReceiver().equals(mailDestinatario));
assertTrue(mmessage.getContent().toString().equals(textoMensaje));

//muestra el contenido
System.out.println("Mensaje recibido en servidor Wiser:");
System.out.println("--------------------------------------");
System.out.println("De: " + email.getEnvelopeSender());
System.out.println("Para: " + email.getEnvelopeReceiver());
System.out.println("Asunto: " + mmessage.getSubject());
System.out.println("Contenido: " + mmessage.getContent());
}
}
</code>

== Ver también ==

*[[Wiser]]
*[[Dumbster]]
*[[Mock Object]]
*[[Jetty]]

[[Category:Java]] [[Category:TDD]] [[Category:JUnit]]

Mock de un servidor de correo smtp con Wiser

2011-07-06T12:16:27Z

201.251.185.130:

En el siguiente ejemplo de código se muestra una clase que envía un mail usando la API de JavaMail. Luego, un Test de [[JUnit]] prueba esta clase levantando el servidor de mail [[Wiser]] en memoria y verificando que el mail haya llegado correctamente.

== La clase que manda mails ==

<code java="java">
package com.dosideas.smtp;

import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
* Clase que envía un email.
*/
public class MandaMail {

public void enviarMail(String mailOrigen, String mailDestinatario, String asunto, String textoMensaje)
throws AddressException, MessagingException {

//se puede poner en true para ver la interaccion del protocolo smtp por stdout.
boolean debug = false;

//setea el host y puerto donde esta el servidor de mail.
Properties props = new Properties();
props.put("mail.smtp.host", "localhost");
props.put("mail.smtp.port", 25);

Session session = Session.getDefaultInstance(props, null);
session.setDebug(debug);

// create a message
Message msg = new MimeMessage(session);

// set the from and to address
InternetAddress addressFrom = new InternetAddress(mailOrigen);
msg.setFrom(addressFrom);

InternetAddress addressTo = new InternetAddress(mailDestinatario);
msg.setRecipient(Message.RecipientType.TO, addressTo);

// Setting the Subject and Content Type
msg.setSubject(asunto);
msg.setContent(textoMensaje, "text/plain");
Transport.send(msg);
}
}

</code>

== El test con JUnit y Wiser ==

El siguiente test utiliza la clase anterior para maquetar el [[Servidor SMTP]].

<code java="java">
package com.dosideas.smtp;

import javax.mail.internet.MimeMessage;
import org.subethamail.wiser.WiserMessage;
import org.subethamail.wiser.Wiser;
import java.util.Iterator;
import org.junit.Test;
import static org.junit.Assert.*;

/**
* Test de envio de mail con Junit y Dumbster
*/
public class MandaMailTest {

private Wiser smtpServer;

@Before
public void startSmtpServer() {
smtpServer = new Wiser();
smtpServer.setPort(9580);
smtpServer.start();
}

@After
public void stopSmtpServer() {
smtpServer.stop();
}

@Test
public void testEnviarMail() throws Exception {

MandaMail instance = new MandaMail();

String mailDestinatario = "destinatario@dosideas.com";
String mailOrigen = "origen@dosideas.com";
String asunto = "Asunto del mail de prueba";
String textoMensaje = "Este es un mail para probar el servidor de Wiser";

try {
//envia el mail.
instance.enviarMail(mailOrigen, mailDestinatario, asunto, textoMensaje);
} catch (Exception e) {
e.printStackTrace();
fail("Unexpected exception: " + e);
}

//verifica que se obtenga el mail y que tenga los datos enviados.
assertTrue(smtpServer.getMessages().size() == 1);
Iterator emailIter = smtpServer.getMessages().iterator();
WiserMessage email = (WiserMessage) emailIter.next();
MimeMessage mmessage = email.getMimeMessage();
assertTrue(mmessage.getSubject().equals(asunto));
assertTrue(email.getEnvelopeSender().equals(mailOrigen));
assertTrue(email.getEnvelopeReceiver().equals(mailDestinatario));
assertTrue(mmessage.getContent().toString().equals(textoMensaje));

//muestra el contenido
System.out.println("Mensaje recibido en servidor Wiser:");
System.out.println("--------------------------------------");
System.out.println("De: " + email.getEnvelopeSender());
System.out.println("Para: " + email.getEnvelopeReceiver());
System.out.println("Asunto: " + mmessage.getSubject());
System.out.println("Contenido: " + mmessage.getContent());
}
}
</code>

== Ver también ==

*[[Wiser]]
*[[Dumbster]]
*[[Mock Object]]
*[[Jetty]]

[[Category:Java]] [[Category:TDD]] [[Category:JUnit]]

Mock de un servidor de correo smtp con Wiser

2011-07-06T12:15:14Z

201.251.185.130: /* El test con JUnit */

En el siguiente ejemplo de código se muestra una clase que envía un mail usando la API de JavaMail.
Luego, un Test de Junit prueba esta clase levantando el servidor de mail [[Wiser]] en memoria y verificando que el mail haya llegado correctamente.

<code java="java">
package com.dosideas.smtp;

import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
* Clase que envía un email.
*/
public class MandaMail {

public void enviarMail(String mailOrigen, String mailDestinatario, String asunto, String textoMensaje)
throws AddressException, MessagingException {

//se puede poner en true para ver la interaccion del protocolo smtp por stdout.
boolean debug = false;

//setea el host y puerto donde esta el servidor de mail.
Properties props = new Properties();
props.put("mail.smtp.host", "localhost");
props.put("mail.smtp.port", 25);

Session session = Session.getDefaultInstance(props, null);
session.setDebug(debug);

// create a message
Message msg = new MimeMessage(session);

// set the from and to address
InternetAddress addressFrom = new InternetAddress(mailOrigen);
msg.setFrom(addressFrom);

InternetAddress addressTo = new InternetAddress(mailDestinatario);
msg.setRecipient(Message.RecipientType.TO, addressTo);

// Setting the Subject and Content Type
msg.setSubject(asunto);
msg.setContent(textoMensaje, "text/plain");
Transport.send(msg);
}
}

</code>

== El test con JUnit ==

El siguiente test utiliza la clase anterior para maquetar el [[Servidor SMTP]].

<code java="java">
package com.dosideas.smtp;

import javax.mail.internet.MimeMessage;
import org.subethamail.wiser.WiserMessage;
import org.subethamail.wiser.Wiser;
import java.util.Iterator;
import org.junit.Test;
import static org.junit.Assert.*;

/**
* Test de envio de mail con Junit y Dumbster
*/
public class MandaMailTest {

private Wiser smtpServer;

@Before
public void startSmtpServer() {
smtpServer = new Wiser();
smtpServer.setPort(9580);
smtpServer.start();
}

@After
public void stopSmtpServer() {
smtpServer.stop();
}

@Test
public void testEnviarMail() throws Exception {

MandaMail instance = new MandaMail();

String mailDestinatario = "destinatario@dosideas.com";
String mailOrigen = "origen@dosideas.com";
String asunto = "Asunto del mail de prueba";
String textoMensaje = "Este es un mail para probar el servidor de Wiser";

try {
//envia el mail.
instance.enviarMail(mailOrigen, mailDestinatario, asunto, textoMensaje);
} catch (Exception e) {
e.printStackTrace();
fail("Unexpected exception: " + e);
}

//verifica que se obtenga el mail y que tenga los datos enviados.
assertTrue(smtpServer.getMessages().size() == 1);
Iterator emailIter = smtpServer.getMessages().iterator();
WiserMessage email = (WiserMessage) emailIter.next();
MimeMessage mmessage = email.getMimeMessage();
assertTrue(mmessage.getSubject().equals(asunto));
assertTrue(email.getEnvelopeSender().equals(mailOrigen));
assertTrue(email.getEnvelopeReceiver().equals(mailDestinatario));
assertTrue(mmessage.getContent().toString().equals(textoMensaje));

//muestra el contenido
System.out.println("Mensaje recibido en servidor Wiser:");
System.out.println("--------------------------------------");
System.out.println("De: " + email.getEnvelopeSender());
System.out.println("Para: " + email.getEnvelopeReceiver());
System.out.println("Asunto: " + mmessage.getSubject());
System.out.println("Contenido: " + mmessage.getContent());
}
}
</code>

== Ver también ==

*[[Wiser]]
*[[Dumbster]]
*[[Mock Object]]
*[[Jetty]]

[[Category:Java]] [[Category:TDD]] [[Category:JUnit]]

Wiser

2011-07-06T12:12:40Z

201.251.185.130:

[[Wiser]] es un proyecto de [[Software Libre]] que permite generar [[Mock Object]] de un servidor de mail SMTP.

Permite realizar Tests con Junit en los que se pueden enviar y obtener mails de este servidor de correo mock.

== Ver también ==
* [[Mock de un servidor de correo smtp con Wiser]]
* [http://code.google.com/p/subethasmtp/ Sitio oficial de Wiser]

[[Category:Java]] [[Category:TDD]] [[Category:JUnit]]

GlassFish

2011-07-01T18:59:18Z

201.251.185.130:

GlassFish es un [[Servidor de Aplicaciones]] para [[Java EE]] libre de código abierto, apoyado por Sun. Usualmente GlassFish es uno de los primeros Servidores de aplicaciones en soportar las últimas novedades de [[Java EE]].

== Librerías cliente ==
Para acceder a EJBs y otros recursos del Application Server, un cliente standalone necesita las siguientes librerias (que se encuentran en el directorio ''lib/'' de GlassFish):
* j2ee.jar
* appserv-rt.jar
* appserv-deployment-client.jar
* appserv-ext.jar

En el caso de que los EJBs estén en GlassFish 3, deben agregarse las siguientes librerías (que se encuentran en el directorio ''glassfish\modules'' de GlassFish):
*javax.ejb.jar
*ejb-container.jar
*deployment-common.jar
*dol.jar
*glassfish-corba-csiv2-idl.jar
*glassfish-corba-codegen.jar
*ssl-impl.jar
*security.jar
*ejb.security.jar
*management-api.jar
*gmbal.jar
*glassfish-corba-asm.jar
*glassfish-corba-newtimer.jar
*glassfish-corba-orbgeneric.jar
*bean-validator.jar
*config-types.jar
*kernel.jar
*config.jar
*config-api.jar
*glassfish-corba-omgapi.jar
*glassfish-corba-orb.jar
*orb-connector.jar
*orb-enabler.jar
*orb-iiop.jar
*glassfish-api.jar
*auto-depends.jar
*hk2-core.jar
*internal-api.jar
*common-util.jar
*glassfish-corba-internal-api.jar
*glassfish-naming.jar

Luego el contexto para hacer el lookup se obtiene haciendo:

<code java>

Properties jndiProps = new Properties();
jndiProps.put("java.naming.factory.initial", "com.sun.enterprise.naming.impl.SerialInitContextFactory");
jndiProps.put("java.naming.factory.url.pkgs", "com.sun.enterprise.naming");
jndiProps.put("java.naming.factory.state", "com.sun.corba.ee.impl.presentation.rmi.JNDIStateFactoryImpl");

// puerto e ip por defecto
jndiProps.setProperty("org.omg.CORBA.ORBInitialHost", "localhost");
jndiProps.setProperty("org.omg.CORBA.ORBInitialPort", "3700");
InitialContext initialContext = new InitialContext(jndiProps);
</code>

== Breve resumen de uso ==

Hi:

I have been observing demetole.wordpress.com as a lurker for some time now.
I made a decision that I need to get involved and socialize with the people here.
I'm expecting to hook up with a lot of wonderful persons and learn some awesome stuff.

Hopefully this message didn't find itself in an inappropriate area. I'm hoping you'll forgive me if this is unsuitable.

--------------------

DONN SCHWARTZ
Home Economics Teacher

=== Iniciar GlassFish ===

asadmin start-domain

GlassFish inicia, y puede cerrarse la consola donde se ejecutó este comando.

=== Configurar GlassFish (consola de administración) ===

Una vez iniciado, la consola de administración de GlassFish se puede acceder desde:

http://localhost:4848
'''usuario''': admin
'''password''': adminadmin

Desde esta consola pueden administrarse las aplicaciones (deploys/redeploys/undeploys) y configurar los ConnectionPool y DataSource.

=== Acceder a aplicaciones instaladas ===

Por default, GlassFish expone las aplicaciones web en el puerto 8080. Por ejemplo, para acceder a la aplicación web "miAplicacion":

http://localhost:8080/miAplicacion

=== Detener GlassFish ===

asadmin stop-domain

=== Crear un dominio nuevo ===

asadmin create-domain --adminport 4848 domain2

== Integración con CentOS / Fedora y otros Linux ==
[[GlassFish]] se inicia desde la línea de comandos, por lo cual es muy facil integrarlo con los sistemas de servicios que ofrecen las distintas distribuciones de Linux.

Para integrarlo con CentOS / Fedora / RedHat Linux, ubicar el siguiente script en '''/etc/init.d/glassfish'''
<pre>
#!/bin/bash
#
# glassfish Este script se encarga de iniciar y detener el
# servidor de aplicaciones Java GlassFish v3.
#

# Source function library.
. /etc/init.d/functions

prog="GlassFish v3"
asadmin="/usr/local/glassfishv3/bin/asadmin"

# Esta variable la usa GlassFish para determinar el JDK a usar.
# Habra otra manera?
export AS_JAVA=/usr/local/jdk1.6.0_18/

start() {
action $"Starting $prog: " $asadmin start-domain
}
stop() {
action $"Stopping $prog: " $asadmin stop-domain
}
restart() {
action $"Restarting $prog: " $asadmin restart-domain
}

case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
*)
echo $"Usage: $0 {start|stop|restart}"
exit 2
esac

exit $?
</pre>

Luego, podemos ejecutar los siguentes comandos desde la consola de Linux para iniciar/detener [[GlassFish]]
service glassfish start
service glassfish stop

== Ver también ==
* [[Servidor de Aplicaciones]]
* [https://glassfish.dev.java.net/ Web oficial de GlassFish]
* [https://glassfish.dev.java.net/downloads/quickstart/index.html GlassFish Quick Start]
* [https://glassfish.dev.java.net/public/downloadsindex.html Descarga de GlassFish ]
* [https://glassfishplugins.dev.java.net/eclipse33/index.html Plugin de Glassfish para Eclipse]

[[Category:GlassFish]]

Hibernate Con Spring

2011-06-17T17:29:43Z

201.251.185.130: /* La clase HibernateDaoSupport */

[[Category:Spring Framework]]
[[Category:Hibernate]]
[[Spring Framework]] provee amplio soporte para [[Hibernate]]. En particular, brinda implementaciones de [[DAO]] que ofrecen diversas utilidades para acceder a la session de Hibernate.

==La clase HibernateDaoSupport==

Spring nos provee la clase ''HibernateDaoSupport'' para brindarle a nuestros DAO soporte para Hibernate.

'''Importante:''' ¡Esta clase está obsoleta y no debería utilizarse!. En cambio, crear un DAO común e inyectar el '''SessionFactory''' de Hibernate directamente, para utilizar.

=== HibernateTemplate ===

En particular, '''uno de los métodos''' más útiles que provee es ''getHibernateTemplate()''. Este método devuelve un template con varios métodos útiles, que simplifican el uso de Hibernate. Estos métodos suelen encapsular varias excepciones propias de acceso a datos de Hibernate (y SQL) dentro de una ''DataAccessException'' (que hereda de RuntimeException).

===Creando un DAO con soporte de Spring===
La forma más simple de usar Hibernate con Spring es crear clases que hereden de !HibernateDaoSupport. Esta clase ofrece varias utilidades para manipular la session de Hibernate, y se encarga de manejar automáticamente las transacciones.

==== La interfaz del DAO ====
La interfaz de nuestro DAO es simple, y no necesita tener ninguna herencia ni restricción en particular:
<code java>
public interface InvasorDao {
guardarInvasor(Invasor invasor);
}
</code>

==== La implementación del DAO ====
La implementación del DAO deberá extender !HibernateDaoSupport. Esta clase nos proveerá de varios métodos útiles para manipular la session de Hibernate.
<code java>
public class InvasorDaoImpl extends HibernateDaoSupport implements InvasorDao {
public void guardarInvasor(Invasor invasor) {
getHibernateTemplate().save(invasor);
}
}
</code>

==== La declaracion del Dao ====
En el XML de Spring deberemos declarar el Dao y la Factory de Hibernate. Al Dao se le asocia el factory de Hibernate del cual Spring sacará la session de Hibernate.
<code xml>
<bean id="dao.InvasorDao" class="com.dosideas.dao.impl.InvasorDaoImpl">
<property name="sessionFactory" ref="defaultSessionFactory"/>
</bean>

<bean id="defaultSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="defaultDataSource" />
<property name="mappingResources">
<list>

<value>com/dosideas/domain/map/Invasor.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
</props>
</property>
</bean>
</code>

===Uso de la Session directamente===
Es posible utilizar la Session de Hibernate directamente, a través del método ''getSession()'' que provee HibernateDaoSupport. Cuando se pide la Session de esta manera, es fundamental

<code java>
Session session = null;
try {
session = getSession();
//hacer cosas...
}
finally {
releaseSession(session);
}
</code>

== Configuración con anotaciones ==
Hibernate puede configurarse con anotaciones en vez de archivos XML para definir los mapeos. Para esto usamos la clase de Spring '''AnnotationSessionFactoryBean'''.
<code xml>
<beans>

<bean id="defaultSessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="defaultDataSource" />
<property name="annotatedClasses">
<list>

<value>com.dosideas.domain.MiClaseDeDominio</value>
</list>

</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>

</beans>
</code>

Y la clase de dominio anotada como corresponde:

<code java5>
package com.dosideas.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "TABLA_DE_ORIGEN")
public class MiClaseDeDominio {
@Id
@Column(name = "COLUMNA_PK")
private String clase;

@Column(name = "NOMBRE")
private String nombre;

//getters y setters...
}
</code>

==Ver también==
* [[Consultas Con HibernateTemplate]]
* [http://static.springframework.org/spring/docs/2.0.x/reference/orm.html Manual de Spring, Capítulo 12]

EJB

2011-06-16T18:34:22Z

201.251.185.130: /* Testeo de los EJB */

[[Category:EJB]]
Los Enterprise Java Beans (también conocidos por sus siglas EJB) son una de las API que forman parte del estándar de construcción de aplicaciones empresariales [[Java EE]]. Su especificación detalla cómo un [[Servidor de Aplicaciones]] provee objetos desde el lado del servidor que son, precisamente, los EJBs:

* comunicación remota utilizando CORBA
* transacciones
* control de la concurrencia
* eventos utilizando JMS (Java messaging service)
* servicios de nombres y de directorio
* seguridad
* ubicación de componentes en un servidor de aplicaciones.

La especificación de Enterprise Java Bean define los papeles jugados por el contenedor de EJB y los EJBs, además de disponer los EJBs en un contenedor.

==Tipos de EJB==
Actualmente, en la especificación 3.0 de EJB, existen 2 tipos principales de EJB:
*'''Session Beans'''
** Stateful Session Beans, son objetos distribuidos que mantienen estado. Pueden ser utilizados, por ejemplo, para mantener los items de un carrito de compras.
** Stateless Session Beans, son objetos distribuidos que no mantienen estado, lo que permite que sean invocados de manera concurrente. Suelen exponer lógica de negocio.

[[Message Driven Bean]], son objetos distribuidos que se asocian a destinos JMS y se invocan asincrónicamente al momento de la llegada de un mensaje al destino.

En la versión 2.x de EJB existía un tercer tipo: '''Entity Beans''', que eran objetos distribuidos para la persistencia de datos en una [[Base De Datos]]. Estos objetos fueron reemplazados en la versión 3.0 por la JavaPersistenceApi.

==Testeo de los EJB==
Como los EJB se ejecutan dentro de un [[Servidor de Aplicaciones]], puede resultar dificil su testeo, en particular la PruebaUnitaria. Existen algunos frameworks para poder testear unitariamente a los EJB:
* [[MockEjb]]
* [[Cactus]]

==Ver también==
* [[JMS]]
* [[Message Driven Bean]]
* [[Ejb Con Spring]]
* [[Timer Service En EJB]]
* [http://es.wikipedia.org/wiki/Enterprise_JavaBeans EJB en la Wikipedia]

Configuración de ejecución selectiva de tests

2011-05-02T18:23:49Z

201.251.185.130:

Para poder correr selectivamente los test de integración de nuestras aplicaciones utilizamos la funcionalidad provista por la clase Assume de [[JUnit]]. La clase Assume contiene métodos útiles para afirmar las hipótesis sobre las condiciones en las que los resultados de los test son significativos. Un supuesto negativo no significa que el código está roto, pero si que los resultados de los test no proporciona ninguna información útil. Por defecto [[JUnit]] trata los test con las hipótesis negativas como ignorados.

Para el caso de proyectos creados con [[NetBeans]] compilados con [[Ant]], podemos indicar si queremos o no correr determinados test usando ciertas propiedades.

Propiedad:

-Dtest-sys-prop.correrIntegracion=NO

<code java5>

@BeforeClass
public static void setUpOnce() throws Throwable {
System.out.println("Se usarán los test de integración [SI/NO]: " + System.getProperty("correrIntegracion"));
Assume.assumeTrue(System.getProperty("correrIntegracion") == null
? true : System.getProperty("correrIntegracion").matches("SI"));
}
</code>

Como podemos ver en el ejemplo, por linea de comando se indica la propiedad "test-sys-prop.correrIntegracion", pero en el test se consulta por la propiedad “correrIntegracion”, esto se debe a que por defecto la tarea [[Ant]] creada por Netbeans para correr los test de [[JUnit]] tiene la propiedad “fork” en true. En esta tarea podemos ver el tag "syspropertyset", el cual indica que todas las propiedades que tengan el prefijo "test-sys-prop." se pasen sin este prefijo al proceso iniciado por el fork para ejecutar la clase de test.

<code xml>
<target name="-init-macrodef-junit">
<macrodef name="junit" uri="http://www.netbeans.org/ns/j2se-project/2">
<attribute name="includes" default="**/*Test.java"/>
<sequential>
<junit showoutput="true" fork="true" dir="${basedir}" failureproperty="tests.failed" errorproperty="tests.failed">
.
.
.
<syspropertyset>
<propertyref prefix="test-sys-prop."/>
<mapper type="glob" from="test-sys-prop.*" to="*"/>
</syspropertyset>
.
.
.
</junit>
.
.
.
</sequential>
</macrodef>
</target>
</code>

Configuración de ejecución selectiva de tests

2011-05-02T18:23:08Z

201.251.185.130:

Para poder correr selectivamente los test de integración de nuestras aplicaciones utilizamos la funcionalidad provista por la clase Assume de [[JUnit]]. La clase Assume contiene métodos útiles para afirmar las hipótesis sobre las condiciones en las que los resultados de los test son significativos. Un supuesto negativo no significa que el código está roto, pero si que los resultados de los test no proporciona ninguna información útil. Por defecto [[JUnit]] trata los test con las hipótesis negativas como ignorados.

Para el caso de proyectos creados con [[NetBeans]] compilados con [[Ant]], podemos indicar si queremos o no correr determinados test usando ciertas propiedades.

Propiedad:
-Dtest-sys-prop.correrIntegracion=NO

<code java5>

@BeforeClass
public static void setUpOnce() throws Throwable {
System.out.println("Se usarán los test de integración [SI/NO]: " + System.getProperty("correrIntegracion"));
Assume.assumeTrue(System.getProperty("correrIntegracion") == null
? true : System.getProperty("correrIntegracion").matches("SI"));
}
</code>

Como podemos ver en el ejemplo, por linea de comando se indica la propiedad "test-sys-prop.correrIntegracion", pero en el test se consulta por la propiedad “correrIntegracion”, esto se debe a que por defecto la tarea [[Ant]] creada por Netbeans para correr los test de [[JUnit]] tiene la propiedad “fork” en true. En esta tarea podemos ver el tag "syspropertyset", el cual indica que todas las propiedades que tengan el prefijo "test-sys-prop." se pasen sin este prefijo al proceso iniciado por el fork para ejecutar la clase de test.

<code xml>
<target name="-init-macrodef-junit">
<macrodef name="junit" uri="http://www.netbeans.org/ns/j2se-project/2">
<attribute name="includes" default="**/*Test.java"/>
<sequential>
<junit showoutput="true" fork="true" dir="${basedir}" failureproperty="tests.failed" errorproperty="tests.failed">
.
.
.
<syspropertyset>
<propertyref prefix="test-sys-prop."/>
<mapper type="glob" from="test-sys-prop.*" to="*"/>
</syspropertyset>
.
.
.
</junit>
.
.
.
</sequential>
</macrodef>
</target>
</code>

Configuración de ejecución selectiva de tests

2011-05-02T18:07:42Z

201.251.185.130:

Para poder correr selectivamente los test de integración de nuestras aplicaciones utilizamos la funcionalidad provista por la clase Assume de [[JUnit]]. La clase Assume contiene métodos útiles para afirmar las hipótesis sobre las condiciones en las que los resultados de los test son significativos. Un supuesto negativo no significa que el código está roto, pero si que los resultados de los test no proporciona ninguna información útil. Por defecto [[JUnit]] trata los test con las hipótesis negativas como ignorados.

Utilizando propiedades de línea de comando, en nuestro caso en la configuración del proyecto en [[Hudson]], podemos indicar si queremos o no correr determinados test.

Propiedad:
-Dtest-sys-prop.correrIntegracion=NO

<code java5>

@BeforeClass
public static void setUpOnce() throws Throwable {
System.out.println("Se usarán los test de integración [SI/NO]: " + System.getProperty("correrIntegracion"));
Assume.assumeTrue(System.getProperty("correrIntegracion") == null
? true : System.getProperty("correrIntegracion").matches("SI"));
}
</code>

Como podemos ver en el ejemplo, por linea de comando se indica la propiedad "test-sys-prop.correrIntegracion", pero en el test se consulta por la propiedad “correrIntegracion”, esto se debe a que por defecto la tarea [[Ant]] creada por Netbeans para correr los test de [[JUnit]] tiene la propiedad “fork” en true. En esta tarea podemos ver el tag "syspropertyset", el cual indica que todas las propiedades que tengan el prefijo "test-sys-prop." se pasen sin este prefijo al proceso iniciado por el fork para ejecutar la clase de test.

<code xml>
<target name="-init-macrodef-junit">
<macrodef name="junit" uri="http://www.netbeans.org/ns/j2se-project/2">
<attribute name="includes" default="**/*Test.java"/>
<sequential>
<junit showoutput="true" fork="true" dir="${basedir}" failureproperty="tests.failed" errorproperty="tests.failed">
.
.
.
<syspropertyset>
<propertyref prefix="test-sys-prop."/>
<mapper type="glob" from="test-sys-prop.*" to="*"/>
</syspropertyset>
.
.
.
</junit>
.
.
.
</sequential>
</macrodef>
</target>
</code>

Configuración de ejecución selectiva de tests

2011-05-02T18:05:14Z

201.251.185.130:

Para poder correr selectivamente los test de integración de nuestras aplicaciones utilizamos la funcionalidad provista por la clase Assume de [[JUnit]]. La clase Assume contiene métodos útiles para afirmar las hipótesis sobre las condiciones en las que los resultados de los test son significativos. Un supuesto negativo no significa que el código está roto, pero si que los resultados de los test no proporciona ninguna información útil. Por defecto [[JUnit]] trata los test con las hipótesis negativas como ignorados.

Utilizando propiedades de línea de comando, en nuestro caso en la configuración del proyecto en [[Hudson]], podemos indicar si queremos o no correr determinados test.

Propiedad:
-Dtest-sys-prop.correrIntegracion=NO

<code java5>

@BeforeClass
public static void setUpOnce() throws Throwable {
System.out.println("Se usarán los test de integración [SI/NO]: " + System.getProperty("correrIntegracion"));
Assume.assumeTrue(System.getProperty("correrIntegracion") == null
? true : System.getProperty("correrIntegracion").matches("SI"));
}
</code>

Como podemos ver en el ejemplo, por linea de comando se indica la propiedad "test-sys-prop.correrIntegracion", pero en el test se consulta por la propiedad “correrIntegracion”, esto se debe a que por defecto la tarea creada por Netbeans para correr los test de [[JUnit]] tiene la propiedad “fork” en true. En esta tarea podemos ver el tag "syspropertyset", el cual indica que todas las propiedades que tengan el prefijo "test-sys-prop." se pasen sin este prefijo al proceso iniciado por el fork para ejecutar la clase de test.

<code xml>
<target name="-init-macrodef-junit">
<macrodef name="junit" uri="http://www.netbeans.org/ns/j2se-project/2">
<attribute name="includes" default="**/*Test.java"/>
<sequential>
<junit showoutput="true" fork="true" dir="${basedir}" failureproperty="tests.failed" errorproperty="tests.failed">
.
.
.
<syspropertyset>
<propertyref prefix="test-sys-prop."/>
<mapper type="glob" from="test-sys-prop.*" to="*"/>
</syspropertyset>
.
.
.
</junit>
.
.
.
</sequential>
</macrodef>
</target>
</code>

Configuración de ejecución selectiva de tests

2011-05-02T17:57:38Z

201.251.185.130:

Configuración de ejecución selectiva de tests

2011-05-02T17:55:53Z

201.251.185.130: Página creada con 'Para poder correr selectivamente los test de integración de nuestras aplicaciones utilizamos la funcionalidad provista por la clase Assume de JUnit. La clase Assume contien…'

JUnit

2011-05-02T17:22:47Z

201.251.185.130: /* Ver también */

[[JUnit]] es un framework de código abierto desarrollado especialmente para crear, ejecutar y hacer reportes de estado de conjuntos de [[Prueba Unitaria]] automatizadas hechos en lenguaje Java.

[[JUnit]] es uno de los frameworks más populares en Java para realizar pruebas unitarias y llevar un desarrollo utilizando la práctica de [[Test Driven Development]].

===Ciclo de vida===
Al momento de ejecutar los tests, [[JUnit]] ejecuta los siguientes métodos propios de cada clase de test:

* Método '''@BeforeClass''' (método estático, antes de la construcción de la clase)
* Por cada método anotado con @Test
** Constructor de la clase de test
** Método anotado con '''@Before'''
** Método anotado con '''@Test'''
** Método anotado con '''@After'''
* Al finalizar todos los @Test, se ejecuta '''@AfterClass'''

===Ejemplo===
La siguiente clase contiene 2 tests, y sirve para ver el ciclo de vida de [[JUnit]]

<code java>
public class HolaMundoTest {

public HolaMundoTest() {
System.out.println(" Constructor de HolaMundoTest");
}

@BeforeClass
public static void setUpClass() throws Exception {
System.out.println("@BeforeClass");
}

@AfterClass
public static void tearDownClass() throws Exception {
System.out.println("@AfterClass");
}

@Before
public void setUp() {
System.out.println(" @Before");
}

@After
public void tearDown() {
System.out.println(" @After");
}

@Test
public void decirHola() {
System.out.println(" TEST decirHola");
}

@Test
public void decirChau() {
System.out.println(" TEST decirChau");
}
}
</code>

La salida por consola de esta ejecución es:
@BeforeClass
Constructor de HolaMundoTest
@Before
TEST decirHola
@After
Constructor de HolaMundoTest
@Before
TEST decirChau
@After
@AfterClass

==Ver también==
* [[Prueba Unitaria]]
* [[Spring Test]]
* [[Tests De JUnit Parametrizados]]
* [[Tests De JUnit Multihilo]]
* [[Test de Metodos y Atributos Privados]]
* [http://www.junit.org Web oficial de JUnit]
* [http://javaboutique.internet.com/tutorials/UnitTesting/ Unit testing Java programs]
* [[Configuración de ejecución selectiva de tests]]

[[Category:JUnit]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-04-28T14:19:45Z

201.251.185.130:

===Comunicando con Base de Datos con PBL (Process Business Language)===

Para ejecutar comandos SQL en Aqualogic BPM 5.7 hay que seguir los siguientes pasos:

====Primer paso====

Se debe crear nuevo "External Resource", haciendo click derecho en el directorio del proyecto "External Resources", del tipo "SQL Database". Los campos se deben completar con la información de la base de datos que queremos consultar y con un nombre significativo.

====Segundo paso====

Se debe crear un nuevo "BPM Object", haciendo click derecho sobre el modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro objeto, haciendo click derecho sobre el objeto y seleccionando la opción "New Method". Ahora se debe editar el nuevo método, expandiendo el objeto bpm y haciendo doble click sobre el nombre del método creado. Ahora podemos editarlo e incluir el código necesario para comunicarnos con la BD a través de una clase propia de Fuego, un ejemplo de implementación puede ser el siguiente:

<code java>
String queryAEjecutar ="SELECT campo1, campo2, campo3 FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator <Any[Any]> iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede observar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

<code java>
foreach (e in iterator) {

logMessage("campo1: "+e["campo1"], severity : INFO);

logMessage("campo2: "+e["campo2"], severity : INFO);

logMessage("campo3: "+e["campo3"], severity : INFO);

logMessage("nombreColumna: "+e["nombreColumna"], severity : INFO);

}
</code>

=== Versionando con CVS ===
El producto Aqualogic BPM 5.7 incluye un cliente de CVS que permite agregar, remover, actualizar en un repositorio CVS.

==== Configurar el cliente CVS ====
* Levantar el Studio BPM.
* File -> Preference ->Default Version Control
** Version Control Manger: CVS
** Host: host del servidor CVS
** User Name: usuario del CVS
** User Password: password del usuario CVS
** path: ruta dentro del repositorio donde se guardará el proyecto.

==== Subir el proyecto al CVS ====
* Levantar el Studio BPM.
* Abrir el proyecto a versionar.
* File -> Project Preference -> Project Version Control.
** Version Control Manager: CVS (nos carga la información ingresada en el punto anterior).
* File -> VCS -> Store project in repository
** Path: directorio en el que se creará el proyecto en el repositorio.
** Si es la primera vez que se sube un proyecto de Aqualogic BPM, pedirá que se ingrese la ruta del directorio donde se creará el "common catalog"
*** Common catalog: Es un catalogo de componente, el cual puede ser compartido por otros proyectos de Aqualogic BPM.
En el repositorio quedarán creados 2 directorios, el del proyecto y el del common catalog, ademas se crearán 2 alias en el CVS que apuntan al proyecto y al common catalog.

==== Obtener el proyecto del CVS ====
* Levantar el Studio BPM.
* File -> Project Preference -> Project Version Control.
* File -> Import -> Project -> from Repository.
** Version Control Manager: CVS
** En la siguiente pantalla, seleccionar el proyecto del repositorio.

==== Trabajar con proyectos versionados ====
Aqualogic BPM 5.7, posee una política restrictiva de edición para los proyecto versionados.
La política, consiste en que todo el proyecto se encuentra en modo lectura y solo un usuario puede editar un determinado archivo versionado (Ej.: un proceso).
===== Editar un procesos =====
* Seleccionar el proceso a editar.
* Menú contextual -> VCS -> edit.
Esto habilita al usuario a modificar el proceso. En caso de que exitiera otro usuario modificando el proceso nos aparecerá un mensaje de error.

===== Grabar los cambios realizados en un proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> commit.
Este paso es importante, debido a que si se libera la edición del proceso sin realizar el commit se perderán los cambios.

===== Liberar la edición del proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> unedit.

===Incluir un jar y utilizarlo===
Una vez que tenemos creado nuestro proyecto BPM podemos llegar a necesitar utilizar ciertas clases de java, tanto para modelar entidades como para invocar servicios externos a nuestro proyecto.

En el caso que necesitemos incluír alguna librería al proyecto BPM los pasos a realizar son los siguientes:

* En "Recursos externos" hacer botón derecho y seleccionar la opción "Nuevo recurso externo".
* Seleccionar un nombre y en tipo seleccionar "Biblioteca de clase Java".
* Le damos clic al botón "Agregar" y buscamos el jar correspondiente que vamos a querer incluír.
* Aceptar.

Finalizado estos pasos vamos a ver que se agregó a "Recursos externos" la librería que acabamos de incluir. Lo siguiente va a ser crear un módulo desde el cual invocar a las clases de nuestro jar. Para esto tenemos que hacer lo siguiente:

* En "Catálogo" hacemos botón derecho y seleccionamos la opción "Crear módulo".
* Le ponemos un nombre y le damos Aceptar.
* Realizado esto, veremos que se agregó un módulo al Catálogo. Lo que tenemos que hacer ahora es indicarle a ese módulo que contenga la configuración de nuestro jar. Para esto hacemos clic derecho sobre el módulo > Componente de catálogo > Java.
* Seleccionamos la opción "Usar una configuración existente" (está marcada por defecto) y en el combo seleccionamos nuestro recurso externo que agregamos antes.
* Luego, seleccionaremos las clases Java que quiero incluír en mi módulo.
* Se hará la carga de clases automáticamente.
* Finalizado esto deberíamos ver dentro de "Catálogo" nuestro módulo nuevo y al amplicar su contenido ver el árbol de las clases que incluímos en él.

Para poder usar estas clases que incluímos, dentro de una actividad se podrán crear instancias de esta forma:

<code java>ClaseDeMiBiblioteca instancia = new ClaseDeMiBiblioteca();</code>

e invocar a sus métodos de esta forma:

<code java>ObjetoRespuesta respuesta = (ObjetoRespuesta) instancia.metodo(arg1 : parametroAEnviar);</code>

===Tratamiento de excepciones de servicios externos===
Puede suceder que, al momento de invocar algún servicio externo a nuestro proyecto de BPM, este retorne como respuesta una excepción. Para poder darle un comportamiento a nuestro proceso en BPM se puede utilizar una transición del tipo "Excepción" entre dos actividades.

Para dar un ejemplo concreto vamos a imaginarnos 2 actividades a las que llamaremos "Inicio" y "Comportamiento correcto". La actividad "Inicio" invocará a un servicio, y si sale todo bien, se pasará luego a la actividad "Comportamiento correcto".

[[Archivo:1.jpg]]

Ahora, puede suceder que cuando "Inicio" invoca al servicio, éste devuelva una Excepción. ¿Qué hacemos en ese caso? Creamos una actividad (en nuestro ejemplo es "Comportamiento excepción"), la cual nuestro sistema ejecutará en caso de que el servicio falle, y le asociamos una transición entre "Inicio" y esta nueva actividad de esta forma:

[[Archivo:2.jpg]]

Para crear dicha transición, debemos crear la actividad a la cual asociarla, dale doble clic y luego seleccionar como tipo de transición aquella que dice "Excepción". Para indicarle para qué tipo de Excepción queremos que se siga dicho flujo, en "Nombre de excepción" deberemos cargar la clase con la excepción que puede llegar.

=== Ver también ===
* [[Oracle BPM]]

[[Category:Oracle]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-04-28T14:18:16Z

201.251.185.130: /* Incluir un jar y utilizarlo */

===Comunicando con Base de Datos con PBL (Process Business Language)===

Para ejecutar comandos SQL en Aqualogic BPM 5.7 hay que seguir los siguientes pasos:

====Primer paso====

Se debe crear nuevo "External Resource", haciendo click derecho en el directorio del proyecto "External Resources", del tipo "SQL Database". Los campos se deben completar con la información de la base de datos que queremos consultar y con un nombre significativo.

====Segundo paso====

Se debe crear un nuevo "BPM Object", haciendo click derecho sobre el modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro objeto, haciendo click derecho sobre el objeto y seleccionando la opción "New Method". Ahora se debe editar el nuevo método, expandiendo el objeto bpm y haciendo doble click sobre el nombre del método creado. Ahora podemos editarlo e incluir el código necesario para comunicarnos con la BD a través de una clase propia de Fuego, un ejemplo de implementación puede ser el siguiente:

<code java>
String queryAEjecutar ="SELECT campo1, campo2, campo3 FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator <Any[Any]> iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede observar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

<code java>
foreach (e in iterator) {

logMessage("campo1: "+e["campo1"], severity : INFO);

logMessage("campo2: "+e["campo2"], severity : INFO);

logMessage("campo3: "+e["campo3"], severity : INFO);

logMessage("nombreColumna: "+e["nombreColumna"], severity : INFO);

}
</code>

=== Versionando con CVS ===
El producto Aqualogic BPM 5.7 incluye un cliente de CVS que permite agregar, remover, actualizar en un repositorio CVS.

==== Configurar el cliente CVS ====
* Levantar el Studio BPM.
* File -> Preference ->Default Version Control
** Version Control Manger: CVS
** Host: host del servidor CVS
** User Name: usuario del CVS
** User Password: password del usuario CVS
** path: ruta dentro del repositorio donde se guardará el proyecto.

==== Subir el proyecto al CVS ====
* Levantar el Studio BPM.
* Abrir el proyecto a versionar.
* File -> Project Preference -> Project Version Control.
** Version Control Manager: CVS (nos carga la información ingresada en el punto anterior).
* File -> VCS -> Store project in repository
** Path: directorio en el que se creará el proyecto en el repositorio.
** Si es la primera vez que se sube un proyecto de Aqualogic BPM, pedirá que se ingrese la ruta del directorio donde se creará el "common catalog"
*** Common catalog: Es un catalogo de componente, el cual puede ser compartido por otros proyectos de Aqualogic BPM.
En el repositorio quedarán creados 2 directorios, el del proyecto y el del common catalog, ademas se crearán 2 alias en el CVS que apuntan al proyecto y al common catalog.

==== Obtener el proyecto del CVS ====
* Levantar el Studio BPM.
* File -> Project Preference -> Project Version Control.
* File -> Import -> Project -> from Repository.
** Version Control Manager: CVS
** En la siguiente pantalla, seleccionar el proyecto del repositorio.

==== Trabajar con proyectos versionados ====
Aqualogic BPM 5.7, posee una política restrictiva de edición para los proyecto versionados.
La política, consiste en que todo el proyecto se encuentra en modo lectura y solo un usuario puede editar un determinado archivo versionado (Ej.: un proceso).
===== Editar un procesos =====
* Seleccionar el proceso a editar.
* Menú contextual -> VCS -> edit.
Esto habilita al usuario a modificar el proceso. En caso de que exitiera otro usuario modificando el proceso nos aparecerá un mensaje de error.

===== Grabar los cambios realizados en un proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> commit.
Este paso es importante, debido a que si se libera la edición del proceso sin realizar el commit se perderán los cambios.

===== Liberar la edición del proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> unedit.

===Incluir un jar y utilizarlo===
Una vez que tenemos creado nuestro proyecto BPM podemos llegar a necesitar utilizar ciertas clases de java, tanto para modelar entidades como para invocar servicios externos a nuestro proyecto.

En el caso que necesitemos incluír alguna librería al proyecto BPM los pasos a realizar son los siguientes:

* En "Recursos externos" hacer botón derecho y seleccionar la opción "Nuevo recurso externo".
* Seleccionar un nombre y en tipo seleccionar "Biblioteca de clase Java".
* Le damos clic al botón "Agregar" y buscamos el jar correspondiente que vamos a querer incluír.
* Aceptar.

Finalizado estos pasos vamos a ver que se agregó a "Recursos externos" la librería que acabamos de incluir. Lo siguiente va a ser crear un módulo desde el cual invocar a las clases de nuestro jar. Para esto tenemos que hacer lo siguiente:

* En "Catálogo" hacemos botón derecho y seleccionamos la opción "Crear módulo".
* Le ponemos un nombre y le damos Aceptar.
* Realizado esto, veremos que se agregó un módulo al Catálogo. Lo que tenemos que hacer ahora es indicarle a ese módulo que contenga la configuración de nuestro jar. Para esto hacemos clic derecho sobre el módulo > Componente de catálogo > Java.
* Seleccionamos la opción "Usar una configuración existente" (está marcada por defecto) y en el combo seleccionamos nuestro recurso externo que agregamos antes.
* Luego, seleccionaremos las clases Java que quiero incluír en mi módulo.
* Se hará la carga de clases automáticamente.
* Finalizado esto deberíamos ver dentro de "Catálogo" nuestro módulo nuevo y al amplicar su contenido ver el árbol de las clases que incluímos en él.

Para poder usar estas clases que incluímos, dentro de una actividad se podrán crear instancias de esta forma:

<code java>ClaseDeMiBiblioteca instancia = new ClaseDeMiBiblioteca();</code>

e invocar a sus métodos de esta forma:

<code java>ObjetoRespuesta respuesta = (ObjetoRespuesta) instancia.metodo(arg1 : parametroAEnviar);</code>

=== Ver también ===
* [[Oracle BPM]]

[[Category:Oracle]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-04-28T14:16:31Z

201.251.185.130: /* Incluir un jar y utilizarlo */

===Comunicando con Base de Datos con PBL (Process Business Language)===

Para ejecutar comandos SQL en Aqualogic BPM 5.7 hay que seguir los siguientes pasos:

====Primer paso====

Se debe crear nuevo "External Resource", haciendo click derecho en el directorio del proyecto "External Resources", del tipo "SQL Database". Los campos se deben completar con la información de la base de datos que queremos consultar y con un nombre significativo.

====Segundo paso====

Se debe crear un nuevo "BPM Object", haciendo click derecho sobre el modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro objeto, haciendo click derecho sobre el objeto y seleccionando la opción "New Method". Ahora se debe editar el nuevo método, expandiendo el objeto bpm y haciendo doble click sobre el nombre del método creado. Ahora podemos editarlo e incluir el código necesario para comunicarnos con la BD a través de una clase propia de Fuego, un ejemplo de implementación puede ser el siguiente:

<code java>
String queryAEjecutar ="SELECT campo1, campo2, campo3 FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator <Any[Any]> iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede observar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

<code java>
foreach (e in iterator) {

logMessage("campo1: "+e["campo1"], severity : INFO);

logMessage("campo2: "+e["campo2"], severity : INFO);

logMessage("campo3: "+e["campo3"], severity : INFO);

logMessage("nombreColumna: "+e["nombreColumna"], severity : INFO);

}
</code>

=== Versionando con CVS ===
El producto Aqualogic BPM 5.7 incluye un cliente de CVS que permite agregar, remover, actualizar en un repositorio CVS.

==== Configurar el cliente CVS ====
* Levantar el Studio BPM.
* File -> Preference ->Default Version Control
** Version Control Manger: CVS
** Host: host del servidor CVS
** User Name: usuario del CVS
** User Password: password del usuario CVS
** path: ruta dentro del repositorio donde se guardará el proyecto.

==== Subir el proyecto al CVS ====
* Levantar el Studio BPM.
* Abrir el proyecto a versionar.
* File -> Project Preference -> Project Version Control.
** Version Control Manager: CVS (nos carga la información ingresada en el punto anterior).
* File -> VCS -> Store project in repository
** Path: directorio en el que se creará el proyecto en el repositorio.
** Si es la primera vez que se sube un proyecto de Aqualogic BPM, pedirá que se ingrese la ruta del directorio donde se creará el "common catalog"
*** Common catalog: Es un catalogo de componente, el cual puede ser compartido por otros proyectos de Aqualogic BPM.
En el repositorio quedarán creados 2 directorios, el del proyecto y el del common catalog, ademas se crearán 2 alias en el CVS que apuntan al proyecto y al common catalog.

==== Obtener el proyecto del CVS ====
* Levantar el Studio BPM.
* File -> Project Preference -> Project Version Control.
* File -> Import -> Project -> from Repository.
** Version Control Manager: CVS
** En la siguiente pantalla, seleccionar el proyecto del repositorio.

==== Trabajar con proyectos versionados ====
Aqualogic BPM 5.7, posee una política restrictiva de edición para los proyecto versionados.
La política, consiste en que todo el proyecto se encuentra en modo lectura y solo un usuario puede editar un determinado archivo versionado (Ej.: un proceso).
===== Editar un procesos =====
* Seleccionar el proceso a editar.
* Menú contextual -> VCS -> edit.
Esto habilita al usuario a modificar el proceso. En caso de que exitiera otro usuario modificando el proceso nos aparecerá un mensaje de error.

===== Grabar los cambios realizados en un proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> commit.
Este paso es importante, debido a que si se libera la edición del proceso sin realizar el commit se perderán los cambios.

===== Liberar la edición del proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> unedit.

===Incluir un jar y utilizarlo===
Una vez que tenemos creado nuestro proyecto BPM podemos llegar a necesitar utilizar ciertas clases de java, tanto para modelar entidades como para invocar servicios externos a nuestro proyecto.

En el caso que necesitemos incluír alguna librería al proyecto BPM los pasos a realizar son los siguientes:

* En "Recursos externos" hacer botón derecho y seleccionar la opción "Nuevo recurso externo".
* Seleccionar un nombre y en tipo seleccionar "Biblioteca de clase Java".
* Le damos clic al botón "Agregar" y buscamos el jar correspondiente que vamos a querer incluír.
* Aceptar.

Finalizado estos pasos vamos a ver que se agregó a "Recursos externos" la librería que acabamos de incluir. Lo siguiente va a ser crear un módulo desde el cual invocar a las clases de nuestro jar. Para esto tenemos que hacer lo siguiente:

* En "Catálogo" hacemos botón derecho y seleccionamos la opción "Crear módulo".
* Le ponemos un nombre y le damos Aceptar.
* Realizado esto, veremos que se agregó un módulo al Catálogo. Lo que tenemos que hacer ahora es indicarle a ese módulo que contenga la configuración de nuestro jar. Para esto hacemos clic derecho sobre el módulo > Componente de catálogo > Java.
* Seleccionamos la opción "Usar una configuración existente" (está marcada por defecto) y en el combo seleccionamos nuestro recurso externo que agregamos antes.
* Luego, seleccionaremos las clases Java que quiero incluír en mi módulo.
* Se hará la carga de clases automáticamente.
* Finalizado esto deberíamos ver dentro de "Catálogo" nuestro módulo nuevo y al amplicar su contenido ver el árbol de las clases que incluímos en él.

Para poder usar estas clases que incluímos, dentro de una actividad se podrán crear instancias de esta forma:

ClaseDeMiBiblioteca instancia = new ClaseDeMiBiblioteca();

e invocar a sus métodos de esta forma:

ObjetoRespuesta respuesta = (ObjetoRespuesta) instancia.metodo(arg1 : parametroAEnviar);

=== Ver también ===
* [[Oracle BPM]]

[[Category:Oracle]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-04-28T14:15:34Z

201.251.185.130:

===Comunicando con Base de Datos con PBL (Process Business Language)===

Para ejecutar comandos SQL en Aqualogic BPM 5.7 hay que seguir los siguientes pasos:

====Primer paso====

Se debe crear nuevo "External Resource", haciendo click derecho en el directorio del proyecto "External Resources", del tipo "SQL Database". Los campos se deben completar con la información de la base de datos que queremos consultar y con un nombre significativo.

====Segundo paso====

Se debe crear un nuevo "BPM Object", haciendo click derecho sobre el modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro objeto, haciendo click derecho sobre el objeto y seleccionando la opción "New Method". Ahora se debe editar el nuevo método, expandiendo el objeto bpm y haciendo doble click sobre el nombre del método creado. Ahora podemos editarlo e incluir el código necesario para comunicarnos con la BD a través de una clase propia de Fuego, un ejemplo de implementación puede ser el siguiente:

<code java>
String queryAEjecutar ="SELECT campo1, campo2, campo3 FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator <Any[Any]> iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede observar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

<code java>
foreach (e in iterator) {

logMessage("campo1: "+e["campo1"], severity : INFO);

logMessage("campo2: "+e["campo2"], severity : INFO);

logMessage("campo3: "+e["campo3"], severity : INFO);

logMessage("nombreColumna: "+e["nombreColumna"], severity : INFO);

}
</code>

=== Versionando con CVS ===
El producto Aqualogic BPM 5.7 incluye un cliente de CVS que permite agregar, remover, actualizar en un repositorio CVS.

==== Configurar el cliente CVS ====
* Levantar el Studio BPM.
* File -> Preference ->Default Version Control
** Version Control Manger: CVS
** Host: host del servidor CVS
** User Name: usuario del CVS
** User Password: password del usuario CVS
** path: ruta dentro del repositorio donde se guardará el proyecto.

==== Subir el proyecto al CVS ====
* Levantar el Studio BPM.
* Abrir el proyecto a versionar.
* File -> Project Preference -> Project Version Control.
** Version Control Manager: CVS (nos carga la información ingresada en el punto anterior).
* File -> VCS -> Store project in repository
** Path: directorio en el que se creará el proyecto en el repositorio.
** Si es la primera vez que se sube un proyecto de Aqualogic BPM, pedirá que se ingrese la ruta del directorio donde se creará el "common catalog"
*** Common catalog: Es un catalogo de componente, el cual puede ser compartido por otros proyectos de Aqualogic BPM.
En el repositorio quedarán creados 2 directorios, el del proyecto y el del common catalog, ademas se crearán 2 alias en el CVS que apuntan al proyecto y al common catalog.

==== Obtener el proyecto del CVS ====
* Levantar el Studio BPM.
* File -> Project Preference -> Project Version Control.
* File -> Import -> Project -> from Repository.
** Version Control Manager: CVS
** En la siguiente pantalla, seleccionar el proyecto del repositorio.

==== Trabajar con proyectos versionados ====
Aqualogic BPM 5.7, posee una política restrictiva de edición para los proyecto versionados.
La política, consiste en que todo el proyecto se encuentra en modo lectura y solo un usuario puede editar un determinado archivo versionado (Ej.: un proceso).
===== Editar un procesos =====
* Seleccionar el proceso a editar.
* Menú contextual -> VCS -> edit.
Esto habilita al usuario a modificar el proceso. En caso de que exitiera otro usuario modificando el proceso nos aparecerá un mensaje de error.

===== Grabar los cambios realizados en un proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> commit.
Este paso es importante, debido a que si se libera la edición del proceso sin realizar el commit se perderán los cambios.

===== Liberar la edición del proceso =====
* Seleccionar el proceso que se esta editando.
* Menú contextual -> VCS -> unedit.

===Incluir un jar y utilizarlo===
Una vez que tenemos creado nuestro proyecto BPM podemos llegar a necesitar utilizar ciertas clases de java, tanto para modelar entidades como para invocar servicios externos a nuestro proyecto.

En el caso que necesitemos incluír alguna librería al proyecto BPM los pasos a realizar son los siguientes:

1) En "Recursos externos" hacer botón derecho y seleccionar la opción "Nuevo recurso externo".
2) Seleccionar un nombre y en tipo seleccionar "Biblioteca de clase Java".
3) Le damos clic al botón "Agregar" y buscamos el jar correspondiente que vamos a querer incluír.
4) Aceptar.

Finalizado estos pasos vamos a ver que se agregó a "Recursos externos" la librería que acabamos de incluir. Lo siguiente va a ser crear un módulo desde el cual invocar a las clases de nuestro jar. Para esto tenemos que hacer lo siguiente:

1) En "Catálogo" hacemos botón derecho y seleccionamos la opción "Crear módulo".
2) Le ponemos un nombre y le damos Aceptar.
3) Realizado esto, veremos que se agregó un módulo al Catálogo. Lo que tenemos que hacer ahora es indicarle a ese módulo que contenga la configuración de nuestro jar. Para esto hacemos clic derecho sobre el módulo > Componente de catálogo > Java.
4) Seleccionamos la opción "Usar una configuración existente" (está marcada por defecto) y en el combo seleccionamos nuestro recurso externo que agregamos antes.
5) Luego, seleccionaremos las clases Java que quiero incluír en mi módulo.
6) Se hará la carga de clases automáticamente.
7) Finalizado esto deberíamos ver dentro de "Catálogo" nuestro módulo nuevo y al amplicar su contenido ver el árbol de las clases que incluímos en él.

Para poder usar estas clases que incluímos, dentro de una actividad se podrán crear instancias de esta forma:

ClaseDeMiBiblioteca instancia = new ClaseDeMiBiblioteca();

e invocar a sus métodos de esta forma:

ObjetoRespuesta respuesta = (ObjetoRespuesta) instancia.metodo(arg1 : parametroAEnviar);

=== Ver también ===
* [[Oracle BPM]]

[[Category:Oracle]]

Mock de un servidor de correo smtp con Wiser

2011-04-19T15:01:17Z

201.251.185.130:

En el siguiente ejemplo de código se muestra una clase que envía un mail usando la API de JavaMail.
Luego, un Test de Junit prueba esta clase levantando el servidor de mail [[Wiser]] en memoria y verificando que el mail haya llegado correctamente.

<code java="java">
package com.dosideas.smtp;

import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
* Clase que envía un email.
*/
public class MandaMail {

public void enviarMail(String mailOrigen, String mailDestinatario, String asunto, String textoMensaje)
throws AddressException, MessagingException {

//se puede poner en true para ver la interaccion del protocolo smtp por stdout.
boolean debug = false;

//setea el host y puerto donde esta el servidor de mail.
Properties props = new Properties();
props.put("mail.smtp.host", "localhost");
props.put("mail.smtp.port", 25);

Session session = Session.getDefaultInstance(props, null);
session.setDebug(debug);

// create a message
Message msg = new MimeMessage(session);

// set the from and to address
InternetAddress addressFrom = new InternetAddress(mailOrigen);
msg.setFrom(addressFrom);

InternetAddress addressTo = new InternetAddress(mailDestinatario);
msg.setRecipient(Message.RecipientType.TO, addressTo);

// Setting the Subject and Content Type
msg.setSubject(asunto);
msg.setContent(textoMensaje, "text/plain");
Transport.send(msg);
}
}

</code>

== El test con JUnit ==

El siguiente test utiliza la clase anterior para maquetar el [[Servidor SMTP]].

<code java="java">
package com.dosideas.smtp;

import javax.mail.internet.MimeMessage;
import org.subethamail.wiser.WiserMessage;
import org.subethamail.wiser.Wiser;
import java.util.Iterator;
import org.junit.Test;
import static org.junit.Assert.*;

/**
* Test de envio de mail con Junit y Dumbster
*/
public class MandaMailTest {

@Test
public void testEnviarMail() throws Exception {

MandaMail instance = new MandaMail();

String mailDestinatario = "destinatario@dumbster.com";
String mailOrigen = "origen@dumbster.com";
String asunto = "Asunto del mail de prueba";
String textoMensaje = "Este es un mail para probar el servidor de dumbster";

//arranca el servidor de mail de Dumbster.
Wiser server = new Wiser();
server.setPort(25);
server.start();

try {
//envia el mail.
instance.enviarMail(mailOrigen, mailDestinatario, asunto, textoMensaje);
} catch (Exception e) {
e.printStackTrace();
fail("Unexpected exception: " + e);
}

//detiene el servidor de Dumbster
server.stop();

//verifica que se obtenga el mail y que tenga los datos enviados.
assertTrue(server.getMessages().size() == 1);
Iterator emailIter = server.getMessages().iterator();
WiserMessage email = (WiserMessage) emailIter.next();
MimeMessage mmessage = email.getMimeMessage();
assertTrue(mmessage.getSubject().equals(asunto));
assertTrue(email.getEnvelopeSender().equals(mailOrigen));
assertTrue(email.getEnvelopeReceiver().equals(mailDestinatario));
assertTrue(mmessage.getContent().toString().equals(textoMensaje));

//muestra el contenido
System.out.println("Mensaje recibido en servidor Dumbster:");
System.out.println("--------------------------------------");
System.out.println("De: " + email.getEnvelopeSender());
System.out.println("Para: " + email.getEnvelopeReceiver());
System.out.println("Asunto: " + mmessage.getSubject());
System.out.println("Contenido: " + mmessage.getContent());

}
}
</code>

== Ver también ==

*[[Wiser]]
*[[Dumbster]]
*[[Mock Object]]
*[[Jetty]]

[[Category:Java]] [[Category:TDD]] [[Category:JUnit]]

Dumbster

2011-04-19T15:00:56Z

201.251.185.130: /* Ver también */

Dumbster es un proyecto de [[Software Libre]] que permite generar [[Mock Object]] de un servidor de mail SMTP.

Permite realizar Tests con Junit en los que se pueden enviar y obtener mails de este servidor de correo mock.

== Issues conocidos ==

Dumbster 1.6 tiene problemas en plataformas MacOSX.

Debido a un race condition Dumbster puede llegar a producir un Deadlock, el problema suele aparecer cuando se intenta iniciar una nueva instancia de Dumbster luego de haber cerrado otra.

Los detalles del problema se pueden ver en [http://sourceforge.net/tracker/?func=detail&aid=1354551&group_id=78413&atid=553186 el bug reportado en sourceforge].

Hay un parche que se puede aplicar para solucionar este problema, aunque otra solución es utilizar otra herramienta como [[Wiser]]

== Ver también ==
* [[Mock de un servidor de correo smtp con Dumbster]]
* [[Wiser]]
* [[Mock de un servidor de correo smtp con Wiser]]
* [http://quintanasoft.com/dumbster/ Sitio oficial de Dumbster]

[[Category:Java]] [[Category:TDD]] [[Category:JUnit]]