1:45:24
2023-08-31 09:10:16
49:05
2023-08-31 11:33:11
1:08:01
2023-08-31 12:36:28
42:18
2023-08-31 15:49:43
1:01:14
2023-08-31 23:21:25
5:58
2023-09-01 09:15:11
11:59
2023-09-01 09:21:33
3:42:30
2023-09-01 09:34:32
8:12
2023-09-01 16:29:10
Visit the Spring Cloud grupo 1 course recordings page
WEBVTT
-->
Pero bueno, a ver, si quieres, intentalo y dale, dale.
-->
Bien, entonces, a ver, entonces vamos a dejar los otros 5 minutos del Pomodoro 1230, 1242.
-->
Nos volvemos a conectar, ¿va? Ya sería el último corto, después vendría ya el largo.
-->
Y este, y revisamos, y bueno, ya continuaremos con la creación del primer micro, ¿va?
-->
Entonces ahorita nos vemos en 5 minutos.
-->
Listo.
-->
Sale, entonces, voy a compartir, va.
-->
Entonces, ya que pudieron entrar a esta página, donde serían los repos, este, la idea sería que
-->
fuéramos descargando, o sea, al final tenemos que descargarlos todos, pero ahorita para el día de hoy
-->
vamos a descargarnos nada más el de user service y este, el de product service y el de orden service, por favor.
-->
Entonces, para descargarlo, solamente hay que darle, hay que entrar a la, a cada uno de los repositorios.
-->
O sea, yo lo que hago es darle clic derecho, abrir en una nueva pestaña y se me va abriendo.
-->
Entonces, cuando ya estés aquí adentro en user service, este, vas a ver una, digamos, como un drop box,
-->
donde dice code, aquí en la parte de HTTPS, ves, ves este enlace, le das copiar, ¿sí?
-->
Y, por ejemplo, utilizando git bash, por ejemplo, puede servir, ya que lo tenemos ahí abierto.
-->
Hay que, primero, hay que meternos a la ruta en donde quieres que guardemos el repositorio.
-->
Yo les creé, según me acuerdo, una carpeta que se llama repositorios y se encuentra aquí en disco local.
-->
Aquí se van a usuarios y luego se van a nobleproj y aquí adentro hay una carpeta que se llama repositorios.
-->
Entonces, lo que pueden hacer es copiar este pad, ¿sí?
-->
Venís aquí al git bash o la terminal, no hay problema ahí, y entren ahí al, a la URL, bueno, al pad que acaban de pegar.
-->
Como esta tiene espacios, ah, bueno, no tiene espacios, la pueden poner así entre comillas simples o sin comillas y el chiste es que ya puedan entrar aquí a la ruta, ¿va?
-->
Entonces, una vez que ya estén ahí adentro, este, aquí ya pueden ejecutar este comando de git clone, git clone,
-->
y todo esto, según entiendo, viene en la presentación.
-->
Entonces, aquí lo voy poniendo, comparto en mi pantalla, git clone y aquí en el repositorio, ¿se acuerdan?
-->
En la ruta HTTPS la copiamos y es la que vamos a pegar ahí en el bash.
-->
Entonces, yo me meto aquí, le doy pegar y eso en automático, bueno, le doy enter y me va a estar descargando una carpeta que se llama user service.
-->
Aquí en mi, en mi carpeta de repositorios.
-->
Hay que hacerlo y avísenme si hay algún problema.
-->
Yo los voy a ir monitoreando y si necesitan que revisemos, repasemos, lo volvemos, lo volvemos a hacer.
-->
El de usuario, sí, el de usuario, el de producto y el de órdenes, por favor.
-->
Sí, gracias.
-->
A ver, voy a ver a tu máquina.
-->
Ah, pero te digo que...
-->
No.
-->
¿Quieres compartir o quieres que te lo repita a los pasos y los vas a seguir?
-->
Las comitas simples.
-->
Sí, a ver, intentalo con las comitas simples.
-->
Va.
-->
Los demás, si ya terminaron de copiar todos los repositorios, ayúdame también a ejecutar este comando, porfa.
-->
Que es git, espacio, config, espacio, guión, guión, list.
-->
Porque necesitamos ver que haya un user name y un user email configurado.
-->
Perfecto.
-->
Perfecto.
-->
Sale.
-->
Y bueno, ya que tengan los repositorios, ayúdenme a ejecutar este comando, git config list.
-->
Y déjenme ver quién ya lo tiene.
-->
Básicamente en el config list debe de aparecer hasta abajo un user name y un user email.
-->
Nada más seleccionense en el que si tenga un valor, por favor.
-->
Y en tu problemas en cuanto a esas propiedades.
-->
Adelante, dime en dónde.
-->
Ah, a ver, déjamelo comparto acá.
-->
Aquí lo voy a compartir.
-->
Este git config.
-->
No, ahí nada más.
-->
Fíjate si en el user name, al final dice user.name, user.email, que tenga un valor.
-->
De hecho tiene que decir capalata, no sé qué.
-->
Cuando ejecutaste el git config list te va a dar una serie de propiedades.
-->
Hasta abajo dice user.name y debe de venir un valor.
-->
Y para el user.email.
-->
Corre, corre.
-->
Ok, sale.
-->
Entonces ya que tenemos eso configurado, ya hay que bajarlos todos los repositorios que son el de producto, el de usuario y el de orden.
-->
Entonces eso ya nada más lo voy a ilustrar así de forma rápida.
-->
Básicamente lo que hicimos aquí en el de usuario, hay que hacer lo mismo, pero en el que se llama producto.
-->
Y en el que se llama orden.
-->
Es decir, lo abro.
-->
Por ejemplo, el de producto.
-->
Igual me va a aparecer aquí en la parte que dice code.
-->
HTTPS, le doy copiar a ese enlace.
-->
Y aquí en el bash, obviamente nada más me regreso un nivel.
-->
Ah, no, ahí estoy en repositorios.
-->
Ahí le doy otra vez git clone.
-->
Pego la url y me lo descarga.
-->
Vale.
-->
Eso mismo para los tres repos.
-->
Y listo.
-->
Ya que los tenemos ahí abiertos, los vamos a mantener ahí un ratito.
-->
En lo que voy a ir explicando cómo se crean los proyectos.
-->
Entonces, aquí en la diapositiva.
-->
Pues nos dice que yo voy a crear con initializer.
-->
Estos proyectos, este proyecto y le voy a setear.
-->
Está esta data o está esta meta.
-->
La metadata nos ayuda a este.
-->
Pues a describir a describir el proyecto.
-->
Entonces, este.
-->
Yo voy a ir creando.
-->
Por ejemplo, en el grope voy a poner con punto ATT.
-->
Que hace referencia, pues estamos trabajando aquí en AT&T.
-->
Entonces, si te fijas aquí en el grope.
-->
Tú puedes escribir AT&T.
-->
Va en el artifact.
-->
Pones user service.
-->
En este caso nosotros estamos viendo el de producto.
-->
Le pones producto.
-->
Service.
-->
Entonces, si te fijas ahí solito en automático.
-->
Ya te he puesto completo.
-->
Todo lo demás lo vas a dejar igual.
-->
Solamente si acaso puedes cambiar la descripción.
-->
Yo en este caso copio esta que tengo acá.
-->
La pego acá.
-->
El nombre del paquete.
-->
Lo único que hay que cerciorarse.
-->
Es no utilizar la parte de, bueno aquí es de productos.
-->
No hay que ocupar esto.
-->
No hay que ocupar esto.
-->
Ocupamos este.
-->
Y este.
-->
Estamos ocupando.
-->
El YAR.
-->
Estamos ocupando.
-->
Ya va a 17.
-->
Va.
-->
No voy a agregar dependencia.
-->
Si acaso sería bueno agregar la de Spring.
-->
Seleccionamos Spring Web.
-->
Y al hacer eso.
-->
Yo le doy generar.
-->
Y me va a descargar ya un paquete.
-->
Nada más que ahí.
-->
Espérame.
-->
Me equivoqué.
-->
Porque.
-->
Este está mal.
-->
Este product service está mal.
-->
Creo que es todo esto.
-->
Ya me lo quito.
-->
Me equivoqué porque no elegí Maven.
-->
No me había fijado.
-->
No elegí.
-->
Aquí se tiene que elegir Java.
-->
Aquí se tiene que elegir Maven.
-->
Aquí la versión de Spring que está bien esa.
-->
Porque de todo lo vamos a cambiar.
-->
Ahora sí.
-->
Ya con eso ya le das en generar.
-->
Cuando se genera.
-->
Se te va a abrir un archivo.
-->
Bueno se te va a descargar un archivo.
-->
Que es un zip.
-->
Y ese proyecto trae.
-->
Digamos todo lo que es un proyecto de Spring.
-->
Nativo.
-->
Así cero desde cero.
-->
Un proyecto desde cero.
-->
Y esto ahorita lo ilustré nada más.
-->
Para que vean como yo lo hice.
-->
Pero bueno al final ya el proyecto que se genera.
-->
Es el que yo voy a abrir.
-->
Por eso les pedí que descargaran el archivo.
-->
Es por ejemplo el de producto.
-->
Cualquiera de los tres de ese producto.
-->
Usuario o orden.
-->
Tienen la misma estructura.
-->
Entonces cuando tú lo abres en IntelliJ.
-->
Se te va a abrir este proyecto.
-->
Con estas mismas estructuras de carpetas.
-->
Te va a poner el nombre que le diste.
-->
Te va a generar estas carpetas.
-->
Te va a generar un archivo POM.
-->
Que es muy importante.
-->
Y lo vamos a ir repasando.
-->
Te va a generar un Ritme.
-->
Todo esto.
-->
El archivo importante que vamos a repasar ahorita.
-->
Es el POM.
-->
Entonces.
-->
Todo esto que fuimos dando de alta.
-->
Aquí en Spring Initializer.
-->
Que de hecho también se ve aquí en la presentación.
-->
Es decir.
-->
El Grove.
-->
El Artifact.
-->
Todo eso viene dentro.
-->
De nuestro archivo.
-->
POM.XML.
-->
Es un POM.XML.
-->
Porque yo elegí Maven.
-->
Y te fijas.
-->
Aquí viene.
-->
Como que el tema de con Maven.
-->
Porque está ocupando Maven.
-->
Como gestor de paquetes.
-->
Y Maven ocupa archivos XML.
-->
Diferente a Gradle.
-->
Por ejemplo que ocupan los JSON.
-->
Entonces.
-->
Esto fue meramente por.
-->
Por puro clasismo.
-->
Porque lo he hecho así mucho tiempo.
-->
Pero tú puedes haber elegido.
-->
Gestor de paquetes que ocupes.
-->
Entonces yo casi estoy seguro.
-->
Que ustedes también han ocupado Maven.
-->
Porque es como.
-->
Es el pionero.
-->
En esto de crear.
-->
Gestor de paquetes con.
-->
Con Spring.
-->
Entonces.
-->
Bueno.
-->
Todo esto que se fue dictando.
-->
Aquí en la metadata.
-->
Que se ve aquí en la.
-->
Presentación.
-->
Se va viendo en el POM.
-->
Por ejemplo el Grove.
-->
Que es con .att.
-->
Aquí lo tienes.
-->
Ahí vas a tener también.
-->
La parte del Artifact.
-->
Tienes el Name.
-->
¿Se acuerdan?
-->
Aquí nada más voy a dejar.
-->
Esta propiedad así en azul.
-->
¿Se acuerdan?
-->
Que les decía que con Eureka.
-->
Hay una propiedad que se ocupa mucho.
-->
Y es el Name.
-->
Bueno este es el Name.
-->
Que se le da al proyecto en el POM.
-->
Que es diferente a la que se le da.
-->
En el archivo de configuración.
-->
Pero básicamente nos referimos a esa propiedad.
-->
Al nombre del microservicio.
-->
Aquí tiene una pequeña descripción.
-->
De propiedades.
-->
Tiene como versión 17.
-->
Que es la que vamos a estar ocupando.
-->
Tiene la biblioteca de Spring Boot.
-->
La versión 2.6.
-->
2.6.3 que es la que.
-->
Aquí dicta que descarguemos.
-->
Sale.
-->
Tiene todo esta parte.
-->
Va.
-->
Entonces esto.
-->
Es lo que se va creando.
-->
Si nosotros creamos eso desde Spring Initializer.
-->
Le damos descargar.
-->
Nos va a generar este archivo.
-->
Esta estructura de proyectos.
-->
Aquí obviamente.
-->
Yo la pongo ya ilustrada.
-->
Directamente desde el repositorio que me baje.
-->
Porque bueno.
-->
Para que ya se vean las otras dependencias.
-->
Que le fui agregando.
-->
Que fuera de Postgres.
-->
Que fuera la de JPA.
-->
Para manejo de base de datos.
-->
La parte del módulo de prueba.
-->
Que se agrega pero no se ocupa.
-->
Aquí no vamos a hacer nada de testing unitario.
-->
Y esta es la dependencia que se agrega.
-->
De Spring Web.
-->
Aquí adentro también hay una configuración.
-->
Que se agrega.
-->
Para evitar que corran las pruebas unitarias.
-->
Entonces este se agrega.
-->
Y pues listo.
-->
Con detalle.
-->
Este es el archivo pump.
-->
Que se encuentra en nuestro repositorio.
-->
Del microservicio.
-->
Product Service.
-->
Entonces.
-->
Eso es básicamente esta parte.
-->
Aquí tú creas el proyecto.
-->
Y es lo que te decía.
-->
Te va a generar una estructura de este tipo.
-->
En este caso tienes el Product Service.
-->
Source.
-->
Java.
-->
User Service hasta llegar a la aplicación.
-->
Principal.
-->
Que es la que tiene el método main.
-->
Entonces esa también la podemos encontrar nosotros.
-->
Que está en main.
-->
Java.
-->
Entonces para eso.
-->
Aquí básicamente es lo mismo.
-->
En la raíz del proyecto.
-->
Buscas la carpeta.
-->
Java.
-->
El paquete.
-->
Y si te fijas aquí viene nuestra clase principal.
-->
Viene nuestra clase principal.
-->
Está decorada con este método main.
-->
Tiene esta anotación.
-->
Que es la que ya habíamos repasado.
-->
Que nos permite identificar esta clase.
-->
Como una clase Spring Boot Application.
-->
Es decir que se va a autoconfigurar.
-->
Se va a autoconfigurar.
-->
Entonces yo no me voy a pelear ahí con.
-->
Problemas de configuración y nada de eso.
-->
IntelliJ.
-->
Otra cosa es que tiene una.
-->
Tiene un mecanismo.
-->
Para que detecte lo que son estos métodos main.
-->
Dentro de las clases.
-->
Y tienen este triangulito.
-->
Si tú le picas.
-->
Ahí solito te corre toda la aplicación.
-->
Te corre el proyecto.
-->
Entonces bueno.
-->
Esta es la parte de cómo se crea el Product Service.
-->
Desde Spring Initializer.
-->
Ahorita todavía no hemos hablado de estas carpetas.
-->
De hecho en la presentación no se ven.
-->
Como les decía esto.
-->
Que bajamos del repositorio.
-->
Ya está más completo.
-->
Para que vayamos explicando cada uno.
-->
Y luego lo podamos replicar.
-->
En los otros microservices.
-->
Entonces hasta aquí.
-->
Llega a donde se ve la parte de la clase main.
-->
Con Java.
-->
Digo con el microservicio de producto.
-->
Y su archivo pom.
-->
Va.
-->
Que es como lo básico que te descarga.
-->
Spring Initializer.
-->
Hasta aquí alguna.
-->
Duda algún comentario.
-->
Perfecto.
-->
Súper.
-->
Vale.
-->
Entonces aquí.
-->
Vamos siguiendo la demo.
-->
Y.
-->
El objetivo de crear.
-->
El objetivo es crear un CRUD.
-->
Mejor dicho.
-->
En cada uno de los tres microservicios.
-->
Es decir nosotros vamos a tener un CRUD.
-->
De usuarios.
-->
Vamos a tener un CRUD de productos.
-->
Y un CRUD de órdenes.
-->
Y ese CRUD se llama así.
-->
Por las siglas del.
-->
En inglés.
-->
Que vienen a ser un create.
-->
Un read.
-->
Un update.
-->
Y un delete.
-->
Que son básicamente las operaciones.
-->
De lectura, escritura.
-->
Actualización y borrado.
-->
Para.
-->
Alguna entidad.
-->
En este caso usuarios.
-->
Entonces para nosotros.
-->
Hacer este CRUD.
-->
Que básicamente se va a exponer como un API.
-->
Nosotros vamos a crear.
-->
Endpoints.
-->
En este caso vamos a crear cinco endpoints.
-->
¿Por qué cinco? Porque el get.
-->
Que viene a ser el read.
-->
Se acostumbra a crear.
-->
Dos por default.
-->
Uno que te de todo.
-->
Todos los registros de esa.
-->
Entidad de la tabla de usuarios.
-->
Y también te de el usuario.
-->
Por ID.
-->
Uno en específico.
-->
Pasando el ID.
-->
Va.
-->
Entonces son dos de get.
-->
Y los demás pues ya es el de post.
-->
Es el que nos va a ayudar a hacer el alta del nuevo usuario.
-->
El put.
-->
La actualización.
-->
De alguna información.
-->
De un cierto usuario.
-->
Pasando el ID.
-->
Y el delete. Que es el borrado.
-->
Del usuario.
-->
También pasando el ID.
-->
Entonces estos son los endpoints.
-->
Que vamos a estar mapeando.
-->
Que vamos a estar creando en cada uno de los microservicios.
-->
Bien. Entonces.
-->
Aquí nos dice cómo vamos a crear.
-->
Los endpoints.
-->
Para dar de alta usuarios.
-->
Y para obtenerlos.
-->
Es decir el post y el get.
-->
Y bueno.
-->
Aquí nos va a ir describiendo.
-->
Cómo se va a ir dando de alta.
-->
Y para qué sirve cada una de las clases.
-->
Nos vamos a ir detallando.
-->
Una por una.
-->
Entonces aquí te dice básicamente.
-->
Que tienes que crear.
-->
Los siguientes paquetes.
-->
Esos paquetes como les digo.
-->
Yo aquí en este microservicio.
-->
Que ya les estoy mostrando.
-->
Ya están hechos.
-->
Y lo dice así para que ustedes ya puedan ver.
-->
Cómo queda el producto final.
-->
Y esto ustedes lo van a retomar.
-->
Cuando les toque hacer el de usuario.
-->
Y el de órdenes.
-->
Que es básicamente acabando este micro.
-->
Pues básicamente aquí.
-->
Lo que te dice es que tú te pares.
-->
En el paquete raíz.
-->
En AT&T user service.
-->
O product service.
-->
Y tú le des.
-->
Bueno crees los siguientes paquetes.
-->
Que básicamente es crear.
-->
Carpetas.
-->
Controller, model, LTO, repositor y service.
-->
Va. Entonces.
-->
Voy a crear yo por ejemplo una que se llame.
-->
Controller 2. Como para ver cómo.
-->
Ilustrar cómo se crea el paquete.
-->
Sí. Simplemente le das new.
-->
Eliges package.
-->
Y ahí pones el nombre de la carpeta que quieres.
-->
O sea yo por ejemplo voy a crear controller.
-->
Ahí ya me marca que ya existe.
-->
Porque ya existe.
-->
Lo voy a poner así. Controller 2.
-->
Y ya va a crear ese paquete.
-->
Si tú te fijas se crea como una carpeta.
-->
Los paquetes al final son esos.
-->
Carpetas. Entonces.
-->
Esa es la forma en la que tú vas creando.
-->
Los paquetes.
-->
Va. Yo aquí los voy a ir.
-->
Los voy a ir quitando.
-->
Porque no tiene caso que los guarde.
-->
Pero bueno.
-->
Esto es la forma en la que creas el paquete.
-->
Controller.
-->
También ahí te va a ir diciendo que quieres el carpet.
-->
El paquete.
-->
De modelo.
-->
DTO, de repositor y de servicio.
-->
Entonces vas a tener.
-->
Controller, modelo.
-->
Aquí está. Vas a tener.
-->
DTO, servicio y repositor.
-->
Son los paquetes que vamos a estar ocupando.
-->
Nuestras capas.
-->
Por así decir.
-->
¿Para qué sirve cada una? Bueno.
-->
El controller.
-->
Nos sirve para almacenar las clases controladoras.
-->
Que van a manejar las peticiones.
-->
De los endpoints.
-->
Es decir que ahí en esa clase controller.
-->
Tú vas a encontrar mapeados estos endpoints.
-->
Va para cada entidad.
-->
La clase de modelo.
-->
Te almacena la clase.
-->
El modelo.
-->
Básicamente.
-->
En este caso aquí se habla del modelo de usuario.
-->
Nosotros aquí en nuestra tabla.
-->
En nuestro microservicio de productos.
-->
En la carpeta modelo.
-->
Pues vamos a ver nuestro modelo de producto.
-->
Ahorita vamos a ver cómo se crea todo esto.
-->
Ahorita nada más ilustro.
-->
Que contiene.
-->
¿Va?
-->
¿Para qué nos sirve el DTO?
-->
Básicamente son las clases.
-->
Que nos permiten pasar.
-->
La data.
-->
Desde que llega una petición.
-->
Hasta que se almacenen la base de datos.
-->
¿Va?
-->
Entonces ese DTO lo vas a encontrar.
-->
Al mismo nivel que el controller.
-->
¿Por qué? Porque aquí es donde llega la petición.
-->
¿No?
-->
Entonces, ah, déjame.
-->
Acepto a una persona.
-->
Listo.
-->
Entonces tú aquí por ejemplo.
-->
Tienes los DTOs.
-->
Si te fijas ahí lo subrayo.
-->
Lo selecciono.
-->
Y se colorea.
-->
¿No? En donde se está ocupando.
-->
Entonces básicamente esos DTOs.
-->
Nacen.
-->
Conforme también nace el modelo.
-->
Lo voy a ver nada más como para que lo veas.
-->
De reojo ahorita.
-->
Y si te fijas es muy similar a nuestra clase modelo.
-->
Solamente que esto no sirve.
-->
Para hacer persistencia.
-->
Simplemente es para pasar información.
-->
De un request hacia un modelo.
-->
¿Va?
-->
Para eso sirve.
-->
Ahorita vamos a ir viendo cómo se crea cada clase.
-->
El repositorio es el paquete.
-->
Que nos permite utilizar.
-->
La interfaz y user repository.
-->
Que es la que va a interactuar con la base de datos.
-->
Nosotros con.
-->
Las librerías de JPA.
-->
Vamos a poder mapear.
-->
A través de interfaces.
-->
El CRUD.
-->
Tan sencillo.
-->
Entonces en el repositorio.
-->
Tú te vas a encontrar esta entidad.
-->
Que es el product repository.
-->
Que básicamente nada más es.
-->
Extiende, extender del repositorio de JPA.
-->
Y con eso.
-->
Se acuerdan de la definición de Spring.
-->
Spring Boot.
-->
Nada más mapeas de una forma.
-->
Bonita.
-->
De una forma que.
-->
Que te pide que mapees Spring.
-->
Y en automático te hace todo.
-->
Aquí tú ya tienes.
-->
Todo un CRUD.
-->
Aquí tú ya puedes ocupar todos los métodos.
-->
Para hacer alta baja consulta.
-->
Simplemente con estas líneas.
-->
Y diciéndole de qué.
-->
Entidad.
-->
Quieres que sea ese CRUD.
-->
Y obviamente este JPA repository.
-->
Hace caso de lo que viene.
-->
Aquí en este application.
-->
Que ahorita lo vemos a detalle.
-->
Todavía no hemos hablado de él.
-->
Ya lo habíamos hablado al principio.
-->
Pero a detalle de este no.
-->
Pero si te fijas.
-->
Este es un archivo de configuración.
-->
De los que platicábamos al inicio.
-->
Y aquí se ve cómo viene la base de datos.
-->
La connection string.
-->
Entonces ese connection string.
-->
Es el que está ocupando.
-->
Nuestro repositorio.
-->
Para conectarse a la base de datos.
-->
De productos.
-->
Ahí él va a encontrar una tabla.
-->
Que se llama producto.
-->
Todo esto está mapeado, está en automático.
-->
Si te fijas yo nada más meto.
-->
Nombres de forma correcta.
-->
Y en automático Spring entiende.
-->
Lo que tiene que hacer.
-->
Y ya con eso él.
-->
Se va a encargar de hacer todo el crud.
-->
De productos.
-->
Y después de esto.
-->
Viene la parte del servicio.
-->
Que nos sirve para.
-->
Prácticamente ser la lógica de negocio.
-->
Entonces ese paquete.
-->
Se encuentra aquí en service.
-->
Y tiene dos clases.
-->
La interfaz que nos define.
-->
El que se va a hacer.
-->
Que básicamente son los métodos de los cruds.
-->
El get all.
-->
El get by ID.
-->
El create, el update, el delete.
-->
Y la implementación que nos dice.
-->
Cómo se va a hacer cada uno de esos métodos.
-->
Que no es más que utilizar el concepto de.
-->
Inyección de dependencias.
-->
Y estar ocupando.
-->
Por ejemplo un get all productos.
-->
O usar el repositorio.
-->
Que es este.
-->
Se está creando una instancia en ese repositorio.
-->
Y como te decía.
-->
Ya tienen los métodos ya guardados.
-->
Aquí yo no le.
-->
Definí ningún método.
-->
Ya los trae por default.
-->
Aquí tienes un find all.
-->
Un find by ID.
-->
Vas a tener también un delete.
-->
Un save.
-->
Y por ahí también viene el update.
-->
Entonces esto es este.
-->
Básicamente el cómo funciona.
-->
Lo vamos a ver a detalle.
-->
Clase por clase.
-->
Ahorita nada más estoy como.
-->
Repasando que contiene cada.
-->
Cada este cada paquete.
-->
Va.
-->
Y si te fijas.
-->
En la siguiente diapositiva.
-->
Te dice que así quedaría la estructura.
-->
El mapa.
-->
Tu clase main.
-->
Tu paquete controller con su clase.
-->
Tu paquete model con su clase.
-->
Tu paquete DTO con su clase.
-->
Tu paquete repositorio con su clase.
-->
Tu paquete service con sus clases.
-->
Que son básicamente las mismas.
-->
Que nosotros ya.
-->
Fuimos revisando.
-->
Tu clase tu paquete principal.
-->
El controller su clase.
-->
El DTO su clase.
-->
El modelo.
-->
Repositorio el servicio.
-->
Y tu clase main.
-->
Bueno incluso aquí en el mapa se ve.
-->
El resource.
-->
El resource es.
-->
Y otro archivo muy importante.
-->
El pom.
-->
Hasta aquí hay alguna duda de cómo se.
-->
Piensa la aplicación.
-->
Más o menos va a entender qué es lo que se hace.
-->
En cada.
-->
En esta aplicación. En este micro servicio de producto.
-->
O en esta aplicación de producto.
-->
Hola hola. ¿Todo bien?
-->
Perfecto. Entonces.
-->
Igual es.
-->
Y dicen que repasemos las cosas.
-->
No hay ningún problema.
-->
Entonces bueno.
-->
Esto es como la embarrada de.
-->
Que es lo que lleva cada clase.
-->
Más bien cada paquete.
-->
Y ahorita vamos a ver en detalle cada clase.
-->
Entonces listo.
-->
Ahora sí.
-->
Aquí es donde te dice.
-->
Te va a ir diciendo cómo ir creando cada clase.
-->
En cada paquete.
-->
Y para que se ocupa.
-->
Entonces este.
-->
Todo eso.
-->
Lo voy a explicar a través de este diagrama.
-->
Que bueno.
-->
Este diagrama es ya más bien este.
-->
Ya más bien la parte de.
-->
Agregarlo.
-->
Con este.
-->
Con la iniciativa de la nube.
-->
Entonces esto.
-->
No voy a.
-->
No lo vamos a.
-->
Todavía hasta crear los microservicios.
-->
Y bueno.
-->
Nos vamos a quedar en esta parte.
-->
Vamos a ver con detalle.
-->
Ya la aplicación.
-->
La del producto.
-->
Para que la podamos.
-->
Desarrollar en el otro.
-->
En el otro.
-->
En el otro micro.
-->
Entonces esta aplicación de producto.
-->
Ya vimos cómo se creó con.
-->
Initializer.
-->
La abrimos aquí en Intel y.
-->
Y.
-->
Identificamos un archivo importante.
-->
Que es el POM.
-->
En el POM.
-->
Nada más hay que cerciorarse.
-->
De que lo tengas.
-->
Igual que aquí.
-->
Es decir tienes que tener.
-->
Bueno yo estoy en una rama.
-->
Que se llama feature first day.
-->
Eso es otra de las cosas que tal vez también.
-->
Tendríamos que ir.
-->
Hablando.
-->
En los repositorios que les pasé.
-->
Producto orden usuario.
-->
Si te fijas.
-->
Existen tres ramas.
-->
Bueno de hecho en todos los repositorios existen tres ramas.
-->
Existe tu rama main.
-->
Tu rama develop.
-->
Y tu rama feature first day.
-->
Esta rama feature first day.
-->
Es la que.
-->
De la que ustedes van a tener que crear.
-->
Una nueva rama.
-->
Con sus iniciales.
-->
Para cada microservicio.
-->
Y ahí es donde vamos a estar trabajando.
-->
Esas ramas que van a ir creando.
-->
Ustedes con su.
-->
Inici con su inicial.
-->
Son las que van a estar.
-->
Desarrollando.
-->
En este caso por ejemplo.
-->
El de producto que ya está.
-->
Terminado.
-->
La rama de feature first day.
-->
Ya está ahí completa.
-->
Ya tiene todo.
-->
Pero por ejemplo la de usuario.
-->
La de órdenes.
-->
No tiene.
-->
Completos todos los paquetes.
-->
Todas las clases demás.
-->
Entonces el objetivo del ejercicio.
-->
Del día de hoy.
-->
Cuando ya terminemos.
-->
Va a hacer hacer el cruz de usuario.
-->
Bueno completar el cruz de usuario.
-->
Y el de órdenes.
-->
Basándose en el de producto.
-->
Va ese es el objetivo.
-->
Entonces en este producto.
-->
Por eso hago alusión de la rama.
-->
Porque yo estoy igual.
-->
En la rama de feature first day.
-->
Que es esta.
-->
Y en esta estoy creando este.
-->
Pues esto.
-->
Entonces estoy creando aquí el.
-->
La estructura.
-->
La definición del proyecto.
-->
Con maven.
-->
Perdón con spring initializer la cree.
-->
Obviamente utilizando maven.
-->
Y bueno se ve toda la metadata que fui.
-->
Dándole de alta.
-->
Y fui creando su group ID.
-->
El artefacto el name el description.
-->
Sus properties.
-->
La versión de Java la versión de spring boot.
-->
Agregue dependencias.
-->
Como spring web.
-->
Agregue.
-->
Spring starter boot.
-->
Para que sea spring boot.
-->
Agarré la parte de JPA.
-->
Agregue el driver de.
-->
Postgres.
-->
Y estas configuraciones.
-->
Adicionales.
-->
Para que no tomen cuenta.
-->
El testing unitario.
-->
Una vez que ya tengo hecho esto.
-->
Yo con maven aquí tiene.
-->
IntelliJ tiene incorporada.
-->
Una.
-->
Digamos un maven.
-->
Tiene maven incorporado.
-->
Entonces yo con eso puedo.
-->
Hacer la descarga de paquetes.
-->
Ya sueno la.
-->
Ya sueno la alarma.
-->
Me va a dar un.
-->
A hacer rápido.
-->
Unos últimos 5 minutos.
-->
Porque este es el último descanso.
-->
Es el descanso largo.
-->
A ver ahorita lo hablamos.
-->
Yo teniendo maven aquí.
-->
Incorporado.
-->
Puedo hacer la.
-->
Sincronización y al presionar.
-->
Este botón me va a estar descargando.
-->
Los paquetes.
-->
Que paquetes va a descargar.
-->
Maven en automático va a reconocer.
-->
que se trata de un proyecto Maven porque existe un POM.
-->
Entonces, al existir un POM, Maven, su naturaleza es venirse a este archivo
-->
y va a ir leyendo todas las dependencias que tienes aquí tú dadas de alta.
-->
Y las va a ir a buscar en un repositorio global que se llama el Maven Repository.
-->
Y va a empezar a buscar estas dependencias y las va a descargar en tu proyecto.
-->
Las va a ir descargando y se van a ir guardando en una carpeta
-->
que se llama external libraries, ¿va?
-->
Entonces, si te fijas aquí, todas estas librerías,
-->
ya las puedes cargando de Maven.
-->
¿Esto para qué sirve?
-->
Pues para que el día de mañana que tú quieras ocupar un,
-->
no sé, una librería que te transforme o que te ayude a manejar validaciones
-->
en JSONs o crear JSONs o no sé,
-->
algo que te manejo de fechas, bibliotecas externas,
-->
las puedas ocupar.
-->
Por ejemplo, yo las voy a usar para manejar
-->
la persistencia con JPA.
-->
Y mañana que vayamos agregando más miembros en la familia de Spring Cloud,
-->
más librerías, aquí las vamos a meter, ¿no?
-->
Para que podamos utilizar Fame Client, Eureka, el Config Server,
-->
todo eso lo vamos a ir agregando aquí en Maven, ¿va?
-->
En las dependencias.
-->
Entonces, esto es cómo funciona un pump,
-->
así como a nivel rápido, a grandes rasgos.
-->
Y bueno, en específicamente cómo funciona el pump de nuestro
-->
microservicio de productos, ¿va?
-->
Entonces, a ver, aquí es que fíjense que me cambiaron la jugada
-->
porque yo estaba acostumbrado a dar el curso de 8 a 4, ¿va?
-->
Entonces, ahorita ya se hizo, o sea,
-->
se me cambia porque ya empezó a las 9 y ya se traslapa una hora que es,
-->
no sé, en mi curso anterior a estas horas ya era la hora de la comida.
-->
¿Quieren que hagamos ahorita mejor la hora de la comida?
-->
¿Demos la hora de receso una hora?
-->
¿O damos el descanso largo y después tomamos otra sesión de 45 minutos
-->
y después haríamos la hora de comida?
-->
¿Cómo les funciona más?
-->
¿Sí?
-->
Perfecto.
-->
Entonces, podemos hacer esto, miren,
-->
podemos campechanear, podemos seguirnos ahorita de aquí hasta las 2.
-->
Y porque ahorita ya se tendría que tomar el pomodoro,
-->
el descanso largo de 25 minutos.
-->
¿Qué les parece si hacemos esto?
-->
Nos seguimos de aquí a las 2, a las de 2 a 3, la hora de la comida.
-->
Y después de la hora de la comida seguimos con los pomodoros,
-->
pero en uno de esos en vez de descansar 5 minutos,
-->
hacemos el descanso de los 25.
-->
¿Va?
-->
Va.
-->
Entonces, ah, bien, perfecto.
-->
Entonces, vamos a darle de aquí a las 2.
-->
Continuamos y tomamos ya la hora de la comida.
-->
Sal y vale.
-->
Entonces, va.
-->
Entonces, esta es la parte del pom, ¿sale?
-->
Este es el fichero que se crea, que se ocupa con Maven, ¿sale?
-->
Bueno, después de este archivo,
-->
otro archivo importantísimo es el application.yaml.
-->
Este archivo es el que les decía que es el archivo de
-->
configuración.
-->
Este archivo se puede llamar application.yaml,
-->
también lo van a encontrar como application.properties,
-->
o incluso hay otros que se llaman bootstrap.yaml, ¿va?
-->
Son archivos que le brindan a tu proyecto configuración.
-->
Por ejemplo, el ejemplo creo que más común es el de la
-->
base de datos.
-->
Simplemente, yo al declarar un archivo application.yaml en la
-->
carpeta resources, la configuración de Spring Boot en
-->
automático va a entender que este es un archivo de
-->
configuración.
-->
Y todavía más, aún más inteligente,
-->
va a entender que si tú creas esta estructura de
-->
propiedades, en este caso Spring Datasource,
-->
URL y username and password, va a entender que cuando tú
-->
estás trabajando con un modelo basado en persistencia de JPA,
-->
que es su biblioteca, su framework interno,
-->
Hibernate, toda esta parte, cuando tú crees repositorios,
-->
¿sí?
-->
Cuando tú extiendas clases de este JPA y pases el modelo
-->
y demás, esto en automático,
-->
la configuración de Spring Boot va a entender que se tiene
-->
que conectar a una base de datos que se llama
-->
productdb en el puerto 5433 del host local con el
-->
username y con este password.
-->
Todo eso lo va a entender en automático, ¿sí?
-->
Cuando eso suceda, ya aquí te va a brindar de ciertos
-->
métodos que son suficientes para hacer un crud, ¿va?
-->
Esa es como funcionaría la parte de la configuración de
-->
base de datos.
-->
Ahora, esta connection string, ¿de dónde la sacamos?
-->
Si se acuerdan que ya hicimos un ejercicio en donde nos
-->
conectamos a la base de datos de cada uno de ellos,
-->
de cada entidad.
-->
Y si se acuerdan, todo eso nació de este archivo que
-->
teníamos que se llama Docker Compose.
-->
Aquí adentro ustedes pueden ver o repasar y extraer las
-->
conexiones.
-->
Aquí tienes, por ejemplo, el usuario, el password y la
-->
base de datos.
-->
También tienes el puerto, ¿sí?
-->
Con eso tienes aquí todo mapeado para que tú puedas
-->
conectarte aquí en la base de datos, ¿va?
-->
Y, bueno, eso es con respecto a la base de datos.
-->
Pero el propósito, o sea, lo que trató de ilustrar es el
-->
propósito de este archivo.
-->
Este archivo, entonces, lo que nos permite hacer es
-->
definir propiedades que son globales a todo tu proyecto,
-->
¿sí?
-->
Esta es la que les decía que es muy, muy importante, esto.
-->
Cuando vean el Spring Application Name,
-->
este name es importante porque a lo mejor aquí ahorita tú lo
-->
defines y lo puedes ocupar para ciertas cosas,
-->
lo que tú quieras.
-->
Para mandar un mensaje cada vez que haces una petición en
-->
tus blogs, sepas de qué microservicio estás hablando,
-->
Está bien.
-->
Pero más allá, más al fondo,
-->
mañana que estemos trabajando con Eureka,
-->
este name es imprescindible, ¿no?
-->
Porque este es el name que les decía que con el que Eureka va
-->
a identificar a cada microservicio, ¿sí?
-->
Y los van a mascarar.
-->
Entonces te vas dando cuenta que todo tiene un por qué,
-->
Aquí, por ejemplo, el server te dice en qué servidor está
-->
corriendo o en qué servidor quiero que corra,
-->
mejor dicho, ¿va?
-->
Entonces, cuando yo lo levante,
-->
este proyecto va a correr en el puerto 8082.
-->
Muy importante que si yo estoy creando una familia de
-->
microservicios o una nube de microservicios,
-->
pues a cada micro le de un puerto diferente, ¿no?
-->
A cada puerto le de, a cada proyecto le de un puerto
-->
diferente.
-->
Aquí también le estoy diciendo a qué nivel quiero que
-->
se metan los logs, etcétera, etcétera, ¿no?
-->
Entonces, si tú te fijas en el Application Jam ni en el
-->
POM, yo he descargado alguna librería o he
-->
agregado alguna configuración que digan que
-->
este proyecto se trate de que sea un microservicio.
-->
O sea, yo en ningún momento le dije microservicio igual a
-->
True o algo así, ¿no?
-->
O descargue una librería que me sirva para crear un
-->
microservicio.
-->
Este, o sea, no, no es que sea un tipo de proyecto nuevo y
-->
demás, ¿no?
-->
O sea, es un proyecto tal cual hemos estado trabajando,
-->
¿no?
-->
Pero que al momento de yo irlo configurando con estas
-->
librerías, digamos, de esta forma,
-->
sirve para que sea tratado como un microservicio, ¿no?
-->
Esto es para que lo tengan identificado.
-->
Esto es un microservicio.
-->
Así se ve, ¿va?
-->
Entonces, este en específico es nuestro microservicio de
-->
productos, ¿sí?
-->
Microservicio de, de, de microservicio de productos.
-->
Sale, entonces, este, listo.
-->
Hasta aquí alguna duda con estos dos archivos.
-->
Más o menos se ilustra de cómo para qué sirven.
-->
A grandes rasgos.
-->
Adelante.
-->
¿De cuál, perdón?
-->
Ah, OK.
-->
Este YAML.
-->
Sí, sí, es muy parecido.
-->
De hecho, ambos son extensión YAML, si te fijas.
-->
Es YML.
-->
Este también es YML.
-->
Es que lo que pasa es que YAML es un formato pues ya
-->
es más estándar, ¿no?
-->
OK.
-->
OK.
-->
Este sí, son, digamos, ahorita si yo lo quitará,
-->
no, no le, no le afectaría.
-->
No le afectaría porque ahorita nadie lo está ocupando,
-->
ni siquiera el código.
-->
Pero ahí, vete, más adelante vamos a ocupar estas
-->
variables justo en la práctica del config server y
-->
el config repo.
-->
Para que nosotros podamos hacer uso de estas variables,
-->
ocupamos una anotación que es el value.
-->
Y ese value nosotros ya lo podemos utilizar en cualquier
-->
parte del método.
-->
Aquí no se va a ver porque no,
-->
no hemos llegado a ese punto.
-->
Pero utilizando ese value vamos a poder utilizar los
-->
valores de estas variables.
-->
Perdóname, te entendí de si esta propiedad name tiene que
-->
ser igual a cuál otra, ¿perdón?
-->
Ah, OK.
-->
Ah, no, no, no.
-->
Son independientes.
-->
Digamos que esta es como la,
-->
el name que tú le das al empaquetado de tu,
-->
de tu proyecto, ¿no?
-->
Pero esta es la de tu,
-->
la de la configuración,
-->
como, como dijimos,
-->
interna de tu,
-->
de tu proyecto, ¿no?
-->
Esa es una muy buena observación.
-->
Pero sí, no, no, no.
-->
Son diferentes propiedades, ¿va?
-->
Perfecto.
-->
¿Alguna otra duda?
-->
Correcto.
-->
Sí.
-->
Sí, aquí en la práctica tú puedes tener,
-->
es que generalmente el tema de microservicios están
-->
empaquetados, ¿no?
-->
En contenedores de Docker.
-->
Entonces,
-->
son instancias o te conectas más bien a un grupo de
-->
réplicas que vienen metidas dentro de cierto contenedor.
-->
Ahí te facilita mucho Kubernetes y muchos de esos
-->
software.
-->
Pero para fines prácticos sí,
-->
son urls diferentes al localhost.
-->
Este te van a exponer una url,
-->
un puerto,
-->
un usuario y esas son las conexiones que tú,
-->
que tú debes de seguir.
-->
Va, perfecto.
-->
Sale y vale.
-->
¿Alguien más que nutra este ejercicio con sus
-->
preguntas u observaciones también válidas?
-->
Perfecto.
-->
Sale y vale.
-->
Entonces,
-->
si no hay,
-->
continuamos.
-->
Entonces,
-->
es muy importante esos dos archivos,
-->
ya que al estar haciendo muchos microservicios los
-->
vamos a estar viendo.
-->
Creo que más que el código de programación.
-->
Es más configuración.
-->
Pero bueno.
-->
Ok.
-->
Entonces,
-->
aquí en la parte de ya entrando a detalle,
-->
cada una de estas paquetes que se ilustran como
-->
carpetas,
-->
contienen clases,
-->
contienen ciertas clases que hacen un algo.
-->
La clase,
-->
el paquete principal,
-->
que es este paquete raíz,
-->
donde está el nombre de tu micro.
-->
Tú tienes una clase
-->
main,
-->
que se llama,
-->
como se llama tu microservicio,
-->
ProductServiceApplication.
-->
Esa clase,
-->
como te decía,
-->
tiene un código,
-->
un método main,
-->
que es un public static void main,
-->
que es aquí donde nace todo.
-->
Esta es la que ejecuta todo.
-->
esto es muy importante que si estamos trabajando
-->
en el framework de Spring Boot,
-->
pues la decoremos con la anotación
-->
spring-arroba-spring-boot-application
-->
para que haga todo lo que incluso aquí
-->
te no dice,
-->
autoconfiguración.
-->
Para que toda esa autoconfiguración funcione,
-->
debe estar marcada de esta forma.
-->
Son de las pocas cosas que te pide Spring Boot,
-->
como para que
-->
tengas ahí cuidado.
-->
Y todo funciona.
-->
Y el IDE de IntelliJ,
-->
si te fijas aquí ya tiene un botoncito,
-->
que si tú le picas,
-->
en automático te dice que si lo quieres correr,
-->
lo quieres debugging,
-->
le quieres correr la cobertura,
-->
etcétera, etcétera, etcétera.
-->
Entonces,
-->
eso es lo que tendríamos,
-->
en esta clase main.
-->
De esta clase,
-->
creo que ya la conocen,
-->
de otros proyectos,
-->
¿tienen alguna duda con esa clase?
-->
Perfecto.
-->
Entonces, si no...
-->
Adelante.
-->
Ah, ok.
-->
No te lo estaba abriendo así.
-->
Ah, listo.
-->
No.
-->
Ok.
-->
Qué bueno que salió eso.
-->
Adelante.
-->
¿Meicky le picas un stirme?
-->
Sí, puede ser que no hayas bajado las dependencias,
-->
es decir, aquí dentro del PUM te va a aparecer un circulito azul,
-->
o aquí en Maven,
-->
le puedes picar, es este circulito.
-->
Fíjate que también yo lo he notado.
-->
Yo lo he notado en otros proyectos.
-->
¿Qué pasa?
-->
Cuando tu abres un proyecto,
-->
aquí te aparece como una notificación
-->
que te dice que si quieres cargarlo como un proyecto me iven o algo así ahí tú le
-->
dices que sí y en automático te lo tiene que transformar de esta forma incluso no
-->
sé si se vea aquí en la campanita de notificaciones probablemente y venga
-->
lo si lo he notado fíjate que si me ha pasado probablemente lo puedas tuver si
-->
si no lo que te recomendaría es volver a salir del proyecto porque creo que no
-->
sé si no te deja incluso descargar los paquetes eso es porque no lo
-->
conoce como un proyecto me iven hay veces que medio sea tonta también
-->
inteligente entonces lo que puedes hacer es salir del proyecto y volverlo a abrir
-->
y te tiene que abrir una notificación algo así que te dice algo como
-->
tratarlo como proyecto me iven no importar no algo así tú le dices que
-->
sí y ya te ya te lo tiene que tratar de esta forma si si me ha pasado
-->
ok ok
-->
a en abrir proyecto le das file open project y ya te aparece y va bien
-->
sale entonces esto que explicábamos es la parte
-->
de la clase me salí bien ahora ya que fuimos creando si se acuerdan del paso
-->
anterior fuimos creando los paquetes que al final se ven como carpetas si lo
-->
fijas si te fijas y al final esos son los paquetes son formas de
-->
acomodar las clases en agrupar las clases es un paquete es eso es una
-->
carpeta entonces aquí las inteligen las va a tratar así y dentro de cada una
-->
de ellas tú vas a ir viendo las clases entonces si tú te fijas
-->
la clase la primerita donde va a caer la petición cuando la expongamos
-->
este este micro es en el controller que hago para que una clase sea
-->
tratada como un controller bueno tu folder se llama control va tu clase que
-->
se llama product debe determinar con la notación controller en este caso yo
-->
estoy utilizando un controlador de productos porque vamos estoy hablando de
-->
mi microservicio de products va entonces mi product controller
-->
estas son de las cosas que les digo que springboard toma como
-->
si tú me dices que esta clase se llama controller yo sé que es un controlador
-->
y él entiende cómo lo debe de tratar él va a en automático va a estar
-->
escaneando tu clase y te va a decir oye te falta la notación rest
-->
controller que onda y te va a empezar a mandando errores no te va a
-->
empezar a ir mandando errores en caso de que no encuentre algo de
-->
autoconfiguración eso en lo personal a mi experiencia también es un
-->
problema y es una lata porque luego tú dices pero porque es el error cierto
-->
error y es que uno tiene que entender o tiene que aprender de cómo se
-->
autoconfigura cada cosa entonces eso también es un problemita para mi
-->
punto de vista no sobre todo también para los que van empezando dices y
-->
a mí a mí me llegó a pasar la verdad sale entonces este tipo de
-->
cosas fueron bueno son vaya alguna mención de que también se tiene que
-->
tener cuidado no en este caso si te fijas esta clase aparte que se decora
-->
con el controller se decora con el request mapping para que nos sirve este
-->
rico es me pin para que cuando yo tenga mi url local ya sabes 2 puntos
-->
locajos 80 80
-->
pueda yo poner diagonal products y pueda acceder a todos los endpoints
-->
que están definidos en esta clase y esos endpoints también tienen su
-->
propio pat por ejemplo los que ocupan una id en específico no por ejemplo
-->
bueno estos impuestos valdrían la pena revisarlos de acá
-->
si te fijas acá entonces este es el pat base por así decirlo y lo demás
-->
es lo que ocupa como parámetro no eso mismo es lo que estamos
-->
definiendo acá en él en la clase de controlador sale estás definiendo tu
-->
ruta base que es esta sale y todo lo demás pues son los los los los
-->
endpoints que ocupan el parámetro id va
-->
ocupas esta línea que te sirve para hacer logger
-->
interno que no es más que pintar logs si algo falló tú puedes ocupar
-->
un punto log y te va a imprimir aquí los logs no que vamos a ver también la
-->
propuesta que trae spring boot spring cloud perdón un mecanismo que se
-->
llama sipkin que no es más que un servidor que básicamente te permite
-->
rastrear errores por por medio de identificadores entonces vamos a
-->
configurar también hay un cliente de sipkin un servidor de sipkin y
-->
vamos a hacer esto de los blogs de una forma más más pero no porque digo los
-->
logos ayudan sirven no nadie dice que no pero este hay otros mecanismos
-->
actualmente no para poder monitorear entonces este después viene la parte
-->
de utilizar una inyección de dependencias aquí vamos a inyectar el
-->
servicio de productos este servicio de productos es básicamente
-->
este de acá si te fijas del control fíjate fíjate cómo brinca el colorcito
-->
azul se va al product service cuando yo le digo dime de qué clase es se va
-->
hasta acá no el controller manda a llamar al service entonces este service
-->
lo manda a llamar porque en el service el product service implementation está
-->
toda la lógica que se ocupa para hacer los los cruz ahorita la vamos a
-->
repasar también con detalle nada más lo que quería que vieran es cómo el
-->
controlador manda a llamar a la implementación del service va entonces
-->
tienes aquí el cliente del producto del product service y este estos
-->
autowirets que son básicamente pasar en el constructor todos los clientes
-->
que se que se ocupan como dependencias externas no que en este
-->
caso es el servicio pues aquí lo inicializamos y hasta ahí no hay
-->
ningún problema y ya empezamos a ver los mapeos de rutas por ejemplo que
-->
nos pide aquí crear la definición o el planteamiento del
-->
problema nos permite nos está pidiendo crear cinco en points un get users que
-->
es el get all un get user by id uno en específico un post de usuarios un
-->
put de usuario por id y un delete de usuarios por id entonces al hacer eso
-->
nosotros tenemos esto tenemos el get mapping este lo que hace es traerme
-->
todos los productos lo único que hace es consume ocupa el servicio de
-->
producto este servicio y manda a llamar al método get all products yo me voy
-->
a la definición de este método aquí lo vas a ver dentro de esta clase
-->
si te fijas ahí va a existir el get all products y te va a decir que hace
-->
entonces este get all products si te fijas es una implementación de su del
-->
service de hecho se llama input porque es la
-->
implementación de este service este service es solamente una interfaz una
-->
interfaz de los conceptos que tenemos de programación orientada a
-->
objetos pues nos permite hacer abstracción no solamente nos va a
-->
definir nos va a permitir definir qué queremos hacer entonces aquí nos está
-->
diciendo quiero hacer un método get all un método get by id y un create un
-->
update un delete y la implementación de esta interfaz ahora sí nos va a
-->
decir el cómo se debe de hacer entonces ahora sí es ese get all
-->
productos lo hago haciendo esto
-->
y si te fijas este de aquí este service implementation también tiene
-->
una inyección de dependencia pero con la capa que se va a encargar de
-->
recuperar de los repositorios la información en este caso es el
-->
producto repositorio si te fijas yo me voy a su definición igual sale y
-->
cuá y fíjate cómo estoy parado aquí cuando yo mapeo a la clase que me
-->
abrió va a brincar y se va a ir al repositorio entonces ahí tú vas haciendo
-->
la cadenita no el controlador ocupa el servicio y el servicio ocupa el
-->
repositorio si te fijas aquí está tu repositorio va el repositorio como
-->
yo te decía con de las clases de configuración él sabe que todo lo que
-->
extienda de jpa repositor y va a ocupar un un connection string que va a estar
-->
muy seguramente dado de alta en un archivo aplicación properties ocupa que
-->
le digas de qué modelo quieres entonces ahí está la otra palabra clave modelo
-->
si ocupa un modelo aquí si te fijas los subraya si yo me voy igual a
-->
su definición le doy clic derecho y a la implementación la enlazo aquí para
-->
que me diga qué clase es si te fijas ahora subió a modelo va entonces ahí la
-->
cadenita el controlador ocupa el servicio el servicio al repositorio el
-->
repositorio al modelo va y si te fijas ya se están ocupando todas las
-->
claras todas las carpetas es como separarlo en capas por así decir no y
-->
tu modelo es una clase que basado en estas anotaciones la clase la
-->
anotación entity la anotación table se mapea con la tabla que nosotros
-->
creamos acá y bueno quien los en los ddl no en los definition language por
-->
ejemplo el de producto vamos a volver a abrir el definición de
-->
no el manipulation sino el definición de producto
-->
el que define la tabla producto y si te fijas aquí está no mi nombre mi nombre
-->
de tabla es products igual que la que estoy creando acá no products
-->
sale y las propiedades que tiene son id name y price entonces son esas
-->
tres propiedades las que tengo que agregar no hay di nombre y price el
-->
id adelante
-->
a
-->
claro
-->
cambiar entre esquemas
-->
ok bueno a ver bueno una una primer nota que habría que hacer ahí de
-->
hecho este es el tema de que cuando tú estás trabajando aquí en microservicios si te fijas yo
-->
no voy a no es que no se haga pero es tal vez un poco ya no tan necesario el hacer relaciones uno
-->
a muchos muchos a muchos porque si te fijas ahorita vas a ver cómo se relaciona el producto
-->
con órdenes con los varios y yo no yo no voy a crear ese tipo de relaciones porque porque las
-->
bases de datos están contenidas en servidores separados no que es como que la propuesta que
-->
trae el microservicio cada cada base de datos se va a guardar en su en un servidor propio no
-->
obstante no quiere decir que no haya dentro de ese servicio relaciones entre tablas no que
-->
si se pueden mapear cuando quieres trabajar de entre esquemas lo mejor que puedes hacer es
-->
aquí en la conexión este no o sea tú aquí puedes mapear que base de datos también puedes
-->
decirle hacia qué esquema se va a conectar y de esa forma este ya tu conexión debería de
-->
funcionar no necesitas especificar le más además si no lo quieres mapear en el conexión
-->
este si hay si hay ciertas anotaciones que te permiten mapear los esquemas va aquí como
-->
el ejemplo que yo traía era muy este es muy burdo realmente es muy de tablas sencillas para
-->
no invertir mucho tiempo pues no se ilustra no es necesario crear varios esquemas pero
-->
incluso me parece que aquí mismo tú puedes dar de alta el esquema con esta anotación no
-->
con el nombre punto el nombre de la tabla y con eso las tareas mapeando de hecho creo
-->
que ésta también te tiene que funcionar lo podrías probar ahorita que toque la práctica
-->
meter el esquema public que es donde tenemos aquí nosotros dado de alta la tabla si y este
-->
te fijas aquí va a estar public este en la base de datos tu esquema y este aquí está el
-->
esquema y lo puedes este mapear y te debe de funcionar según yo si te debe de funcionar con
-->
esta misma anotación que te estoy poniendo entonces lo puedes mapear de esa forma o lo
-->
puedes mapear simplemente así en caso de que sea el mismo esquema va si más o menos
-->
perfecto va que va ok entonces este bueno esta es la clase del modelo de productos va entonces
-->
si te fijas tiene las anotaciones para que está este campo se ha tratado como un identificador
-->
una primera aquí tiene su generación su estrategia de generación identity para que
-->
funcione como un este como una identidad y no va a ganar redundancia como un serial aquí
-->
en en pos en postgres que así así lo lo maneja el bar chart de 255 pues es un string y aquí
-->
tenemos como un doble el numérico que es un 10 2 al final es un doble lo mapeamos de esta
-->
forma sí y tienes también su constructor y tiene sus guedas y sus sedes va aquí está la sección
-->
de guedas y sedes y este es el modelo este tal cual es el modelo y nos falta por recorrer
-->
una última clase que es el DTO el DTO es de hecho el primero que se maneja porque aquí
-->
en el controlador este esto que se maneja acá y lo puedes ver los detalles lo puedes
-->
ver tanto en los ricos es como a los responses va entonces este es el que les decía que
-->
solamente es una clase que sirve como para para ir pasando las peticiones y las respuestas
-->
desde que llega la petición hasta que se va al modelo o se guarda en la base entonces
-->
el controlador también ocupa al DTO si te fijas aquí desde el controller te puede ser
-->
el DTO y el DTO no es más que la misma clase modelo este pero sin las anotaciones de
-->
persistencia no es él no es un entity no es un table es un este es una es un DTO un
-->
data transfer object así plano y tiene las tres propiedades tiene el constructor y tiene
-->
sus que decirse va no sé si haya duda adelante
-->
ok
-->
ok bueno esta clase modelo como dices las anotaciones no sirven porque esta clase sirve
-->
para utilizar persistencia es decir esto se va a guardar en la base de datos esto es esto es
-->
un modelo que se mapea con la base de datos y que es necesaria por las por los frameworks
-->
de persistencia y de jpa si cuando hablábamos del repositorio te acordas que te decía que
-->
extiende de jpa él requiere un modelo para que sepa cómo guardar la información y
-->
esa clase modelo debe de tener estas anotaciones esa es una para darle un porqué de esta clase
-->
digamos esta si no tenemos duda de que debe de ir ahora el DTO para que existe ah bueno
-->
sirve para que tú puedas tener un orden en y puedas diferenciar tus request y tu
-->
respons en objetos que sean para ti legibles porque a lo mejor yo puedo prescindir del
-->
DTO pero puedo crear aquí otra otro objeto x no y guardar información o puedo incluso
-->
pasar los parámetros tal cual no o sea puedo guardar el puedo pedir que me den
-->
el nombre y el doble así tal cual las propiedades este aquí en el controlador puedo pedir que
-->
me llegue un request así pero lo más digamos la mejor práctica es manejarlo todo como
-->
objetos entonces el DTO sirve para que te llegue el request el objeto request yo lo
-->
yo lo tengo más bien como un DTO y ese request o ese DTO es el que yo voy propagando
-->
hacia las diferentes capas por ejemplo el controlador que ocupa el servicio aquí si
-->
te fijas cuando ocupa el create este producto que llegó es el que llega del de la petición
-->
el parámetro va lo voy mandando y eso es lo que me lo voy a convertir en una entidad o en
-->
un modelo para que se transforme de esta forma y se pueda guardar entonces esa es
-->
y el otro es para que se maneje la el request el inter exactamente exactamente
-->
el modelo correcto exacto si no tuvieras base no ocupas el modelo puedes ocupar el
-->
DTO y lo puedes este ir mapeando incluso para fein clients este tú puedes propagar
-->
los DTOs y en otro micro por ejemplo el de órdenes que ocupa consumir al de usuario
-->
entonces tú puedes crear un en órdenes un DTO de hecho así está así lo vamos a hacer en
-->
órdenes tú creas un DTO de usuarios porque es el que vas a mandar al aquí al micro servicio
-->
de usuarios y ese DTO es el que se va a convertir en un modelo cuando llegue allá
-->
la petición va pero si básicamente esa es como esta es toda la arquitectura que se ocupa
-->
en el crudo en lo en lo de hecho es la misma que se ocupa en los tres crudos va este caso
-->
vimos productos en la diapositiva viene el de usuarios y el de órdenes pues es el que
-->
vamos a ir haciendo poco a poco va entonces ahorita ya hay que detenerlo vamos a ir a tomar
-->
la hora de comida a las 3 nos volvemos a conectar y ahora empezaremos con la práctica de crear
-->
bueno correr este micro servicio de producto para que vean cómo funciona el crudo lo vamos
-->
a levantar vamos a hacer peticiones hacia los cinco endpoints vamos a ver cómo responde y
-->
una vez que ya tengamos eso ya pasamos a la parte práctica que va a ser que me ayuden a
-->
crear más bien a completar el micro servicio de usuarios basándonos en este producto y
-->
completar el micro servicio de órdenes igual basándonos en este producto va realmente es
-->
un ejercicio muy sencillo pero con eso estaríamos terminando el el curso el día de hoy va
-->
alguna duda de lo que se plantea hacer
-->
súper muy bien bueno pues entonces nos estamos viendo a las a las 3 les parece esto provecho hasta luego