Author Archives: Eugenia Pérez

About Eugenia Pérez

I'm a computer engineer and I've also studied a two-year long Msc in Web Engineering. After working as a web developer, I've been teaching programming, databases and web technologies for the last few years to students of vocational training, software specialist courses for engineers and released some publications. My Linkedin Profile

Thymeleaf #Spring MVC

Otro tema que será incluido en el libro de Spring es el motor de plantillas Thymeleaf, muy utilizado en Spring MVC

En este post hablaré de esta librería y también de sus expresiones básicas. En sucesivos posts iré ampliando su funcionalidad.

Thymeleaf es un lenguaje de plantillas que puede integrarse perfectamente con las aplicaciones Spring MVC, siendo además una nueva alternativa que está desplazando a las tradicionales páginas JSP.

Una de las mayores ventajas de Thymeleaf es, sin duda, su casi nula influencia en la apariencia de una plantilla cuando no está procesada. Es decir, un diseñador o cualquier persona que tenga que retocar el aspecto de una plantilla vería una página totalmente normal. En lugar de utilizar etiquetas especiales, Thymeleaf utiliza atributos de las etiquetas existentes para el procesamiento dinámico, dejando los valores normales de las etiquetas como valores por defecto; esto provoca que las plantillas Thymeleaf, las cuales tienen extensión HTML sean cómodamente visibles y editables offline.

Además de permitirnos cargar las plantillas Thymeleaf como vistas desde los controladores, también obtenemos las siguientes ventajas:

  • Posibilidad de utilizar el SpEL en las plantillas
  • Formularios integrados con componentes
  • Internacionalización de mensajes
  • Estructuras de control básicas
  • Etiquetas de seguridad

Para disponer de Thymeleaf en un proyecto Spring Boot basta con añadir una dependencia en el fichero pom.xml. Sin Spring Boot, sería preciso, además de la dependencia de Thymeleaf, configurar la resolución de plantillas bien a través de XML o a través de beans.

Esta línea, aunque no es imprescindible, se suele poner al inicio de las plantillas:

 <html xmlns:th="http://www.thymeleaf.org">

Thymeleaf puede procesar plantillas XML, xHTML y HTML5, válidas o no.

Expresiones básicas

El aspecto que tiene una etiqueta, por ejemplo, h1, en una plantilla Thymeleaf sería el siguiente:

<h1 th:text="#{title}">This is default title</h1>

En ese caso, se añade un atributo th:text que indica el texto que se quiere meter en la etiqueta. En este caso, el texto proviene de un mensaje configurado en los ficheros de mensajes que se utilizan en la internacionalización. En caso de no haber valor o de que la página no esté procesada por Thymeleaf, lo que se vería en el navegador sería “This is default title”.

Si ese texto contenido en la variable tuviera etiquetas HTML, estás serían modificadas. Para preservar las etiquetas y que sean interpretadas por el navegador, se debería poner

 <h1 th:utext="#{title}">This is default title</h1>

En cuanto a los tipos de expresiones que se utilizan, en resumen, serían las siguientes:

  • #{variable}: mensajes de texto de ficheros de properties.
  • ${variable}: referencia a variables y a objeto del modelo, por ejemplo, objetos que se nos pasan desde el controlador, como resultados de una consulta, una lista de entidades, un registro, etc.
  • *{campo}: un campo que forma parte de una referencia a un objeto, se aplica cuando se utiliza una expresión ${variable}, por ejemplo en los campos de un formulario.
  • @{campo}: expresiones para crear enlaces.

En el acceso a variables se utiliza el símbolo $. Por ejemplo, para sacar el atributo name de una instancia de Person:

<span th:text="${person.name}">Default name</span>

Aunque también se pueden usar los corchetes:

<span th:text="${person['name']}">Default name</span>

En el caso de querer mostrar lo que contiene un objeto o una instancia y sus campos, podemos utilizar el atributo object.

<ul th:object="${customer}">
 <li><b>Name:</b> <span th:text="*{name}">Sebastian</span>.</li>
 <li><b>Email:</b> <span th:text="*{email}">Pepper</span>.</li>
 <li><b>Address:</b> <span th:text="*{address}">Saturn</span>.</li>
</ul>

En cuanto a expresiones básicas, dentro de los atributos de Thymeleaf se pueden usar las siguientes:

  • Literales de texto o de número: ‘hello’, 42, 0, 1, -42.0
  • Literales booleanas: true, false
  • Literal nula: null
  • Concatenaciones de cadenas: +
  • Sustituciones de literales:  Hello ${name}
  • Opedores aritméticos: +, -, *, /, %
  • Conversión a negativo: -
  • Operadores booleanos: and, or, not, !
  • Operadores de comparación: >, gt, <, lt,  >=, ge, <=, le, ==, eq, !=, en
  • Operador condicional if: cond ? then
  • Operador condicional if-then-else: cond ? then : else
  • Valor por defecto: cond ?: default

Todas estas expresiones pueden utilizarse tanto en literales, como en expresiones condicionales que se verán más adelante.

<span th:text="'Hello' + ${name}">Hello</span>

En cuanto a los mensajes con traducción, en algunos casos pueden contener variables.

thanks.msg=Thanks for visiting us {0}
<h1 th:utext="#{thanks.msg(${loginname})}">Thanks dude</h1>

 <div th:unless="${#lists.isEmpty(posts)}">
   <table><tr><th th:thymeleaf"#{id}">Id</th></tr>
 </div>
facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

Java Streams

Ahí va otra mini-entrega del libro… Para que a Java le dejen de llamar el COBOL del Siglo XXI ha procurado actualizar, entre otras cosas, el tratamiento de colecciones…

El lenguaje de programación Java está evolucionando en las últimas versiones, incorporando técnicas e incluso paradigmas de otros lenguajes como la programación funcional. Una de los avances más evidentes es el tratamiento que permite hacer de las colecciones con métodos bien conocidos en otros entornos como map, filter, etc, sin la necesidad de hacer bucles. En lugar de escribir el típico bucle for para recorrer una lista, ahora se puede convertir la colección en un stream e ir aplicando filtros y funciones en una única sentencia. Esta forma de trabajar es similar a la que se utiliza en la programación reactiva, donde los datos llegan en forma de flujos. A continuación se presentan las distintas técnicas existentes en Java para el tratamiento de colecciones, las cuales nos servirán para incorporar, además de una actualización del conocimiento del lenguaje, una manera práctica de introducir el concepto de flujos o streams.

Bucles sobre colecciones
Supongamos que queremos hacer un programa que cuente los números pares de un array. Esta sería la forma clásica:

c

Desde la versión 5 de Java, existe un foreach implícito en utilizando la sentencia for, con la cual se puede ahorrar el tratamiento de índices.

Otra forma peculiar es aplicar el foreach directamente sobre la colección, cosa que en otros lenguajes (Ruby, JavaScript) es algo de lo más natural. En el caso de Java, nos obliga a crear una instancia de Consumer con el método accept para tratar cada elemento.

Streams sobre colecciones
Hay una manera de hacerlo con una única línea. Se trata de usar los streams. Desde la versión 8 de Java, las colecciones pueden convertirse en streams invocando simplemente el método stream(). A partir de ahí, se pueden aplicar filtros, agrupaciones y toda clase de modificaciones. Este sería el ejemplo más simple. Convertimos la colección a Stream y a cada elemento se le aplica el println para mostrarlo por pantalla.

Volviendo al problema de contar los números pares, utilizando streams nos basta con una línea de código.

Otra técnica que se puede usar parallelStream, el cual procesa varios elementos de la colección a la vez. Según lo que querramos obtener no siempre será lo aconsejable.

Map nos permite aplicar una función a cada elemento, en este caso tomamos cada entero , lo convertimos a String, luego a Float, y finalmente retornamos una lista de Float.

Mediante filter, podemos aplicar un filtro a cada elemento para que se selecionen únicamente aquellos que cumplan con esa condición, y mediante el collect convertimos todos esos elementos en una lista.

Además de aplicar filtros, también se puede aplicar al final el método size para obtener simplemente el total de valores que cumples la condición de filtrado.

Si queremos sacar determinados valores pero solamente cierto número de ellos, se pueden aplicar distintas funciones:

  • limit(n): en lugar de tratar todos los elementos se limita a n.
  • skip(n): permite saltar n elementos del Stream.

Una forma de convertir la lista a una cadena, aplicando el formato que queramos, es mediante la conversión a String y aplicando una unión (collect) de todos los elementos con una cadena de unión concreta.

Otra función obvia es la de suma.

Mediante collect podemos unir todos los elementos en uno aplicando distintas funciones. En este caso, se suman todos los valores de la colección.

También al stream se le pueden sacar valores concretos como el máximo y el mínimo:

En el tratamiento de Streams también existe un método por defecto que nos ofrece una instancia de IntSummaryStatistics, que, como su nombre indica, contiene información sobre la colección, como número de elementos, tipos, etc.

En el caso de tener, ya no un conjunto de números sino un conjunto de listas de números, se puede aplicar el aplanado de la misma (flatten), es decir, múltiples listas que se convierten en una.

También se pueden crear agrupaciones y formar otras estructuras de datos. En el siguiente ejemplo, la lista de números se agrupan en una estructura Map.

…That’s all forks!
facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

Is Docker… Dead?

Recientemente leía un post a través de Linkedin con el llamativo título de “Docker is dead”. En una época donde hay tanta información y donde se confrontan muchos puntos de vista son frecuentes este tipo de afirmaciones cuando menos temerarias. A veces no son más que anzuelos que derivan en interminables discusiones para solaz del autor que ya ha conseguido su propósito de atraer visitas.

Como todas las tecnologías, Docker no es mejor o peor por definición, sino que depende de las situaciones concretas para poder hablar de su idoneidad.

Así como la virtualización ha traído evidentes beneficios para facilitar la administración de sistemas, Docker ha supuesto un antes y un después en el despliegue de aplicaciones, permitiendo una flexibilidad y una optimización sin precedentes.

Docker es una vuelta de tuerca más en la virtualización, ya que nos permite empaquetar cualquier tipo de aplicación para ser ejecutado en un servidor Docker. La ventaja es que una aplicación Docker no necesita toda la infraestructura extra de una máquina virtual, sino que esta es compartida por todas las aplicaciones o containers Docker en ejecución. La diferencia entre la virtualización tradicional y Docker sería la que muestra la siguiente imagen:


Pero ¿Qué tipo de aplicaciones pueden definirse en una imagen Docker? Prácticamente cualquiera: desde un “Hello World”, un shell de linux, un sistema Ubuntu, un MySQL, un Apache, una aplicación RoR y por supuesto una aplicación Java. Cualquier programa puede ser containerizado, facilitando enormemente su ejecución en cualquier parte. De ahí viene el apropiado concepto de container presente en el logotipo de Docker: si todo lo que se transporta tiene una forma estándar, vaya a donde vaya se podrá manipular de forma previsible.  Además, un proyecto puede distribuirse en uno o varios containers funcionando conjuntamente.

Aparte de las ventajas evidentes para la gestión de aplicaciones, la tecnología basada en containers se ajusta perfectamente al modelo de desarrollo de microservicios. Y por si eso fuera poco, también facilita la vida de los desarrolladores, permitiendo crear entornos de desarrollo de forma mucho más flexible y adaptable a cualquier equipo y de definir procesos de integración más fiables.

Imágenes y containers

Estos son dos conceptos clave en Docker. Una imagen es una plantilla que define cómo debe ser la aplicación. Generalmente parte de una base, se le aplican unas personalizaciones, unos comandos de inicio, se copian unos ficheros, etc. todo ellos especificados en un sencillo fichero de texto llamado Dockerfile. Existen repositorios públicos de imágenes como dockerhub, de donde pueden descargarse o subirse imágenes Docker.

El container es una imagen Docker en ejecución. En cierto modo, como se diría en la jerga del programador la imagen es la clase y el container una instancia, y obviamente, se pueden tener muchos containers de una misma imagen.

Para crear la imagen hay que tener en cuenta qué es lo que necesita nuestra aplicación. ¿Un shell? ¿un intérprete o un compilador de algún lenguaje? Se define el entorno necesario, se ajusta, se añade el código de la aplicación, se compila o se prepara y se da la orden de ejecución.

En cuanto se ejecuta la imagen se crea un container Docker y este encajará en cualquier entorno de ejecución de containers: desde nuestro entorno de desarrollo a proveedores como AWS o Azure.

Creando una imagen de Spring Boot

¿Qué es lo que se necesita para ejecutar una aplicación Java? El JDK. ¿Y para compilar una aplicación Spring Boot? Maven o Gradle, basándose en Java. El siguiente entorno instala una imagen base de Openjdk en un Linux, instala Maven, indicar un directorio de trabajo, copia el código fuente de nuestra aplicación, la compila y empaqueta con Maven y define el punto de inicio del container: la ejecución de la propia aplicación.

Para definir todo eso, creamos el siguiente fichero Dockerfile dentro de la raiz de un proyecto Spring Boot.

Dockerfile

FROM java:8
RUN  apt-get     update
RUN  apt-get     install -y    maven
WORKDIR  /app
COPY pom.xml    /app/pom.xml
COPY src   /app/src
RUN  ["mvn",     "package"]
ENTRYPOINT     ["/usr/lib/jvm/java-8-openjdk-amd64/bin/java",  "-jar",      "target/s04.hellorest-0.0.1-SNAPSHOT.jar"]

Para crear la imagen se pueden usar todo tipo de comandos, pero el ENTRYPOINT se ejecuta cuando se inicia el container.

Una vez definido el fichero Dockerfile, pasamos a crear la imagen con el comando docker build. La primera vez que se haga docker necesitará descargarse todo aquello que no tenga localmente, por lo que el proceso puede durar unos minutos.

eugenia@localhost:~/spring$ docker build -t spring-boot-eu
Sending build context to Docker daemon 58.88 kB
Step 1 : FROM java:8
8: Pulling from library/java
5040bd298390: Downloading 517.7 kB/51.36 MB
fce5728aad85: Downloading 1.375 MB/18.54 MB
76610ec20bf5: Downloading 432.7 kB/42.5 MB
60170fec2151: Waiting
e98f73de8f0d: Waiting
11f7af24ed9c: Waiting
49e2d6393f32: Waiting
bb9cdec9c7f3: Waiting Downloaded:
…
 https://repo.maven.apache.org/maven2/com/google/guava/guava/11.0.2/guava-11.0.2.jar (1610 KB at 151.1 KB/sec)
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 15:05.898s
[INFO] Finished at: Sun Jan 28 11:41:59 UTC 2018
[INFO] Final Memory: 28M/115M
[INFO] ------------------------------------------------------------------------
 ---> a6435b21dc60
Removing intermediate container 083cea6047a4
Step 8 : CMD ["/usr/lib/jvm/java-8-openjdk-amd64/bin/java",     "-jar", "target/      s04.hellorest-0.1.0.jar"]
 ---> Running in 6f7d2aae0da7
 ---> a494450a2271
Removing intermediate container 6f7d2aae0da7
Successfully built a494450a2271
…

Cada una de las líneas de Dockerfile supone una capa o layer y estas, una vez creadas no necesitan volver a crearse. Solamente la capa superior, la de la ejecución es la que se tiene que recrear. Por lo tanto, tras el primer build los siguientes serán muchísimo más rápidos. Y lo que es mejor aún, las capas son compartidas por todas aquellas imágenes que les hagan referencia, por lo que un conjunto de aplicaciones spring-boot compartirán las primeras capas y no precisarán ni descargar ni ocupar espacio extra.

Ahora ya podemos ejecutar la aplicación creando el container docker con docker run:

eugenia@localhost:~/spring$  docker run -p 8080:8080 -i -t spring-boot-eu myapp

Las opciones incluidas en el comando son:

  • -p 8080:8080: mapea el puerto 8080 del container con el del host, para poder acceder desde fuera.
  • -i: modo interactivo, deja la ejecución del container en primer plano y veremos los logs de tomcat. Otra opción más habitual sería -d, la cual dejaría el container en segundo plano.
  • -t spring-boot-eu: la imagen que queremos ejecutar.
  • myapp: el nombre que le damos a la imagen.

Si lo ejecutamos en modo -d, podemos verificar que el container está en marcha con docker ps:

eugenia@localhost:~/spring$ docker run -p 8080:8080 -d -t spring-boot-eu myapp
b4b907baac10dc77fea998b293736a28197377650faf1410b47d31b0dc20563f
eugenia@localhost:~/spring$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
b4b907baac10        spring-boot-eu      "/usr/lib/jvm/java-8-"   7 seconds ago       Up 6 seconds        0.0.0.0:8080->8080/tcp   berserk_goldstine
eugenia@localhost:~/spring$

Y en cualquier caso, esto es lo que veremos en el navegador. La aplicación Spring Boot containerizada y respondiendo en el puerto 8080.

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

[Offtopic] #Bilbostack2018

El próximo sábado va a tener lugar en Bilbao el evento Bilbostack, que es un conjunto de conferencias de diversas temáticas y tecnologías, entre las cuales pueden resultar interesantes para desarrolladores las que tratarán sobre el Framework JavaScript VUE, la etiqueta HTML <canvas> o la retrospectivas de equipos ágiles. Para los que no hayan oído hablar de VUE es un Framework JavaScript de creciente popularidad cuya adopción a día de hoy parece estar solo por detrás de React.

La charla parece especialmente interesante porque en lugar de ser la típica introducción a conceptos básicos se enfocará más a problemas frecuentes y herramientas que ayuden en las tareas diarias de desarrollo.

Como curiosidad destacar que entre las ponentes hay mayoría de mujeres, algo de agradecer en estos tiempos que está tan de actualidad la presencia femenina en el sector tecnológico.

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

El proyecto Lombok

Otro tema del que se está profundizando en el libro de Spring es Lombok…

Lombok es un proyecto que facilita el mantenimiento de los POJOs (Plain Old Java Object). Básicamente consiste en añadir una serie de anotaciones mínimas a la clase para que de manera automática se generen los métodos set/get, constructores, toString, y lo que necesitemos, incluyendo opciones variadas.

La ventaja de Lombok es que desarrollamos POJOs que solamente consisten en clases con atributos y en el editor de código no veremos más que:

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import lombok.Data;

@Entity

@Data

public class Customer {

  @Id

  @GeneratedValue(strategy=GenerationType.AUTO)

  private int id;

  private String name;

  private String address;

}

Lombok se encarga de que se generen los métodos necesarios, y aunque no los veamos ahí el resto de clases son conscientes, en tiempo de compilación, de que esos métodos existen. En un proyecto Maven, de hecho, esos métodos se crean dentro de la carpeta target.

Y de forma transparente, cada vez que se retoca algo en esos atributos, los métodos necesarios se regeneran y el desarrollador no se tiene que molestar.

Cómo configurar Lombok

Para utilizar Lombok se deben hacer dos cosas:

  1. Incluir la librería en el proyecto
  2. Configurar lombok en el entorno de desarrollo

Incluir la librería es relativamente sencillo si se utiliza un gestor de proyectos como Maven o Gradle. En Maven, por ejemplo, basta con añadir esta dependencia:

<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
</dependency>

En cuanto a la configuración, puede variar un poco según el IDE. Para eclipse, debemos descargarnos un JAR de la web de lombok:

https://projectlombok.org/downloads/lombok.jar

Y a continuación ejecutarlo

java -jar lombok.jar

Nos aparecerá un pequeño diálogo donde le debemos indicar el directorio donde se encuentra Eclipse mediante el botón Specify Location y a continuación pulsar Install/Update…

Lombok modificará lo necesario y una vez reiniciado Eclipse ya tendremos soporte para aplicar esta herramienta.

Algunas opciones

Lombok dispone de variadas anotaciones en caso de que tengamos necesidades específicas.

  • @Data: es la anotación básica con la que obtenetemos métodos set/get, toString, un constructor con todos los campos y los métodos equals y hashCode.
  • @Log4j: nos da el acceso a este tipo de loggers.
  • @NoArgsConstructor: genera un constructor sin argumentos, necesario si se ha puesto otro constructor. Los ORM como Hibernate necesitan el constructor vacío.
  • @EqualsAndHashCode: genera los métodos equals y hashCode, permite exluir campos:
  • @EqualsAndHashCode(exclude = {“director”,”cast”})
  • @ToString: genera el método toString y tambien permite excluir campos, ideal para evitar bucles cuando hay dependencias.

La referencia completa se encuentra en:

https://projectlombok.org/features/all

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

Spring Microservices

Seguramente ya hayas oído hablar del concepto de microservicios y, ciertamente, es una de esas nuevas tendencias, que tanto abundan en el ámbito del desarrollo, que aparentemente se pone tan de moda que hace que muchos profesionales se empeñen en cambiar sus sistema actual pese a que no encaje dentro de esa nueva tendencia. Como suele pasar, el desarrollo de aplicaciones mediante microservicios no es mejor o peor, es simplemente otra manera de organizar un sistema que según cada caso resultará en más eficiente o no.

Los microservicios no son una tecnología propietaria, por tanto los cánones que marcan qué es un microservicio y qué no lo es no están establecidos por ninguna entidad en particular. Sin embargo, existen una serie de principios que se cumplen de forma regular en la mayoría de ellos, y que aprovechan el auge de tecnologías como los containers, la computación en la nube y el perfil de DevOp.

¿…Pero qué son…?

Tradicionalmente se procuraba construir aplicaciones desarrollando componentes, con el objetivo de crear un sistema desacoplado y donde esos componentes trabajaban de forma cohesionada y eran fácilmente sustituibles. El objetivo final, siempre era el mismo,  facilitar el mantenimiento y mejora de ese sistema. Sin embargo, en esta era en la que disponibilidad y el tiempo de respuesta se hacen tan cruciales, donde hay infinidad de aplicaciones a las que acceden millones de usuarios en todo el mundo, los sistemas pueden tener un punto débil: ser sistemas monolíticos. Y esto, puede provocar en muchos casos, que para cada modificación haya que cambiar el sistema entero, aunque solo se haya retocado un pequeño componente (si bien es cierto que en la nube hay sistemas que facilitan que ese cambio sea transparente).

Por lo tanto, curiosamente puede darse la circunstancia de que un equipo de ingenieros desarrollen un sistema con una arquitectura más limpia que una patena con una cobertura de código de 100% y un build con integración continua que funcione como un reloj… Pero su sistema sea ¡monolítico!. Al igual que ocurre con los coches, aunque estén hechos a base de componentes reemplazables, si se les añade una mejora el coche tendrá que ir a boxes con la consecuente parada, aunque sea de unos segundos. ¿Imaginas que pudieras cambiar una rueda con el coche en movimiento?

Eso es lo que facilitan los microservicios. En lugar de centrarse simplemente en los componentes, los sistemas se dividen en servicios independientes. Esos servicios, internamente tendrán su organización y componentes, pero a diferencia de los sistemas monolíticos, se pueden “implantar/iniciar/parar/cambiar” de manera, precisamente, independiente y sin afectar al resto de servicios. Esto además, tiene otra ventaja derivada, cuando una aplicación tiene mucha carga de acceso, podemos crear nuevos nodos/instancias/containers de forma automática y segura al superar determinados umbrales programados. Al ser un sistema monolítico, aunque sea un container (Docker), resulta que estamos clonando la aplicación completa, y con una arquitectura de microservicios tenemos la granularidad, si es aplicable, para poder clonar los microservicios que tengan mayor demanda. Por ejemplo un sistema puede tener momentos donde necesite dar respuesta a la parte de altas de usuario, y en otros momentos tener más carga en el servicio de envío de mensajes.

De todo esto se hablará en el libro que será proximamente publicado, dado que es un tema en el que actualmente estoy profundizando…

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

Edición de Spring

Hacia finales de Febrero tendremos el borrador de un nuevo libro basado en la última versión del Framework de Spring. Este libro, que será publicado por Anaya, incluye las características novedosas de la versión 5.0, así como multitud de ejemplos para clarificar cada uno de los capítulos de los que consta. Como siempre nos encontramos derrochando ilusión, esfuerzo y buenas prácticas.

Si quieres saber más acerca del mismo te dejo la reseña y el índice de contenidos que seguirá.

La reseña del editor

El perfil de desarrollador Java es uno de los actualmente más demandados siendo Spring, junto con otras tecnologías como Hibernate, los líderes indiscutibles entre las tecnologías para el desarrollo de aplicaciones empresariales. Adicionalmente, dado que conceptos tales como la inyección de dependencias, aspectos, patrones como MVC y el uso de frameworks de mapeo de bases de datos a entidades, se encuentran presentes en muchos otros lenguajes, entornos y frameworks, podemos considerar que el desarrollo de aplicaciones con Spring abre puertas tanto a la adquisición de conocimientos valiosos como de nuevas oportunidades laborales.

 El libro comienza sentando las bases mediante los conceptos esenciales de Spring, presentando además las facilidades que ofrece Spring Boot, sin perder de vista las configuraciones tradicionales que todavía se pueden encontrar en muchos proyectos existentes. A continuación se adentra en la programación orientada a aspectos y en la gestión de datos, tanto relacionales como NoSQL, que serán contenidos clave para posteriormente presentar el desarrollo de aplicaciones web con Spring MVC. Adicionalmente, se presentan una serie de funcionalidades extra que actualmente ofrece el framework para acceder a servidores de todo tipo, crear tareas batch, y mostrar las nuevas tendencias de desarrollo con Reactive Spring, testing así como distintos escenarios de implementación.

 En cada capítulo se presentan proyectos de muestra, desde ejemplos sencillos que permiten asimilar contenidos esenciales así como proyectos progresivamente más complejos que van abarcando las distintas áreas de Spring. Por lo tanto, el presente libro permite que tanto aquellas personas que no tengan grandes conocimientos previos puedan iniciarse en el desarrollo de aplicaciones empresariales con el framework, como la posibilidad de ofrecer a desarrolladores más experimentados una actualización a la versión 5 de Spring.

Índice de contenidos

1.       Fundamentos de  Spring
 1.1       Inversión de dependencia
 1.2       Inyección por XML
 1.3       Autowiring
 1.4       Colecciones
 1.5       SPeL
 1.6       Spring Boot
 1.7       Ciclo de vida
 1.8       Ámbito
 1.9       Configuración
 1.10     Properties
 1.11     Profiles
2.       Aspectos
 2.1       Programación orientada a aspectos
 2.2       Aspectos con Spring
3.       Acceso a datos
 3.1       JPA
 3.2       Mapeos de relaciones
 3.3       Queries avanzadas
 3.4       NoSQL
4.       Spring MVC
 4.1       Controllers
 4.2       Plantillas
 4.2.1       Thymeleaf
 4.2.2       Mustache
 4.3       Internacionalización
 4.4       Validación
 4.5       Seguridad
 4.6       Recursos REST
5.       Reactive Spring
6.       Spring para servicios específicos
 6.1       Email
 6.2       Colas de mensajes
 6.3       Websockets
 6.4       Spring Batch
7.       Testing
 7.1       Test unitarios
 7.2       Test de modelos
 7.3       Test de controladores
 7.4       Test de integracón
8.       Deployment
 8.1       Spring Docker
 8.2       Microservices
facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

An upcoming book on Spring 5

By the end of summer the book titled “Java Limpio” was released. In the first third of the book the Java programming principles are covered with many specific details of the language. Then the attention is focused in the good programming practices that every single developer should master, despite the language is used: unit testing, refactoring, patterns, clean code, solid principles, lean and Scrum methodology. Actually the lack of technical disciplines makes the agile process to become just a simple business process without the ultimate goal: to make better software.

To become a good developer you should create maintainable, easy-to-read and clean code following good practices, and that is what Software Craftmanship is all about. But it is also necessary to know which tools could make our software easier to be developed and maintained. Anytime you are programming enterprise applications or any other kind of projects accessing data you will be applying common patterns such as MVC, DAO and dependency injection tools. There are frameworks for every language, but when it comes to Java, the indisputable leader after more than a decade is Spring.

At its core, Spring is a dependency injection framework that provides support for any features an application may need, such as database access, web development, aspects, and it is capable of work with many other available frameworks like Hibernate. For any developer willing to work with enterprise Java environment, Spring is a must, as well as other usual companions like Hibernate, and tools like Maven, Gradle, Git, etc. And whatsmore, all the technologies that have emerged over the last decade around the web, the noSQL databases and the like, are already available to be integrated with this framework.

According to this, we are preparing a book about Spring that hopefully will become a useful guide for modern JEE development. We have experience as a developers and also as teachers and mentors of these technologies, with other works published around these particular area. That allows us to meet the requirements not olny for developers looking for thorough references but also for those who are new to this software ecosystem.

This work will be long enough for those who need a first dive as well as deep enough for the already initiated that need updates on version 5 of Spring. Therefore the basic principles of dependency injection, aspects, data access, inversion of control, MVC projects and REST resources are covered throughout the book. In addition to that, a wide variety of areas will be exposed as Spring boot, different template engines, reactive spring, etc. Always showing simple proof of concept projects to quickly understand the idea; so once you get the ball rolling we will show how to implement complex developments involving different elements of a JEE project.

Eat your own dogfood

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

My recently released books & Building embedded forms with Symfony2

Since two of the books I’ve writing this year are almost ready to go and one of the others is been reviewed by the editors, I’m already working on a new book on Symfony3 Framework. In these two covers, there are still some typos which have been already fixed (I’m sure you’ve already notice that my name shows up as Maria Eugenia? If you know me a little, I guess that you’re laughing right now because you know how much this bothers me… ;-)  )

As it is known, Symfony is one the most widely used frameworks for PHP. As many others it implements the very popular MVC pattern. As all you probably know in this pattern Controllers send data wrapped up in models which then are used by views to present information to the final users. In a web app forms commonly needed to both present and collect data. Forms are linked to models, however sometimes it can be useful to build a form which is intended to pick up information of more than one model. In this context embedded forms play a key role. Let’s assume that we’d like to have a form where users can create tweets and link them to a specific category. Moreover this category has to be one of the many stored in a table of a database. In this scenario a form built for a Tweet class is not enough. We need some kind of hybrid form made up for two classes: Tweet and Category.

Symfony2 includes a special type of field called Entity. This field is a choice field and needs to be related to a class persisted by Doctrine to get the collection of possible values from the table of the database.

The class bellow extends from AbstractType and its goal is to render a form for a Message (Tweet Class). Pay attention to the lines marked in bold related to the Entity field to create a select control to display all the possible categories.

/**
 * Class to centralize the creating of message related forms.
 *
 * @author Eugenia Pérez
 */
class MessageType extends AbstractType {

    /**
     * Creates a new form object to create messages.
     *
     * @param type $action
     * @return type
     */
    public function buildForm(FormBuilderInterface $builder, array $options) {
        $builder
                ->add('message', 'text', array('label' => 'Message:'))
                ->add(MessageController::SAVE_BTN, 'submit', array(
                    'label' => 'Post',
                    'attr' => array('class' => 'btn btn-sm btn-info')))
                ->add(MessageController::HIGHLIGHT_BTN, 'submit', array(
                    'label' => 'Post & Highlight',
                    'attr' => array('class' => 'btn btn-sm btn-success')))
                ->add('tag', 'entity', array(
                    'class' => 'AppBundle:Tag'));

        if ($options != null && $options['action'] != null) {
            $builder->setAction($options['action']);
        }
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver) {
        $resolver->setDefaults(
array('data_class' => 'AppBundle\Entity\Text'));
    }

    public function getName() {
        return 'message';
    }

}

Once this is set up, taking care of the data send by the client needs no especial handling. It’s just a regular action that uses the handle request method to read the data and then Doctrine takes control of it to persist the Message Entity including the link to the Category selected by the user.

/**
     * Receives the data sent by the user to create a new message.
     *
     * @Route("/message", name="new_message")
     * @Method({"POST"})
     */
    public function createAction(Request $request) {
        $text = new Text();

        $postForm = $this->createForm(new MessageType(), $text);
        $postForm->handleRequest($request);

        if ($postForm->isValid()) {
            $text = $postForm->getData();
            $text->setCreationDate(new DateTime());

            $em = $this->getDoctrine()->getManager();
            $em->persist($text);
            $em->flush();
            return $this->render('alert/success.html.twig', array('info' => 'Message published successfully'));
        } else {
            return $this->render('message/index.html.twig', array(
                        'postForm' => $postForm->createView()));
        }
    }

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather

Gaining momentum with Symfony2

I cannot yet reveal too much about the 3 technical books that I’m going to publish, but they will be pretty soon available to the public. So I’ve decided to write another tech book with practical concerns and real-world apps, based on the Symfony Framework. Hoping it’ll be an ideal complement for vocational education and training sector teachers to give server-side software development lessons based on PHP and also for those who want to achieve the SensioLabs Symfony Certification.

Since there are 16 topics in this certification test, I’m trying to structure a reference book guide close to that kind of structure, in order to facilitate a proper tracking and a a successful preparation (with determination…) Topics are basically these ones: https://sensiolabs.com/en/symfony/certification.html

Some of the features that have caught my attention after deepening, elaborating and enriching the contents are:
- A cool feature that Twig provides is what it’s called filters. What this means is that Twig provides a mechanism to transform the content which is going to be displayed just before it happens. This is something that some other frameworks also include like for example AngularJs, while the latter does it client-side. There are some built-in filters which you can use just out the box, such as upper, lower, etc.

{% extends 'base.html.twig' %}

{% block title %}Days of the week!{% endblock %}
{% block body %}
    <p>The days of the week are:</p>
    <ol>
        {# Prints out the list of days #}
        {% for day in daysOfWeek %}
            <li>{{day | upper}}</li>
         {% endfor %}
    </ol>
{% endblock %}
{% block footer %}
    {{parent()}}
    <span><a href="http://eugeniaperez.es">EugeniaPerez.es</a>
{% endblock %}

- As all we know web apps are accesed using a wide range of devices. Mobile devices are widely used by users to consume contents. This is why it’s essential to provide a convenient way to browse our sites. With Symfony and its routing module we can easily determine what kind of device is behind an HTTP request. Of course this can be done inspecting the User Agent HTTP header. In that way we can search for keywords such as Android, IOS and so on to identify mobile devices.

/**

* Returns the product details for mobile devices.

* @Route("/products/{id}", requirements={ "id" : "\d+" },

* condition="request.headers.get('User-Agent') matches '/Android/i'")

*/

public function mobileShowAction($id) {

     return new Response('<h1>Mobile version site</h1>Product #' . $id .'requested');

}

/**

* Returns the product details.

* @Route("/products/{id}", requirements={ "id" : "\d+" })

*/

//@Route("/products/{id}", requirements={ "id" : "1|2" })

public function showAction($id) {

     return new Response('Product #' . $id . ' requested');

}

With the condition presented above we are matching all the incoming devices that contain Android in their User Agent. Then we can have another action without the condition to serve contents to the rest of the clients.

facebooktwittergoogle_plusredditpinterestlinkedinmailby feather