Dos Ideas. - Contribuciones del usuario [es]

Web Service con Axis 2

2011-10-03T19:30:57Z

201.251.182.130:

Axis 2 es un framework para el desarrollo y consumo de Webservices en Java, e intenta solucionar algunos temas pendientes de su predecesor Axis 1.

A continuación haremos un proyecto prototipo, partiendo de un WSDL de un servicio sencillo de calculadora.

== Pasos: ==

==== Crear un proyecto Web con Netbeans ====
Utilizaremos el nombre DosIdeas-Axis2 para el proyecto.
==== Agregar la librería Axis 2 al proyecto ====
Como puede ser que no este instalada, deberemos bajarla del sitio Web (http://ws.apache.org/axis2/download/1_4_1/download.cgi). Utilizaremos la versión 1.4.1 que es la última versión compatible con Java 1.4.
En la versión 1.5 de Axis 2 cambia bastante la forma de construir Web Services, pero no será visto en este tutorial.

El proyecto viene con muchas mas librerías de las que son estrictamente necesarias para el ejemplo. No obstante, para simplificar incorporaremos todas.
==== Agregar Spring 2.5 o posterior ====
Si bien no es imprescindible para el funcionamiento, permite una clara separación de la lógica de negocio de la implementación del servicio Web.
==== Copiar WSDL de ejemplo al proyecto ====
Para este proyecto, tenemos un WSDL de un servicio Calculadora, que tiene 2 operaciones:
* dividir (división entera)
* sumar

La operación dividir necesita 2 parámetros, dividendo y divisor y devuelve 2 valores, cociente y resto. Además debe devolver un mensaje de error en caso que el divisor sea 0.

==== Generar código java a partir de un documento WSDL ====
Axis 2 viene con un generador de código que ahorra al usuario la construcción de todas clases necesarias para la implementación de WebServices.
En este caso utilizaremos una tarea Ant para construir dichas clases. En caso de trabajar con Eclipse, también tendremos la posibilidad de utilizar el plugin de Web Services, que viene con la distribución JEE del IDE.

<property name="axis2.home" value="D:/development/axis2-1.4.1" />
<property name="output.wsdl2java.dir" value="build/codegen" />
<property name="src.dir" value="src/java" />

<property name="wsdl.uri" value="resources/wsdl/CalculadoraService.wsdl" />
<property name="services.folder" value="web/WEB-INF/services" />

<property name="service.name" value="CalculadoraService" />

<property name="service.wsdl.uri" value="resources/wsdl/${service.name}.wsdl" />
<property name="service.folder" value="${services.folder}/${service.name}/META-INF" />

<path id="axis2.classpath">
<fileset dir="${axis2.home}/lib">
<include name="**/*.jar" />
</fileset>
</path>

<target name="run-wsdl2java-server">
<mkdir dir="${output.wsdl2java.dir}" />
<delete dir="${output.wsdl2java.dir}" includeemptydirs="true" />
<java classname="org.apache.axis2.wsdl.WSDL2Java" fork="true">
<classpath refid="axis2.classpath"/>
<arg value="-uri"/><arg file="${wsdl.uri}"/>
<arg value="-ss"/>
<arg value="-g"/>
<arg value="-sd"/>
<arg value="-o"/><arg file="${output.wsdl2java.dir}"/>
</java>

<copy todir="${src.dir}" overwrite="true">
<fileset dir="${output.wsdl2java.dir}/src">
<include name="**/*.java"/>
</fileset>
</copy>
<mkdir dir="${service.folder}" />
<delete dir="${service.folder}" includeemptydirs="true" />

<mkdir dir="${service.folder}/service" />

<copy todir="${service.folder}/service" overwrite="true">
<fileset dir="${output.wsdl2java.dir}/resources">
<include name="**/*"/>
</fileset>
</copy>
</target>

Esta tarea Ant generará todas las clases involucradas en el Web Service y una serie de archivos, incluyendo la clase que contendrá la lógica de negocio, la cual vendrá con implementaciones dummy.
Luego se copiaran los clases java al directorio de fuentes y por último se copiará el archivo de configuración y el wsdl al directorio de servicio predeterminado de Axis.

==== Implementar lógica de negocio ====
De las clases generadas, la única que tendremos que implementar es la que tiene el sufijo Skeleton. En caso que implementaramos la lógica aquí, sería poco reutilizable, por lo que haremos en un paso siguiente una clase con la lógica de negocio y en el Skeleton tan solo invocaremos dicha clase.

public class CalculadoraServiceSkeleton {

protected CalculadoraBo calculadoraBo = null;

public CalculadoraBo getCalculadoraBo() {
return calculadoraBo;
}

public void setCalculadoraBo(CalculadoraBo calculadoraBo) {
this.calculadoraBo = calculadoraBo;
}

/**
* Auto generated method signature
*
* @param divisionSolicitud
* @throws DivisionPorCeroError :
*/
public com.dosideas.www.cursos.calculadora.DivisionRespuesta dividir(
com.dosideas.www.cursos.calculadora.DivisionSolicitud divisionSolicitud)
throws DivisionPorCeroError {
int divisor = divisionSolicitud.getDivisor();
int dividendo = divisionSolicitud.getDividendo();
try {
int cociente = calculadoraBo.divide(dividendo, divisor);
int resto = calculadoraBo.modulo(dividendo, divisor);
DivisionRespuesta rta = new DivisionRespuesta();
rta.setCociente(cociente);
rta.setResto(resto);
return rta;
} catch (ArithmeticException e) {
DivisionPorCeroException error = new DivisionPorCeroException();
// En caso que no se setee el objeto descripcion, tira un error genérico AxisFault
DivisionPorCero div = new DivisionPorCero();
// Si no se llenan todos los campos obligatorios, devuelve error 500 de http
div.setDivisionPorCero("Descripcion del error");
error.setFaultMessage(div);
throw error;
}
}

/**
* Auto generated method signature
*
* @param sumaSolicitud
*/
public com.dosideas.www.cursos.calculadora.SumaRespuesta sumar(
com.dosideas.www.cursos.calculadora.SumaSolicitud sumaSolicitud) {
SumaRespuesta rta = new SumaRespuesta();
rta.setNumero(calculadoraBo.sum(sumaSolicitud.getNumero1(), sumaSolicitud.getNumero2()));
return rta;
}
}
Se recomienda prestar especial atención al tratamiento de los errores custom.
Cada error de negocio cuenta con un tipo interno, que contiene la descripción del error. En caso de no llenar dicha descripción, se lanzará un error genérico AxisFault.
Además hay que tener especial cuidado al llenar dicha descripción. En caso que no se cumpla con el formato, Axis devuelve un error http 500, en vez de un error descriptivo.
Luego se crea la clase con la lógica de negocio, la cual después se inyectará en la clase Skeleton via Spring

public class CalculadoraBo {
public int sum(int n1, int n2) {
return n1 + n2;
}

public int divide(int n1, int n2){
return n1 / n2;
}

public int modulo(int n1, int n2){
return n1 % n2;
}
}

==== Configurar descriptores de Spring ====

<bean id="applicationContext"
class="org.apache.axis2.extensions.spring.receivers.ApplicationContextHolder" />

<bean id="calculadoraBo" class="com.dosideas.business.CalculadoraBo">

</bean>
<bean id="calculadoraService" class="com.dosideas.www.cursos.calculadora.CalculadoraServiceSkeleton">
<property name="calculadoraBo" ref="calculadoraBo" />
</bean>

==== Configurar web.xml ====

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
<display-name>Apache-Axis Servlet</display-name>
<servlet-name>AxisServlet</servlet-name>
<servlet-class>org.apache.axis2.transport.http.AxisServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>AxisServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

==== Modificar services.xml para que use Spring ====

<parameter name="ServiceObjectSupplier" locked="false">
org.apache.axis2.extensions.spring.receivers.SpringAppContextAwareObjectSupplier</parameter>
<parameter name="SpringBeanName" locked="false">calculadoraService</parameter>

La configuración descrita aquí funciona tanto para Tomcat como para Glassfish.
En caso que se desee hacer un Web Service para Weblogic o para Websphere, son necesarios algunos pasos adicionales. Se sugiere leer la siguiente nota: [[Web Service con Axis 2 para Weblogic y Websphere]]

==== Sugerencias para la construcción del WSDL ====

* No utilizar las palabras Error o Exception al final de los tipos o de los mensajes Fault. Estas palabras son utilizadas por el generador de código, por lo que luego el código generado será incorrecto.
* Si se usa la versión 1.4 de Axis 2, no nombrar de la misma forma un mensaje de error que el tipo que contiene. Genera un error extraño en el generador de código, por el que genera 2 excepciones con el nombre del mensaje. Ej: Con el tipo DivisionPorCero, generó DivisionPorCeroException0 y DivisionPorCeroException1.

== Recursos ==

=== WSDL de Calculadora Service ===

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="CalculadoraServiceDefinitions" targetNamespace="http://www.dosideas.com/cursos/calculadora" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:calc="http://www.dosideas.com/cursos/calculadora" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="http://www.dosideas.com/cursos/calculadora">
<xs:element name="divisionSolicitud">
<xs:complexType>
<xs:sequence>
<xs:element name="dividendo" type="xs:int"/>
<xs:element name="divisor" type="xs:int"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="divisionRespuesta">
<xs:complexType>
<xs:sequence>
<xs:element name="cociente" type="xs:int"/>
<xs:element name="resto" type="xs:int"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="divisionPorCero" type="xs:string"/>
<xs:element name="sumaSolicitud">
<xs:complexType>
<xs:sequence>
<xs:element name="numero1" type="xs:int"/>
<xs:element name="numero2" type="xs:int"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sumaRespuesta">
<xs:complexType>
<xs:sequence>
<xs:element name="numero" type="xs:int"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
</wsdl:types>
<wsdl:message name="divisionSolicitud">
<wsdl:part name="parameters" element="calc:divisionSolicitud">
</wsdl:part>
</wsdl:message>
<wsdl:message name="divisionRespuesta">
<wsdl:part name="parameters" element="calc:divisionRespuesta">
</wsdl:part>
</wsdl:message>
<wsdl:message name="divisionPorCero">
<wsdl:part name="divisionPorCero" element="calc:divisionPorCero">
</wsdl:part>
</wsdl:message>
<wsdl:message name="sumarResponse">
<wsdl:part name="parameters" element="calc:sumaRespuesta">
</wsdl:part>
</wsdl:message>
<wsdl:message name="sumarRequest">
<wsdl:part name="parameters" element="calc:sumaSolicitud">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="Calculadora">
<wsdl:operation name="dividir" parameterOrder="parameters">
<wsdl:input message="calc:divisionSolicitud">
</wsdl:input>
<wsdl:output message="calc:divisionRespuesta">
</wsdl:output>
<wsdl:fault name="divisionPorCero" message="calc:divisionPorCero">
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="sumar">
<wsdl:input message="calc:sumarRequest">
</wsdl:input>
<wsdl:output message="calc:sumarResponse">
</wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="CalculadoraServiceSoapBinding" type="calc:Calculadora">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="dividir">
<soap:operation soapAction="" style="document"/>
<wsdl:input>
<soap:body parts="parameters" use="literal"/>
</wsdl:input>
<wsdl:output>
<soap:body parts="parameters" use="literal"/>
</wsdl:output>
<wsdl:fault name="divisionPorCero">
<soap:fault name="divisionPorCero" use="literal"/>
</wsdl:fault>
</wsdl:operation>
<wsdl:operation name="sumar">
<soap:operation soapAction="http://www.dosideas.com/cursos/calculadora/sumar"/>
<wsdl:input>
<soap:body use="literal"/>
</wsdl:input>
<wsdl:output>
<soap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="CalculadoraService">
<wsdl:port name="CalculadoraSoapPort" binding="calc:CalculadoraServiceSoapBinding">
<soap:address location="http://localhost:8080/Axis2-15/services/CalculadoraService"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
==Proyectos de ejemplo para descargar==
Aquí que te podés descargar 2 versiones del proyecto

* [http://www.dosideas.com/descargas/category/8-.html?download=32%3A2-1.4.1-p-1.4 Axis2 1.4.1 para JDK 1.4]
* [http://www.dosideas.com/descargas/category/8-.html?download=33%3A2-1.5.1-p-5 Axis2 1.5.1 para JDK 5]

==Ver también==
* [[Web Service]]
* [[Clientes De Web Service]]
* [[Cliente Web Service con Ant y Axis2]]
* [[Web Service con Axis 2 para Weblogic y Websphere]]
* [[Web Service Con Spring]]
* [http://ws.apache.org/axis2/ Apache Axis 2]

[[Category:Java]]
[[Category:Web Service]]

UML

2011-09-28T17:37:53Z

201.251.182.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]
* [http://www.uml.org/ Sitio oficial de UML]

REST con Spring

2011-09-07T13:36:16Z

201.251.182.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 la 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]

REST con Spring

2011-09-07T13:35:20Z

201.251.182.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 la 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]

REST con Spring

2011-09-07T13:34:48Z

201.251.182.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 la 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]

REST con Spring

2011-09-07T13:29:18Z

201.251.182.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 la 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]

REST con Spring

2011-09-07T13:13:06Z

201.251.182.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");
}
Y configurar lo siguiente en el applicationContext.xml

</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]

Mockito

2011-09-06T19:22:27Z

201.251.182.130: Deshecha la edición 6168 de 211.214.160.38 (disc.)

Mockito es una librería [[Java]] para la creación de [[Mock Object]] muy usados para el testeo unitario en [[Test Driven Development]], basado en [[EasyMock]].

Mockito fue creado con el objetivo de simplificar y solucionar algunos de los temas antes mencionados. EasyMock y Mockito puede hacer exactamente las mismas cosas, pero Mockito tiene un API más natural y práctico de usar.

==Características principales==
# Se pueden crear mocks de interfaces y clases concretas.
# Verificación de invocaciones (cantidad exacta, al menos una vez, órden de invocación, etc.)
# El stack trace se mantiene limpio, ya que los errores ocurren en los assert que se hagan (y no dentro del método bajo prueba, como en EasyMock).
# Un API más clara para crear stubs y verificaciones

==Ejemplo de uso==
<code java>
import static org.mockito.Mockito.*;
.....
//creamos el mock y el stub
ArrayList instance = mock(ArrayList.class);
doReturn("hola mundo").when(instance).get(0);

//ejecutamos la lógica a probar
instance.get(0);

//verificamos que se hayan invocado los métodos
verify(instance).get(0);
</code>

==Más de una invocación a un mismo método==

Algunas veces necesitamos que un método retorne un valor y que en la segunda invocación retorne nulo o una excepción. Para eso, anidamos los retornos:

<code html4strict>

//Retornos para las 2 invocaciones
doReturn("algo").doReturn(null).when(instance).scrollNext();

//ejecutamos la lógica a probar
instance.unMetodoQueUsaScroll();

//verificamos que se haya invocado el mismo método dos veces
verify(instance, times(2)).scrollNext();

</code>

* [http://mockito.googlecode.com/svn/branches/1.5/javadoc/org/mockito/Mockito.html Leer más en Mockito API]

==Ejemplos de Mockito junto a PowerMock==

===Invocación a un método estático===

Para mockear métodos estáticos, según el [http://code.google.com/p/mockito/wiki/FAQ FAQ] de mockito, esto no es posible. Pero nombra 2 framewors que pueden resultarnos útil [http://jmockit.dev.java.net/ JMockit] y [http://code.google.com/p/powermock PowerMock]

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(ClaseConMetodosEstaticos.class)
public class DosIdeasTestCase {
@Test
public void testMetodo_conInvocacionAMetodosEstaticos() {

//PowerMockito mockea los metodos estaticos que se encuentren en la
//clase ClaseConMetodosEstaticos
PowerMockito.mockStatic(ClaseConMetodosEstaticos.class);

//Con mockito determinamos el retorno del metodo estatico
when(ClaseConMetodosEstaticos.firstStaticMethod(param)).thenReturn(value);

// ejecucion
instance.invocarMetodoEstatico();

//Por cada metodo estatico que se quiere verificar se debe invocar
//a PowerMockito.verifyStatic().
PowerMockito.verifyStatic();
ClaseConMetodosEstaticos.secondStaticMethod();
}
}
</code>

===Invocación a un método privado===

<code java>
public class PruebaMetodoPrivado {

public String decirHola(String nombre) {
return decirHolaNombre(nombre);
}

private String decirHolaNombre(String nombre) {
return "Hola "+nombre;
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(PruebaMetodoPrivado.class)
public class PruebaMetodoPrivadoTest {

@Spy
PruebaMetodoPrivado metodoPrivado = new PruebaMetodoPrivado();

@Test
public void mockMetodoPrivado() throws Exception {

Assert.assertEquals("Hola Juan", metodoPrivado.decirHola("Juan"));
doReturn("Chau Juan").when(metodoPrivado,"decirHolaNombre","Juan");
Assert.assertEquals("Chau Juan",metodoPrivado.decirHola("Juan"));
verifyPrivate(metodoPrivado,
Mockito.times(2)).invoke("decirHolaNombre","Juan");
}
}

</code>

===Inicialización de atributos estaticos===

<code java>
public class PruebaInicializacionEstaticos {

private static final String atributo = new String("CHAU");

public String crearObjetoLista() {
return atributo;
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@SuppressStaticInitializationFor("PruebaInicializacionEstaticos")
@PrepareForTest(PruebaInicializacionEstaticos.class)
public class PruebaMetodoPrivadoTest {

PruebaInicializacionEstaticos pruebaInicializacionEstaticos =
new PruebaInicializacionEstaticos();

@Test
public void controlCreacionLista() throws Exception {
Assert.assertNull(pruebaInicializacionEstaticos.retornarAtrinbuto());
String s = "Hola";
Whitebox.setInternalState(pruebaInicializacionEstaticos.class,"atributo", s);
Assert.assertEquals(s, pruebaInicializacionEstaticos.retornarAtrinbuto());
}
}
</code>

===Captura creación de objetos===

<code java>
public class PruebaCreacionObjeto {

public List crearObjetoLista() {
return new ArrayList();
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(PruebaCreacionObjeto.class)
public class PruebaMetodoPrivadoTest {

@Spy
PruebaCreacionObjeto pruebaCreacionObjeto = new PruebaCreacionObjeto();

@Test
public void controlCreacionLista() throws Exception {
List list = new ArrayList();
list.add("Hola");
whenNew(ArrayList.class).withNoArguments().thenReturn((ArrayList) list);
List resultado = pruebaCreacionObjeto.crearObjetoLista();
Assert.assertEquals(list, resultado);
verifyNew(ArrayList.class);
}
}
</code>

Para mas ejemplos de Mockito junto a PowerMock ver los [http://code.google.com/p/powermock/wiki/MockitoUsage13 ejemplos] provisto por la documentación de PowerMock.

[http://www.dosideas.com/descargas/category/3-testing.html?download=40 Descargar proyecto NetBeans demo de los ejemplos]

===PowerMockito & Cobertura===
Existe un problema al utilizar PowerMockito con Cobertura (versión 1.8.4), este último no registra la corrida de los test con anotación @PrepareForTest, dando como resultados falta de cobertura.
Para solucionar este inconveniente solo hay que actualizar la versión de Cobertura.

==Ejemplo de Mockito para mockear appender de log4j==

<code java>
//Inicializamos mock.
Appender mockAppender = mock(AppenderSkeleton.class);
//Inicializamos logger de la clase bajo test
Logger log = Logger.getLogger(ClaseATestear.class);
//Agregamos el mock del appender al logger.
log.addAppender(mockAppender);
//Seteamos el nivel de log que nos interesa recuperar.
log.setLevel(Level.DEBUG);
</code>

Para poder obtener los log que se produjeron utilizamos la clase ArgumentCaptor de mockito que nos permite, entre otras cosas, capturar los eventos de log.

<code java>
ArgumentCaptor loggingEventCaptor = ArgumentCaptor.forClass(LoggingEvent.class);

loggingEventCaptor.capture());
</code>

Una posible forma de obtener un mensaje particular es iterando la lista de mensajes que nos da la clase capturada.

<code java>
List<LoggingEvent> loggingEvent = (List<LoggingEvent>) loggingEventCaptor.getAllValues();
</code>

== BDDMockito ==
BDDMokcito es una clase alternativa que ofrece [[Mockito]] para crear pruebas al estilo [[Behavior Driven Development]] (BDD) (es decir, con bloques dado / cuando / entonces).

El problema es que el API de Mockito usa la palabra "when" y no se integra bien con los comentarios //given //when //then (según BDD, el stubbing forma parte del área //given, y no del //when).

BDDMockito agrega una clase que tiene alias para los métodos de stub, usando given(Object).

<code java5>
import static org.mockito.BDDMockito.*;

Vendedor vendedor = mock(Vendedor.class);
Negocio negocio = new Negocio(vendedor);

@Test
public void comprarPan() throws Exception {
//given
given(vendedor.buscarPan()).willReturn(new Pan());

//when
Compra compra = negocio.comprarPan();

//then
assertThat(compra, contienePan());
}
</code>

Stubbing con void y excepciones:
<code java5>
//given
willThrow(new RuntimeException("boo")).given(mock).foo();

//when
Result result = sistemaBajoPrueba.ejecutar();

//then
assertEquals(failure, result);
</code>

==Ver también==
* [[EasyMock]]
* [[Captura De Parametros]]
* [[Inyeccion De Mocks De Mockito Con Spring]]
* [http://www.dosideas.com/descargas/category/3-testing.html?download=11%3Ademo-de-mockito Proyecto de ejemplos con Mockito]
* [http://www.dosideas.com/java/242-mockito-o-basta-de-easymock.html Introducción a Mockito]
* [http://mockito.googlecode.com/svn/branches/1.8.0/javadoc/org/mockito/BDDMockito.html Javadoc de BDDMockito]

[[Category:TDD]]
[[Category:BDD]]
[[Category:JUnit]]

Mockito

2011-09-06T19:18:34Z

201.251.182.130: Deshecha la edición 6179 de 209.0.141.71 (disc.)

Google Guava

2011-09-02T17:52:52Z

201.251.182.130: /* Ver también */

[http://code.google.com/p/guava-libraries/ Google Guava] es un proyecto de Google que reúne un conjunto de librerías usadas internamente dentro de Google para sus proyectos que emplean Java. El propósito de la librería es simplificar el código empleado para realizar tareas que son comunes dentro de [[Java]] y que no están soportadas por las librerías estándar, de esta manera busca eliminar código propenso a errores.

== Maven ==

<code xml>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>r09</version>
</dependency>
</code>

Controlara última versión [http://mvnrepository.com/artifact/com.google.guava/guava aquí].

== Ejemplos ==

===CharMatcher===

Determina verdadero o falso para cualquier carácter java, también ofrece métodos básicos de tratamiento de texto.

==== and / or ====

<code java>
String input = "La fecha es : 01/01/2011";
CharMatcher charMatcher = CharMatcher.DIGIT.or(CharMatcher.is('/'));
String output = charMatcher.retainFrom(input);
System.out.println(output);

// Salida : 01/01/2011
</code>

==== negate ====

<code java>
String input = "MAYUSCULA minuscula";
CharMatcher charMatcher = CharMatcher.JAVA_LOWER_CASE.or(CharMatcher.WHITESPACE).negate();
String output = charMatcher.retainFrom(input);
System.out.println(output);

// Salida: MAYUSCULA
</code>

==== inRange ====

<code java>
String input = "Solo quedan los numeros 1, 2, 3, 4 que son menores a 5 ";
CharMatcher charMatcher = CharMatcher.inRange('0', '4').or(CharMatcher.WHITESPACE);
String output = charMatcher.retainFrom(input);
System.out.println(output);

// Salida: 1 2 3 4
</code>

=== Joiner ===

Une fragmentos de texto mediante un separador. también ofrece métodos básicos de tratamiento de texto.

==== join ====

<code java>
String[] nombres = {"Josefina", "Nacho", "Lali", "Coco"};
String output = Joiner.on(", ").join(nombres);
System.out.println(output);

// Salida: Josefina, Nacho, Lali, Coco
</code>

==== skipNulls ====

<code java>
String[] nombres = {null, "Josefina", null, "Nacho", null, "Lali", null, "Coco"};
String output = Joiner.on(", ").skipNulls().join(nombres);
System.out.println(output);

// Salida: Josefina, Nacho, Lali, Coco
</code>

==== useForNull ====

<code java>
String[] nombres = {null, "Josefina", null, "Nacho", null, "Lali", null, "Coco"};
String output = Joiner.on(", ").useForNull("n/a").join(nombres);
System.out.println(output);

// Salida: n/a, Josefina, n/a, Nacho, n/a, Lali, n/a, Coco
</code>

==== withKeyValueSeparator ====

<code java>
Map<Integer, String> map = newHashMap();
map.put(1, "Josefina");
map.put(2, "Nacho");
map.put(3, "Lali");
String output = Joiner.on(", ").withKeyValueSeparator(" -> ").join(map);
System.out.println(output);

// Salida: 1 -> Josefina, 2 -> Nacho, 3 -> Lali
</code>

=== Splitter ===

Divide cadenas de texto en subcadenas mediante el reconocimiento de un separador (también conocido como delimitador), este se puede definir mediante un carácter, una cadena literal, una expresión regular, un CharMatcher, o mediante el uso de una longitud fija.

==== split ====

Split retorna una instancia de Iterable en lugar de un Array.

<code java>
String input = "Josefina|Nacho|Lali";
Iterable<String> split = Splitter.on("|").split(input);
List<String> output = newArrayList(split);
System.out.println(output);

// Salida: [Josefina, Nacho, Lali]
</code>

==== fixedLength ====

<code java>
String input ="Josefina Nacho Lali ";
Iterable<String> splitted = Splitter.fixedLength(10).trimResults().split(input);
List<String> output = newArrayList(splitted);
System.out.println(output);

//Salida: [Josefina, Nacho, Lali]
</code>

==== onPattern ====

<code java>
String input ="Josefina Nacho Lali";
Iterable<String> splitted =
Splitter.onPattern("[a-z&&[aeiou]]").omitEmptyStrings().split(input);
List<String> output = newArrayList(splitted);
System.out.println(output);

// Salida: [J, s, f, n, N, ch, L, l]
</code>

=== Collection2 ===

Proporciona métodos estáticos para trabajar con colecciones.

==== filter ====

<code java>
List<String> input = newArrayList("Josefina","Nacho","Lali");
Collection<String> output =
Collections2.filter(input, new Predicate<String>() {

public boolean apply(String t) {
if (t.contains("i")) {
return true;
}
return false;
}
});

System.out.println(output);

// Salida: [Josefina, Lali]
</code>

==== transform ====

<code java>
List<String> input = newArrayList("Josefina", "Nacho", "Lali");
Collection<String> output =
Collections2.transform(input, new Function<String, String>() {

public String apply(String f) {
return f.replaceAll("fina","");
}
});

System.out.println(output);

// Salida: [Jose, Nacho, Lali]
</code>

=== Constraints ===

Restringe la carga de las colecciones medinate limitaciones.

==== constrainedCollection ====

<code java>
Constraint<String> debeContenerJoL = new Constraint<String>() {

@Override
public String checkElement(String s) {
checkNotNull(s);
if (!s.contentEquals("JL")) {
throw new IllegalArgumentException("No contiene J ni L");
}
return s;
}
};

Collection<String> input = newArrayList("Josefina");
Collection<String> output = constrainedCollection(input, debeContenerJoL);
output.add("Nacho");

// Salida:
Exception in thread "main" java.lang.IllegalArgumentException: No contiene J ni L
</code>

<code java>
Collection<String> input = newArrayList("Josefina");
Collection<String> output = constrainedCollection(input, notNull());
output.add(null);

// Salida:
Exception in thread "main" java.lang.NullPointerException
</code>

=== Ordering ===

Comparador con métodos para soportar funciones comunes.

==== sortedCopy ====

<code java>
List<String> input = newArrayList("Josefina","Nacho","Lali");

Ordering<String> ordering = Ordering.from(new Comparator< String>() {

@Override
public int compare(String string1, String string2) {
return Ints.compare(string1.length(), string2.length());

}
});

List<String> output = ordering.sortedCopy(input);
System.out.println(output);

// Salida: [Lali, Nacho, Josefina]
</code>

=== Multimap ===

Basicamente es un map en el que se pueden asignar muchos valores a una sola clave.

<code java>
Multimap<Integer, String> output = HashMultimap.create();
output.put(1, "Josefina");
output.put(2, "nacho");
output.put(3, "Lali");
output.put(1, "Josefina_2");
System.out.println(output);

// Salida: {1=[Josefina, Josefina_2], 2=[Bacho], 3=[lali]}
</code>

==== ImmutableSetMultimap ====

===== inline =====
<code java>
Multimap<Integer, String> output =
ImmutableSetMultimap.of(1, "Josefina", 2, "Nacho", 3, "Lali", 1, "Josefina_2");
System.out.println(output);

// Salida: {1=[Josefina, Josefina_2], 2=[Nacho], 3=[Lali]}
</code>

===== builder =====

<code java>
Multimap<Integer, String> output =
new ImmutableSetMultimap.Builder<Integer, String>()
.put(1, "Josefina")
.put(2, "Nacho")
.put(3, "Lali")
.put(1, "Josefina_2")
.build();
System.out.println(output);

// Salida: {1=[Josefina, Josefina_2], 2=[Bacho], 3=[Lali]}
</code>

=== Tables ===

Es una colección con columnas filas y valores. Permite el traspaso de una tabla a otra.

<code java>
Table<Integer, String, String> table = HashBasedTable.create();
table.put(1, "Hija", "Josefina");
table.put(1, "Sobrino", "Nacho");
table.put(1, "Pareja", "Lali");

Table output = Tables.transpose(table);

System.out.println(output);

// Salida: {Sobrino={1=Nacho}, Hija={1=Josefina}, Pareja={1=Lali}}
</code>

=== BiMap ===

Es un Map que solo permite valores únicos.

<code java>
BiMap<Integer, String> output = HashBiMap.create();
output.put(1, "Josefina");
output.put(2, "Lali");
output.put(3, "Josefina"); //IllegalArgumentException

// Salida:
Exception in thread "main" java.lang.IllegalArgumentException: value already present: Josefina

</code>

=== Throwables ===

Clase utilitaria que contiene métodos estáticos para el manejo de excepciones.

==== propagate ====

En el caso de que la excepción sea del tipo RuntimeException la lanza, de lo contrario crea una RuntimeException con la excepción recibida y la lanza.

<code java>
try {
throw new Exception("Error !!!");
} catch (Throwable t) {
throw Throwables.propagate(t);
}

// Salida:
Exception in thread "main" java.lang.RuntimeException: java.lang.Exception: Error !!!
at com.google.common.base.Throwables.propagate(Throwables.java:155)
at com.dosideas.guavalibrarydemo.Ejemplo.main(Ejemplo.java:92)
Caused by: java.lang.Exception: Error !!!
at com.dosideas.guavalibrarydemo.Ejemplo.main(Ejemplo.java:90)
</code>

=== Files ===

Clase con métodos útiles para el manejo de archovs.

==== readLines ====

<code java>
ClassLoader cla = App.class.getClassLoader();
File file = new File(cla.getResource("prueba.txt").getFile());
List<String> lines = Files.readLines(file, Charsets.UTF_8);
</code>

==Ver también==
* [http://code.google.com/p/dosideas-aplicaciones-modelo/source/browse/#svn Descargar con svn de nuestro proyecto en google-code la aplicación demo de Google Guava]
* [http://www.javacodegeeks.com/2011/09/google-guava-libraries-essentials.html Google Guava Libraries Essentials]
* [http://guava-libraries.googlecode.com/svn/tags/release09/javadoc/index.html Google Guava API]

[[Category:Java]]

Mockito

2011-08-23T13:34:14Z

201.251.182.130: /* Ejemplo de Mockito para mockear appender de log4j */

Mockito

2011-08-23T13:19:42Z

201.251.182.130:

Mockito es una librería [[Java]] para la creación de [[Mock Object]] muy usados para el testeo unitario en [[Test Driven Development]], basado en [[EasyMock]].

Mockito fue creado con el objetivo de simplificar y solucionar algunos de los temas antes mencionados. EasyMock y Mockito puede hacer exactamente las mismas cosas, pero Mockito tiene un API más natural y práctico de usar.

==Características principales==
# Se pueden crear mocks de interfaces y clases concretas.
# Verificación de invocaciones (cantidad exacta, al menos una vez, órden de invocación, etc.)
# El stack trace se mantiene limpio, ya que los errores ocurren en los assert que se hagan (y no dentro del método bajo prueba, como en EasyMock).
# Un API más clara para crear stubs y verificaciones

==Ejemplo de uso==
<code java>
import static org.mockito.Mockito.*;
.....
//creamos el mock y el stub
ArrayList instance = mock(ArrayList.class);
doReturn("hola mundo").when(instance).get(0);

//ejecutamos la lógica a probar
instance.get(0);

//verificamos que se hayan invocado los métodos
verify(instance).get(0);
</code>

==Más de una invocación a un mismo método==

Algunas veces necesitamos que un método retorne un valor y que en la segunda invocación retorne nulo o una excepción. Para eso, anidamos los retornos:

<code html4strict>

//Retornos para las 2 invocaciones
doReturn("algo").doReturn(null).when(instance).scrollNext();

//ejecutamos la lógica a probar
instance.unMetodoQueUsaScroll();

//verificamos que se haya invocado el mismo método dos veces
verify(instance, times(2)).scrollNext();

</code>

* [http://mockito.googlecode.com/svn/branches/1.5/javadoc/org/mockito/Mockito.html Leer más en Mockito API]

==Ejemplos de Mockito junto a PowerMock==

===Invocación a un método estático===

Para mockear métodos estáticos, según el [http://code.google.com/p/mockito/wiki/FAQ FAQ] de mockito, esto no es posible. Pero nombra 2 framewors que pueden resultarnos útil [http://jmockit.dev.java.net/ JMockit] y [http://code.google.com/p/powermock PowerMock]

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(ClaseConMetodosEstaticos.class)
public class DosIdeasTestCase {
@Test
public void testMetodo_conInvocacionAMetodosEstaticos() {

//PowerMockito mockea los metodos estaticos que se encuentren en la
//clase ClaseConMetodosEstaticos
PowerMockito.mockStatic(ClaseConMetodosEstaticos.class);

//Con mockito determinamos el retorno del metodo estatico
when(ClaseConMetodosEstaticos.firstStaticMethod(param)).thenReturn(value);

// ejecucion
instance.invocarMetodoEstatico();

//Por cada metodo estatico que se quiere verificar se debe invocar
//a PowerMockito.verifyStatic().
PowerMockito.verifyStatic();
ClaseConMetodosEstaticos.secondStaticMethod();
}
}
</code>

===Invocación a un método privado===

<code java>
public class PruebaMetodoPrivado {

public String decirHola(String nombre) {
return decirHolaNombre(nombre);
}

private String decirHolaNombre(String nombre) {
return "Hola "+nombre;
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(PruebaMetodoPrivado.class)
public class PruebaMetodoPrivadoTest {

@Spy
PruebaMetodoPrivado metodoPrivado = new PruebaMetodoPrivado();

@Test
public void mockMetodoPrivado() throws Exception {

Assert.assertEquals("Hola Juan", metodoPrivado.decirHola("Juan"));
doReturn("Chau Juan").when(metodoPrivado,"decirHolaNombre","Juan");
Assert.assertEquals("Chau Juan",metodoPrivado.decirHola("Juan"));
verifyPrivate(metodoPrivado,
Mockito.times(2)).invoke("decirHolaNombre","Juan");
}
}

</code>

===Inicialización de atributos estaticos===

<code java>
public class PruebaInicializacionEstaticos {

private static final String atributo = new String("CHAU");

public String crearObjetoLista() {
return atributo;
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@SuppressStaticInitializationFor("PruebaInicializacionEstaticos")
@PrepareForTest(PruebaInicializacionEstaticos.class)
public class PruebaMetodoPrivadoTest {

PruebaInicializacionEstaticos pruebaInicializacionEstaticos =
new PruebaInicializacionEstaticos();

@Test
public void controlCreacionLista() throws Exception {
Assert.assertNull(pruebaInicializacionEstaticos.retornarAtrinbuto());
String s = "Hola";
Whitebox.setInternalState(pruebaInicializacionEstaticos.class,"atributo", s);
Assert.assertEquals(s, pruebaInicializacionEstaticos.retornarAtrinbuto());
}
}
</code>

===Captura creación de objetos===

<code java>
public class PruebaCreacionObjeto {

public List crearObjetoLista() {
return new ArrayList();
}
}
</code>

<code java>
@RunWith(PowerMockRunner.class)
@PrepareForTest(PruebaCreacionObjeto.class)
public class PruebaMetodoPrivadoTest {

@Spy
PruebaCreacionObjeto pruebaCreacionObjeto = new PruebaCreacionObjeto();

@Test
public void controlCreacionLista() throws Exception {
List list = new ArrayList();
list.add("Hola");
whenNew(ArrayList.class).withNoArguments().thenReturn((ArrayList) list);
List resultado = pruebaCreacionObjeto.crearObjetoLista();
Assert.assertEquals(list, resultado);
verifyNew(ArrayList.class);
}
}
</code>

Para mas ejemplos de Mockito junto a PowerMock ver los [http://code.google.com/p/powermock/wiki/MockitoUsage13 ejemplos] provisto por la documentación de PowerMock.

[http://www.dosideas.com/descargas/category/3-testing.html?download=40 Descargar proyecto NetBeans demo de los ejemplos]

===PowerMockito & Cobertura===
Existe un problema al utilizar PowerMockito con Cobertura (versión 1.8.4), este último no registra la corrida de los test con anotación @PrepareForTest, dando como resultados falta de cobertura.
Para solucionar este inconveniente solo hay que actualizar la versión de Cobertura.

==Ejemplo de Mockito para mockear appender de log4j==

<code java>
//Inicializamos mock.
Appender mockAppender = mock(AppenderSkeleton.class);
//Inicializamos logger de la clase bajo test
Logger log = Logger.getLogger(ClaseATestear.class);
//Agregamos el mock del appender al logger.
log.addAppender(mockAppender);
//Seteamos el nivel de log que nos interesa recuperar.
log.setLevel(Level.DEBUG);
</code>

Para poder obtener los log que se producieron utilizamos la clase ArgumentCaptor de mockito que nos permite, entre otras cosas, capturar los eventos de log.

<code java>
ArgumentCaptor loggingEventCaptor = ArgumentCaptor.forClass(LoggingEvent.class);

loggingEventCaptor.capture());
</code>

Una posible forma de obtener un mensaje particular es iterando la lista de mensajes que nos da la clase capturada.

<code java>
List<LoggingEvent> loggingEvent = (List<LoggingEvent>) loggingEventCaptor.getAllValues();
</code>

== BDDMockito ==
BDDMokcito es una clase alternativa que ofrece [[Mockito]] para crear pruebas al estilo [[Behavior Driven Development]] (BDD) (es decir, con bloques dado / cuando / entonces).

El problema es que el API de Mockito usa la palabra "when" y no se integra bien con los comentarios //given //when //then (según BDD, el stubbing forma parte del área //given, y no del //when).

BDDMockito agrega una clase que tiene alias para los métodos de stub, usando given(Object).

<code java5>
import static org.mockito.BDDMockito.*;

Vendedor vendedor = mock(Vendedor.class);
Negocio negocio = new Negocio(vendedor);

@Test
public void comprarPan() throws Exception {
//given
given(vendedor.buscarPan()).willReturn(new Pan());

//when
Compra compra = negocio.comprarPan();

//then
assertThat(compra, contienePan());
}
</code>

Stubbing con void y excepciones:
<code java5>
//given
willThrow(new RuntimeException("boo")).given(mock).foo();

//when
Result result = sistemaBajoPrueba.ejecutar();

//then
assertEquals(failure, result);
</code>

==Ver también==
* [[EasyMock]]
* [[Captura De Parametros]]
* [[Inyeccion De Mocks De Mockito Con Spring]]
* [http://www.dosideas.com/descargas/category/3-testing.html?download=11%3Ademo-de-mockito Proyecto de ejemplos con Mockito]
* [http://www.dosideas.com/java/242-mockito-o-basta-de-easymock.html Introducción a Mockito]
* [http://mockito.googlecode.com/svn/branches/1.8.0/javadoc/org/mockito/BDDMockito.html Javadoc de BDDMockito]

[[Category:TDD]]
[[Category:BDD]]
[[Category:JUnit]]

Oracle BPM 11g

2011-08-10T14:25:29Z

201.251.182.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
# 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]

[[Category: Oracle]]

Oracle BPM 11g

2011-08-10T14:23:52Z

201.251.182.130: Página creada con '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 v…'

Oracle BPM

2011-08-10T14:15:48Z

201.251.182.130: /* Ver también */

[[Image:Bpm.jpg|left]] BPM, acrónimo de Business Process Management, en español Gestión de Procesos de Negocio, se identifica como uno de los tópicos más escuchados en lo que respecta a tecnologías aplicadas al entorno empresarial. Constituye una filosofía que acompañada de tecnología permite gestionar de forma integral la organización, administrando mejor la carga de trabajo entre las diferentes áreas.

¿ Qué es Oracle BPM ? Es un entorno de ejecución de procesos de negocios de empresas y está compuesto de diferentes aplicaciones y servicios que pueden ser instalados y configurados en diferentes topologías a manejar diferentes escenarios, soportando diferentes usos.

Un entorno BPM es la infraestructura técnica en la cuál se ejecutan procesos de negocio. Definimos entorno BPM como todos los componentes ejecutables (aplicaciones y servicios) que trabajan juntos para permitir la ejecución de procesos de negocio.

=== Infraestructura técnica ===

Algunos componentes deben estar siempre presente para el entorno de ejecución, mientras que otros dependen de la activación de características o requisitos externos. Oracle BPM soporta una variada combinación de estos componentes, que van desde muy sencillos y pequeños a toda la organización.

Los componentes que tienen que estar presentes:

* por lo menos un motor BPM con su correpondiente esquema de base de datos
* un directorio en el repositorio que contiene el esquema de base de datos
* la aplicación BPM, vista de usuario final
* la aplicación BPM, vista administrador

Los componentes opcionales:

* servidor LDAP
* más motores BPM
* un servicio de monitoreo de procesos
* múltiples áreas de trabajo de BPM
* clientes JAVA

=== Ejemplos de entornos Oracle BPM ===

Los siguientes gráficos proveen una vista de alto nivel de diferentes partes. Estos gráficos muestran 3 tipos de artefactos: cajas, puntos, y registros.

* Las cajas representan aplicaciones y servicios en el entorno.
* Los puntos representan los servicios expuestos por las aplicaciones (cajas).
* Las flechas representan una conexion entre una aplicación y un servicio expuesto por otro.

==== Ejemplo 1: ilustra la arquitectura generada con el wizard de Oracle BPM Enterprise Standalone ====

[[Archivo:BPM-imagen1.JPG]]

==== Ejemplo 2: ilustra la arquitectura generada con el wizard de Oracle BPM Enterprise for WebLogic ====

[[Archivo:BPM-imagen2.JPG]]

==== Ejemplo 3: entorno clusterizado a través de Oracle BPM Enterprise for WebLogic ====

Representea una topología escalable, típicamente usada en instalaciones grandes.

[[Archivo:BPM-imagen3.JPG]]

=== Componentes de un entorno BPM ===

Esta sección enfoca sobre las cajas presentadas en los gráficos de arriba. Las cajas representan la ejecución de aplicaciones como parte del entorno. Consideramos aplicaciones a procesos Java standalone, servidores web y de aplicaciones, aplicaciones web, aplicaciones JEE (EARs), servidores de base de datos, servidores LDAP.

Desde esta perspectiva, los componentes de un entorno BPM se pueden dividir en 3 grupos: BPM Core, BPM Clients y servicios de soporte. Cada entorno BPM contendrá componenetes en cada uno de estos grupos.

=== BPM Core ===

Hay 2 componentes principales: el motor BPM y el servicio de monitoreo de procesos.

==== Motor BPM ====

Es un componente que ejecuta procesos de negocio. El motor BPM es el elemento core de cada entorno BPM desde diferentes puntos de vista:

* desde un punto de vista lógico, es el responsable de crear, almacenar y mover alrededor de instancias de procesos desplegados en él
* desde un punto de vista de ejecución. un motor BPM es un servicio que ejecuta tareas de procesos que son definidas por procesos de BPM como actividades de procesos. Las ejecuciones pueden ser disparadas externamente por clientes o internamentes en el 'background'
* desde un punto de vista físico, el motor de BPM toma diferentes formas dependiendo de los productos seleccionados. Es un proceso java standalone en el caso de un enterprise standalone. Es una aplicación JEE en el caso de enterprise para weblogic y websphere

Hay muchos parámetros de configuración con los cuales adaptar el comportamiento de motores BPM, para cosas como hilos, puertos, conexiones a base de datos.

¿ Dónde definimos el motor BPM ?

Los motores BPM son creados en un directorio BPM. Esto es un repositorio metadata con todas las definiciones, incluyendo motores, organización de procesos y recursos. Cuando un motor comienza a ejecutar, este lee los parámetros del directorio BPM, y los procesos desplegados. Una vez que el motor es creado, este representa la definición lógica.

===== Motor BPM como una aplicación J2EE =====

El motor BPM J2EE ejecuta como una aplicación ear desplegada en un contenedor J2EE (WebLogic o WebSphere). El ear contiene EJBs, MDBs y Servlets que juntos conforman el motor BPM. Un archivo ear debe ser generado desde el proceso BPM administrador para cada motor BPM definido. Este archivo ear está desplegado en un servidor J2EE o cluster. Desplegando en un cluster, muchos servidores ejecutan motores BPM concurrentemente. Algún cluster puede responder el pedido de un proceso desplegado en el motor BPM.

===== Motor BPM como un proceso Java =====

El motor BPM sin dependencias ejectuta como un proceso java que se realiza en segundo plano y no requiere J2EE o contenedor web. Solamente un proceso Java ejecuta el motor, lo que se llama motor activo. Uno o más procesos Java pueden permanecer en modo pausa como soporte. Cuando el motor activo deja de responder uno de los motores pasivos toma el rol de motor activo. El motor BPM sin dependencias tiene sus propios hilos, conexiones, gestión de pedidos, y es altamente configurable.

===== Servicios expuestos del motor BPM =====

El motor de BPM expone varios servicios a través de los cuales puede comunicarse con clientes externos. Estas interfaces contienen operaciones a manipular, consultas, y crean instancias de procesos desplegados en el motor BPM. Estos servicios son representados por los puntos en las figuras de arriba.

===== Motores BPM y procesos de negocio =====

Los procesos de negocio suelen interactuar entre sí, por ejemplo, para dar inicio a un sub-proceso, o notificar a otro proceso de algún evento.

Desde una perspectiva de diseño, dos procesos que interactúan no es necesario que ejecuten en el mismo motor de BPM. El conocimiento y comunicación entre los motores BPM es manejado automáticamente por el motor. Sin embargo, en algunos casos es necesario configurar la ubicación del motor BPM.

Desde una perspectiva de cliente, diferentes versiones del mismo proceso pueden ser desplegados en diferentes motores. Clientes BPM conectan al directorio BPM, then conocen motores corriendo los procesos que les interesa y conectan a esos motores.

En la mayoria de ambientes BPM el total de procesos de negocio ejecutan en un motor BPM. En algunos casos, es necesario tener muchos motores ejecutando en el mismo ambiente BPM.

¿ Cuántos motores BPM en tu ambiente ?

Motores BPM son desplegados para procesos de negocio. Los procesos pueden ser desplegados en algún motor BPM definido en tu entorno BPM.

Desde el punto de vista de ejecución, un proceso es desplegado en un motor BPM, este no puede ser cambiado a otro, al menos que despliegues una nueva versión del proceso, uno activo y el otro deprecado.

Desde el punto de vista físico, los protocolos de comunicación a ser usado entre los motores BPM dependen de su tipo (independiente o JEE) y si los motores son definidos en el mismo. En el caso de motores JEE, los clientes BPM deben configurarse con las propiedades del motor BPM.

Hay dos posibles casos donde los motores BPM definidos en diferentes directorios BPM interactuan. En el primer caso, tenemos comunicación B2B entre diferentes organizaciones. Y la interacción es limitada a la comunicación interprocesos (IPC).

En el segundo caso, una organización muy grande tiene diferentes directorios BPM para diferentes divisiones o areas funcionales, más claro que centralizar los procesos en un único directorio BPM. En este escenario los usuarios finales deben ver las instancias de procesos ejecutando en motores BPM definidos en diferentes directorios BPM. Esto puede ser archivado por configuración de clientes BPM. El cliente BPM es el que agrega la información desde los motores y presenta una vista unificada al usuario.

==== Servicio de monitoreo de procesos ====

El Servicio de Control de Procesos es responsable de la construcción de la información global de las ejecuciones de instancias de procesos y métricas.

Desde el punto de vista lógico, el servicio busca nuevos eventos de instancias de procesos (creaciones, ejecuciones, terminaciones) que han ocurrido desde la última ejecución y transforma los acontecimientos en filas agregadas al tablero.

Desde el punto de vista del tiempo de ejecución, cada entorno tiene su propia instancia del servicio de monitore de procesos. Cada instancia consulta el esquema de base de datos de tiempo de ejecución de cada motor BPM definido en el directorio BPM en busca de nuevos eventos, que luego serán agregados.

Desde un punto de vista físico, el servicio funciona de forma continua como una JVM independiente en segundo plano, y es independiente del tipo de motor de BPM (Independiente, WebLogic, WebSphere) y si los motores se detienen o se inicia. El servicio no tiene interfaz de usuario y sólo lee los esquemas de base de datos del motor BPM, y escribe en los esquemas de base de datos específicos. Ya que se ejecuta independiente, se conecta a bases de datos utilizando drivers JDBC, haciendo conexiones directas, y no puede utilizar datasources de JEE.

El Servicio de Control de Procesos tiene un propósito muy específico y crítico. Sin esto, no recibe información precisa para mostrar en el tablero de control de los procesos. En algunos casos, cuando el servicio no ha estado funcionando durante mucho tiempo, debe leer y agregar muchos eventos, considerando tiempo y recursos considerables.

=== BPM Clients ===

Los clientes BPM son aplicaciones que interactuan con los procesos de negocio que ejecutan en los motores BPM.

La mayoría de los clientes de BPM se conectan a los motores de BPM a través de los servicios expuestos por el motor. Pero hay otro tipo de cliente BPM: los que interactúan con los procesos de negocio a través de recursos externos, como una cola JMS, un sistema de archivos, o una tabla de base de datos. En este caso es el proceso de negocio en sí - como parte de su definición - la que establece una interacción empujando y tirando de la información a través de estos recursos, la definición de un contrato con la entidad externa para intercambiar información. Desde el punto de vista de que el servicio de motores BPM utiliza el cliente para conectarse, tenemos dos grandes grupos: los clientes PAPI, que utilizan el servicio de proceso interno, y los clientes de servicios Web.

==== Cliente PAPI ====

Es el proceso API y refiere a la API de Java que este cliente usa para interactuar con el motor BPM. PAPI está embebido en muchas aplicaciones web. Realiza funciones críticas desde el punto de vista de usuario final. Está configurado para autenticar y autorizar usuarios finales, encuentra los procesos disponibles en el directorio BPM, conecta a los motores BPM que ejecutan dichos procesos, y retorna información a los usuarios finales. Es la única API de JAVA para la interacción de procesos.

===== Características de ejecución del cliente PAPI =====

PAPI está diseñado para soportar un portal de procesos interactivo. Algunas optimizaciones se realizaron para la perfomance de cliente PAPI, incluyendo cache en memoria de información acerca de procesos.

Un cliente PAPI requiere conectividad al directorio y al motor.

Los clientes PAPI no hablan entre si ni acceden a recursos utilizados por los procesos de negocio.

Los clientes PAPI pueden ejecutarse como procesos independientes de JAVA. Cada uno requiere una copia de la memoria caché y exige mucha memoria.

==== Area de trabajo BPM ====

El "workspace" o area de trabajo BPM es lo más importante en la aplicación de usuario final. El area de trabajo BPM es a los procesos de negocio lo que el Outlook es al mail: la principal aplicación de interacción. El area de trabajo BPM es un cliente PAPI, y tiene funcionalidad adicional que es importante entender. Desde la perspectiva de la topología, es una práctica saludable tener áreas de trabajo BPM siempre disponible. El area de trabajo BPM provee un montón de funcionalidad sobre PAPI: soporte a flujos de pantallas, tableros, diseños de páginas, etc. La aplicación también permite adaptar la interfaz de usuario a través de hojas de estilos y otras configuraciones. Autenticación y SSO (Single Sign On) tienen importantes consideraciones en el área de trabajo de BPM. El área de trabajo BPM puede confiar en el servidor web (Tomcat, Weblogic, etc) para autenticar y conectar a usuarios remotos.

==== Clientes Web Service (WS) ====

Pueden elegirse clientes WS entre dos servicios disponibles: los servicios "Process-WS" expuestos por el motor BPM y la aplicación "PAPI-WS".

El servicio "Process-WS" expone ciertas actividades del proceso de negocio como operaciones de WS. En particular, puede ser usado para crear nuevas instancias de procesos y enviar notificaciones a las instancias de procesos existentes. Las actividades de los procesos de negocio tienen que ser marcadas explícitamente como expuestas para ser agregadas al servicio. Técnicamente, este servicio es provisto por el mismo motor BPM. Cuando levanta el motor, lee todos los procesos definidos y busca cuales actividades están marcadas. La interfaz expuesta por el servicio es definida por el parámetro las actividades expuestas (creación y espera notificación), entonces la interfaz del servicio está directamente relacionada a la definición de los procesos.

El servicio "PAPI-WS" expone la mayoría de las operaciones de PAPI a través de una interfaz SOA. Este servicio está separado de la aplicación web PAPI-WS. Esta aplicación se despliega como cualquier otra aplicación web, y simula un servicio web alrededor de la funcionalidad PAPI. El servicio "PAPI-WS" es un cliente PAPI porque usa la API. La interfaz expuesta por el servicio es similar a la API, y esta es independiente de los procesos desplegados. PAPI-WS puede interactuar con cualquier proceso desplegado en el entorno.

==== Clientes de administracion ====

Esta categoría incluye el proceso administrador de BPM, la herramienta principal de administración junto con el área de trabajo de BPM y la vista de archivos. Estas aplicaciones web no son usadas para tareas diarias, y son importantes en la configuración y administración del entorno.

El proceso administrador proporciona configuración y administración para la organización, motores, recursos externos, procesos de negocio, y es usado para desplegar procesos de negocio en los motores BPM. Adicionalmente a la configuración técnica de la conexion del directorio BPM, el proceso administrador de BPM también maneja la configuración del resto del entorno.

Desde un punto de vista técnico, el proceso administrador de BPM requiere conectividad al directorio y a motores BPM en orden al monitoreo y control de los mismos (parar, comenzar). El proceso administrador BPM también puede crear el esquema de base de datos requerido por el motor BPM.

La aplicación administradora del área de trabajo de BPM es la responsable de configurar las vistas del área de trabajo (PAPI) y presentar la disponibilidad a los usuarios del área de trabajo. Utilizado por los dueños del negocio o administradores, quienes quieren proporcionar adaptaciones, vistas basadas en roles y presentaciones a usuarios. Por ejemplo, puede proporcionar una vista de seguimiento para los gestores y una cola de trabajo priorizada para los roles no gerenciales.

El visualizador de archivos BPM es una aplicación web que es usada para ver la información archivada de instancias de procesos. Esta información se saca de los motores BPM y se introduce en los archivos de base de datos.

==== Clasificación por tipo de aplicación ====

Hay varios tipos de procesos clientes, incluyendo aplicaciones de usuario final y sistemas backend. Las aplicaciones de usuario final pueden ser parte del producto, por ejemplo, área de trabajo BPM. La mayoría de los entornos tendrá al menos una aplicación de usuario final con la que los usuarios del proceso interctúan con el sitema. La aplicación a ser usada está basada en decisiones de diseño tomadas por el equipo de desrrollo. Estas aplicaciones deben ser comunicadas con el motor BPM en orden a acceder a la información de los procesos e invocar operaciones de los procesos.

¿ Cuántos clientes BPM en tu entorno ?

NO hay restricciones en el número y tipo de clientes BPM trabajando en un entorno BPM. Estas decisiones están basadas en la arquitectura del entorno. La mayoría de los entornos usan áreas de trabajo BPM, mientras que otros pueden optar por construir su propia interfaz de usuario, ya sea a través del PAPI o servicios web. Una tercera opción es escribir los servicios backend que llevan a cabo operaciones específicas en los procesos, como la creación de una instancia cuando llega un mensaje en una cola. Un punto de interés en estos entornos distribuidos es la sincronización de información a través de diferentes componentes. Por ejemplo, si una instancia de proceso está actualizada por una tarea ejecutada en el motor BPM, el estado actualizado de la instancia del proceso debe estar propagado a cualquier cliente PAPI que pueda estar escuchando para actualizaciones. Otro ejemplo es que si un nuevo proceso está desplegado, este debería aparecer inmediatamente en el área de trabajo de BPM y estar disponible para usar. La frecuencia y método de actualización de los diferentes componentes del entorno son consideraciones importantes en los cambios posibles de las propiedades del entorno.

=== Servicios de soporte ===

Un número de servicios de soporte son requeridos para el entorno BPM, incluyendo base de datos, LDAPs y servidores web y J2EE. Los requerimientos de servicio específico dependen de la configuración, topología, y el motor BPM.

==== Base de datos ====

Toda la configuración e información de ejecución se almacena en base de datos. En sistemas de archivos del servidor, se almacenan los archivos de log, cache. La BPM de Oracle requiere un esquema separado de base de datos por cada función específica:

* Requerido por cada directorio BPM: metadata
* Requerido por cada motor BPM: información de ejecución

===== Conexión a base de datos =====

Hay 2 maneras para que una aplicación BPM pueda obtener conexión a la base de datos: directamente, via los drivers de JDBC o usando datasources de J2EE. Las aplicaciones independientes como el administrador de BPM, el servicio de monitoreo de procesos y el motor independiente siempre usan los drivers JDBC.

==== Servidores de aplicaciones J2EE ====

Los servidores de aplicaciones pueden ser usados como contenedores para motores BPM y/o clientes BPM (área de trabajo BPM, por ejemplo). Cualquier combinación es soportado, asumiendo la configuración correspondiente. Por ejemplo: un área de trabajo BPM corriendo en Weblogic puede ser conectada a un motor BPM independiente. Un cliente java PAPI independiente puede ser conectado a un motor BPM desplegado en Weblogic o WebSphere, motores BPM siempre ejecutan como una aplicación J2EE instalada en un servidor o un clúster.

==== Recursos J2EE usados por el motor BPM ====

Los motores BPM que ejecutan en un servidor de aplicaciones J2EE utilizan datasources para acceder al esquema del directoio y motor. Adicionalmente a estos esquemas requeridos, cada motor BPM requiere dos recursos de mensajeria: una cola y un topic. Estos recursos JMS son necesarios para archivar funcionalidad que el motor BPM independiente puede implementar sin ellos. Los servidores de aplicación no proporcionan un framework para las ejecuciones en segunod plano, entonces las colas JMS son usadas como disparadores de eventos en segundo plano con un MDB. El motor BPM genera un mensaje cuando una tarea tiene que ejecutar. El MDB levanta el mensaje y ejecuta la tarea. El topic JMS se usa para enviar información a los clientes PAPI. Los motores BPM necesitan una forma de propagar los cambios a todos los clientes PAPI, y estos clientes esperan mensajes en estos topicos. El motor BPM coloca un mensaje en el topic cuando hay noticias para publicar, y los clientes leen los mensajes y actualizan la memoria interna. Entonces, el motor BPM es el publicador y los clientes PAPI son los suscriptores.

==== Portal web: centro de integracion web, portal weblogic ====

La BPM de Oracle está integrada con portales en diferentes formas. Algunas aplicaciones web de BPM, área de trabajo BPM particulares, pueden ser navegadas a través del centro de integración web (WCI) o del portal weblogic (WLP). Otra alternatiba es construir portles, usando PAPI. Este último caso no es diferente de cualquiere adaptación de una aplicación PAPI.

Desde el punto de vista físico, el área de trabajo de BPM ejecuta separado de JVM, tipicamente se construye en un servidor Tomcat, y se comunica con WCI remotamente. Para la integración del directorio BPM, la información del WCI es accedida de la misma manera que con cualquier proveedor LDAP.

==== Portal weblogic de integracion (WLP) ====

La integración con este portal se logra mediante la creación de un portal de aplicaciones que incluye un área de trabajo BPM de portlets, además de todas las librerías del cliente PAPI. Esta aplicación se instala en WLP, y de ese modo se incorpora en el portal.

Desde el punto de vista físico, el área de trabajo de BPM del portal de aplicaciones ejecuta sobre el proceso java WLP, de la misma forma que el área de trabajo BPM de las aplicaciones web que ejecutan en Tomcat o Weblogic.

==== LDAPs ====

Son usados como fuente de información de la organización, específicamente usuarios, unidades organizacionales y grupos. Esta integración es muy flexible y configurable.

===== Integración técnica =====

Desde un punto de vista técnico, LDAP se convierte en parte de los metadatos del directorio, por lo que cualquier aplicación que requiere acceso al directorio BPM (por ejemplo, los motores BPM, los clientes PAPI, el proceso administrador). Dado que el acceso a LDAP es de sólo lectura, se utiliza el acceso anónimo. No obstante, puede configurarse la conexión segura y la autenticación. Generalmente, las conexiones LDAP se utilizan a través de un pool para mejorar el rendimiento, y la autenticación se utiliza con usuario/contraseña que proporciona LDAP. Luego, el proceso de autorización se maneja con el esquema de directorio BPM.

===== Integración funcional =====

BPM define usuarios, grupos y unidades de la organización en una estructura única y bien definida. Esto difiere de cómo muchas organizaciones definen los conceptos. Por ejemplo, Oracle BPM definie que un usuario solo puede pertenecer a una unidad de organización, asigna funciones a los usuarios y grupos, mientras que algunas organizaciones podrían asignar funciones a la unidad organizativa. Es importante entender que en todos los casos la estructura LDAP tiene que estar mapeada con el modelo de organización de la BPM.

=== Servicios requeridos por el proceso de negocio ===

Si tus procesos de negocio integran con otros sistemas (web service, colas, etc), estos se convierten en parte de tu entorno BPM y son necesarios para que tus procesos ejecuten. La configuración de estos recursos se realiza sobre todo en el proceso administrador de BPM.

=== Servicios provistos por componentes BPM ===

El proveedor de servicios más importante es el motor BPM. Cada operación instancia de proceso se produce en el motor de BPM y la dispara automáticamente el motor, o externamente un cliente BPM. El principal servicio expuesto por el motor BPM es el servicio de procesos interno. Este servicio es usado por PAPI para interactuar con el motor. Cada cliente PAPI usa este servicio para consultar e invocar instancias del proceso.

==== Servicio de proceso del motor BPM ====

Desde el punto de vista lógico, el servicio de proceso del motor BPM expone una interfaz a través de diferentes protocolos:

* protocolo Java RMI, si es una implementación standalone
* EJBs, que utilizan el protocolo del servidor de aplicaciones (wl, t3, loop, etc) en las implementaciones en wl y websphere. Los EJBs forman parte de la aplicación ear, que se instala en el servidor de aplicaciones como motor BPM.

Los clientes PAPI ubican automáticamente los motores y seleccionan el protocolo adecuado en función del tipo de motor.

=== Elección de una topología ===

Muchos factores pueden influir la selección de una topología:

* Carga de los procesos de negocio: el número de instancias de proceso, las actividades en el proceso, y personas que interactuan con el proceso
* Aprovechamiento de infraestructura existente: servidores wl, etc
* Aprovechamiento de conocimientos existentes: J2EE, Java
* Políticas institucionales, por ejemplo, separar backend del frontend
* Confiabilidad, disponibilidad y requisitos de performance
* Costo

=== Guia para definir una topología ===

Algunas pautas según las capacidades del producto:

* Definir al menos un motor de BPM
* Los procesos pueden ser desplegados en ninguno de los motores definidos
* Cada motor de BPM se puede configurar independiente y optimizado para casos de uso específicos
* Puede haber muchos clientes BPM según se necesiten
* El área de trabajo de BPM y los clientes PAPI pueden estar en el mismo servidor que el motor de BPM o en otro diferente
* Los clientes PAPI pueden implementarse en cluster o en granja de servidores
* Cada cliente PAPI pude configurarse de forma independiente
* Los clientes PAPI pueden interactuar con cualquiera de los procesos
* Los motores de BPM, clientes PAPI y todas las aplicaciones de BPM requieren conexión con el directorio BPM
* El área de trabajo BPM y el motor BPM son aplicaciones que consumen muchos recursos. La decisión de ubicar en el mismo servidor de destino o grupo tiene importantes implicaciones en el rendimiento
* La comunicación entre el área de trabajo BPM y el motor BPM requiere de una configuración específica, dependiendo de si están en diferentes grupos o dominios. Es más fácil de configurar desplegados en diferentes dominios en lugar de grupos diferentes

=== Requisitos ===

*
*

=== Demo ===

*
*

=== Problemas y soluciones ===

*

=== Ver también ===

* [http://www.oracle.com/technetwork/articles/bpm-environment-explained-097155.html Nota original de entorno BPM explicado]
* [[BEA Aqualogic BPM 5.7 (Fuego)]]
* [[Oracle BPM 11g]]

[[Category:Oracle]]

Servidor de Aplicaciones

2011-08-10T14:15:07Z

201.251.182.130:

[[Category:Java]]
Se denomina Servidor de Aplicaciones (Application Server) a un servidor en una red de computadores que ejecuta ciertas aplicaciones

Usualmente se trata de un dispositivo de software que proporciona servicios de aplicación a las computadoras cliente. Un servidor de aplicaciones generalmente gestiona la mayor parte (o la totalidad) de las funciones de lógica de negocio y de acceso a los datos de la aplicación. Los principales beneficios de la aplicación de la tecnología de servidores de aplicación son la centralización y la disminución de la complejidad en el desarrollo de aplicaciones. Si bien el término es aplicable a todas las plataformas de software, hoy en día el término servidor de aplicaciones se ha convertido en sinónimo de la plataforma [[Java EE]] de Sun Microsystems.

Existen diversos Application Servers JEE en el mercado:
* [[GlassFish]] (software libre)
* [[JBoss Application Server]] (software libre)
* IBM [[WebSphere]] (comercial)
* Oracle [[WebLogic]] (comercial)
* [[Oracle BPM]] (comercial)

==Ver también==
* [http://es.wikipedia.org/wiki/Servidor_de_aplicaciones Servidor de aplicaciones en la Wikipedia]
* [http://www.theserverside.com/tt/articles/article.tss?l=WhatIsAnAppServer What is an application server?]

HTML

2011-07-08T20:16:18Z

201.251.182.130: Página creada con ' * Tablas en HTML'

* [[Tablas en HTML]]

Spring Integration

2011-07-07T14:25:25Z

201.251.182.130: /* Ver también */

[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://code.google.com/p/dosideas-aplicaciones-modelo/source/browse/#svn Descargar con svn de nuestro proyecto en google-code la aplicación demo de Spring Integration]
* [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:23:48Z

201.251.182.130: /* Ver también */

[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://code.google.com/p/dosideas-aplicaciones-modelo/source/browse/#svn Descarga de nuestro proyecto en google-code la aplicación demo de Spring Integration]
* [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:23:21Z

201.251.182.130: /* Ver también */

[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://code.google.com/p/dosideas-aplicaciones-modelo/source/browse/#svn Descarga de nuestro proyecto en google-code la aplicación demo de Spring Integration]
* [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]]
[[Category:JDBC]]
[[Category:TCP]]
[[Category:UDP]]
[[Category:FTP]]

Spring Integration

2011-07-07T14:20:32Z

201.251.182.130: /* Ver también */

[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==
* [https://code.google.com/p/dosideas-aplicaciones-modelo/source/browse/#svn Descarga de nuestro proyecto en google-code la aplicación demo de Spring Integration]
* [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]]
[[Category:JDBC]]
[[Category:TCP]]
[[Category:UDP]]
[[Category:FTP]]

Spring Integration

2011-07-07T14:18:54Z

201.251.182.130: /* Ver también */

[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://dosideas-aplicaciones-modelo.googlecode.com/svn/spring-integration-demo/trunk Descarga de nuestro proyecto en google-code la aplicación demo de Spring Integration]
* [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]]
[[Category:JDBC]]
[[Category:TCP]]
[[Category:UDP]]
[[Category:FTP]]

Spring Integration

2011-07-07T14:17:21Z

201.251.182.130: /* Ver también */

[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://dosideas-aplicaciones-modelo.googlecode.com/svn/spring-integration-demo/trunk Descarga con svn nuestra ultima aplicación demo de Spring Integration]
* [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]]
[[Category:JDBC]]
[[Category:TCP]]
[[Category:UDP]]
[[Category:FTP]]

Closures o Clausuras de Javascript

2011-06-28T15:53:06Z

201.251.182.130: Página creada con 'Category:JavaScript ==Closures o Clausuras de JavaScript== El concepto es "clausurar" el contexto en el que se ejecuta una funcion, a esta funcion se la denomina ''Clos…'

[[Category:JavaScript]]
==Closures o Clausuras de [[JavaScript]]==

El concepto es "clausurar" el contexto en el que se ejecuta una funcion, a esta funcion se la denomina ''Closure''.

===Como funcionan?===

En donde se encuentra una funcion dentro de otra, la funcion interna tiene acceso a las variables de la funcion externa.

<code javascript>
function externa(x) {
var variable = 3;

function interna(y) {
alert(x + y + (++variable));
}

interna(10);
}

externa(2);
</code>

Esto siempre dará un alert de 16, porque ''interna()'' puede acceder a la ''x'' que fue definida como argumento en ''externa()'' y tambien puede acceder a ''variable'' de ''externa()''.

Eso '''NO''' es un ''closure''. Un ''closure'' es cuando se retorna la funcion interna y esta misma cierra sus variables externas antes de salir.

<code javascript>
function externa(x) {
var variable = 3;

return function (y) {
alert( x + y + (++variable) );
}

}
var interna = externa(2); // interna es ahora un closure.
interna(10);
</code>

Tambien retornará un alert de 16, porque ''interna()'' todavia puede referenciar a ''x'' y ''variable'', aunque ya no este directamente dentro del alcance de ''externa()''.

Sin embargo, como ''variable'' todavía esta siendo manejada dentro del closure ''interna()'', va a continuar incrementandose cada vez que ''interna()'' sea llamada, a diferencia del ejemplo anterior.

===Importante cuando trabajamos con Closures===

En el último ejemplo ''x'' es un número literal y como todo literal en javascript, cuando se llame a ''externa()'' el numero ''x'' es copiado en la funcion como argumento.

Por otro lado, javascript siempre utiliza referencias cuando trabaja con Objetos. Por ejemplo, si llamamos a ''externa()'' con un objeto, '''el closure que retornará estará referenciado al objeto original'''.

<code javascript>
function externa(x) {
var variable = 3;

return function (y) {
alert(x + y + variable);
x.unaProp = x.unaProp ? x.unaProp + 1 : 1;
alert(x.unaProp);
}

}

var edad = new Number(2);
var interna = externa(edad); // interna es una closure referenciando al objeto edad.
interna(10);
</code>

Como es esperado, cada llamada a ''interna()'' incrementará ''x.unaProp''. Lo que puede no ser esperado es que ''x'' está referenciando al mismo objeto que guarda ''edad'', luego de un par de llamadas a ''interna()'' ''edad.unaProp'' valdrá 2.

==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]

==Fuente==
* [http://stackoverflow.com/questions/111102/how-do-javascript-closures-work Stackoverflow: How do JavaScript closures work?]

JavaScript

2011-06-28T15:18:21Z

201.251.182.130:

[[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.

[[Closures o Clausuras de Javascript]]

==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]

SoapUI

2011-05-31T18:13:17Z

201.251.182.130: /* Conclusión */

[[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>

|}

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>

|}
{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Parametros-Peticion.jpg|center|Editar Parametros Peticion
default [[SoapUI]]
desc none
</imagemap>

|}

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>

|}

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>

|}

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

|}

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

|}

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>

|}

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.

==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>

|}

==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]]

SoapUI

2011-05-31T18:13:05Z

201.251.182.130: /* Conclusión */

[[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>

|}

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>

|}
{| width="80%" align="center" border="0"
|-
| <imagemap>
Image:SoapUI-Parametros-Peticion.jpg|center|Editar Parametros Peticion
default [[SoapUI]]
desc none
</imagemap>

|}

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>

|}

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>

|}

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

|}

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

|}

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>

|}

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.

==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>

|}

==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.
cccc

==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]]

Configuración de ejecución selectiva de tests

2011-05-02T18:14:51Z

201.251.182.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:14:31Z

201.251.182.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 IDE]] compilados con [[Apache 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>

Selenium con DSL

2011-04-29T12:35:02Z

201.251.182.130: /* Ejemplo */

[[Selenium]] es una herramienta para pruebas de aplicaciones web. Quién tuvo la posibilidad de utilizarla, sabrá lo poderosa que es la herramienta, la cuál tiene diversas funciones para ejecutar con nuestra aplicación web.
Puede ocurrir, que nuestros test de [[Selenium]] se vayan complejizando a medida que nuestra aplicación crece, por lo que esta es una posible solución, combinando el poder de [[Selenium]] con un enfoque [[DSL]].

== Ejemplo ==
A continuación mostramos una propuesta de como encarar un test de [[Selenium]]con [[DSL]]. Para el ejemplo, suponemos un sistema de biblioteca, con las siguientes pantallas y su navegación.
Se puede observar que pare este sistemas planteamos dos roles de usuario, el Bibliotecario y el Socio.

[[Archivo:reservaLibro.jpg]]

=== Creando un test ===
En el siguiente test, vamos a probar la funcionalidad de la reserva de libro.
Para escribir el siguiente test, se utilizó una sintaxis acotada y simple con las siguientes reglas:

* '''ir'''''<NombreDeLaPagina>'': Los métodos que comiencen con el prefijo “ir”, nos retorna el nuevo contexto (página).
* '''verificar'''''<Descripción>'': Los métodos que comiencen con el prefijo "verificar", poseen los “assert” para comprobar alguna acción realizada en la página, este método siempre retona la misma página (this).
* '''ingresarComo'''''<Nombre del Rol>'': Rol con el que se probará el sistema.
* '''aceptar, cancelar, volver, buscar''': Son nombre de las acciones básica que se realizan en un página y pueden (o nó) devolver otra página.
* ''<acciones propias de la página>'' : Estos métodos realizan acciones sobre el sistema sin ir a otra página. Ej.: reservar

==== ReservaSeleniumDslTest ====
<code java>
package com.test.dsl;

import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class ReservaSeleniumDslTest {

@BeforeClass
public static void setUpClass() throws Exception {
Usuario.inicializar();
}

@AfterClass
public static void tearDownClass() throws Exception {
Usuario.finalizar();
}

@Test
public void comoBibliotecarioQuieroRealizarUnaReserva() {
Usuario.ingresaComoBibliotecario()
.irReservaDeLibro()
.reservar()
.aceptar()
.verificarReserva()
.aceptar()
.salir();
}
}
</code>

De esta forma, escribimos el test de manera que al leer los métodos a los que se invoca, se entiende paso a paso lo que el test realiza, sin confundirnos con la implementación. Utilizando los patrones "method chaining" , "builder", "Page object" ayuda a realizar una abstracción de la implementación.

A continuación las implementaciones de las clases utilizadas.

==== Usuario ====

<code java>
package com.test.dsl;

import org.openqa.selenium.server.SeleniumServer;

import com.test.dsl.pagina.HomeBibliotecario;
import com.test.dsl.pagina.HomeUsuario;
import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;

public class Usuario {

public static final String TIEMPO_ESPERA = "90000";
public static final String VELOCIDAD_CERO = "0";
public static final String VELOCIDAD_TEST = "350";

private static SeleniumServer seleniumServer;
private static Selenium selenium ;

public static void inicializar() throws Exception {
seleniumServer = new SeleniumServer();
seleniumServer.start();
selenium = new DefaultSelenium("localhost", 4444, "*chrome", "http://localhost:8585/");
selenium.start();
}

public static void finalizar() {
selenium.stop();
seleniumServer.stop();
}

public static HomeBibliotecario ingresaComoBibliotecario() {
Usuario.login("bibliotecario_test","123456");
return new HomeBibliotecario(selenium);
}

public static HomeUsuario ingresaComoUsuario() {
Usuario.login("usuario_test","123456");
return new HomeUsuario(selenium);
}

private static void login(String username, String password) {
selenium.open("");
selenium.waitForPageToLoad(TIEMPO_ESPERA);
selenium.type("username", username);
selenium.type("password", password);
selenium.click("submitbutton");
selenium.waitForPageToLoad(TIEMPO_ESPERA);

}
}

</code>

Esta clase es la que determina con que rol vamos a probar la aplicación.
El método '''ingresarComoBibliotecario''' instancia y devuelve un objeto de la clase '''HomeBibliotecario''' cuya implementación es:

==== HomeBibliotecario ====
<code java>
package com.test.dsl.pagina;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class HomeBibliotecario {

private Selenium selenium;

public HomeBibliotecario(Selenium selenium) {
this.selenium = selenium;
}

public ReservaDeLibro irReservaDeLibro() {
selenium.click("link=ReservaLibro");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new ReservaDeLibro(selenium);
}

public void salir() {
selenium.click("link=logout");
}
}
</code>

Volvemos a utilizar el patrón builder y el método ingresar denuncia devuelve un objeto de la clase AltaDenuncia. De esta manera, cada clase representa a una pantalla de la aplicación, y expone cada funcionalidad que la misma ofrece. AltaDenuncia sería así:
Volvemos a utilizar el patrón method chaining y el método '''irReservaDeLibro''' devuelve un objeto de la clase '''ReservaDeLibro'''. De esta manera, cada clase representa a una pantalla de la aplicación (page object), y expone cada funcionalidad que la misma ofrece (acciones que puedo realizar en la página y páginas a la que puedo acceder)

==== ReservaDeLibro ====
<code java>
package com.test.dsl.pagina;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class ReservaDeLibro {

private Selenium selenium;

public ReservaDeLibro(Selenium selenium) {
this.selenium = selenium;
}

public ReservaDeLibro reservar() {
selenium.type("libro", "El señor de los anillos");
selenium.type("codSocio", "0001");
selenium.type("fechaHasta", "2011-01-01");
return this;
}

public ComprobanteDeLibro aceptar() {
selenium.click("submitbutton");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new ComprobanteDeLibro(selenium);
}
}
</code>

==== ComprobanteDeLibro ====
<code java>
package com.test.dsl.pagina;

import org.junit.Assert;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class ComprobanteDeLibro {
private Selenium selenium;

public ComprobanteDeLibro(Selenium selenium) {
this.selenium = selenium;
}

public ComprobanteDeLibro verificarReserva() {
Assert.assertTrue(selenium.isTextPresent("El señor de los anillos"));
Assert.assertTrue(selenium.isTextPresent("0001"));
Assert.assertTrue(selenium.isTextPresent("2011-01-01"));
return this;
}

public HomeBibliotecario aceptar() {
selenium.click("submitbutton");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new HomeBibliotecario(selenium);
}
}

</code>

Tanto el aceptar (como el cancelar en ReservaDeLibro), devuelven la home del bibliotecario.

== Conclusiones ==

El resultado de hacer los test de esta manera, es la facilidad de escritura y mantenimiento del test en si mismo. A su vez, se podría diseñar las clases a utilizar en el DSL a conveniencia.

Selenium con DSL

2011-04-29T12:30:53Z

201.251.182.130: /* Creando un test */

[[Selenium]] es una herramienta para pruebas de aplicaciones web. Quién tuvo la posibilidad de utilizarla, sabrá lo poderosa que es la herramienta, la cuál tiene diversas funciones para ejecutar con nuestra aplicación web.
Puede ocurrir, que nuestros test de [[Selenium]] se vayan complejizando a medida que nuestra aplicación crece, por lo que esta es una posible solución, combinando el poder de [[Selenium]] con un enfoque [[DSL]].

== Ejemplo ==
A continuación mostramos una propuesta de como encarar un test de [[Selenium]]con [[DSL]]. Para el ejemplo, suponemos un sistema de biblioteca, con las siguientes pantallas y su navegación.
Se puede observar que pare este sistemas planteamos dos roles de usuario, el Bibliotecario y el Socio.

=== Creando un test ===
En el siguiente test, vamos a probar la funcionalidad de la reserva de libro.
Para escribir el siguiente test, se utilizó una sintaxis acotada y simple con las siguientes reglas:

* '''ir'''''<NombreDeLaPagina>'': Los métodos que comiencen con el prefijo “ir”, nos retorna el nuevo contexto (página).
* '''verificar'''''<Descripción>'': Los métodos que comiencen con el prefijo "verificar", poseen los “assert” para comprobar alguna acción realizada en la página, este método siempre retona la misma página (this).
* '''ingresarComo'''''<Nombre del Rol>'': Rol con el que se probará el sistema.
* '''aceptar, cancelar, volver, buscar''': Son nombre de las acciones básica que se realizan en un página y pueden (o nó) devolver otra página.
* ''<acciones propias de la página>'' : Estos métodos realizan acciones sobre el sistema sin ir a otra página. Ej.: reservar

==== ReservaSeleniumDslTest ====
<code java>
package com.test.dsl;

import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class ReservaSeleniumDslTest {

@BeforeClass
public static void setUpClass() throws Exception {
Usuario.inicializar();
}

@AfterClass
public static void tearDownClass() throws Exception {
Usuario.finalizar();
}

@Test
public void comoBibliotecarioQuieroRealizarUnaReserva() {
Usuario.ingresaComoBibliotecario()
.irReservaDeLibro()
.reservar()
.aceptar()
.verificarReserva()
.aceptar()
.salir();
}
}
</code>

De esta forma, escribimos el test de manera que al leer los métodos a los que se invoca, se entiende paso a paso lo que el test realiza, sin confundirnos con la implementación. Utilizando los patrones "method chaining" , "builder", "Page object" ayuda a realizar una abstracción de la implementación.

A continuación las implementaciones de las clases utilizadas.

==== Usuario ====

<code java>
package com.test.dsl;

import org.openqa.selenium.server.SeleniumServer;

import com.test.dsl.pagina.HomeBibliotecario;
import com.test.dsl.pagina.HomeUsuario;
import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;

public class Usuario {

public static final String TIEMPO_ESPERA = "90000";
public static final String VELOCIDAD_CERO = "0";
public static final String VELOCIDAD_TEST = "350";

private static SeleniumServer seleniumServer;
private static Selenium selenium ;

public static void inicializar() throws Exception {
seleniumServer = new SeleniumServer();
seleniumServer.start();
selenium = new DefaultSelenium("localhost", 4444, "*chrome", "http://localhost:8585/");
selenium.start();
}

public static void finalizar() {
selenium.stop();
seleniumServer.stop();
}

public static HomeBibliotecario ingresaComoBibliotecario() {
Usuario.login("bibliotecario_test","123456");
return new HomeBibliotecario(selenium);
}

public static HomeUsuario ingresaComoUsuario() {
Usuario.login("usuario_test","123456");
return new HomeUsuario(selenium);
}

private static void login(String username, String password) {
selenium.open("");
selenium.waitForPageToLoad(TIEMPO_ESPERA);
selenium.type("username", username);
selenium.type("password", password);
selenium.click("submitbutton");
selenium.waitForPageToLoad(TIEMPO_ESPERA);

}
}

</code>

Esta clase es la que determina con que rol vamos a probar la aplicación.
El método '''ingresarComoBibliotecario''' instancia y devuelve un objeto de la clase '''HomeBibliotecario''' cuya implementación es:

==== HomeBibliotecario ====
<code java>
package com.test.dsl.pagina;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class HomeBibliotecario {

private Selenium selenium;

public HomeBibliotecario(Selenium selenium) {
this.selenium = selenium;
}

public ReservaDeLibro irReservaDeLibro() {
selenium.click("link=ReservaLibro");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new ReservaDeLibro(selenium);
}

public void salir() {
selenium.click("link=logout");
}
}
</code>

Volvemos a utilizar el patrón builder y el método ingresar denuncia devuelve un objeto de la clase AltaDenuncia. De esta manera, cada clase representa a una pantalla de la aplicación, y expone cada funcionalidad que la misma ofrece. AltaDenuncia sería así:
Volvemos a utilizar el patrón method chaining y el método '''irReservaDeLibro''' devuelve un objeto de la clase '''ReservaDeLibro'''. De esta manera, cada clase representa a una pantalla de la aplicación (page object), y expone cada funcionalidad que la misma ofrece (acciones que puedo realizar en la página y páginas a la que puedo acceder)

==== ReservaDeLibro ====
<code java>
package com.test.dsl.pagina;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class ReservaDeLibro {

private Selenium selenium;

public ReservaDeLibro(Selenium selenium) {
this.selenium = selenium;
}

public ReservaDeLibro reservar() {
selenium.type("libro", "El señor de los anillos");
selenium.type("codSocio", "0001");
selenium.type("fechaHasta", "2011-01-01");
return this;
}

public ComprobanteDeLibro aceptar() {
selenium.click("submitbutton");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new ComprobanteDeLibro(selenium);
}
}
</code>

==== ComprobanteDeLibro ====
<code java>
package com.test.dsl.pagina;

import org.junit.Assert;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class ComprobanteDeLibro {
private Selenium selenium;

public ComprobanteDeLibro(Selenium selenium) {
this.selenium = selenium;
}

public ComprobanteDeLibro verificarReserva() {
Assert.assertTrue(selenium.isTextPresent("El señor de los anillos"));
Assert.assertTrue(selenium.isTextPresent("0001"));
Assert.assertTrue(selenium.isTextPresent("2011-01-01"));
return this;
}

public HomeBibliotecario aceptar() {
selenium.click("submitbutton");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new HomeBibliotecario(selenium);
}
}

</code>

Tanto el aceptar (como el cancelar en ReservaDeLibro), devuelven la home del bibliotecario.

== Conclusiones ==

El resultado de hacer los test de esta manera, es la facilidad de escritura y mantenimiento del test en si mismo. A su vez, se podría diseñar las clases a utilizar en el DSL a conveniencia.

Selenium con DSL

2011-04-29T12:30:03Z

201.251.182.130:

[[Selenium]] es una herramienta para pruebas de aplicaciones web. Quién tuvo la posibilidad de utilizarla, sabrá lo poderosa que es la herramienta, la cuál tiene diversas funciones para ejecutar con nuestra aplicación web.
Puede ocurrir, que nuestros test de [[Selenium]] se vayan complejizando a medida que nuestra aplicación crece, por lo que esta es una posible solución, combinando el poder de [[Selenium]] con un enfoque [[DSL]].

== Ejemplo ==
A continuación mostramos una propuesta de como encarar un test de [[Selenium]]con [[DSL]]. Para el ejemplo, suponemos un sistema de biblioteca, con las siguientes pantallas y su navegación.
Se puede observar que pare este sistemas planteamos dos roles de usuario, el Bibliotecario y el Socio.

=== Creando un test ===
En el siguiente test, vamos a probar la funcionalidad de la reserva de libro.
Para escribir el siguiente test, se utilizó una sintaxis acotada y simple con las siguientes reglas:

* '''ir'''''<NombreDeLaPagina>'': Los métodos que comiencen con el prefijo “ir”, nos retorna el nuevo contexto (página).
* '''verificar'''''<Descripción>'': Los métodos que comiencen con el prefijo "verificar", poseen los “assert” para comprobar alguna acción realizada en la página, este método siempre retona la misma página (this).
* '''ingresarComo'''''<Nombre del Rol>'': Rol con el que se probará el sistema en la prueba.
* '''aceptar, cancelar, volver, buscar''': Son nombre de las acciones básica que se realizan en un página y pueden (o nó) devolver otra página.
* ''<acciones propias de la página>'' : Estos métodos realizan acciones sobre el sistema sin ir a otra página. Ej.: reservar

==== ReservaSeleniumDslTest ====
<code java>
package com.test.dsl;

import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class ReservaSeleniumDslTest {

@BeforeClass
public static void setUpClass() throws Exception {
Usuario.inicializar();
}

@AfterClass
public static void tearDownClass() throws Exception {
Usuario.finalizar();
}

@Test
public void comoBibliotecarioQuieroRealizarUnaReserva() {
Usuario.ingresaComoBibliotecario()
.irReservaDeLibro()
.reservar()
.aceptar()
.verificarReserva()
.aceptar()
.salir();
}
}
</code>

De esta forma, escribimos el test de manera que al leer los métodos a los que se invoca, se entiende paso a paso lo que el test realiza, sin confundirnos con la implementación. Utilizando los patrones "method chaining" , "builder", "Page object" ayuda a realizar una abstracción de la implementación.

A continuación las implementaciones de las clases utilizadas.

==== Usuario ====

<code java>
package com.test.dsl;

import org.openqa.selenium.server.SeleniumServer;

import com.test.dsl.pagina.HomeBibliotecario;
import com.test.dsl.pagina.HomeUsuario;
import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;

public class Usuario {

public static final String TIEMPO_ESPERA = "90000";
public static final String VELOCIDAD_CERO = "0";
public static final String VELOCIDAD_TEST = "350";

private static SeleniumServer seleniumServer;
private static Selenium selenium ;

public static void inicializar() throws Exception {
seleniumServer = new SeleniumServer();
seleniumServer.start();
selenium = new DefaultSelenium("localhost", 4444, "*chrome", "http://localhost:8585/");
selenium.start();
}

public static void finalizar() {
selenium.stop();
seleniumServer.stop();
}

public static HomeBibliotecario ingresaComoBibliotecario() {
Usuario.login("bibliotecario_test","123456");
return new HomeBibliotecario(selenium);
}

public static HomeUsuario ingresaComoUsuario() {
Usuario.login("usuario_test","123456");
return new HomeUsuario(selenium);
}

private static void login(String username, String password) {
selenium.open("");
selenium.waitForPageToLoad(TIEMPO_ESPERA);
selenium.type("username", username);
selenium.type("password", password);
selenium.click("submitbutton");
selenium.waitForPageToLoad(TIEMPO_ESPERA);

}
}

</code>

Esta clase es la que determina con que rol vamos a probar la aplicación.
El método '''ingresarComoBibliotecario''' instancia y devuelve un objeto de la clase '''HomeBibliotecario''' cuya implementación es:

==== HomeBibliotecario ====
<code java>
package com.test.dsl.pagina;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class HomeBibliotecario {

private Selenium selenium;

public HomeBibliotecario(Selenium selenium) {
this.selenium = selenium;
}

public ReservaDeLibro irReservaDeLibro() {
selenium.click("link=ReservaLibro");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new ReservaDeLibro(selenium);
}

public void salir() {
selenium.click("link=logout");
}
}
</code>

Volvemos a utilizar el patrón builder y el método ingresar denuncia devuelve un objeto de la clase AltaDenuncia. De esta manera, cada clase representa a una pantalla de la aplicación, y expone cada funcionalidad que la misma ofrece. AltaDenuncia sería así:
Volvemos a utilizar el patrón method chaining y el método '''irReservaDeLibro''' devuelve un objeto de la clase '''ReservaDeLibro'''. De esta manera, cada clase representa a una pantalla de la aplicación (page object), y expone cada funcionalidad que la misma ofrece (acciones que puedo realizar en la página y páginas a la que puedo acceder)

==== ReservaDeLibro ====
<code java>
package com.test.dsl.pagina;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class ReservaDeLibro {

private Selenium selenium;

public ReservaDeLibro(Selenium selenium) {
this.selenium = selenium;
}

public ReservaDeLibro reservar() {
selenium.type("libro", "El señor de los anillos");
selenium.type("codSocio", "0001");
selenium.type("fechaHasta", "2011-01-01");
return this;
}

public ComprobanteDeLibro aceptar() {
selenium.click("submitbutton");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new ComprobanteDeLibro(selenium);
}
}
</code>

==== ComprobanteDeLibro ====
<code java>
package com.test.dsl.pagina;

import org.junit.Assert;

import com.test.dsl.Usuario;
import com.thoughtworks.selenium.Selenium;

public class ComprobanteDeLibro {
private Selenium selenium;

public ComprobanteDeLibro(Selenium selenium) {
this.selenium = selenium;
}

public ComprobanteDeLibro verificarReserva() {
Assert.assertTrue(selenium.isTextPresent("El señor de los anillos"));
Assert.assertTrue(selenium.isTextPresent("0001"));
Assert.assertTrue(selenium.isTextPresent("2011-01-01"));
return this;
}

public HomeBibliotecario aceptar() {
selenium.click("submitbutton");
selenium.waitForPageToLoad(Usuario.TIEMPO_ESPERA);
return new HomeBibliotecario(selenium);
}
}

</code>

Tanto el aceptar (como el cancelar en ReservaDeLibro), devuelven la home del bibliotecario.

== Conclusiones ==

El resultado de hacer los test de esta manera, es la facilidad de escritura y mantenimiento del test en si mismo. A su vez, se podría diseñar las clases a utilizar en el DSL a conveniencia.

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-25T13:03:10Z

201.251.182.130: /* Segundo paso */

===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.

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

[[Category:Oracle]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-24T18:45:43Z

201.251.182.130: /* Versionando con CVS */

===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 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.

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

[[Category:Oracle]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-24T18:25:48Z

201.251.182.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 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, actulizar 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.

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

[[Category:Oracle]]

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-24T12:31:45Z

201.251.182.130: /* Segundo paso */

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-24T12:17:01Z

201.251.182.130: /* Segundo paso */

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-24T12:10:27Z

201.251.182.130:

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-21T19:27:24Z

201.251.182.130: /* Segundo paso */

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-21T19:02:59Z

201.251.182.130: /* Comunicando con Base de Datos con PBL (Process Business Language) */

===Comunicando con Base de Datos con PBL (Process Business Language)===

Para executar 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 del modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro método, 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 * FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede obserbar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-21T19:00:02Z

201.251.182.130: /* Comunicando con Base de Datos con PBL (Process Business Language) */

===Comunicando con Base de Datos con PBL (Process Business Language)===

Para executar 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 del modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro método, 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 * FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede obserbar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-21T18:59:45Z

201.251.182.130: /* Comunicando con Base de Datos con PBL (Process Business Language) */

=Comunicando con Base de Datos con PBL (Process Business Language)=

Para executar 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 del modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro método, 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 * FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede obserbar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-21T18:59:24Z

201.251.182.130:

== Comunicando con Base de Datos con PBL (Process Business Language) ==

Para executar 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 del modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro método, 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 * FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);
</code>

Como se puede obserbar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

BEA Aqualogic BPM 5.7 (Fuego)

2011-01-21T18:54:07Z

201.251.182.130: Página creada con '== Comunicando con Base de Datos con PBL (Process Business Language) == Para executar comandos SQL en Aqualogic BPM 5.7 hay que seguir los siguientes pasos: Primer paso: Se …'

== Comunicando con Base de Datos con PBL (Process Business Language) ==

Para executar 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 del modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro método, 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> 

String queryAEjecutar = "SELECT * FROM nombreTabla WHERE nombreColumna in (?, ?); 

String nombreDeLaBDCreada = "NombreBD"; 

String[] arrayDeParametros = {"valor1", "valor2"}; 

Iterator iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros) 

</code>

Spring Roo

2010-12-22T14:48:40Z

201.251.182.130:

[[Spring Roo]] es una herramienta RAD extensible para [[Java]] basada en [[Spring Framework]]. Basicamente es un generador de código avanzado, que se utiliza desde la linea de comandos invocando sentencias.

La idea detrás de [[Spring Roo]] es incrementar la productividad del desarrollador [[Java]] sin comprometer la integridad estructural o la flexibilidad de la solución. No contiene un componente Runtime. Esto es muy importante, no solo porque no ata la solución al framework, sino porque no genera overhead. Se puede eliminar facilmente.

Está construido con una serie de plugins (al estilo de [[Maven]]). Fue diseñado pensando en la usabilidad. Los comandos son contextuales; tiene los comandos "hint" y "help" para consultar el uso rápidamente y la tecla TAB para autocompletar.

Está basado en scripts, por lo que en caso que se cometer un error, se puede hacer rollback. Todos los comandos escritos se van guardando automáticamente (log.roo).

== Características ==
* Permite desarrollar una aplicación Web en minutos. Genera un war. Construye dos capas: la de persistencia y la de presentación. Para agregar la capa de negocio, se pueden agregar las clases manualmente a los controladores generados con Roo.
* Permite generar un modelo de datos complejo, incluyendo validaciones.
* La aplicación Web es RESTful y tiene soporte para internacionalización en varios idiomas.
* Tiene soporte de seguridad out-of-the-box.
* La presentación usa [[Dojo]] (incorporar otro, por ejemplo [[JQuery]], se hace a mano y es costoso).

=== Generación de código ===
Es un generador de código ''hibrido'', utilizando generación activa y pasiva.

Utiliza generación pasiva para generación de archivos java y xml.
Utiliza generación activa para la metadata con la ayuda de los tags @Roo* y modifica gradualmente .aj y los jsp.

Sincroniza los cambios entre Roo y las modificaciones realizadas al código (roundtrip).

[[Spring Roo]] no interviene en runtime, solo lo hace en tiempo de desarrollo. Una vez creado el proyecto con Spring Roo, podría eliminarse y seguir trabajando con un [[IDE]].

=== Librerías/Frameworks que usa ===

* [[Java]]
* [[AspectJ]]
* [[Eclipse]]
* Java Persistence API: [[Hibernate]], [[OpenJPA]], [[EclipseLink]]
* [[Java Server Pages]]
* [[JUnit]]
* [[Log4J]]
* [[Maven]]
* [[Selenium]]
* [[Spring Framework]]
* [[Spring MVC]]
* [[Spring Security]]
* [[Spring Web Flow]]

== Requisitos ==

Tener instalado Java y Maven, las últimas versiones estables.

== Configuración ==
Descargar la última versión de Roo del sitio oficial.
Descomprimir en una carpeta en el disco local. Ej: c:\roo-1.2
Incluir la carpeta con los ejecutables dentro de la variable de entorno PATH. Ej.: c:\roo-1.2\bin

== Uso ==
Para la ejecución de comandos podemos utilizar:
* el shell de roo mediante linea de comando
* el shell que viene embebido en el [[SpringSource Tool Suite]]
* o el [[IDE]] que utilizás habitualmente, por ejemplo [[Eclipse]]. En este caso deberías instalar el plugin para trabajar con aspectos y maven.

Para empezar a usar los comandos Roo mediante el shell, crear una carpeta e invocar a [[Spring Roo]]
Ej.:

mkdir helloworld
cd helloworld
roo

Al hacer eso se iniciará la interfaz y desplegará el siguiente mensaje:

/ __ \/ __ \/ __ \
/ /_/ / / / / / / /
/ _, _/ /_/ / /_/ /
/_/ |_|\____/\____/ 1.0.2.RELEASE [rev 638]

Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.
roo>

La tecla TAB despliega las opciones:

*/ /* // ; addon date development exit help hint
metadata poll project quit reference script system version
roo>

La sentencia help lista todos los comandos con descripciones breves.

== Pasos para crear una aplicación mínima ==

*Crear el proyecto
*Elegir el framework de persistencia
*Crear el modelo de dominio
*Generar de la capa de presentación

En detalle podés verlo en [[Roo: Pasos para crear una aplicación mínima]].

== Manejo de propiedades ==

Roo genera archivos de propiedades dentro del proyecto, por ejemplo: database.properties.
Dichos archivos pueden ser modificados automáticamente por los comandos de roo. Se debe tener en cuenta entonces que al ejecutar un comando que impacte valores configurados manualmente, será necesario volver a configurarlos.
Las claves definidas manualmente por el usuario no son alteradas por ningún comando de roo.

== Maven ==

Desde Roo se pueden ejecutar varias tareas de Maven sin tener que salir del entorno.
Por ejemplo:
* 'perform tests' equivale a 'mvn test'
* 'perform eclipse' equivale a 'mvn eclipse:eclipse'

== Seguridad ==

El módulo de seguridad que viene predeterminado necesita unos pequeños cambios de configuración. De forma predeterminada viene configurado un path segurizado que no corresponde con la aplicación en desarrollo.
Se invoca mediante la sentencia:

security setup

== Ejecutar un script ==

Todo lo que se va ejecutando por consola, se va grabando en un archivo de log (log.roo).
Es posible re-ejecutar las acciones, copiando el archivo con otro nombre y utilizando la sentencia 'script <nombre de archivo>'
Ej.:

roo>script helloworld.roo

== Ejemplos ==

Necesitamos tener correctamente instaladas las siguientes versiones (verificar la configuración de las variables de entorno PATH y JAVA_HOME):

* JDK 1.6 UPDATE 21
* Spring Roo 1.0.2
* Apache Maven 2.2.1

Para poder ejecutar los siguientes ejemplos:

* [[Ejemplo de script con Spring Roo]]
* [[Ejemplo de proyecto web ABM con Spring Roo]]
* [[Ejemplo de proyecto web ABM con SpringSource Tool Suite]]

== Personalizacion de la capa de persistencia ==

En [[Capa de Persistencia de Spring Roo]] veremos algunas características de uso con [[Oracle]].

== Personalizacion de la capa de presentación ==

En [[Capa de Presentación de Spring Roo]] veremos como cambiar la apariencia de las pantallas web.

== Uso de mensajeria ==

En [[JMS con Spring Roo]] veremos como incorporar tareas asincrónicas a la aplicación.

== Uso de servicios web con Rest ==

En [[Restful con Spring Roo]] veremos como incorporar servicios web sencillos a la aplicación, con la tecnología [http://www.dosideas.com/noticias/java/314-introduccion-a-los-servicios-web-restful.html Rest].

== Creación de Add On ==

Podemos incorporar nuevos comandos de Spring Roo, creando un Add On nuevo.

* [https://fisheye.springsource.org/browse/spring-roo Listado de addons existentes]
* [http://www.slideshare.net/desmax74/spring-roo-internals-javaday-iv Arquitectura de Spring Roo]
* [http://abaddon-gtz.blogspot.com/2010/04/un-sencillo-add-on-de-spring-roo.html Un sencillo Add On de Spring Roo]

== Problemas y soluciones ==
* [[Problemas frecuentes con Spring Roo]]

== Para que es ideal ==

* Hacer backends de Administración (ABMs/CRUDs con interfaz Web)

== Lo que le falta ==

* La posibilidad de importar modelos de datos,ya sea desde la base de datos o bien de un archivo de configuración Hibernate. (próximamente disponible en la versión 1.1.0)

== Ver también ==
* [[SpringSource Tool Suite]]
* [http://www.springsource.org/roo/ Web oficial de Spring Roo]
* [http://static.springsource.org/spring-roo/reference/html-single/index.html Manual de referencia]
* [http://www.infoq.com/presentations/Introducing-Spring-Roo Presentación hecha por el creador]
* [https://admin.na3.acrobat.com/_a204547676/p38684494/?launcher=false&fcsContent=true&pbMode=normal Curso de Spring Roo on-line]
* [http://blog.springsource.com/2009/05/27/roo-part-2/ Ejemplo con buscador dinámico]
* [http://stsmedia.net/introducing-spring-roo-part-2-security-jms-email-support/ Ejemplo con Jms y envío de mails]

[[Category: Spring Framework]]

Ant

2010-12-14T13:58:31Z

201.251.182.130: /* Ver también */

[[Ant]] es una herramienta de build de [[Software Libre]] especializada en construir proyectos Java. [[Ant]] utiliza archivos XML para expresar las instrucciones de ejecución de build. Ella posee una gran variedad de tareas que permiten la realización de actividades como generación de pruebas unitarias, publicación de información, entre otras.

Algunos ejemplos de tareas pueden ser:

*Prepare -> Realiza la creación de directorios que contendrán los ejecutables.
*Compile -> Compila el código fuente del producto.
*Instrument -> Instrumenta el código para permitir la generación de información de cobertura de código.
*Compile-test -> Compila el código de pruebas unitarias automatizadas.
*Test -> Ejecuta la batería de pruebas unitarias automatizadas, genera la información en HTML de las pruebas ejecutadas con éxito y con falla y genera la información en HTMl de la cobertura de código.
*[[PMD]] -> Ejecuta la generación de información de análisis estática de código.
*Javadoc -> Ejecuta la generación de documentación de las clases en base a los comentarios en el código fuente.
*Run -> Ejecuta el software.
*Clean -> Realiza la limpieza de los directorios que contienen los ejecutables.
*Jar -> Realiza el empaquetado del software para que pueda se utilizado en producción.

El script de build puede ser ejecutado de diversas maneras y con múltiples opciones. En el caso de línea de comando, por ejemplo "ant test pmd javadoc jar", todas las secciones del archivo XML serán ejecutadas.

Ant puede ser utilizado para realizar la implantación de una aplicación JEE Web en producción. Un ejemplo de una sección que haría eso sería el siguiente: <code xml="xml">
<target name="deploy">
<deploy url="${tomcat.manager.url}"
username="${tomcat.manager.username}"
password="${tomcat.manager.password}"
path="/${webap.name}"
war="file:${warfile.path}" />
</target>
</code>

 

== Condicionales con ant ==

A continuación se muestra una forma de simular los típicos condicionales "if - then - else" con tags de Ant. El ejemplo muestra como realizar diferentes acciones según el contenido de un parámetro.

<code xml="xml">
<?xml version="1.0"?>
<project name="Condicional" default="if" basedir=".">

<target name="if">
<condition property="condition">
<equals arg1="${param}" arg2="VALOR1" />
</condition>
<antcall target="then"/>
<antcall target="else"/>
</target>

<target name="then" if="condition">
<echo>El parámetro fue VALOR1</echo>
</target>

<target name="else" unless="condition">
<condition property="conditionElse">
<equals arg1="${param}" arg2="VALOR2" />
</condition>
<antcall target="thenElse"/>
<antcall target="elseElse"/>
</target>

<target name="thenElse" if="conditionElse">
<echo>El parámetro fue VALOR2</echo>
</target>

<target name="elseElse" unless="conditionElse">
<fail message="Parametro desconocido"></fail>
</target>

</project>
</code>

 

El tag '''condition''' setea una properties de acuerdo a la condición que contiene. Si la condición tiene valor '''true''', el valor de la propertie es seteado en '''true '''por default (tambien se puede especificar que valor asignarle a la propertie con el atributo '''value'''). De otra manera la propertie no es seteada. Existe un [http://ant.apache.org/manual/Tasks/conditions.html listado de condiciones] permitidas para el tag.

Luego utilizando los atributos del tag target : '''if '''y '''unless '''podemos simular un flujo de condicionales:

*El atributo '''if '''permite que se ejecute el target solo si el valor de la variable que se le pasa es '''true'''.
*El atributo '''unless '''se comporta de la manera contraria: solo permite la ejecución del target si el valor de la variable no es true.

 

== Profiling de las tareas Ant ==
'''Nota:''' Requiere una versión 1.8 o superior.

En caso de que se quiera obtener los tiempo de ejecución de cada tarea ant (clean, report, etc) basta con definir el parámetro logger con el valor ''org.apache.tools.ant.listener.ProfileLogger''. [http://ant.apache.org/manual/listeners.html Para más información]

Por ejemplo si queremos saber los tiempos para la siguiente tarea:
<code>
> ant clean compile test javadoc
</code>

con el profiling quedaría:

<code>
> ant -logger org.apache.tools.ant.listener.ProfileLogger clean compile test javadoc report
</code>

dando como resultado:
<code>
...
Target clean: started Tue Dec 14 17:15:40 PKT 2010
...
Target clean: finishedTue Dec 14 17:15:40 PKT 2010 (0ms)
...
</code>

== Ver también ==

*[[Automatizacion De Build]]
*[[Maven]]
*[http://ant.apache.org/ Web oficial de Ant]
*[http://ant.apache.org/manual/Tasks/condition.html Documentación de tag Condition]
*[http://ant.apache.org/manual/listeners.html Documentación de Listeners & Loggers]
*[http://www.dosideas.com/java/391-automatizacion-de-despliegues-ino-mas-dolores-de-cabeza.html Patrones para la automatización de despliegues]

[[Category:Java]]

Ant

2010-12-14T13:43:07Z

201.251.182.130: /* Profiling de las tareas Ant */

[[Ant]] es una herramienta de build de [[Software Libre]] especializada en construir proyectos Java. [[Ant]] utiliza archivos XML para expresar las instrucciones de ejecución de build. Ella posee una gran variedad de tareas que permiten la realización de actividades como generación de pruebas unitarias, publicación de información, entre otras.

Algunos ejemplos de tareas pueden ser:

*Prepare -> Realiza la creación de directorios que contendrán los ejecutables.
*Compile -> Compila el código fuente del producto.
*Instrument -> Instrumenta el código para permitir la generación de información de cobertura de código.
*Compile-test -> Compila el código de pruebas unitarias automatizadas.
*Test -> Ejecuta la batería de pruebas unitarias automatizadas, genera la información en HTML de las pruebas ejecutadas con éxito y con falla y genera la información en HTMl de la cobertura de código.
*[[PMD]] -> Ejecuta la generación de información de análisis estática de código.
*Javadoc -> Ejecuta la generación de documentación de las clases en base a los comentarios en el código fuente.
*Run -> Ejecuta el software.
*Clean -> Realiza la limpieza de los directorios que contienen los ejecutables.
*Jar -> Realiza el empaquetado del software para que pueda se utilizado en producción.

El script de build puede ser ejecutado de diversas maneras y con múltiples opciones. En el caso de línea de comando, por ejemplo "ant test pmd javadoc jar", todas las secciones del archivo XML serán ejecutadas.

Ant puede ser utilizado para realizar la implantación de una aplicación JEE Web en producción. Un ejemplo de una sección que haría eso sería el siguiente: <code xml="xml">
<target name="deploy">
<deploy url="${tomcat.manager.url}"
username="${tomcat.manager.username}"
password="${tomcat.manager.password}"
path="/${webap.name}"
war="file:${warfile.path}" />
</target>
</code>

 

== Condicionales con ant ==

A continuación se muestra una forma de simular los típicos condicionales "if - then - else" con tags de Ant. El ejemplo muestra como realizar diferentes acciones según el contenido de un parámetro.

<code xml="xml">
<?xml version="1.0"?>
<project name="Condicional" default="if" basedir=".">

<target name="if">
<condition property="condition">
<equals arg1="${param}" arg2="VALOR1" />
</condition>
<antcall target="then"/>
<antcall target="else"/>
</target>

<target name="then" if="condition">
<echo>El parámetro fue VALOR1</echo>
</target>

<target name="else" unless="condition">
<condition property="conditionElse">
<equals arg1="${param}" arg2="VALOR2" />
</condition>
<antcall target="thenElse"/>
<antcall target="elseElse"/>
</target>

<target name="thenElse" if="conditionElse">
<echo>El parámetro fue VALOR2</echo>
</target>

<target name="elseElse" unless="conditionElse">
<fail message="Parametro desconocido"></fail>
</target>

</project>
</code>

 

El tag '''condition''' setea una properties de acuerdo a la condición que contiene. Si la condición tiene valor '''true''', el valor de la propertie es seteado en '''true '''por default (tambien se puede especificar que valor asignarle a la propertie con el atributo '''value'''). De otra manera la propertie no es seteada. Existe un [http://ant.apache.org/manual/Tasks/conditions.html listado de condiciones] permitidas para el tag.

Luego utilizando los atributos del tag target : '''if '''y '''unless '''podemos simular un flujo de condicionales:

*El atributo '''if '''permite que se ejecute el target solo si el valor de la variable que se le pasa es '''true'''.
*El atributo '''unless '''se comporta de la manera contraria: solo permite la ejecución del target si el valor de la variable no es true.

 

== Profiling de las tareas Ant ==
'''Nota:''' Requiere una versión 1.8 o superior.

En caso de que se quiera obtener los tiempo de ejecución de cada tarea ant (clean, report, etc) basta con definir el parámetro logger con el valor ''org.apache.tools.ant.listener.ProfileLogger''. [http://ant.apache.org/manual/listeners.html Para más información]

Por ejemplo si queremos saber los tiempos para la siguiente tarea:
<code>
> ant clean compile test javadoc
</code>

con el profiling quedaría:

<code>
> ant -logger org.apache.tools.ant.listener.ProfileLogger clean compile test javadoc report
</code>

dando como resultado:
<code>
...
Target clean: started Tue Dec 14 17:15:40 PKT 2010
...
Target clean: finishedTue Dec 14 17:15:40 PKT 2010 (0ms)
...
</code>

== Ver también ==

*[[Automatizacion De Build]]
*[[Maven]]
*[http://ant.apache.org/ Web oficial de Ant]
*[http://ant.apache.org/manual/Tasks/condition.html Documentación de tag Condition]
*[http://www.dosideas.com/java/391-automatizacion-de-despliegues-ino-mas-dolores-de-cabeza.html Patrones para la automatización de despliegues]

[[Category:Java]]

Ant

2010-12-14T13:36:40Z

201.251.182.130: /* Profiling de las tareas Ant */

[[Ant]] es una herramienta de build de [[Software Libre]] especializada en construir proyectos Java. [[Ant]] utiliza archivos XML para expresar las instrucciones de ejecución de build. Ella posee una gran variedad de tareas que permiten la realización de actividades como generación de pruebas unitarias, publicación de información, entre otras.

Algunos ejemplos de tareas pueden ser:

*Prepare -> Realiza la creación de directorios que contendrán los ejecutables.
*Compile -> Compila el código fuente del producto.
*Instrument -> Instrumenta el código para permitir la generación de información de cobertura de código.
*Compile-test -> Compila el código de pruebas unitarias automatizadas.
*Test -> Ejecuta la batería de pruebas unitarias automatizadas, genera la información en HTML de las pruebas ejecutadas con éxito y con falla y genera la información en HTMl de la cobertura de código.
*[[PMD]] -> Ejecuta la generación de información de análisis estática de código.
*Javadoc -> Ejecuta la generación de documentación de las clases en base a los comentarios en el código fuente.
*Run -> Ejecuta el software.
*Clean -> Realiza la limpieza de los directorios que contienen los ejecutables.
*Jar -> Realiza el empaquetado del software para que pueda se utilizado en producción.

El script de build puede ser ejecutado de diversas maneras y con múltiples opciones. En el caso de línea de comando, por ejemplo "ant test pmd javadoc jar", todas las secciones del archivo XML serán ejecutadas.

Ant puede ser utilizado para realizar la implantación de una aplicación JEE Web en producción. Un ejemplo de una sección que haría eso sería el siguiente: <code xml="xml">
<target name="deploy">
<deploy url="${tomcat.manager.url}"
username="${tomcat.manager.username}"
password="${tomcat.manager.password}"
path="/${webap.name}"
war="file:${warfile.path}" />
</target>
</code>

 

== Condicionales con ant ==

A continuación se muestra una forma de simular los típicos condicionales "if - then - else" con tags de Ant. El ejemplo muestra como realizar diferentes acciones según el contenido de un parámetro.

<code xml="xml">
<?xml version="1.0"?>
<project name="Condicional" default="if" basedir=".">

<target name="if">
<condition property="condition">
<equals arg1="${param}" arg2="VALOR1" />
</condition>
<antcall target="then"/>
<antcall target="else"/>
</target>

<target name="then" if="condition">
<echo>El parámetro fue VALOR1</echo>
</target>

<target name="else" unless="condition">
<condition property="conditionElse">
<equals arg1="${param}" arg2="VALOR2" />
</condition>
<antcall target="thenElse"/>
<antcall target="elseElse"/>
</target>

<target name="thenElse" if="conditionElse">
<echo>El parámetro fue VALOR2</echo>
</target>

<target name="elseElse" unless="conditionElse">
<fail message="Parametro desconocido"></fail>
</target>

</project>
</code>

 

El tag '''condition''' setea una properties de acuerdo a la condición que contiene. Si la condición tiene valor '''true''', el valor de la propertie es seteado en '''true '''por default (tambien se puede especificar que valor asignarle a la propertie con el atributo '''value'''). De otra manera la propertie no es seteada. Existe un [http://ant.apache.org/manual/Tasks/conditions.html listado de condiciones] permitidas para el tag.

Luego utilizando los atributos del tag target : '''if '''y '''unless '''podemos simular un flujo de condicionales:

*El atributo '''if '''permite que se ejecute el target solo si el valor de la variable que se le pasa es '''true'''.
*El atributo '''unless '''se comporta de la manera contraria: solo permite la ejecución del target si el valor de la variable no es true.

 

== Profiling de las tareas Ant ==
'''Nota:''' Requiere una versión 1.8 o superior.

En caso de que se quiera obtener los tiempo de ejecución de cada tarea ant (clean, report, etc) basta con definir el parámetro logger con el valor ''org.apache.tools.ant.listener.ProfileLogger''

Por ejemplo si para la tarea:
<code>
> ant clean compile test javadoc
</code>

con el profiling quedaría:

<code>
> ant -logger org.apache.tools.ant.listener.ProfileLogger clean compile test javadoc report
</code>

== Ver también ==

*[[Automatizacion De Build]]
*[[Maven]]
*[http://ant.apache.org/ Web oficial de Ant]
*[http://ant.apache.org/manual/Tasks/condition.html Documentación de tag Condition]
*[http://www.dosideas.com/java/391-automatizacion-de-despliegues-ino-mas-dolores-de-cabeza.html Patrones para la automatización de despliegues]

[[Category:Java]]

Lista De Impedimentos

2010-12-02T18:59:24Z

201.251.182.130:

[[Category:Scrum]]
Se considera un Impedimento a cualquier cosa alrededor de un proyecto [[Scrum]] que interfiera con la productividad o calidad del mismo.

Es responsabilidad del [[Scrum Master]] eliminar cualquier impedimento que le impida al equipo producir código de calidad productiva. La Lista de Impedimentos es un grupo de tareas que el [[Scrum Master]] usa para el seguimiento de los impedimientos que necesitan ser resueltos.

== Seguimiento de un impedimento ==
Durante cada [[Reunion Diaria De Scrum]] el [[Scrum Master]] informará el estado del impedimento y de no haber sido resuelto irá asentando el paso de los días en el registro del impedimento.

Una vez resuelto, el Scrum Master podrá tachar el impedimento de la lista. El Impedimento seguirá pegado en el afiche, y servirá para analizar al finalizar el Sprint.

Un impedimento que tarda mucho en resolverse seguramente producirá un impacto negativo en los tiempos de una historia. Lo mismo ocurrirá si un Sprint sufre un número excesivo de impedimentos.

En ambos casos es problable que el equipo no logre cumplir con el compromiso asumido, y contará con un detalle visible de las dificultades que tuvieron.

== Ejemplo ==
Supongamos un impedimento con un "Servicio de morosidad", el cual el equipo debe utilizar para completar alguna historia del Sprint (el servicio es externo al Sprint, y no es responsabilidad del equipo). Durante una Reunion Diaria De Scrum algún integrante puede mencionar que dicho servicio no está funcionado. El Scrum Master entonces creará una nota adhesiva con el impedimento, y la ubicará en la sección correspondiente en el afiche del Sprint.

{| border="0" valign="top"
|-
| [[image:Impedimento-servicio-de-morosidad.jpg|frame|El Scrum Master escribe la nota adhesiva y lo pega en el afiche del Sprint]]
|| [[image:Impedimento-servicio-de-morosidad-2.jpg|frame|2 días y sigue el impedimento sin resolverse]]
|-
| [[image:Impedimento-servicio-de-morosidad-5.jpg|frame|5 días sin resolución]]
|| [[image:Impedimento-servicio-de-morosidad-resuelto.jpg|frame|Luego de 7 días el impedimento quedó solucionado]]
|}

Struts

2010-11-19T17:59:44Z

201.251.182.130: /* Previniendo la cache del navegador en Struts  */

== Previniendo la cache del navegador en Struts  ==

Muchas veces, la utilización por parte del usuario de un sitio del "Volver" del navegador puede ocasionarnos problemas. Para prevenir esto, se suele utilizar el siguiente código html:

<code>
<meta http-equiv="Expires" content="Tue, 01 Jan 2000 12:12:12 GMT">
<meta http-equiv="Pragma" content="no-cache">
</code>

Esto funciona inconsistentemente en Internet Explorer. A continuación, una alternativa para que funcione con Struts:

<code>
<%
response.setHeader("Cache-Control","no-cache");
response.setHeader("Pragma","no-cache");
response.setDateHeader ("Expires", 0);
%>
</code>

Con esto, Internet Explorer soporta el cache.

Sin embargo, al parecer, Firefox 3 tiene problemas con el no-cache. Si se necesita contemplar también este explorador, el código es el siguiente:

<code>
<%
response.setHeader("Cache-Control","no-store");
response.setHeader("Pragma","no-cache");
response.setDateHeader ("Expires", 0);
%>
</code>

== saveToken y isTokenValid ==

El método saveToken() de la clase Action de Struts, es utilizado para evitar submits duplicados. Para hacer este checkeo, struts tiene el método saveToken() para setear el token, y isTokenValid() para validarlo del lado receptor.

== Ver también ==
* [[Struts, AJAX y Global Exceptions]]
* [http://lab.artlung.com/anti-cache/ Fuente]

[[Category:Struts]]