https://dosideas.com/wiki/api.php?action=feedcontributions&feedformat=atom&user=LeitoDos Ideas. - Contribuciones del usuario [es]2026-05-05T00:58:37ZContribuciones del usuarioMediaWiki 1.28.2https://dosideas.com/wiki/index.php?title=REST_con_Spring&diff=5692REST con Spring2011-02-10T17:33:47Z<p>Leito: </p>
<hr />
<div>[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple. <br />
<br />
== Un ejemplo ==<br />
Vamos a realizar una aplicación que responda a las siguientes URL: <br />
<br />
/persona/todos : devuelve todas las personas<br />
/persona/123 : devuelve la persona cuyo id es 123<br />
<br />
Tendremos que seguir 3 pasos:<br />
# Configurar el servlet de Spring<br />
# Crear la clase que atenderá y resolverá estas peticiones<br />
# Configurar Spring<br />
<br />
=== El servlet de Spring ===<br />
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: <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<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"><br />
<display-name>json-con-spring-mvc</display-name><br />
<br />
<filter><br />
<filter-name>characterEncodingFilter</filter-name><br />
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><br />
<init-param><br />
<param-name>encoding</param-name><br />
<param-value>UTF-8</param-value><br />
</init-param><br />
<init-param><br />
<param-name>forceEncoding</param-name><br />
<param-value>true</param-value><br />
</init-param><br />
</filter><br />
<br />
<filter-mapping><br />
<filter-name>characterEncodingFilter</filter-name><br />
<url-pattern>/*</url-pattern><br />
</filter-mapping><br />
<br />
<servlet><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><br />
<init-param><br />
<param-name>contextConfigLocation</param-name><br />
<param-value><br />
WEB-INF/applicationContext-clasico.xml<br />
</param-value><br />
</init-param><br />
<load-on-startup>1</load-on-startup><br />
</servlet><br />
<br />
<servlet-mapping><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<url-pattern>/app/*</url-pattern><br />
</servlet-mapping><br />
<br />
<session-config><br />
<session-timeout><br />
30<br />
</session-timeout><br />
</session-config><br />
<welcome-file-list><br />
<welcome-file>index.jsp</welcome-file><br />
</welcome-file-list><br />
</web-app><br />
</code><br />
<br />
En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app". <br />
<br />
=== El controller ===<br />
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.)<br />
<br />
Para esto, creamos una clase de la siguiente forma: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.util.ArrayList;<br />
import java.util.Collection;<br />
import org.springframework.stereotype.Controller;<br />
import org.springframework.web.bind.annotation.PathVariable;<br />
import org.springframework.web.bind.annotation.RequestBody;<br />
import org.springframework.web.bind.annotation.RequestMapping;<br />
import org.springframework.web.bind.annotation.ResponseBody;<br />
<br />
@Controller<br />
@RequestMapping(value="/persona")<br />
public class PersonaController {<br />
<br />
@RequestMapping(value="/{id}")<br />
public @ResponseBody Persona get(@PathVariable Long id) {<br />
Persona p = new Persona("Invasor " + id, "Zim " + id);<br />
return p;<br />
}<br />
<br />
@RequestMapping(value="/todos")<br />
public @ResponseBody Collection<Persona> getTodos() {<br />
Collection<Persona> personas = new ArrayList<Persona>();<br />
for (int i = 0; i < 10; i++) {<br />
Persona p = new Persona("Invasor " + i, "Zim" + i);<br />
personas.add(p);<br />
}<br />
<br />
return personas;<br />
}<br />
}<br />
</code><br />
<br />
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. <br />
<br />
=== La configuración ===<br />
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet): <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<beans xmlns="http://www.springframework.org/schema/beans"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xmlns:p="http://www.springframework.org/schema/p"<br />
xmlns:aop="http://www.springframework.org/schema/aop"<br />
xmlns:tx="http://www.springframework.org/schema/tx"<br />
xmlns:context="http://www.springframework.org/schema/context"<br />
xmlns:mvc="http://www.springframework.org/schema/mvc"<br />
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd<br />
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd<br />
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd<br />
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd<br />
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"><br />
<br />
<context:component-scan base-package="com.dosideas.jsonconspringmvc"/><br />
<br />
<mvc:annotation-driven /><br />
<br />
</beans><br />
</code><br />
<br />
El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados. <br />
<br />
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. <br />
<br />
=== Probando ===<br />
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.io.IOException;<br />
import org.apache.commons.httpclient.methods.GetMethod;<br />
import org.apache.commons.httpclient.HttpMethod;<br />
import org.apache.commons.httpclient.HttpClient;<br />
import org.junit.Test;<br />
import static org.junit.Assert.*;<br />
<br />
public class HttpTest {<br />
<br />
@Test<br />
public void personaTodosJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("[{\""));<br />
}<br />
<br />
@Test<br />
public void personaPorIdJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("{\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
@Test<br />
public void personaPorIdXML() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/xml");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
}<br />
</code><br />
<br />
== Manejo de errores ==<br />
Es posible personalizar las excepciones para que devuelvan códigos de estado HTTP personalizados, usando la anotación @ResponseStatus en la excepción lanzada. <br />
<br />
<code java5><br />
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="No se encontró el recurso pedido")<br />
public class NotFoundException extends RuntimeException { ... }<br />
<br />
.....<br />
<br />
@RequestMapping(value="/id/{id}")<br />
public @ResponseBody Persona findById(@PathVariable long id) {<br />
Contact contact = personaService.findById(id);<br />
if (contact == null) {<br />
throw new NotFoundException();<br />
} else {<br />
return contact;<br />
}<br />
}<br />
</code><br />
<br />
== Manejo de la respuesta ==<br />
La anotación @ResponseStatus puede usarse para personalizar el código HTTP de cualquier respuesta, al ubicarla en el método. <br />
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]]).<br />
<br />
<code java5><br />
@RequestMapping(value="/delete/{id}")<br />
@ResponseStatus(HttpStatus.NO_CONTENT)<br />
public void delete(@PathVariable long id) {<br />
contactService.delete(id);<br />
}<br />
</code><br />
<br />
<br />
=== Descargar un proyecto de ejemplo ===<br />
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.<br />
<br />
== Ver también ==<br />
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]<br />
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]<br />
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]<br />
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]<br />
* [http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=springRestJson Spring + REST + JSON = SOAUI]<br />
* [http://www.jpalace.org/docs/spring/rest.html Sprint REST Tutorial]</div>Leitohttps://dosideas.com/wiki/index.php?title=Controller_con_Spring_usando_anotaciones&diff=5691Controller con Spring usando anotaciones2011-02-10T17:26:07Z<p>Leito: /* Ver también */</p>
<hr />
<div>[[Spring Framework]] nos permiten la creación de Controllers mediante anotaciones. Mostraremos un sencillo ejemplo utilizando [[Spring Framework]] 3.0<br />
<br />
== Ejemplo ==<br />
<br />
=== Creación del controller ===<br />
<br />
<code java><br />
package com.dosideas.web.controller;<br />
<br />
import org.springframework.stereotype.Controller;<br />
import org.springframework.web.bind.annotation.RequestMapping;<br />
<br />
@Controller<br />
public class PruebaController {<br />
<br />
@RequestMapping(value="/unMetodo.htm")<br />
public String imprimirHolaMundo() {<br />
System.out.println("Hola Mundo");<br />
return "index";<br />
}<br />
}<br />
</code><br />
<br />
Lo que hacemos en la creación del controller es agregar la anotación @Controller, que indica que dicha clase es un controller. Además, antes del método agregamos la anotación @RequestMapping con un valor. Dicho valor tendrá que ver con el url al que tendremos que dirigirnos para ejecutar el método del controller. Por último en el controller, estamos retornando un String (en este caso "index"). Ese String corresponde al nombre del .jsp (que se encuentra en WEB-INF/jsp) al que queremos que se redirija la página una vez que se ejecute el método.<br />
<br />
=== Configuración del web.xml ===<br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<web-app version="2.5"<br />
xmlns="http://java.sun.com/xml/ns/javaee"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee <br />
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"><br />
<br />
<!-- Declaración del servlet --><br />
<servlet><br />
<servlet-name>pruebaController</servlet-name><br />
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><br />
<load-on-startup>1</load-on-startup><br />
</servlet><br />
<br />
<!-- Mapping del servlet anterior--><br />
<servlet-mapping><br />
<servlet-name>pruebaController</servlet-name><br />
<!-- Interceptaremos todo lo que es .htm --><br />
<url-pattern>*.htm</url-pattern><br />
</servlet-mapping><br />
<br />
<!--Tiempo en minutos que dura una session --><br />
<session-config><br />
<session-timeout>30</session-timeout><br />
</session-config><br />
<br />
</web-app><br />
</code><br />
<br />
=== Configuración del <servlet-name>-servlet.xml ===<br />
<br />
El nombre de este archivo debe ser el mismo que se configuró en el web.xml en el tag <servlet-name>. Como nosotros le pusimos pruebaController, quedará pruebaController-servlet.xml :)<br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<beans xmlns="http://www.springframework.org/schema/beans"<br />
xmlns:p="http://www.springframework.org/schema/p"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xmlns:context="http://www.springframework.org/schema/context"<br />
xsi:schemaLocation="http://www.springframework.org/schema/beans <br />
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd<br />
http://www.springframework.org/schema/context <br />
http://www.springframework.org/schema/context/spring-context-2.5.xsd"><br />
<br />
<!--<br />
La siguiente declaración se encargará de levantar las clases que posean las <br />
anotaciones (@Controller, @RequestMapping, @Repository, etc) en el paquete que <br />
se le indique. Notese que en este caso le indico el paquete de la clase controller <br />
que quiero ejemplificar.<br />
--><br />
<context:component-scan base-package="com.dosideas.web.controller"/><br />
<br />
<!-- Declaramos un HandlerMapping para que entre al método del controller --><br />
<bean<br />
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/><br />
<br />
<!-- Declaramos un HandlerAdapter para que se redirija al .jsp que configuramos --><br />
<bean<br />
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/><br />
<br />
<br />
<!--<br />
En la siguiente declaración configuramos el prefijo y el <br />
sufijo del archivo .jsp (en este caso) al cual se va a <br />
redireccionar una vez que se ejecute el método del Controller.<br />
--><br />
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"<br />
p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/><br />
</beans><br />
</code><br />
<br />
=== Probamos lo realizado ===<br />
<br />
Si todo quedó como mostramos y tenemos el archivo index.jsp en la carpeta WEB-INF/jsp, deployamos el .war y deberíamos poder pegarle al controller, que ejecute el método y que redirija a index.jsp utilizando la siguiente url:<br />
<br />
<nowiki>http://<ip>:<puerto>/<nombreApp>/<valor setteado en el @RequestMapping del método></nowiki><br />
<br />
Por ejemplo:<br />
<nowiki>http://111.111.111.111:8001/servletSpringConAnotaciones/unMetodo.htm</nowiki><br />
<br />
== Ver también ==<br />
* [[REST con Spring]]<br />
* [http://static.springsource.org/spring/docs/2.5.6/reference/mvc.html#mvc-annotation Documentación oficial de Spring para Controller con Anotaciones]<br />
<br />
[[Category:Spring Framework]]</div>Leitohttps://dosideas.com/wiki/index.php?title=REST_con_Spring&diff=5642REST con Spring2010-12-22T15:48:46Z<p>Leito: /* Probando */</p>
<hr />
<div>[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple. <br />
<br />
== Un ejemplo ==<br />
Vamos a realizar una aplicación que responda a las siguientes URL: <br />
<br />
/persona/todos : devuelve todas las personas<br />
/persona/123 : devuelve la persona cuyo id es 123<br />
<br />
Tendremos que seguir 3 pasos:<br />
# Configurar el servlet de Spring<br />
# Crear la clase que atenderá y resolverá estas peticiones<br />
# Configurar Spring<br />
<br />
=== El servlet de Spring ===<br />
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: <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<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"><br />
<display-name>json-con-spring-mvc</display-name><br />
<br />
<filter><br />
<filter-name>characterEncodingFilter</filter-name><br />
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><br />
<init-param><br />
<param-name>encoding</param-name><br />
<param-value>UTF-8</param-value><br />
</init-param><br />
<init-param><br />
<param-name>forceEncoding</param-name><br />
<param-value>true</param-value><br />
</init-param><br />
</filter><br />
<br />
<filter-mapping><br />
<filter-name>characterEncodingFilter</filter-name><br />
<url-pattern>/*</url-pattern><br />
</filter-mapping><br />
<br />
<servlet><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><br />
<init-param><br />
<param-name>contextConfigLocation</param-name><br />
<param-value><br />
WEB-INF/applicationContext-clasico.xml<br />
</param-value><br />
</init-param><br />
<load-on-startup>1</load-on-startup><br />
</servlet><br />
<br />
<servlet-mapping><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<url-pattern>/app/*</url-pattern><br />
</servlet-mapping><br />
<br />
<session-config><br />
<session-timeout><br />
30<br />
</session-timeout><br />
</session-config><br />
<welcome-file-list><br />
<welcome-file>index.jsp</welcome-file><br />
</welcome-file-list><br />
</web-app><br />
</code><br />
<br />
En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app". <br />
<br />
=== El controller ===<br />
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.)<br />
<br />
Para esto, creamos una clase de la siguiente forma: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.util.ArrayList;<br />
import java.util.Collection;<br />
import org.springframework.stereotype.Controller;<br />
import org.springframework.web.bind.annotation.PathVariable;<br />
import org.springframework.web.bind.annotation.RequestBody;<br />
import org.springframework.web.bind.annotation.RequestMapping;<br />
import org.springframework.web.bind.annotation.ResponseBody;<br />
<br />
@Controller<br />
@RequestMapping(value="/persona")<br />
public class PersonaController {<br />
<br />
@RequestMapping(value="/{id}")<br />
public @ResponseBody Persona get(@PathVariable Long id) {<br />
Persona p = new Persona("Invasor " + id, "Zim " + id);<br />
return p;<br />
}<br />
<br />
@RequestMapping(value="/todos")<br />
public @ResponseBody Collection<Persona> getTodos() {<br />
Collection<Persona> personas = new ArrayList<Persona>();<br />
for (int i = 0; i < 10; i++) {<br />
Persona p = new Persona("Invasor " + i, "Zim" + i);<br />
personas.add(p);<br />
}<br />
<br />
return personas;<br />
}<br />
}<br />
</code><br />
<br />
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. <br />
<br />
=== La configuración ===<br />
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet): <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<beans xmlns="http://www.springframework.org/schema/beans"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xmlns:p="http://www.springframework.org/schema/p"<br />
xmlns:aop="http://www.springframework.org/schema/aop"<br />
xmlns:tx="http://www.springframework.org/schema/tx"<br />
xmlns:context="http://www.springframework.org/schema/context"<br />
xmlns:mvc="http://www.springframework.org/schema/mvc"<br />
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd<br />
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd<br />
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd<br />
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd<br />
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"><br />
<br />
<context:component-scan base-package="com.dosideas.jsonconspringmvc"/><br />
<br />
<mvc:annotation-driven /><br />
<br />
</beans><br />
</code><br />
<br />
El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados. <br />
<br />
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. <br />
<br />
=== Probando ===<br />
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.io.IOException;<br />
import org.apache.commons.httpclient.methods.GetMethod;<br />
import org.apache.commons.httpclient.HttpMethod;<br />
import org.apache.commons.httpclient.HttpClient;<br />
import org.junit.Test;<br />
import static org.junit.Assert.*;<br />
<br />
public class HttpTest {<br />
<br />
@Test<br />
public void personaTodosJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("[{\""));<br />
}<br />
<br />
@Test<br />
public void personaPorIdJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("{\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
@Test<br />
public void personaPorIdXML() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/xml");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
}<br />
</code><br />
<br />
=== Descargar un proyecto de ejemplo ===<br />
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.<br />
<br />
== Ver también ==<br />
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]<br />
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]<br />
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]<br />
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]</div>Leitohttps://dosideas.com/wiki/index.php?title=REST_con_Spring&diff=5641REST con Spring2010-12-22T15:35:19Z<p>Leito: /* Ver también */</p>
<hr />
<div>[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple. <br />
<br />
== Un ejemplo ==<br />
Vamos a realizar una aplicación que responda a las siguientes URL: <br />
<br />
/persona/todos : devuelve todas las personas<br />
/persona/123 : devuelve la persona cuyo id es 123<br />
<br />
Tendremos que seguir 3 pasos:<br />
# Configurar el servlet de Spring<br />
# Crear la clase que atenderá y resolverá estas peticiones<br />
# Configurar Spring<br />
<br />
=== El servlet de Spring ===<br />
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: <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<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"><br />
<display-name>json-con-spring-mvc</display-name><br />
<br />
<filter><br />
<filter-name>characterEncodingFilter</filter-name><br />
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><br />
<init-param><br />
<param-name>encoding</param-name><br />
<param-value>UTF-8</param-value><br />
</init-param><br />
<init-param><br />
<param-name>forceEncoding</param-name><br />
<param-value>true</param-value><br />
</init-param><br />
</filter><br />
<br />
<filter-mapping><br />
<filter-name>characterEncodingFilter</filter-name><br />
<url-pattern>/*</url-pattern><br />
</filter-mapping><br />
<br />
<servlet><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><br />
<init-param><br />
<param-name>contextConfigLocation</param-name><br />
<param-value><br />
WEB-INF/applicationContext-clasico.xml<br />
</param-value><br />
</init-param><br />
<load-on-startup>1</load-on-startup><br />
</servlet><br />
<br />
<servlet-mapping><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<url-pattern>/app/*</url-pattern><br />
</servlet-mapping><br />
<br />
<session-config><br />
<session-timeout><br />
30<br />
</session-timeout><br />
</session-config><br />
<welcome-file-list><br />
<welcome-file>index.jsp</welcome-file><br />
</welcome-file-list><br />
</web-app><br />
</code><br />
<br />
En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app". <br />
<br />
=== El controller ===<br />
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.)<br />
<br />
Para esto, creamos una clase de la siguiente forma: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.util.ArrayList;<br />
import java.util.Collection;<br />
import org.springframework.stereotype.Controller;<br />
import org.springframework.web.bind.annotation.PathVariable;<br />
import org.springframework.web.bind.annotation.RequestBody;<br />
import org.springframework.web.bind.annotation.RequestMapping;<br />
import org.springframework.web.bind.annotation.ResponseBody;<br />
<br />
@Controller<br />
@RequestMapping(value="/persona")<br />
public class PersonaController {<br />
<br />
@RequestMapping(value="/{id}")<br />
public @ResponseBody Persona get(@PathVariable Long id) {<br />
Persona p = new Persona("Invasor " + id, "Zim " + id);<br />
return p;<br />
}<br />
<br />
@RequestMapping(value="/todos")<br />
public @ResponseBody Collection<Persona> getTodos() {<br />
Collection<Persona> personas = new ArrayList<Persona>();<br />
for (int i = 0; i < 10; i++) {<br />
Persona p = new Persona("Invasor " + i, "Zim" + i);<br />
personas.add(p);<br />
}<br />
<br />
return personas;<br />
}<br />
}<br />
</code><br />
<br />
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. <br />
<br />
=== La configuración ===<br />
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet): <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<beans xmlns="http://www.springframework.org/schema/beans"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xmlns:p="http://www.springframework.org/schema/p"<br />
xmlns:aop="http://www.springframework.org/schema/aop"<br />
xmlns:tx="http://www.springframework.org/schema/tx"<br />
xmlns:context="http://www.springframework.org/schema/context"<br />
xmlns:mvc="http://www.springframework.org/schema/mvc"<br />
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd<br />
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd<br />
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd<br />
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd<br />
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"><br />
<br />
<context:component-scan base-package="com.dosideas.jsonconspringmvc"/><br />
<br />
<mvc:annotation-driven /><br />
<br />
</beans><br />
</code><br />
<br />
El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados. <br />
<br />
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. <br />
<br />
=== Probando ===<br />
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.io.IOException;<br />
import org.apache.commons.httpclient.methods.GetMethod;<br />
import org.apache.commons.httpclient.HttpMethod;<br />
import org.apache.commons.httpclient.HttpClient;<br />
import org.junit.Test;<br />
import static org.junit.Assert.*;<br />
<br />
public class HttpTest {<br />
<br />
@Test<br />
public void personaTodosJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("[{\""));<br />
}<br />
<br />
@Test<br />
public void personaPorIdJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("{\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
@Test<br />
public void personaPorIdXML() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/xml");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
}<br />
</code><br />
<br />
== Ver también ==<br />
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=41%3Ap Descargar un proyecto de ejemplo]<br />
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]<br />
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]<br />
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]</div>Leitohttps://dosideas.com/wiki/index.php?title=REST_con_Spring&diff=5640REST con Spring2010-12-22T15:22:23Z<p>Leito: /* Probando */</p>
<hr />
<div>[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple. <br />
<br />
== Un ejemplo ==<br />
Vamos a realizar una aplicación que responda a las siguientes URL: <br />
<br />
/persona/todos : devuelve todas las personas<br />
/persona/123 : devuelve la persona cuyo id es 123<br />
<br />
Tendremos que seguir 3 pasos:<br />
# Configurar el servlet de Spring<br />
# Crear la clase que atenderá y resolverá estas peticiones<br />
# Configurar Spring<br />
<br />
=== El servlet de Spring ===<br />
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: <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<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"><br />
<display-name>json-con-spring-mvc</display-name><br />
<br />
<filter><br />
<filter-name>characterEncodingFilter</filter-name><br />
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><br />
<init-param><br />
<param-name>encoding</param-name><br />
<param-value>UTF-8</param-value><br />
</init-param><br />
<init-param><br />
<param-name>forceEncoding</param-name><br />
<param-value>true</param-value><br />
</init-param><br />
</filter><br />
<br />
<filter-mapping><br />
<filter-name>characterEncodingFilter</filter-name><br />
<url-pattern>/*</url-pattern><br />
</filter-mapping><br />
<br />
<servlet><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><br />
<init-param><br />
<param-name>contextConfigLocation</param-name><br />
<param-value><br />
WEB-INF/applicationContext-clasico.xml<br />
</param-value><br />
</init-param><br />
<load-on-startup>1</load-on-startup><br />
</servlet><br />
<br />
<servlet-mapping><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<url-pattern>/app/*</url-pattern><br />
</servlet-mapping><br />
<br />
<session-config><br />
<session-timeout><br />
30<br />
</session-timeout><br />
</session-config><br />
<welcome-file-list><br />
<welcome-file>index.jsp</welcome-file><br />
</welcome-file-list><br />
</web-app><br />
</code><br />
<br />
En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app". <br />
<br />
=== El controller ===<br />
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.)<br />
<br />
Para esto, creamos una clase de la siguiente forma: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.util.ArrayList;<br />
import java.util.Collection;<br />
import org.springframework.stereotype.Controller;<br />
import org.springframework.web.bind.annotation.PathVariable;<br />
import org.springframework.web.bind.annotation.RequestBody;<br />
import org.springframework.web.bind.annotation.RequestMapping;<br />
import org.springframework.web.bind.annotation.ResponseBody;<br />
<br />
@Controller<br />
@RequestMapping(value="/persona")<br />
public class PersonaController {<br />
<br />
@RequestMapping(value="/{id}")<br />
public @ResponseBody Persona get(@PathVariable Long id) {<br />
Persona p = new Persona("Invasor " + id, "Zim " + id);<br />
return p;<br />
}<br />
<br />
@RequestMapping(value="/todos")<br />
public @ResponseBody Collection<Persona> getTodos() {<br />
Collection<Persona> personas = new ArrayList<Persona>();<br />
for (int i = 0; i < 10; i++) {<br />
Persona p = new Persona("Invasor " + i, "Zim" + i);<br />
personas.add(p);<br />
}<br />
<br />
return personas;<br />
}<br />
}<br />
</code><br />
<br />
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. <br />
<br />
=== La configuración ===<br />
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet): <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<beans xmlns="http://www.springframework.org/schema/beans"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xmlns:p="http://www.springframework.org/schema/p"<br />
xmlns:aop="http://www.springframework.org/schema/aop"<br />
xmlns:tx="http://www.springframework.org/schema/tx"<br />
xmlns:context="http://www.springframework.org/schema/context"<br />
xmlns:mvc="http://www.springframework.org/schema/mvc"<br />
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd<br />
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd<br />
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd<br />
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd<br />
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"><br />
<br />
<context:component-scan base-package="com.dosideas.jsonconspringmvc"/><br />
<br />
<mvc:annotation-driven /><br />
<br />
</beans><br />
</code><br />
<br />
El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados. <br />
<br />
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. <br />
<br />
=== Probando ===<br />
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.io.IOException;<br />
import org.apache.commons.httpclient.methods.GetMethod;<br />
import org.apache.commons.httpclient.HttpMethod;<br />
import org.apache.commons.httpclient.HttpClient;<br />
import org.junit.Test;<br />
import static org.junit.Assert.*;<br />
<br />
public class HttpTest {<br />
<br />
@Test<br />
public void personaTodosJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("[{\""));<br />
}<br />
<br />
@Test<br />
public void personaPorIdJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("{\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
@Test<br />
public void personaPorIdXML() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/xml");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
}<br />
</code><br />
<br />
== Ver también ==<br />
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]<br />
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]<br />
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]</div>Leitohttps://dosideas.com/wiki/index.php?title=Spring_Framework&diff=5639Spring Framework2010-12-22T15:20:37Z<p>Leito: /* Ver también */</p>
<hr />
<div>[[Category:Spring Framework]]<br />
<br />
Spring Framework (también conocido simplemente como Spring) es un framework [[Java]] de [[Software Libre]], liviano de aplicación (también existe actualmente una versión para .NET). Su principal característica es brindar un factory de objetos basado en la [[Inyeccion De Dependencia]].<br />
<br />
Por su diseño el framework ofrece mucha libertad a los desarrolladores en Java y soluciones muy bien documentadas y fáciles de usar para las prácticas comunes en la industria.<br />
<br />
Mientras que las características fundamentales de este framework pueden emplearse en cualquier aplicación hecha en Java, existen muchas extensiones y mejoras para construir aplicaciones basadas en web por encima de la plataforma [[Java EE]]<br />
<br />
{{curso|url=http://www.dosideas.com/cursos/course/view.php?id=13|nombre=Introducción a Spring Framework 3.0}}<br />
<br />
{{curso|url=http://www.dosideas.com/cursos/course/view.php?id=4|nombre=Introducción al desarrollo Java EE}}<br />
<br />
==Descargar la librería==<br />
Spring puede bajarse libremente de la [http://www.springframework.org web oficial de Spring].<br />
<br />
Existen dos distribuciones básicas: la librería de Spring por si misma, y un paquete que contiene Spring junto con todas las dependencias ("with-dependencies"). Este último paquete es el recomendado para comenzar con Spring.<br />
<br />
==Ver también==<br />
* [[Configuracion De Spring]]<br />
* [[Enviar Mails Con Spring]]<br />
* [[Interceptores Con Spring]]<br />
* [[Instanciacion De Objetos Con Spring]]<br />
* [[Transacciones Con Spring]]<br />
* [[Mensajeria Con Spring]]<br />
* [[Hibernate Con Spring]]<br />
* [[Web Service Con Spring]]<br />
* [[REST con Spring]]<br />
* [[Stored Procedures con Spring]]<br />
* [[Ejb Con Spring]]<br />
* [[JSF Con Spring]]<br />
* [[Groovy Con Spring]]<br />
* [[Spring Batch]]<br />
* [[Buenas Practicas De Configuracion De Spring]]<br />
* [[Inyeccion De Mocks De Mockito Con Spring]]<br />
* [[Inicializacion Lazy De Spring Para Tests]]<br />
* [[WebLogic con Spring]]<br />
* [[Spring Integration]]<br />
* [[Despliegue de Rars con Spring]]<br />
* [[Controller con Spring usando anotaciones]]<br />
* [[PropertyEditor de Spring]]<br />
* [[Spring LDAP]]<br />
<br />
==Más información==<br />
* [http://www.dosideas.com/descargas/category/2-spring-framework.html?download=30%3Ap-3.0 Descargar proyecto con ejemplos de uso]<br />
* [http://www.springframework.org Web oficial de Spring ]<br />
* [http://es.wikipedia.org/wiki/Spring_Framework Spring en la Wikipedia ]<br />
* [http://www.springframework.org/docs/Spring-MVC-step-by-step/ Developing a Spring Framework MVC application step-by-step ]<br />
* [http://wiki.netbeans.org/SpringMVConNetBeansGlassFish Step-by-step: Spring MVC with NetBeans and GlassFish]</div>Leitohttps://dosideas.com/wiki/index.php?title=REST_con_Spring&diff=5638REST con Spring2010-12-22T15:18:42Z<p>Leito: </p>
<hr />
<div>[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple. <br />
<br />
== Un ejemplo ==<br />
Vamos a realizar una aplicación que responda a las siguientes URL: <br />
<br />
/persona/todos : devuelve todas las personas<br />
/persona/123 : devuelve la persona cuyo id es 123<br />
<br />
Tendremos que seguir 3 pasos:<br />
# Configurar el servlet de Spring<br />
# Crear la clase que atenderá y resolverá estas peticiones<br />
# Configurar Spring<br />
<br />
=== El servlet de Spring ===<br />
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: <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<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"><br />
<display-name>json-con-spring-mvc</display-name><br />
<br />
<filter><br />
<filter-name>characterEncodingFilter</filter-name><br />
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><br />
<init-param><br />
<param-name>encoding</param-name><br />
<param-value>UTF-8</param-value><br />
</init-param><br />
<init-param><br />
<param-name>forceEncoding</param-name><br />
<param-value>true</param-value><br />
</init-param><br />
</filter><br />
<br />
<filter-mapping><br />
<filter-name>characterEncodingFilter</filter-name><br />
<url-pattern>/*</url-pattern><br />
</filter-mapping><br />
<br />
<servlet><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><br />
<init-param><br />
<param-name>contextConfigLocation</param-name><br />
<param-value><br />
WEB-INF/applicationContext-clasico.xml<br />
</param-value><br />
</init-param><br />
<load-on-startup>1</load-on-startup><br />
</servlet><br />
<br />
<servlet-mapping><br />
<servlet-name>Spring MVC Dispatcher Servlet</servlet-name><br />
<url-pattern>/app/*</url-pattern><br />
</servlet-mapping><br />
<br />
<session-config><br />
<session-timeout><br />
30<br />
</session-timeout><br />
</session-config><br />
<welcome-file-list><br />
<welcome-file>index.jsp</welcome-file><br />
</welcome-file-list><br />
</web-app><br />
</code><br />
<br />
En este ejemplo, el servlet de Spring queda atendiendo todas las URL que empiecen con "/app". <br />
<br />
=== El controller ===<br />
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.)<br />
<br />
Para esto, creamos una clase de la siguiente forma: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.util.ArrayList;<br />
import java.util.Collection;<br />
import org.springframework.stereotype.Controller;<br />
import org.springframework.web.bind.annotation.PathVariable;<br />
import org.springframework.web.bind.annotation.RequestBody;<br />
import org.springframework.web.bind.annotation.RequestMapping;<br />
import org.springframework.web.bind.annotation.ResponseBody;<br />
<br />
@Controller<br />
@RequestMapping(value="/persona")<br />
public class PersonaController {<br />
<br />
@RequestMapping(value="/{id}")<br />
public @ResponseBody Persona get(@PathVariable Long id) {<br />
Persona p = new Persona("Invasor " + id, "Zim " + id);<br />
return p;<br />
}<br />
<br />
@RequestMapping(value="/todos")<br />
public @ResponseBody Collection<Persona> getTodos() {<br />
Collection<Persona> personas = new ArrayList<Persona>();<br />
for (int i = 0; i < 10; i++) {<br />
Persona p = new Persona("Invasor " + i, "Zim" + i);<br />
personas.add(p);<br />
}<br />
<br />
return personas;<br />
}<br />
}<br />
</code><br />
<br />
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. <br />
<br />
=== La configuración ===<br />
Lo último que nos queda configurar es Spring con un archivo clásico (el cual es referenciado por el servlet): <br />
<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<beans xmlns="http://www.springframework.org/schema/beans"<br />
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<br />
xmlns:p="http://www.springframework.org/schema/p"<br />
xmlns:aop="http://www.springframework.org/schema/aop"<br />
xmlns:tx="http://www.springframework.org/schema/tx"<br />
xmlns:context="http://www.springframework.org/schema/context"<br />
xmlns:mvc="http://www.springframework.org/schema/mvc"<br />
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd<br />
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd<br />
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd<br />
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd<br />
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"><br />
<br />
<context:component-scan base-package="com.dosideas.jsonconspringmvc"/><br />
<br />
<mvc:annotation-driven /><br />
<br />
</beans><br />
</code><br />
<br />
El tag ''mvc:annotation-driven'' se encarga de configurar automáticamente para emepezar a recibir y responder peticiones usando los controladores encontrados. <br />
<br />
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. <br />
<br />
=== Probando ===<br />
Podemos crear una prueba [[JUnit]] para acceder a nuestro servicio: <br />
<br />
<code java5><br />
package com.dosideas.jsonconspringmvc;<br />
<br />
import java.io.IOException;<br />
import org.apache.commons.httpclient.methods.GetMethod;<br />
import org.apache.commons.httpclient.HttpMethod;<br />
import org.apache.commons.httpclient.HttpClient;<br />
import org.junit.After;<br />
import org.junit.AfterClass;<br />
import org.junit.Before;<br />
import org.junit.BeforeClass;<br />
import org.junit.Test;<br />
import static org.junit.Assert.*;<br />
<br />
public class HttpTest {<br />
<br />
@Test<br />
public void personaTodosJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/todos");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("[{\""));<br />
}<br />
<br />
@Test<br />
public void personaPorIdJSON() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/json");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("{\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
@Test<br />
public void personaPorIdXML() throws IOException {<br />
HttpClient httpclient = new HttpClient();<br />
HttpMethod method = new GetMethod("http://localhost:8084/json-con-spring-mvc/app/persona/34421");<br />
method.addRequestHeader("accept", "application/xml");<br />
<br />
httpclient.executeMethod(method);<br />
String resultado = method.getResponseBodyAsString();<br />
System.out.println(resultado);<br />
<br />
assertNotNull(resultado);<br />
assertTrue(resultado.startsWith("<?xml version=\"1.0\""));<br />
assertTrue(resultado.contains("34421"));<br />
}<br />
<br />
}<br />
</code><br />
<br />
<br />
== Ver también ==<br />
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]<br />
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]<br />
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]</div>Leitohttps://dosideas.com/wiki/index.php?title=REST_con_Spring&diff=5637REST con Spring2010-12-22T15:02:25Z<p>Leito: Página creada con 'Spring Framework 3.x trae la posibilidad de crear servicios web REST de manera muy simple. == Ver también == * [http://static.springsource.org/spring/docs/3.0.0.M3/spring…'</p>
<hr />
<div>[[Spring Framework]] 3.x trae la posibilidad de crear servicios web REST de manera muy simple. <br />
<br />
== Ver también ==<br />
* [http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18.html Creating Restful services - Documentación oficial]<br />
* [http://www.informit.com/guides/content.aspx?g=java&seqNum=544 Creating Restful web services]<br />
* [http://www.ibm.com/developerworks/web/library/wa-spring3webserv/index.html?ca=drs- Building RESTful web services using Spring 3]</div>Leitohttps://dosideas.com/wiki/index.php?title=Web_Service_Con_Spring&diff=5636Web Service Con Spring2010-12-22T14:52:42Z<p>Leito: /* Ver también */</p>
<hr />
<div>[[Spring Framework]] tiene un soporte para poder invocar web services de forma muy simple.<br />
<br />
A continuación vamos a ver un ejemplo concreto invocando a un [[Web Service]] de prueba.<br />
<br />
==El web service HolaMundo==<br />
<br />
Supongamos que tenemos un web service funcionando, con la siguiente operación:<br />
<br />
decirHola(nombre : String) : String<br />
<br />
De este web service, por supuesto, conocemos la URL del [[WSDL]].<br />
<br />
===Invocando al web service con Spring===<br />
<br />
Acceder a un web service con Spring implica programar una única interfaz, que será nuestra interfaz de negocio que representará las operaciones del web service.<br />
<br />
El resto es configuración, asociando dicha interfaz al web service que queremos consumir.<br />
<br />
====La interfaz====<br />
<br />
La interfaz HolaMundo será entonces muy simple:<br />
<code java><br />
package com.dosideas.ws.business;<br />
<br />
public interface HolaMundoBo {<br />
public String decirHola(String nombre);<br />
}<br />
</code><br />
<br />
Eso será todo lo que programaremos para consumir a nuestro web service.<br />
<br />
====La configuración====<br />
<br />
Claro que, falta la magia de la configuración. Deberemos declarar nuestro bean para ser consumible en un archivo de configuración de Spring.<br />
<code xml><br />
<bean id="business.HolaMundoBo" <br />
class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean"><br />
<property name="serviceInterface"<br />
value="com.dosideas.ws.business.HolaMundoBo" /><br />
<property name="wsdlDocumentUrl"<br />
value="http://localhost:8080/HolaMundoWS/HolaMundoWebServiceService?wsdl" /><br />
<property name="namespaceUri"<br />
value="http://ws.demo.dosideas.com/" /><br />
<property name="serviceName"<br />
value="HolaMundoWebServiceService" /><br />
<property name="portName"<br />
value="HolaMundoWebServicePort" /><br />
<property name="serviceFactoryClass"<br />
value="org.apache.axis.client.ServiceFactory"/><br />
</bean><br />
</code><br />
<br />
El atributo '''serviceInterface''' es la interfaz de negocio que deberá implementar Spring, y es la interfaz que escribimos en el punto anterior.<br />
<br />
El atributo '''wsdlDocumentUrl''' es justamente la URL del WSDL.<br />
<br />
Los atributos '''namespaceUri''', '''serviceName''' y '''portName''' son los datos necesarios para invocar un web service cualquiera, y salen del mismo WSDL.<br />
<br />
====Invocando al web service====<br />
<br />
A partir de aquí, invocar al web service es exactamente igual que invocar a cualquier otra clase. Supongamos entonces el método de un test:<br />
<code java><br />
public void testHolaMundo() {<br />
HolaMundoBo instance = (HolaMundoBo) ApplicationContext.getBean("business.HolaMundoBo");<br />
String result = instance.decirHola("Zim");<br />
assertEquals("Hola, Zim", result);<br />
}<br />
</code><br />
<br />
==Sobre los tipos de Web Services==<br />
<br />
Existen dos tipos de web services: RPC y Document.<br />
<br />
Si bien el nombre de la clase no parece indicarlo, es posible usar el método arriba indicado para acceder a web services Document.<br />
<br />
Si el web service contiene objetos no comunes (DTOs propios, por ejemplo) será necesario declarar serializadores para dichos DTO. El subcapítulo 17.5.3 Register Bean Mappings tiene un ejemplo de cómo registrar mapeos propios..<br />
<br />
== Ver también ==<br />
* [[REST con Spring]]<br />
* [[Spring Web Services]]<br />
* [[Web Service]]<br />
* [[Spring Framework]]<br />
* [http://static.springframework.org/spring/docs/1.1.5/reference/remoting.html Manual de Spring, Capítulo 17: Remoting]<br />
<br />
[[Categoría:Spring Framework]]<br />
[[Categoría:Web Service]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Conformaci%C3%B3n_de_equipos&diff=3429Conformación de equipos2009-10-09T18:38:28Z<p>Leito: /* La intención de conformar un equipo */</p>
<hr />
<div>El desarrollo de software consiste en la creación de Propiedad Intelectual: creamos abstracciones, cosas que no existen en el mundo real. Aplicamos nuestro intelecto para crear productos de software. <br />
<br />
Este trabajo intelectual lo hacemos en equipos, esperando lograr armonia y sinergía entre sus integrantes para crear los mejores productos posibles. Lo cierto es, muy pocas veces tenemos ''intención'' de crear Grandes Equipos. Y, sin embargo, recién cuando seamos capaces de crear Grandes Equipos de personas podremos alcanzar un Gran Producto, ese software que exceda las expectativas de nuestro cliente. <br />
<br />
La conformación de equipos trata sobre cómo crear Grandes Equipos, en donde los integrantes actuen de forma profesional, íntegra y alineada en pos de un objetivo en común.<br />
<br />
== La intención de conformar un equipo ==<br />
Generalmente, aprendemos a programar "de forma casera": nos enseña algo la facultad, vemos cómo programa un amigo o colega, y obviamente probamos mucho por nuestra cuenta. No tenemos ''intención'' de programar "bien", sino simples ganas. Pero más allá de estas ganas, es común que varias personas pasen su tiempo sin hacer algo concreto y probado para programar ''mejor''. Sin embargo, cuando realmente emepezamos a actuar con verdadera intención de mejorar, aprendemos que existen patrones de diseño, prácticas probadas, convenciones, etc. Más aún, entramos en contacto con prácticas como [[Extreme Programming]], que nos guian a través de prácticas para lograr programar de manera profesional. Logramos la intención de programar bien. <br />
<br />
Algo similar ocurre con la gestión de proyectos. Es común que los jefes gestionen los proyectos "con la receta de la abuela": técnicas y prácticas que surgen del día-a-día. Son estos jefes que terminan gestionado "como se hace acá", usando planillas de excel, mails, pedidos verbales, llamados por teléfono, micro-gestión, ausencia de gestión, y a veces todo esto junto. Gestionamos proyectos sin intención de gestionar bien. Recién cuando cobramos consciencia de nuestra necesidad de tener una ''intención'' por gestionar es que comenzamos a ver lo que ocurre en el mundo. Y allí nos encontramos con técnicas para la gestión de proyectos, como por ejemplo [[Scrum]]. Logramos la intención de gestionar bien.<br />
<br />
Y sin embargo, podemos lograr la intención de programar bien, podemos lograr una buena gestión de proyectos... y nos sigue quedando una parte fundamental por cubrir. La gestión de proyectos y la programación son actividades que giran alrededor de '''equipos de personas'''. ¿Y cómo conformamos estos equipos? ¿Tenemos ''intención'' de crear buenos equipos? <br />
<br />
Es común que dejemos librado al azar la conformación del equipo: juntamos a un grupo de personas y les pedimos que resuelvan un proyecto, que generen un producto. Pero, ¿qué hacemos para que este equipo logre alcanzar su máximo potencial, para así lograr el mejor resultado? <br />
<br />
Las técnicas de conformación de equipos se encargan de este paso fundamental para el desarrollo de software. '''Antes de construir software debemos construir personas'''.<br />
<br />
En esta sección hablaremos sobre distintas técnicas de conformación de equipos, basadas en el libro '''Software for your head''', de Jim y Michele McCarthy (ISBN 0-201-60456-6).<br />
<br />
==Las etapas para crear un Gran Equipo==<br />
La conformación de un equipo de propiedad intelectual gira alrededor de las personas, sus relaciones y emociones. ¿Cómo mejorar la relación entre las personas? ¿Cómo entender lo que nos pasa? ¿Hacia dónde vamos? ¿Qué queremos para nosotros? ¿Y para el equipo?<br />
<br />
Nuestro objetivo será encontrar una Visión Compartida por el equipo: aquello que una y guíe al equipo más allá de la duración de un proyecto. Algo que sea de tanto valor para el equipo y para las personas que logre perdurar en el tiempo. Algo por lo que que valga la pena el esfuerzo. <br />
<br />
Veremos varios protocolos y patrones para logra conformar el Mejor Equipo, que genere así el Mejor Producto posible. Las 4 etapas, en órden, serán: <br />
<br />
# Check-In<br />
# Decisión<br />
# Alineamiento<br />
# Visión compartida<br />
<br />
<br />
=== Check-In ===<br />
<br />
=== Decisión ===<br />
<br />
=== Alineamiento ===<br />
<br />
=== Visión compartida ===<br />
<br />
<br />
== Las personas son quienes crean al producto ==<br />
<br />
(EQUIPO = PRODUCTO) es uno de los conceptos más importantes del desarrollo de software, y a menudo queda olvidado. El PRODUCTO es consecuencia del trabajo del EQUIPO: todas las características que tiene un PRODUCTO son porque el EQUIPO fue capaz de generarlas. Por otro lado, no puedo agregar algo a un PRODUCTO si en el EQUIPO no existe una característica que lo genere. <br />
<br />
Existe una correlación directa (aunque a veces no obvia) entre una característica del PRODUCTO y una característica del EQUIPO. Ahora, como el PRODUCTO es consecuencia del trabajo del EQUIPO, para introducir o modificar características en el PRODUCTO deberemos actuar sobre el EQUIPO, que es la única parte de la ecuación a la que tenemos acceso. <br />
<br />
De esta manera, (EQUIPO = PRODUCTO) nos permite analizar de forma pasiva una situación. También es una herramienta activa sumamente poderosa, ya que al modificar al EQUIPO vamos a modificar, inevitablemente, el PRODUCTO que se construye. <br />
<br />
=== Los procesos y las personas ===<br />
Son las personas quienes, a través de sus relaciones, crean y sostienen a los procesos. Son las personas quienes usan y aplican las herramientas. Y en definitiva, son las personas quienes trabajan en equipo y crean productos. Por eso buscamos crear los Mejores Equipos que nos permitan desarrollar los Mejores Productos para nuestros clientes. <br />
<br />
Los valores que respaldamos y aplicamos en su totalidad nos permiten crear mejores relaciones humanas que, a su vez, generan los mejores equipos de propiedad intelectual posibles. Y allí reside el gran valor que tenemos para ofrecerle a nuestro cliente.<br />
<br />
=== La conformación de equipos ===<br />
Teniendo en cuenta que deberemos trabajar sobre el Equipo, estamos hablando de relaciones de personas. <br />
<br />
[[Agil]] habla de un cambio en la forma de pensar y encarar el trabajo, basándonos fuertemente en principios y valores humanos. Aquí radica la dificultad de una implementación Ágil verdadera. <br />
<br />
Ágil NO es implementar Scrum, XP u otra metodología. Ágil es un cambio cultural que, luego, se acompaña con cambios en las prácticas y métodos de la organización. <br />
<br />
Implementar Scrum (o cuaqluier metodología) sin aceptar el desafío del cambio cultural es una invitación al desastre. Es en el cambio cultural donde radica el verdadero valor de negocio que se pretende generar y maximizar, y no en metodologías particulares. Ya lo sabemos: la bala de plata no existe. Sólo el trabajo serio y profesional. <br />
<br />
Es por todo esto que la conformación de equipos es un aspecto fundamental en el desarrollo de cualquier creación de propiedad intelectual (como ser el desarrollo de software). Son las personas que, a través de sus conversaciones, generan relaciones y obtienen resultados (como ser, un producto de software).</div>Leitohttps://dosideas.com/wiki/index.php?title=Conformaci%C3%B3n_de_equipos&diff=3428Conformación de equipos2009-10-09T18:10:50Z<p>Leito: </p>
<hr />
<div>El desarrollo de software consiste en la creación de Propiedad Intelectual: creamos abstracciones, cosas que no existen en el mundo real. Aplicamos nuestro intelecto para crear productos de software. <br />
<br />
Este trabajo intelectual lo hacemos en equipos, esperando lograr armonia y sinergía entre sus integrantes para crear los mejores productos posibles. Lo cierto es, muy pocas veces tenemos ''intención'' de crear Grandes Equipos. Y, sin embargo, recién cuando seamos capaces de crear Grandes Equipos de personas podremos alcanzar un Gran Producto, ese software que exceda las expectativas de nuestro cliente. <br />
<br />
La conformación de equipos trata sobre cómo crear Grandes Equipos, en donde los integrantes actuen de forma profesional, íntegra y alineada en pos de un objetivo en común.<br />
<br />
== La intención de conformar un equipo ==<br />
Generalmente, aprendemos a programar "de forma casera": nos enseña algo la facultad, vemos cómo programa un amigo o colega, y obviamente probamos mucho por nuestra cuenta. No tenemos ''intención'' de programar "bien", sino simples ganas. Pero más allá de estas ganas, es común que varias personas pasen su tiempo sin hacer algo concreto y probado para programar ''mejor''. Sin embargo, cuando realmente emepezamos a actuar con verdadera intención de mejorar, aprendemos que existen patrones de diseño, prácticas probadas, convenciones, etc. Más aún, entramos en contacto con prácticas como [[Extreme Programming]], que nos guian a través de prácticas para lograr programar de manera profesional. Logramos la intención de programar bien. <br />
<br />
Algo similar ocurre con la gestión de proyectos. Es común que los jefes gestionen los proyectos "con la receta de la abuela": técnicas y prácticas que surgen del día-a-día. Son estos jefes que terminan gestionado "como se hace acá", usando planillas de excel, mails, pedidos verbales, llamados por teléfono, micro-gestión, ausencia de gestión, y a veces todo esto junto. Gestionamos proyectos sin intención de gestionar bien. Recién cuando cobramos consciencia de nuestra necesidad de tener una ''intención'' por gestionar es que comenzamos a ver lo que ocurre en el mundo. Y allí nos encontramos con técnicas para la gestión de proyectos, como por ejemplo [[Scrum]]. Logramos la intención de gestionar bien.<br />
<br />
Y sin embargo, podemos lograr la intención de programar bien, podemos lograr una buena gestión de proyectos... y nos sigue quedando una parte fundamental por cubrir. La gestión de proyectos y la programación son actividades que giran alrededor de '''equipos de personas'''. ¿Y cómo conformamos estos equipos? ¿Tenemos ''intención'' de crear buenos equipos? <br />
<br />
Es común que dejemos librado al azar la conformación del equipo: juntamos a un grupo de personas y les pedimos que resuelvan un proyecto, que generen un producto. Pero, ¿qué hacemos para que este equipo logre alcanzar su máximo potencial, para así lograr el mejor resultado? <br />
<br />
Las técnicas de conformación de equipos se encargan de este paso fundamental para el desarrollo de software. '''Antes de construir software debemos construir personas'''.<br />
<br />
En esta sección hablaremos sobre distintas técnicas de conformación de equipos, basadas en el libro '''Software for your head''', de Jim y Michele McCarthy. <br />
<br />
==Las etapas para crear un Gran Equipo==<br />
La conformación de un equipo de propiedad intelectual gira alrededor de las personas, sus relaciones y emociones. ¿Cómo mejorar la relación entre las personas? ¿Cómo entender lo que nos pasa? ¿Hacia dónde vamos? ¿Qué queremos para nosotros? ¿Y para el equipo?<br />
<br />
Nuestro objetivo será encontrar una Visión Compartida por el equipo: aquello que una y guíe al equipo más allá de la duración de un proyecto. Algo que sea de tanto valor para el equipo y para las personas que logre perdurar en el tiempo. Algo por lo que que valga la pena el esfuerzo. <br />
<br />
Veremos varios protocolos y patrones para logra conformar el Mejor Equipo, que genere así el Mejor Producto posible. Las 4 etapas, en órden, serán: <br />
<br />
# Check-In<br />
# Decisión<br />
# Alineamiento<br />
# Visión compartida<br />
<br />
<br />
=== Check-In ===<br />
<br />
=== Decisión ===<br />
<br />
=== Alineamiento ===<br />
<br />
=== Visión compartida ===<br />
<br />
<br />
== Las personas son quienes crean al producto ==<br />
<br />
(EQUIPO = PRODUCTO) es uno de los conceptos más importantes del desarrollo de software, y a menudo queda olvidado. El PRODUCTO es consecuencia del trabajo del EQUIPO: todas las características que tiene un PRODUCTO son porque el EQUIPO fue capaz de generarlas. Por otro lado, no puedo agregar algo a un PRODUCTO si en el EQUIPO no existe una característica que lo genere. <br />
<br />
Existe una correlación directa (aunque a veces no obvia) entre una característica del PRODUCTO y una característica del EQUIPO. Ahora, como el PRODUCTO es consecuencia del trabajo del EQUIPO, para introducir o modificar características en el PRODUCTO deberemos actuar sobre el EQUIPO, que es la única parte de la ecuación a la que tenemos acceso. <br />
<br />
De esta manera, (EQUIPO = PRODUCTO) nos permite analizar de forma pasiva una situación. También es una herramienta activa sumamente poderosa, ya que al modificar al EQUIPO vamos a modificar, inevitablemente, el PRODUCTO que se construye. <br />
<br />
=== Los procesos y las personas ===<br />
Son las personas quienes, a través de sus relaciones, crean y sostienen a los procesos. Son las personas quienes usan y aplican las herramientas. Y en definitiva, son las personas quienes trabajan en equipo y crean productos. Por eso buscamos crear los Mejores Equipos que nos permitan desarrollar los Mejores Productos para nuestros clientes. <br />
<br />
Los valores que respaldamos y aplicamos en su totalidad nos permiten crear mejores relaciones humanas que, a su vez, generan los mejores equipos de propiedad intelectual posibles. Y allí reside el gran valor que tenemos para ofrecerle a nuestro cliente.<br />
<br />
=== La conformación de equipos ===<br />
Teniendo en cuenta que deberemos trabajar sobre el Equipo, estamos hablando de relaciones de personas. <br />
<br />
[[Agil]] habla de un cambio en la forma de pensar y encarar el trabajo, basándonos fuertemente en principios y valores humanos. Aquí radica la dificultad de una implementación Ágil verdadera. <br />
<br />
Ágil NO es implementar Scrum, XP u otra metodología. Ágil es un cambio cultural que, luego, se acompaña con cambios en las prácticas y métodos de la organización. <br />
<br />
Implementar Scrum (o cuaqluier metodología) sin aceptar el desafío del cambio cultural es una invitación al desastre. Es en el cambio cultural donde radica el verdadero valor de negocio que se pretende generar y maximizar, y no en metodologías particulares. Ya lo sabemos: la bala de plata no existe. Sólo el trabajo serio y profesional. <br />
<br />
Es por todo esto que la conformación de equipos es un aspecto fundamental en el desarrollo de cualquier creación de propiedad intelectual (como ser el desarrollo de software). Son las personas que, a través de sus conversaciones, generan relaciones y obtienen resultados (como ser, un producto de software).</div>Leitohttps://dosideas.com/wiki/index.php?title=Conformaci%C3%B3n_de_equipos&diff=3427Conformación de equipos2009-10-09T18:07:51Z<p>Leito: </p>
<hr />
<div>El desarrollo de software consiste en la creación de Propiedad Intelectual: creamos abstracciones, cosas que no existen en el mundo real. Aplicamos nuestro intelecto para crear productos de software. <br />
<br />
Este trabajo intelectual lo hacemos en equipos, esperando lograr armonia y sinergía entre sus integrantes para crear los mejores productos posibles. Lo cierto es, muy pocas veces tenemos ''intención'' de crear Grandes Equipos. Y, sin embargo, recién cuando seamos capaces de crear Grandes Equipos de personas podremos alcanzar un Gran Producto, ese software que exceda las expectativas de nuestro cliente. <br />
<br />
La conformación de equipos trata sobre cómo crear Grandes Equipos, en donde los integrantes actuen de forma profesional, íntegra y alineada en pos de un objetivo en común.<br />
<br />
== La intención de conformar un equipo ==<br />
Generalmente, aprendemos a programar "de forma casera": nos enseña algo la facultad, vemos cómo programa un amigo o colega, y obviamente probamos mucho por nuestra cuenta. No tenemos ''intención'' de programar "bien", sino simples ganas. Pero más allá de estas ganas, es común que varias personas pasen su tiempo sin hacer algo concreto y probado para programar ''mejor''. Sin embargo, cuando realmente emepezamos a actuar con verdadera intención de mejorar, aprendemos que existen patrones de diseño, prácticas probadas, convenciones, etc. Más aún, entramos en contacto con prácticas como [[Extreme Programming]], que nos guian a través de prácticas para lograr programar de manera profesional. Logramos la intención de programar bien. <br />
<br />
Algo similar ocurre con la gestión de proyectos. Es común que los jefes gestionen los proyectos "con la receta de la abuela": técnicas y prácticas que surgen del día-a-día. Son estos jefes que terminan gestionado "como se hace acá", usando planillas de excel, mails, pedidos verbales, llamados por teléfono, micro-gestión, ausencia de gestión, y a veces todo esto junto. Gestionamos proyectos sin intención de gestionar bien. Recién cuando cobramos consciencia de nuestra necesidad de tener una ''intención'' por gestionar es que comenzamos a ver lo que ocurre en el mundo. Y allí nos encontramos con técnicas para la gestión de proyectos, como por ejemplo [[Scrum]]. Logramos la intención de gestionar bien.<br />
<br />
Y sin embargo, podemos lograr la intención de programar bien, podemos lograr una buena gestión de proyectos... y nos sigue quedando una parte fundamental por cubrir. La gestión de proyectos y la programación son actividades que giran alrededor de '''equipos de personas'''. ¿Y cómo conformamos estos equipos? ¿Tenemos ''intención'' de crear buenos equipos? <br />
<br />
Es común que dejemos librado al azar la conformación del equipo: juntamos a un grupo de personas y les pedimos que resuelvan un proyecto, que generen un producto. Pero, ¿qué hacemos para que este equipo logre alcanzar su máximo potencial, para así lograr el mejor resultado? <br />
<br />
Las técnicas de conformación de equipos se encargan de este paso fundamental para el desarrollo de software. '''Antes de construir software debemos construir personas'''.<br />
<br />
En esta sección hablaremos sobre distintas técnicas de conformación de equipos, basadas en el libro '''Software for your head''', de Jim y Michele McCarthy. <br />
<br />
==Las etapas para crear un Gran Equipo==<br />
La conformación de un equipo de propiedad intelectual gira alrededor de las personas, sus relaciones y emociones. ¿Cómo mejorar la relación entre las personas? ¿Cómo entender lo que nos pasa? ¿Hacia dónde vamos? ¿Qué queremos para nosotros? ¿Y para el equipo?<br />
<br />
Nuestro objetivo será encontrar una Visión Compartida por el equipo: aquello que una y guíe al equipo más allá de la duración de un proyecto. Algo que sea de tanto valor para el equipo y para las personas que logre perdurar en el tiempo. Algo por lo que que valga la pena el esfuerzo. <br />
<br />
Veremos varios protocolos y patrones para logra conformar el Mejor Equipo, que genere así el Mejor Producto posible. Las 4 etapas, en órden, serán: <br />
<br />
# Check-In<br />
# Decisión<br />
# Alineamiento<br />
# Visión compartida<br />
<br />
<br />
=== Check-In ===<br />
<br />
=== Decisión ===<br />
<br />
=== Alineamiento ===<br />
<br />
=== Visión compartida ===<br />
<br />
<br />
<br />
(EQUIPO = PRODUCTO) es uno de los conceptos más importantes del desarrollo de software, y a menudo queda olvidado. El PRODUCTO es consecuencia del trabajo del EQUIPO: todas las características que tiene un PRODUCTO son porque el EQUIPO fue capaz de generarlas. Por otro lado, no puedo agregar algo a un PRODUCTO si en el EQUIPO no existe una característica que lo genere. <br />
<br />
Existe una correlación directa (aunque a veces no obvia) entre una característica del PRODUCTO y una característica del EQUIPO. Ahora, como el PRODUCTO es consecuencia del trabajo del EQUIPO, para introducir o modificar características en el PRODUCTO deberemos actuar sobre el EQUIPO, que es la única parte de la ecuación a la que tenemos acceso. <br />
<br />
De esta manera, (EQUIPO = PRODUCTO) nos permite analizar de forma pasiva una situación. También es una herramienta activa sumamente poderosa, ya que al modificar al EQUIPO vamos a modificar, inevitablemente, el PRODUCTO que se construye. <br />
<br />
== Los procesos y las personas ==<br />
Son las personas quienes, a través de sus relaciones, crean y sostienen a los procesos. Son las personas quienes usan y aplican las herramientas. Y en definitiva, son las personas quienes trabajan en equipo y crean productos. Por eso buscamos crear los Mejores Equipos que nos permitan desarrollar los Mejores Productos para nuestros clientes. <br />
<br />
Los valores que respaldamos y aplicamos en su totalidad nos permiten crear mejores relaciones humanas que, a su vez, generan los mejores equipos de propiedad intelectual posibles. Y allí reside el gran valor que tenemos para ofrecerle a nuestro cliente.<br />
<br />
== La conformación de equipos ==<br />
Teniendo en cuenta que deberemos trabajar sobre el Equipo, estamos hablando de relaciones de personas. <br />
<br />
[[Agil]] habla de un cambio en la forma de pensar y encarar el trabajo, basándonos fuertemente en principios y valores humanos. Aquí radica la dificultad de una implementación Ágil verdadera. <br />
<br />
Ágil NO es implementar Scrum, XP u otra metodología. Ágil es un cambio cultural que, luego, se acompaña con cambios en las prácticas y métodos de la organización. <br />
<br />
Implementar Scrum (o cuaqluier metodología) sin aceptar el desafío del cambio cultural es una invitación al desastre. Es en el cambio cultural donde radica el verdadero valor de negocio que se pretende generar y maximizar, y no en metodologías particulares. Ya lo sabemos: la bala de plata no existe. Sólo el trabajo serio y profesional. <br />
<br />
Es por todo esto que la conformación de equipos es un aspecto fundamental en el desarrollo de cualquier creación de propiedad intelectual (como ser el desarrollo de software). Son las personas que, a través de sus conversaciones, generan relaciones y obtienen resultados (como ser, un producto de software).</div>Leitohttps://dosideas.com/wiki/index.php?title=Conformaci%C3%B3n_de_equipos&diff=3426Conformación de equipos2009-10-09T17:58:56Z<p>Leito: </p>
<hr />
<div>El desarrollo de software consiste en la creación de Propiedad Intelectual: creamos abstracciones, cosas que no existen en el mundo real. Aplicamos nuestro intelecto para crear productos de software. <br />
<br />
Este trabajo intelectual lo hacemos en equipos, esperando lograr armonia y sinergía entre sus integrantes para crear los mejores productos posibles. Lo cierto es, muy pocas veces tenemos ''intención'' de crear Grandes Equipos. Y, sin embargo, recién cuando seamos capaces de crear Grandes Equipos de personas podremos alcanzar un Gran Producto, ese software que exceda las expectativas de nuestro cliente. <br />
<br />
La conformación de equipos trata sobre cómo crear Grandes Equipos, en donde los integrantes actuen de forma profesional, íntegra y alineada en pos de un objetivo en común.<br />
<br />
== La intención de conformar un equipo ==<br />
Generalmente, aprendemos a programar "de forma casera": nos enseña algo la facultad, vemos cómo programa un amigo o colega, y obviamente probamos mucho por nuestra cuenta. No tenemos ''intención'' de programar "bien", sino simples ganas. Pero más allá de estas ganas, es común que varias personas pasen su tiempo sin hacer algo concreto y probado para programar ''mejor''. Sin embargo, cuando realmente emepezamos a actuar con verdadera intención de mejorar, aprendemos que existen patrones de diseño, prácticas probadas, convenciones, etc. Más aún, entramos en contacto con prácticas como [[Extreme Programming]], que nos guian a través de prácticas para lograr programar de manera profesional. Logramos la intención de programar bien. <br />
<br />
Algo similar ocurre con la gestión de proyectos. Es común que los jefes gestionen los proyectos "con la receta de la abuela": técnicas y prácticas que surgen del día-a-día. Son estos jefes que terminan gestionado "como se hace acá", usando planillas de excel, mails, pedidos verbales, llamados por teléfono, micro-gestión, ausencia de gestión, y a veces todo esto junto. Gestionamos proyectos sin intención de gestionar bien. Recién cuando cobramos consciencia de nuestra necesidad de tener una ''intención'' por gestionar es que comenzamos a ver lo que ocurre en el mundo. Y allí nos encontramos con técnicas para la gestión de proyectos, como por ejemplo [[Scrum]]. Logramos la intención de gestionar bien.<br />
<br />
<br />
<br />
<br />
<br />
(EQUIPO = PRODUCTO) es uno de los conceptos más importantes del desarrollo de software, y a menudo queda olvidado. El PRODUCTO es consecuencia del trabajo del EQUIPO: todas las características que tiene un PRODUCTO son porque el EQUIPO fue capaz de generarlas. Por otro lado, no puedo agregar algo a un PRODUCTO si en el EQUIPO no existe una característica que lo genere. <br />
<br />
Existe una correlación directa (aunque a veces no obvia) entre una característica del PRODUCTO y una característica del EQUIPO. Ahora, como el PRODUCTO es consecuencia del trabajo del EQUIPO, para introducir o modificar características en el PRODUCTO deberemos actuar sobre el EQUIPO, que es la única parte de la ecuación a la que tenemos acceso. <br />
<br />
De esta manera, (EQUIPO = PRODUCTO) nos permite analizar de forma pasiva una situación. También es una herramienta activa sumamente poderosa, ya que al modificar al EQUIPO vamos a modificar, inevitablemente, el PRODUCTO que se construye. <br />
<br />
== Los procesos y las personas ==<br />
Son las personas quienes, a través de sus relaciones, crean y sostienen a los procesos. Son las personas quienes usan y aplican las herramientas. Y en definitiva, son las personas quienes trabajan en equipo y crean productos. Por eso buscamos crear los Mejores Equipos que nos permitan desarrollar los Mejores Productos para nuestros clientes. <br />
<br />
Los valores que respaldamos y aplicamos en su totalidad nos permiten crear mejores relaciones humanas que, a su vez, generan los mejores equipos de propiedad intelectual posibles. Y allí reside el gran valor que tenemos para ofrecerle a nuestro cliente.<br />
<br />
== La conformación de equipos ==<br />
Teniendo en cuenta que deberemos trabajar sobre el Equipo, estamos hablando de relaciones de personas. <br />
<br />
[[Agil]] habla de un cambio en la forma de pensar y encarar el trabajo, basándonos fuertemente en principios y valores humanos. Aquí radica la dificultad de una implementación Ágil verdadera. <br />
<br />
Ágil NO es implementar Scrum, XP u otra metodología. Ágil es un cambio cultural que, luego, se acompaña con cambios en las prácticas y métodos de la organización. <br />
<br />
Implementar Scrum (o cuaqluier metodología) sin aceptar el desafío del cambio cultural es una invitación al desastre. Es en el cambio cultural donde radica el verdadero valor de negocio que se pretende generar y maximizar, y no en metodologías particulares. Ya lo sabemos: la bala de plata no existe. Sólo el trabajo serio y profesional. <br />
<br />
Es por todo esto que la conformación de equipos es un aspecto fundamental en el desarrollo de cualquier creación de propiedad intelectual (como ser el desarrollo de software). Son las personas que, a través de sus conversaciones, generan relaciones y obtienen resultados (como ser, un producto de software).</div>Leitohttps://dosideas.com/wiki/index.php?title=Dos_Ideas.:Derechos_de_autor&diff=3425Dos Ideas.:Derechos de autor2009-10-09T17:52:30Z<p>Leito: </p>
<hr />
<div>El contenido de la wiki de Dos Ideas se publica bajo la licencia [http://creativecommons.org/licenses/by-sa/2.5/ar/ Creative Commons BY-SA].<br />
<br />
En pocas palabras, son libres de usar, modificar y distribuir el contenido de esta wiki a gusto, siempre y cuando compartan el nuevo contenido bajo las mismas condiciones.</div>Leitohttps://dosideas.com/wiki/index.php?title=Dos_Ideas.:Derechos_de_autor&diff=3424Dos Ideas.:Derechos de autor2009-10-09T17:49:33Z<p>Leito: Página creada con 'El contenido de la wiki de Dos Ideas se publica bajo la licencia [http://creativecommons.org/licenses/by-sa/2.5/ar/ Creative Commons BY-SA].'</p>
<hr />
<div>El contenido de la wiki de Dos Ideas se publica bajo la licencia [http://creativecommons.org/licenses/by-sa/2.5/ar/ Creative Commons BY-SA].</div>Leitohttps://dosideas.com/wiki/index.php?title=CLOB_de_Oracle_en_Weblogic&diff=3423CLOB de Oracle en Weblogic2009-10-09T17:07:56Z<p>Leito: /* Ver también */</p>
<hr />
<div>Si tenemos una aplicación [[Java]] corriendo en [[WebLogic]] la forma de acceder a un [[CLOB de Oracle]] para escritura se maneja de una forma especial. en nuestro caso utilizamos [[JDBC]] y por consiguiente la clase '''weblogic.jdbc.vendor.oracle.OracleThinClob'''. Aqui dejamos un ejemplo:<br />
<br />
<code java5>import java.io.IOException;<br />
import java.io.Writer;<br />
import java.sql.Clob;<br />
import java.sql.ResultSet;<br />
import java.sql.SQLException;<br />
<br />
import org.springframework.dao.DataAccessResourceFailureException;<br />
import org.springframework.jdbc.core.RowMapper;<br />
import org.springframework.jdbc.core.support.JdbcDaoSupport;<br />
<br />
import weblogic.jdbc.vendor.oracle.OracleThinClob;<br />
<br />
import com.dosideas.dao.UnDao;<br />
<br />
public class UnDaoImpl extends JdbcDaoSupport implements UnDao {<br />
<br />
/**<br />
* Query que busca el Clob por id.<br />
* SELECT ARCHIVO FROM TABLA_CON_ARCHIVO WHERE ID = ? FOR UPDATE;<br />
*/<br />
private String query;<br />
<br />
/**<br />
* Obtiene el writer del Clob.<br />
*/<br />
public Writer obtenerWriter(Long id) {<br />
Clob clobReporte = (Clob) getJdbcTemplate()<br />
.queryForObject(getQuery(), <br />
new Object[] {idPeticion }, <br />
new RowMapper() {<br />
public Object mapRow(ResultSet resultSet, int rowNum) <br />
throws SQLException {<br />
return (Clob) resultSet.getClob(1);<br />
}<br />
});<br />
Writer writerDelClob = null;<br />
<br />
try {<br />
writerDelClob = ((OracleThinClob) clobReporte).getCharacterOutputStream();<br />
} catch (SQLException e) {<br />
// Tratar el error<br />
}<br />
<br />
return writerDelClob;<br />
}<br />
</code><br />
<br />
== Ver también ==<br />
* [[Oracle]]<br />
* [[JDBC]]<br />
* [[CLOB de Oracle]]<br />
* [http://www.oracle.com/technology/docs/tech/java/sqlj_jdbc/doc_library/javadoc/oracle.sql.CLOB.html Javadoc CLOB]<br />
*[http://download.oracle.com/docs/cd/E13222_01/wls/docs91/jdbc/thirdparty.html#1045809 Using Third-Party Drivers with WebLogic Server]<br />
<br />
[[Category:Oracle]]<br />
[[Category:WebLogic]]<br />
[[Category:Java]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Metodologias_De_Desarrollo&diff=3421Metodologias De Desarrollo2009-10-09T12:31:31Z<p>Leito: /* Metodologías */</p>
<hr />
<div>El desarrollo de software es un proceso que involucra a personas y tecnología para la creación de sistemas informáticos.<br />
<br />
Las empresas que se destacan en el negocio del software son aquellas que poseen un proceso de creación e innovación de productos ágil y eficaz. El proceso de desarrollo de productos es el mas crítico para la continuidad del éxito, prosperidad y continuidad de las organizaciones.<br />
<br />
==Metodologías==<br />
Actualmente se puede realizar una distinción entre dos grandes grupos de metodologías para el desarrollo de software:<br />
* [[Agil]] <br />
* [[Conformación de equipos]]<br />
<br />
==Libros==<br />
* [[Libros]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Metodologias_De_Desarrollo&diff=3420Metodologias De Desarrollo2009-10-09T12:31:16Z<p>Leito: /* Metodologías */</p>
<hr />
<div>El desarrollo de software es un proceso que involucra a personas y tecnología para la creación de sistemas informáticos.<br />
<br />
Las empresas que se destacan en el negocio del software son aquellas que poseen un proceso de creación e innovación de productos ágil y eficaz. El proceso de desarrollo de productos es el mas crítico para la continuidad del éxito, prosperidad y continuidad de las organizaciones.<br />
<br />
==Metodologías==<br />
Actualmente se puede realizar una distinción entre dos grandes grupos de metodologías para el desarrollo de software:<br />
* [[Agil]] - Desarrollo ágil de software<br />
* [[Conformación de equipos]] - Técnicas para la conformación de equipos<br />
<br />
==Libros==<br />
* [[Libros]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Ayuda:Estilo_De_Notas&diff=3419Ayuda:Estilo De Notas2009-10-09T12:30:22Z<p>Leito: /* Cantidad de información */</p>
<hr />
<div>Para tener una wiki ordenada y prolija, veremos a continuación una serie de convenciones y consejos a la hora de escribir una página wiki en Dos Ideas.<br />
<br />
==Idioma==<br />
Preferimos el uso de '''castellano''' en la medida de lo posible. Evitamos el uso de inglés u otros idiomas cuando existen términos y expresiones en castellano de uso habitual.<br />
<br />
Usamos la terminología en inglés (u otro idioma) cuando no exista una traducción exacta, o la expresión sea más comunmente usada en su idioma original.<br />
<br />
==Estilo de escritura==<br />
En la medida de lo posible usamos un estilo impersonal e informal.<br />
Configuro el archivo x.properties para... //NO ESCRIBIR ASI<br />
Se configura el archivo x.properties... //PREFERIBLE<br />
<br />
==Nombres de las páginas==<br />
El nombre de cada página wiki tiene que tener sentido y servir para ubicar el contenido. Ejemplos:<br />
Ejemplo de uso //NO! No está en claro sobre QUE tema se verá el ejemplo<br />
EjemploDeUsoDeFoo //NO! No "pegar" todas las palabras, usar espacios<br />
Ejemplo De Uso De Foo //NO! Solo usar mayúsculas cuando es necesario<br />
Ejemplo de uso de Foo //OK. Viendo el titulo se sabe qué se encontrará en la página<br />
Anotaciones //Uso general de anotaciones, sin referencia a ninguna tecnología en particular<br />
Anotaciones con Foo //Queda claro que se verán anotaciones para la tecnología Foo<br />
<br />
Sólo usar mayúsculas para la primer letra de la página, o cuando se hace referencia a un nombre.<br />
Ejemplo de uso //OK<br />
Ejemplo De Uso //NO! no usar mayúsculas innecesariamente<br />
<br />
'''Nota sobre las mayúsculas''': varias páginas de la wiki comenzaron siguiendo una convención distinta sobre las mayúsculas. Por favor, para páginas nuevas seguir esta nueva convención.<br />
<br />
En el caso de siglas, usar mayúsculas para todas las letras de la sigla. Por ejemplo:<br />
Mensajeria con MDB<br />
Pruebas ee EJB<br />
Desarrollo con TDD<br />
<br />
Evitar las páginas con nombres de una sola palabra, a menos que se trate de nombres de tecnologías.<br />
<br />
==Cantidad de información==<br />
Cada página tiene que ser "autocontenida". Es decir, tiene que aportar algo por sí misma.<br />
<br />
== Fin de la nota==<br />
Terminamos la nota con dos grupos de links: hacia otros temas de la misma wiki, y hacia recursos externos, en este orden.<br />
Todos estos temas se ubican bajo el título de nivel 2 "Ver también". Por ejemplo: <br />
<br />
<pre><br />
<nowiki><br />
==Ver también==<br />
* [[Una página wiki relacionada]]<br />
* [[Otra página wiki relacionada]]<br />
* [http://www.foo.org Web oficial de Foo]<br />
* [http://www.foo.org/tutorial Tutorial de Foo]<br />
</nowiki><br />
</pre><br />
<br />
== Categorías ==<br />
Ubicar la página en una o más categorías, para facilitar su búsqueda. En el caso de categorías con sub-categorías, ubicar el artículo en la subcategoría más específica (evitando agregar a la categoría padre). <br />
<br />
Escribir los tags de Categoría al final de la página wiki.<br />
<br />
Por ejemplo, un artículo que habla sobre el uso de Web Services con Spring Framework: <br />
<pre><br />
<nowiki><br />
[[Categoría:Spring Framework]]<br />
[[Categoría:Web Service]]<br />
</nowiki><br />
</pre></div>Leitohttps://dosideas.com/wiki/index.php?title=Ayuda:Estilo_De_Notas&diff=3418Ayuda:Estilo De Notas2009-10-09T12:29:54Z<p>Leito: /* Categorías */</p>
<hr />
<div>Para tener una wiki ordenada y prolija, veremos a continuación una serie de convenciones y consejos a la hora de escribir una página wiki en Dos Ideas.<br />
<br />
==Idioma==<br />
Preferimos el uso de '''castellano''' en la medida de lo posible. Evitamos el uso de inglés u otros idiomas cuando existen términos y expresiones en castellano de uso habitual.<br />
<br />
Usamos la terminología en inglés (u otro idioma) cuando no exista una traducción exacta, o la expresión sea más comunmente usada en su idioma original.<br />
<br />
==Estilo de escritura==<br />
En la medida de lo posible usamos un estilo impersonal e informal.<br />
Configuro el archivo x.properties para... //NO ESCRIBIR ASI<br />
Se configura el archivo x.properties... //PREFERIBLE<br />
<br />
==Nombres de las páginas==<br />
El nombre de cada página wiki tiene que tener sentido y servir para ubicar el contenido. Ejemplos:<br />
Ejemplo de uso //NO! No está en claro sobre QUE tema se verá el ejemplo<br />
EjemploDeUsoDeFoo //NO! No "pegar" todas las palabras, usar espacios<br />
Ejemplo De Uso De Foo //NO! Solo usar mayúsculas cuando es necesario<br />
Ejemplo de uso de Foo //OK. Viendo el titulo se sabe qué se encontrará en la página<br />
Anotaciones //Uso general de anotaciones, sin referencia a ninguna tecnología en particular<br />
Anotaciones con Foo //Queda claro que se verán anotaciones para la tecnología Foo<br />
<br />
Sólo usar mayúsculas para la primer letra de la página, o cuando se hace referencia a un nombre.<br />
Ejemplo de uso //OK<br />
Ejemplo De Uso //NO! no usar mayúsculas innecesariamente<br />
<br />
'''Nota sobre las mayúsculas''': varias páginas de la wiki comenzaron siguiendo una convención distinta sobre las mayúsculas. Por favor, para páginas nuevas seguir esta nueva convención.<br />
<br />
En el caso de siglas, usar mayúsculas para todas las letras de la sigla. Por ejemplo:<br />
Mensajeria con MDB<br />
Pruebas ee EJB<br />
Desarrollo con TDD<br />
<br />
Evitar las páginas con nombres de una sola palabra, a menos que se trate de nombres de tecnologías.<br />
<br />
==Cantidad de información==<br />
Cada página tiene que ser "autocontenida". Es decir, tiene que aportar algo por sí misma.<br />
<br />
<br />
== Fin de la nota==<br />
Terminamos la nota con dos grupos de links: hacia otros temas de la misma wiki, y hacia recursos externos, en este orden.<br />
Todos estos temas se ubican bajo el título de nivel 2 "Ver también". Por ejemplo: <br />
<br />
<pre><br />
<nowiki><br />
==Ver también==<br />
* [[Una página wiki relacionada]]<br />
* [[Otra página wiki relacionada]]<br />
* [http://www.foo.org Web oficial de Foo]<br />
* [http://www.foo.org/tutorial Tutorial de Foo]<br />
</nowiki><br />
</pre><br />
<br />
== Categorías ==<br />
Ubicar la página en una o más categorías, para facilitar su búsqueda. En el caso de categorías con sub-categorías, ubicar el artículo en la subcategoría más específica (evitando agregar a la categoría padre). <br />
<br />
Escribir los tags de Categoría al final de la página wiki.<br />
<br />
Por ejemplo, un artículo que habla sobre el uso de Web Services con Spring Framework: <br />
<pre><br />
<nowiki><br />
[[Categoría:Spring Framework]]<br />
[[Categoría:Web Service]]<br />
</nowiki><br />
</pre></div>Leitohttps://dosideas.com/wiki/index.php?title=Ayuda:Estilo_De_Notas&diff=3417Ayuda:Estilo De Notas2009-10-09T12:29:41Z<p>Leito: /* Fin de la nota */</p>
<hr />
<div>Para tener una wiki ordenada y prolija, veremos a continuación una serie de convenciones y consejos a la hora de escribir una página wiki en Dos Ideas.<br />
<br />
==Idioma==<br />
Preferimos el uso de '''castellano''' en la medida de lo posible. Evitamos el uso de inglés u otros idiomas cuando existen términos y expresiones en castellano de uso habitual.<br />
<br />
Usamos la terminología en inglés (u otro idioma) cuando no exista una traducción exacta, o la expresión sea más comunmente usada en su idioma original.<br />
<br />
==Estilo de escritura==<br />
En la medida de lo posible usamos un estilo impersonal e informal.<br />
Configuro el archivo x.properties para... //NO ESCRIBIR ASI<br />
Se configura el archivo x.properties... //PREFERIBLE<br />
<br />
==Nombres de las páginas==<br />
El nombre de cada página wiki tiene que tener sentido y servir para ubicar el contenido. Ejemplos:<br />
Ejemplo de uso //NO! No está en claro sobre QUE tema se verá el ejemplo<br />
EjemploDeUsoDeFoo //NO! No "pegar" todas las palabras, usar espacios<br />
Ejemplo De Uso De Foo //NO! Solo usar mayúsculas cuando es necesario<br />
Ejemplo de uso de Foo //OK. Viendo el titulo se sabe qué se encontrará en la página<br />
Anotaciones //Uso general de anotaciones, sin referencia a ninguna tecnología en particular<br />
Anotaciones con Foo //Queda claro que se verán anotaciones para la tecnología Foo<br />
<br />
Sólo usar mayúsculas para la primer letra de la página, o cuando se hace referencia a un nombre.<br />
Ejemplo de uso //OK<br />
Ejemplo De Uso //NO! no usar mayúsculas innecesariamente<br />
<br />
'''Nota sobre las mayúsculas''': varias páginas de la wiki comenzaron siguiendo una convención distinta sobre las mayúsculas. Por favor, para páginas nuevas seguir esta nueva convención.<br />
<br />
En el caso de siglas, usar mayúsculas para todas las letras de la sigla. Por ejemplo:<br />
Mensajeria con MDB<br />
Pruebas ee EJB<br />
Desarrollo con TDD<br />
<br />
Evitar las páginas con nombres de una sola palabra, a menos que se trate de nombres de tecnologías.<br />
<br />
==Cantidad de información==<br />
Cada página tiene que ser "autocontenida". Es decir, tiene que aportar algo por sí misma.<br />
<br />
<br />
== Fin de la nota==<br />
Terminamos la nota con dos grupos de links: hacia otros temas de la misma wiki, y hacia recursos externos, en este orden.<br />
Todos estos temas se ubican bajo el título de nivel 2 "Ver también". Por ejemplo: <br />
<br />
<pre><br />
<nowiki><br />
==Ver también==<br />
* [[Una página wiki relacionada]]<br />
* [[Otra página wiki relacionada]]<br />
* [http://www.foo.org Web oficial de Foo]<br />
* [http://www.foo.org/tutorial Tutorial de Foo]<br />
</nowiki><br />
</pre><br />
<br />
== Categorías ==<br />
Ubicar la página en una o más categorías, para facilitar su búsqueda. En el caso de categorías con sub-categorías, ubicar el artículo en la subcategoría más específica (evitando agregar a la categoría padre). Escribir los tags de Categoría al final de la página wiki.<br />
<br />
Por ejemplo, un artículo que habla sobre el uso de Web Services con Spring Framework: <br />
<pre><br />
<nowiki><br />
[[Categoría:Spring Framework]]<br />
[[Categoría:Web Service]]<br />
</nowiki><br />
</pre></div>Leitohttps://dosideas.com/wiki/index.php?title=Ayuda:Estilo_De_Notas&diff=3416Ayuda:Estilo De Notas2009-10-09T12:29:16Z<p>Leito: /* Nombres de las páginas */</p>
<hr />
<div>Para tener una wiki ordenada y prolija, veremos a continuación una serie de convenciones y consejos a la hora de escribir una página wiki en Dos Ideas.<br />
<br />
==Idioma==<br />
Preferimos el uso de '''castellano''' en la medida de lo posible. Evitamos el uso de inglés u otros idiomas cuando existen términos y expresiones en castellano de uso habitual.<br />
<br />
Usamos la terminología en inglés (u otro idioma) cuando no exista una traducción exacta, o la expresión sea más comunmente usada en su idioma original.<br />
<br />
==Estilo de escritura==<br />
En la medida de lo posible usamos un estilo impersonal e informal.<br />
Configuro el archivo x.properties para... //NO ESCRIBIR ASI<br />
Se configura el archivo x.properties... //PREFERIBLE<br />
<br />
==Nombres de las páginas==<br />
El nombre de cada página wiki tiene que tener sentido y servir para ubicar el contenido. Ejemplos:<br />
Ejemplo de uso //NO! No está en claro sobre QUE tema se verá el ejemplo<br />
EjemploDeUsoDeFoo //NO! No "pegar" todas las palabras, usar espacios<br />
Ejemplo De Uso De Foo //NO! Solo usar mayúsculas cuando es necesario<br />
Ejemplo de uso de Foo //OK. Viendo el titulo se sabe qué se encontrará en la página<br />
Anotaciones //Uso general de anotaciones, sin referencia a ninguna tecnología en particular<br />
Anotaciones con Foo //Queda claro que se verán anotaciones para la tecnología Foo<br />
<br />
Sólo usar mayúsculas para la primer letra de la página, o cuando se hace referencia a un nombre.<br />
Ejemplo de uso //OK<br />
Ejemplo De Uso //NO! no usar mayúsculas innecesariamente<br />
<br />
'''Nota sobre las mayúsculas''': varias páginas de la wiki comenzaron siguiendo una convención distinta sobre las mayúsculas. Por favor, para páginas nuevas seguir esta nueva convención.<br />
<br />
En el caso de siglas, usar mayúsculas para todas las letras de la sigla. Por ejemplo:<br />
Mensajeria con MDB<br />
Pruebas ee EJB<br />
Desarrollo con TDD<br />
<br />
Evitar las páginas con nombres de una sola palabra, a menos que se trate de nombres de tecnologías.<br />
<br />
==Cantidad de información==<br />
Cada página tiene que ser "autocontenida". Es decir, tiene que aportar algo por sí misma.<br />
<br />
<br />
== Fin de la nota==<br />
Terminamos la nota con dos grupos de links: hacia otros temas de la misma wiki, y hacia recursos externos, en este orden.<br />
Todos estos temas se ubican bajo el título de nivel 2 "Ver también". Por ejemplo: <br />
<br />
<pre><br />
<nowiki><br />
==Ver también==<br />
* [[Una Pagina Wiki Relacionada]]<br />
* [[Otra Pagina Wiki Relacionada]]<br />
* [http://www.foo.org Web oficial de Foo]<br />
* [http://www.foo.org/tutorial Tutorial de Foo]<br />
</nowiki><br />
</pre><br />
<br />
== Categorías ==<br />
Ubicar la página en una o más categorías, para facilitar su búsqueda. En el caso de categorías con sub-categorías, ubicar el artículo en la subcategoría más específica (evitando agregar a la categoría padre). Escribir los tags de Categoría al final de la página wiki.<br />
<br />
Por ejemplo, un artículo que habla sobre el uso de Web Services con Spring Framework: <br />
<pre><br />
<nowiki><br />
[[Categoría:Spring Framework]]<br />
[[Categoría:Web Service]]<br />
</nowiki><br />
</pre></div>Leitohttps://dosideas.com/wiki/index.php?title=Metodologias_De_Desarrollo&diff=3415Metodologias De Desarrollo2009-10-09T12:26:25Z<p>Leito: /* Metodologías */</p>
<hr />
<div>El desarrollo de software es un proceso que involucra a personas y tecnología para la creación de sistemas informáticos.<br />
<br />
Las empresas que se destacan en el negocio del software son aquellas que poseen un proceso de creación e innovación de productos ágil y eficaz. El proceso de desarrollo de productos es el mas crítico para la continuidad del éxito, prosperidad y continuidad de las organizaciones.<br />
<br />
==Metodologías==<br />
Actualmente se puede realizar una distinción entre dos grandes grupos de metodologías para el desarrollo de software:<br />
* [[Desarrollo Agil De Software]]<br />
* [[Conformación de equipos]]<br />
<br />
==Libros==<br />
* [[Libros]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Conformaci%C3%B3n_de_equipos&diff=3413Conformación de equipos2009-10-09T12:26:07Z<p>Leito: Conformación De Equipos trasladada a Conformación de equipos</p>
<hr />
<div>(EQUIPO = PRODUCTO) es uno de los conceptos más importantes del desarrollo de software, y a menudo queda olvidado. El PRODUCTO es consecuencia del trabajo del EQUIPO: todas las características que tiene un PRODUCTO son porque el EQUIPO fue capaz de generarlas. Por otro lado, no puedo agregar algo a un PRODUCTO si en el EQUIPO no existe una característica que lo genere. <br />
<br />
Existe una correlación directa (aunque a veces no obvia) entre una característica del PRODUCTO y una característica del EQUIPO. Ahora, como el PRODUCTO es consecuencia del trabajo del EQUIPO, para introducir o modificar características en el PRODUCTO deberemos actuar sobre el EQUIPO, que es la única parte de la ecuación a la que tenemos acceso. <br />
<br />
De esta manera, (EQUIPO = PRODUCTO) nos permite analizar de forma pasiva una situación. También es una herramienta activa sumamente poderosa, ya que al modificar al EQUIPO vamos a modificar, inevitablemente, el PRODUCTO que se construye. <br />
<br />
== Los procesos y las personas ==<br />
Son las personas quienes, a través de sus relaciones, crean y sostienen a los procesos. Son las personas quienes usan y aplican las herramientas. Y en definitiva, son las personas quienes trabajan en equipo y crean productos. Por eso buscamos crear los Mejores Equipos que nos permitan desarrollar los Mejores Productos para nuestros clientes. <br />
<br />
Los valores que respaldamos y aplicamos en su totalidad nos permiten crear mejores relaciones humanas que, a su vez, generan los mejores equipos de propiedad intelectual posibles. Y allí reside el gran valor que tenemos para ofrecerle a nuestro cliente.<br />
<br />
== La conformación de equipos ==<br />
Teniendo en cuenta que deberemos trabajar sobre el Equipo, estamos hablando de relaciones de personas. <br />
<br />
[[Agil]] habla de un cambio en la forma de pensar y encarar el trabajo, basándonos fuertemente en principios y valores humanos. Aquí radica la dificultad de una implementación Ágil verdadera. <br />
<br />
Ágil NO es implementar Scrum, XP u otra metodología. Ágil es un cambio cultural que, luego, se acompaña con cambios en las prácticas y métodos de la organización. <br />
<br />
Implementar Scrum (o cuaqluier metodología) sin aceptar el desafío del cambio cultural es una invitación al desastre. Es en el cambio cultural donde radica el verdadero valor de negocio que se pretende generar y maximizar, y no en metodologías particulares. Ya lo sabemos: la bala de plata no existe. Sólo el trabajo serio y profesional. <br />
<br />
Es por todo esto que la conformación de equipos es un aspecto fundamental en el desarrollo de cualquier creación de propiedad intelectual (como ser el desarrollo de software). Son las personas que, a través de sus conversaciones, generan relaciones y obtienen resultados (como ser, un producto de software).</div>Leitohttps://dosideas.com/wiki/index.php?title=Conformaci%C3%B3n_De_Equipos&diff=3414Conformación De Equipos2009-10-09T12:26:07Z<p>Leito: Conformación De Equipos trasladada a Conformación de equipos</p>
<hr />
<div>#REDIRECCIÓN [[Conformación de equipos]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2828Colas De Mensajes Con AquaLogic2009-07-20T17:48:12Z<p>Leito: </p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==La definición del servicio==<br />
===Wsdl===<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<definitions name="facturaWsdl" targetNamespace="http://j2ee.netbeans.org/wsdl/facturaWsdl"<br />
xmlns="http://schemas.xmlsoap.org/wsdl/"<br />
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"<br />
xmlns:xsd="http://www.w3.org/2001/XMLSchema" <br />
xmlns:tns="http://j2ee.netbeans.org/wsdl/facturaWsdl" <br />
xmlns:ns="http://xml.netbeans.org/schema/facturaXmlSchema" <br />
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"><br />
<br />
<types><br />
<xsd:schema targetNamespace="http://j2ee.netbeans.org/wsdl/facturaWsdl"><br />
<xsd:import namespace="http://xml.netbeans.org/schema/facturaXmlSchema" <br />
schemaLocation="../schema/facturaXmlSchema.xsd"/><br />
</xsd:schema><br />
</types><br />
<message name="enviarFacturaRequest"><br />
<part name="part1" element="ns:factura"/><br />
</message><br />
<message name="enviarFacturaResponse"/><br />
<portType name="facturaWsdlPortType"><br />
<operation name="enviarFactura"><br />
<input name="input1" message="tns:enviarFacturaRequest"/><br />
<output name="output1" message="tns:enviarFacturaResponse"/><br />
</operation><br />
</portType><br />
<binding name="facturaWsdlBinding" type="tns:facturaWsdlPortType"><br />
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/><br />
<operation name="enviarFactura"><br />
<soap:operation/><br />
<input name="input1"><br />
<soap:body use="literal"/><br />
</input><br />
<output name="output1"><br />
<soap:body use="literal"/><br />
</output><br />
</operation><br />
</binding><br />
<service name="facturaWsdlService"><br />
<port name="facturaWsdlPort" binding="tns:facturaWsdlBinding"><br />
<soap:address <br />
location="http://localhost:${HttpDefaultPort}/facturaWsdlService/facturaWsdlPort"/><br />
</port><br />
</service><br />
</definitions><br />
</code><br />
<br />
===El Esquema XML (XSD)===<br />
<code xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<br />
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"<br />
targetNamespace="http://xml.netbeans.org/schema/facturaXmlSchema"<br />
xmlns:tns="http://xml.netbeans.org/schema/facturaXmlSchema"<br />
elementFormDefault="qualified"><br />
<br />
<xsd:element name="factura"><br />
<xsd:complexType><br />
<xsd:sequence><br />
<xsd:element name="numeroFactura" type="xsd:string"/><br />
<xsd:element name="fecha" type="xsd:string"/><br />
<xsd:element name="items" type="tns:listaItemsFactura"/><br />
</xsd:sequence><br />
</xsd:complexType><br />
</xsd:element><br />
<br />
<xsd:complexType name="itemFactura"><br />
<xsd:all><br />
<xsd:element name="codigoArticulo" type="xsd:string"/><br />
<xsd:element name="descripcion" minOccurs="0" type="xsd:string"/><br />
<xsd:element name="cantidad" type="xsd:int"/><br />
<xsd:element name="precio" type="xsd:double"/><br />
</xsd:all><br />
</xsd:complexType><br />
<br />
<xsd:complexType name="listaItemsFactura"><br />
<xsd:sequence><br />
<xsd:element name="item" maxOccurs="unbounded" type="tns:itemFactura"/><br />
</xsd:sequence><br />
</xsd:complexType><br />
<br />
</xsd:schema><br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg | 750px ]]<br />
<br />
Para ser ordenados, dentro del proyecto demoFactura creamos una carpeta “envío de facturas”, donde crearemos todos los recursos de esta demo.<br />
<br />
[[Image:Aqualogic_demoFactura_2.jpg | 750px ]]<br />
<br />
== Agregamos el Esquema XML (XSD) == <br />
<br />
Para subir el esquema XML al AquaLogic, dentro de nuestra carpeta elegimos la opción XML Schema en el combo “Create Resource:”<br />
<br />
[[Image:Aqualogic_demoFactura_3.jpg ]]<br />
<br />
Le ponemos un nombre al recurso que estamos creando y cargamos el archivo de definición de una factura.<br />
<br />
[[Image:Aqualogic_demoFactura_4.jpg | 750px ]]<br />
<br />
Después de hacer click en Save vemos que tenemos el archivo xsd cargado correctamente:<br />
<br />
[[Image:Aqualogic_demoFactura_5.jpg | 750px ]]<br />
<br />
== Agregamos el WSDL ==<br />
Para cargar el wsdl seguimos los mismos pasos que en el apartado anterior, eligiendo en el combo “Create Resource:” la opción WSDL.<br />
<br />
Después de dar un nombre al recurso, cargar el archivo .wsdl y guardar los cambios tendremos:<br />
<br />
[[Image:Aqualogic_demoFactura_6.jpg | 750px ]]<br />
<br />
== Creamos un Business Service ==<br />
El business service será el responsable de enviar el mensaje a la queue. Si elegimos la opción “Business Service” del combo “Create Resource” ingresamos al wizard para configurar este servicio.<br />
En el primer paso damos un nombre al servicio e indicamos que es de tipo “Messaging Service”.<br />
<br />
[[Image:Aqualogic_demoFactura_7.jpg | 750px ]]<br />
<br />
Seteamos request y response como texto: <br />
<br />
[[Image:Aqualogic_demoFactura_8.jpg | 750px ]]<br />
<br />
Marcamos que se utilizará el protocolo jms y agregamos con el botón Add los destinos del mensaje. El formato de las uri es jms://<host>:<puerto>/<jndi-connection-factory>/<jndi-queue> (Si nuestros jndi contienen “/”, las escapeamos con “.”)<br />
<br />
[[Image:Aqualogic_demoFactura_9.jpg | 750px ]]<br />
<br />
Indicamos que el destinatario es una queue y que se enviará un text message.<br />
<br />
[[Image:Aqualogic_demoFactura_10.jpg | 750px ]]<br />
<br />
En el último paso del wizard verificamos toda la información ingresada y guardamos los cambios. Entonces ya podemos probar el bussinessService mediante el ícono de “Launch Test Console”:<br />
<br />
[[Image:Aqualogic_demoFactura_11.jpg | 750px ]]<br />
<br />
Escribimos el texto que viajará en el mensaje y presionamos el botón Execute:<br />
<br />
[[Image:Aqualogic_demoFactura_12.jpg | 750px ]]<br />
<br />
El servicio termina correctamente y podemos ver que nuestra queue ha recibido un mensaje con el texto ingresado.<br />
<br />
== Creamos un Proxy Service ==<br />
El Proxy service nos permitirá exponer el servicio para ser invocado vía http. Ingresamos al wizard de configuración eligiendo la opción “Proxy Service” en el combo “Create Resource”.<br />
Ponemos un nombre al servicio e indicamos que lo vamos a crear a partir de nuestro wsdl, el cual elegimos mediante el botón Browse:<br />
<br />
[[Image:Aqualogic_demoFactura_13.jpg | 750px ]]<br />
<br />
Marcamos que podrá ser consumido mediante el protocolo http y definimos la url de invocación:<br />
<br />
[[Image:Aqualogic_demoFactura_14.jpg | 750px ]]<br />
<br />
Dejamos todas las opciones por defecto hasta que termina el wizard y activamos los cambios.<br />
<br />
Ahora hay que asociar el Proxy a nuestro business service. Para eso editamos el flujo del mensaje:<br />
<br />
[[Image:Aqualogic_demoFactura_15.jpg | 750px ]]<br />
<br />
Y definimos un ruteo:<br />
<br />
[[Image:Aqualogic_demoFactura_16.jpg | 750px ]]<br />
[[Image:Aqualogic_demoFactura_17.jpg | 750px ]]<br />
[[Image:Aqualogic_demoFactura_18.jpg | 750px ]]<br />
<br />
Click en el link <service> para buscar nuestro business service y que nos quede así:<br />
<br />
[[Image:Aqualogic_demoFactura_19.jpg | 750px ]]<br />
<br />
Guardamos los cambios y probamos nuestro Proxy con el ícono de “Launch Test Console”, como hicimos antes con el business service.<br />
<br />
[[Image:Aqualogic_demoFactura_20.jpg | 750px ]]<br />
<br />
Ejecutado ese request podemos ver que el mensaje completo llegó a la queue correctamente.<br />
<br />
== Agregamos el JMSType al mensaje ==<br />
<br />
Vamos a editar el routeo entre el proxy y el business service para agregar el JMSType del mensaje que se encola:<br />
<br />
[[Image:Aqualogic_demoFactura_21.jpg | 750px ]]<br />
<br />
Presionamos Add header y seleccionamos en el combo la opción JMSType:<br />
<br />
[[Image:Aqualogic_demoFactura_22.jpg | 750px ]]<br />
<br />
Editamos el link <Expression> con el jmsType deseado, en este caso ‘facturaType’. Activamos los cambios y si probamos de nuevo el Proxy vemos que el mensaje se encola con el type indicado.<br />
<br />
[[Image:Aqualogic_demoFactura_23.jpg | 750px ]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2825Colas De Mensajes Con AquaLogic2009-07-20T17:22:05Z<p>Leito: /* Creación del proyecto */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg | 750px ]]<br />
<br />
Para ser ordenados, dentro del proyecto demoFactura creamos una carpeta “envío de facturas”, donde crearemos todos los recursos de esta demo.<br />
<br />
[[Image:Aqualogic_demoFactura_2.jpg | 750px ]]<br />
<br />
=== Agregamos el Esquema XML (XSD) === <br />
<br />
Para subir el esquema XML al AquaLogic, dentro de nuestra carpeta elegimos la opción XML Schema en el combo “Create Resource:”<br />
<br />
[[Image:Aqualogic_demoFactura_3.jpg ]]<br />
<br />
Le ponemos un nombre al recurso que estamos creando y cargamos el archivo de definición de una factura.<br />
<br />
[[Image:Aqualogic_demoFactura_4.jpg | 750px ]]<br />
<br />
Después de hacer click en Save vemos que tenemos el archivo xsd cargado correctamente:<br />
<br />
[[Image:Aqualogic_demoFactura_5.jpg | 750px ]]<br />
<br />
=== Agregamos el WSDL ===<br />
Para cargar el wsdl seguimos los mismos pasos que en el apartado anterior, eligiendo en el combo “Create Resource:” la opción WSDL.<br />
<br />
Después de dar un nombre al recurso, cargar el archivo .wsdl y guardar los cambios tendremos:<br />
[[Image:Aqualogic_demoFactura_6.jpg | 750px ]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2824Colas De Mensajes Con AquaLogic2009-07-20T17:19:16Z<p>Leito: /* Creación del proyecto */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg | 750px ]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2823Colas De Mensajes Con AquaLogic2009-07-20T17:18:51Z<p>Leito: /* Creación del proyecto */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg | 500px ]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2822Colas De Mensajes Con AquaLogic2009-07-20T16:03:16Z<p>Leito: /* Creación del proyecto */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg ]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2821Colas De Mensajes Con AquaLogic2009-07-20T16:03:07Z<p>Leito: /* Creación del proyecto */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg | width=500px]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2820Colas De Mensajes Con AquaLogic2009-07-20T16:02:11Z<p>Leito: /* Creación del proyecto */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_1.jpg]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2819Colas De Mensajes Con AquaLogic2009-07-20T16:01:31Z<p>Leito: </p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Web Service]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_23.jpg]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2818Colas De Mensajes Con AquaLogic2009-07-20T15:58:45Z<p>Leito: /* El WSDL */</p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Servicio Web]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_23.jpg]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2817Colas De Mensajes Con AquaLogic2009-07-20T15:58:30Z<p>Leito: </p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Servicio Web]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
==El WSDL==<br />
<code xml><br />
poner aca el codigo...<br />
</code xml><br />
<br />
==El Esquema XML (XSD)==<br />
<code xml><br />
poner aca el codigo...<br />
</code xml><br />
<br />
==Creación del proyecto==<br />
Recordemos que para crear objetos y/o modificarlos en [[AquaLogic]] se debe crear una sesión y luego activar la misma para que los cambios tengan efecto.<br />
<br />
Desde la consola de aqualogic, en el Project Explorer creamos un proyecto llamado <br />
"demoFactura":<br />
<br />
[[Image:Aqualogic_demoFactura_23.jpg]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Colas_De_Mensajes_Con_AquaLogic&diff=2816Colas De Mensajes Con AquaLogic2009-07-20T15:56:44Z<p>Leito: </p>
<hr />
<div>Vamos a exponer con [[AquaLogic]] un [[Servicio Web]] que nos permita enviar un mensaje a una cola de mensajería. Partimos de un [[WSDL]] en donde definimos una operación “enviarFactura” que recibe como parámetro un elemento de tipo factura. Los elementos y tipos de dato de una factura se encuentran definidos en el esquema xml asociado al [[WSDL]].<br />
<br />
[[Image:Aqualogic_demoFactura_23.jpg]]</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_23.jpg&diff=2815Archivo:Aqualogic demoFactura 23.jpg2009-07-20T15:52:56Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_22.jpg&diff=2814Archivo:Aqualogic demoFactura 22.jpg2009-07-20T15:52:47Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_21.jpg&diff=2813Archivo:Aqualogic demoFactura 21.jpg2009-07-20T15:52:12Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_20.jpg&diff=2812Archivo:Aqualogic demoFactura 20.jpg2009-07-20T15:52:02Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_19.jpg&diff=2811Archivo:Aqualogic demoFactura 19.jpg2009-07-20T15:51:51Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_18.jpg&diff=2810Archivo:Aqualogic demoFactura 18.jpg2009-07-20T15:51:42Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_17.jpg&diff=2809Archivo:Aqualogic demoFactura 17.jpg2009-07-20T15:51:09Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_16.jpg&diff=2808Archivo:Aqualogic demoFactura 16.jpg2009-07-20T15:50:59Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_15.jpg&diff=2807Archivo:Aqualogic demoFactura 15.jpg2009-07-20T15:50:50Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_14.jpg&diff=2806Archivo:Aqualogic demoFactura 14.jpg2009-07-20T15:50:39Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_13.jpg&diff=2805Archivo:Aqualogic demoFactura 13.jpg2009-07-20T15:50:30Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_12.jpg&diff=2804Archivo:Aqualogic demoFactura 12.jpg2009-07-20T15:50:20Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_11.jpg&diff=2803Archivo:Aqualogic demoFactura 11.jpg2009-07-20T15:50:11Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leitohttps://dosideas.com/wiki/index.php?title=Archivo:Aqualogic_demoFactura_10.jpg&diff=2802Archivo:Aqualogic demoFactura 10.jpg2009-07-20T15:49:57Z<p>Leito: Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</p>
<hr />
<div>Imagen para la pagina "Colas De Mensajeria Con AquaLogic"</div>Leito