Construcción de Microservicios con Java

En este capítulo se va cubrir los siguientes puntos:

 Crear un proyecto template usando STS y Maven

 Escribir microservicios con Spring Boot

 Escribir REST APIs con Spring MVC

 Escribir microservicios con WildFly Swarm

 Escribir microservicios con Dropwizard

 Escribir REST Apis con SparkJava

Los microservicios han ganado mucha tracción recientemente. Una

arquitectura basada en microservicio es una forma de diseñar su
software. En tal arquitectura, las aplicaciones se dividen en
servicios más pequeños para que puedang implementarse y
administrarse por separado.

Esto quita muchos puntos de error que ocurren en las aplicaciones

monolíticas tradicionales. Dicho esto, los microservicios pueden
construirse utilizando cualquier lenguaje de programación. De
hecho, hay muchas bibliotecas y framewroks que ayudan a los
programadores a crear microservicios utilizando Java, Scala, C #,
JavaScript, Python, Ruby, etc. En este libro, nos centraremos más
en la creación y el despliegue de microservicios con Java.
Introducción
En un diseño tradicional basado en microservicios, las
aplicaciones monolíticas se dividirán en servicios más pequeños
que pueden comunicarse con otros servicios, ya sea en un modelo
síncrono o asíncrono, según el caso de necesidad y uso. La primera
pregunta que cualquier persona tendría al desglosar las
aplicaciones monolíticas es "¿cuáles son los servicios potenciales
en los que se puede desglosar mi aplicación?" No hay una regla
general o una respuesta directa a esto. Pero por lo general, se
buscan funcionalidades independientes. Cada funcionalidad puede
considerarse como un servicio propio.

Para ilustrar esto, echemos un vistazo a una aplicación de ejemplo

y veamos cómo podría dividirse en microservicios más pequeños,
manejables y desplegables. La aplicación de muestra que veremos es
una aplicación de seguimiento de motociclistas. Esta aplicación
tendrá las siguientes funcionalidades:

 Interfaz web para monitorear el progreso del usuario en un

mapa.

 API REST para consumir los datos de geo localización del

usuario constantemente

 Código de análisis para realizar cálculos de sugerencias de

rutas de ciclismo, predicciones meteorológicas, sugerencias
de equipo de ciclismo, calorías quemadas, consumo de agua,
etc.

Veamos cómo esta aplicación podría haber sido diseñada como una
aplicación monolítica:
Como puede ver, toda la aplicación se incluye como un artefacto y,
por lo tanto, promueve un único punto de falla (SPOF). Si, por
algún motivo, el código analítico bloquea su JVM, perderemos la
interfaz web, las API REST y los análisis en general. Ahora,
echemos un vistazo a cómo esto podría dividirse en microservicios
manejables:

En este diagrama de arquitectura, puede ver que todas y cada una

de las funciones se implementan como su propio microservicio. Las
implementaciones del servicio se dividieron en un Servicio de
notificaciones, que se encargará de enviar notificaciones a los
usuarios, y el Servicio de localización geográfica, que realiza un
seguimiento de la geo localización.

(Latitud y longitud) Información de todos los usuarios. El código

de Analytics se ha dividido en sus propios microservicios.
Entonces, si un tipo de microservicio analítico se desactiva, los
otros microservicios seguirán funcionando correctamente. Es
posible que hayas notado que faltan las API REST. En realidad no
faltan, sino que se integran en sus respectivos microservicios.

Ahora no perdamos más tiempo y saltemos directamente a la

construcción de una parte de esta aplicación. Para poder ilustrar
los conceptos extensos que ofrece este libro, he elegido el
servicio de rastreo de geo localización como nuestro microservicio
de ejemplo. Este servicio será responsable de recopilar la geo
localización de todos los usuarios de esta aplicación y luego
almacenarlos en un almacén de datos.

Creando una plantilla de proyecto usando STS y Maven

Crear un proyecto para su microservicio no es diferente a crear un
proyecto Java simple.

Usaremos Maven como nuestro framework de compilación, ya que se

considera uno de los frameworks de compilación más populares. Si
se siente cómodo utilizando otros frameworks, como Gradle, SBT o
Ivy, siéntase libre de usarlos. Pero tenga en cuenta que las
recetas de este libro utilizarán Maven extensivamente. A menos que
sea un experto en su framework preferido, le recomiendo usar
Maven.

Preparándome
Para crear su proyecto de microservicio, necesitará el siguiente
software. Siga las instrucciones en sus respectivos sitios web
para instalarlos:

 JDK 1.8+

 Maven 3.3.9+

 Spring Tool Suite (STS) 3.8.0+

Asegúrese de que tanto Java como Maven estén en su variable PATH

para que pueda usar los comandos java y mvn en cada shell de
terminal sin tener que establecer PATH cada vez. Spring Tool Suite
es una versión sofisticada de Eclipse que tiene muchos
complementos y extensiones de Spring. Si está familiarizado con
otros IDE, siéntase libre de usarlos. Pero por familiaridad, este
libro utilizará STS para todas las recetas.

Cómo hacerlo…
Una vez que haya instalado el software mencionado anteriormente,
abra Spring Tool Suite. La primera vez que lo abra, se le pedirá
que elija un espacio de trabajo. Continúa e ingresa la ubicación
de tu área de trabajo En esta receta, aprenderemos cómo crear una
plantilla de proyecto Maven utilizando STS y Maven. STS viene con
la integración de Maven fuera de la caja. Así que no tenemos que
configurarle algo más. Después de que su STS IDE haya completado
el inicio, siga los pasos a continuación

Instrucciones para crear un nuevo proyecto de Maven:

1.- en la pantalla de STS, clic derecho sobre Package Explorer,

seleccione New, y selecciona Maven Project, como se muestra a
continuación:

2.- Esto abrirá una ventana emergente que le permitirá elegir el

tipo de proyecto de Maven que le gustaría crear. Omitiremos la
selección del arquetipo al marcar la casilla que dice Crear un
proyecto simple (omitir la selección del arquetipo) y luego
presionar Siguiente:
3.- En la siguiente ventana, ingresar el siguiente detalle para
crear tu proyecto:

 Group Id: com.packt.microservices

 Artifact Id: geolocation

 Name: geolocation

4.- después de haber ingresado el detalle, pulsar en finalizar.

5.- Esto creará un módulo

JAR de Maven simple con
todos los directorios
necesarios en su lugar.
Dependiendo de su
configuración IDE, STS
configura su nuevo proyecto
con la versión Java
predeterminada. Si no ha
configurado ningún valor
predeterminado, configurará
su proyecto con Java 1.5.
Puede verificar esto verificando la estructura de su proyecto en
STS. La siguiente captura de pantalla muestra que STS usa Java 1.5
para su proyecto:
6.- Usaremos las expresiones lambda de Java 8 en otros capítulos.
Así que vamos a cambiar la versión de Java de 1.5 a 1.8. Para
cambiar la versión de Java, configuraremos el maven-compiler-
plugin en el archivo pom.xml. Agregue la siguiente sección de
código a la sección del proyecto de su archivo pom.xml:

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

7.- Guarde su archivo pom.xml, haga clic con el botón derecho en

su proyecto, elija Maven y luego presione Actualizar proyecto...o
use el método abreviado de teclado Alt + F5. Esto cambiará
automáticamente la versión de Java de tu proyecto a 1.8.

8.- Nuestro proyecto microservicios está ahora listo para jugar.

Hay más…

Si está más cómodo usando la línea de comandos para crear

proyectos de Maven, escriba el siguiente comando en su terminal
para crear el nuevo proyecto:

mvn -B archetype:generate
-DarchetypeGroupId=org.apache.maven.archetypes \
-DgroupId=com.packt.microservices -DartifactId=geolocation \
-Dname=geolocation

Después de que Maven cree el proyecto, debería poder importar su

proyecto a su IDE.

Como esto está fuera del alcance de este libro, no veremos cómo
importar un proyecto Maven existente en su IDE.

Escribir microservicios con Spring Boot.

Ahora que nuestro proyecto está listo, veamos cómo escribir

nuestro microservicio. Hay varios frameworks basados en Java que
te permiten crear microservicios. Uno de los marcos más populares
del ecosistema Spring es el framework Spring Boot. En esta receta,
lo haremos. Observe cómo crear una aplicación de microservicio
simple utilizando Spring Boot.

Preparándome

Cualquier aplicación requiere un punto de entrada (Entry Point)

para iniciar la aplicación. Para las aplicaciones basadas en Java,
puede escribir una clase que tenga el método principal (main) y
ejecutar esa clase como una aplicación Java.

De manera similar, Spring Boot requiere una clase Java simple con
el método principal para ejecutarlo como una aplicación Spring
Boot (microservicio). Antes de comenzar a escribir su
microservicio Spring Boot, también necesitará algunas dependencias
de Maven en su archivo pom.xml.

Como hacerlo…

1. Crear una clase Java called (llamada)

package com.packt.microservices.gelocation;

public class GeoLocationApplication{

public static void main(String[] args){

//left empty intentionally

 }

2. Ahora que tenemos nuestro proyecto de plantilla

básica, hagamos de este proyecto un proyecto
secundario del módulo pom de spring-boot-starter-
parent. Este módulo tiene muchas configuraciones de
requisitos previos en su archivo pom.xml, lo que
reduce la cantidad de código repetitivo en nuestro
archivo pom.xml. En el momento que se escribió esto,
1.3.6.RELEASE fue la versión más reciente:

<parent>

<groupId> org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version> 1.3.6.RELEASE </version>

</parent>

3. Después de este paso, es posible que desee ejecutar

una actualización de Maven en su proyecto, ya que ha
agregado un nuevo módulo principal. Si ve alguna
advertencia sobre la versión del complemento
compilador de maven, puede ignorarlo o simplemente
eliminar el elemento <version> 3.5.1 </version>. Si
elimina el elemento de versión, realice una
actualización de Maven después.

4. Spring Boot tiene la capacidad de habilitar o

deshabilitar módulos Spring como Spring MVC, Spring
Data y Spring Caching. En nuestro caso de uso,
crearemos algunas API REST para consumir la
información de geolocalización de los usuarios. Así
que necesitaremos Spring MVC. Agregue las siguientes
dependencias a su archivo pom.xml:
<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

</dependencies>

5. También debemos exponer las API utilizando servidores

web como Tomcat, Jetty o Undertow. Spring Boot tiene
un servidor Tomcat en memoria que se inicia tan
pronto como inicia su aplicación Spring Boot. Así que
ya tenemos un servidor Tomcat en memoria que
podríamos utilizar

6. Ahora modifiquemos la clase

GeoLocationApplication.java para convertirla en una
aplicación Spring Boot:

package com.packt.microservices.geolocation;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure

.SpringBootApplication;
@SpringBootApplication

public class GeoLocationApplication {

public static void main(String[] args) {

SpringApplication.run(GeoLocationApplication.class,
args);

7. Como puede ver, hemos agregado una anotación,

SpringBootApplication, a nuestra clase. La anotación
@SpringBootApplication reduce la cantidad de líneas
de código escritas al agregar las siguientes tres
anotaciones implícitamente:
@Configuración
@ComponentScan
@EnableAutoConfiguration

Si está familiarizado con Spring, ya sabrá lo que hacen

las dos primeras anotaciones. @EnableAutoConfiguration
es la única anotación que forma parte de Spring Boot. El
paquete AutoConfiguration tiene un mecanismo inteligente
que adivina la configuración de su aplicación y
configura automáticamente los beans que probablemente
necesitará en su código.
También puede ver que hemos agregado una línea más al
método principal, que en realidad le dice a Spring Boot
 la clase que se usará para iniciar esta aplicación. En
nuestro caso, es GeoLocationApplication.class. Si desea
agregar más lógica de inicialización a su aplicación,
como configurar la base de datos o configurar su caché,
no dude en agregarla.
aquí.
1. Ahora que nuestra aplicación Spring Boot está lista
para ejecutarse, veamos cómo ejecutar nuestro
microservicio. Haga clic con el botón derecho en
GeoLocationApplication.java desde el Explorador de
paquetes, seleccione Ejecutar como y luego seleccione
Spring Boot App. También puede elegir la aplicación Java
en lugar de la aplicación Spring Boot. Ambas opciones
finalmente hacen lo mismo. Debería ver algo como esto en
su consola STS:

2. Si observa detenidamente los registros de la consola,

notará que Tomcat se está iniciando en el número de
puerto 8080. Para asegurarnos de que nuestro servidor
Tomcat esté escuchando, ejecutemos un sencillo comando
curl. cURL es una utilidad de línea de comandos
disponible en la mayoría de los sistemas Unix y Mac.
 Para Windows, use herramientas como Cygwin o incluso
Postman.
Postman es una extensión de Google Chrome que te brinda
la posibilidad de enviar y recibir solicitudes HTTP.
Para simplificar, utilizaremos cURL. Ejecute el
siguiente comando en su terminal:
curl http://localhost:8080

3. Esto debería darnos una salida como esta: {"timestamp":

1467420963000, "status": 404, "error": "Not Found ","
message ":" No message available ","path ":" / "}

Este mensaje de error está siendo producido por Spring.

Esto verifica que nuestro microservicio Spring Boot está
listo para comenzar a construir con más funciones. Hay
más configuraciones necesarias para Spring Boot, que
realizaremos más adelante en este capítulo junto con
Spring MVC.

Escribiendo API REST con Spring MVC

Hay dos tipos de modelos de comunicación. Uno de ellos
es sincrónico, donde el cliente espera a que el servidor
responda a su solicitud. El otro es asíncrono, donde el
cliente dispara una solicitud y la olvida. Aunque
Servlet 3.0 y superior le permiten crear servlets
asíncronos, en nuestras recetas, nos centraremos en las
API HTTP basadas en servlet tradicionales para
simplificar.
También veremos la comunicación asíncrona en capítulos
posteriores.

Preparandome
Cuando se trata de crear API REST, hay varios frameworks
para elegir. Como ya configuramos el ecosistema de
Spring en nuestra receta anterior, tendría más sentido y
sería mucho más fácil usar Spring MVC para exponer las
API de REST.
Cómo hacerlo...
La verdadera ventaja de Spring Boot es que no tiene que
agregar nuevas dependencias para habilitar el soporte
web para su aplicación. El archivo pom principal de
Spring Boot (spring-boot-starter-parent) se encarga de
eso por ti. Ahora veamos cómo escribir nuestra primera
API. Si está familiarizado con Spring MVC, esto debería
ser muy sencillo para usted:

1. Crear una clase de controlador llamada

com.packt.microservices.geolocation.GeoLocationCont
roller.java ,que será responsable de las
operaciones básicas CRUD para la geolocalización
de los usuarios.

package com.packt.microservices.geolocation;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

@RequestMapping("/geolocation")

public class GeoLocationController {

}
Hay dos cosas a tener en cuenta aquí. La anotación de
@RestController indica que vamos a utilizar este
controlador para exponer nuestras API REST. Agrega
implícitamente la anotación @ResponseBody a todos los
métodos del controlador, ya que es algo que querría
hacer al exponer sus API REST mediante Spring MVC. La
anotación @RequestMapping especifica dónde se encuentra
su recurso HTTP. Estamos configurando @RequestMapping en
el nivel del controlador para aplicarlo a todos los
métodos del controlador.

El uso de @RequestMapping en el nivel de clase de

Controller para definir una ruta de recurso raíz se
considera una de las mejores prácticas. En lugar de
Al tener que crear rutas de API como /getGeolocation
o /createGeolocation, siempre es una mejor práctica usar
la misma ruta, /geolocation, con el método GET para
obtener datos de geolocalización y el método POST para
crear datos de geolocalización.

2. Antes de comenzar a crear nuestras API,

necesitaremos algunas clases para el objeto Dominio
y servicio. Vamos a empezar con la creación de
nuestro objeto de dominio. Supongamos que nuestra
ubicación geográfica consiste en latitud y
longitud. Definiremos la latitud y la longitud como
Double para proporcionar una mejor precisión. Ahora
tendremos que decir cuál es la geolocalización del
usuario. Así que podríamos querer agregar un ID de
usuario. También debemos decir a qué hora estuvo el
usuario en la geolocalización. Por lo tanto, es
posible que desee agregar una marca de tiempo en
formato de hora EPOCH. La marca de tiempo será de
tipo long. Así es como se verá tu clase Plain old
Java Object(POJO):

package com.packt.microservices.geolocation;

import java.io.Serializable;
import java.util.UUID;

public class GeoLocation implements Serializable {

private static final long serialVersionUID = 1L;

private double latitude;

private double longitude;

private UUID userId;

private long timestamp;

public double getLatitude() {

return latitude;

public void setLatitude(double latitude) {

this.latitude = latitude;

}
public double getLongitude() {

return longitude;

public void setLongitude(double longitude) {

this.longitude = longitude;

public UUID getUserId() {

return userId;

public void setUserId(UUID userId) {

this.userId = userId;

}
public long getTimestamp() {

return timestamp;

public void setTimestamp(long timestamp) {

this.timestamp = timestamp;

Como puede ver, hemos utilizado la clase java.utilIDID

para representar el ID de usuario, asumiendo que este
UUID identifica de forma única a un usuario. No
crearemos el POJO User ya que está fuera del alcance de
esta receta.
En un escenario ideal, uno estaría usando una base de
datos relacional o NoSQL para almacenar las
geolocalizaciones. En este caso, NoSQL parece más
adecuado debido a varios motivos, incluido el hecho de
que nuestros datos son datos de series de tiempo, en
formato JSON, no estructurados pero que cambiarán con el
tiempo y tendremos una enorme cantidad de datos.

3. Por motivos de simplicidad, almacenaremos nuestras

geolocalizaciones en una colección en memoria
java.util.List <GeoLocation>. Vamos a crear nuestro
repositorio que contiene todos nuestros objetos de
geolocalización,
com.packt.microservices.geolocation.GeoLocationRepositor
y.java:

package com.packt.microservices.geolocation;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.springframework.stereotype.Repository;

@Repository

public class GeoLocationRepository {

private List<GeoLocation> geolocations = new

ArrayList<GeoLocation>();

public void addGeoLocation(GeoLocation geolocation) {

geolocations.add(geolocation);

}
public List<GeoLocation> getGeoLocations() {

return Collections.unmodifiableList(geolocations);

4. Ahora veamos cómo se verá su interfaz de servicio:

package com.packt.microservices.geolocation;

import java.util.List;

public interface GeoLocationService {

public GeoLocation create(GeoLocation geolocation);

public List<GeoLocation> findAll();

Tanto nuestro repositorio como nuestro servicio tienen

una interfaz muy simple. Idealmente en aplicaciones en
tiempo real, es posible que desee agregar métodos más
complicados que no solo realicen operaciones de CRUD,
sino que también clasifiquen, filtren, seleccionen solo
campos específicos, etc. Ahora echemos un vistazo a
nuestra clase
com.packt.microservices.geolocation.GeoLocationServiceIm
pl.java:
package com.packt.microservices.geolocation;

import java.util.List;

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

import org.springframework.stereotype.Service;

@Service

public class GeoLocationServiceImpl implements

GeoLocationService {

@Autowired

private GeoLocationRepository repository;

@Override

public GeoLocation create(GeoLocation geolocation) {

repository.addGeoLocation(geolocation);

return geolocation;
 }

@Override

public List<GeoLocation> findAll() {

return repository.getGeoLocations();

Siempre se recomienda encarecidamente que escriba casos

de prueba de unidad para cualquier código nuevo. Pero
como eso está un poco fuera del alcance de este libro,
no escribiremos casos de prueba de unidad para ninguno
de los códigos anteriores. Para obtener más información
sobre la prueba de unidad de las aplicaciones Spring
Boot, consulte la documentación de Spring Boot en h t t
p s ://d o c s . s p r i n g . i o /s p r i n g - b o o
t /d o c s /c u r r e n t

/r e f e r e n c e /h t m l /b o o t - f e a t u r e s -
t e s t i n g . h t m l .

6. Ahora que nuestras clases de dominio y servicio están

listas para su uso, modifiquemos nuestra clase de
Controlador para guardar y encontrar geolocalizaciones.
Agregue el siguiente fragmento de código en el cuerpo de
su clase de Controlador:

@Autowired
private GeoLocationService service;

@RequestMapping(method = RequestMethod.POST, produces =

"application/json", consumes = "application/json")

public GeoLocation create(@RequestBody GeoLocation

geolocation) {

return service.create(geolocation);

@RequestMapping(method = RequestMethod.GET, produces =

"application/json")

public List<GeoLocation> findAll() {

return service.findAll();

}
En esta implementación, hay algunas cosas para notar. La
anotación @RequestMapping no tiene una ruta definida ya
que ya se deriva de la anotación de nivel de clase.
Tanto para los métodos create como findAll, estamos
utilizando la misma ruta pero diferentes métodos HTTP
según las mejores prácticas. Como estamos tratando solo
con JSON aquí, hemos establecido los valores de
producción y consumo en application / json. Los tipos de
retorno de los métodos create y findAll son GeoLocation
y List <GeoLocation> respectivamente. Spring MVC usa
internamente a Jackson para convertirlos a sus cadenas
JSON equivalentes.
¡Eso es! Ahora estamos listos para probar nuestra
aplicación:
1. Intentemos crear dos geolocalizaciones utilizando la
API POST y luego intentaremos recuperarlas utilizando el
método GET. Ejecute los siguientes comandos cURL en su
terminal uno por uno:

curl -H "Content-Type: application/json" -X POST

-d'{"timestamp":

1468203975, "userId": "f1196aac-470e-11e6-beb8-

9e71128cae77", "latitude":

41.803488, "longitude": -88.144040}'

http://localhost:8080/geolocation

2. deberia tener una salida similar a la siguiente:

"latitude": 41.803488,
"longitude": -88.14404,

"userId": "f1196aac-470e-11e6-beb8-9e71128cae77",

"timestamp": 1468203975

curl -H "Content-Type: application/json" -X POST -d

'{"timestamp":

1468203975, "userId": "f1196aac-470e-11e6-beb8-

9e71128cae77", "latitude":

9.568012, "longitude": 77.962444}'

http://localhost:8080/geolocation

3. deberia tener una salida similar a la siguiente:

"latitude": 9.568012,

"longitude": 77.962444,

"userId": "f1196aac-470e-11e6-beb8-9e71128cae77",
"timestamp": 1468203975

4. Para verificar que se almaceno correctamente se debe

ejecutar el siguiente comando cURL por consola:

curl http://localhost:8080/geolocation

5. Esto deberia imprimir algo como lo siguiente por

consola:

"latitude": 41.803488,

"longitude": -88.14404,

"userId": "f1196aac-470e-11e6-beb8-9e71128cae77",

"timestamp": 1468203975

},
{

"latitude": 9.568012,

"longitude": 77.962444,

"userId": "f1196aac-470e-11e6-beb8-9e71128cae77",

"timestamp": 1468203975

Ahora tiene una versión completamente funcional de su

microservicio. Las recetas restantes de este capítulo
intentan lograr la misma lógica con diferentes
frameworks, como WildFly Swarm y Dropwizard. Más
adelante en este capítulo, también veremos otro
framework que lo ayuda a crear API REST rápidamente
llamadas SparkJava (diferente de Apache Spark). Si va a
utilizar Spring Boot para sus microservicios, puede
pasar al siguiente capítulo. Si está interesado en
alguno de los frameworks mencionados, vaya a la receta
correspondiente en este capítulo.
Escribiendo microservicios con WildFly
Swarm.
WildFly Swarm es un framework del empaquetado de
aplicaciones J2EE de RedHat que utiliza el servidor
Undertow en memoria para implementar microservicios. En
esta receta, crearemos la misma API de GeoLocation
utilizando WildFly Swarm y JAX-RS.
Para evitar confusiones y conflictos de dependencia en
nuestro proyecto, crearemos el microservicio WildFly
Swarm como su propio proyecto Maven. Esta receta está
aquí para ayudarlo a comenzar a usar WildFly Swarm.
Cuando está creando su aplicación de nivel de
producción, es su elección utilizar Spring Boot, WildFly
Swarm, Dropwizard o SparkJava según sus necesidades.
Preparandome
De forma similar a como creamos el proyecto Spring Boot
Maven, crea un módulo WAR de Maven con groupId
com.packt.microservices y name / artifactId geolocation-
wildfly. Siéntase libre de usar su IDE o la línea de
comandos. Tenga en cuenta que algunos IDE se quejan de
que falta un archivo web.xml. Veremos cómo solucionarlo
en la siguiente sección.
Cómo hacerlo...
1. Antes de configurar el proyecto WildFly Swarm,
debemos corregir el error web.xml que falta. El mensaje
de error dice que Maven espera ver un archivo web.xml en
su proyecto, ya que es un módulo WAR, pero este archivo
no se encuentra en su proyecto. Para solucionar esto,
tenemos que agregar y configurar el plugin maven-war.
 Agregue el siguiente fragmento de código a la sección
del proyecto de su archivo pom.xml:

<build>

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-war-plugin</artifactId>

<version>2.6</version>

<configuration>

<failOnMissingWebXml>false</failOnMissingWebXml>

</configuration>

</plugin>

</plugins>

</build>

2. Después de agregar el fragmento, guarde su archivo

pom.xml y realice una actualización de Maven.
Además, si ve que su proyecto está utilizando una
versión de Java distinta de la 1.8, siga la sección
Creación de una plantilla de proyecto usando STS y Maven
para cambiar la versión de Java a la 1.8. Nuevamente,
realice una actualización de Maven para que los cambios
surtan efecto.

3. Ahora, agreguemos las dependencias requeridas para este

proyecto. Como ahora estamos exponiendo nuestras API,
debemos agregar la biblioteca JAX-RS. JAX-RS es la API
estándar compatible con JSR para crear servicios web
RESTful. JBoss tiene su propia versión de JAX-RS. Así
que vamos a agregar esa dependencia al archivo pom.xml

<dependencies>
 <dependency>

<groupId>org.jboss.spec.javax.ws.rs</groupId>

<artifactId>jboss-jaxrs-api_2.0_spec</artifactId>

<version>1.0.0.Final</version>

<scope>provided</scope>

</dependency>

</dependencies>

Lo único que debes tener en cuenta aquí es el

alcance provisto.
El alcance proporcionado en general significa que
este JAR no necesita estar incluido con el
artefacto final cuando se construye. Generalmente,
las dependencias con el alcance proporcionado
estarán disponibles para su aplicación, ya sea a
través de su servidor web o servidor de
aplicaciones. En este caso, cuando Wildfly Swarm
agrupe su aplicación y la ejecute en el servidor
Undertow en memoria, su servidor ya tendrá esta
dependencia.

4. El siguiente paso para crear la API de GeoLocation

utilizando Wildfly Swarm es crear el objeto de dominio.
Utilice el archivo
com.packt.microservices.geolocation.GeoLocation.java de
la Receta previa.
5. Ahora que tenemos el objeto de dominio, hay dos clases
que debe crear para escribir su primer servicio web JAX-
RS. El primero de ellos es la clase Application. La
clase Application en JAX-RS se usa para definir los
diversos componentes que usará en su aplicación. También
puede contener algunos metadatos sobre su aplicación,
como su basePath (o ApplicationPath) a todos los
recursos enumerados en esta clase Application. En este
caso, vamos a utilizar /geolocalización como nuestra
basePath. Veamos cómo se ve:

package com.packt.microservices.geolocation;

import javax.ws.rs.ApplicationPath;

import javax.ws.rs.core.Application;

@ApplicationPath("/geolocation")

public class GeoLocationApplication extends Application

{

public GeoLocationApplication() {}

Hay dos cosas a tener en cuenta en esta clase; uno es la

clase de Application y la otra es la anotación
@ApplicationPath, ambas de las cuales
ya hemos hablado acerca de ellas.

6. Ahora vamos a pasar a la clase de resources, que es

responsable de exponer las API. Si está familiarizado
con Spring MVC, puede comparar las clases resources con
los controladores. Ellos son responsables de definir la
API para cualquier recurso específico.
Las anotaciones son ligeramente diferentes de las de
Spring MVC. Vamos a crear una nueva clase de recurso
llamada
com.packt.microservices.geolocation.GeoLocationResource.
java que expone una API GET simple:

package com.packt.microservices.geolocation;

import java.util.ArrayList;

import java.util.List;

import javax.ws.rs.GET;

import javax.ws.rs.Path;

import javax.ws.rs.Produces;

@Path("/")

public class GeoLocationResource {

@GET

@Produces("application/json")

public List<GeoLocation> findAll() {

 return new ArrayList<>();

Todas las tres anotaciones, @GET, @Path y @Produces, son

bastante auto explicativas.

Antes de comenzar a escribir las API y la clase de servicio,

probemos la aplicación desde la línea de comandos para
asegurarnos de que funciona como se espera. Con la
implementación actual, cualquier solicitud GET enviada a la
URL /geolocalización debe devolver una matriz JSON vacía.

Hasta ahora, hemos creado las API RESTful usando JAX-RS. Es

solo otro proyecto JAX-RS:

1. Para que sea un microservicio con Wildfly Swarm, todo lo

que tiene que hacer es agregar el complemento wildfly-
swarm al archivo pom.xml de Maven. Este complemento se
vinculará a la fase del paquete de la compilación, de
modo que cada vez que se active el objetivo del paquete,
el complemento creará un JAR súper con todas las
dependencias necesarias. Un JAR súper es solo un JAR
grueso que contiene todas las dependencias dentro de sí
mismo. También implementa nuestra aplicación en un
servidor Undertow en memoria. Agregue el siguiente
fragmento de código a la sección de complementos del
archivo pom.xml:

plugin>

<groupId>org.wildfly.swarm</groupId>

<artifactId>wildfly-swarm-plugin</artifactId>
<version>1.0.0.Final</version>

<executions>

<execution>

<id>package</id>

<goals>

<goal>package</goal>

</goals>

</execution>

</executions>

</plugin>
Microservicios de contenedorización con Docker

En este capítulo, nos centraremos más en cómo empaquetar y

enviar nuestro microservicio. Aprenderemos las siguientes
recetas:

1. Construyendo un JAR ejecutable usando el plugin Maven

Shade

2. Construyendo un JAR ejecutable usando el complemento

Spring Boot Maven

3. Instalación y configuración de Docker

4. Escribiendo tu Dockerfile

5. Construyendo tu imagen Docker

6. Ejecutando su microservicio dentro de un contenedor

Docker

7. Empujando tu imagen a Docker Hub

Construyendo un JAR ejecutable usando Maven Shade

Antes de saltar a esta receta, hablemos sobre por qué lo

estamos haciendo. Nuestro objetivo es construir un artefacto
enviable que pueda ejecutarse desde cualquier plataforma o
máquina. Para hacer eso, tenemos que asegurarnos de que
nuestro artefacto final tenga todas las dependencias
empaquetadas en él. Todo lo que estamos tratando de hacer
aquí es crear un JAR grueso con todas las dependencias,
llamado uber JAR, del cual hablamos en el capítulo anterior.
Casi todos los marcos que ayudan a crear microservicios, como
Spring Boot y WildFly Swarm, tienen sus propios complementos
de Maven que lo ayudan a crear un JAR ejecutable.
Pero si utiliza frameworks como SparkJava y RatPack que no
son realmente frameworks de microservicio sino que ayudan a
construir API de HTTP, tendrá que asegurarse de usar el
complemento correcto de Maven o Gradle para crear un JAR
ejecutable.
Ratpack es un frameworks que le permite crear servicios HTTP
de alto rendimiento. Internamente, utiliza Netty como su
motor HTTP. Utiliza el mecanismo de no bloqueo basado en
eventos de Netty para exponer los servicios HTTP, por lo que
sus API serán asíncronas. Además, la forma en que escribes
las API en Ratpack es un poco diferente de cómo las escribes
en otras bibliotecas. Para obtener más información sobre
Ratpack, consulte su documentación en
https://ratpack.io/manual/current/.

Preparandome
Si ya está utilizando Spring Boot o WildFly Swarm, puede
omitir esta receta, ya que se encarga de empaquetar su
aplicación. Para hacer cumplir el paquete de su JAR
ejecutable, utilizaremos el complemento de maven-shade. Este
plugin está especialmente construido para este propósito.
Echemos un vistazo a cómo hacer esto en nuestro proyecto
SparkJava. Todo este tiempo, hemos estado ejecutando nuestro
proyecto de geolocalización-sparkjava desde el IDE. Ahora
veamos cómo podemos crear un JAR ejecutable para este
proyecto y ejecutarlo desde la línea de comandos.

Cómo hacerlo...
1. Agrega este fragmento a Build | Plugins Sección de
complementos del archivo pom.xml de su proyecto:
<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-shade-plugin</artifactId>

<version>2.4.3</version>

<executions>

<execution>

<phase>package</phase>

<goals>

<goal>shade</goal>

</goals>

<configuration>

<transformers>

<transformer
implementation="org.apache.maven.plugins.shade.

resource.ManifestResourceTransformer">

<mainClass>com.packt.microservices.geolocation.GeoLocationCon
troller</mainClass>

</transformer>

</transformers>

</configuration>

</execution>

</executions>

</plugin>

2. Vamos a tratar de entender el fragmento. El complemento se

asegura de que cada vez que se active la fase de paquete de
su compilación Maven, use el ManifestResourceTransformer para
agregar el nombre mainClass dado a la propiedad Main-Class
del archivo META-INF / MANIFEST.MF. Esta propiedad especifica
el punto de entrada a su archivo JAR. Dicho esto, vamos a
seguir adelante y ejecutar el objetivo del paquete Maven.
Ejecute el siguiente comando desde el directorio raíz del
proyecto en su terminal:
mvn clean package

3. El comando anterior de Maven empaqueta su proyecto en un

JAR ejecutable utilizando el complemento de maven-shade.
Antes de empaquetar, también ejecuta otros objetivos de
Maven, incluidos limpiar, validar, compilar y probar. No
discutiremos en profundidad estos objetivos de Maven, ya que
están fuera del alcance de este libro.
El comando anterior debería darle algo como esto en su
consola: