Enlaces interesantes #10

enlaces-interesEn mi página de facebook, en mi perfil de twitter y/o en mi perfil de LinkedIn suelo publicar enlaces relacionados con la temática del blog que por algún motivo me han parecido interesantes. Para que no queden desperdigados y “perdidos en el olvido” los recopilaré en entradas del blog periódicamente.


  • 15/08/2013: Why REST is so important
    REST explicado con el ejemplo de una granja. Según el autor, REST es uno de los conceptos menos comprendidos de la historia de las tecnologías de la información. Muy bueno para aclarar conceptos.


  • 27/08/2013: Is Java Riskier than C?
    ¿Tiene más riesgos el desarrollo Java que el desarrollo en C/C++? En un principio parece lógico pensar que Java es más seguro que C, pero merece darle una pensada.


  • 28/08/2013: Bad code happens, so be prepared
    Los errores son algo que forma parte del desarrollo de software en sí mismo. Cuando los desarrolladores partan de la base de que su código tiene fallos, serán capaces de diseñar software de mayor calidad.


  • 28/08/2013: Disponible el video del seminario Git vs. Subversion: ¿cuándo utilizar uno u otro?
    ¿Git o Subversion? Cada uno con sus ventajas e inconvenientes, ¿cuándo usar uno u otro? Ni siempre uno ni siempre el otro, depende del caso.


  • 28/08/2013: Java y JSON sencillo
    Cecilio Álvarez nos muestra en su blog un sencillo ejemplo sobre cómo trabajar con Java y JSON.


  • 31/08/2013: CannotMeasureProductivity
    ¿Imposible medir la productividad en desarrollo de software? Martin Fowler filosofea sobre el tema en este post.


  • 01/09/2013: A New Beginning
    Jeff Friesen responde a nuestras preguntas sobre Java en su blog.


  • 03/09/2013: Gestión del valor ganado paso a paso
    En este post sobre gestión de proyectos se nos habla del método EVM – Gestión del valor ganado. Es un método para medir el desempeño de un proyecto, permite comparar la cantidad de trabajo planificado con la cantidad de trabajo real que se ha realizado. Así se puede determinar si el trabajo va según lo previsto y dentro del presupuesto del proyecto.


  • 04/09/2013: KitKat será la nueva versión de Android (4.4)
    Aunque los rumores indicaban que el nombre de la nueva versión de Android sería Key Lime Pie, Sundar Pichai nos ha sorprendido a todos en Google+ mostrando la foto de la estatua en GooglePlex. A pesar de que han mantenido la correlación en la letra el cambio de nombre es bastante sorprendente. Así que la nueva versión de Android es KitKat.


  • 06/09/2013: Finite State Machine 4 java
    Sencilla librería que implementa máquinas de estado finitas para Java.


  • 11/09/2013: Enterprises still running old Java and Flash software, Websense finds
    El 40% de las aplicaciones Java empresariales aún usan Java 6, obsoleto y sin soporte desde abril de 2013, dejándolas expuestas a serias vulnerabilidades.


  • 11/09/2013: Java 8 developer preview ready for testing
    La versión developer preview de Java 8 está lista para ser testeada por la comunidad de desarrolladores.


  • 11/09/2013: Spring Framework 3.2.4 Released
    Anunciada la versión 3.2.4 de Spring Framework. Incluye numerosos bugfixes y mejoras y la gente de Spring recomienda a todo el mundo que se actualice.


Aprendiendo Vaadin #6: Usando SpringVaadinIntegration con soporte de navegación

Gestor de proyectosLlevaba tiempo buscando una forma de poder desarrollar una aplicación RIA sin tener que sufrir una dura curva de aprendizaje, aprovechando mis conocimientos de Java y obteniendo unos resultados suficientemente buenos. De primeras, GWT me pareció una buena opción, pero después descubrí Vaadin, que bajo mi punto de vista va un paso más allá y me convenció mucho más. En esta serie de entradas compartiré mis primeras experiencias con este framework.

En mi anterior post sobre Vaadin expliqué de una forma práctica cómo implementar soporte de navegación en una aplicación Vaadin. Para ello creé dos vistas, y para poder usar autowiring de spring en las vistas, las clases para las vistas debían ser internas a la clase UI que albergaba al navegador encargado de dar el soporte para navegación.
Usando el plugin SpringVaadinIntegration tendremos la posibilidad de usar autowiring en las clases vista de forma independiente a la clase UI. Para conseguir esto, voy a partir del mismo código del ejemplo anterior para ir modificándolo.

Como primer paso copiamos el proyecto del post anterior a un nuevo proyecto al que llamaré ApVaadinSpringVaadinIntegration. Para añadir la dependencia en maven de SpringVaadinIntegration necesitaremos definir en nuestro pom.xml el repositorio de Vaadin add-ons (si no lo tenemos ya definido, como en mi caso) y ya podremos definir la dependencia. Para añadir el repositorio al pom (si es que no lo tenemos ya agregado):

<repositories>
    <repository>
        <id>vaadin-addons</id>
        <url>http://maven.vaadin.com/vaadin-addons</url>
    </repository>
</repositories>

Y para añadir la dependencia del plugin:

<dependencies>
    <dependency>
        <groupId>ru.xpoft.vaadin</groupId>
        <artifactId>spring-vaadin-integration</artifactId>
        <version>1.7.3</version>
    </dependency>
</dependencies>

Antes de terminar con el pom nos aseguraremos de que aún contamos con la dependencia heredada al copiar el proyecto spring-web, pues la necesitaremos.

Ahora haremos los cambios necesarios al archivo web.xml. Es necesario redefinir el servlet de entrada de Vaadin y sustituirlo por el servlet aportado por el plugin SpringVaadinIntegration. Ahora podremos eliminar todas las referencias a la clase UIProvider que en nuestro ejemplo habíamos denominado MyUIProvider. La referencia al servlet en nuestro web.xml debe quedar así:

<servlet>
    <servlet-name>Test Application</servlet-name>
    <servlet-class>ru.xpoft.vaadin.SpringVaadinServlet</servlet-class>
    <init-param>
        <param-name>beanName</param-name>
        <param-value>MyVaadinUI</param-value>
    </init-param>
</servlet>

Y ahora podemos eliminar la clase MyUIProvider y también la clase Inject, ambas heredadas del ejemplo anterior al copiar el proyecto. A continuación modificaremos nuestra clase MyVaadinUI para hacerla funcionar con el plugin. La etiquetamos como @Component y @Scope(“prototype”). Los diferentes valores que podemos usar para la etiqueta @Scope son:

  • @Scope(“prototype”): crea una nueva instancia por cada nueva página.
  • @Scope(“session”): guarda la instancia UI en la sesión de usuario para ser reusada.
  • Opción por defecto: si no definimos el @Scope se usará en modo Singleton. Esto es, en todas las llamadas y en todos los casos se usará la misma instancia UI.

Ahora es posible extraer de nuestra clase UI las clases vista internas. Nos las llevamos fuera, al mismo paquete donde tenemos declarada la clase MyVaadinUI.

Al extraer las clases vista hay que etiquetarlas con las etiquetas ya conocidas @Component, @Scope, y con la etiqueta @VaadinView. Además, lo que normalmente hacíamos en el constructor ahora lo haremos en un método PostConstruct debidamente etiquetado. Así nuestras vistas serán instanciadas automáticamente, gracias al plugin.

Un problema con el que nos encontramos tras hacer todo esto es que nuestras vistas ya no conocen el servicio helloService. Ahora sí podremos inyectarlo mediante autowiring gracias al plugin SpringVaadinIntegration. De hecho, este servicio ya no nos sirve de nada en nuestra clase UI, así que lo mejor será borrarlo de ella.

El siguiente problema con el que nos encontramos es que nuestras vistas, que antes conocían a la instancia de nuestro Navigator, ahora han dejado de conocerla. La buena noticia es que ya no la vamos a necesitar en nuestras vistas para navegar de una vista a otra, usaremos Links (enlaces) para navegar. Eso sí, para seguir contando con soporte de navegación necesitaremos definir un nuevo Navigator haciendo uso de la clase DiscoveryNavigator que es proporcionada por el plugin y sustituyendo al antiguo Navigator en nuestra clase MyVaadinUI.
Por último, eliminamos de nuestras vistas todas las referencias al antiguo botón que ya no usaremos.

Después de todo esto, nuestra clase MyVaadinUI tendrá este aspecto, muy limpio:

@Component("MyVaadinUI")
@Scope("prototype")
public class MyVaadinUI extends UI {
	
	DiscoveryNavigator navigator;
	protected static final String STARTVIEW = "";
	protected static final String MAINVIEW = "main";  

	@Override
	protected void init(VaadinRequest request) {    	
        	getPage().setTitle("Ejemplo de navegación");        
       		navigator = new DiscoveryNavigator(this, this);        
    	}    
}

Del mismo modo, las vistas también han quedado bastante reducidas y limpias. El código para la vista StartView quedaría así:

@Component
@Scope("prototype")
@VaadinView(MyVaadinUI.STARTVIEW)
public class StartView extends VerticalLayout implements View {
	
	@Autowired
	HelloService helloService;
	
	@PostConstruct
	public void PostConstruct() {
		setSizeFull();
        	addComponent(new Link("Ir a la vista principal (MainView)", new ExternalResource("#!" + MyVaadinUI.MAINVIEW)));
	}
	
	@Override
	public void enter(ViewChangeEvent event) {
		Notification.show(helloService.sayHello(this));
	}
}

y el código para la vista MainView quedaría muy similar:

@Component
@Scope("prototype")
@VaadinView(MyVaadinUI.MAINVIEW)
public class MainView extends VerticalLayout implements View {

	@Autowired
	HelloService helloService;
	
	@PostConstruct
	public void PostConstruct() {
		setSizeFull();
		addComponent(new Link("Ir a la vista inicial (StartView)", new ExternalResource("#!" + MyVaadinUI.STARTVIEW)));
	}
	
	@Override
	public void enter(ViewChangeEvent event) {
		Notification.show(helloService.sayHello(this));
	}
}

Tras todo esto, tenemos una aplicación muy similar a la que teníamos, pero con menos clases y menos líneas de código, mucho más limpia y sencilla. Ahora podemos usar autowiring en las vistas, y podemos definir las vistas externamente a la clase UI.

Puedes descargar el código fuente de este ejemplo aquí.

Enlaces interesantes #9

enlaces-interesEn mi página de facebook, en mi perfil de twitter y/o en mi perfil de LinkedIn suelo publicar enlaces relacionados con la temática del blog que por algún motivo me han parecido interesantes. Para que no queden desperdigados y “perdidos en el olvido” los recopilaré en entradas del blog periódicamente.


  • 20/07/2013: Cómo implementar una intranet corporativa en WordPress
    No cabe duda de que el potencial de WordPress usando los plugins adecuados es enorme. En este artículo se comentan varios plugins interesantes que pueden facilitar la implementación de una intranet mediante WordPress. Sobre todo, para el caso de intranets, me parecen interesantes el plugin para LDAP y el plugin para Active Directory.


  • 23/07/2013: El principio KISS
    Principio KISS: “Keep It Simple, Stupid”. En este enlace se habla sobre este principio que bajo mi punto de vista debe ser siempre la base de todo lo que hagamos en desarrollo de software.


  • 29/07/2013: Spring Batch Partitioning Example
    El blog de Mkyong es un habitual de entre mis enlaces favoritos. En este post nos presenta un ejemplo práctico y claro sobre Spring Batch Partitioning, o lo que es lo mismo, cómo ejecutar los trabajos Spring Batch en múltiples hebras concurrentes.


  • 31/07/2013: Spring Batch Tutorial
    Este post, también del blog de Mkyong es un complemento perfecto para el enlace anterior. De hecho, engloba al enlace anterior. Se trata de un recopilatorio de enlaces de posts de Mkyong recopilados y ordenados en forma de tutorial sobre Spring Batch.

Aprendiendo Vaadin #5: Soporte de navegación

Gestor de proyectosLlevaba tiempo buscando una forma de poder desarrollar una aplicación RIA sin tener que sufrir una dura curva de aprendizaje, aprovechando mis conocimientos de Java y obteniendo unos resultados suficientemente buenos. De primeras, GWT me pareció una buena opción, pero después descubrí Vaadin, que bajo mi punto de vista va un paso más allá y me convenció mucho más. En esta serie de entradas compartiré mis primeras experiencias con este framework.

Las aplicaciones Vaadin por defecto funcionan en modo SPA (Single Page Application), o sea, todo el contenido, páginas web, formularios, etc. de la aplicación son cargados en una sola página web. Algo muy característico de las aplicaciones SPA es que se pierde el soporte de navegación, o lo que es lo mismo, no permiten moverse atrás/adelante mediante el navegador, y además tampoco permiten guardar una página concreta de la aplicación como favorita (bookmark del navegador). Sólo puedes establecer como bookmark la página de entrada a la aplicación.

Puede que este modo de funcionamiento nos interese o no. Por si no fuera así, vamos a ver cómo implementar soporte de navegación a una aplicación Vaadin. Para esto se suele usar la clase Navigator de Vaadin, que será la encargada de gestionar la navegación entre vistas (View), y a cada vista le podremos asignar un fragmento URI, gracias al cual podremos establecer un bookmark a cada vista.

Como primer paso, clonamos el proyecto de mi anterior post sobre Vaadin en un nuevo proyecto al que he llamado ApVaadinURIFragment. El código fuente que voy a explicar en este post se puede descargar aquí.

Una vez clonado el proyecto conviene hacerle unos cambios. He cambiado el nombre del paquete de com.dherrabits.aprendiendovaadin a com.dherrabits.aprendiendovaadin.urifragment. También me ha parecido buena idea cambiar el nombre del archivo de contexto de spring de context.xml a spring-context.xml. Como he cambiado el nombre del paquete también será necesario cambiar el contenido del archivo de contexto de spring, que debe quedar así:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:lang="http://www.springframework.org/schema/lang"
   xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/lang


http://www.springframework.org/schema/lang/spring-lang-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.dherrerabits.aprendiendovaadin.urifragment" />
</beans>

Por el mismo motivo, es necesario cambiar las referencias a las clases en el archivo web.xml que debe quedar así:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
  <display-name>Vaadin Web Application</display-name>
  <context-param>
    <description>Vaadin production mode</description>
    <param-name>productionMode</param-name>
    <param-value>false</param-value>
  </context-param>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/spring/spring-context.xml</param-value>
  </context-param>
  <listener>       
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <listener>
    <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>Vaadin Application Servlet</servlet-name>
    <servlet-class>com.vaadin.server.VaadinServlet</servlet-class>
    <init-param>
      <description>Vaadin UI to display</description>
      <param-name>UI</param-name>
      <param-value>com.dherrerabits.aprendiendovaadin.urifragment.MyVaadinUI</param-value>
    </init-param>
    <init-param>
      <description>Application widgetset</description>
      <param-name>widgetset</param-name>
      <param-value>com.dherrerabits.aprendiendovaadin.urifragment.AppWidgetSet</param-value>
    </init-param>
    <init-param>
      <description>Vaadin UI Provider</description>
      <param-name>UIProvider</param-name>
      <param-value>com.dherrerabits.aprendiendovaadin.urifragment.MyUIProvider</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>Vaadin Application Servlet</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

Crearé dos páginas o vistas, una página de entrada por defecto a la que llamare StartView y una página principal a la que llamaré MainView. Ambas mostrarán un mensaje de bienvenida y un botón para navegar de una a otra. Cada una de ellas será una clase que implementará la interfaz View. Ambas serán clases internas a la clase MyVaadinUI. Esto es así por comodidad, para que las vistas tengan acceso al navegador que se definirá en MyVaadinUI y también para que las vistas tengan acceso a los servicios de Spring inyectados en MyVaadinUI. En un siguiente post explicaré cómo usar Spring y autowiring también en las Vistas de forma independiente, usando para ello el plugin SpringVaadinIntegration.

Bien, según lo explicado anteriormente, el código para la clase de la vista de entrada por defecto será algo así:

    public class StartView extends VerticalLayout implements View,ClickListener {
    	
    	public StartView() {
    		
            setSizeFull();
            Button button = new Button("Ir a la vista principal (MainView)");
            button.addClickListener((Button.ClickListener) this);
            addComponent(button);
            setComponentAlignment(button, Alignment.TOP_LEFT);
            
        }
    	
    	@Override
    	public void enter(ViewChangeEvent event) {
    		Notification.show(helloService.sayHello(this));
    	}

    	@Override
    	public void buttonClick(ClickEvent event) {
    		navigator.navigateTo(MAINVIEW);
    	}

    }

y el código para la vista principal será:

    public class MainView extends VerticalLayout implements View,ClickListener {

    	public MainView() {
    		
            setSizeFull();
            Button button = new Button("Ir a la vista inicial (StartView)");
            button.addClickListener((Button.ClickListener) this);
            addComponent(button);
            setComponentAlignment(button, Alignment.TOP_LEFT);
            
        }
    	
    	@Override
    	public void enter(ViewChangeEvent event) {
    		Notification.show(helloService.sayHello(this));
    	}

    	@Override
    	public void buttonClick(ClickEvent event) {
    		navigator.navigateTo("");
    	}

    }

Recordemos que son clases internas a MyVaadinUI y por tanto tienen acceso al servicio Spring inyectado helloService y a la instancia navigator. He modificado el servicio helloService para que devuelva un mensaje diferente en base a qué vista le esté invocando, quedando así:

package com.dherrerabits.aprendiendovaadin.urifragment;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

import com.dherrerabits.aprendiendovaadin.urifragment.MyVaadinUI.MainView;
import com.dherrerabits.aprendiendovaadin.urifragment.MyVaadinUI.StartView;
  
@Service
@Scope("prototype")
public class HelloService {
  
    public String sayHello(Object c) {
    	if (c instanceof StartView)
    		return "Bienvenido a la vista inicial (StartView)";
    	else if (c instanceof MainView)
    		return "Bienvenido a la vista principal (MainView)";
    	else
    		return "Hola desde servicio Spring!!!";
    }
}

Por último, he definido en MyVaadinUI el Navigator que gestionará la navegación entre vistas, he definido el nombre que se empleará para el URI Fragment de la vista principal, y he añadido las vistas al Navigator, y con esto ya estaría todo. El fuente de MyVaadinUI con las clases de vista internas incluidas quedaría finalmente así:

package com.dherrerabits.aprendiendovaadin.urifragment;

import org.springframework.beans.factory.annotation.Autowired;

import com.vaadin.navigator.Navigator;
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Notification;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;
  
/**
 * The Application's "main" class
 */
@SuppressWarnings("serial")
public class MyVaadinUI extends UI {
      
	@Autowired
    HelloService helloService;
	
    Navigator navigator;
    protected static final String MAINVIEW = "main";

    @Override
    protected void init(VaadinRequest request) {
    	
        getPage().setTitle("Ejemplo de navegación");
        
        // Crear un navegador para controlar las Vistas
        navigator = new Navigator(this, this);
        
        // Crear y registrar las Vistas
        navigator.addView("", new StartView());
        navigator.addView(MAINVIEW, new MainView());
        
    }
  
    public class StartView extends VerticalLayout implements View,ClickListener {
    	
    	public StartView() {
    		
            setSizeFull();
            Button button = new Button("Ir a la vista principal (MainView)");
            button.addClickListener((Button.ClickListener) this);
            addComponent(button);
            setComponentAlignment(button, Alignment.TOP_LEFT);
            
        }
    	
    	@Override
    	public void enter(ViewChangeEvent event) {
    		Notification.show(helloService.sayHello(this));
    	}

    	@Override
    	public void buttonClick(ClickEvent event) {
    		navigator.navigateTo(MAINVIEW);
    	}

    }

    public class MainView extends VerticalLayout implements View,ClickListener {

    	public MainView() {
    		
            setSizeFull();
            Button button = new Button("Ir a la vista inicial (StartView)");
            button.addClickListener((Button.ClickListener) this);
            addComponent(button);
            setComponentAlignment(button, Alignment.TOP_LEFT);
            
        }
    	
    	@Override
    	public void enter(ViewChangeEvent event) {
    		Notification.show(helloService.sayHello(this));
    	}

    	@Override
    	public void buttonClick(ClickEvent event) {
    		navigator.navigateTo("");
    	}

    }

    
}

Y así disponemos de forma sencilla de un proyecto Vaadin con soporte de navegación mediante vistas usando un servicio Spring auto-inyectado. Como he comentado anteriormente, en un siguiente post explicaré cómo usar Spring y autowiring también en las Vistas de forma independiente, usando para ello el plugin SpringVaadinIntegration. De esta forma será posible usar autowiring de Spring en las vistas sin que estas tengan que ser clases internas a nuestra clase UI.

Puedes descargar el código fuente de este ejemplo aquí.

Enlaces interesantes #8

enlaces-interesEn mi página de facebook, en mi perfil de twitter y/o en mi perfil de LinkedIn suelo publicar enlaces relacionados con la temática del blog que por algún motivo me han parecido interesantes. Para que no queden desperdigados y “perdidos en el olvido” los recopilaré en entradas del blog periódicamente.


  • 09/07/2013: Cómo elegir un lenguaje de programación
    “¿Por qué elegimos un lenguaje de programación u otro? ¿Qué factores afectan (o deberían afectar) a esa decisión? Muchas veces el lenguaje que usamos viene impuesto por la empresa en que trabajamos, la plataforma que usamos o el proyecto concreto, pero cuando podemos decidir qué lenguaje utilizar, hay varios factores que es importante tener en cuenta.”
    Estoy muy de acuerdo con la conclusión del artículo: “Establece un contexto, comprende tus necesidades, tus conocimientos y tus limitaciones, y en base a eso toma una decisión. Es más complicado que ser un fanboy de un lenguaje (o un estilo de programación) concreto, pero también es más práctico.”. En definitiva, como siempre: usa el sentido común.


  • 11/07/2013: Copiar y pegar – Un asesino de tu voluntad de aprender a programar en java
    Evidentemente el copy-paste no es una forma de evitar que aprendas a programar en java sino una forma de evitar que aprendas a programar en general, o diría más, el copy-paste evita que aprendas a escribir y a expresarte y provoca la no asimilación de los conceptos que estás tratando. Por otra parte, tal como resaltan en el artículo, estoy de acuerdo en que “La presión en el trabajo asesina el aprendizaje del Programador”.


  • 12/07/2013: Eclipse Quick Search
    Desde el blog de Spring nos hablan de la característica “Quick Search” incluída en su herramienta Spring ToolSuite (STS) 3.3.0 y en Groovy Grails Tool Suite (GGTS) 3.3.0 que facilita las búsquedas en Eclipse a cualquier desarrollador, incluso aunque no uses Spring ni Grails.


  • 13/07/2013: Spring Batch Example – XML File To CSV File
    Como ya he dicho en varias ocasiones, me gusta mucho el blog de Mkyong porque suele aportar soluciones prácticas y directas, muy al grano, para situaciones muy comunes en el día a día del desarrollo en java. En este caso nos cuenta cómo configurar un trabajo Spring Batch para convertir un fichero XML en un CSV.


Aprendiendo Vaadin #4: Agregando Spring

Gestor de proyectosLlevaba tiempo buscando una forma de poder desarrollar una aplicación RIA sin tener que sufrir una dura curva de aprendizaje, aprovechando mis conocimientos de Java y obteniendo unos resultados suficientemente buenos. De primeras, GWT me pareció una buena opción, pero después descubrí Vaadin, que bajo mi punto de vista va un paso más allá y me convenció mucho más. En esta serie de entradas compartiré mis primeras experiencias con este framework.

En mi anterior post sobre Vaadin mostré cómo crear un proyecto desde cero usando Eclipse, Maven y Tomcat. Creo que un buen siguiente paso sería incorporar Spring a la solución.

Parto desde cero: para este proyecto estoy estrenando Eclipse Kepler en su versión Eclipse IDE for Java Developers. En casos como este (cuando estás aprendiendo o desarrollando proyectos experimentales) recomiendo usar las últimas versiones de las herramientas. En el trabajo ya es otra historia y no siempre es lo mejor estar a la última.

Para crear el proyecto Maven para la versión 7 de Vaadin me guiaré por las recomendaciones de Javi Serrano, un muy buen colega de profesión, que podemos ver en este post de su blog. La solución propuesta consiste, según las propias palabras de Javier, en una clase “Inyectora”, una serie de escuchadores y parámetros de contexto en el archivo web.xml y una configuración mínima de spring que permita el “Autowiring” de las dependencias de modo transparente. Por tanto creamos un nuevo proyecto Maven desde Eclipse, y en la pantalla de selección de arquetipo añadimos el arquetipo vaadin-archetype-application a nuestro repositorio Local (este paso no es necesario, es cuestión personal) pulsando “Add Archetype…” y usando esta información:

AddArchetype

Al paquete del proyecto lo he llamado com.dherrerabits.aprendiendovaadin, y al proyecto AprendiendoVaadinAgregandoSpring. El nombre del paquete es relevante pues después modificaremos el archivo web.xml y lo usaremos en él. Una vez generado el proyecto agregamos las dependencias de Spring al pom:

spring-dependency

Ahora modificamos el archivo web.xml sustituyéndolo por el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
	id="WebApp_ID" version="2.5">
  <display-name>Vaadin Web Application</display-name>
  <context-param>
    <description>Vaadin production mode</description>
    <param-name>productionMode</param-name>
    <param-value>false</param-value>
  </context-param>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/spring/context.xml</param-value>
  </context-param>
  <listener>       
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <listener>
    <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>Vaadin Application Servlet</servlet-name>
    <servlet-class>com.vaadin.server.VaadinServlet</servlet-class>
    <init-param>
      <description>Vaadin UI to display</description>
      <param-name>UI</param-name>
      <param-value>com.dherrerabits.aprendiendovaadin.MyVaadinUI</param-value>
    </init-param>
    <init-param>
      <description>Application widgetset</description>
      <param-name>widgetset</param-name>
      <param-value>com.dherrerabits.aprendiendovaadin.AppWidgetSet</param-value>
    </init-param>
    <init-param>
      <description>Vaadin UI Provider</description>
      <param-name>UIProvider</param-name>
      <param-value>com.dherrerabits.aprendiendovaadin.MyUIProvider</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>Vaadin Application Servlet</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

A continuación creamos el archivo context.xml en la ruta “src/main/webapp/WEB-INF/spring“:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:lang="http://www.springframework.org/schema/lang"
   xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/lang


http://www.springframework.org/schema/lang/spring-lang-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.dherrerabits.aprendiendovaadin" />
</beans>

El siguiente paso, como muy bien nos explica Javi Serrano en su blog, será crear la clase inyectora:

package com.dherrerabits.aprendiendovaadin;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
 
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.context.support.WebApplicationContextUtils;
 
public class Inject {
 
    public static void inject( Object component )
    {
        ApplicationContext context = getApplicationContext();
        AutowireCapableBeanFactory beanFactory = context.getAutowireCapableBeanFactory();
        beanFactory.autowireBeanProperties( component, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false );
    }
 
    private static ApplicationContext getApplicationContext()
    {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        HttpSession session = request.getSession( false );
        ServletContext servletContext = session.getServletContext();
        WebApplicationContext context = WebApplicationContextUtils.getRequiredWebApplicationContext( servletContext );
        return context;
    }
}

A continuación creamos la clase UIProvider a la que llamaremos MyUIProvider:

package com.dherrerabits.aprendiendovaadin;

import com.vaadin.server.UIClassSelectionEvent;
import com.vaadin.server.UICreateEvent;
import com.vaadin.server.UIProvider;
import com.vaadin.ui.UI;
 
@SuppressWarnings("serial")
public class MyUIProvider extends UIProvider {
 
    @Override
    public Class getUIClass(UIClassSelectionEvent event) {
        return MyVaadinUI.class;
    }
 
    @Override
    public UI createInstance(UICreateEvent event) {
        UI instance = super.createInstance(event);
        Inject.inject(instance);
        return instance;
    }
}

Siguiendo los pasos de Javi, creamos el servicio HelloService:

package com.dherrerabits.aprendiendovaadin;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
 
@Service
@Scope("prototype")
public class HelloService {
 
    public String sayHello() {
        return "Hello Vaadiners from a Spring Service!!!";
    }
}

Y a continuación modificamos la clase MyVaadinUI que se creó automáticamente, con el objetivo de que use el servicio recién creado quedando así:

package com.dherrerabits.aprendiendovaadin;

import org.springframework.beans.factory.annotation.Autowired;
 
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Notification;
import com.vaadin.ui.Notification.Type;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;
 
/**
 * The Application's "main" class
 */
@SuppressWarnings("serial")
public class MyVaadinUI extends UI implements ClickListener{
     
    @Autowired
    HelloService helloService;
 
    @Override
    protected void init(VaadinRequest request) {
        final VerticalLayout layout = new VerticalLayout();
        layout.setMargin(true);
        setContent(layout);
        Button button = new Button("Click Me");
        button.addClickListener((Button.ClickListener) this);
        layout.addComponent(button);
    }
     
    public void buttonClick(ClickEvent event){
        if (helloService != null){
            Notification.show("The injected service says", helloService.sayHello(), Type.HUMANIZED_MESSAGE);
        }
    }
 
}

A continuación, tal como nos indica Javi en su blog, es posible probar la aplicación usando el comando “mvn package jetty:run”. Yo personalmente no soy muy amigo del command prompt y ejecutaré el mismo comando para probar, pero desde eclipse:

jetty-run

Y ya podemos probar usando la URL: http://localhost:8080/AprendiendoVaadinAgregandoSpring

Pues bien, para continuar por donde me había quedado en anteriores posts, ahora incluiré Tomcat en Eclipse (aunque no des-recomiendo en absoluto usar Jetty para desarrollar, es más bien una opción personal). En la distro de Eclipse que he elegido no están incluidas las “Web Tools Platform”, así que las instalaré a continuación:

wtp

No es mi intención explicar aquí cómo instalar Tomcat en Eclipse. Eso ya está más que documentado en la web. Ahora convertimos el proyecto en un proyecto web, tal como expliqué en mi anterior post y finalmente tenemos en marcha un proyecto funcionando con las siguientes tecnologías: Eclipse, Maven, Tomcat, Spring y Vaadin 7.

Llegados a este punto es el momento ideal para generar el correspondiente arquetipo de Maven usando la sentencia mvn archetype:create-from-project. Automáticamente se nos generará un arquetipo a partir del proyecto que hemos creado, y se guardará en target. Para poder usar el arquetipo, deberá estar instalado en nuestro repositorio con lo que ejecutamos un mvn install desde target/generated-sources/archetype.
Ahora ya podemos crear un nuevo proyecto usando el arquetipo, desde Eclipse, File->New->Other…->Maven->Maven Project, en la pantalla de selección de arquetipo será importante pulsar el check Include snapshot archetypes, pues de la forma en la que hemos generado el arquetipo se habrá instalado en versión snapshot, y una vez generado el proyecto mediante Maven, habremos conseguido crear muy fácil y rápidamente un proyecto web eclipse con Maven, Spring y Vaadin 7.

Puedes descargar el código fuente de este ejemplo aquí.

Enlaces interesantes #7

enlaces-interesEn mi página de facebook, en mi perfil de twitter y/o en mi perfil de LinkedIn suelo publicar enlaces relacionados con la temática del blog que por algún motivo me han parecido interesantes. Para que no queden desperdigados y “perdidos en el olvido” los recopilaré en entradas del blog periódicamente.


  • 01/07/2013: Cupcloud, guarda todo tu trabajo al instante
    Cupcloud es un interesante nuevo proyecto cuya idea es que con un solo click puedas guardar el estado de tu equipo, y además puedas acceder al estado guardado desde cualquier otro equipo o lugar, ya que el estado se almacena en la nube. En este momento acaba de empezar su andadura y está limitado en funciones y posibilidades, pero promete bastante bajo mi punto de vista.


  • 02/07/2013: Aprende Dart en 15 minutos
    En este enlace es posible hacerse una idea de un vistazo rápido de las posibilidades de Dart. Además también es posible encontrar tutoriales rápidos para otros lenguajes.


  • 03/07/2013: Estilo Nueva Jersey
    Curioso post sobre el estilo Nueva Jersey de desarrollo de software. El estilo Nueva Jersey es una técnica de desarrollo de software (más bien una estrategia) basada en el principio “peor es mejor”, en la que se prefiere sacrificar determinados aspectos del producto final a cambio de conseguir un sistema mucho más sencillo de utilizar y de mantener (sobre todo esto último ya que permite adaptar de forma más rápida el sistema a las necesidades del usuario).


  • 06/07/2013: Convertir String con comas a Long – Java
    Me gusta mucho el blog de Mkyong. Suele aportar soluciones prácticas y directas, muy al grano, para situaciones muy comunes en el día a día del desarrollo en java. En este caso nos cuenta alternativas para convertir una cadena numérica con comas de tipo String a tipo Long.