Spring Boot – CORE

Es un framework de código abierto para desarrollo de aplicaciones para JVM, es decir que trabajamos principalmente con Java; sin embargo, también provee soporte para lenguajes como Groovy y Kotlin.

Este framework nos permite implementar diversas arquitecturas y estilos de aplicación dependiendo de la necesidad del proyecto. Trabaja con versiones de JDK superiores al 8. A demás nos provee diferentes entornos de trabajo:

• Despliegue en un servidor propio
• Despliegue en servidor embebido
• Despliegue en la nube

Dentro de estos entornos nos provee una estructura modular, es decir que iremos conectando las diferentes piezas que requiera nuestra aplicación.

Spring Boot nació como respuesta a las exigencias de los estándares de la comunidad de desarrollo, por este motivo intrínsecamente implementa estándares y buenas practicas, al  igual que nos propone la siguiente filosofía de diseño:

1. Establecer altos estándares de calidad para el código.
2. Preocúpese por el diseño de la API.
3. Mantenga compatibilidad con versiones anteriores.

Estas reglas las ofrece de manera automática, es decir que se implementan casi al instante, esto se logra a través de, como mencionamos antes, conectar diferentes módulos(inyección de dependencias). A demás implementa estas reglas en su propio desarrollo a partir de ser un framework que ofrece opciones en todos los niveles de aplicación y se acomoda a las diversas necesidades.

Los módulos de Spring Boot están orientados de tal manera que podamos identificar tres capas principales:

• Capa de presentación.
• Capa de Negocio.
• Capa de persistencia.

Esta forma de trabajo modular es la que lo convierte en uno de los mas populares frameworks para Java, a demás de otros subsistemas de los cuales no hemos mencionado, como : logging, web services, seguridad, automatización de pruebas, entre otros.

Spring Boot permite a los desarrolladores enfocarse mas en la lógica de negocio y menos en problemas de plomería.

La inyección de dependencias es un patrón de diseño en donde se le suministran objetos a una clase en lugar de ser la propia clase quien los crea.

El Core de Spring Boot es un contenedor que se encarga de orquestar beans(objetos gestionados). Estos beans son objetos de tipo POJO, es decir que son clases simples con sus atributos privados a los cuales se pueden acceder por métodos get y set.

Cumpliendo con el patrón de inyección de dependencias, proveemos estos beans a los módulos de Spring Boot indicándole su forma de instanciación y correlaciones entre ellos; el Core se encargara de implementarlo.

Este principio de software es uno de los pilares de Spring Boot, consiste en darte el control de los objetos al propio framework, es decir que el framework será el encargado de instanciar nuestras clases y reproducir el comportamiento que deseamos a partir de la configuración que le seteamos.

Las principales ventajas de este principio es que logra modularizar nuestra aplicación permitiendo tener nuestra lógica compacta y aislada, repercutiendo en la mantenibilidad y facilidad de implementación de pruebas.

Para implementar este principio(IoC, Inversion of Control) se utiliza en Spring Boot la inyección de dependencias, anteriormente ya lo habíamos mencionado, para ver la diferencia vamos a plantear un ejemplo:

Código tradicional

public class Person {
    private Document document;
    
    public Person() {
        document = new Document();
    }
}

Inyección de dependencias

public class Person {
    private Document document;
    
    public Person(Document document) {
        this.document = document;
    }
}

El ApplicationContext es una interfaz que nos permite implementar IoC, es decir, la instanciación  y el control del ciclo de vida e interacción entre objetos. Se encarga de procesar nuestros beans.

Spring provee diferentes implementaciones de esta interfaz:

• ClassPathXmlApplicationContext
• FileSystemXmlApplicationContext
• WebApplicationContext

El proceso de implementacion de, por ejemplo, ClassPathXmlApplicationContext es:

1. Crear archivo de configuración XML(/src/main/resources/beans.xml) para los beans.

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   
       <bean id="personService" class="com.jhontona.service.PersonServiceImpl" />
   </beans>

2. Implementar el ApplicationContext, en este caso en las pruebas unitarias(/src/test/java/com/person/service/PersonServiceTest.java)

   package com.person.service;
   import static org.junit.jupiter.api.Assertions.assertNotNull;
   
   import org.junit.jupiter.api.BeforeEach;
   import org.junit.jupiter.api.Test;
   import org.springframework.context.support.ClassPathXmlApplicationContet;
   
   public class PersonServiceTest {
       private ClassPathXmlApplicationContext context;
       private PersonService service;
   
       @BeforeEach
       void setUp() {
           context = new ClassPathXmlApplicationContext("beans.xml");
           service = context.getBean("personService", PersonService.class);
       }
   
       @Test
       void testGetOnePerson() {
           assertNotNull(service);
       }
   }

Este archivo de beans.xml podemos personalizarlo dependiendo de nuestras necesidades, por ejemplo, podemos colocarle uno o varios alias a nuestro bean:

<bean id="personService" name="alias1,alias2" class="com.jhontona.service.PersonServiceImpl" />

Al bean le podemos indicar acceder a un constructor especifico o un método setter, ejemplo:

Constructor

public PersonService(String name, Integer age, Boolean document) {

<bean id="personService" class="com.jhontona.service.PersonServiceImpl">
    <constructor-arg name="document" value="true"/>
    <constructor-arg index="0" value="Juanito"/>
    <constructor-arg value="19"/>
</bean>

Estos atributos los podemos pasar por nombre, índice, tipo u orden de los argumentos.

A demás, podemos tener tantos beans como queramos. y hacer referencia entre ellos con el atributo ref.

Hasta aquí esta breve introducción a Spring Boot, vimos algunos puntos claves a cerca del ecosistema de Spring.