Saltar navegación

20260203 JPA-SPRING_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 7 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, aquí en particular, esto a lo que se refiere es, si quitamos un elemento de la colección, que hasta ahí llegábamos, entonces quitar un elemento de la colección no significa que el elemento desaparezca. 00:00:00
aparezca, ¿no? porque cuando hacemos 00:00:18
un remove, de hecho 00:00:20
el elemento me lo devuelve con ahorro de retorno 00:00:21
recordáis que cuando uno hace un remove en una colección 00:00:24
el elemento te lo devuelve con ahorro de retorno 00:00:26
por eso cuando queríamos borrar 00:00:28
todos los que eran igual a algo 00:00:30
en una lista hacemos un while remove 00:00:32
while remove diferente de null 00:00:33
entonces 00:00:35
si quitamos un elemento de la colección 00:00:36
de pedidos, ese pedido 00:00:40
ese pedido en principio 00:00:42
no tendría por qué desaparecer 00:00:44
¿vale? 00:00:46
Entonces, el Orphan Removal True es 00:00:48
si ese pedido, 00:00:50
elimínalo. Ya está, automáticamente. 00:00:52
¿Vale? Que deje de molestar. 00:00:54
Que deje de molestarlo, elimina. 00:00:55
Vale. Lo que más o menos incluyamos. 00:00:56
¿Vale? Eso por un lado. 00:00:59
Que se quedó ahí huérfano el matizarlo un poquito. 00:01:01
Y la otra cosa que se quedó 00:01:04
extraña 00:01:05
era, ¿por qué aquí 00:01:06
en los modelos 00:01:09
que hace ChatGPT pone siempre 00:01:12
Protected? 00:01:13
Cuando yo directamente aquí, normalmente 00:01:15
no pongo nada, ¿vale? Y él pone 00:01:17
protected, ¿vale? Porque yo normalmente aquí en este no pongo nada, o de poner 00:01:21
pongo público, una de las dos cosas, ¿vale? ¿Sabéis qué significa no poner 00:01:25
nada? ¿Sabéis qué significa? Que puedes instanciar 00:01:29
desde el propio paquete, pero no desde fuera, ¿vale? Entonces 00:01:33
normalmente en el constructor sin parámetros, cuando estás en un 00:01:37
modelo JPA, el constructor sin parámetros 00:01:41
normalmente puede estar pensado 00:01:45
quieres tú tenerlo protegido 00:01:47
para que solo lo use hibernate, hibernate lo tiene que usar 00:01:49
porque ya sabemos de memoria que hibernate 00:01:51
que es lo que implementa dentro JPA 00:01:54
usa el constructor sin parámetros 00:01:55
para instanciar los objetos 00:01:57
porque si no lo hacemos, de hecho siempre nos dice 00:01:58
te faltan constructores sin parámetros 00:02:02
entonces tiene que estar, eso ya lo sabemos 00:02:03
que tiene que estar 00:02:06
pero podemos decidir que no lo use 00:02:06
nadie más que hibernate 00:02:10
pues entonces si le quitamos este, ya está 00:02:11
solo lo usa hibernate y se acabó 00:02:13
No podríamos poner private, lógica 00:02:15
Si ponemos private ya no lo puede usar ni Dios 00:02:16
Si ponemos public lo puede usar cualquiera 00:02:18
Entonces decidimos 00:02:21
Hombre, tú puedes poner un constructor 00:02:22
Privado, el problema es que entonces 00:02:27
Solamente lo puedes usar desde otro método 00:02:28
De la clase, a ver, tendría sentido 00:02:31
Si lo quieres usar desde otro 00:02:33
Método, yo qué sé 00:02:34
¿Vale? 00:02:36
Entonces 00:02:39
¿Por qué pone protected? 00:02:39
Chat GPT 00:02:43
Pues por nada en particular, o sea la respuesta 00:02:43
que me ha venido a dar es 00:02:46
pues porque la palabra 00:02:47
porque protected sabemos lo que significa 00:02:50
significa que además 00:02:52
de las clases del paquete te puede instanciar 00:02:54
cualquier subclase, esté de donde esté 00:02:56
eso lo vimos ya el año pasado, es decir 00:02:58
protected es un 00:03:00
public añadido 00:03:02
perdón, un public no, un package 00:03:04
con el añadido de las subclases del resto del 00:03:05
universo, ¿por qué te lo pone? 00:03:08
lo que me ha venido a decir o me ha parecido 00:03:11
entenderle es, bueno porque 00:03:12
Porque protected aporta un significado, o sea, no por el significado sintáctico, no, sino porque si tú pones protected, al ver ahí la palabra protected, pues de repente se te enciende la lucecita, ah, que este constructor es especial porque lo va a usar hibernate, que no tiene nada que ver con que esté protected, como que es informativo porque la palabra protected significa protegido, significa protegido a nivel lingüístico, no a nivel nuestro de Java. 00:03:14
Bueno, pues por eso lo pone, ¿vale? Y si lo pone es porque lo ha visto en muchos proyectos, entonces debe ser que por ahí está en proyectos, digo yo, si no, no lo pondría. Entonces, si lo veis por ahí en algún sitio, pues no tiene más significado que ese, ¿vale? Pues yo qué sé, por hábito, por costumbre, porque sea informativo, pero ya sabemos lo que aporta. 00:03:44
que alguna subclase tuya fuera 00:04:05
te puede instanciar. 00:04:07
Pero vamos, pones public 00:04:09
si no te importa que te instancien 00:04:11
sin parámetros y también, depende, 00:04:13
es que todo depende del contexto. 00:04:15
Vale, pues eran las dos cosas 00:04:18
que se quedaron aquí 00:04:19
pendientes de este modelo. 00:04:21
De lo demás ya habíamos completado el modelo, 00:04:23
ya habíamos entendido todo, 00:04:25
etcétera, etcétera. 00:04:27
Ahora, 00:04:30
esto lo íbamos a hacer ya con 00:04:32
Sprint, poniendo esa capita adicional 00:04:33
De Sprint, vale 00:04:35
A ver 00:04:36
No estaba subido 00:04:41
Porque se supone que lo hicimos el otro día 00:04:43
Y está todavía sin hacer 00:04:45
Pero al final 00:04:47
Lo he subido a una carpeta temporal 00:04:49
A un este temporal temp 00:04:51
Que está aquí, vale 00:04:53
Pero vamos, si viniste el otro día 00:04:57
Tienes que tener escrito el otro día, pues solo hicimos eso 00:04:59
Vale, solo hicimos eso 00:05:01
vale, entonces ahora es cuando estamos 00:05:03
cubriendo la capa de sprint, que se supone 00:05:06
que nos va a oficiar las cosas 00:05:08
y si es verdad, nos va a oficiar 00:05:09
las cosas, bueno, ¿qué sería lo siguiente 00:05:12
que haríamos si 00:05:14
¿qué sería lo siguiente que haríamos 00:05:15
si no tuviéramos sprint? hacer nuestros 00:05:18
DAOs, ¿verdad? hacer nuestros DAOs 00:05:20
vale, pues 00:05:22
con sprint en lugar de nuestros DAOs 00:05:24
lo que vamos a hacer son 00:05:26
repositorios 00:05:28
que ahí venía el debate del otro día 00:05:29
qué es un repositorio 00:05:32
y qué es un DAO. Un repositorio 00:05:34
esencialmente es un DAO. Es una clase 00:05:36
que tiene métodos para acceder a la base de datos. 00:05:38
Pero el repositorio 00:05:40
no lo hacemos nosotros. 00:05:42
Al menos no al completo. 00:05:44
El repositorio, su versión inicial, 00:05:46
su versión básica, la tiene hecha 00:05:48
a Spring. Ya está. 00:05:50
Entonces, la tiene hecha a Spring, 00:05:52
construida por dentro, 00:05:54
ya con sus propios DAOs o como 00:05:56
la construya. Entonces, es cierto 00:05:58
que el repositorio 00:05:59
Tiene métodos como más pegados al modelo 00:06:01
No está en el DAO 00:06:04
Es como muy de meterse en la tierra 00:06:06
El CREATE, el GET, el DELETE 00:06:08
Y el no sé qué 00:06:11
Está un poco pensado para eso 00:06:11
Aunque luego en el DAO uno al final 00:06:12
Acaba poniendo muchos métodos 00:06:14
El repositorio, pues el debate era 00:06:16
Que quizá está como un poquito 00:06:19
Más pegado al modelo 00:06:21
Ves métodos más amplios 00:06:22
Más generales, más parecidos a servicios 00:06:26
A lo mejor 00:06:28
entonces sería 00:06:29
pues como si hubiera un DAO que nosotros 00:06:32
ni vemos, ni accedemos, ni construimos 00:06:34
el repositorio 00:06:36
que también lo hace Spring, aunque ese 00:06:38
ya sí que lo vemos, porque lo 00:06:40
tenemos que escribir nosotros, aunque luego 00:06:42
Spring lo implemente 00:06:44
y luego ya por encima del repositorio, como siempre 00:06:45
los servicios, como siempre 00:06:48
entonces, como ahora estamos con 00:06:49
Spring, nuestra siguiente capa entonces sería 00:06:52
hacer ya el repositorio, porque 00:06:54
el repositorio sí es el bin, el objeto 00:06:56
que Spring maneja. 00:06:58
Instancia maneja 00:07:01
como todos los BIMs que es capaz 00:07:02
de manejar. Vale, pues entonces 00:07:04
lo metemos en un 00:07:06
paquete de repositorio, en lugar 00:07:08
de un paquete de DAO, pues en un paquete de repositorio 00:07:10
y lo natural 00:07:12
es hacer un 00:07:13
repositorio por entidad. 00:07:16
Aunque de nuevo 00:07:18
esto es un poco más 00:07:19
flexible realmente, porque al estar 00:07:22
un poquito más pegado al 00:07:23
modelo que a la propia base de datos 00:07:26
no es como el DAO, el DAO está más pegado 00:07:28
a la base de datos, entonces tengo tabla 00:07:30
o entidad, tengo DAO, tengo tabla, entidad 00:07:31
tengo DAO, el repositorio 00:07:33
al estar más pegado al modelo porque 00:07:36
tiene métodos 00:07:38
a lo mejor que mezclan más cosas, más 00:07:39
de servicio, pues 00:07:41
no es tan, tan, tan, tan 00:07:43
por cada entidad o repositorio, en general 00:07:46
sí, en general sí, ¿vale? 00:07:48
más o menos 00:07:50
es que no hay normal 00:07:50
a ver, es que 00:07:54
el de normal es que no existe 00:07:56
O sea, depende del proyecto en sí, pero en general una entidad me ofrece su persistencia, me ofrece su acceso a datos a través de un repositorio, ¿vale? Lo que pasa es que ese repositorio me puede ofrecer a lo mejor cosas relacionadas con otras entidades porque habrá métodos que mezclen varias cosas, que hay un poco mezcla y de nuevo depende de los servicios que tengas que hacer, de la aplicación que tengas y del modelo que tengas, depende de muchas cosas. 00:07:57
O sea, no hay el de normal, es un poco, pues bueno, entender la arquitectura y ya está. Vale, en este caso son dos tablas, corrientes y molientes. Vale, pues entonces un cliente repositorio, un pedido repositorio. 00:08:26
Y ahora, pues nuestro cliente repositorio, como no la vamos a implementar nosotros, porque eso es la magia de Spring, que la implementa ella, pues que sea una interfaz, porque no la vamos a implementar nosotros. 00:08:39
Esta es la parte interesante 00:08:57
De Spring Data 00:09:00
La parte interesante es 00:09:02
Que la implementa ella 00:09:04
¿Vale? 00:09:06
Nosotros los DAOs los tenemos que hacer 00:09:07
Tampoco es que nos cueste horrores hacerlos 00:09:09
Y gracias a hacerlos 00:09:11
Tenemos más control realmente 00:09:13
Luego de los servicios que están haciendo 00:09:15
Así aquí no tenemos mucho 00:09:16
Pero bueno 00:09:18
Claro 00:09:20
Manejas tú donde está el Entity Manager 00:09:22
Sabes exactamente en qué momento se está instanciando 00:09:25
Cuando lo cierras 00:09:27
Tienes un poco más de control 00:09:28
Aquí ya empiezas a perderlo 00:09:29
Pero bueno 00:09:31
Pero bueno, es más mágico 00:09:32
Vale, entonces para que esto realmente 00:09:37
Sea algo 00:09:39
Implementable por Spring 00:09:41
Pues tiene que heredar 00:09:42
De JPA Repository 00:09:44
Tiene que heredar de ahí, sí o sí 00:09:46
Para que Spring diga, uy que lo tengo que implementar 00:09:47
Según tu modelo 00:09:50
Vale 00:09:52
Entonces, jprepositorio es una clase genérica 00:09:53
Que depende 00:09:57
De la entidad en concreto 00:09:58
Y del tipo de dato de la clave 00:10:00
Porque la clave es básica, lógicamente 00:10:02
Para el acceso a datos 00:10:04
Pues el tipo de dato de la clase es cliente 00:10:05
Y la clave en nuestro caso 00:10:09
De cliente era long 00:10:11
La clave era long 00:10:12
Pues ya está 00:10:13
Se acabó el repositorio 00:10:16
Se acabó el DAO 00:10:19
Si queremos 00:10:21
¿Vale? Si queremos 00:10:22
Se puede quedar así 00:10:24
Y ya tenemos un DAO que hace unas cuantas cosas 00:10:25
Vamos a verlo 00:10:28
Ya está 00:10:29
Si lo sabes 00:10:30
Ahora lo sabremos 00:10:35
Al fin y al cabo son 4, 5, 6 00:10:38
¿Vale? 00:10:39
Entonces ya está 00:10:42
Están en JPA Repositorio esos métodos 00:10:43
Pero luego pues podemos 00:10:45
Gracias al entorno de desarrollo rápidamente nos ofrece 00:10:46
Gracias a la documentación que integra el entorno 00:10:50
pues nos ofrece los que hay 00:10:52
ya no hay más que hacer, se acabó 00:10:53
¿vale? 00:10:56
esto ya 00:10:58
va a ser un objeto 00:10:59
de los manejados por Sprint 00:11:02
recordad que Sprint 00:11:04
entre otras cosas 00:11:06
su origen sobre todo 00:11:08
venía por 00:11:09
instanciar los objetos que hicieran 00:11:12
falta e inyectarlos a través de los 00:11:14
constructores o de donde fuera 00:11:16
a donde hicieran falta y nos olvidamos 00:11:17
de ellos, que para yo crearte 00:11:20
a Tinnit un datasource, saco el datasource 00:11:22
y lo meto, que para crear el datasource 00:11:24
necesito un no sé qué 00:11:27
me lo invento, lo instancio y lo meto 00:11:28
o sea, todo eso, ¿no? Spring es 00:11:30
crea objetos según hagan falta y ya está 00:11:32
bueno, pues este es uno 00:11:33
de los que Spring tendrá que 00:11:36
crear solo cuando vea que 00:11:38
a alguien le hace falta 00:11:40
¿a quién le va a hacer falta un repositorio? pues al servicio 00:11:41
¿vale? pues este es 00:11:45
uno de los que Spring creará solo 00:11:46
entonces, oficialmente 00:11:48
teóricamente habría que marcarlo 00:11:51
¿vale? porque mediante 00:11:53
anotaciones es como le decimos a Spring las cosas 00:11:54
¿vale? 00:11:56
entonces, estos 00:11:59
nos hemos despreocupado de eso 00:12:00
porque estos no son los objetos del 00:12:02
modelo, no son objetos pensados 00:12:04
para que Spring los instancie cuando le 00:12:06
hagan falta, no, los objetos del 00:12:08
modelo forman parte de nuestra aplicación 00:12:10
los clientes que tengamos, no sé qué, que nos irán 00:12:12
llegando, pues los vamos instanciando según nos van 00:12:14
llegando lo que sea, eso ya se hace en nuestra aplicación 00:12:16
Spring esencialmente 00:12:18
se dedica a gestionar todos los bins relacionados 00:12:20
con la configuración de alguna manera 00:12:22
los objetos del modelo no 00:12:24
son los objetos que yo decido cuando 00:12:26
aparecen y cuando no, porque son mis datos 00:12:28
son los datos de mi aplicación, estos son datos 00:12:30
de mi aplicación, el resto son 00:12:32
pues los esclavos, esclavos que 00:12:33
están todos al servicio de que mis datos 00:12:36
entren y salgan en la base de datos 00:12:38
que es lo que hace cualquier aplicación, coger datos 00:12:40
y llevarlos de un lado a otro 00:12:42
pues esos datos son responsabilidad mía 00:12:43
los clientes y los pedidos son responsabilidad mía 00:12:46
y el resto son los esclavos 00:12:49
para que esos tránsitos de datos funcionen 00:12:51
y los esclavos sí que son los que 00:12:52
Spring tiene que gestionar 00:12:54
pues cliente repository será un objeto 00:12:56
esclavo necesario para que 00:12:58
todos estos datos puedan ir de un lado para otro 00:13:00
entonces yo lo tendría que marcar de alguna 00:13:02
manera para que Spring diga 00:13:04
este es un... en general 00:13:06
los objetos que maneja 00:13:08
Spring son componentes 00:13:11
se anotarían como componentes, pero bueno 00:13:12
ya no hace falta porque está Spring Boot 00:13:14
Etcétera, etcétera, hay muchas cosas 00:13:16
Dentro de los objetos component 00:13:18
Que son los objetos en general que Spring 00:13:20
Puede manejar solito, instanciar solito 00:13:22
Hay algunos 00:13:24
Con características especiales 00:13:26
Pues como el controller, si os suena 00:13:28
De la primera vez que ya volveremos a él 00:13:30
Pues como el servicio 00:13:32
O como el repositorio 00:13:34
Entonces yo, pues teóricamente 00:13:36
Debería decir, oye que tú eres un component 00:13:38
Un objeto component, ¿vale? 00:13:40
Podría poner aquí incluso 00:13:42
Component 00:13:43
vale 00:13:45
pero 00:13:46
sería todavía más preciso 00:13:48
si dijera eres un component 00:13:52
vale, o sea un objeto de sprint 00:13:54
pero es que además eres un repositorio 00:13:55
pues sería mucho más 00:13:57
precisa 00:13:59
todavía si pusiera aquí esto 00:14:02
y no pasa nada 00:14:03
y puedo ponerle, pero en este 00:14:05
caso en particular no es necesario 00:14:08
porque al heredar de jpa 00:14:09
repository, al heredar 00:14:12
Ya Spring infiere 00:14:14
Que esto es un component para él 00:14:16
Y ya está 00:14:18
Entonces no es necesaria anotación 00:14:19
¿Pasa algo porque la ponga? 00:14:21
No pasa nada, de hecho 00:14:23
Muchas anotaciones, muchas veces son meramente 00:14:25
Aclaratorias, para que uno 00:14:28
Entienda las cosas 00:14:30
Esta en particular, pues no hace falta 00:14:31
¿Cómo ponen las dos? 00:14:34
¿Cómo? 00:14:36
¿Qué dos? 00:14:37
¿Componen? No, hombre, no, las dos no 00:14:40
Claro, porque una sería una subclase de la otra de alguna manera, ¿vale? Entonces, en este caso, la anotación es opcional. Pero la pongamos o no la pongamos, esto es un objeto que va a ser gestionado por Spring, eso está claro. 00:14:41
Vale, entonces pedido repository, vale, pues pedido repository lo mismo, extiende de jpeg a repository parametrizado a los dos datos, el tipo de entidad y el tipo de la clave primaria, integer, long, string, la que sea. 00:14:55
Y ya tengo el dado. 00:15:24
¿Es la clave primaria compuesta igual que la última que has pasado? 00:15:25
Sí, el tipo de la clave primaria, claro. Entonces, aquí, ahora ya el siguiente paso sería hacer los servicios, ¿vale? Por ejemplo, aquí cliente service, ¿vale? Ahora mismo está vacío, podéis escribirlo vosotros si no lo tenéis escrito, ¿vale? Este sería nuestro servicio, por ejemplo, de los clientes. 00:15:28
Aunque recordad que el servicio todavía es más flexible. En principio, pues bueno, una clase para los servicios de cliente, una clase para los servicios de pedido, pero claro, los servicios son los casos de uso ya, las funcionalidades. Y las funcionalidades ya sí que están muy mezcladas, mezclan mucho. 00:15:53
clientes cuyos pedidos no sé qué 00:16:10
entonces bueno, en principio 00:16:13
una clase de servicio 00:16:14
por entidad 00:16:16
pero no es tan rígido, puede haber una clase de servicio 00:16:18
sin más o otro tipo 00:16:20
de agrupaciones 00:16:22
¿Puedes poner pedido de repositorio? 00:16:23
Sí, es como 00:16:27
la otra, solo cambia 00:16:28
esto y esto 00:16:30
¿Vale? 00:16:31
Vale, ¿dónde 00:16:34
estábamos? Aquí 00:16:36
bueno, pues lo siguiente que haríamos sería nuestro servicio 00:16:37
nuestro servicio 00:16:41
con el constructor 00:16:42
y el 00:16:44
repositor, la clase de servicios 00:16:46
va a necesitar este 00:16:49
repositorio casi seguro, y puede que también el otro 00:16:50
puede que también 00:16:52
esto no es rígido, no es que 00:16:53
la clase donde están los servicios del cliente 00:16:56
solo tenga que usar este, pues no 00:16:58
igual tiene que usar el resto de repositorios 00:17:00
pues si tiene que usar el resto de repositorios lo pongo, no pasa nada 00:17:02
claro 00:17:04
claro, es un servicio 00:17:05
que usará lo que haga falta 00:17:08
vale 00:17:09
pero bueno, este se supone 00:17:10
casi seguro que lo va a usar, porque si son servicios 00:17:14
de clientes 00:17:16
entonces, aquí 00:17:16
de nuevo, aquí es donde 00:17:19
Spring va a aparecer 00:17:22
porque cuando nosotros instanciemos el servicio 00:17:23
porque ya desde mi aplicación 00:17:26
sea un controller 00:17:28
sea un main, sea lo que sea 00:17:30
ya desde mi aplicación 00:17:32
lo que yo necesito es el objeto 00:17:33
servicio, para llamar a sus métodos 00:17:35
es lo que yo instancio 00:17:37
vale, pues desde el momento en que yo lo instancie 00:17:38
yo o Spring o quien sea 00:17:41
en el momento en que este servicio aparezca 00:17:43
que es el que tiene que aparecer en mi main 00:17:45
porque es el que tiene las funcionalidades 00:17:46
en el momento en el que aparezca 00:17:48
Spring se va a dar cuenta de que, uy, necesita 00:17:50
un repository, pues ya está 00:17:53
lo crea y punto, pero tal 00:17:54
lo crea y se lo inyecta al 00:17:57
este porque no va 00:17:58
porque estás con el 00:18:02
No, si se la va a pasar a edificar. 00:18:05
Porque creo que está con lo de pintar, claro. 00:18:10
¿Cómo quito esto ahora? 00:18:12
El último botón. 00:18:14
Dale al cuadrado de abajo de ahí. 00:18:16
Ah, vale, para aquí. 00:18:19
Ah, y lo que no sé es cómo lo he abierto. 00:18:20
Ah, lo he abierto aquí, ¿verdad? 00:18:23
No, no, lo he abierto aquí. 00:18:24
Bueno, pues nada. 00:18:26
A ver, ahora cómo vuelvo yo, no tengo que volver. 00:18:27
Ahí nos va. 00:18:31
¿Dónde la pintarás vos? 00:18:32
vale, pues entonces 00:18:32
Spring ya pum, lo hará aparecer 00:18:38
y ya está 00:18:40
vale, en su momento mencionamos 00:18:41
que lo he puesto aquí para que no se me 00:18:44
olvide 00:18:45
que 00:18:46
Spring sabe 00:18:48
que tiene que hacer aparecer 00:18:52
lo que este necesite 00:18:53
entonces 00:18:55
hay dos maneras de decírselo 00:18:57
una pues que 00:19:00
decirle, oye, inyectalo en el constructor 00:19:02
y otra, ponerle aquí una anotación 00:19:04
que es esta de aquí, que la mencionamos también un día 00:19:09
autowire, que es, si tú pones en cualquier 00:19:12
propiedad el autowire, pues lo que hace sprint es 00:19:16
la hace aparecer tal cual, la hace aparecer dentro 00:19:20
de cliente service, no la hace pasar a través del constructor 00:19:24
su matiz, entonces 00:19:28
Entonces, aquí yo entiendo que hay diferentes criterios, ¿vale? Si el que haya un constructor, a mí me parece buena idea porque te independizas de Spring, tú siempre vas a poder instanciar clientes service con el repositor y no vas a vivir tan agobiado por la existencia de Spring. 00:19:31
si pones aquí autowire y quitas el constructor 00:19:51
pues simplemente has deshabilitado 00:19:53
ese constructor, entonces bueno 00:19:55
pues 00:19:57
no lo sé, lo de mala idea es 00:19:58
intuición 00:20:01
bien, pero vamos, vale 00:20:03
no lo sé 00:20:05
no lo sé cómo estará más por ahí, dime 00:20:06
se recomienda que 00:20:09
en el 95% de los casos lo hagas por 00:20:11
constructor y quites el celular del 00:20:13
autowire por atributo 00:20:15
¿y qué razón da? 00:20:16
Pero vamos, no te dice por qué 00:20:18
Porque 00:20:30
Pero bueno 00:20:30
Claro, sí, lo que pasa es que 00:20:32
Esas son las cosas que a mí me 00:20:36
Me desconciertan de este mundo 00:20:37
Te recomiendo que lo hagas así 00:20:39
Vale, yo lo hago así, pero ¿por qué? 00:20:41
Porque funciona distinto 00:20:43
No debería, porque 00:20:44
Pero bueno, que es que así 00:20:46
Trabajar con un framework es así 00:20:48
Tú al final sigues sus recomendaciones y ya está 00:20:50
Pero bueno 00:20:53
Y si haces un segundo constructor, como si haces un constructor vacío 00:20:54
Ya tienes que meter el autowire 00:20:57
Pones autowire en el que quieres el print 00:20:58
Para distanciar 00:21:00
Vale, aquí 00:21:01
Si pones autowire sin más y no hay ninguno 00:21:06
Lógicamente te va a salir sin parámetro, que es el que tiene 00:21:09
Vale, pues nada 00:21:11
Bla, bla, bla 00:21:13
Aquí tenemos el servicio 00:21:17
Y ahora, aquí viene la magia estupenda 00:21:18
¿Vale? Por ejemplo 00:21:21
¿Qué puedo querer hacer yo con un cliente? 00:21:22
Pues recuperar un cliente 00:21:26
Dado su ID, dame este cliente 00:21:27
Por ejemplo, ¿no? Pues entonces yo me podría hacer 00:21:29
Aquí un servicio 00:21:31
Recupera cliente 00:21:32
A través de su clave 00:21:42
Que era long 00:21:45
Vale 00:21:46
Bueno, pues vamos a necesitar el repositorio 00:21:47
Que el repositorio es el que me hace las cosas 00:21:51
¿Vale? 00:21:53
Y aquí es donde 00:21:55
Veo todo lo que Spring ha hecho por mí 00:21:56
Todos estos métodos están implementados 00:21:59
No los tengo que hacer yo 00:22:02
Se acabó 00:22:03
¿Cómo están implementados? 00:22:06
No sé, pero bueno 00:22:07
Podría importarnos 00:22:09
Pero 00:22:12
No, no, no 00:22:13
Vamos a verlo 00:22:18
No vamos a verlo, no tenemos ganas 00:22:19
Bueno, podemos tener ganas 00:22:21
Pero no tiempo 00:22:24
El repositorio como se llama 00:22:24
Cliente repo, vale 00:22:26
Porque la lupa, porque los de atrás 00:22:29
Ah, que se llama clientes 00:22:34
Vale, es que ya se llamaba clientes 00:22:38
Todos veis incluso pequeñito 00:22:39
Pero todo eso también lo veíais 00:22:41
Por favor 00:22:44
Que vista tenéis 00:22:46
Vamos, que la lupa no gusta nada 00:22:47
Bueno, pues nada, no lo veo ni yo 00:22:50
Pero si vosotros lo veis 00:22:56
Vale, pues tenemos el crud básico 00:22:57
En realidad, el crud básico y alguna otra cosa 00:23:01
Tenemos 00:23:03
Vale 00:23:04
Tenemos borrar 00:23:06
Eliminar el objeto 00:23:08
Eliminarlos todos 00:23:10
Los clientes 00:23:12
Eliminar por ID 00:23:14
Eliminar 00:23:16
Por ID a mogollón 00:23:18
Un montón 00:23:20
O sea, le pasas un montón de claves 00:23:21
Y te elimina 00:23:25
En un proceso batch 00:23:27
¿Vale? 00:23:29
Borrar uno por ID 00:23:34
Si existe o no existe 00:23:35
Recuperar todos los clientes 00:23:38
Recuperar por ID 00:23:41
¿Vale? 00:23:44
Y guardar 00:23:48
Uno que no sea persistente 00:23:49
Todavía hacerlo persistente 00:23:50
Entonces tiene el CRUD básico 00:23:51
Insertar 00:23:52
Recuperar por id 00:23:54
Recuperar todos, eliminar 00:23:56
Y bueno, modificar 00:24:00
Pero modificar es que es un 00:24:03
Se hace automáticamente 00:24:04
Ah, perdón 00:24:06
Vale, vale 00:24:10
Vale, pues entonces 00:24:10
En este caso es que sería tan sencillo 00:24:13
Como 00:24:15
By id y le pasamos id 00:24:16
Vale, y este me devuelve 00:24:27
que no lo he sacado, ¿verdad? 00:24:34
id, me lo devuelve el optional 00:24:40
y aquí pues bueno 00:24:41
ya os sacamos el optional 00:24:45
lo bestia, lo de siempre 00:24:47
o si yo no quiero evitar null 00:24:48
pues yo que sé, doy un cliente vacío 00:24:51
aquí lo que cada uno quiera 00:24:53
¿vale? si somos un poco burros 00:24:54
no hay manera de comentar 00:24:57
no hay manera de comentar 00:24:58
claro, es que esto no es como se hacen las cosas 00:25:00
ojalá, ojalá esto fuera 00:25:03
un recetario, pero esto no es un recetario 00:25:05
porque 00:25:07
igual dentro de un año lo que estás haciendo es 00:25:08
completamente distinto a lo que hacemos aquí 00:25:11
y no pasará nada 00:25:12
será lo que hacen allí 00:25:15
entonces 00:25:16
no, no te lo enseñarán 00:25:17
lo tendrás que aprender tú y sacar 00:25:21
tus propias conclusiones y todo 00:25:23
es que este mundo es muy distinto a 00:25:24
voy a aprender a hacer cosas y ahora que ya he aprendido 00:25:26
voy a hacerlas, es que no tiene nada que ver con eso 00:25:29
nada que ver, voy a 00:25:30
educarme un poco en ciertas maneras 00:25:32
de pensar y luego voy a tratar 00:25:34
de aplicarlas para aprender cosas 00:25:36
completamente distintas 00:25:38
se trata de eso 00:25:39
pues sobrevivimos como podemos 00:25:40
¿cómo quieres que evaluemos? 00:25:46
vale, pues entonces 00:25:54
se admite cualquier tipo de sugerencia 00:25:55
sobre cómo evaluar 00:25:57
en una situación así 00:25:58
porque no es tan sencillo 00:26:00
ojalá tuviéramos la solución 00:26:01
ojalá tuviéramos 00:26:02
Bueno, pero esa se la tendréis que decir a Estefano 00:26:04
¿Vale? 00:26:09
Pero efectivamente 00:26:15
¿Cómo se evalúa de algo tan amplio como eso? 00:26:17
¿Cómo se hace? 00:26:19
Entonces en mi caso mi opción es 00:26:22
Planteo cosas al menos fáciles 00:26:24
Pues que no impliquen memoria 00:26:28
para no, y ya está 00:26:30
para que ciertas destrezas básicas al menos 00:26:32
¿qué hago? ¿os encierro aquí 00:26:36
tres días? 00:26:38
vale, pues entonces, en relación a lo que decías 00:26:42
tú, ¿cuál es la recomendada? 00:26:45
no hay recomendada, pero siempre 00:26:47
hay pautas, a ver 00:26:48
hay muchas pautas que más o menos siempre 00:26:50
con las que siempre trabajamos, que es 00:26:53
cuidado con los null, por ejemplo 00:26:54
no te repitas, hay muchas cosas 00:26:56
esta por ejemplo, es muy fea 00:26:59
porque este es un null pointer excepción 00:27:01
claro, pero eso ya 00:27:03
eso ya es un tema que bueno 00:27:05
que ya sabe, es transversal 00:27:06
a esto, esto es un tema 00:27:09
recurrente que ya sabéis, ya sabéis que en real se evitan 00:27:11
los null, yo este get lo he puesto 00:27:13
por comodidad, claro, pero este get 00:27:15
ya sabéis y es transversal a esto 00:27:17
no lo tenemos que decir todo el rato, que este get 00:27:19
si saco del optional o bestia 00:27:21
pues al optional no estoy usando 00:27:23
todas sus posibilidades, estoy 00:27:25
empeñándome en devolver el null 00:27:26
vale, me empeño en devolver el null 00:27:29
¿por qué ahora? por comodidad 00:27:31
que no quiero devolver el null para asegurarme 00:27:32
o para facilitar que el otro 00:27:35
no tenga un null pointer exception, pues pondría aquí 00:27:37
un or else y pondría 00:27:39
aquí un new cliente, por ejemplo, o pondría 00:27:41
otra cosa, ¿vale? 00:27:43
depende 00:27:46
es que depende del resto de la aplicación 00:27:47
¿cómo se vaya a usar ese caso de uso? 00:27:49
ya, pero claro, todo esto 00:27:55
se basa en que luego tú lo documentas todo 00:27:57
tú te haces aquí tu javadoc 00:27:59
Y el otro, el que te va a usar 00:28:00
Pues tienes ayuda 00:28:03
¿Vale? Esto pues es 00:28:04
Comodidad, pues hacer un optional para sacarlo 00:28:06
Con el get, pues hombre, es 00:28:08
Irte para volver 00:28:10
Pero bueno, ahora como no estamos ahora mismo 00:28:12
Centrados en eso 00:28:14
Vale, pues entonces, pues estupendo 00:28:16
Ya estás, es que no tendría más que hacer 00:28:18
Se acabó, no tendría más que hacer 00:28:20
Si lo que quiero es hacer un CRUD básico de consultas 00:28:22
Entonces, ¿esto va a funcionar? Pues sí 00:28:25
Y fijaos 00:28:26
Aquí, ni entity manager, ni transacción, ni nada de nada, ¿vale? Nada de nada, yo no he visto nada, ¿vale? Vale, aquí, ¿qué me falta en este servicio? Este servicio también tiene que ser un componente, un bin gestionado por Spring, ¿vale? 00:28:28
Pues vamos a anotarlo 00:28:49
¿Vale? Este no se anota solo 00:28:51
Porque este no hereda de nadie 00:28:54
Este es una cosa que estoy haciendo yo 00:28:56
¿Vale? Entonces vamos a anotarlo 00:28:57
Component 00:29:00
Idealmente service 00:29:01
Porque es un servicio 00:29:03
Aunque sea más informativo que otra cosa 00:29:04
Vale, entonces yo aquí repito 00:29:07
Ni me he preocupado 00:29:15
De meterle al service 00:29:17
El entity manager 00:29:18
Para que el service se lo dé al 00:29:20
al DAO, me he olvidado 00:29:22
del contexto de persistencia, Spring 00:29:24
instancia el contexto de persistencia, instancia 00:29:26
todo, me he olvidado del begin 00:29:28
del commit, me olvido de muchas cosas 00:29:30
pero sé 00:29:32
que existen por debajo 00:29:34
sé que existen por debajo porque el saber que existen 00:29:35
por debajo y cómo funciona 00:29:38
puede hacer que en una aplicación muchísimo 00:29:40
más grande, lógicamente en un asuntito 00:29:42
como este, pues tomar 00:29:44
hacerme a mí tomar decisiones sobre por qué 00:29:46
me están fallando las cosas, por qué no 00:29:48
En relación a las transacciones, por ejemplo, recordáis que las transacciones eran un concepto a nivel de servicio, no de DAO, ¿vale? Los DAOs hacían cosas muy atómicas y yo luego en el servicio decidía cuántas de ellas entraban a formar parte de una transacción, ¿vale? ¿Cuántas de ellas entraban a formar parte de una transacción? 00:29:50
Aquí eso no ha cambiado 00:30:12
Aquí la transacción es a nivel de servicio 00:30:14
¿Vale? 00:30:16
Entonces, los métodos 00:30:18
Yo antes en los métodos 00:30:20
Pues me preocupaba de poner el 00:30:22
BeginTransaction, commit 00:30:24
Cuando yo quería agrupar unas 00:30:26
Sentencias en transacción 00:30:28
Aquí 00:30:30
Si yo quiero 00:30:31
Si yo quiero 00:30:33
Que un método 00:30:35
Sea todo el entero, una transacción 00:30:37
De principio a fin 00:30:40
lo tengo que anotar 00:30:41
lo tengo que anotar con transaccional 00:30:43
en este sería una tontería 00:30:45
transaccional 00:30:46
en este sería una tontería 00:30:48
porque es que además solo tengo una sentencia 00:30:51
en este sería una tontería 00:30:53
pero en otros 00:30:54
métodos, como luego podemos ver 00:30:57
en un ejemplo, de tener transaccional 00:30:59
o no tenerlo, la trascendencia 00:31:01
es muy grande, porque si no tengo transaccional 00:31:03
el contexto 00:31:05
de persistencia no va a estar abierto 00:31:07
todo el tiempo de vida del método 00:31:09
cada sentencia va a ir 00:31:11
por libre, entonces me van a salir ahí unos 00:31:14
lazy y unas 00:31:15
excepto y unas cosas muy caras 00:31:16
¿vale? 00:31:19
¿transaccionar hacia que si fallase 00:31:21
empezaba como que no tomaba en cuenta 00:31:23
todo lo que había hecho? 00:31:25
claro, si ha fallado 00:31:28
ahora un rollback, ¿vale? 00:31:30
porque trabaja en modo transacción 00:31:31
entonces, bueno 00:31:33
en general, pues la mayoría de los 00:31:35
métodos de servicio, pues queremos 00:31:37
que sean transacciones, la gran mayoría. 00:31:39
Vale, pues si quisiéramos 00:31:42
probar esto, ahora 00:31:43
aquí nos falta 00:31:45
que es que no hemos configurado nada. 00:31:47
¿Vale? En nuestro proyecto sin sprint 00:31:50
teníamos nuestro persistence 00:31:51
xml y ese 00:31:53
persistence tenía el origen de datos, 00:31:55
lógicamente, y un montón de cosas. 00:31:57
Aquí no está en ningún sitio. 00:31:59
¿Vale? Aquí 00:32:01
lo que ocurre es que el 00:32:03
repositorio 00:32:05
de forma oculta, cuando 00:32:06
instancie tendrá que recibir 00:32:09
todos esos datos a través de otros 00:32:11
bins como data source 00:32:13
bins que tiene que crear 00:32:15
sprint y gestionar 00:32:17
vale 00:32:20
pues no estamos con 00:32:21
sprint boot todavía, estamos con sprint 00:32:23
normal, pues habrá que decirle 00:32:25
que bins son, habrá que configurarlo 00:32:27
de alguna manera, habrá que configurar 00:32:29
esa parte de la fuente de datos 00:32:32
de la base de datos, habrá que 00:32:33
configurarla, vale pues para 00:32:35
eso necesitamos una clase de configuración 00:32:37
que es esta que está subida 00:32:39
al aula virtual, para que la descarguéis 00:32:41
directamente, es esta de aquí 00:32:43
bueno, cambia con tus 00:32:45
a ver, siempre la misma 00:32:47
en cuanto a la parte de configuración, sí 00:32:49
lo que pasa es que normalmente no se usa porque se usa 00:32:51
con Spring Boot, ¿vale? que sería el siguiente 00:32:53
de salto, pero Spring Boot 00:32:55
lo que hace es usar eso que está ahí dentro, o generarlo 00:32:57
vale, entonces si 00:33:00
descargáis esta clase de aquí 00:33:01
si descargáis esta clase 00:33:03
de aquí y la ponéis 00:33:06
en otro paquete aparte, 00:33:07
¿vale? Pues es esta. 00:33:09
Pues esta en su momento, también la usamos, 00:33:46
es una clase 00:33:49
en la que yo 00:33:49
explico, declaro, doy instrucciones 00:33:51
para construir bins 00:33:54
que Spring va a necesitar 00:33:56
inyectarles a otros, ¿vale? 00:33:58
Estos en particular los va a necesitar 00:34:00
para el JPA repository, 00:34:02
los va a necesitar para él. Entonces yo le doy 00:34:04
indicaciones sobre cómo construir. ¿Qué va a 00:34:06
necesitar? Va a necesitar 00:34:08
mi fuente de datos, 00:34:10
la va a necesitar el data source 00:34:11
el jpa repositorio la necesita 00:34:13
pues yo le doy instrucciones de como la construye 00:34:15
vale, le doy aquí 00:34:18
pues el driver que necesita 00:34:20
la dirección 00:34:21
de la base de datos, en fin 00:34:24
esto, lo que teníamos en el persistence 00:34:26
¿qué más va a necesitar 00:34:28
el repositorio? 00:34:31
va a necesitar el entity manager 00:34:34
el contexto de persistencia, sí o sí 00:34:35
¿veis? se anota con bin para decirle a Spring 00:34:37
oye que este es un bin que cuando haga falta 00:34:39
Créalo y mételo a quien haga falta 00:34:41
Vale, pues el entity manager también 00:34:43
Vale 00:34:46
Vale, pues aquí 00:34:47
Aquí tenemos el entity manager factory 00:34:49
Que es el que él va a instanciar 00:34:51
Para luego llamar al método que me crea el entity manager en sí 00:34:53
Vale, pues aquí 00:34:55
Este, que este sí 00:34:57
Yo lo he copiado y pegado del primer sitio 00:34:58
Donde he visto 00:35:01
Pero vamos 00:35:03
Estas son las propiedades 00:35:04
Que estaban en el persistence 00:35:07
O sea, lo mismo que estaba en el persistence 00:35:08
Lo tenemos puesto aquí, pero en bins 00:35:11
¿Vale? 00:35:14
Entonces aquí pues ponemos 00:35:15
Esto de aquí 00:35:17
Con esto veis que crea un fichero 00:35:19
De propiedades, crea un fichero de propiedades 00:35:25
Que lo podíamos haber hecho nosotros 00:35:27
Pero es que así ni siquiera 00:35:28
Ni siquiera metemos más 00:35:31
Basura, crea un fichero de propiedades 00:35:33
Y le fija ese fichero 00:35:35
De propiedades al factory 00:35:37
¿Vale? 00:35:38
Se podría hacer de otra manera 00:35:40
Podríamos hacer nuestro propio fichero de propiedades 00:35:42
Aquí cargarlo 00:35:45
Y fijárselo al factory 00:35:46
¿Esto crea un fichero de propiedades? 00:35:48
Sí, recordad la clase properties 00:35:50
Pero es temporal, ¿no? 00:35:52
No, perdón, no crea un fichero, crea un objeto properties 00:35:53
Que luego tú podrías llevar a un fichero 00:35:56
Claro, entonces este objeto properties 00:35:57
Podríamos tener esto ya en un fichero 00:36:00
Estas propiedades 00:36:03
Entonces, el properties lo podríamos hacer 00:36:04
Leyendo del fichero 00:36:07
así tendríamos el properties 00:36:08
y fijándoselo 00:36:10
pero si nos queremos ahorrar ese fichero 00:36:11
creamos nuestro properties directamente 00:36:15
no leyéndolo del fichero 00:36:17
sino creamos y lo fijamos 00:36:19
¿vale? pero que se podría hacer de otra manera 00:36:20
en cualquier caso este método 00:36:23
en realidad lo único que nos importa es para 00:36:25
ver que 00:36:26
efectivamente el JPA repository 00:36:28
va a necesitar 00:36:30
un entity manager también 00:36:32
que se va a crear a partir del 00:36:34
factory 00:36:36
Él teniendo un factory 00:36:37
Podría ya llamar al 00:36:39
Creativity Manager 00:36:40
Hola 00:36:42
Bueno, estas son las que vimos en el persistence 00:36:44
Que significaban 00:36:50
Esta era que hacer 00:36:52
Si la base de datos no existe 00:36:53
Te la crea, la ignora 00:36:55
Ah, el nombre sí 00:36:58
Se tienen que llamar así porque 00:37:02
Estas son para hibernate 00:37:04
Y Bernat, recordad que es el que está abajo del todo 00:37:05
Bueno, no, el que está abajo del todo es JDBC 00:37:08
Que sigue ahí abajo, aunque ya no lo veamos 00:37:10
JDBC es el último 00:37:12
O sea, todo esto que estamos haciendo 00:37:15
Genera un chorizo 00:37:16
De sentencia JDBC 00:37:18
Es lo que genera, nada más 00:37:20
En última instancia es eso 00:37:21
Todo JDBC, lo que hay debajo 00:37:23
¿Vale? 00:37:25
¿La anotación BIN? 00:37:27
La anotación BIN significa 00:37:29
Oye tú, Sprint 00:37:31
cuando alguien necesite 00:37:33
un entity manager factory 00:37:35
créalo de esta manera 00:37:37
¿quién lo va a necesitar? 00:37:39
el servicio 00:37:42
y el repositorio porque necesita un entity manager 00:37:43
un contexto de persistencia, sí o sí 00:37:46
lo necesita, eso significa 00:37:47
cuando alguien necesite esto 00:37:49
créalo de esta manera y se lo das 00:37:51
no lo tienes que hacer 00:37:54
tú por programa, el pasárselo 00:37:56
en el constructo, el no sé no 00:37:57
y aparte de 00:37:59
el entity manager 00:38:03
y el objeto de datos 00:38:05
la fuente de datos 00:38:07
si vamos a usar transacciones 00:38:09
pues tenemos que crear 00:38:11
también un manejador de transacciones 00:38:13
que siempre usamos transacciones 00:38:15
un manejador de transacciones 00:38:18
¿vale? estos serían los 3 bins 00:38:19
que va a manejar Spring cuando los necesite 00:38:21
en nuestro proyecto concreto 00:38:23
aparte de el repositorio 00:38:25
y el service, que esos es que están 00:38:27
anotados por libre 00:38:29
están anotados por libre, los podríamos poner aquí como 00:38:30
bin, pero 00:38:33
lo liamos 00:38:35
más que nada, como ya tenemos una clase para 00:38:37
ellos hecha, lo anotamos ahí en su clase y se acabó 00:38:39
¿vale? bueno, vamos a parar 00:38:42
un segundín 00:38:43
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
7 de febrero de 2026 - 18:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
158.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid