Saltar navegación

20260108 JPA_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 12 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

de menos 00:00:00
he pensado mucho en vosotros 00:00:00
todo este tiempo 00:00:03
igual que vosotros en mí 00:00:04
hemos pensado mucho en vosotros 00:00:06
venga, tema 3 00:00:08
de nuevo, empezamos 00:00:11
vale, usando el 00:00:12
JDBC, a ver Juana 00:00:15
¿qué haces? 00:00:17
Karol, perdón 00:00:20
a ver, es que a mí es que me gusta 00:00:21
más su primer nombre, os reconozco 00:00:23
no, no, no 00:00:25
no, es que no sé, me parece más bonito 00:00:28
pero bueno 00:00:31
¿Carol? 00:00:31
¿qué hace Carol? 00:00:35
que está ahí tomada, eso era 00:00:36
nada, olvídalo 00:00:38
da igual 00:00:41
imagínate lo concentrada que estaría 00:00:41
bueno, da igual, no pasa nada 00:00:46
a ver 00:00:48
en el tema anterior 00:00:50
ya hemos apuntado 00:00:52
¿vale? 00:00:54
Que JDBC es potente, pero engorroso, ¿vale? Por capturar todas las excepciones, por mapear las propiedades de objetos en campos de la tabla, por gestionar las conexiones, por todo eso. 00:00:55
Spring JDBC 00:01:11
bueno, nos ha envuelto 00:01:16
ya un poquito 00:01:18
esa complejidad 00:01:19
nos ha ocultado la gestión 00:01:21
de las excepciones 00:01:24
nos ha obligado a hacer un mapper, pero un mapper 00:01:25
muy poco potente, la verdad, lo teníamos que hacer 00:01:28
con una bifunction 00:01:30
y era un poco engorroso, con una bifunction 00:01:31
hacer el mapper, pues era un poco 00:01:34
pesado, entonces 00:01:36
si recordamos 00:01:38
JaxB, JaxB 00:01:41
nos pareció maravilloso 00:01:43
porque también teníamos un problema 00:01:44
similar que era 00:01:47
modelo XML, modelo de clases 00:01:48
necesitábamos 00:01:51
un mapeo entre ambos 00:01:53
poníamos 00:01:54
unas anotaciones en las clases 00:01:57
anotaciones que 00:01:59
expresaban a que 00:02:00
se correspondía cada propiedad en términos 00:02:03
de nodos y a partir 00:02:05
de ahí las librerías 00:02:07
de JAX-B lo hacían todos solas. 00:02:09
Bueno, pues 00:02:12
la idea de los ORM 00:02:13
que son 00:02:15
el mapeo objeto relacional 00:02:16
como bien indica su nombre 00:02:19
¿vale? 00:02:21
Pues la idea de las herramientas ORM 00:02:23
es exactamente 00:02:36
esa en origen. 00:02:38
Configurar mediante 00:02:41
anotaciones o mediante 00:02:42
XML o de muchas maneras. 00:02:44
Pero esencialmente al final la que sobrevive 00:02:46
y la que más se usa es mediante anotaciones 00:02:48
Configurar mediante anotaciones un mapeo entre mi modelo de clases 00:02:50
Que puede ser todo lo complejo que sea 00:02:55
Pedidos, compras, clientes 00:02:57
Pues hacer un mapeo entre mis clases y mis tablas 00:03:00
Yo tendría ahí un montón de tablas, compras, pedidos, clientes 00:03:06
Aquí un montón de clases 00:03:10
Mediante anotaciones especifico cómo se traduce cada cosa en cada cosa 00:03:11
una vez configurado 00:03:18
ahora yo ya trabajo en el mundo 00:03:20
de los objetos, mi aplicación se 00:03:22
olvida completamente 00:03:24
del SQL si quiere 00:03:26
se olvida completamente 00:03:28
del SQL y de la base de datos 00:03:30
y mi aplicación 00:03:32
trabaja en el mundo de objetos que existen 00:03:34
y que puede 00:03:36
hacer persistentes 00:03:38
entonces 00:03:41
persistir un objeto será 00:03:42
uy, se queda conectado a la base de datos 00:03:44
muy bien 00:03:47
Yo ahí puedo hacer un insert o un update, puedo cambiar las propiedades, con lo cual el objeto cambia su estado y cambia sus datos en la base de datos. 00:03:47
Esa es la idea, que una vez que yo he hecho el mapeo, trabaje en el mundo de los objetos. 00:04:01
Esa es la idea. 00:04:06
Luego todo eso tiene sus trucos, por supuesto. 00:04:07
No es que yo toco los objetos y automáticamente se cambie la base de datos. 00:04:10
pues no, tengo que hacer los commit 00:04:13
tengo que hacer 00:04:15
varias cosas 00:04:16
pero bueno, esencialmente de casi 00:04:18
todo lo de la base de datos me olvido 00:04:21
salvo configurar 00:04:23
el conector, salvo configurar la conexión 00:04:24
y ya está, trabajo con las librerías 00:04:27
que me ofrece el RM 00:04:29
para hacer el CRUD, que son ya 00:04:30
métodos muy sencillos 00:04:33
insert, persist, merge 00:04:34
find, métodos muy sencillos 00:04:37
y ya está, esa es la idea 00:04:39
y luego a través de esas librerías 00:04:41
a través de esas librerías ORM 00:04:43
pues puedes hacer muchísimas más cosas 00:04:45
puedes lógicamente gestionar 00:04:47
transacciones 00:04:49
hacer procedimientos almacenados 00:04:50
puedes hacer un montón de cosas 00:04:53
vale 00:04:55
entonces 00:04:57
ahora llega 00:05:01
¿cómo se hace esto? ¿cada uno a su manera 00:05:04
como le dé la gana? 00:05:06
no, estandarizando, sí 00:05:08
en realidad 00:05:10
¿cuál fue el primer 00:05:12
bebé, que ahora es el abuelo 00:05:14
de todo esto. El primer bebé 00:05:16
pues nació por libre, 00:05:19
así de la nada, como Jesucristo. 00:05:20
Pues igual. 00:05:23
Este hibernato se gestionaría, 00:05:30
digo yo, en algún cerebro. 00:05:33
En realidad, a ver, hubo más bebés 00:05:35
antes que este, ¿vale? 00:05:37
Pero bueno, este bebé... 00:05:39
No, no, no. 00:05:40
Lo que pasa es que esos otros bebés, pues como Struths, 00:05:42
como... eran unos 00:05:45
bebés más 00:05:47
confusos. No acababan 00:05:50
de ser exactamente un ORM 00:05:52
tal cual. Eran como muy 00:05:54
ligeros, mezclaban mucho SQL, 00:05:56
pero se usan, por supuesto. 00:05:58
Y Bernat fue como el primer 00:06:01
bebé creado así por las buenas 00:06:02
para decir un ORM puro 00:06:04
que realmente te permite 00:06:06
olvidarte del SQL 00:06:07
si quieres olvidarte de la complejidad de la base 00:06:10
de datos. 00:06:12
Ahora viene la gran pregunta. 00:06:14
Le voy a llamar hibernate el resto de mi vida 00:06:15
¿Vale? Vosotros llamadle como os dé la gana 00:06:18
Hibernate, como salga de ahí 00:06:20
Yo le voy a llamar hibernate 00:06:22
¿Vale? 00:06:24
Pues ya está 00:06:25
Lo digo por si me preguntáis 00:06:27
Y no entiendo de qué me estáis hablando 00:06:32
¿Cómo le queréis llamar? 00:06:33
Hibernate va 00:06:36
Hibernate, vale, pues así le voy a llamar 00:06:36
Hibernate 00:06:39
Es como Eclipse, pues ya está 00:06:41
No tengo ni idea 00:06:43
yo creo que no 00:06:45
bueno, pues entonces 00:06:46
ahora 00:06:49
este tiene 00:06:50
su propia manera de funcionar 00:06:53
su propia manera de configurarse 00:06:54
completamente al margen de 00:06:56
estándares de Java 00:06:58
de Spring, de todo 00:07:00
hay un hibernate puro y duro 00:07:02
y maduro y estupendo 00:07:05
y potente y maravilloso 00:07:06
maduro, maduro, potente y maravilloso 00:07:08
que uno puede usar 00:07:13
y otros años pues hemos usado 00:07:14
al principio hibernate puro sin más 00:07:16
porque es la base 00:07:18
para luego usarlo con los estándares que van por arriba 00:07:20
pero bueno, vamos a dejar 00:07:22
el uso del hibernate puro sin más 00:07:24
para si nos sobra tiempo un poquito más adelante 00:07:26
y vamos a verlo en otro contexto 00:07:28
bueno, pues hibernate 00:07:31
nació, creció, se hizo grande 00:07:33
y poderoso 00:07:34
pero en paralelo 00:07:35
viene el mundo de la estandarización 00:07:38
aquí hay que estandarizar 00:07:40
a qué hay que unificar, etc. 00:07:42
Bueno, pues en Java 00:07:46
la estandarización en cuanto a la persistencia 00:07:47
acceso a datos, persistencia, estamos en nuevos sinónimos 00:07:51
¿Cuál es? Pues es JPA 00:07:54
de hecho como su nombre indica 00:07:57
Java Persistence API 00:08:01
Entonces esta API es la que te ofrece todos los métodos 00:08:08
y todas las movidas para acceder a una base de datos 00:08:12
desde el mundo de los objetos 00:08:16
asumiendo que los objetos son persistentes 00:08:18
están conectados 00:08:21
a la base de datos 00:08:23
mapeados de alguna manera 00:08:24
te ofrecen los métodos para que tú 00:08:28
los recuperes 00:08:30
los modifiques, hagas commit 00:08:32
para que esas modificaciones se reflejen 00:08:35
pero tú del SQL pasas completamente 00:08:37
tocas los objetos 00:08:39
y llamas a métodos 00:08:40
de aquí y esos métodos 00:08:43
hacen los commit, hacen los insert 00:08:44
hacen las cositas 00:08:46
para que en la base de datos todo quede consistente 00:08:47
con el estado de los objetos 00:08:50
de la aplicación 00:08:52
pero JPA es una API 00:08:53
entonces JPA necesita 00:08:58
que alguien la implemente 00:09:00
y le dé un funcionamiento 00:09:02
se lo pueden dar muchos 00:09:04
pero ella 00:09:07
esencialmente casi solamente lo mejor 00:09:09
es el que más le gusta 00:09:12
Y al final es el que casi siempre se ha quedado y el que siempre se usa. El estándar de facto en el uso de aplicaciones Java persistentes es que sea este el que implemente JPA. Entonces, cuando usamos JPA, pues usamos la dependencia de Ibermate también, claro. 00:09:15
¿Vale? Pero claro, todo esto no es nadie si no tiene debajo al que verdaderamente accede a la base de datos, porque aquí estos pueden decir lo que les dé la gana, pero quien realmente accede a la base de datos es JDC, tal y como lo hemos visto, tal y como lo hemos visto. 00:09:32
Entonces, ¿qué estamos haciendo? Le estamos poniendo esta capa por encima. Le ponemos un JPA implementado con hibernate, pero hibernate por debajo va a estar usando JBC, es que no hay otra. 00:09:55
entonces nosotros 00:10:09
llevamos a los métodos de JPA 00:10:14
para nuestros objetos 00:10:15
con eso conseguimos 00:10:20
sincronización con las tablas 00:10:22
JPA 00:10:24
estará llamando por debajo a este 00:10:27
de aquí, más que estará llamando 00:10:29
lo está utilizando por dentro 00:10:31
lo está utilizando para implementarse 00:10:32
y este sí o sí usa JF 00:10:34
con lo cual 00:10:36
el driver de MySQL es imprescindible 00:10:38
Luego dependencia de hibernate 00:10:40
Tendremos que tener 00:10:43
Dependencia de JBBC también 00:10:44
No nos la podemos quitar 00:10:46
Y esto no hace falta dependencia en sí 00:10:47
Porque está integrado en la propia distribución 00:10:50
Entonces este sería un uso 00:10:53
El JPA puro 00:10:56
¿Vale? JPA puro 00:10:58
Que es el que tenemos que ver 00:11:00
Luego otra cosa es que digamos 00:11:02
Este la T, este la T 00:11:04
Vamos a ponerle otra capa más 00:11:05
Ya que nos encanta 00:11:09
Uy, ¿qué pasó? 00:11:09
No, has borrado 00:11:10
Uy, no me puedo ir arriba 00:11:13
Uy, de verdad 00:11:15
No pasa nada 00:11:18
Acá ya he sacado unos diagramas 00:11:22
Vale 00:11:24
Uy, qué nivel, ¿no? 00:11:26
JPA 00:11:36
Y ahora sí, JPA 00:11:36
No queremos usarlo así 00:11:40
Porque es que 00:11:42
Ya nos quita trabajo 00:11:44
Pero aún así todavía queremos las cosas más fáciles 00:11:46
Todavía 00:11:49
Porque se nos genera trinceto 00:11:49
Pues podemos poner 00:11:52
Spring Data 00:11:54
JPA 00:11:55
Que es la parte de Spring 00:11:57
¿Vale? 00:12:01
Que es la parte de Spring 00:12:02
Que nos ofrece 00:12:03
Funcionalidades de acceso a datos 00:12:06
Con JPA 00:12:08
que nos da un montón de trabajo hecho 00:12:09
bueno, pero vamos a ver 00:12:12
antes de empezar ya a ver 00:12:14
ejemplos concretos de proyectos 00:12:16
de cómo hacerlo con esto 00:12:18
vamos a ver un poquito 00:12:19
detalles de la arquitectura de esto de aquí 00:12:20
para que nos suenen los nombres y las cosas 00:12:23
porque luego os vais a ir todos de charla 00:12:26
estáis un viernes por la noche 00:12:28
a las 4 de la mañana, os sacamos de más de conversación 00:12:29
y si no tenéis términos 00:12:32
interesantes de los que hablar, pues la tía o el tío 00:12:34
se os pira 00:12:36
que nos ha pasado a todos 00:12:36
claro 00:12:39
y si le dices eso ya no se te va 00:12:42
pues se le puede sacar 00:12:44
mucho partido 00:12:52
si te dice que sí 00:12:53
la tienes en el bote 00:12:57
no hombre, si alguien es capaz 00:12:59
de que a las 4 de la mañana escucharte un rollo de Sprint 00:13:06
es que está muy enamorado 00:13:08
vale, pues el habla virtual 00:13:09
a ver 00:13:17
esto es un texto 00:13:18
en el cual 00:13:20
podéis leer 00:13:22
una introducción mejor escrita 00:13:25
que 00:13:27
lo que 00:13:28
esto está ya mejor escrito 00:13:29
A ver, porque todo esto 00:13:31
es una cosa que merecía la pena escribirlo 00:13:37
Entonces, en origen era un texto mío 00:13:39
y luego le he dicho a Chargetete 00:13:42
Me toca ver el título más bonito 00:13:43
y corrígeme si me lo he equivocado 00:13:45
y me ha quedado 00:13:47
y luego yo 00:13:49
lo he vuelto a tunear también 00:13:52
y ha quedado algo que yo creo que explica 00:13:53
más o menos bien el contexto de lo que vamos a ver 00:13:55
Entonces, el que tenga ganas 00:13:57
se lo lee 00:13:59
que deberíais leerlo 00:14:00
porque no os acordáis, ¿verdad? 00:14:02
hombre 00:14:04
vale 00:14:04
vale, entonces aquí por ejemplo 00:14:05
está este cuadrito 00:14:09
que 00:14:10
nos pone la situación muy en general 00:14:12
de la persistencia 00:14:15
este es el ORN 00:14:16
entonces 00:14:19
nuestra aplicación va a tener objetos 00:14:21
pero los objetos pueden ser 00:14:24
transitorios 00:14:26
o persistentes 00:14:28
los persistentes 00:14:29
estarán en el marco 00:14:32
de persistencia del ORM 00:14:34
y los 00:14:36
persistentes serán 00:14:38
los que el ORM se encargue 00:14:40
de sincronizar con 00:14:42
la base de datos, para que los datos 00:14:44
que tienen los objetos sean los que estén en la base 00:14:46
de datos, a respuesta de nuestras 00:14:48
órdenes, no es que lo haga solo, o sea, esto no es 00:14:50
que lo haga todo solo, hay que hacerlo 00:14:52
¿vale? entonces 00:14:54
lógicamente el ORM tira del 00:14:56
Conector JL. 00:14:58
Imprescindible. 00:15:01
Configurar el mapeo. 00:15:02
Esto es el rollo. 00:15:04
Tenemos que configurar el mapeo 00:15:05
para que esté claro y todo funcione. 00:15:06
¿Vale? 00:15:09
Pero bueno, hay trucos. 00:15:10
Hay trucos también para que te lo hagas medio solo. 00:15:11
Bueno, este sería el esquema más general, 00:15:14
más grosero de la situación. 00:15:18
¿Vale? 00:15:20
Aquí te sigue contando rollo. 00:15:21
Vale. 00:15:23
La mayoría de los ORM aquí menciono. 00:15:23
técnicas de mapeo 00:15:25
lo que os he dicho 00:15:29
en origen a través de un fichero 00:15:29
aparte xml o json que especificaba 00:15:33
el mapeo, ahora actualmente 00:15:35
esencialmente anotaciones 00:15:37
que es lo que vamos a usar nosotros 00:15:38
vale, los ORM 00:15:40
te permiten hacer consultas 00:15:43
también a tu manera y te incorporan 00:15:47
lenguajes propios 00:15:49
el hibernate por ejemplo 00:15:50
te da el hql 00:15:53
que es un lenguaje propio de consultas. 00:15:55
JPA te incorpora al JPQL, luego veremos qué significa. 00:15:59
Pero bueno, aquí habla un poco de Ibernate, esto la idea es que lo leáis. 00:16:03
Y aquí tenemos este cuadro, pero que lo tengo sacado yo en mis diapositivas de cuadros. 00:16:08
Aquí explica el estado de los objetos dentro de ese contexto de persistencia. 00:16:13
Transistorio no está asociado, persistente sí estará asociado. 00:16:19
aunque también luego están estos otros dos estados 00:16:22
pero bueno, el objeto que ha sido persistente 00:16:26
lo puedes separar 00:16:29
y ya deja de ser persistente, ya no está conectado a la base de datos 00:16:31
y el objeto que está en un contexto de persistencia 00:16:35
lo puedes marcar para eliminar y cuando se haga el commit 00:16:38
se queda el eliminado de la base de datos 00:16:41
aquí en este documento está un poquito el esquema 00:16:43
del estado que tendrán los objetos 00:16:49
dentro de ese 00:16:51
marco de persistencia que gestiona 00:16:53
el ORM. 00:16:55
¿Vale? Tú, en tu aplicación, 00:16:57
creas los objetos, conmigo o como te dé la gana, 00:16:59
los creas. 00:17:02
¿Por qué se va otra vez a persistir 00:17:02
el polígono de la gente? 00:17:04
Es que no me ha dado tiempo ni a... 00:17:06
Estaba saliendo de aquí. 00:17:08
Ya, pero eso tiene sentido. 00:17:09
La vida que no veo tiene mucho sentido. 00:17:11
Pero me has hecho un update. 00:17:16
Yo me he hecho un update por ningún sitio. 00:17:17
No he hecho un update. 00:17:20
Detache de separado. 00:17:21
Porque lo puedes volver a actualizar 00:17:22
A ver, que esto es para hacernos una idea 00:17:28
Es hacernos una idea 00:17:33
Esto no es la base de la aplicación 00:17:34
Luego en los proyectos ya lo veremos 00:17:36
Es para ponernos en contexto 00:17:37
Pues tu aplicación arranca 00:17:39
Y tiene sus objetos 00:17:41
Que instanciarás como te dé la gana 00:17:43
Tiene los objetos 00:17:45
Todos esos objetos con los que trabaja la aplicación 00:17:46
Y hacer cosas con ellos son objetos transitorios 00:17:48
A mí no hay persistencia ni hay nada. 00:17:50
Entonces, el ORM te tiene que dar una manera 00:17:53
de hacerlos persistentes. 00:17:55
Que entren en el contexto de persistencia. 00:17:57
Normalmente ese método se suele llamar persist. 00:18:00
¿Vale? 00:18:03
¿Y merge? 00:18:04
Vale. 00:18:05
Merge también. 00:18:06
Lo que pasa es que este se usa normalmente 00:18:08
para actualizar un objeto persistente. 00:18:10
Bueno, es que esto depende mucho del ORM en particular. 00:18:15
Esto es la idea. 00:18:18
vale, el objeto se convierte en persistente 00:18:19
entonces con este objeto tú ya trabajas 00:18:22
haces tus cosas y ya está 00:18:24
con los sucesivos commit 00:18:26
con los sucesivos commit 00:18:29
el estado del objeto se va a reflejar 00:18:31
en la base de datos 00:18:34
aquí faltaría, esto está conectado a la base de datos 00:18:35
vale 00:18:38
vale, cada vez que hagas un refresh 00:18:39
si el estado del objeto en la base de datos 00:18:42
ha cambiado, pues este se sincronizará 00:18:44
si en un momento dado 00:18:47
no te interesa que esté conectado 00:18:48
con la base de datos, lo puedes separar 00:18:50
y se convierte en separado 00:18:52
del cual podría volver aquí otra vez 00:18:54
cuando el objeto 00:18:56
lo quieres eliminar 00:18:58
lo marcas como remove 00:18:59
pasa a este 00:19:02
estado, cuando ya se hagan los commit 00:19:05
correspondientes, ese objeto 00:19:06
ese dato 00:19:08
desaparecerá de la base de datos 00:19:10
desaparecerá de la base de datos 00:19:12
se supone que ese objeto tú luego lo querrás 00:19:14
para que el reconector de basura se lo lleve 00:19:16
no, pero ese es otro tema. Lo que importa es que 00:19:18
desaparezca la masividad. 00:19:20
Esa es un poco la idea. Que nos suene 00:19:22
que hay estos cuatro tipos de objetos. 00:19:24
Que hay un contexto de persistencia que no se nos tiene que olvidar. 00:19:26
En el ORM. 00:19:29
Vale. 00:19:31
Y ya está. Bueno, entonces os leéis esto 00:19:32
para clarificar un poco 00:19:34
los conceptos básicos de 00:19:36
los ORMs. 00:19:38
Ahora, 00:19:40
volvemos aquí. 00:19:42
Arquitectura. Tenemos 00:19:44
esto, esto y esto. 00:19:57
Vale, esto es, este cuadro representa lo mismo que estaba en los apuntes, ¿vale? El objeto nuevo, el objeto existente y aquí ya es un objeto manejado por el ORM, ¿vale? 00:19:59
pues este método, cuando se hacen 00:20:17
los commit y los métodos 00:20:19
correspondientes que en Invernate JPA 00:20:22
es plus, pues actualizan la base 00:20:23
de datos, lo recuperas de la base 00:20:25
de datos con el método find 00:20:27
y tienes un objeto persistente también porque lo has 00:20:29
recuperado, lo puedes pasar a eliminado 00:20:31
lo puedes pasar a separado 00:20:33
bueno, esa es la idea, vale 00:20:35
este cuadro nos importará menos porque precisamente 00:20:36
estos métodos son los que vamos a trabajar 00:20:39
ahora la arquitectura esta con la que 00:20:41
os quería yo 00:20:43
ilustrar, pues para que tuvierais 00:20:44
tema de conversación, a las 4 de la mañana 00:20:46
ya nos quedamos, y conocierais 00:20:48
esos términos que todo el mundo conoce 00:20:50
todo el mundo 00:20:52
dígame 00:20:54
¿estás grabando? 00:20:57
sí 00:20:58
vale, pues a ver 00:20:58
esto ya lo hemos 00:21:02
mencionado 00:21:05
¿de qué arquitectura estamos hablando? 00:21:05
esto es lo que yo he escrito en la pizarra 00:21:08
base de datos, JDBC por encima 00:21:10
hibernate que implementa JPA 00:21:12
y mi aplicación 00:21:15
que puede 00:21:17
directamente trabajar con JPA 00:21:18
a través de su objeto 00:21:21
su manejador 00:21:23
de entidades 00:21:25
que sería este 00:21:27
o puede trabajar con el Spring Data JPA 00:21:28
tendremos que hacer las dos versiones 00:21:31
esta hay que explicar 00:21:36
y esta es la bonita 00:21:38
¿vale? 00:21:40
esta es la arquitectura de hibernate 00:21:41
esto 00:21:43
es lo que está aquí dentro en realidad 00:21:45
lo que está aquí 00:21:48
y JPA lo llama 00:21:50
esto que está aquí dentro 00:21:52
esto moradito hibernate que JPA 00:21:55
lo llama es todo esto, es decir 00:21:56
es un conglomerado de tecnologías 00:21:58
de muchísimas que hibernate 00:22:00
usa, muchísimas 00:22:02
por supuesto debajo está la base de datos 00:22:03
y por encima de la base de datos está 00:22:06
JDBC 00:22:08
vale, pero también necesitamos 00:22:10
poder localizar recursos 00:22:13
que están por ahí distribuidos 00:22:15
pues para eso tenemos el módulo 00:22:16
Java 00:22:19
el JNDI 00:22:20
que esto viene de Java Name Domain 00:22:22
algo 00:22:25
JNDI 00:22:27
si lo buscáis por ahí 00:22:29
este es el módulo que se ocupa 00:22:30
de localizar los recursos 00:22:34
que están por ahí 00:22:36
porque podemos trabajar con bases de datos 00:22:37
que están en cualquier lado 00:22:40
con recursos que están en cualquier lado 00:22:41
vale, esta es la parte 00:22:43
que se ocupa de las 00:22:45
transacciones 00:22:47
¿vale? Java Transactions 00:22:49
API 00:22:51
entonces 00:22:52
Hibernate trabaja con 00:22:54
un objeto sesión, ese es el fundamental 00:22:56
la sesión 00:22:59
hay que abrir una sesión y cuando 00:23:01
se abre una sesión aparece un contexto de persistencia 00:23:03
esa sesión 00:23:05
¿quién la crea? 00:23:07
una sesión factory 00:23:09
¿Vale? La aplicación está aquí 00:23:10
Que tendrá sus objetos transitorios 00:23:12
Creamos un session factory 00:23:16
Y él crea una sesión 00:23:17
Automáticamente aparece un contexto 00:23:19
De persistencia en el cual ya podemos 00:23:22
Meter objetos persistentes 00:23:23
Bien, porque hemos hecho persistentes 00:23:25
Los de la aplicación 00:23:28
O bien porque hemos recuperado 00:23:30
De la base de datos, por ambas vías 00:23:31
Desde arriba y desde abajo 00:23:33
Pueden llegar objetos persistentes ahí 00:23:34
¿Vale? 00:23:36
Entonces, la sesión es el núcleo de 00:23:38
Libertad 00:23:41
¿Vale? 00:23:42
No es obligatorio 00:23:44
Pero se recomienda trabajar siempre con transacciones 00:23:45
O sea, es obligatorio 00:23:48
Cuando actualizamos 00:23:50
La base de datos 00:23:52
No lo es cuando hacemos consultas 00:23:53
Pero un poquito por homogeneidad 00:23:56
Por, se dice, mira, por defecto 00:23:58
Mételo todo siempre en una transacción 00:24:01
Y ya está, entonces la sesión crea la transacción 00:24:02
¿Vale? 00:24:04
entonces, este es el que te provee 00:24:07
de las conexiones, que se apoya sobre 00:24:09
JDBC, la sesión 00:24:11
lógicamente necesita 00:24:13
este proveedor de conexiones 00:24:14
el manejador este de transacciones 00:24:16
que se apoya en este JTA 00:24:19
aunque no obligatorio 00:24:21
podría saltárselo, bueno, esto lo pongo 00:24:23
solo para ilustrar 00:24:25
que esto 00:24:27
es una arquitectura ya compleja 00:24:28
según vamos poniendo cambios, es una arquitectura compleja 00:24:31
con un montón de dependencias y de rollos 00:24:33
y entonces cuando nos falla 00:24:35
algo, nos pueden 00:24:36
haber fallado mil cosas 00:24:38
diferentes, luego ahora 00:24:40
encontrar un error, ahora ya no es tan 00:24:42
fácil, porque ahora cuando algo nos 00:24:44
falla, vete a saber 00:24:46
porque esto recuerdo 00:24:48
que es lo que está aquí dentro 00:24:50
y además resumido 00:24:52
luego está todo lo que hay aquí, más todo lo que 00:24:54
hay aquí, aquí hay millones 00:24:56
de cosas y listo, entonces cuando te falla 00:24:58
algo, pero 00:25:00
tener una foto en la cabeza, un 00:25:01
vistazo de con qué estamos trabajando 00:25:04
y cuál es nuestra arquitectura y dónde está cada cosa 00:25:06
y que esa foto no se nos olvide, 00:25:08
pues nos ayuda. 00:25:11
No solo para el viernes por la noche, 00:25:12
nos ayuda porque damos un error. 00:25:14
¿El JTA y el JPA son la misma también? 00:25:15
No, no, no, no, no. 00:25:19
No tiene nada que ver. 00:25:20
No, JTA es un módulo de gestión 00:25:22
de transacciones que usa Hibernate. 00:25:25
Es una dependencia, ¿vale? 00:25:26
Y JPA es una API para la 00:25:28
persistencia de Java, ¿vale? 00:25:30
Vale, entonces, no sé si me he olvidado 00:25:33
algo lo que quisiera contaros de la distribución. 00:25:34
Yo creo que no. 00:25:36
Vale. Entonces, 00:25:51
JTA 00:25:56
es un módulo muy complejo 00:25:57
en realidad, porque es un módulo de gestión 00:25:59
de transacciones a nivel de aplicaciones 00:26:01
empresariales. En realidad 00:26:03
no hay por qué usarlo, 00:26:05
porque con JDBC ya podemos 00:26:07
gestionar las transacciones como lo hemos hecho 00:26:09
hasta ahora. O bien, 00:26:11
haciéndose el commit, poniendo 00:26:14
el set autocommit falso y luego haciendo 00:26:15
el commit con el jdbc puro 00:26:17
o bien con las anotaciones transactional 00:26:18
eso no sería jdbc 00:26:21
es una gestión de transacciones nuestra 00:26:23
más manual, en aplicaciones empresariales 00:26:25
ya complicadas 00:26:27
este te ofrece muchísimas más 00:26:28
posibilidades en funcionalidades 00:26:31
que están distribuidas, hacer una transacción 00:26:33
a diferentes niveles, pero bueno 00:26:34
aparece ahí dentro 00:26:37
porque para ese tipo de aplicaciones se puede usar 00:26:38
vale, y ahora ya yo creo 00:26:41
que vamos a empezar a programar, ¿verdad? 00:26:43
No, no, no, no 00:26:45
No explico mejor esto porque no lo sé 00:26:55
Y porque 00:26:57
A ver 00:26:58
Que podría tirarme el pisto, pero para qué 00:27:06
Si yo no conozco JTA 00:27:13
En detalle, para qué voy a hablar de él 00:27:15
Pero vamos que si quieres que te explique 00:27:17
JTA en detalle, se te lo pido en detalle 00:27:19
Vale, pero bueno 00:27:21
¿Entendéis el contexto 00:27:29
De lo que estamos hablando? 00:27:32
Y lo que vamos a hacer 00:27:34
Y lo que vamos a trabajar 00:27:35
Vale, pues entonces 00:27:36
Venga, en estos 5 minutos vamos a hacer la parte 00:27:41
Venga, nuestro primer ejemplito 00:27:46
nuestro primer ejemplito 00:27:49
al menos que tenga una clave 00:27:51
porque si no tiene una clave 00:27:52
nuestro primer ejemplito 00:27:53
con esta base de datos 00:27:56
vamos a hacer un jpa puro 00:27:58
y ya solo con eso 00:28:01
ya salen bastantes 00:28:03
cosas 00:28:05
bastantes detallitos 00:28:06
monos 00:28:09
Bueno, pues ejecutáis ese script 00:28:09
Os aparecerá una base de datos 00:28:22
Pégalo en una pestañita SQL del Wordbench 00:28:25
Y lo ejecutas 00:28:34
y era 00:28:35
esta base de datos 00:28:40
a ver, ¿dónde estamos? 00:28:52
hay que hacer lo de la ingeniería 00:29:26
no, bueno, esto lo he hecho yo para que veamos 00:29:28
la base de datos 00:29:30
luego ya los ejemplos que os pasaré 00:29:31
para hacer vosotros 00:29:35
para que practiquéis vosotros 00:29:36
con esto, con Spring Data, con lo que sea 00:29:37
ya van a empezar a tener 5 o 6 tablas 00:29:39
5 o 6 tablitas 00:29:42
con relaciones de muchos a muchos 00:29:48
y todo eso, es que si no, estoy insultando 00:29:50
vuestra inteligencia 00:29:52
¿Quién me ha quitado la infusión? 00:29:53
Pero si la has movido 00:29:56
¿Yo a dónde? 00:29:57
Vale, una única clave ajena 00:29:58
Bueno 00:30:19
Pues ahora vamos a hacer una aplicación 00:30:20
que recupere empleados con cierto nombre, 00:30:25
los departamentos con más de tantos empleados. 00:30:31
Solo con esto ya podemos hacer un montón de historias. 00:30:33
Pues venga, como ya tenéis la base de datos hecha, 00:30:37
ahora vamos a abrir el Eclipse Normalucho y Corrientucho. 00:30:39
Porque va a ser una aplicación de escritorio ahora mismo, 00:30:47
no vamos a hacerle... 00:30:50
lo que se acaba de hacer en Spring 00:30:51
lo has aprendido 00:30:56
por lo cual cuando le pongamos la capa de Spring 00:30:57
a esto, se la podrás poner 00:31:00
automáticamente, lo que pasa es que ya se la vamos a poner 00:31:02
con Spring Data JPA 00:31:04
es para que aprendas Spring y Spring.org 00:31:05
pero como que pana 00:31:12
pero a ver, es que de verdad 00:31:16
en el día a día aquí 00:31:18
Pero vosotros qué creéis que es la vida 00:31:19
Hay muchas cosas en la vida 00:31:27
¿Vale? 00:31:39
Entonces, ¿cuándo...? 00:31:40
Bueno, porque 00:31:42
cuando no vamos a hacer un proyecto con sprint 00:31:47
pues hombre, es más 00:31:50
cómodo el otro 00:31:52
hombre, con el sprint tool 00:31:53
puedes hacer proyectos sin sprint 00:31:58
por supuesto, es un eclipse normal y corriente 00:32:00
a ver, si solo queréis 00:32:02
usar el sprint solamente, si queréis 00:32:04
me da igual 00:32:06
lo único que decía es que este proyecto que vamos a hacer 00:32:06
ahora es sin sprint 00:32:10
pero lo que forma parte 00:32:11
de vuestro desarrollo como seres humanos 00:32:14
el no perderos en la vida 00:32:15
claro, el 00:32:18
yo que sé 00:32:22
el manejaros en las situaciones, el no quedaros 00:32:22
desconcertados por cualquier cosa 00:32:26
yo que sé 00:32:27
venga 00:32:29
abrimos 00:32:31
o el que 00:32:33
o el sprint tools, el que te dé la gana 00:32:35
vamos a hacer un proyecto 00:32:38
sin sprint 00:32:39
ala, volvemos aquí 00:32:40
vale 00:33:03
venga, pues este lo vamos a hacer 00:33:11
este como es el primero 00:33:20
lo vamos a hacer de cero, luego ya sabéis que al final 00:33:22
la acabamos copiando, pegando y de todo. 00:33:24
Pues venga. 00:33:27
¿Eh? 00:33:31
Claro, este desde cero. 00:33:32
Venga, proyecto de 00:33:35
Mave. 00:33:36
¿Qué grupo queremos? El de siempre. 00:33:43
¿Por qué no es mejor 00:33:45
que ponía el número tanto? 00:33:47
Porque la verdad es que el número 00:33:49
da un 2 y un 2. 00:33:51
No, el convenio 00:33:53
ponerlo así, siempre, porque 00:33:55
de toda la vida. 00:33:57
Bueno, lo sé, igual me equivoqué. 00:34:00
Dime. 00:34:02
¿Dónde? En la anterior, dices. 00:34:10
Un proyecto normal. 00:34:16
Aquí lo que pasa es que me ha añadido a mi working set. 00:34:18
Si tú no tienes working set, eso 00:34:20
no lo marcas, claro. 00:34:21
Vale. 00:34:25
Unidad didáctica 3. 00:34:25
JPA 00:34:28
empleados 00:34:30
departamentos 00:34:33
clase 00:34:34
y ahora 00:34:36
¿para qué vamos a usar? 00:34:42
ahora sí que os va a volar la cabeza 00:34:44
bueno, ahora no, el próximo día 00:34:45
pero a ver, no me digáis 00:34:47
pero sí 00:34:51
lo he hecho mil veces 00:34:51
y ahora resulta que 00:34:53
crear un proyecto 00:34:56
se acabó 00:35:01
y ya se han muerto 00:35:02
pues os va a volar la cabeza ahora 00:35:04
porque vamos a usar este proyecto 00:35:07
JPA puro 00:35:09
para darle un diseño guay 00:35:10
con clases genéricas 00:35:12
con dados genéricos 00:35:15
el proyecto, yo lo he llamado así 00:35:16
tú llámalo como quieras 00:35:21
lo llamo así 00:35:22
pero si habéis hablado virtual, si no me lío. 00:35:24
Vale, pues venga. 00:35:27
Venga, nuestro, ¿qué es lo primero que hacemos siempre? 00:35:32
El modelo. 00:35:35
Lo primero que hacemos siempre es el modelo. 00:35:37
Ah, bueno, las dependencias, tienes razón. 00:35:40
Sí, pero bueno. 00:35:42
Hasta, ¿cómo me llaman? 00:35:46
Model. 00:35:49
Vale, según me las vaya pidiendo y así. 00:35:50
La de hibernate y el driver son las que vamos a necesitar seguro 00:35:54
Ahora las ponemos cuando las vaya pidiendo 00:35:58
Venga, pues a ver, el modelo 00:36:00
Pues el modelo, uno se mira aquí esto 00:36:02
Y dice, pues dos entidades 00:36:05
Departamento y empleado 00:36:07
Pues ya está, tan ricamente 00:36:09
Se hace una nueva clase 00:36:11
Empleado 00:36:16
Y se hace una nueva clase departamento 00:36:19
Entonces, a ver, ¿qué queremos que tengan? 00:36:22
Pues departamento va a tener 00:36:35
Su id entero 00:36:38
Y su nombre string 00:36:40
Pues ya está 00:36:42
El departamento 00:36:43
Va a tener 00:36:47
Esto queda como más profesional 00:36:47
Poner el proper 00:36:51
Vale, vamos a poner ahora mismo 00:36:52
Los getter y setter y ya está 00:37:01
Luego ya le iremos completando 00:37:02
No hombre, se acaba 00:37:04
Hay 40, la clase 00:37:07
No, no, no, no, hay 40 00:37:08
Sí, vale 00:37:10
Empleado 00:37:13
Empleado 00:37:17
Que tiene 00:37:19
Su ID entero 00:37:20
Su nombre string 00:37:23
Y luego tiene esa clave ajena 00:37:25
Su ID entero 00:37:28
El nombre de empleado 00:37:36
Que es string 00:37:40
Y ahora tiene este campo 00:37:41
Que de alguna manera 00:37:43
Tenemos que mapear aquí 00:37:44
Pero aquí lo que jamás haríamos 00:37:46
Sería poner un campo entero 00:37:50
Y de departamento 00:37:51
No, porque para qué queremos 00:37:52
Entonces ORM es capas 00:37:55
Para manejar luego nosotros 00:37:57
El ir de un objeto a otro no tendría sentido 00:37:59
Entonces el empleado 00:38:01
Pertenece a un departamento 00:38:03
Y como tal 00:38:05
Estará aquí su departamento 00:38:06
Pues los nombres rusos 00:38:09
Vale, con sus getter y setter 00:38:17
Vale, entonces, ahora mismo las vamos a dejar así 00:38:24
O sea, ahora mismo 00:38:34
Me refiero a estos próximos dos segundos 00:38:35
Sí, pero 00:38:37
Ahora se la vamos a ir pidiendo 00:38:40
Vale, entonces, ahora mismo esto se nos quedaría así 00:38:41
Ahora vamos a empezar a 00:38:44
Configurar 00:38:45
Estas entidades 00:38:47
Para que se mapeen exactamente 00:38:50
Con las tablas correspondientes 00:38:52
Según 00:38:54
Las 00:38:56
Reglas de JPA 00:38:58
Bueno, pues cada tabla es una entidad 00:38:59
Luego lo primero que necesitamos es 00:39:02
Anotarlas con entity 00:39:04
Cada una de ellas 00:39:08
Entity 00:39:10
Y entity 00:39:12
Vale, entonces 00:39:14
Estas anotaciones, como todas las anotaciones 00:39:20
Son clases 00:39:23
Que habrá que importar 00:39:24
Vale, entonces aquí 00:39:27
Necesitamos 00:39:28
Ya antes las dependencias 00:39:30
Vale 00:39:32
Pues entonces, a ver, vale, las dependencias necesitamos hibernate, que es la implementación de JPA, y necesitamos el driver, ¿vale? 00:39:33
Entonces, las podéis buscar en el repositorio de Maven, o las voy a copiar yo aquí. 00:40:02
¿Qué le pasa a este ratón? 00:40:14
Se ha muerto el ratón 00:40:24
El mejor momento 00:40:30
Ahí está 00:40:33
Vale 00:40:42
Entonces 00:40:43
Y le vamos a quitar esto de aquí 00:40:58
Ah, y otra cosa que no hemos hecho 00:41:00
Es cambiar 00:41:07
La máquina virtual 00:41:09
Que se me ha quedado en la 8 00:41:12
Y ahora 00:41:14
El nivel de compilación 00:41:23
Aquí 00:41:27
Driver MySQL 00:41:29
Ahora lo pongo de todas maneras 00:41:39
Vale, entonces un segundito 00:41:41
Voy a ver cuál me ofrece 00:41:44
A ver si la que me ofrece es la buena 00:41:46
O vamos a necesitar 00:41:48
Vale, sí, me ofrece la buena, la de la carta 00:41:50
Vale, pues entonces 00:41:57
las dependencias que he puesto 00:41:59
son 00:42:01
estas dos 00:42:03
la del ORM de Hibernate 00:42:06
que implementa el JPA y el driver 00:42:09
¿vale? 00:42:10
con eso ya se puede importar de 00:42:12
Jakarta, porque recordad que 00:42:14
JPA es estándar de 00:42:16
Java 00:42:19
entonces, como es a partir 00:42:19
de cierta, no es el JavaX 00:42:23
Persistence Entity 00:42:25
sino el Jakarta 00:42:27
No existe 00:42:28
Esta versión no es la más actualizada 00:42:29
De Ibernate, podríamos poner 00:42:42
No es la más actualizada, pero bueno, se puede cambiar ahí 00:42:43
Y ya está, tampoco hay mucho 00:42:45
Que ya no vamos 00:42:47
Que ya no vamos, ¿no? 00:42:54
No, que tengo que irme al baño, que es que tengo que presentar ahora 00:42:57
Dale, dale, dale 00:42:59
Ah, que tienes presentación de videojuegos 00:43:00
Pues venga, pues nada, vamos a ir recogiendo 00:43:02
Vale, pero las podíais coger de Maven también 00:43:04
Ahí está 00:43:09
¿Cuál era la determinación? 00:43:15
Esas dos que están ahí 00:43:19
Vale 00:43:20
Te lo dejo ya 00:43:21
Te lo dejo ya 00:43:30
Ya lo conocía 00:43:33
Vale 00:43:34
Bueno, pues tenemos una clase preciosa 00:43:46
El próximo día 00:43:50
La más bonita del mundo 00:43:50
¿Qué? 00:43:54
Estaba creando la tabla esta 00:43:56
De empleado y departamento 00:43:58
Que tienes ahí 00:44:01
Sí 00:44:02
Yo voy a meter por SQL 00:44:02
Pero 00:44:05
¿Qué SQL explicaste ahorita? 00:44:06
¿Cómo? ¿El qué? ¿El qué? 00:44:09
Para meterlo en el código SQL 00:44:10
A ver, no mediante el código SQL 00:44:13
Que si tú 00:44:15
Abres el proyecto 00:44:17
Ahí en las sentencias 00:44:18
Pues lo tienes, por ejemplo 00:44:20
Aquí donde lo teníamos 00:44:21
Espérate 00:44:24
Estaba aquí en 00:44:24
Ay, no, este no 00:44:26
Vale 00:44:28
este que trabajaba 00:44:31
con transacciones 00:44:37
pues aquí el de implementación 00:44:38
tenía, mira ves 00:44:41
aquí tienes las propiedades 00:44:43
la tabla, ID, escaparate 00:44:45
NIF comprador 00:44:47
coche y color 00:44:49
estas son 00:44:51
para meterlas ahí 00:44:51
en MySQL 00:44:57
¿cómo para meterlas? 00:44:57
A ver, el script está 00:45:01
Pues te haces aquí un 00:45:05
SQL 00:45:08
Y aquí copias y pegas 00:45:10
No sé 00:45:14
No, no, no 00:45:17
Pues no sé decirte 00:45:25
A ver, Cecilia es un nombre 00:45:26
que está de moda últimamente 00:45:44
Cecilia, sí 00:45:46
Yo he conocido de mi edad Celias 00:45:49
Bueno, Celias sí que hay bastantes 00:45:52
Yo creo que he conocido a alguna niña 00:45:55
Sí, Virginia, sí 00:46:01
Y esto sin parar 00:46:10
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:
12 de enero de 2026 - 20:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
191.10 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid