Tegucigalpa, M.D.

Spring Boot
Apuntes

10/05/2022
 Inversion of Control (Ioc)

La inversión de control es un principio de diseño de la programación orientada a objetos

en la ingeniería de software. A través de este principio, el control de cada parte del
objeto o programa se transfiere al contenedor o marco, lo que puede reducir el
acoplamiento del código informático.
En la programación tradicional, cuando necesita usar una biblioteca de cl ases o una
determinada clase, generalmente se llama directamente; IoC proporciona un marco
para controlar el flujo del programa y personalizar la llamada para nuestro programa
durante el proceso de programación. Para implementar tal mecanismo, el framework se
construye a través de comportamientos abstractos, si queremos agregar
comportamientos personalizados, solo necesitamos extender las clases del framework
o implementar comportamientos personalizados en forma de plug-ins.
Es cuando delegamos a nuestro framework que maneje nuestras dependencias
mediante una configuración para que gestione la instancia del objeto, el ciclo de vida
del objeto y la configuración.
Este se puede hacer con las anotaciones @Component, @Service, @Repository,
@RestController, al agregar una de estas anotaciones le estamos diciendo al framework
que la clase va a cargarse en el contenedor.

Ventajas de la arquitectura de IoC

➢ Separar la ejecución del programa de su implementación
➢ Puede cambiar de forma flexible entre diferentes implementaciones
➢ Hacer el programa más modular
➢ El aislamiento de componentes facilita las pruebas, la confianza en la
simulación y la comunicación entre componentes
Ejemplo:
 Dependency Injection (DI)

La inyección de dependencias es un patrón de Software, que implementa la inversión

de control para resolver dependencias; a partir de la cual los objetos definen sus
dependencias con otros objetos.
Todas estas dependencias, se encuentran en un contenedor, que será el responsable de
inyectarlas y crear los bean necesarios, por un proceso que se llama Inversión de Control
(IoC).

El contenedor IoC en Spring

En Spring el contenedor IoC esta representado por la interfaz ApplicationContext, la
cual es la responsable de configurar e instanciar todos los objetos (los beans) y
manejar su ciclo de vida.
La Inyección de Dependencia en Spring puede ser hecha a través de campos, setters o
constructores.

Inyección de Dependencias basada en Constructor

En el caso de la Inyección de Dependencias basada en constructor, el contenedor
invocará a un constructor con argumentos en la que cada una representa a una
dependencia.
Vamos a ver la configuración de un bean y sus dependencias mediante anotaciones de
Spring:

La primera anotación que vemos @Configuration es necesaria porque nos dice que es
una clase de definición de beans.
La siguiente anotación que vemos @Bean, indica que vamos a definir un bean, por
defecto Spring crea el bean como Singleton Scope.
Inyección de Dependencias basada en Setter
La Inyección basada en Setter es parecida a la Inyección basada en constructor con la
única diferencia que una vez se crea el objeto se hace un set con los atributos del
mismo.

Vamos a ver un ejemplo con anotaciones:

Spring recomienda por lo general hacer uso de la inyección por constructor para aquellas
dependencias que son obligatorias y basado en setter para la inyección de aquellas
dependencias que son opcionales.

Inyección de Dependencias basada en campos

En el caso de la Inyección de Dependencias (DI) para campos, podemos realizar
añadiendo la anotación @Autowired en el campo de la clase de la que queremos su
dependencia:

En este caso se usará reflexión para inyectar el «book» in la «library».

Sin lugar a dudas este es un sistema sencillo, práctico y bastante limpio pero no siempre
debería ser usado.
➢ Al tener que utilizar reflexión para realizar la inyección de dependencia es mucho
más costoso que hacerlo a través de constructor o por setter.
 ➢ Se puede llegar a violar el Principio de Responsabilidad única, ya que es
realmente sencillo añadir dependencias, y si caemos en el error de añadir
muchas, va a parecer que esa clase pueda estar haciendo más funciones de las
que debiera.

Documentación:

• https://www.baeldung.com/inversion-control-and-dependency-injection-in-spring
• https://refactorizando.com/inyeccion-dependencias/
 Application Context

ApplicationContext es una piedra angular de una aplicación Spring Boot. Representa el

contenedor Spring IoC y es responsable de instanciar, configurar y ensamblar los
beans. El contenedor obtiene sus instrucciones sobre qué objetos instanciar, configurar
y ensamblar mediante la lectura de metadatos de configuración. Los metadatos de
configuración se representan en XML, anotaciones Java o código Java.

ApplicationContext proporciona lo siguiente:

➢ Métodos de fábrica de frijoles para acceder a los componentes de la aplicación
➢ La capacidad de cargar recursos de archivo de forma genérica.
➢ La capacidad de publicar eventos para oyentes registrados.
➢ La capacidad de resolución de mensajes, apoyando la internacionalización

ApplicationContext tiene varias implementaciones. Por

ejemplo, ClassPathXmlApplicationContext toma la configuración de un archivo XML en
el classpath o AnnotationConfigApplicationContext, que lee la configuración usando
anotaciones, especialmente @Configuration.

ClassPathXmlApplicationContext:
En caso de que queramos cargar un archivo de configuración XML desde el classpath ,
podemos usar la clase ClassPathXmlApplicationContext . Similar
a FileSystemXMLApplicationContext, es útil para probar arneses, así como contextos de
aplicaciones incrustados dentro de archivos JAR.

Entonces, veamos un ejemplo del uso de esta clase:

AnotaciónConfigWebApplicationContext:

AnnotationConfigWebApplicationContext es una variante basada en web de

AnnotationConfigApplicationContext.
Podemos usar esta clase cuando configuramos el detector de
servlet ContextLoaderListener de Spring o un Spring MVC DispatcherServlet en
un archivo web.xml.
Además, desde Spring 3.0 en adelante, también podemos configurar este contenedor
de contexto de aplicación mediante programación. Todo lo que tenemos que hacer es
implementar la interfaz WebApplicationInitializer :

Documentación:

➢ https://www.baeldung.com/spring-application-context
 Programación Orientada a Aspectos (AOP)

La programación orientada a aspectos (AOP - Aspect Oriented Programming) es un

paradigma de programación que intenta formalizar y representar de forma concisa los
elementos que son transversales a todo el sistema. En los lenguajes orientados a
objetos, la estructura del sistema se basa en la idea de clases y jerarquías de clases. La
herencia permite modularizar el sistema, eliminando la necesidad de duplicar código.
No obstante, siempre hay aspectos que son transversales a esta estructura: el ejemplo
más clásico es el de control de permisos de ejecución de ciertos métodos en una clase:

Es una metodología con la que se crean las aplicaciones, nos da la flexibilidad para
eliminar las preocupaciones transversales de nuestra aplicación y separarlas de la lógica
de negocio.

La Programación Orientada a Aspectos (AOP) complementa la Programación Orientada

a Objetos (OOP) al proporcionar otra forma de pensar sobre la estructura del
programa. La unidad clave de modularidad en OOP es la clase, mientras que en AOP la
unidad de modularidad es el aspecto . Los aspectos permiten la modularización de
preocupaciones como la gestión de transacciones que abarcan múltiples tipos y
objetos. (Tales preocupaciones a menudo se denominan preocupaciones
transversales en la literatura AOP).
Uno de los componentes clave de Spring es el marco AOP . Si bien el contenedor Spring
IoC no depende de AOP, lo que significa que no necesita usar AOP si no lo desea, AOP
complementa Spring IoC para proporcionar una solución de middleware muy capaz.
Comprender AOP con la implementación:

1. Crear un proyecto Maven.

2. Añadir las dependencias necesarias.

3. Crear la clase ShoppingCart con el método checkout

@Component:
@Component es una anotación de nivel de clase. Se utiliza para denotar una clase como
un Componente. Podemos usar @Component en toda la aplicación para marcar los
beans como componentes administrados de Spring. Un componente es responsable de
algunas operaciones.
A nivel de Spring Framework esta anotación simplemente registra un bean dentro del
framework sin mayor efecto. Es decir, si disponemos de una clase como la siguiente.

@Component
public class MiComponente {

4. Creamos una clase BenConfig la cual se encargará de administrar nuestros

Beans dentro de la aplicación.

@Configuration: La anotación Spring @Configuration ayuda en la configuración basada

en anotaciones Spring. La anotación @Configuration indica que una clase declara uno o
más @Beanmétodos y puede ser procesada por el contenedor Spring para generar
definiciones de beans y solicitudes de servicio para esos beans en tiempo de ejecución.

@ComponentScan: Mientras desarrollamos una aplicación, debemos decirle al

framework Spring que busque componentes administrados por
Spring. @ComponentScan permite que Spring busque elementos como
configuraciones, controladores, servicios y otros componentes que definamos.
En particular, la anotación @ComponentScan se usa con la
anotación @Configuration para especificar el paquete para que Spring busque
componentes.
@EnableAspectJAutoProxy: La anotación Spring @EnableAspectJAutoProxy permite la
compatibilidad con el manejo de componentes marcados con @Aspectla anotación de
AspectJ. El @EnableAspectJAutoProxy se utiliza en @Configuration las
clases. @EnableAspectJAutoProxyes equivalente al elemento <aop:aspectj-
autoproxy>XML.

5. Creamos la clase LogginAspect.

@AspectJ: se refiere a un estilo de declaración de aspectos como clases regulares de

Java anotadas con anotaciones de Java 5.

Hay cinco tipos de consejos en el aspecto AOP.

• @Before : Consejo que se ejecuta antes de un punto de unión, pero que no tiene
la capacidad de evitar que el flujo de ejecución avance hasta el punto de unión
(a menos que genere una excepción).
• @AfterReturning : Consejo que se ejecutará después de que un punto de unión
se complete normalmente.
• @AfterThrowing : Consejo para ejecutar si un método sale al lanzar una
excepción.
 • @After : Consejo a ejecutar independientemente del medio por el que sale un
punto de unión (retorno normal o excepcional).
• @Around : consejos que rodean un punto de unión, como la invocación de un
método.

6. Creamos la clase AuthenticationAspect.

@Pointcut: un predicado que coincide con los puntos de unión. El consejo está asociado
con una expresión de punto de corte y se ejecuta en cualquier punto de unión que
coincida con el punto de corte (por ejemplo, la ejecución de un método con un nombre
determinado). El concepto de puntos de unión combinados con expresiones de corte de
puntos es fundamental para AOP, y Spring usa el lenguaje de expresiones de corte de
puntos de AspectJ de forma predeterminada.
 7. Clase Main.

Documentación:

• https://docs.spring.io/spring-framework/docs/4.3.12.RELEASE/spring-
framework-reference/html/aop.html
 Spring Boot

1. Estructura de un proyecto en Spring Boot:

Esta estructura de paquetes agrupa las clases en 9 paquetes principales los cuales
definiremos a continuación.

2. Paquete de configuración “config” en cual creamos 2 clases para la configuración

de la seguridad y la configuración web de nuestro proyecto:
ApiSecurityConfig: en esta clase definimos la configuración de seguridad para nuestras
Apis, como ser los Cors, autorizaciones y autenticación.

3. Paquete “response” este paquete sirve para retornar las diferentes respuestas
del api, así como también los diferentes errores que se pueden mostrar al probar
nuestras Apis.

Clase BaseResponse:
Clase Response:

Clase ErrorResponse: Clase utilizada para devolver la respuesta de error de la API.

 4. Paquete “Utils” Este paquete contiene una colección de funciones de utilidad.
Clase JsonLowerCaseResolver: Clase para la resolución de ID de tipo Json.

Clase Messages: Clase de mensajes para recuperar mensajes de recursos.

Clase SortingPagingUtils: Clase de utilidades para paginación y clasificación.

5. Paquete “Models”, Cada Modelo tiene un ambiente principal que se utiliza para
la creación y reorganización de la base de datos, y como ambiente por defecto
para la generación de la aplicación.
Anotaciones En Java
Una anotación en Java es aquella característica que le permite incrustar información
suplementaria en un archivo fuente. Esta información no cambia las acciones de un
programa, pero puede ser utilizada por varias herramientas, tanto durante el desarrollo
como durante el despliegue.

Anotaciones necesarias para la creación de entidades:

@Entity
Las entidades en JPA no son más que POJO que representan datos que se pueden
conservar en la base de datos. Una entidad representa una tabla almacenada en una
base de datos. Cada instancia de una entidad representa una fila en la tabla.

@Table(name=”Estudiante”)
La anotación @Table le permite especificar los detalles de la tabla que se utilizará para
conservar la entidad en la base de datos. La anotación @Table proporciona cuatro
atributos, lo que le permite anular el nombre de la tabla, su catálogo y su esquema, y
aplicar restricciones únicas en las columnas de la tabla. Por ahora, estamos usando solo
el nombre de la tabla, que es Estudiante.

@Id
se anota con @Idpara que JPA la reconozca como la ID del objeto. La idpropiedad
también se anota con @GeneratedValuepara indicar que el ID debe generarse
automáticamente.

@Column(name=”nombreColumna”)
se usa para Agregar el nombre de la columna en la tabla de una base de datos.

@ManyToOne
Existe relación Many-To-One entre las entidades donde se hace referencia a una entidad
(columna o conjunto de columnas) con valores únicos que contienen de otra entidad
(columna o conjunto de columnas). En bases de datos relacionales, estas relaciones se
aplican mediante el uso de clave primaria clave externa entre las tablas.

@OneToMany
En esta relación, cada fila de una entidad se hace referencia a los muchos registros
secundarios en otra entidad. Lo importante es que los registros secundarios no pueden
tener varios padres. En una relación uno a varios entre la tabla A y B de la tabla, cada
fila en la tabla A puede ser vinculado a una o varias filas en la tabla B.
@OneToOne
En una relación uno-a-uno, un elemento puede vincularse al único otro elemento.
Significa que cada fila de una entidad se refiere a una y sólo una fila de otra entidad.

@ManyToMany
Relación de varios a varios es donde una o más filas de una entidad se asocian a más de
una fila en otra entidad.

@JoinTable
la cual nos sirve para definir la estructura de la tabla intermedia que contendrá la
relación.

Documentación:

https://www.baeldung.com/jpa-many-to-many

https://spring.io/projects/spring-data-jpa

Clase enum “ModelStatus”: Sirve para cambiar el estado cuando sea de tipo enum.
 6. Paquete y clase “Mapper”: Nos permite hacer el mapeo entre los DTO y las
entidades y viceversa.

Dependencias necesarias:
MapStruct
es una librería que nos va a permitir hacer mapeo de objetos sin tener que escribir todo
el código a mano, simplemente con una interfaz, en la que le vamos a indicar el objeto
de entrada y el objeto de salida.

Anotación necesaria:
@Mapper(componentModel = "spring")
Sirve para indicar que va hacer un mapeo de spring.
 7. Paquete “DTO”:
Un objeto de transferencia de datos es un objeto que transporta datos entre procesos.
La motivación de su uso tiene relación con el hecho que la comunicación entre procesos
se realiza generalmente mediante interfaces remotas, donde cada llamada es una
operación costosa.

Clase Dto: Clase DTO para encapsular la implementación de la entidad.

Dependencia:
Jackson
Jackson es una librería Java muy potente para el procesamiento / parseo de objetos a
json y viceversa. Ofrece muchas opciones y posibilidades, anotaciones propias, etc.

Anotaciones:
@JsonSerialize
se usa para especificar un serializador personalizado para organizar el objeto json.

@JsonProperty
es un meta datos para decirle a serializer cómo hacer un objeto serial. Se utiliza para:
variable nombre. acceso (LECTURA, ESCRITURA)
Dependencia:
javax-validation
validation contiene las API de validación de beans que describen cómo validar mediante
programación JavaBeans.

Anotaciones:
@NotNull
no puede ser nulo, pero puede estar vacío, sin restricción de tamaño.

@NotEmpty
no puede ser nulo y Size> 0

@NotBlank
solo se usa para String, no puede ser nulo y tamaño> 0 después de trim ().

@Size (min = 2, max = 32)

Se usa para determinar el tamaño mínimo y máximo de los datos.

@Email
Se usa para validar que los datos tengan formato de email.

@Builder
le permite generar automáticamente el código requerido para que su clase sea
instanciable. Se puede colocar en una clase, o en un constructor, o en un método.

@Builder.Default
El campo anotado con @Defaultdebe tener una expresión de inicialización; esa
expresión se toma como predeterminada para usarse si no se establece explícitamente
durante la construcción.

@NoArgsConstructor
generará un constructor sin parámetros. Si esto no es posible (debido a los campos
finales), en su lugar se producirá un error de compilación, a menos que se
utilice @NoArgsConstructor (force = true).

@AllArgsConstructor
genera un constructor con un parámetro para cada campo en su clase.

@Getter and @Setter

Podemos anotar cualquier campo con las anotaciones Getter y Setter para generar
automáticamente los métodos getter y setter de dicho campo.
 8. Paquete “Repository”:
Es el package que contiene las interfaces que extienden de JPA para que estas clases se
conecten a la base de datos. Estas gestionan información ya sea de buscar, bor rar,
actualizar o crear un registro en la base de datos.

Dependencias:
springFramework starter-web
Spring Framework es un framework Open Source que facilita la creación de aplicaciones
de todo tipo en Java, Kotlin y Groovy.

Anotaciones:
@Repository
El concepto de Repository como clase que se encarga de gestionar todas las operaciones
de persistencia contra una tabla de la base de datos es hace ya mucho tiempo un clásico.
 9. Paquete “Service”

En este paquete se implenta la lógica del negocio.

Dependencias:
springFramework starter-web

Anotaciones:
@Service
marca una clase Java que realiza algún servicio, como ejecutar lógica de negocios,
realizar cálculos y llamar a API externas. Esta anotación es una forma especializada de la
anotación @Component destinada a ser utilizada en la capa de servicio.

Interfaz de servicio para operaciones CRUD de la entidad.

Implementación de los métodos creados en nuestro servicio:

• Implementación del método save:

• Implementación del método de paginación:

• Implementación del método findById:

• Implementación de método findByName:

• Implementación de método delete:

 10. Paquete “Controllers”

Entendemos como controlador a la capa de una aplicación que responde a eventos e

invoca peticiones a la capa modelo.

Dependencias:
springFramework starter-web

Anotaciones:
@RestController
anotación en Spring es esencialmente una combinación de @Controller y
@ResponseBody.

@Controller
permite la autodetección de clases de componentes en el classpath y las definiciones de
bean de registro automático para ellas. Para habilitar la detección automática de dichos
controladores anotados, puede agregar el escaneo de componentes a su configuración.
La clase Java anotada con @Controller es capaz de manejar múltiples asignaciones de
solicitudes.

@ResquestBody
nos permite recuperar el cuerpo de la solicitud. Luego podemos devolverlo como una
cadena o deserializarlo en un objeto Java antiguo simple (POJO). Spring tiene
mecanismos integrados para deserializar objetos JSON y XML en POJO, lo que también
facilita mucho esta tarea.

@RequestMapping (path = "/api/v1/students")

se utiliza para asignar solicitudes web a clases de manejador y métodos de manejador
específicos. Cuando @RequestMapping se usa en el nivel de clase, crea un URI base para
el que se usará el controlador. Cuando esta anotación se utiliza en los métodos, le dará
el URI en el que se ejecutarán los métodos del controlador. A partir de esto, puede inferir
que la asignación de solicitud a nivel de clase seguirá siendo la misma, mientras que cada
método de controlador tendrá su propia asignación de solicitud.

@GetMapping(params = "studentName")
Esta anotación se utiliza para asignar solicitudes HTTP GET a métodos de controlador
específicos. @GetMapping es una anotación compuesta que actúa como un acceso
directo para @RequestMapping (method = RequestMethod.GET).
@PathVariable
es la anotación que nos sirve dentro de Spring framework para configurar variables
dentro de los propios segmentos de la URL algo que a nivel de Arquitecturas REST es
imprescindible.

@PostMapping(value = "/{studentId}/subjects")
Esta anotación se utiliza para asignar solicitudes HTTP POST a métodos de controlador
específicos. @PostMapping es una anotación compuesta que actúa como un acceso
directo para @RequestMapping (method = RequestMethod.POST).

@PutMapping
Esta anotación se utiliza para mapear solicitudes HTTP PUT en métodos de manejador
específicos. @PutMapping es una anotación compuesta que actúa como un acceso
directo para @RequestMapping (method = RequestMethod.PUT).

@DeleteMapping(value = "/{studentId}")
Esta anotación se usa para asignar solicitudes HTTP DELETE a métodos de controlador
específicos. @DeleteMapping es una anotación compuesta que actúa como un acceso
directo para @RequestMapping (method = RequestMethod.DELETE).

Para más información puede orientarse de la documentación oficial.

https://spring.io/guides/tutorials/rest/
• Método para obtener los datos ordenado paginado con criterios dados “GET”.

• Método del controlador para obtener una solo registro por su ID “GET”.
• Método del controlador para guardar un registro “POST”.

• Método del controlador para eliminar un registro por el ID “DELETE”.