JAVA EE

MI7
[NOMBRE DE LA EMPRESA] [Dirección de la compañía]
Contenido
¿Cómo funcionan las aplicaciones Java EE?.......................................................... 3
Hola Mundo con JSP ............................................................................................... 4
Java Servlets ........................................................................................................... 5
Java Beans.............................................................................................................. 7
MVC en nuestra aplicación...................................................................................... 8
Archivos War empaquetados y su estructura .......................................................... 9
Asistentes Inteligentes Maven ................................................................................. 9
Gradle ................................................................................................................... 11
Aplicaciones orientadas a presentación vs servicios ............................................. 12
Creando un proyecto de Java que se conecta a la base de datos. ....................... 13
¿Qué es Hibernate? .............................................................................................. 14
Configurando Hibernate en Spring Tool Suite ....................................................... 15
version para intellig ............................................................................................ 16
Integrando Hibernate al proyecto y conectando a la base de datos ...................... 16
Pasos en intellij idea .......................................................................................... 17
Mapeo y Anotaciones con Hibernate JPA ............................................................. 22
Mapeando nuestro proyecto con Hibernate JPA ................................................... 22
Anotaciones básicas en nuestro proyecto ............................................................. 23
Relaciones o Asociaciones en Hibernate [One To One, One To Many y Many to
Many]. ................................................................................................................... 24
Mapeando Relaciones a nuestro proyecto ............................................................ 26
- One to Many - Uno a muchos .......................................................................... 26
- Many to Many - Muchos a muchos .................................................................. 26
Queries a la base de datos usando Hibernate ...................................................... 28
Importante.......................................................................................................... 28
¿Qué es un DAO? ................................................................................................. 28
Manejo de Session en Hibernate .......................................................................... 29
Hql en Hibernate ................................................................................................... 29
Consultas basicas en Hibernate ............................................................................ 30
https://www.mkyong.com/hibernate/hibernate-query-examples-hql/ ..................... 30
¿Qué es un Framework? ....................................................................................... 31
¿Qué es Spring Framework? ................................................................................ 32
Spring Bean Factory .............................................................................................. 35
Composición de Spring, Spring MVC y Spring Boot .............................................. 38
La composición de todo el Spring framework .................................................... 38
La composición de Spring MVC ......................................................................... 39
Spring Boot ........................................................................................................ 39
Integrando Spring al proyecto ............................................................................... 40
Componentes de un proyecto en Spring Boot ....................................................... 41
Capas de nuestra aplicación.............................................................................. 41
Configurando Hibernate con Spring ...................................................................... 43
Configurando DAO's con Spring y Filtros con HQL Hibernate .............................. 44
HQL Hibernate Query Language ....................................................................... 44
Hibernate HQL Joins ............................................................................................. 45
¿Qué es y cómo funciona API Rest? .................................................................... 47
Configurando Service ............................................................................................ 47
Creando Controller API Rest por Entidad .............................................................. 48
Definiendo métodos, Get y Post ............................................................................ 48
Métodos Patch y Delete ........................................................................................ 49
Manejando mensajes de error personalizados ...................................................... 49
Manejando Filtros en REST .................................................................................. 50
Subir imágenes en un api rest ............................................................................... 51
@JsonIgnore ......................................................................................................... 53
¿Cómo funcionan las aplicaciones Java EE?

Las aplicaciones Java EE nacen debido a que necesitamos aplicaciones

distribuídas, aplicaciones con muchos componentes que funcionen en entornos
separados y al mismo tiempo puedan estar conectados mediante una red.
Es por ello que necesitaremos una mente central que una estos componentes,
este será un servidor, que tenga todos los recursos de velocidad, seguridad y
confiabilidad, este debe estar idealmente dedicado a nuestra aplicación.
En Java EE siempre necesitaremos un servidor, ya sea de pago o gratuito.
Algunos servidores de aplicaciones famosos son GlassFish, WildFly, Apache etc.
Existe otro conocido que no es considerado servidor de aplicaciones sino más
bien contenedor de aplicaciones me refiero a Apache Tomcat, el cual esta
diseñado para contener aplicaciones Java solamente.

** COMENTARIO
Un contenedor web es un servidor que se limita solamente a entregar información
solicitada por el cliente (solicitud y entrega) y esta funcion es posible gracias a los
servlets, normalmente el software que se utiliza es Apache Tomcat.
Un servidor de aplicaciones es un servidor dedicado para dar servicio de una
aplicación a una cantidad grande de usuarios (dependiendo de la capacidad de tu
servidor) por medio de la red, todas las operaciones que hagas en la aplicacion
utiliza recursos del servidor y muy pocos de tu ordenador, es como si manejaras
una computadora remota desde tu navegador web, a diferencia de los
contenedores web, el software como WebSphere, GlassFIsh gestiona la seguridad
y el manejo de usuarios de la aplicación cuando acceses a la red a esta aplicación
montada.
JEE nace por la necesidad de aplicaciones distribuidas, es decir que funcione en
entornos separados. Por tanto es necesario que exista un servidor, sobre una red,
de manera que las aplicaciones sean transaccionales.
Existen servidores que son de pago (WebLogic, JBoss, WebSphere) y otros no
(JOnAS, Wildfly, GlassFish, Gerónimo y TomEE). Apache Tomcat se considera
como un contenedor de aplicaciones, trabaja únicamente con Servlets
(Aplicaciones JAVA).

Hola Mundo con JSP

Utilizaremos el IDE Eclipse para hacer nuestro primer Hola Mundo usando JSP.
Iremos al menú File -> New -> Dynamic Web Project
Colocaremos el nombre de nuestro proyecto HolaMundo
Damos click en Finish
Ahora para crear un archivo jsp
Iremos a la carpeta WebContent click derecho New -> JSP File
Colocaremos en nombre de nuestro archivo index.jsp
Damos Next dejamos todo como está y damos click en Finish
Este archivo jsp será nuestra vista en nuestra arquitectura MVC de Java EE.
Un jsp significa Java Server Pages, y está diseñado para crear páginas web
dinámicas

** COMENTARIO

POJO (Plain Old Java Object): Es una instancia de una clase (Objeto) que no
extiende ni implementa nada en especial, sirve para enfatizar el uso de clases
simples y que no dependen de un framework en especial.
Por ejemplo, un Controller de Spring tiene que extender de SimpleFormController,
e implementar los métodos abstractos de ese tipo: por eso, no es un POJO. Un
Servlet, tiene que extender de HttpServlet por lo que tampoco es un POJO. En
cambio, si defines una clase Vehículo con atributos y unas cuantas operaciones,
tienes un POJO.
EJB (Enterprise Java Bean): Simplifica la construcción de soluciones
empresariales y permite el manejo de transacciones, seguridad, persistencia, etc.
JavaBean (Bean): Es una clase simple en Java que cumple con ciertas normas
con los nombres de sus propiedades y métodos. Debe tener:
- un constructor sin argumentos.

- tiene declarados todos sus atributos como privados.

- para cada uno de ellos un método setter y getter.

- y deben ser serializables.

Java Servlets

Hemos creado la vista del proyecto nuestro archivo jsp, ahora crearemos un
archivo que controle la visata y el acceso al proyecto, un controlador que aquí lo
conoceremos como Servlet.
Un Servlet es una clase de java con super poderes pues hereda de la clase
HttpServlet a partir de la cual podemos sobreescribir los métodos doGet y
doPost.
Veremos cómo funciona un Servlet en un control de acceso a un sistema, un
Login.

** COMENTARIO

Servlet: Es una clase que hereda métodos de la clase HttpServlet, una vez
heredados tiene la capacidad de manejar cualquier tipo de request, para
identificarlo puedes ubicar dentro del código sus métodos doGet o doPost o
atraves de su anotación (@WebServlet) + el nombre que le quieras dar como
URL.
**
Un Servlet es el controlador y maneja las rutas a través de @WebServlet("/path").
Se trata de una clase que hereda de HttpServlet para tener acceso a los métodos
doGet y doPost.
Java Beans

En el curso anterior entendimos qué es un POJO o un modelo de datos hecho

clase.
Los Beans son similares a los POJO’s solo que tienen la peculiaridad de que
debe implementar la interfaz Serializable, siempre. Dado que tenemos un
proyecto de Java EE y trabajamos sobre una red, necesitamos serializar los
objetos para generar transferencias de datos.

La interfaz Serializable: Nos ayuda a que el objeto/clase tenga un número y ese

número (id) nos ayuda a identificarlo en la red cuando se hace alguna
transferencia de datos.
Creando nuestro Bean;
Creando un package->nueva clase->implements Serializable:
public class LoginBean implements Serializable{
}
-> agregando atributos privados con sus métodos getters/setters y por último su
constractor vacío:
private String name;
private String password;

public LoginBean() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}

MVC en nuestra aplicación

Crearemos el método autenticación para verificar que la contraseña sea válida.

Sobreescrbiremos el método doPost que indicamos en el formulario del archivo
jsp.
Recuperaremos los datos name y password del formulario a partir del objeto
request.
Si la autenticación es exitosa llevaremos al usuario a la página welcome.jsp
pero si falla lo debe llevar a error.jsp, esto lo hacemos con ayuda del objeto
dispatcher que será el disparador de las respuestas.

RequestDispatcher: Generar las respuesta que vamos a enviar

Request.forward(request, response): para ejecutar el dispatcher
Archivos War empaquetados y su estructura

WAR (Web ARchive): Es un archivo que contiene componentes para una

aplicacion web de Java y se estructuran siguiendo una jerarquia
(https://docs.oracle.com/cd/E13222_01/wls/docs90/webapp/configurewebapp.html)
, un archivo de esta extension es el vehiculo para pasar tu aplicacion web a
produccion (target environment).

Asistentes Inteligentes Maven

Si pensamos en todo lo que hemos hecho hasta ahora podemos decir:
Creamos un proyecto Web y debemos la mayoría de archivos desde cero
Generamos un archivo war
Si queremos integrar librerías debemos hacerlo dando click derecho en el proyecto
Properties -> Java Build Path -> Libraries y seleccionar la librería previamente
descargada
Esto de repente se vuelve repetitivo y cansado, tenemos asistentes inteligentes en
Java que nos ayudan a resolver lo anterior y principalmente:
Crear Proyectos basados en plantillas
Descargar librerías de terceros jar
Crear todos los componentes y archivos ejecutales
Tenemos un Asistente muy importante su nombre es Maven y nos ayuda
esencialmente a ejecutar las acciones que describimos, a través de un
archivo de configuración pom.xml
Gradle

Gradle también es un asistente inteligente, está basado en Groovy un lenguaje

de programación que usa Domain Specified Language que es una forma de
analizar la información, modelandola en objetos JSON.
La información de configuración del proyecto la encontraremos en un archivo
llamado build.gradle la cuál estará en forma de objetos JSON.
Aplicaciones orientadas a presentación vs servicios
Creando un proyecto de Java que se conecta a la base de datos.

Añadir dependencias en maven 4.0

En el video anterior creamos nuestra base de datos, en este trabajaremos con
nuestro diagrama UML.
Abriremos Spring Tool Suite y crearemos un nuevo proyecto basado en Maven:
Damos Click derecho New->Other->Maven->Maven Project
Damos Next -> Next -> Next
Escribimos el Group Id (nuestro package): com.platzi
Ponemos el Artifact Id (nombre proyecto): hibernate
Damos click en Finish
Abrimos nuestro archivo pom.xml para integrar la dependencia de MySQL
Puedes obtener dependecias del sitio: https://mvnrepository.com/
Buscaremos MySQL y seleccionamos la versión 5.1.21
En el resultado copiamos la correspondiente a Maven:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.21</version>
</dependency>
¿Qué es Hibernate?

Hibernate es un ORM (Object Relational Mapping)

 Es una herramienta que nos permite mapear una base de datos

 Hibernate esta diseñado para trabajar con bases de datos relacionales.
 La idea de Hiberante es tener una clase equivalente a una tabla de base de
datos incluyendo los campos.
 Podremos operar los datos operando no sobre tablas sino sobre objetos
 Busca solucionar el problema de la diferencia entre dos modelos de datos
coexistentes en una aplicación
 Podemos definir tipos de datos
 Generar sentencias SQL

Hibernate permite conectarnos a una base de datos a partir de un archivo de

configuración llamado hibernate.cfg.xml.
Mapearemos las tablas y campos de una base de datos a partir de Anotaciónes
@ en las clases
Configurando Hibernate en Spring Tool Suite
Integraremos un Plugin de Hibernate en Spring Tool Suite para tener accesos
rápidos a archivos de configuración de Hibernate.
Para integrarlo debemos ir a nuestro IDE Spring Tool Suite:
Help -> Install New Software
Click en Add y colocar un nombre que nos permita identificar el software del
Plugin, puede ser Hibernate
Iremos al sitio http://download.jboss.org/jbosstools/updates/stable/ para buscar la
versión de eclipse en la que está basado nuestro Spring Tool Suite (revisa en la
sección de Acerca De o About del IDE)
Una vez que seleccionamos la versión de eclipse, entramos a ella y en la parte
inferior copiaremos el enlace que se antepone la leyenda “Content has moved to”
para nuestro caso es este:
https://download.jboss.org/jbosstools/neon/stable/updates/
Este enlace lo pegamos en el campo que dejamos pendiente cuando dimos Click
en Add y damos click en OK
Descargará los paquetes y dentro de JBoss Web and Java EE Development
seleccionamos Hibernate Tools y damos click en Siguiente.
Descargará el paquete seleccionado, aceptamos los términos y damos click en
Finish.
En algún punto de la descarga te pedirá permiso de instalar software de terceros e
decimos que sí.
Se reiniciará el IDE y quedará listo.

version para intellig

https://plugins.jetbrains.com/plugin/7515-jboss-forge-idea-plugin

Integrando Hibernate al proyecto y conectando a la base de datos

Crearemos una carpeta llamada resources esta contendrá el archivo de

configuración cfg.hbm de hibernate.
Desde nuestro File Explorer vamos al workspace del proyecto
Entramos a nuestro proyecto hibernate -> src -> main
Dentro crearemos la carpeta resources
Regresamos al IDE damos click derecho en el proyecto Properties -> Java Build
Path -> Source
Damos click en Add Folder
Buscamos resources la seleccionamos y damos Ok y Apply
Cerramos la ventana dando Ok
Aparecerá nuestra carpeta, la seleccionamos y le damos click derecho New ->
Other -> Hibernate -> Hibernate Configuration File (cfg.xml)
Nos aparecerá una ventana solicitando los datos de conexión a la base de datos.
Llenaremos lo siguiente:
Driver class: com.mysql.jdbc.Driver
Connection URL: jdbc:mysql//localhost:3306/platziprofesores
Username: platziprofesores
Password: platziprofesores
Como resultado tendremos un archivo hibernate.cfg.xml con los datos que
ingresamos en formato XML.
Por último integraremos la dependecia de Hibernate:
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.2.6.Final</version>
</dependency>
Pasos en intellij idea

Creamos el proyecto MAVEN

Seleccionamos el proyecto y le damos click derecho, se desplegare varias
opciones y elegimos “add frameworks support”
Nos mostrara la siguiente ventana

Seleccionamos HIBERNATE y marcamos las dos primeras opciones

Una vez dado OK, nos mostrara la siguiente pantalla
Seleccionamos el explorador de Choose Data source
Se mostrara la siguiente pantalla
Y le damos click al icono de mas
Mapeo y Anotaciones con Hibernate JPA

Para cada tabla de la base de datos que queramos persistir en el proyecto

debemos hacer un mapeo.
Los Mapeos los haremos a partir de Annotations @ de Java
@Entity: Se aplica a la clase e indica que esta clase es una entidad a persistir.
@Table: Se aplica a la clase indica el nombre de la tabla de la base de datos.
@Column: Se aplica a una propiedad Java e indica el nombre de la columna de la
tabla.
@Id: Se aplica a una propiedad de la clase e indica que es la clave primaria.
@GeneratedValue: Indica que Hibernate deberá generar el valor de la clave
primaria

Mapeando nuestro proyecto con Hibernate JPA

Haremos el mapeo de nuestros beans SocialMedia, Teacher, Course,

TeacherSocialMedia. Todas las anotaciones las traeremos del paquete
javax.persistence.*
Primero colocaremos nuestra etiqueta @Entity arriba del nombre de la clase y
posteriormente @Table(name=“nombre_tabla_base_datos”) para indicar el
nombre de la tabla.
Para los campos usaremos @Column(name=“columna_base_datos”) y en el
campo que referencía al identificador colocaremos @Id seguido de
@GeneratedValue(strategy=GenerationType.IDENTITY) que indica que se
autogenere el identificador.

Anotaciones básicas en nuestro proyecto

Al tener una tabla de llaves que adicionalmente tiene un campo tenemos que
mapear también la tabla para mapear el campo, normalmente no sería necesario
pues Hibernate se encargaría de generar la relación.
La forma de modelar las relaciones a muchos en Java es manejando colecciones
de Objetos
Podemos usar la Colección Set, List, Vector, HashMap, etc
Relaciones o Asociaciones en Hibernate [One To One, One To Many
y Many to Many].

En Hibernate podemos manejar las relaciones que existen en la base de datos,

tenemos las siguientes:
 One to One (Unidireccional): Un objeto tiene una referencia de otro
objeto.
 One to One (Bidireccional): Los dos objetos tienen referencias uno de
otro.
 One to Many: Un objeto tenga una lista de otros objetos
 Many to Many: Un objeto A tenga una lista de otros objetos B y también
que el objeto B a su vez tenga la lista de objetos A
Adicional conoceremos la anotación @JoinColumn que nos idicará el nombre de
la columna que une las tablas
Mapeando Relaciones a nuestro proyecto
En el Proyecto trabajaremos las siguientes relaciones:

- One to Many - Uno a muchos

La clase Teacher tiene una colección de Cursos
La clase Curso tiene una referencia de Curso
Nuestra clase Padre (Owner) será Teacher
La clase Hijo (No Owner) Courses
Por lo tanto en la clase Teacher donde tenemos nuestra colección de Cursos
colocaremos la anotación: @OnetoMany(mappedBy=“teacher”)
Mientras que en la clase Course donde tenemos la referencia de Teacher
colocaremos la anotación: @ManyToOne(optional=true,
fetch=FetchType.EAGER) y además @JoinColumn(name=“id_teacher”) aquí
se especifica el nombre del campo de la tabla que tiene la llave foránea

- Many to Many - Muchos a muchos

La relación de Teacher hacia TeacherSocialMedia va de Uno a muchos
La relación de SocialMedia hacia TeacherSocialMedia va de Uno a muchos
Dicho lo anterior la clase Teacher tiene una colección de TeacherSocialMedias y
la clase SocialMedia también
Por lo tanto en la clase Teacher donde tenemos la colección
TeacherSocialMedia colocaremos la siguiente anotación:
@OneToMany(cascade=CascadeType.ALL) y
@JoinColumn(name=“id_teacher”) donde se especifica el nombre del campo de
la tabla que tiene la llave foránea
Ahora en la clase SocialMedia haremos algo similar vamos a la colección
TeacherSocialMedia colocamos: @OneToMany y
@JoinColumn(name=“id_social_media”) que especifica el nombre del campo
de la tabla que tiene la llave foránea.
Por último en la clase TeacherSocialMedia vamos a la referencia de Teacher y
SocialMedia y ponemos: @ManyToOne(fetch=FetchType.EAGER) junto con
@JoinColumn(name=“id_teacher”) para teacher y
@JoinColumn(name=“id_social_media”) para socialMedia los cuales indican el
campos que tienen la llave foránea.
En el Proyecto trabajaremos las siguientes relaciones:
 One to Many - Uno a muchos
La clase Teacher tiene una colección de Cursos
La clase Curso tiene una referencia de Curso
Nuestra clase Padre (Owner) será Teacher
La clase Hijo (No Owner) Courses
Por lo tanto en la clase Teacher donde tenemos nuestra colección de Cursos
colocaremos la anotación: @OnetoMany(mappedBy=“teacher”)
Mientras que en la clase Course donde tenemos la referencia de Teacher
colocaremos la anotación: @ManyToOne(optional=true, fetch=FetchType.EAGER)
y además @JoinColumn(name=“id_teacher”) aquí se especifica el nombre del
campo de la tabla que tiene la llave foránea
 Many to Many - Muchos a muchos
La relación de Teacher hacia TeacherSocialMedia va de Uno a muchos
La relación de SocialMedia hacia TeacherSocialMedia va de Uno a muchos
Dicho lo anterior la clase Teacher tiene una colección de TeacherSocialMedias y
la clase SocialMedia también
Por lo tanto en la clase Teacher donde tenemos la colección TeacherSocialMedia
colocaremos la siguiente anotación: @OneToMany(cascade=CascadeType.ALL) y
@JoinColumn(name=“id_teacher”) donde se especifica el nombre del campo de la
tabla que tiene la llave foránea
Ahora en la clase SocialMedia haremos algo similar vamos a la colección
TeacherSocialMedia colocamos: @OneToMany y
@JoinColumn(name=“id_social_media”) que especifica el nombre del campo de la
tabla que tiene la llave foránea.
Por último en la clase TeacherSocialMedia vamos a la referencia de Teacher y
SocialMedia y ponemos: @ManyToOne(fetch=FetchType.EAGER) junto con
@JoinColumn(name=“id_teacher”) para teacher y
@JoinColumn(name=“id_social_media”) para socialMedia los cuales indican el
campos que tienen la llave

Queries a la base de datos usando Hibernate

Para poder utilizar todos los mapeos y configuraciones que hemos hecho al
proyecto es necesario utilizar las siguientes clases:
SessionFactory
Configuration
Session
Ellos nos dan acceso a nuestra base de datos leyendo nuestro archivo de
configuración que tiene los parámetros de conexión y las clases mapeadas que
fungirán como entidades.
Una vez obtenido nuestro objeto session si queremos ejecutar un query en
Hibernate debemos iniciar una transacción, posteriormente declarar el query
y finalmente ejecutar la transacción con commit.

Importante
Es importante tener el archivo .cfg en resources para que puede leerlo la
sesión, además que en el archivo especifiquemos el user y password

¿Qué es un DAO?

DAO significa Data Access Object

El cuál es un patrón de diseño que nos permite crear un API de un Objeto
específico.
Un APi significará crear todas las acciones que se pueden realizar hacia un objeto.
Por ejemplo un CRUD:
 Create
 Read
 Update
 Delete
Generaremos un DAO de cada entidad para ello debemos crear una Interfaz
donde se declaren los métodos de API y una clase que implemente la interfaz.

Manejo de Session en Hibernate

Para crear un objeto sesión que sea reutilizable en nuestra clase PlatziSession
crearemos un constructor y dentro implementaremos todo el código de conexión a
base de datos y apertura del objeto session.
Por último crearemos el método getSession() para estar recuperando el objeto.
A a partir de esto puedo llamar al objeto en los métodos DAO por ejemplo si quiero
guardar un teacher lo haría así:
platziSession.getSession.persist(teacher);
platziSession.getSession.getTransaction().commit();

Hql en Hibernate
Hql significa Hibernate Query Language el cual es completamente orientado a
objetos.
Si quisieramos ejecutar un query SELECT podemos hacer lo siguiente:
platziSession.getSession().createQuery("from Teacher").list();
Consultas basicas en Hibernate
.setMaxResults(1) = el numero de registros que queremos que
extraiga de la base de datos

https://www.mkyong.com/hibernate/hibernate-query-examples-
hql/

https://docs.jboss.org/hibernate/orm/3.5/reference/es-ES/html/queryhql.html
¿Qué es un Framework?

Librería: conjunto de clases, métodos etc. que son invocadas por el flujo del
programa y que posteriormente devuelven el control a este.
Framework: Un framework controla el flujo del código, él decide cuándo llamar
nuestro código.
 Librería - Programación secuencial.
 Framework - Programación por eventos.
Inversión de Flujo o de control
Se da cuando el programador deja de tener el control del flujo del código y en su
lugar el framework toma el control del programa, llamando al código cuando
suceda un evento específico.
¿Qué es Spring Framework?
Spring usa inversión de control, específicamente controlará la creación y
destrucción de objetos.
Un programa tradicional de java tendrá en su método main todas las llamadas a
los objetos secuencialmente.
Con Spring framework tendremos las llamadas a los objetos se concentrarán en
un contenedor y de este se encargará Spring.
Podemos decir que la clase A para ser llamada y convertirse en objeto,
depende de la clase Principal (la que contiene el método main) la llame.
Entonces si se implementa el contenedor de Spring en la clase Principal
decimos que Spring está inyectando el objeto A, es decir Spring está
inyectando la dependencia.
Tenemos lo siguiente:
Clase Vehículo - A
Clase Motor - B
En el ejemplo la clase Vehículo inyecta directa y explícitamente la clase Motor, la
clase A inyecta la clase B.
Debemos evitar que la clase B decida qué objetos crear.
La forma de desacoplar esta dependencia directa es creando una clase más
genérica, nos referimos a una interfaz que tenga métodos que puedan ser
implementados en varias clases, esta Interfaz será la indicada a inyectar en
la clase A (Vehículo) pues al ser genérica se puede crear no solo un tipo de
objeto sino varios.
Recuerda que cuando sobreescribimos métodos y le damos diferente
comportamiento a ese comportamiento le llamamos Polimorfismo
Spring Bean Factory

Los objetos que son la columna vertebral de tu aplicación y que son administrados
por el contenedor Spring se denominan beans.
Un bean en Spring será un objeto que tenga consigo un CRUD de acciones
Los DAO’s son Beans, pero usaremos su interfaz pues es el elemento más
abstracto y reutilizable.
También tendremos objetos de servicio y objetos que nos permitan conectarnos
con otras partes del sistema como Bases de Datos.
Cuando nuestra interfaz implementa solo a una clase usaremos la anotación
@Autowired
Cuando la interfaz implementa a varias clases usaremos la anotación
@Configuration y @Bean
Composición de Spring, Spring MVC y Spring Boot

La composición de todo el Spring framework

La composición de Spring MVC

Spring Boot
Va a simplificar toda la configuración de Spring, se encarga del servidor,
seguridad, etc.
Integrando Spring al proyecto

Abrimos intellliJ IDEA, deplegamos file > new>Project>spring iniatializr

 Le damos next
 Spring Boot Version > latest
 Dependencias:
SQL > MySQL y JPA
Web > Web
Presionamos Next
 Dejamos todo como esta y damos click en Finish

Componentes de un proyecto en Spring Boot

Capas de nuestra aplicación

 Repositories: Se encarga de conectar y traer datos de la base de datos
 Services: Coordina las fuentes de datos
 Controllers: Coordina las entradas y salidas de información
 Json - FrontEnd: Es lo que el usuario visualiza, los datos en formato json
Para trabajar estas capas necesitaremos las siguientes anotaciones
 @Repository > Se enfoca en los DAO’s
 @Service > Servicios, Llama a los DAO’s
 @Controller > Trabaja con la capa de presentación
Configurando Hibernate con Spring

Crearemos nuestra clase DataBaseConfiguration.java esta reemplazará al

archivo hibernate.cfg.xml haremos la instanciación de esta clase a partir de
Spring Framework.
Para que Spring pueda hacer su trabajo de inyección de dependecias es
necesario indicar con la anotación @Configuration que será una clase de
configuraciones de beans. Por lo tanto también usaremos la anotación @Bean.
Esta clase también gestionará la sesión de conexión a la base de datos.

** COMENTARIO
La anotación Bean se maneja solo para aquellos objetos que quieras que se
controlen por el container de Spring. Si necesitas que el ciclo de vida de un objeto
sea administrado por Spring entonces requieres de esta anotación de Bean.
La anotación de Autowired se utiliza para inyectar una instancia de un objeto que
ya se encuentre en el contenedor de Spring. Es decir, un objeto en el que ya
hayas seteado la anotación Bean.
Podríamos decir que la anotación Bean es para almacenar instancas de objetos
en el container y la anotación Autowired es para recuperar instancias de objetos
del container. Claro que esta es información a grajdes razgos, aún hay mucho por
detras que puedes revisar en la documentación de spring 😃
Complementando, la razón por la que en el último metodo se utilizó ambas
anotacioes es por:
 En el caso de la anotación Bean, la utilizamos por que necesitamos que la
instancia del objeto hibernateTransactionManager sea almacenada en el
contenedor de Spring
En el caso de la anotación Autowired, la utilizamos por que requerimos recuperar
un objeto del contenedor de spring. Si te fijas para setear el SessionFactory al
objeto hibernateTransactionManager estamos haciendo uso de sessionFactory().
Este objeto sessionFactory ya lo almacenamos en el contenedor (con la anotacion
bean) anteriormente de esta manera:
@Bean public LocalSessionFactoryBean sessionFactory(){}

Espero me haya explicado!

Configurando DAO's con Spring y Filtros con HQL Hibernate

Los archivos del modelo que teníamos en el proyecto hibernate los copiaremos y
pegaremos en nuestro proyecto ProfesoresPlatzi.
Crearemos nuestro paquete dao y copiaremos la clase TeacherDaoImpl y la
interfaz TeacherDao.
Crearemos una clase abstracta llamada a AbstractSession la cual se encargará de
llamar a la sesión que gestionamos en el archivo de configuración. Estaremos
heredando de esta clase en todos nuestros DAO’s.
HQL Hibernate Query Language
 Si queremos ejecutar un SELECT hacemos:
getSession().createQuery("from Teacher").list();
 Si queremos ejecutar un UPDATE hacemos:
getSession().update(teacher);
 Si queremos encontrar un Teacher a partir de un Id:
getSession().get(Teacher.class, idTeacher);
 Si queremos encontrar un Teacher a partir de un nombre:
(Teacher) getSession().createQuery("from Teacher where name =
:name").setParameter("name", name).uniqueResult();
 Si queremos ejecutar un DELETE hacemos:
getSession().delete(teacher);
(List<Course>) getSession().createQuery("from Course c join c.teacher t where
t.idTeacher = :idTeacher").setParameter("idTeacher", idTeacher).list();

Hibernate HQL Joins

Para crear Joins en HQL es importante mantener los elementos como objetos con
sus propiedades respectivas.
Por ejemplo, si tienes la clase:
Gato
 nombre
 color
 raza
Si quisieras ejecutar un query debes poner algo como esto:
from Gato g

Donde g es un alias para acceder a la clase Gato

Ahora supongamos que existe la clase Persona y esta puede tener una colección
de mascotas gatitos que son de tipo Gato.
Persona
 nombre
 gatitos
Si quisieras saber los nombres de los gatitos de una persona podrías poner algo
así:
from Persona p join p.gatitos g

Por último si quisieras ejecutar un filtro, es decir, obtener los gatitos de esa
persona que se llamen kitty, podríamos hacer algo como:
from Persona p join p.gatitos g where g.nombre = :nombre_gatito

Recuerda que :nombre_gatito es la sintáxis para indicar que es ese parámetro es

una variable que será inyectada con la instrucción: setParameter.
Nota: no olvides poner : (dos puntos) antes del nombre de la variable
 l primer For recorre los items de la lista donde cada item tiene un arreglo de
Objetos de tipo Object[ ].
El segundo For recorre la el arreglo de tipo Object[], en donde cada elemento de
este arreglo puede contener un objeto de tipo Teacher, SocialMedia o
TeacherSocialMedia.
 Lista Item 0

o Object[]

o
 Object 1 (Teacher, SocialMedia, TeacherSocialMedia)

o
 Object 2 (Teacher, SocialMedia, TeacherSocialMedia)

o
 Object 3(Teacher, SocialMedia, TeacherSocialMedia)

o
 Object 4 (Teacher, SocialMedia, TeacherSocialMedia)
 Lista Item 1

o Object[]

o
 Object 1 (Teacher, SocialMedia, TeacherSocialMedia)

o
 Object 2 (Teacher, SocialMedia, TeacherSocialMedia)

o
 Object 3(Teacher, SocialMedia, TeacherSocialMedia)

o
 Object 4 (Teacher, SocialMedia, TeacherSocialMedia)
¿Qué es y cómo funciona API Rest?
API Rest
REST REpresentational State Transfer, lo que significa que cada vez que se
envíe o reciban datos estos serán representados por un estado en particular.
En el Blog de Platzi tenemos la siguiente nota: https://platzi.com/blog/como-crear-
apis/
Un API será un conjunto de métodos o acciones que se enfocan en un objeto en
particular.
Si unimos todo lo que acabamos de aprender, un API Rest significará un
conjunto de métodos/acciones que se pueden aplicar a un objeto
representadas por un estado en particular.
Para definir las URI’s debemos usar sustantivos, objetos, en vez de verbos.

Configurando Service

 La capa Service se enfocará en la lógica de negocio.(va hacer el

intermediario entre el dao y el controller
 Esta se ecargará de coordinar las fuentes de datos.
Haremos un paquete llamado service ahí crearemos las clases e interfaces que
tienen que ver con esta capa.
Copiaremos todos los métodos de las interfaces DAO y las pegaremos en las de
Service

Ponemos los métodos por que es la capa de lógica del negocio, esos métodos son
los que definen las accines de todo el proyecto para cada objeto, como ves la
siguiente capa es la de Repositorio, la cuál puede significar muchas fuentes de
datos, entonces para guardar un Teacher por ejemplo, el método puede ser
guardar()Service puede coordinar la fuente de datos donde queremos que se
guarde Teacher.
El modelo de negocio es guardar un Teacher, eso lo tiene Service y este puede
llamar al Repositorio que implementa una base de datos o llamar al Repositorio
que implementa guardar Teacher en un archivo o un servidor externo etc. 😃

Espero haya quedado más claro 💚

Creando Controller API Rest por Entidad
 Controller trabajará con la capa de presentación
 Recibirá las solicitudes, las procesarlás, llamar a los servicios ejecutar una
acción y devolver una respuesta.
 Idealmente debe existir un controlador por cada entidad, para tener
separados y ordenados los recursos.
Tendremos la etiqueta @RequestMapping que recibirá la localización del recurso
Para la respuesta podemos manejar:
 @ResponseBody quien devolverá la respuesta. A la par debe usarse
@ResponseStatus que devuelve el codigo de status de la respuesta
 @ResponseEntity devolverá la respuesta y al mismo tiempo el código de
status.
Postman
Podemos usar Postman para ejecutar nuestros endpoints más fácilmente.
Lo puedes descargar de aquí: https://www.getpostman.com/

Definiendo métodos, Get y Post

Para trabajar con los métodos de estado en un API Rest podemos realizar lo
siguente:
Para el método GET
Dentro de la etiqueta RequestMaping colocaremos la propiedad method=
seguido de la constante RequestMethod.GET recuerda que estas constantes las
traemos de la librería:
org.springframework.web.bind.annotation.RequestMethod;
La línea completa de código quedaría así:
@RequestMapping(value="/socialMedias", method = RequestMethod.GET,
headers = "Accept=application/json")
Para el método GET que recibe un parámetro en la URL
Colocaremos el parámetro de encerrado con llaves de la siguiente forma
/socialMedias/{id}
La línea completa de código quedaría así:
@RequestMapping(value="/socialMedias/{id}",
method =
RequestMethod.GET, headers = "Accept=application/json")
Con la etiqueta @PathVariable(“id”) Long idSocialMedia recibimos el dato id, el
cual debe tener el mismo nombre que colocamos en la url, posteriormente, lo está
asignando a la variable Long idSocialMedia.
Para el método POST que nos permitirá crear un recurso
Usaremos la constante: RequestMethod.POST
La línea completa de código quedaría así:
@RequestMapping(value="/socialMedias", method = RequestMethod.POST,
headers = "Accept=application/json")

Métodos Patch y Delete

Manejando mensajes de error personalizados

Debemos de crear una clase con las propiedades que queremos que se muestren
en este caso solo mostramos el mensaje de error;
Manejo del error desde el controller

Manejando Filtros en REST

Aquí depende de qué estés manejando a veces necesitas enviar más de un parámetro cuando
envías datos de un objeto en particular en ese caso puedes usar la anotación

@RequestBody Object object

Si parametros separados puedes irlos separando por comas

@RequestParam("name") String username, @RequestParam("password") String

password,

@PathVariable (“Variable”)=Recibe el valor de la variable creada en el Path en el momento del

request.

@RequestParam() : Recibe informacion parametrizada trasmitida por GET o POST.

@RequestBody : Recibe el body del request para almacenarlo en un objeto

Subir imágenes en un api rest
Creamos una variable constante la cual tendra la ruta del folder
public static final String TEACHER_UPLOADED_FOLDER =
"images/teachers/";
Tenemos que colocar en @RequestMapping como headers lo siguiente
headers = ("content-type=multipart/form-data")

Si queremos mostrar la imagen mostrada, en el metodo tenemos que especificar

que devolvera un arreglo de tipo byte
public ResponseEntity<byte[]>
uplodadTeacherImg(@RequestParam("id_teacher") Long idTeacher
, @RequestParam("file") MultipartFile multipartFile
, UriComponentsBuilder uriComponentsBuilder)

y colocarle como parametro

@RequestParam("file") MultipartFile multipartFile
Verificamos si el usuario ya tiene una imagen
if (teacher.getAvatar() != null ||
!teacher.getAvatar().isEmpty()) {
// Obtenemos el dato guardado el campo avatar
String fileName = teacher.getAvatar();
// lo convertimos en tipo Path
Path path = Paths.get(fileName);
// Obtenemos el path del archivo
File file = path.toFile();
// Si la ruta es correcta, entonces lo elimina
if (file.exists()) {
file.delete();
}
}

Y si no tiene una imagen, entonces abrimos un bloqye try- catch porque

manejamos entrada y salida de archivos
Creamos un objeto date, para concatenarlo en el nombre del archivo
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-
HH-mm-ss");
String dateName = dateFormat.format(date);
Luego es hora de asignarle el nombre del archivo
// Asignamos el nombre del archivo
String fileName = String.valueOf(idTeacher) + "-pictureTeacher-
" + dateName + "." +
multipartFile.getContentType().split("/")[1];
teacher.setAvatar(TEACHER_UPLOADED_FOLDER + fileName);

lo guardamos en nuestro servidor

byte[] bytes = multipartFile.getBytes();
Path path = Paths.get(TEACHER_UPLOADED_FOLDER + fileName);
Files.write(path, bytes);

actualizamos el avatar de teacher

_teacherService.updateTeacher(teacher);

Y retornamos la imagen subida

return
ResponseEntity.ok().contentType(MediaType.IMAGE_JPEG).body(byte
s);

@JsonIgnore
Hola, se le agrega @JsonIgnore a la propiedad teacher de la entidad TeacherSocialMedia,
por que la entidad Teacher tiene la propiedad teacherSocialMedia con el fetch type Eager,
esto quiere decir que cuando pides un teacher te traera sus teacherSocialMedia relacionados
pero la entidad TeacherSocialMedia tambien tiene su propiedad teacher como _Eager _ por
lo que pedira a su teacher relacionado y este a su vez a sus teacherSocialMedia relacionados,
ocasionando un bucle infinito, por lo que se agrega @JsonIgnore para no hacerle get a esa
propiedad.
No se le agrega a la propiedad socialMedia de la entidad TeacherSocialMedia por que la
entidad SocialMedia en su propiedad teacherSocialMedia ya tiene el @JsonIgnore, cortando
con el bucle infinito, TeacherSocialMedia trae los SocialMedia relacionados, pero
SocialMedia no puede traer los TeacherSocialMedia gracias a @JsonIgnore, Es lo mismo
que el anterior solo que este corta el bucle al pedir la entidad SocialMedia
SPRING-JPA-DATA
LINKS
https://docs.spring.io/spring-data/jpa/docs/current/reference/html/
https://docs.spring.io/spring-data/data-
commons/docs/1.6.1.RELEASE/reference/html/repositories.html

Usar las siguientes librerías

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
Conexion a la base de datos
En el archivo de application.properties
spring.datasource.url=jdbc:mysql://localhost/db_springboot?useSSL=false
spring.datasource.username= root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.database=mysql
spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.ddl-auto=create-drop
logging.level.org.hibernate.SQL = debug

Usando motor de plantillas THYMELEAF

Una vez que importamos la dependencia de thymeleaf, podemos crear archivos

.html en la carpeta resources/templates

Dentro de los archivos HTML debemos incluir la siguien etiqueta para implementar
el motor de plantillas

Acciones de thymeleaf dentro de el archivo html

Antes de implementar una acción debemos de asegurarnos de enlazar el
controlador con la vista
@Controller
@SessionAttributes("cliente") // Guardamos el objeto en los atributos de la sesion
public class ClienteController {
// busca un componente ya registrado en el contenedor de spring lo tenemos registro como
repository
// @Qualifier("clienteDaoJPA") // por si hay mas de un metodo con el mismo nombre, lo
tenemos que definir el repository

@Autowired
private ClienteService clienteService;

@RequestMapping(value = "/listar", method = RequestMethod.GET)

public String listar(Model model) {
model.addAttribute("titulo", "Listado de clientes");
model.addAttribute("clientes", clienteService.findAllCliente());
return "listar"; // retornar la vista
}

// Este metodo enlaza la vista

@RequestMapping(value = "/form", method = RequestMethod.GET)
public String crear(Map<String, Object> model) {
model.put("btn", "Guardar");
Cliente cliente = new Cliente();
model.put("cliente", cliente);
model.put("titulo", "Formulario cliente");
return "form";
}

@RequestMapping(value = "/form/{id}", method = RequestMethod.GET)

public String editar(@PathVariable("id") Long idCliente, Map<String, Object> model) {
model.put("btn", "Actualizar");
Cliente cliente = clienteService.findById(idCliente);

if (cliente == null) {
return "redirect:/listar";
}
model.put("cliente", cliente);
return "form";
}

// Este metodo es para procesar los datos que nos enviaron desde la vista
@RequestMapping(value = "/form", method = RequestMethod.POST)
public String guardarCliente(@Valid Cliente cliente, BindingResult result, SessionStatus
sessionStatus) {
// @Valid habilita la validacion del objeto mapeado(entity) al form
if (result.hasErrors()) {
 return "form";
}
clienteService.saveCliente(cliente);
sessionStatus.setComplete(); // Eliminamos el objeto de la sesion
return "redirect:listar"; // cuando se guarde el cliente, rdegirlo a la vista con la lista de
clientes
}

Href

For each
Tenemos que obtener la lista recibida desde el controlador

If

Texto
Nombre al input

Errores

Asignar objeto, action y method al form

Class

Validaciones con anotaciones

Desde el mapeado de la entity podemos validar los campos con anotaciones

se puede omitir la anotacion @colum si el nombre del atributo coincide con el de la
DB

Noempty
La cadena no venga vacia

Email
Que cumpla con el formato de un Email
NotNull
Temporal
DateTimeFormat

Declaramos

Validaciones personalizadas
Creamos un archivo de properties dentro de la carpeta sources

Dentro de ese archivo declaramos los mensajers personalizados

Dao crud repository

Tiene métodos por defecto CRUD

https://docs.spring.io/spring-data/jpa/docs/current/reference/html/
https://docs.spring.io/spring-data/data-
commons/docs/1.6.1.RELEASE/reference/html/repositories.html

Services
Se hace con la finalidad de que todo se concentre en un solo lugar y ademas
poder implementar DAOs diferentes

public interface ClienteService {

// Se hace con la finalidad de que todo se concentre en un solo lugar y ademas poder
// implementar DAOs diferentes
public List<Cliente> findAllCliente();
public void saveCliente(Cliente cliente);
public Cliente findById(Long idCliente);
}
Fragmentando templates