Aprendiendo Vaadin #3: Usando Eclipse, Maven y Tomcat

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é cómo crear un entorno de desarrollo Vaadin usando Eclipse y Maven, y como servidor Jetty. Aunque esta configuración es válida, no me termina de convencer. Me parece mucho más cómodo usar un servidor Tomcat integrado en Eclipse para ejecutar y hacer debug. En la documentación no he encontrado apenas nada al respecto. Para cubrir este hueco, veamos la forma de conseguir esto:

Parto de la suposición de que ya tenemos un servidor Tomcat v6 (ó 7) integrado en Eclipse (Juno o Indigo). Evolucionaremos el proyecto Maven AprendiendoVaadinConMaven. Lo mejor será hacer una copia exacta del proyecto original y llamarlo AprendiendoVaadinConMavenYTomcat. Si hacemos memoria, la estructura del proyecto creado será:

estructura_proyecto

El siguiente paso será convertir el proyecto creado en un proyecto web que podamos añadir al servidor Tomcat desde Eclipse. Para ello, usando el botón derecho del ratón sobre el proyecto entraremos a sus propiedades y accedemos a la opción “Project Facets”, y pulsamos en “Convert to faceted form…”. A continuación seleccionamos “Dynamic Web Module” y la versión 2.4:

facet

En este momento nos aparecerá el mensaje/enlace: Further configuration available…. Es necesario pinchar en él para cambiar la carpeta de contenido por defecto, en lugar de “WebContent” colocaremos “src/main/webapp”:

further-configuration

Tras pulsar OK, ya tenemos el proyecto en formato web y es posible agregarlo al servidor Tomcat integrado en Eclipse, pero en estos momentos, si lo ejecutamos, no funcionará. Para hacerlo funcionar es necesario incluir la dependencias Maven en la sección Deployment Assembly. Para ello volvemos a entrar en las propiedades del proyecto, pulsamos en “Deployment Assembly” y hacemos 2 cosas: primero eliminar “src/test/java” pues no lo vamos a necesitar, y segundo añadir las dependencias de Maven pulsando en Add -> Java Build Path Entries -> Maven Dependencies. Debe quedar así:

deployment-assembly

Y ahora sí, tras actualizar todo y hacer un Build, ya es posible añadir el proyecto web al servidor Tomcat integrado en Eclipse y ejecutar o hacer debug, y ya queda todo listo para usar el mismo ejemplo de los post anteriores, con Maven y el servidor Tomcat integrado en Eclipse.

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

Anuncios

Aprendiendo Vaadin #2: Usando Maven

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 creé un pequeño proyecto al que llamé AprendiendoVaadin y monté un primer entorno de desarrollo siguiendo las indicaciones del libro de Vaadin, usando Eclipse y como guía las instrucciones para instalar el plugin de Eclipse y para crear y ejecutar un nuevo proyecto. El plugin de Vaadin para Eclipse requiere adicionalmente el plugin Apache IvyDE, y como puede resultar evidente, al crear un nuevo proyecto éste se configura automáticamente para usar como gestor de dependencias Apache Ivy.

Como en mi caso llevo años trabajando con Maven, y tampoco los resultados de Google Trends son muy alentadores para Apache Ivy, he preferido cambiar y usar Maven. Para esta tarea el libro de Vaadin en mi opinión se queda bastante corto, así que espero que este post pueda servir de ayuda a algún iniciado como yo. El primer paso fue crear el proyecto Maven al que llamé AprendiendoVaadinConMaven en Eclipse, usando el plugin Maven Integration for Eclipse (m2eclipse). Para ello usé el arquetipo Maven vaadin-archetype-application:

y a continuación los parámetros:

Maven-params

De esta forma se consigue un proyecto inicial básico que incluye a la clase principal MyVaadinUI:

public class MyVaadinUI extends UI
{

    @Override
    protected void init(VaadinRequest request) {
        final VerticalLayout layout = new VerticalLayout();
        layout.setMargin(true);
        setContent(layout);

        Button button = new Button("Click Me");
        button.addClickListener(new Button.ClickListener() {
            public void buttonClick(ClickEvent event) {
                layout.addComponent(new Label("Thank you for clicking"));
            }
        });
        layout.addComponent(button);
    }

}

Como mi intención es continuar con el trabajo hecho en mi anterior post sobre Vaadin, toca renombrar esta clase a AprendiendoVaadinUI y cambiar su contenido. Tras hacer un Refactor->Rename de Eclipse y cambiar su contenido debe quedar algo así:

public class AprendiendoVaadinUI extends UI {

	private final String BTN_CAPTION_MOSTRAR_MENSAJE = "Mostrar mensaje";
	private final String BTN_CAPTION_OCULTAR_MENSAJE = "Ocultar mensaje";
	private final String MENSAJE = "Hola Mundo!!!";

	@Override
	protected void init(VaadinRequest request) {
		final VerticalLayout layout = new VerticalLayout();
		final Label mensaje = new Label(MENSAJE);
		final Button button = new Button(BTN_CAPTION_MOSTRAR_MENSAJE);

		layout.setMargin(true);
		setContent(layout);

		layout.addComponent(button);
		mensaje.setVisible(false);
		layout.addComponent(mensaje);

		button.addClickListener(new Button.ClickListener() {
			public void buttonClick(ClickEvent event) {
				mensaje.setVisible(!mensaje.isVisible());
				if (mensaje.isVisible())
					button.setCaption(BTN_CAPTION_OCULTAR_MENSAJE);
				else
					button.setCaption(BTN_CAPTION_MOSTRAR_MENSAJE);
			}
		});
	}
}

Por el momento todo bien, tras ejecutar un mvn package ya tengo el correspondiente war. Pero con esto no es suficiente, este war no funcionará, porque al intentar entrar en la aplicación el servidor buscará la antigua clase MyVaadinUI. Para corregir esto hay que editar el archivo web.xml y cambiar la clase asignada al servlet de entrada:

<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.AprendiendoVaadinUI</param-value>
        </init-param>

Ahora ya es posible ejecutar la aplicación. El arquetipo de Maven para Vaadin viene preparado y configurado para ejecutar mediante Jetty. Para ello, usando Maven desde Eclipse, en Goals escribimos jetty:run y a continuación se puede probar la aplicación mediante la url http://localhost:8080/

Bien, el problema ahora es que en este punto no se puede hacer debug desde Eclipse. Para solucionar esto habrá que habilitar el debugging remoto. Para ello, en la configuración Maven recién creada con el Goal jetty:run accedemos a la pestaña JRE y especificamos los siguientes argumentos para la máquina virtual:

-Xdebug -Xrunjdwp:transport=dt_socket,address=4000,server=y,suspend=n

Ahora al iniciar Jetty en la consola aparecerá el mensaje:

Listening for transport dt_socket at address: 4000

A continuación es necesario crear una configuración de debug. Para ello haremos botón derecho sobre el proyecto, “Debug As…”-> “Debug Configurations…” y creamos una nueva “Remote Java Application”. Importante recordar aquí que el puerto que hemos indicado en el paso anterior es el 4000:

vaadin-debug

Y ahora sí ya es posible hacer debug. Con esto ya por fin tenemos un entorno de desarrollo Vaadin con Maven completo.

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

Tutorial: Cómo crear un cliente SOAP en Java sin usar AXIS paso a paso

javaHispanoCuando nos encontramos ante la necesidad de desarrollar un cliente SOAP en Java, normalmente lo que se hace es generar las clases stub necesarias mediante AXIS, o también CXF o Metro. Puede que no siempre sea la opción más conveniente o quizá no sea posible el uso de alguna de estas herramientas, aunque eso sí, no cabe duda que facilitan muchísimo un desarrollo que sin ellas sería bastante arduo.

Tengo el placer de anunciar que me han publicado en javaHispano este tutorial“Cómo crear un cliente SOAP en Java sin usar AXIS paso a paso”, donde muestro cómo desarrollar dicho cliente de una manera no habitual, sin usar ninguna de las utilidades mencionadas, y además de una forma sencilla y clara.

Espero que resulte de utilidad para la comunidad de desarrolladores java.

Aprendiendo Vaadin #1: Hola Mundo

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.

Y bien, ¿por qué Vaadin? Creo que es un framework muy a tener en cuenta pues aporta a cualquier equipo de desarrollo RIA grandes y claras ventajas competitivas. Generalmente en este tipo de proyectos suelen existir 2 perfiles claramente diferenciados: el desarrollador de front-end y el de back-end. Aunque se pueda dar el caso, no es muy común contar con miembros en el equipo que dominen ambas vertientes, y más difícil aún es encontrar alguien de estas características en el mercado laboral con cierta urgencia.
Pues bien, usando Vaadin, sólo con perfiles Java es posible desarrollar aplicaciones 100% RIA de resultados sorprendentemente buenos, lo cual aporta una gran flexibilidad para poder echar en cualquier momento más carne en el asador de un lado o de otro.
Por otro lado, la posibilidad de crear aplicaciones móviles HTML5 mediante el add-on TouchKit usando exclusivamente Java para su desarrollo me parece muy atractiva.

Cómo no podía ser de otra forma, el primer acercamiento será creando el típico “Hola Mundo”. Crearé el proyecto AprendiendoVaadin montando primeramente un entorno siguiendo las indicaciones del libro de Vaadin. En mi caso, como voy a usar Eclipse, he seguido las instrucciones para instalar el plugin de Eclipse y para crear y ejecutar un nuevo proyecto. Tras ello me encuentro que ya tengo un pequeño código de ejemplo:

public class AprendiendoVaadinUI extends UI {

	@Override
	protected void init(VaadinRequest request) {
		final VerticalLayout layout = new VerticalLayout();
		layout.setMargin(true);
		setContent(layout);

		Button button = new Button("Click Me");
		button.addClickListener(new Button.ClickListener() {
			public void buttonClick(ClickEvent event) {
				layout.addComponent(new Label("Thank you for clicking"));
			}
		});
		layout.addComponent(button);
	}
}

Resulta fácil de leer y muy claro lo que hace. La clase extiende UI (User Interface) que es la clase padre de donde deben heredar las interfaces de usuario que vayamos a crear. A continuación sobreescribe el método init que inicializará la interfaz de usuario.
Define un Layout vertical que se asigna a la interfaz. Después crea un botón al que asigna un comportamiento ante el evento Click y añade el botón al layout creado previamente.
Ante un click en el botón lo que ocurrirá es que aparecerá un Label dándonos las gracias justo debajo del botón, ya que el layout definido es vertical.

VaadinClickMe

Para llevar este ejemplo tan sencillo un pequeño paso más allá voy a hacer que el mismo botón sirva tanto para mostrar como para ocultar el mensaje “Hola Mundo!!!”. Para ello bastará con jugar con la visibilidad del Label que contiene el mensaje y con la propiedad Caption del botón como se puede ver en el código:

public class AprendiendoVaadinUI extends UI {

	private final String BTN_CAPTION_MOSTRAR_MENSAJE = "Mostrar mensaje";
	private final String BTN_CAPTION_OCULTAR_MENSAJE = "Ocultar mensaje";
	private final String MENSAJE = "Hola Mundo!!!";

	@Override
	protected void init(VaadinRequest request) {
		final VerticalLayout layout = new VerticalLayout();
		final Label mensaje = new Label(MENSAJE);
		final Button button = new Button(BTN_CAPTION_MOSTRAR_MENSAJE);

		layout.setMargin(true);
		setContent(layout);

		layout.addComponent(button);
		mensaje.setVisible(false);
		layout.addComponent(mensaje);

		button.addClickListener(new Button.ClickListener() {
			public void buttonClick(ClickEvent event) {
				mensaje.setVisible(!mensaje.isVisible());
				if (mensaje.isVisible())
					button.setCaption(BTN_CAPTION_OCULTAR_MENSAJE);
				else
					button.setCaption(BTN_CAPTION_MOSTRAR_MENSAJE);
			}
		});
	}
}

Como primer acercamiento no está mal. De una forma muy sencilla y rápida he conseguido algo que de otra forma seguramente me habría costado más, y usando sólo Java. ¿Alguien da más?

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