Spring Boot Parte 2 - Externalizando la Configuración de la Aplicación

Algo muy importante y fácil de olvidar cuando creamos una aplicación, es que (si todo sale bien), esta vera la luz en un mundo productivo y será ahí cuando comenzará su vida útil, en un mundo fuera de la computadora del desarrollador.

Antes de llegar a su destino final (el ambiente de producción) una aplicación sana debería pasar por al menos dos ambientes. El primero es el ambiente del desarrollador, la computadora o computadoras en las que nunca nada falla ni sale mal :). El segundo ambiente debería ser el ambiente de integración continua; aquí será una computadora configurada en la que la aplicación se compilará y se ejecutarán una serie de pruebas automáticas que van desde las pruebas funcionales, hasta pruebas de carga y estrés. El tercer ambiente es un ambiente de testing, aquí un profesional altamente capacitado (el tester) hará su mayor esfuerzo por hacer que nuestra aplicación falle o "se rompa" en formas que nunca imaginamos al momento de escribir nuestro código productivo o de pruebas unitarias.

Una vez que nuestra aplicación sobrevive en los ambientes anteriores, llegará finalmente al ambiente productivo. En este ambiente es donde pasará su vida útil sirviendo a usuarios que no estuvieron involucrados dentro del proceso de construcción.
Como podemos ver, nuestra aplicación pasara a través de varios ambientes, algunos de los cuales no tendremos control y serán distintos al ambiente creado dentro de las máquinas de desarrollo. Debido a esto es muy importante tener un mecanismo que nos permita externalizar la configuración de nuestras aplicaciones Spring Boot y que se ejecute de la misma forma sin importar el ambiente en el que se encuentre. Algunos elementos que comúnmente cambian dependiendo del ambiente en el que ejecutemos la aplicación son: rutas, usuarios de conexiones a base de datos, puertos de funcionamiento, nombres de servidores, etc.

En este tutorial aprenderemos las formas que Spring Boot proporciona para colocar esta información de configuración fuera del código fuente de la aplicación (evitando con esto que tengamos que recompilarla cada vez que vayamos a moverla de ambiente), y las prioridades o precedencias que Spring Boot asigna a cada una de estas formas.

Lombok, escribiendo menos código y logrando más cosas

En este tutorial no veremos un Framework, sino una herramienta Java que nos ayudará a simplificar mucho el código que escribimos en cada una de nuestras clases de datos; o sea, las clases que no contienen lógica de negocio, sino que nos ayudan a "transportar" información, como son los POJOs o los Value Objects.

Lombok es una librería Java que automáticamente se conecta a nuestro editor o herramienta de construcción (como pueden ser Maven o Eclipse) y que nos ayuda a generar código para las tareas más repetitivas de nuestras clases como son la generación de métodos setter y getter, constructores, toString, equals, etc. ¿Recuerdan en los tutoriales de Hibernate como la parte más tardada era generar las entidades por la cantidad de métodos getter y setter que estas tenían? Esas clases ocupan mucho espacio, en término de líneas de código; todo ese código podremos ahorrárnoslo con Lombok, ya que por medio de anotaciones le indicaremos qué es lo que queremos que genere.

En este tutorial aprenderemos cómo instalar Lombok en nuestro IDE y veremos algunos ejemplos de uso.

Spring Boot Parte 1 - Introducción y Hola Mundo

Comenzamos hoy con esta serie tutoriales sobre Spring Boot para renovarnos un poco, especialmente después de haber podido aprender algo de Spring Core y de Spring MVC

Seguramente muchos habrán escuchado de Spring Boot, sobre todo en el ámbito de los microservicios, pero ¿qué es Spring Boot? Spring Boot es un framework ligero que permite eliminar la mayor parte del trabajo de las configuraciones básicas de Spring. Es una de esas maravillas dentro de la maravilla que ya es Spring; literalmente en unos pocos segundos se puede tener una aplicación web recibiendo peticiones y lista para desplegarse, ya que contiene un conjunto inteligente de valores por default, por lo que requiere muy poca o ninguna configuración, y esa poca configuración se da en forma de anotaciones. No por nada ha sido una de las herramientas más utilizados por la comunidad de Spring desde su aparición en 2013.

Además de esto, Spring Boot proporciona un conjunto rico de herramientas integradas para sólo tener que preocuparnos de la lógica de la aplicación. A lo largo de esta serie de tutoriales iremos viendo y configurando cada una de estas herramientas.

Java Tutoriales está de regreso y tendrá algunos cambios

Ha sido un poco más de dos años desde la última vez que escribí. No ha sido por gusto sino por algunas causas de fuerza mayor; pero ya estoy finalmente de regreso.

Con esto quiero decirles que el blog tendrá algunos cambios, no se preocupen que todos serán para bien ^_^. En primer lugar los tutoriales se mantienen con su mismo formato, no se preocupen por eso; aunque ahora buscaré que sean un poco más cortos ya que me tomaba mucho tiempo escribirlos y esa es una de las razones por las que tardaba tanto en escribir nuevos tutoriales, y algunas veces tenía que dejarlos a medias por un buen rato, con tutoriales más cortos podré publicar más seguido.

En segundo lugar iré agregando no solamente tutoriales de Frameworks Java, sino también comenzaré a agregar tutoriales de Patrones de Diseño, UML, Buenas Prácticas y algo de Arquitectura de Software, para ir haciendo más completos los temas de los que trata; de vez en cuando incluso agregaré algunos temas que no tengan que ver con Java, pero sí con el mundo del desarrollo.

Tercero, debido a los cambios que ha habido con Java en los últimos años, en los tutoriales ya no usaré NetBeans sino que cambiaré a Eclipse; esta es una decisión que no me ha gustado mucho pero la verdad desde que la fundación Apache tomó el proyecto, y debido a que Oracle aún no ha terminado de donar completamente todos los módulos y plugins el IDE me parece que ya no funciona tan bien como antes. También, ya no usaremos los jars de las librerías directamente, sino que haremos la gestión de dependencias a través de Gradle, esto un poco con la idea de ir aprendiendo poco a poco cómo funciona esta herramienta.... ¿que por qué no uso Maven? Personalmente en mi trabajo llevo usando Maven desde hace unos 10 años, es una herramienta muy completa, madura y estable; también hay mucho material sobre cómo funciona en infinidad de lugares en la red; Gradle es nuevo para mi así que aprovecharé para aprender a usarlo mejor ;).

Finalmente, el código ya no será colocado en un sitio de Google para su descarga, sino que lo colocaré en Github, creo que así será más fácil para todos simplemente clonar el repositorio, y para mí será más fácil subirlo y actualizarlo.

Bien, me parece que eso es todo; además de una ligera actualización de imagen del blog, que ya le hacía mucha falta. El 21 de enero pasado este blog cumplió 10 años, así que ya era algo justo y necesario.

Siempre es bueno estar de regreso en casa, así que sea bienvenidos y gracias por la paciencia; también perdón a todas las personas a las que no pude contestarles en este tiempo, pero ya estoy de regreso.

Seguimos con las redes sociales del sitio, así que cualquier cosa no duden en ponerse en contacto. Por alguna razón Facebook eliminó el sitio anterior así que tuve que crear una nueva página de JavaTutoriales para poder estar en contacto; pueden encontrare en:

Twitter @JavaTutoriales
GMail: programadorjavablog@gmail.com
Faceboook: @JavaTutoriales

Esperen pronto la primera entrada de esta nueva etapa de JavaTutoriales!!

Spring MVC - Parte 2: Selección de manejadores de peticiones

En el tutorial anterior aprendimos cómo configurar nuestra aplicación para hacer uso de Spring MVC, además creamos dos Controllers con un método cada uno para manejar las peticiones recibidas por el usuario. En esa ocasión configuramos los métodos de una manera simple y directa para responder a las peticiones, sin embargo, Spring MVC permite varias formas de indicar a qué peticiones puede responder un manejador particular.

En este tutorial aprenderemos las distintas maneras que tenemos para indicar a qué peticiones debe responder un método dentro de un Controller, y cómo podemos tomar ventaja de estas formas para recibir distintos tipos de información desde nuestras páginas web.

Spring MVC - Parte 1: Configuración

En tutoriales anteriores hemos visto cómo trabajar con los módulos core de Spring, los cuales proporcionan el motor de inyección de dependencias y el contendor de beans. También tuvimos una serie completa de cómo trabajar con un framework MVC para aplicaciones web, Struts 2.

Spring tiene sus propios módulos que conforman un framework para el desarrollo de aplicaciones Java basadas en web, Este framework sigue el patrón de diseño MVC. A este conjunto de módulos se le conoce con el nombre de Spring MVC.

En esta serie de tutoriales aprenderemos a usar Spring MVC. En este primer tutorial aprenderemos cómo configurar el framework de dos formas, una a través de archivos de configuración en XML y otra a través de código Java y haremos el respectivo Hola Mundo.

Spring - Parte 5: Integración y manejo de transacciones con Hibernate

A lo largo de una serie de tutoriales hemos visto las bondades que nos ofrece el framework Spring para el manejo del ciclo de vida de beans, inyección de dependencia y configuración a través de anotaciones y de archivos de configuración en XML.

Además ya hemos visto cómo trabajar con el framework Hibernate para el manejo de persistencia de nuestra aplicación. Este framework nos permite olvidarnos de escribir queries a mano para centrarnos en la lógica y el flujo de la aplicación, además de proporcionar mecanismos de caché de datos.

En este tutorial veremos cómo integrar estos dos frameworks para que Spring se encargue del manejo de las sesiones y las transacciones que Hibernate usa.

Struts 2 - Parte 7: Tags

Cuando desarrollamos aplicaciones es importante tener un buen back-end que soporte la lógica de la aplicación, y del mismo modo es importante tener un buen front-end, ya que será esta con la que nuestros usuarios interactuarán introduciendo y viendo información. Es por esto que para crear la vista (las páginas web) debemos usar un conjunto de elementos que nos permitan mostrar la información correcta, darle el formato adecuado, y realizar pequeños bloques de lógica en caso de ser necesario (ciclos, condiciones, constantes, etc.).

En el mundo web de Java estos componentes generalmente son implementados en forma de etiquetas (tags). Prácticamente todos los frameworks web de Java incluyen su propio conjunto de etiquetas que se integran perfectamente con los motores de negocio, para hacer uso de las ventajas particulares del framework. Struts 2 no es la excepción, y presenta un conjunto amplio de etiquetas para manejar la información que será presentada al cliente, y además ayudar a dar formato a los componentes de la interfaz de usuario, dándonos la libertad de elegir entre varios "modos".

En este tutorial aprenderemos a usar todas las etiquetas que Struts 2 nos proporciona actualmente, junto con algunos detalles de cada uno de los temas o layouts que nos proporciona.

Struts 2 - Parte 6: Interceptores

Al desarrollar una aplicación, es necesario desarrollar algunas funcionalidades de utilidad que nos hagan más fácil el desarrollo de los procesos de negocio en los cuales estamos interesados. Algunos ejemplos de estas funcionalidades pueden ser el verificar que el usuario haya iniciado una sesión en el sistema, o que tenga permisos para ejecutar la operación que está solicitando, convertir los parámetros de un tipo a otro (de String a Date, o a int), verificar que se hayan proporcionado los datos que son obligatorios, agregar alguna información a la sesión del usuario, etc.

La mayoría de estas funcionalidades pueden ser creadas de una forma genérica y usadas en varias partes de nuestra aplicación o en varias aplicaciones.

Struts 2 integra un mecanismo que nos permite abstraer estas funcionalidades de una manera sencilla, aplicarlas de forma transparente a las acciones que la necesiten (que pueden ser desde una hasta todas las acciones de la aplicación) y configurarlas a través del uso de parámetros.

En este tutorial aprenderemos cómo configurar los interceptores que vienen integrados con Struts 2, además de crear nuestros propios interceptores, agregarlos a un Action, y agregarlos a la pila que se aplica por default a los Actions de nuestra aplicación.

Struts 2 - Parte 5: Tipos de Results

Cada vez que un Action termina su ejecución, se muestra un resultado al usuario. Estos resultados pueden ser de muchos tipos y tener muchos significados. El tipo más común de resultado es mostrar al usuario una nueva página web cierta información, pero ¿si quisiéramos hacer otra cosa? ¿Qué ocurre si queremos regresar un archivo como texto plano? ¿Y cuando queremos regresar un archivo binario? ¿Y su necesitamos redirigir la petición a otro Action o enviar al usuario a otra página?

Los casos anteriores también son muy comunes cuando desarrollamos una aplicación web.

Struts 2 ofrece una gran variedad de tipos de Results para manejar estas y otras situaciones y que aprenderemos cómo usar en este tutorial.