Ecosistema Spring

Índice de contenidos
Introducción............................................................................................................................................................... 3
Objetivos .................................................................................................................................................................... 3
Estructura general de una aplicación web............................................................................................................. 4
¿Qué es un framework?............................................................................................................................................ 4
Historia de Spring ..................................................................................................................................................... 5
Características de Spring.......................................................................................................................................... 5
Arquitectura de Spring ............................................................................................................................................. 6
Programación Orientada a Aspectos...................................................................................................................... 8
Herramientas para este curso............................................................................................................................... 11
Creando un proyecto Spring ................................................................................................................................. 14
Conclusiones ........................................................................................................................................................... 15

Página 2 de 15
Introducción
Las aplicaciones web, como las conocemos hoy en día, tienen un peso enorme en la sociedad. Se usan
en el mundo de los negocios, del turismo, del comercio, del ocio, para disfrutar de contenidos, para
comunicarse con los demás…

En sus orígenes desarrollar aplicaciones web era un trabajo difícil, costoso y largo. Hoy en día los
desarrolladores de todo el mundo han desarrollado técnicas que agilizan el proceso de tal manera que,
además de no resultar tan costosas, su curva de aprendizaje es menor para los desarrolladores nóveles.

En este tema vamos a definir el concepto de framework, entendido como marco de trabajo para cumplir
esta misión, y a comprender el funcionamiento de las aplicaciones web y los nuevos paradigmas de
programación, que solucionan problemas anteriores y hacen de la tarea de programar algo más intuitivo y fácil
de realizar.

Conoceremos la arquitectura del framework Spring de Java, que es uno de los más demandados del
mercado, los diferentes módulos que lo componen y sus conceptos clave y simplificaremos el desarrollo
usando Spring Boot.

Prepararemos un entorno de trabajo para desarrollar aplicaciones web simulando un servidor y veremos
cómo funcionaría todo en un servidor remoto real.

Objetivos
Al finalizar esta unidad, serás capaz de...

• Entender el funcionamiento de un framework y la existencia que reglas de obligado cumplimiento y la

capacidad de éste de facilitar el desarrollo de aplicaciones.

• Conocer la arquitectura de Spring

• Entender el concepto y el funcionamiento de los servicios web y entornos de servidor.

• Conocer las bases de la programación orientada a aspectos

• Saber preparar un entorno de trabajo para desarrollar aplicaciones web basadas en Spring.

Página 3 de 15
Estructura general de una aplicación web
Una aplicación web es una aplicación a la que accedemos mediante peticiones HTTP que se hacen a un
servidor.

Normalmente funcionan en tres capas, una es la capa cliente que son los navegadores web de nuestros
dispositivos que interpretan en código para mostrarlos y recogen las peticiones que los usuarios; otro es
el servidor, que recibe las peticiones y genera las respuestas, a menudo consultando una tercera capa
constituida por la base de datos.

Esto es una definición muy simple del funcionamiento, pero puede darnos una pista de algunas de sus
ventajas; por una parte, la aplicación está escrita una vez y sirve para todos los navegadores en todos los
sistemas operativos, además las actualizaciones se hacen una sola vez sirviendo para todos ellos, incluso los
navegadores de los dispositivos móviles; no ocupa espacio en los discos duros de nuestros dispositivos y no
consume demasiados recursos.

Es importante distinguir sus capas ya que nos servirán para entender el Modelo Vista Controlador que usa
Spring para el desarrollo de aplicaciones web.

La capa de cliente la forma el navegador, que es la capa con la que el usuario interactúa. El navegador sólo
interpreta el código escrito en HTML, CSS y JavaScript y constituye lo que sería la interfaz de usuario. Es lo que
llamaremos vista.

El servidor web nos permite desarrollar lógica compleja, básicamente es donde se ejecutan las cosas y es
llamada lógica de negocio o negocio. Lo que realiza son las operaciones necesarias para responder a las
peticiones del cliente usando para esa comunicación el protocolo HTTP, como conjunto de reglas que permiten
y regulan la comunicación entre un cliente y un servidor. Con Spring Framework manejamos la lógica de la
aplicación.

Las bases de datos son sistemas que contienen información de manera ordenada y, en la mayoría de
los casos, relacionada entre sí por algún tipo de unión. Con el backend de Spring accederemos a los datos
apoyándonos en sus módulos. Las bases de datos se encargan de guardar la información a largo del tiempo y
de devolverla, cuando se le consulte, de manera fiable y precisa.

¿Qué es un framework?

La palabra framework está formada por dos palabras en inglés, frame (marco) y work (trabajo) por lo tanto
podemos definirlo como un marco de trabajo, que facilita el desarrollo del software.

Nos da el esqueleto y permite que muchas personas puedan trabajar en el mismo proyecto y que todo se
pueda integrar y funcione perfectamente.

Existen muchos frameworks, por ejemplo, en PHP tenemos Laravel, Symfony, en JavaScript Angular, React; en
Java Spring, Struts; en desarrollo mobile Ionic, en Python Django en Ruby Ruby On Rails, …

De esta manera no tenemos que preocuparnos de la arquitectura sino sólo de la lógica.

Además, permite ampliar el software ya que, si todos los desarrolladores conocen el framework es más
fácil aportar ideas o ayudar en otras funcionalidades; los framework suelen estar respaldados por los
desarrolladores y por la comunidad, mediante foros, blogs y las documentaciones oficiales.

Página 4 de 15
Historia de Spring
Spring es un framework open-source, creado por Rod Johnson, que nace de la necesidad de realizar
aplicaciones empresariales en lenguaje Java reduciendo la complejidad, la lentitud y los tiempos de
desarrollo de los sistemas utilizados en la época.

La primera versión data de marzo de 2004, cuando las aplicaciones con lenguaje Java se desarrollaban en J2EE,
que trataba de construir aplicaciones de arquitectura multicapa centrada en el servidor. Consumían muchos
recursos, eran inflexibles y trabajar con ellos era realmente difícil.

Spring se integra en las aplicaciones y aporta una estructura consistente de forma que el desarrollador/a
puede enfocarse en el desarrollo de la aplicación. Nos confiere, en resumen, una forma más fácil de crear
aplicaciones.

Por otro lado, también contribuye a generar buenas prácticas de programación. Se organiza modularmente,
simplifica el acceso a datos, minimiza el uso de código repetitivo y contribuye al loose coupling favoreciendo
que los elementos dependan unos de otros en la menor medida posible, por lo que una modificación en uno
de ellos no se tenga que introducir en un montón de clases.

Spring está escrito en sus inicios en lenguaje Java y XML. Actualmente se trabaja con una herramienta más
sencilla que nos permite trabajar de manera más productiva y sin la necesidad de escribir mucho código
XML ni de efectuar manualmente muchas configuraciones. Pese a esto, el núcleo de todo sigue siendo
Spring Framework, por eso se recomienda prestar especial atención a sus características iniciales.

Características de Spring

• Ligero

No requiere mucho espacio; el framework puede ocupar comprimido en un archivo .jar aproximadamente
1MB, lo que teniendo en cuenta la cantidad de servicios que ofrece no es mucho.

Esta característica ayuda a reducir la complejidad del código y a que su propio funcionamiento sea sencillo.
Por otra parte, arrancar una aplicación que pesa poco no debe emplear mucho tiempo y funcionará bien en
cualquier entorno.

• No intrusivo

No existen dependencias del propio framework, es decir, no obliga a implementar ninguna interfaz ni a
extender ninguna clase del API de Spring. Esta característica introduce la posibilidad de migrar la aplicación
ya que la lógica puede ser completamente reutilizable.

Página 5 de 15
 • Inversion of Control (Inversión del control)

Se trata de un paradigma que se conoce como principio de Hollywood. Imaginemos un casting de actores
en el que más de 1000 personas acuden para un papel de extra en una película. Estas personas que realizan
el casting desean saber los resultados lo antes posible y se ven tentadas a llamar al día siguiente; los
organizadores, que prevén esta actitud por parte de los aspirantes les dicen al acabar el casting esa frase
tan típica de “ya os llamaremos”; de esta manera invierten el sentido de la llamada y evitan infinidad de
comunicaciones innecesarias.
Hasta ahora, en nuestros programas atendíamos a la necesidad de controlar el flujo y sabíamos en qué
momento se harían las llamadas a los métodos, o se crearían los objetos. En este caso, al invertir el control, es
Spring quien se encarga de crear los objetos e inyectarlos en la aplicación.

• Programación Orientada a Aspectos (AOP)

Este paradigma de programación viene a complementar al ya conocido Programación Orientada a Objetos.

Recordamos que la POO estructura el sistema en clases y jerarquías de clases, haciendo de la herencia la
herramienta más sencilla para hacer los programas modulares y evitar la duplicidad de código.

Ahora bien, existen elementos que son transversales, es decir, que se comparten y son necesarios para varios
componentes de la aplicación, este supone duplicar los mismos fragmentos de código en varios lugares de
la aplicación en los objetos que no pertenecen a la misma jerarquía. Esto hace que el código sea difícil de
mantener ya que para realizar un cambio debemos buscar todo el código involucrado y aplicar los cambios
necesarios.

La programación orientada a aspectos nos permite separar esos elementos transversales.

Arquitectura de Spring

Spring es totalmente modular; se compone de varias estructuras que pueden trabajar independientemente,
permitiendo al desarrollador incluir los módulos que son de utilidad para su aplicación sin necesidad de
incluirlos todos.

Los diferentes módulos aplicables en Spring:

Spring Core Container

Incluye Core Module, Beans Module, Context Module y Expression Language.Core Module es el componente
más importante en el framework; es el encargado de implementar el principio de Inversion of Control y la
inyección de dependencias.

Beans Module
Es el encargado de proporcionar el patrón de diseño que separa las dependencias a través de la interfaz
BeanFactory. Un patrón de diseño es un esquema de solución a problemas comunes que se dan en
programación.

Se considera un patrón porque ya está probada su efectividad ya que ha resuelto problemas anteriores y
es ampliamente aceptada. Además, un patrón de diseño es reutilizable. Es capaz de manejar objetos de
cualquier naturaleza desde su inicio hasta su destrucción.

Página 6 de 15
Context Module
Como almacén de los beans en memoria y los conecta entre sí. Se trata de una extensión de BeanFactory,
del cual hereda, pero proporciona más funcionalidades como unificar la carga de recursos.

Expression Language (SpEL)

Como lenguaje que nos permite manejar elementos en tiempo de ejecución.

Módulo de OAP, o Programación orientada a aspectos

En este módulo usamos interceptores, que inspeccionan el código para realizar funciones transversales en
una aplicación, como pueden ser la seguridad, o el envío de notificaciones.

Módulo de Acceso a Datos:

JDBC
El módulo JDBC nos permite acceder a bases de datos con mucho menos código.

ORM Object Relational Mapping

Nos permite acceder a datos con un enfoque orientada a objetos, así tratamos las bases de datos
relacionales como objetos con sus atributos y así manejarla más sencillamente desde lenguajes orientados a
objetos.

JMS (Java Messaging Service)

Que nos apoya en todo lo referente a producir y consumir mensajes Java.

Transactions
Nos permite reducir el código para iniciar y cerrar transacciones con la base de datos.

OXM
Para hacer el mapeo relacional de objetos a lenguaje XML. Hay que tener en cuenta que las aplicaciones
a menudo se integran con otras aplicaciones y debe existir un lenguaje común para intercambiar los datos,
independiente de los lenguajes en los que están construidas las aplicaciones.

Los formatos más usados para intercambiar datos son XML y JSON. Spring también posee módulos para
convertir datos de objetos a JSON y viceversa.

WEB/MVC
En la arquitectura Modelo/Vista/Controlador el modelo contiene la representación de los datos, la vista está
compuesta por la interfaz de usuario y el controlador actúa como intermediario entre ambos manejando la
comunicación entre ambos.

Spring web
Se encarga de integrar las aplicaciones web con Spring framework.

Página 7 de 15
Spring portles
Encargado de integrar Spring con los sistemas de portales.

Test
Aumenta la posibilidad de testear la aplicación mediante pruebas unitarias ya que asegura que la
integración sea muy sencilla.

Característica facilitada por el uso de clases POJO (Plain Old Java Object) que puede definirse como un Objeto
de Java Antiguo que consiste en una clase plana, que no extiende ni implementa a ninguna otra, que sólo tiene
atributos, métodos getter y setter y un constructor vacío. Dada esta sencillez son fáciles de testear.

Programación Orientada a Aspectos

Se trata de un nuevo paradigma que proporciona mecanismos para separar todas aquellas tareas que
son compartidas por muchas clases de manera idéntica. Se trata de encontrar lo que se llama un interés
entrecruzado o cross-cutting concern que será encapsulado independientemente y usado eliminando la
repetición de código. En nuestra POO establecíamos que cada clase tenía una responsabilidad, manteniendo
esto diseñábamos una jerarquía de objetos con la que disminuíamos la duplicidad de código.
Ahora bien, si surgen tareas que muchas clases tienen que realizar de la misma manera nos veíamos obligados
a repetir código.

Vamos a ilustrarlo con un ejemplo sencillo relacionado con cuestiones de seguridad de acceso como
escenario para entender el concepto. Imaginemos que necesitamos comprobar si un usuario está autorizado
a realizar los métodos de una aplicación.

Para ese control establecemos una excepción a través de la cual se comprueba la existencia de esos permisos
y que nos permite lanzar un aviso.

Podemos intuir que existen elementos que se pueden usar en todo el sistema, que responden a lo que
antes definimos como interés entrecruzado, que pueden ser además de la seguridad, el manejo de errores,
aspectos de rendimiento... y muchas otras que a medida que la aplicación crezca se hará necesario
implementar.

Para verlo gráficamente podemos quedarnos con esta imagen.

Página 8 de 15
 Conceptos básicos

Aspecto: (aspecto)
Es la funcionalidad modular, en el ejemplo anterior los requisitos de seguridad y la gestión de errores serían
aspectos. La clase que agrupa consejos.

Consejo: (advice)
Es la acción a ejecutar en un punto concreto del programa. El método a realizar, por ejemplo,
comprobarAcceso()

Puntos de corte: (pointcut)

Un punto durante la ejecución de un programa donde se aplican los consejos. A qué métodos de la
aplicación le afectan los consejos.

Puntos de unión: (joinpoint)

Define los posibles puntos del programa donde los consejos se pueden ejecutar, se trata de identificar los
lugares donde se puede agregar un comportamiento

Existen diferentes tipos de consejos, que se ejecutan en un determinado momento:

@Before, se ejecuta antes del punto de unión

@After, se ejecuta después del punto de unión

@Around, rodea la ejecución del punto de unión

Página 9 de 15
@AfterReturning, se ejecuta al finalizar el punto de unión, cuando se retorna un valor

@AfterThrowing, se ejecuta cuando ocurre una excepción

Funcionamiento

Para definir un pointcut hay que añadir la anotación @Pointcut. Dentro de la expresión se pueden usar
expresiones. Éstas son:

Execution
Ejecución de métodos

@annotacion
Una anotación concreta

Within
Un tiempo concreto

@within
Tipos que tienen una anotación concreta

Target
Instancia de un objeto de un tipo concreto

@target
Instancia de un objeto con una anotación concreta

Args
Argumentos de tipo concreto

@args
Argumentos con una anotación concreta

This
Instancia de un objeto de tipo concreto

Página 10 de 15
Bean
Instancia de un bean concreto

Comodín ‘*’
Usamos el comodín ‘*’ para sustituir el tipo de acceso y el nombre de la clase y el comodín ‘..’ para indicar varios
elementos.

En los parámetros, los paréntesis vacíos indican un método sin parámetros (), y (..) indicaría cualquier
número de parámetros; los parámetros también se pueden identificar por tipos (String, *) donde se indica
que el primero es de tipo String y el segundo puede ser cualquiera.

Vamos al código para verlo mejor:

Herramientas para este curso

Necesitamos el JDK para poder desarrollar programas en java, para saber si lo tenemos instalado podemos
abrir la ventana de comandos (escribiendo cmd en el cuadro de búsqueda) y escribimos en ella java -version;
de esta manera nos saldrá la versión que tenemos instalada.

Si, por el contrario, no lo tenemos instalado debemos dirigirnos a la página de Oracle y descargar la versión
que necesite nuestro sistema operativo.
Puedes descargarla en este enlace.

Para continuar necesitamos un entorno de desarrollo o IDE. Podríamos usar eclipse o cualquier otro que
fuera de nuestro gusto. Para comenzar con un proyecto Spring son necesarias las librerías del framework.
Pueden descargarse de esta página.
Ahí podemos ver todas las versiones disponibles del framework y vamos a elegir la última versión RELEASE
que exista. Dentro de ella existen algunos archivos zip, el que contiene las librerías necesarias es el que
termina en dist.zip.

Después de extraer el archivo .zip vemos una estructura de directorios como la que sigue, y es en la carpeta
libs donde se encuentran los archivos .jar que corresponden a las librerías.

Página 11 de 15
Ahora voy a proponer visitar la página oficial y dentro del menú Projects, vamos a pinchar donde dice Spring
Tools 4, estamos en la página https://spring.io/tools . Vemos que nos sugiere tres, de los cuales el primero es
un eclipse con todas las herramientas y plugins para Spring. Lo descargamos para el sistema operativo que
tengamos en la carpeta donde queramos alojar el IDE.

Descomprimimos el archivo .jar con la herramienta que tengamos, puede ser 7zip o winrar o cualquier otra
similar. El resultado de la descompresión es un nuevo archivo rar que se llama contents, y que también
tenemos que descomprimir.

Ahora podemos eliminar todo lo que nos sobra y quedarnos con la carpeta sts-xxx que es nuestro Spring Tool
Suite. Y podemos colocar aquí nuestra carpeta para el workspace.

Cuando entramos en nuestra carpeta sts-xxxx vemos el icono ejecutable de SpringToolSuite4.

Ejecutamos y le indicamos el workspace en el que queremos realizar nuestros proyectos. Veremos algo
así muy parecido a un eclipse. La diferencia es que viene con los plugins necesarios para Spring sin tener que
configurar nada.

Vamos a hacer unas comprobaciones en el IDE para asegurarnos de que todo está correcto antes de
empezar. Tenemos que entrar en Window - > Preferences para ver que tenemos Maven instalado podemos
ir dentro del menú izquierdo a Maven y ver que lo tenemos embebido en el IDE.

Tenemos que asegurarnos que tenemos el jdk instalado, para ello, en esa misma ventana elegimos Java ->
Installed JREs como se muestra en esta imagen, y el jdk de nuestro sistema tiene que estar indicado ahí.

En el caso de que no estuviera debemos revisar la instalación y que aparezca en las variables de entorno del
sistema la variable JAVA_HOME con su path.

Para finalizar podemos ir al menú Help y entrar en Eclipse Marketplace; y si buscamos Spring vemos que el
pluging de Spring Tools está instalado.

Página 12 de 15
 • Breve referencia a Maven

Antes de la existencia de Maven, si necesitabas por alguna causa todas las librerías que nos descargamos en
pasos anteriores, teníamos que meter todos los archivos .jar de las librerías en la carpeta lib del proyecto.
Maven nos brinda toda la gestión y tiene una configuración por defecto.

Un proyecto Maven tiene un archivo XML donde están configuradas todas las dependencias del proyecto y la
información de nuestro proyecto. Las dependencias son las librerías que la aplicación necesita para funcionar
y pueden ser vistas como proyectos en sí de los que se nutre la aplicación.

Antes para cargar una librería teníamos que descargar el archivo .jar de la página web de los desarrolladores y
ponerlo en la carpeta lib, ahora con el repositorio central de Maven podemos buscar la librería que queramos

Página 13 de 15
en él y sólo copiar la dependencia en el archivo pom.xml de nuestro proyecto. https://mvnrepository.com/

Si visitamos el repositorio y buscamos Hibernate y elegimos una versión final sólo tenemos que copiar ese
código que nos indica para que la librería funcione.

Lo que ocurre es que cuando instalamos el proyecto, Maven descarga la librería y la introduce en una carpeta
llamada Maven Dependencies. Por otro lado, Maven usa la carpeta target para guardar todas las clases que
genera, cuando se ejecuta un clean limpia esa carpeta y al instalarlo de nuevo lo vuelve a generar como parte
de su ciclo de vida, así cada vez está generando los recursos que necesita.

Creando un proyecto Spring

Ya en nuestro IDE vamos a crear un primer proyecto con las primeras ayudas que tenemos.

Vamos al menú Archivo -> New -> Spring Starter Project. Le damos un nombre, será de tipo Maven y
la versión de Java que queramos. En cuanto al empaquetamiento lo dejaremos en Jar, que la herramienta
SpringBoot que estamos usando tiene la ventaja de tener un servidor embebido y no tenemos que instalarlo
y configurarlo manualmente.

Puedes poner los nombres que quieras, pero hay una convención para el Package, no es estricto, pero por lo
general comienza con el domino, seguido del nombre de la empresa, una funcionalidad concreta o cualquier
orden que le queramos dar. Hay que tener en cuenta que este será nuestro package raíz.

En cuanto a la versión se recomienda siempre una versión estable.

Ahora nos toca elegir las dependencias para este proyecto. Se trata de una primera prueba para ver el
funcionamiento de todo, pero vamos a introducir algunas cosas.

En el menú de la izquierda elegimos Spring Web, que nos permite crear páginas MVC, o API Rest y además
nos proporciona el servidor Apache Tomcat.

En Template elegimos Thymeleaf.

Y por último Dev Tools para actualizar los cambios en tiempo real después de iniciar el proyecto.

Finalizamos y esperamos a que se carguen todas las dependencias. Inspeccionando el proyecto vemos que
nuestra clase principal, donde arranca todo, está en nuestro package raíz y termina con el nombre
Application.

Página 14 de 15
Para ver el funcionamiento vamos a crear en la carpeta static dentro de src/main/resources un archivo llamado
index.html, para ello, encima de la carpeta pulsamos el botón derecho del ratón y elegimos new -> file en el
menú contextual. Puedes poner simplemente cualquier contenido, simplemente para ver que funciona. Para
verlo tienes que arrancar la aplicación con Run As Spring Boot App. En el Boot Dashboard puedes pinchar en
el enlace debajo del menú local y se abrirá una ventana de navegador con tu contenido HTML. Éste es el mío:

Conclusiones
Un marco de trabajo o framework nos proporciona un modelo y una estructura para nuestras aplicaciones
mejorando nuestro rendimiento y el trabajo en equipo. Por otra parte, el paradigma de la programación
orientada a aspectos (AOP) nos permite hacer nuestra aplicación más modular y evitar repetir código. Trabaja
junto a la POO (Programación Orientada a Objetos) para hacer aplicaciones más escalables y más fáciles de
mantener.

Esto, junto con la estructura totalmente modular de Spring, de la cual podemos servirnos de las partes que
nos interesen sin estar obligados a implementarlo todo, la inyección de dependencias, la reducción del
código XML que existía en versiones anteriores de J2EE reduciendo además muchos de los problemas e
inconvenientes que éste planteaba, la sencillez de las clases POJO (Plan Old Java Object), entre otras cosas,
hacen que sea uno de los frameworks más utilizados del mercado, con un uso ampliamente extendido en
entidades bancarias, aseguradores e instituciones educativas.

Página 15 de 15