Spring Básico

@Service
Las clases de negocio son aquellas que contienen métodos que resuelven el flujo principal del negocio
de nuestra aplicación. En estos métodos se resuelven, por ejemplo, la validación de datos de un cliente, la
coordinación de llamadas para guardar información en la base de datos, el envió de un email si se aprueba el
registro de un usuario, etc.

Las clases de negocio no acceden directamente a los datos (esto lo hacen los @Repository, que veremos más
adelante), ni tampoco se encargan de dibujar los datos al usuario (esto lo hacen las páginas HTML junto a los
@Controller).

Las clases de negocio se anotan con @Service en Spring, quien las levantará en su contexto para poder
inyectarla en donde sea necesario.

Los @Service son clases comunes, con métodos públicos que contienen la lógica de negocio.

Inyección de dependencias
En el @Controller pudimos agregar un atributo y dejar que Spring realice la inyección de dependencias por
nosotros. Spring realizará la inyección de dependencias de todos los objetos que gestione, ya sean
@Controller, @Service, @Repository y otros.

Para indicarle a Spring que realice la inyección de dependencias de una clase, basta con:

1. Agregar un atributo final a la clase que será inyectada

 2. Agregar un constructor que reciba una instancia de dicho atributo, y la setee.

Alternativamente, se puede reemplazar el constructor usando la anotación @Autowired sobre el atributo,

aunque no es la forma que Spring recomienda utilizar actualmente.
 Configuración del DataSource en Spring
En el archivo application.properties tenemos que configurar el acceso a la base de datos, para que Spring
nos deje disponible una conexión lista para usar. El lugar de donde salen estas conexiones se los conoce
como DataSource.

El archivo queda entonces de la siguiente manera:

1. spring.datasource.url=jdbc:mysql://localhost:3306/videojuegos?serverTimezone=GMT-3

2. spring.datasource.username=videojuegos

3. spring.datasource.password=videojuegos

Mapeo del objeto con JPA

Java Persistence API (JPA) son las clases del JDK que se encargan de relacionar un objeto a una tabla en una
base de datos. Incluye un conjunto de anotaciones para poder relacionar: 

 La clase con una tabla (@Entity y opcionalmente @Table)

 El atributo que se asociará a la columna que es primary key (@Id)
 El resto de los atributos con cada columna (opcionalmente con @Column)

Acceso a datos con Spring Data JPA

Spring Data JPA es una extensión de Spring Framework que facilita muchísimo el acceso a las bases de datos,
usando objetos mapeados con JPA. Nos brinda la facilidad de programar interfaces, que serán luego
 implementadas por Spring en tiempo de ejecución. De esta manera, con muy poco código, tendremos
muchísima funcionalidad.

La interfaz que creemos deberá extender JpaRepository (indicando la clase y el tipo de datos del atributo que
es ID). Al extender JpaRepository, tendremos varios métodos útiles para buscar objetos, guardarlos,
actualizarlos y borrarlos.

Por ejemplo, nuestra interfaz para usar el objeto Videojuego queda: 

1. public interface VideojuegoRepository extends JpaRepository<Videojuego, Integer> {

2. }

Resumen de la sección: mapeo avanzado usando

@ManyToOne
En esta sección aprendimos a utilizar la sentencia ALTER de SQL para modificar un modelo de datos
existente. Además, creamos una nueva tabla y la relacionamos utilizando una foreign key. Y, por último,
mapeamos esta relación en Java usando @ManyToOne de JPA.

ALTER de SQL
La sentencia ALTER de SQL nos permite modificar las estructuras existentes de la base de datos (como
tablas), manteniendo los datos ya almacenados.
 Con ALTER podemos:

 agregar una nueva columna a una tabla

 eliminar una columna de una tabla

 cambiar el nombre de una columna

 cambiar el tipo de datos de una columna (y la base realizará la conversión pertinente, si puede)

 cambiar el nombre de una tabla

 cambiar las restricciones de una columna (por ejemplo, agregar un NOT NULL)

 agregar o quitar una foreign key

 y más!

La sentencia ALTER se uso muchisimo en entornos productivos, donde queremos ir evolucionando el modelo
de datos sin perder la información ya almacenada.

 Leer más sobre el uso de ALTER en MariaDB.

Anotación @ManyToOne de JPA

 La anotación @ManyToOne en una @Entity de JPA nos permite indicar que un atributo está relacionado a
través de una foreign key en la tabla, y deseamos que JPA se encargue de buscar el objeto relacionado y
cargarlo automáticamente.

De manera predeterminada, JPA asume que la columna en la tabla se llama como el atributo, agregándole el
sufijo _id al final. Podemos usar la anotación @JoinColumn para indicarle manualmente cuál es el nombre de
la columna que es la foreign key a otra tabla.
1. @ManyToOne
2. @JoinColumn(name="distribuidor_otro_id")
3. private Distribuidor distribuidorAdicional;
 Resumen de la sección: consultas avanzadas con
Spring Data JPA
En esta sección aprendimos el uso de @Query para crear consultas personalizadas a la base de datos.

@Query
La anotación @Query de Spring Data JPA nos permite asociar una consulta a un método de un Repository.
De esta forma, podemos crear métodos que resuelven consultas pesonalizadas y devuelven objetos de
dominio (aquellos anotados con @Entity de JPA).

@Query con JPQL

De manera predeterminada, @Query espera recibir una consulta en formato JPQL (Java Persistence Query
Language). JPQL es el lenguaje de consulta de JPA, parecido a SQL pero con diferencias fundamentales.

En JPQL consultamos las instancias de objetos (en lugar de tablas) y atributos de los mismos (en lugar de
columnas). Es decir, hacemos referencia a clases y atributos, que tienen que estar mapeados con JPA.
JPA luego traduce esta consulta JPQL a SQL para que la base de datos puede ejecutarlo.
1. @Query("from Pais p order by p.nombre")

2. List<Pais> buscarTodos();
 Podemos usar parámetros para personalizar al consulta. Los parámetros se agregan al método
normalmente, y luego se referencian en la consulta por posición, con ?1, ?2, ?3 y así sucesivamente.
1. @Query("from Pais p where p.continente = ?1")

2. List<Pais> buscarPorContinente(String continente);

3.  

4. @Query("from Pais p where p.continente = ?1 and p.fechaIndependencia > ?2")

5. List<Pais> buscarPorContinenteYFechaIndependencia(String continente, LocalDate desde);

Podemos usar wildcards también como en SQL, usando el operador LIKE con el caracter %

1. @Query("from Pais p where p.nombre like ?1%")

2. List<Pais> buscarPorNombreEmpiezaCon(String nombre);

3.  

4. @Query("from Pais p where p.nombre like %?1")

5. List<Pais> buscarPorNombreTerminaCon(String nombre);

6.  

7. @Query("from Pais p where p.nombre like %?1%")

8. List<Pais> buscarPorNombreContiene(String nombre);

 Si sabemos que la consulta devuelve exactamente un solo resultado podemos devolver una única instancia
del método en lugar de un List. Si la consulta llegara a devolver más resultados, Spring Data lanza una
excepción en tiempo de ejecución.
1. @Query("from Pais p where p.nombre = ?1")

2. Pais buscarPorNombre(String nombre);

@Query con SQL nativo

También podemos usar SQL nativo en nuestras consultas, aunque no es lo recomendado. Para usar
SQL nativo, tenemos que agregar el parámetro nativeQuery=true a la anotación @Query. La consulta SQL
que ejecutemos tiene que devolver todas las columnas que necesita la entidad (y cada nombre de columna
tiene que ser el esperado según el mapeo de la entidad).
1. @Query(value = "select * from pais", nativeQuery=true)

2. List<Pais> buscarTodos();

Con SQL nativo JPA usará el query exacto tal cual lo escribimos, con lo cual podemos usar funciones o
consultas complejas propias del motor de base de datos que estamos usando.

Leer más

 @Query en la documentación de Spring Data JPA

Query Methods
 Spring Data nos provee una forma alternativa a @Query para crear métodos de consulta, y es a través de los
Query Mehtods. Un Query Method es la creación de una consulta a partir del nombre de un método, el cual
tiene que seguir cierta sintaxis. Los Query Methods son muy prácticos para crear consultas simples y rápidas,
y nos evitan el uso de @Query. Los query methods empiezan con la palabra findBy y siguen con las
condiciones.
1. findByNombre(String n)

2. findByNombreAndApellido(String n, String a)

3. findByApellidoOrderByNombreAsc(String a)
 Resumen de la sección: formulario de alta para crear
datos
En esta sección aprendimos a crear un formulario en HTML que envie datos a un Controller de Spring MVC
para guardar un objeto.

FORM en HTML con Bootstrap

Los FORM en HTML se usan para recibir información del usuario y poder procesarla.

Bootstrap provee varios ejemplos de FORM que nos permite crear formularios rápidos y atractivos.

Un FORM está compuesto de:

 El atributo METHOD, que indica cómo se enviará la información al servidor. Puede ser GET o POST.
Con GET los valores se envían directamente en la URL, de manera que el usuario puede guardar la página
para consultar más tarde. Con POST los valores se envian en el cuerpo del mensaje HTTP, y por lo tanto no se
ven en la URL.
 El atributo ACTION, que indica a qué URL se deberá enviar la información.
 Elementos que permiten la entrada de datos del usuario. Suelen ser INPUT, SELECT o TEXTAREA. Cada
uno de estos elementos tiene un atributo NAME, que permite indicar el nombre del valor que se enviará.

Asocilar un FORM a un objeto del modelo

 Podemos asociar un objeto del Model a un FORM y sus elementos. De esta manera, Thymeleaf se encargará
de crear los atributos NAME y VALUE del elemento HTML, de forma automática.

Sobre el FORM agregamos el atributo  th:object="${miObjeto}"  para asociar un objeto del Model al formulario.
Luego, usamos  th:field="*{atributo}"  sobre cada INPUT, SELECT o TEXTAREA que queremos asociar a un
atributo en particular.

Recibir datos de un FORM con Spring MVC

Podemos crear métodos en un @Controller que reciben datos de un formulario, tanto por GET o POST.

Usamos las anotaciones @GetMapping() o @PostMapping() para indicar la URL que queremos procesar.

El método puede recibir un objeto cualquiera, que Spring MVC cargará con los datos del FORM que se envia.
Se asociará cada atributo del objeto a un elemento del FORM que tenga el mismo nombre.

Ejemplo de FORM con Thymeleaf

1. <form th:action="@{/guardar}" th:object="${persona}" method="post">

2. <input type="text" th:field="*{nombre}" />

3. <input type="text" th:field="*{apellido}" />

4. <textarea th:field="*{observaciones}"></textarea>

5. <input type="submit" value="Guardar" />

6. </form>

Guardar objetos con Spring Data JPA

Spring Data JPA brinda el método  save()  para crear o actualizar objetos en la base de datos.

Si el objeto a guardar tiene su id en null, JPA realizará un INSERT en la base de datos. El id de la clase además
indica la estrategia que se usará para obtener un nuevo id. Generalmente, se delega esta tarea a la base de
datos (estrategia conocida como IDENTITY).

Si el objeto a guardar tiene un valor en su atributo id, entonces JPA realizará un UPDATE en la base de datos.