TEMAS NO INCLUIDOS

▪ Lombok: Es una librería para Java que a través de anotaciones nos reduce el código que codificamos,
es decir, nos ahorra tiempo y mejora la legibilidad del mismo. Anotaciones importantes: @NonNull,
@Cleanup, @Getter y @Setter, @ToString, @EqualsAndHashCode, @Data (agrupa las características
de @ToString, @EqualsAndHashCode, @Getter/@Setter y @RequiredArgsConstructor juntas: en
otras palabras, @Data genera todos los estándares que normalmente se asocian con POJOS y beans.

▪ JPA: es una especificación que indica cómo se debe realizar la persistencia (almacenamiento) de los
objetos en programas Java. Es una “especificación" porque JPA no tiene una implementación
concreta, sino que, existen diversas tecnologías que implementan JPA para darle concreción
(Hibernate, EclipseLink, OpenJPA, etc.). Anotaciones importantes: @Entity, @ManyToOne,
@OneToMany, etc.
 ESTRUCTURA DEL PROYECTO
Debemos comprender la estructura del proyecto. Necesitamos tener dos carpetas
completamente diferentes para Java y [Link]. Siempre es una buena práctica tener
carpetas completamente diferentes para cada uno. De esta manera, tendremos una
arquitectura limpia o para cualquier otro problema relacionado con la fusión de archivos.

src/main/java Aquí estará todo el código Java

src/main/gui Todo el código de [Link] estará aquí

Todos los archivos de configuración o

src/main/resources
recursos estarán acá: [Link], [Link],
[Link], etc.

src/test/java Aquí estará todo el código de test Java

 INICIALIZADOR DE SPRING
Vamos a [Link] y comenzamos a elegir opciones
 Proyecto Generado
Clickeamos en “Generate” y descomprimimos nuestro proyecto Maven en alguna carpeta.
Luego lo importamos en Eclipse (revisar diapositivas dadas)

Ahora deberemos crear las carpetas de nuestro proyecto. Revisen el [Link] y vean todas
las opciones (hay que familiarizarse con la lectura/modificación de este archivo de Maven)
 [Link]
Sólo se muestran algunas de las dependencias. Revisar y chequear
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-data-rest-hal-explorer</artifactId>
</dependency>
</dependencies>
 ESTRUCTURA DEL BACKEND
Nos debiera quedar así:

La carpeta src/main/gui la generaremos cuando veamos el frontend

 CONFIGURACIÓN H2 CON SPRING BOOT - I
H2 es solo para desarrollo. Cuando se quiera pasar a producción se debe reemplazar con
otra por ejemplo PostgreSQL. Para configurar H2 con Spring Boot entre otras cosas,
necesitamos añadir lo siguiente en el archivo [Link] que está en
/src/main/resources
 CONFIGURACIÓN [Link]
SPRING BOOT - II
[Link]=10090: es para cambiar el port por defecto (8080) donde se ejecuta Tomcat
[Link]-properties=false: para que las herramientas de Spring Boot puedan correrse
desde el IDE (modo DEV); cuando se pase a producción hay que ponerla en “true”.
[Link]=jdbc:h2:mem:[nombre-database]: para base de datos en memoria
y jdbc:h2:file:[path/database-name] para base de datos en disco.
[Link]=[Link]: Driver para H2
[Link] & [Link]: por defecto es “sa” para username y en
blanco para password.
[Link]-platform=[Link].H2Dialect: Spring Boot usa Hibernate para la
implementación de JPA; aquí configuramos el H2Dialect para la base de datos H2.
[Link]=true: esto le indica a Spring que disponga la consola de administración y
que se pueda acceder en: [Link]
[Link]-auto=create-drop: Se usa para inicializar la base de datos. La seteamos en
create-drop para que se pueda crear y borrar cada vez que se inicializa la BD. Para producción hay que
validar otros valores, ¡investigar!
[Link]-sql=true: esto es para que me muestre toda sentencia sql que se ejecute
[Link]=always: Para bases de datos embebidas como la nuestra, los scripts ([Link] y
[Link]) siempre se ejecutan. Para que siempre se ejecuten independientemente del tipo de base
de datos esta línea siempre debe estar.
 CONFIGURACIÓN H2 CON SPRING BOOT – y III
Creamos el archivo [Link] bajo /src/main/resources y escribimos el script siguiente:

DROP TABLE IF EXISTS users;

CREATE TABLE users (

ID INT PRIMARY KEY,
NOMBRE VARCHAR(250) NOT NULL,
APELLIDO VARCHAR(250) NOT NULL,
EMAIL VARCHAR(250) NOT NULL
);

Creamos el archivo [Link] bajo /src/main/resources y escribimos el script siguiente con

los valores que ustedes quieran:
INSERT INTO users (ID, NOMBRE, APELLIDO, EMAIL) VALUES
(1, 'Ernesto Andrés', 'Zapata Icart', 'ea@[Link]'),
(2, 'Susana Beatriz', 'Galetto', 'sb@[Link]'),
(3, 'Luis Andrés', 'Zapata Icart', 'la@[Link]’),
(4, ‘Osvaldo Romeo', ‘Galetto', ‘or@[Link]');
 ARRANQUE DE SPRING BOOT - I
Arrancamos la aplicación…
 ARRANQUE DE SPRING BOOT – y II
La Opción 4 que se ve en la diapositiva anterior se debe ejecutar sólo cuando hacemos
cambios en el archivo [Link]
Consideraciones a tener en cuenta
• Todos los arranques de Spring Boot son en caliente, por lo tanto, cada vez que hacen
un cambio van a ver en la consola que Spring Boot se detiene y vuelve a arrancar.
• Algunas veces, Spring Boot no toma todos los cambios que hacemos en nuestra App,
sobre todo cuando modificamos o agregamos clases, por eso se debemos hacer un
Project -> Clean… y luego la Opción 4 y luego la Opción 3
SPRING BOOT EN EJECUCIÓN
 CONSOLA DE H2
Spring Boot crea esta tabla y le inserta registros. Podemos ver esto yendo a la consola de
H2…y accediendo a la BD en el browser. Asegurarse que tienen la misma URL, nombre de
usuario y password que en el archivo [Link].
 RESTO DE LAS CLASES
Ahora agregaremos las clases de:
• Entity (nuestro modelo)
• Repository (esto sería nuestro DAO – Data Access Object)
• Service (esta sería nuestra “interface”)
• Controller (toda nuestra lógica de negocios)
Repaso del flujo de Spring Boot
El flujo de Spring Boot es así:
[Link] Cliente hace una petición (request) HTTP.
[Link] clase Controller recibe la petición HTTP.
[Link] clase Controller entiende que tipo de petición debe procesar y lo hace.
[Link] es necesario, llama a la clase de Servicio.
[Link] clase Service maneja la lógica de negocio actuando sobre los datos de la BD
mapeando los datos vía JPA.
[Link] todo está bien retorna la vista (view) una página JSP para renderizar en el browser.
 ENTIDAD JPA Users - MODELO
Nuestra clase se llamará [Link] e irá dentro del paquete Entity
Anotaciones importantes
@Entity: esta anotación marca la clase como una entidad JPA
@Id: marca el atributo “id” como clave primaria (primary key)
de la entidad.
@GeneratedValue: especifica que los valores de la clave
primaria van a ser generados automáticamente en la base de
datos.
@Column: se usa para mapear los atributos entre la entidad y
las columnas de la BD; esta anotación puede omitirse, pero si
el nombre del campo en la BD es diferente al nombre de la
entidad es necesario indicarlo con esta anotación.
Ej.: @Column(name=“NOMBRE”).
@Data: de Lombok. Genera los accesores y mutadores
(getters y setters) para todos los atributos, el método equals y
el método toString.
@NoArgsConstructor: de Lombok. Genera un constructor
vacío.
@AllArgsConstructor: de Lombok. Genera un constructor con
todos los campos que estarán disponibles en nuestra clase.
@NotNull: “Bean Validation” es una especificación standard
para validaciones que nos permiten validar fácilmente objetos
de dominio usando un set de restricciones declarados en
forma de anotaciones.
 INTERFACE UsersRepository
Nuestra interface se llamará [Link] e irá dentro del paquete Repository
Anotaciones importantes
Esta interface hereda (extiende) a
JpaRepository y toma el “modelo”
(Users) y el tipo de datos del Id. Ahora
tenemos acceso a toda la API de
PagingAndSortingRepository que, a su
vez, hereda los de CrudRepository, por
lo tanto podemos usar los métodos
implementados (entre otros) save(),
findOne(), findById(), findAll(), count(),
delete(), deleteById().
@RepositoryRestResource: marca la
interface como repositorio Spring Data
JPA se encargará de publicar el
repositorio cómo servicio REST y
acceder a las operaciones
fundamentales que todo repositorio
implementa.
 CLASE Service – SERVICE LAYER - I
Nuestra clase se llamará [Link] e irá dentro del paquete Service
Anotaciones importantes
En esta clase llamamos a todos los métodos de la
interface DAO (en el repositorio) para manejar todas
las operaciones SQL.
@Component: le permite a Spring detectar a
nuestros beans de manera automática. En otras
palabras, sin escribir código permite:
• Escanear nuestra aplicación buscando clases
anotadas con @Component
• Instanciarlas e inyectarles las dependencias
especificadas
• Inyectarlas donde sea necesario
De todas maneras, muchos programadores prefieren
usar anotaciones especializadas más estereotipadas
para que hagan lo mismo, por ejemplo: @Controller,
@Service y @Repository. Todas hacen lo mismo que
@Component.
@Autowired: permite inyectar unas dependencias
con otras dentro de Spring . Cada clase se registra
para instanciar objetos con la anotación
@RestController o @Service y @Repository.
 CLASE Controller – CONTROLLER LAYER
Nuestra clase se llamará [Link] e irá dentro del paquete Controller
Anotaciones importantes
Esta clase se diseña para manejar las peticiones
(request) entrantes, es decir, todos los “endpoints”
CRUD de tipo REST. Se usa la anotación
@RestController donde cada método devuelve una
respuesta (response) como objeto JSON en lugar de
una vista.
@RestController: Es una combinación de las
anotaciones @Controller y @ResponseBody. Los
Beans pedidos (request) o devueltos (response) son
convertidos de y a JSON.
@RequestMapping: especifica la URL base para
todas las peticiones (requests).
@Autowired: Inyectamos UserService para poder
usar todos los métodos aquí definidos.
@GetMapping: indica que este método procesa una
petición (request) de tipo GET.
@PostMapping: indica que este método procesa una
petición (request) de tipo POST.
@PutMapping: indica que este método procesa una
petición (request) de tipo PUT.
@DeleteMapping: indica que este método procesa
una petición (request) de tipo DELETE.
 CLASE Service – SERVICE LAYER – y II
Una vez que los objetos están creados la anotación Spring @Autowired se encarga de construir las relaciones entre los
distintos elementos.

@Component

UsersRepository
UserService

@Autowired

@RestController

UserService
UsersController
 PRUEBAS FINALES - I
Curl

Browser
 PRUEBAS FINALES – y II
Postman
 ¿Qué nos falta?
▪ Que ustedes armen los dos “endpoints” que restan en la clase controladora:
@PutMapping("/{id}") y @DeleteMapping("/{id}")
▪ Armar el frontend con [Link] siguiendo el modelo de datos de la BD, armaremos las
pantallas en [Link].
▪ Pruebas finales compilamos todos y ejecutamos nuestro CRUD con [Link].