Saltar navegación

20260115 JPA_4 - 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 19 de enero de 2026 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, a ver, vamos a revisar rápidamente el main ese que 00:00:00
hemos hecho, que decía él por si alguien, ¿vale? 00:00:03
Pues, a ver, este es la unidad de persistencia o el contexto de 00:00:06
persistencia. 00:00:11
Dentro de él y hasta que aparezca un close, 00:00:11
podemos manejar objetos persistentes y también que no 00:00:16
lo sean, por supuesto, transitorios. 00:00:20
Bueno, siempre se recomienda trabajar en el contexto de 00:00:22
transacciones. 00:00:25
Cuando se modifica la base de datos, obligatorio, 00:00:26
aunque no sea transacción como tal 00:00:28
porque no tengo varias sentencias, pero no ha sido obligatorio 00:00:30
si no, no 00:00:32
¿lo sentís mucho? 00:00:33
no, es mentira, no lo sentís mucho 00:00:38
es una forma de hablar 00:00:40
¿lo sentís mucho de verdad? 00:00:40
pero, ah, vale, vale 00:00:44
¿desde cuándo no se puede subir 00:00:46
hasta menos de 20? 00:00:50
eso yo no lo sé 00:00:53
eso yo no tengo ni idea 00:00:54
pregunto al agajo, no tengo ni idea 00:00:55
¿Y eso qué significa? 00:00:57
Significa nada, no lo sé 00:00:59
Vale, a mí nada 00:01:01
Venga, volvemos 00:01:04
Este es el contexto de persistencia 00:01:05
Recomendable, trabajar con transacciones 00:01:07
Obligatorio cuando se modifica la base de datos 00:01:09
Cuando solo se consulta no, pero bueno 00:01:12
Es un hábito 00:01:14
¿Qué habíamos hecho en este mail? 00:01:14
Creamos un objeto, ahora mismo es transitorio 00:01:17
Y ya está 00:01:20
Con persist lo hacemos persistente 00:01:20
Lo cual tiene como efecto 00:01:23
Insertarlo en la base de datos 00:01:25
¿Vale? Como la clave es autogenerada 00:01:27
Se quedará una clave y ya está 00:01:29
Si no fuera clave autogenerada 00:01:31
Si la clave primaria fuera el nombre 00:01:33
Por ejemplo, y ya hubiera uno que se llama casa 00:01:35
Si probáis a hacerlo, veréis como dice 00:01:37
Un error de clave primaria 00:01:40
Pero bueno, será esperable 00:01:42
Claro, claro 00:01:43
Si como consecuencia, porque lo que 00:01:46
Por debajo llama esto es a un insert de jdbc 00:01:49
Si ese insert falla, pues se lo va a decir 00:01:52
Claro, ahora, ¿qué habíamos hecho en este main? 00:01:53
Cogíamos un empleado al que le íbamos a poner 00:01:56
Este departamento porque lo queríamos cambiar 00:01:58
Con este método find que te recupera 00:02:00
Por clave primaria 00:02:03
¿Vale? Y le decimos 00:02:04
A qué clase va a caer 00:02:06
Bueno, ahora 00:02:07
Cogíamos 00:02:09
Esto para mostrarle para el empleado 00:02:14
Ahora le cambiamos el departamento 00:02:17
Es decir, a este empleado 00:02:19
Le poníamos el departamento 00:02:20
Nuevo que acabamos de coger 00:02:23
Le poníamos ese departamento 00:02:25
¿Vale? Hacíamos la transacción 00:02:27
Para que se hiciera 00:02:30
Y ahora, yo ahora 00:02:31
Esto no estaba antes 00:02:33
Yo ahora quiero acceder 00:02:35
Al objeto departamento 00:02:38
Y a sus empleados en particular 00:02:39
Que tendrá este nuevo 00:02:42
Que le acabo de meter 00:02:44
No era un departamento nuevo, tendrá este nuevo 00:02:45
Pero claro, lo que yo quería hacer antes 00:02:47
Es, oye, como he hecho cambios 00:02:50
En los objetos, refrescámelo 00:02:52
¿Vale? O sea, a empleado le he cambiado 00:02:54
El departamento 00:02:57
Refrescame departamento 00:02:58
Para que se actualice 00:03:01
Su propiedad de empleados 00:03:02
Entonces yo estaba enterrada en el flush 00:03:04
Y luego ya me dio la cabeza que era el refresh 00:03:05
¿Vale? Entonces ahora ya sí 00:03:08
Vamos a coger los empleados 00:03:11
De departamento, que me va a aparecer este 00:03:13
Que le acabo de meter 00:03:15
Me va a aparecer este y aquí pues uno ya hace 00:03:16
Lo que le dé la gana, en mi caso era el stream 00:03:19
Pero eso ya lo habíamos metido en otro sitio 00:03:21
y ya está 00:03:22
vale, esto en cuanto a esto de aquí 00:03:24
ahora, el otro método 00:03:26
que habíamos probado 00:03:28
el flush 00:03:30
creo recordar que te 00:03:34
si tú has hecho un 00:03:35
un get 00:03:37
o sea, si tú has hecho un cambio en la base de datos 00:03:40
te refresca ese cambio 00:03:42
pero aquí no ha sido eso, aquí hemos cambiado 00:03:43
los objetos, o sea, el flush es con la base 00:03:46
de datos, el refresh es 00:03:48
sincronización entre los objetos 00:03:50
¿vale? es decir, yo aquí he cambiado 00:03:51
el departamento 00:03:55
¿vale? he cambiado el departamento y ya está 00:03:56
y esto de hecho 00:03:59
lo podría quitar, no me hace falta 00:04:01
esto no, la base de datos 00:04:02
entonces, hibernate deja 00:04:04
marcado en su mundo 00:04:06
de los objetos, él va dejando 00:04:08
las marcas de lo que va haciendo para cuando 00:04:10
luego te da que hacer commit o lo que sea 00:04:12
¿vale? cuando luego te da que hacer 00:04:14
pues en el mundo de los objetos, él ya deja 00:04:16
marcado que este empleado está 00:04:18
en este departamento, pero yo 00:04:20
el objeto correspondiente lo quiero 00:04:22
sincronizar, o sea, el rifle es una sincronización 00:04:24
entre los objetos, para que los objetos queden coherentes 00:04:26
pero no estoy haciendo nada con la base de datos 00:04:28
¿vale? 00:04:30
entonces, ahora ya el objeto departamento 00:04:32
el contexto de persistencia 00:04:35
lo refresca para que se quede 00:04:36
coherente con esto que acabo de hacer 00:04:38
para que se quede coherente 00:04:40
que luego yo todo esto que estoy haciendo en los objetos 00:04:41
quiero ya que se refleje en la base de datos 00:04:44
pues entonces ya hago el comando 00:04:47
¿vale? 00:04:48
el flush es pues eso 00:04:50
ha habido un cambio en la base de datos y yo quiero que mis objetos 00:04:52
se enteren, hago un flush y ya está 00:04:54
yo no lo he probado 00:04:55
pero es como se supone que funciona 00:05:01
vale 00:05:02
vale, entonces 00:05:03
ahora, siguiente método que habíamos 00:05:06
hecho, pues este 00:05:08
otro contexto de persistencia, nos cogíamos 00:05:10
el departamento, cogíamos 00:05:12
sus empleados, les cambiábamos 00:05:14
el nombre y ya hemos visto que funciona 00:05:17
y ya está, algunas pruebitas que hemos hecho 00:05:18
para ver un poquito por encima cómo funciona JPA 00:05:21
que habéis visto 00:05:23
que es más fácil, trabajo con los objetos 00:05:24
y me olvido del JDBC 00:05:27
y del SQL 00:05:28
me olvido del SQL entre comillas 00:05:30
porque 00:05:33
sí, bueno, eso por 00:05:35
descontado, pero también 00:05:37
me olvido, pero perdón 00:05:39
tampoco me puedo olvidar del todo 00:05:40
porque si yo quiero hacer consultas raras 00:05:42
que no sea una por clave primaria 00:05:44
como me la da el FINE 00:05:47
la tengo que hacer con un lenguaje propio 00:05:48
de JPA que es el JPQL 00:05:50
que se parece mucho al SQL 00:05:53
pero no lo es 00:05:54
¿vale? entonces yo quiero 00:05:55
recógeme 00:05:59
los empleados cuyo departamento 00:06:00
empieza por 00:06:03
mayúscula 00:06:04
esa consulta JPA no la tiene, la tenemos que construir 00:06:05
entonces tendríamos 00:06:08
que hacer un JP 00:06:10
una sentencia JPQL 00:06:12
que es muy parecida a SQL 00:06:14
por ejemplo 00:06:16
Vamos a hacer aquí 00:06:17
Vamos a hacer una consulta 00:06:19
Que 00:06:21
Recoger 00:06:21
Todos los 00:06:26
Empleados 00:06:27
Que 00:06:29
Recoger por otro campo, ya está, más sencillo 00:06:34
Todos los empleados que se llamen 00:06:38
Ana barra baja 00:06:42
Como tengo dos me dará dos 00:06:43
Vale, pues a ver 00:06:45
O sea, recoger empleados por nombre 00:06:47
En definitiva 00:06:48
Vamos a hacernos aquí un método 00:06:49
Ahí mismo 00:06:52
Entonces 00:06:54
Esto me va a dar 00:06:59
Una lista de empleados 00:07:01
Vale, pues aquí tendría que hacer 00:07:02
Esto también 00:07:25
De nuevo, como aquí voy a leer 00:07:27
La transacción 00:07:34
No es obligatoria 00:07:36
Pero bueno, es un buen hábito 00:07:37
Ponerla siempre 00:07:39
Porque no molesta, desde luego daño no va a hacer 00:07:41
Y aquí tendríamos 00:07:44
un em.close 00:07:56
Vale, pues aquí es donde tenemos que 00:07:58
ver qué hago yo para sacar esta lista 00:08:00
de empleados 00:08:03
Esta lista de aquí, ¿cómo la saco? 00:08:04
Esto va a ser una query, tenemos que 00:08:07
hacer una query 00:08:09
El find de em 00:08:09
no nos vale 00:08:12
Este, bueno, no vale 00:08:13
porque este recupera por clave primaria 00:08:17
solamente 00:08:19
Vale, pues entonces, tenemos que 00:08:19
hacer una consulta en el lenguaje 00:08:22
jpul 00:08:24
una query 00:08:26
en el lenguaje jpql 00:08:28
jpql es muy parecido 00:08:29
a sql, muy parecido 00:08:32
pero 00:08:34
los nombres de las tablas 00:08:34
ahora serán los nombres de las clases 00:08:37
y los nombres de los 00:08:39
campos ahora serán los nombres 00:08:42
de las propiedades 00:08:44
para todo lo demás 00:08:45
sería casi equivalente 00:08:48
pero tú en sql que haces 00:08:49
consultas en tablas 00:08:51
nombres de campos 00:08:53
Pues aquí consultas en nombres de clases, nombres de propiedades. Entonces, en JPQL, pues uno lo puede estudiar al detalle o ver un poquito por encima cómo funciona para saberlo y luego ya cuando tiene que hacer algo, preguntárselo a HGPT. Esa sería nuestra opción, lógicamente. 00:08:55
saber de qué va, cómo funciona 00:09:17
y uno quiere... 00:09:20
No, en el examen no, porque yo en el examen no te pido 00:09:21
cosas muy específicas. 00:09:24
Te pido lo que hemos 00:09:26
mencionado aquí. 00:09:27
Entonces, todo lo que 00:09:30
os pido en el examen, lo sabéis 00:09:32
hacer. Luego, otra 00:09:34
cosa es que uno ya se ponga a hacer un proyecto que 00:09:36
necesita cosas muy específicas. 00:09:37
Uy, una consulta que me tiene que hacer, 00:09:40
coger la inicial de no sé qué y hacerme 00:09:41
no sé cuántos, pues esa consulta, 00:09:43
como la tienes muy acotada lo que quieres 00:09:45
se la pides, esa es nuestra manera 00:09:48
de trabajar, verdad 00:09:50
vale, pero esta query es facilita, esta query 00:09:51
es, vamos a seleccionar 00:09:54
el que vamos a seleccionar 00:09:57
todo un empleado 00:09:59
entero 00:10:00
empleado, obligatorio poner 00:10:01
un alias en JPQL 00:10:04
from 00:10:06
¿de qué tabla? from empleado 00:10:09
no, pero estoy seleccionando empleados por nombre 00:10:12
Porque he roto el stream 00:10:16
Bueno, para que me quepa en la pantalla 00:10:29
Pero si no, poner el multilínea 00:10:32
Con los tres, lo que sea 00:10:34
Where 00:10:36
E.nombre 00:10:39
Igual a 00:10:42
Y aquí es donde 00:10:46
Si fuera jdbc 00:10:47
Se pondría la interrogación 00:10:49
Pero aquí no se pone la interrogación 00:10:51
aquí se pone dos puntos y el nombre que le doy 00:10:53
a este parámetro que luego voy a inyectar 00:10:55
llamémosle nombre el que sea 00:10:58
vale 00:10:59
entonces 00:11:01
aquí que estoy haciendo mal 00:11:02
ah bueno que estoy aquí está 00:11:05
vale voy a dejar así para que no 00:11:06
moleste 00:11:09
vale bueno pues ahora 00:11:11
tenemos que hacer una query 00:11:13
una query que esta la sacamos 00:11:15
de em 00:11:20
a ver si veo que pierdo mucho tiempo 00:11:21
no create query 00:11:24
Lo miro en la chuleta y ya está 00:11:25
Esto será 00:11:28
Create 00:11:29
Query 00:11:31
Vale 00:11:33
Y ahora aquí 00:11:34
Le ponemos la query 00:11:36
Import query de Jakarta 00:11:39
Persistence, vale 00:11:46
Y se llaman igual, vale 00:11:48
String 00:11:53
JPQL 00:11:54
Lo vamos a llamar JPQL 00:11:57
jpql 00:11:59
vale, y ahora la query 00:12:03
hay que fijarle el parámetro 00:12:05
query.tendrá un set parameter 00:12:07
vale 00:12:10
el parámetro de posición 00:12:10
que se llama nom 00:12:13
perdón 00:12:15
también se puede acceder por posición 00:12:17
le vamos a dar 00:12:19
el parámetro de aquí arriba del 00:12:21
método que era nombre 00:12:23
mi parámetro 00:12:25
del método 00:12:28
vale, y ahora 00:12:28
a esta query que ya le he fijado el parámetro 00:12:35
le puedo sacar ya 00:12:37
el get result list 00:12:39
y ya esto va aquí 00:12:41
o sea, lo he hecho todo línea por línea 00:12:43
esto sería en una línea normalmente 00:12:45
vale, me dice que claro 00:12:46
es un casting sin chequear 00:12:54
sí, claro que es un casting 00:12:57
sin chequear, pero así es la vida 00:12:59
hay que confiar en que 00:13:01
yo he hecho bien 00:13:03
el jpql de arriba 00:13:05
Bueno, pues esta es la idea de JPQL 00:13:06
Parecido a SQL 00:13:14
Es un mundo de detalles 00:13:16
Y de historias al conocerlo 00:13:18
No es nuestra intención 00:13:19
Yo aquí estoy cogiendo el objeto entero 00:13:21
Podría coger 00:13:23
Solo propiedades sueltas 00:13:25
Entonces no sería un list de empleados 00:13:27
Sino un list de integer, de lo que fuera 00:13:30
Vale, no tengo que coger siempre objetos enteros 00:13:31
Puedo coger propiedades sueltas 00:13:34
Vale, fijo tantos parámetros 00:13:36
Como quiera 00:13:38
puede hacer join, puede hacer de todo 00:13:39
meterse en jpql ya sería 00:13:41
otro tema para el que no tenemos 00:13:45
tiempo 00:13:47
¿vale? entonces lo normal 00:13:48
aquí es anidarlo todo 00:13:51
pues desde empleados de arriba 00:13:53
habríamos hecho el createquery 00:13:55
setparameter de resundice 00:13:57
lo normal es que lo hubiéramos todo 00:13:59
metido en una única línea 00:14:01
¿vale? pero bueno 00:14:03
a partir de aquí podría yo tirar con el 00:14:05
create query, bla, bla, bla, bla, bla, y lo tengo 00:14:07
todo en una línea. Pero así 00:14:09
en principio se ve más claro. 00:14:11
A ver, vamos a probarlo 00:14:14
desde nuestro main. Ah, bueno, 00:14:15
que no he hecho el return. 00:14:17
Return empleados. 00:14:25
Vale. 00:14:31
¿El alias no es en el front? 00:14:38
Vamos a probarlo. 00:14:46
En SQL es en el front. 00:14:51
Pero aquí es que 00:14:53
En el front me está sonando raro a la vista 00:14:54
Vamos a probarlo 00:14:57
Y si no lo cambiamos 00:14:58
Vámonos al main 00:14:59
En mi caso 00:15:08
Yo voy a coger 00:15:15
Ana barra baja 00:15:16
Y ahora voy a mostrarlo todo 00:15:18
Get empleados 00:15:27
Esto voy a hacer 00:15:29
Punto 00:15:32
String 00:15:35
Punto for each 00:15:36
Que me los muestre 00:15:38
Vale, entonces como no tengo un toString 00:15:42
Empleado 00:16:08
Me va a salir un poco feo 00:16:10
Vamos a hacer un toString rápido 00:16:11
Un toString rápido 00:16:13
Sin el departamento 00:16:20
Con id y nombre 00:16:21
Vale, alguien llama por ahí 00:16:23
Igualmente 00:16:30
vale, vamos a ver si 00:16:33
la jpql 00:16:36
la hemos escrito bien, igual no está bien escrita 00:16:38
en ese caso uno lo consulta 00:16:40
y dice, ah, es que he puesto el de donde no es 00:16:42
venga, vale 00:16:43
interpret expression 00:16:52
e.nombre, vale 00:16:56
efectivamente el alias 00:16:57
lo he puesto 00:16:58
select 00:17:00
es que 00:17:01
hay otro lenguaje 00:17:05
que es hql 00:17:07
No, no me 00:17:08
A ver, es que HQL es el propio 00:17:11
De consulta de hibernate 00:17:14
¿Vale? Que se parece a JPQL 00:17:15
Pero no, entonces a veces los mezclo los dos 00:17:18
Y prefiero, en lugar de mirarlo 00:17:20
Que lo hagamos como nos sale 00:17:22
Porque si nos salen errores 00:17:24
Eso hace que doblemente lo aprendamos 00:17:25
Pues hemos tenido que trabajarlo dos veces 00:17:28
Select 00:17:29
A ver, si es así 00:17:31
De empleado es 00:17:35
Selecciona el objeto enterito 00:17:37
Si no, podría yo seleccionar solamente el nombre 00:17:38
El que fuera 00:17:41
No, vamos a seleccionar el objeto enterito 00:17:41
Para que sea un list de empleados 00:17:44
Vamos a ver ahora 00:17:46
¿Tampoco? 00:17:48
Ah, no, pues a mí no 00:17:53
Entonces yo que he escrito mal 00:17:54
Mis matches de input 00:17:55
Expecting one of the following 00:17:58
Que he escrito mal 00:18:00
ah, vale, en mi caso era 00:18:02
en mi caso era porque no había puesto aquí el espacio 00:18:16
vale, entonces tenía 00:18:18
el ewer todo seguido 00:18:20
vale, pero ya sí que funciona así 00:18:21
el alias efectivamente 00:18:23
estaba mal puesto, menos mal que tengo un secretario 00:18:26
muy cualificado 00:18:28
¿subir es ir para allá? 00:18:35
¿hasta dónde? 00:18:36
arriba es el main 00:18:38
es un poquito rara 00:18:39
la sintaxis esta 00:18:46
en SQL 00:18:48
tú piensas en SQL 00:18:50
pero 00:18:53
navegando por tablas 00:18:54
y propiedades, perdón, navegando por 00:18:56
clases y propiedades de campos 00:18:58
propiedades de clases en lugar de por tablas 00:19:00
y campos, y ya está 00:19:02
y luego el resto de la sintaxis 00:19:04
para los join, para todo es igual 00:19:06
lo único es 00:19:08
esto, que jpql 00:19:10
¿por qué hql no? 00:19:12
por eso siempre me lío, pero JPQL 00:19:13
te obliga a poner 00:19:15
un alias a la tabla 00:19:18
en la que estás accediendo, en este caso la clase 00:19:19
y luego ya con el alias 00:19:22
ya aquí recoges de ella lo que quieras 00:19:24
vale 00:19:26
vale, pues esto en cuanto a JPQL 00:19:28
bueno, vistazo muy por encima 00:19:34
de JPA, pero más o menos 00:19:37
la idea la tenemos de que va 00:19:39
perdón 00:19:41
¿cómo? 00:19:43
¿Y si me lo está haciendo? Espérate. Sí, están aquí. Le he puesto en tu stream. Vale. Bueno, pues entonces, esto de JPA está muy bien, pero realmente lo hemos puesto en práctica en una estructura muy chapucera, ¿no? Con un main. 00:19:45
Primer paso, vamos a darle 00:20:13
Otro diseño 00:20:15
Con DAOs y servicios 00:20:18
¿Vale? 00:20:20
Eso nos permite ya entrar un poquito con 00:20:21
Las transacciones 00:20:23
Vale, pues vamos a darle otro diseño 00:20:26
Entonces este main no nos molesta 00:20:29
Se queda aquí como mi main de pruebas 00:20:33
No lo vamos a borrar 00:20:37
Tengo las entidades 00:20:38
¿Vale? ¿Qué es lo siguiente que hacemos cuando hacemos este patrón? 00:20:40
Pues los DAOs 00:20:43
Que el XML se ponga mal 00:20:44
Como el Pong 00:20:56
El del Persistent 00:20:56
Y a mí es que ese no se me ha puesto mal nunca 00:20:57
No sé por qué se os pone mal 00:20:59
Y sí, ¿no? 00:21:02
Es que si a mí se pusiera rojo 00:21:05
Vamos, removería cielo y tierra hasta que se quita el rojo 00:21:07
Pero es que nunca me ha pasado 00:21:09
Entonces no tengo ni idea 00:21:11
No sé deciros 00:21:12
Es decir, os da un error 00:21:13
Por 00:21:20
Si ponéis una S se quita 00:21:20
aquí 00:21:23
y si ponéis una S y quitáis este atributo 00:21:25
¿lo habéis probado? 00:21:28
porque el error se quitaría 00:21:31
y puede que os funcionara 00:21:32
pero vamos, eso habrá que averiguarlo 00:21:36
porque es un rollo 00:21:41
que eso esté así 00:21:42
claro, pero cuando tú pones aquí una S 00:21:43
lo que os está diciendo, por lo que he visto 00:21:45
es que el esquema Location 00:21:48
se ha quitado y no da error 00:21:49
es que eso lo intuía 00:21:52
bueno, pues 00:21:53
a ver, mientras funcione 00:21:55
lo dejamos así 00:21:57
claro 00:21:58
vale 00:22:01
vamos a ver, entonces 00:22:03
vamos al DAO 00:22:05
y ahora sí que 00:22:09
venga, vamos a jugar 00:22:11
¿vale? 00:22:13
porque os gusta jugar 00:22:15
bueno, ¿lo vas a hacer un cajón? 00:22:16
no, no lo voy a hacer un cajón 00:22:19
vamos a jugar con el cerebro 00:22:21
vamos a jugar moviendo las neuronas 00:22:23
que nos encantan, entonces 00:22:25
vamos a pensar, imaginaos que tenemos que hacer 00:22:27
un CRUD básico 00:22:30
vamos a reactivarlas 00:22:32
que si no luego nos llega muy rápido el deterioro 00:22:35
cognitivo 00:22:38
vamos a hacer, imaginaos que lo que 00:22:38
tenemos que hacer con departamento y empleado es un CRUD 00:22:42
básico, create 00:22:44
departamento, delete departamento 00:22:46
create empleado, delete 00:22:48
empleado, pues 00:22:50
¿para qué vamos a duplicar? 00:22:51
empleado DAO, departamento DAO 00:22:53
vamos a hacernos un DAO genérico 00:22:56
con el tipo genérico 00:22:58
vale 00:22:59
y así 00:23:01
pues 00:23:03
refrescamos ciertas ideas 00:23:05
y nos abrimos a ciertos 00:23:08
diseños, vamos a hacernos un 00:23:10
DAO 00:23:12
general, genérico 00:23:14
para todos 00:23:16
este que me valga para todos 00:23:20
interfaz, perdón 00:23:25
Que estoy en las interfaces 00:23:28
Este es el interfaz, todavía no es la implementación 00:23:29
Vale, pues a ver 00:23:34
¿Qué es lo que quiero hacer? 00:23:36
Yo quiero hacer un create 00:23:37
Lo que sea 00:23:39
Departamento empleado, un create 00:23:41
¿Y aquí qué le pasaré? 00:23:43
Departamento o empleado, no sé lo que le pasaré 00:23:46
Con lo cual le paso el tipo genérico 00:23:48
¿Vale? 00:23:50
Objeto, object, como lo queramos llamar 00:23:55
¿Y ahora qué ocurre? 00:23:56
Que mi clase la he convertido 00:24:02
A mi interfaz automáticamente 00:24:04
La he convertido en genérica 00:24:06
¿Vale? 00:24:09
¿Qué me dice esto? 00:24:13
Perdón 00:24:21
Estoy poniendo esto donde no es 00:24:21
Vale 00:24:23
El nombrecito que he elegido 00:24:25
Creo que está muy mal 00:24:30
Entidad, lo que sea, objeto 00:24:32
No, pero no es por eso 00:24:35
¿Por qué me...? 00:24:37
¿Qué llaves? 00:24:38
¿Pero dónde he puesto un punto y coma? 00:24:41
¡Ah! 00:24:43
¡Ah, que sí, que sí, jolines! 00:24:45
Vale, vale, vale 00:24:47
Puedo poner object porque la mayúscula no le molesta 00:24:49
O sea, no 00:24:52
Podría poner object, vale, vale 00:24:52
Vale 00:24:55
Queremos crear lo que sea 00:24:56
¿Qué más queremos? 00:24:59
Queremos recuperar 00:25:01
Por clave primaria 00:25:02
Pero aquí la hemos liado 00:25:05
La clave primaria coincide en este caso 00:25:07
Que se entera para ambas, tanto departamento como id 00:25:09
Pero podría no serlo 00:25:12
Entonces, este es un nuevo tipo genérico 00:25:13
con lo cual este es doblemente 00:25:15
genérico 00:25:21
no, no, no, cómo te vas a perder 00:25:22
cuál es el CRUD básico 00:25:27
insertar, recuperar, eliminar y actualizar 00:25:30
pues eliminar 00:25:33
estoy poniendo void todo el rato 00:25:35
siempre es más bonito un boolean 00:25:36
o algo que te permita validar 00:25:38
si está bien o el número 00:25:41
de registros creados, en este caso uno 00:25:43
pero bueno, estoy poniendo un void 00:25:45
por comodidad 00:25:46
vale, aquí sería 00:25:47
REMUD 00:25:49
que, pues el objeto 00:25:51
y ahora UDATE 00:25:52
UDATE 00:25:57
vale, pues este es el 00:26:01
CRUD básico, y es que 00:26:09
va a ser el mismo para departamento, para 00:26:11
empleado, para Pepito Pérez 00:26:13
para cualquiera, va a ser el mismo 00:26:15
entonces hagamos lo genérico 00:26:17
y ya está, genérico depende de dos 00:26:19
cosas, de la clave que 00:26:21
necesitamos para el GET 00:26:23
y del propio tipo de dato 00:26:25
Vale, pues 00:26:27
Ahora 00:26:42
Vamos a hacer la implementación de esto 00:26:44
Normalmente sí 00:26:46
Normalmente sí 00:27:05
Vale, pues esta, yo que sé 00:27:08
Implementación da 00:27:17
Y esta que implementa 00:27:18
Implements 00:27:28
Que implementa, pues 00:27:30
esta otra, generic 00:27:31
dao, vale 00:27:34
generic dao de 00:27:36
t, k 00:27:40
vale 00:27:42
t, ah sí 00:27:44
k, me he confundido de clave 00:27:46
vale 00:27:48
dao 00:27:49
t, v, y ahora 00:27:54
vale, entonces 00:27:57
tenemos que implementar estos métodos 00:28:02
vale 00:28:04
entonces, estos 00:28:06
métodos 00:28:08
siguen dependiendo 00:28:09
yo haré el persist de este objeto 00:28:12
haré lo que sea 00:28:14
esta clase sigue dependiendo de t y v 00:28:15
con lo cual esto sigue siendo 00:28:18
genérico así 00:28:20
uy jolín con la k 00:28:21
esa vez 00:28:26
vale 00:28:27
a ver los paquetes no van unos dentro de otros 00:28:52
la carpeta si 00:28:55
como he puesto un punto 00:28:57
la carpeta físicamente estará ubicada 00:28:58
pero los paquetes están siempre 00:29:01
desde la raíz 00:29:03
vale, pues entonces, aquí 00:29:05
crear, pues aquí voy a 00:29:17
copiar todo esto de aquí 00:29:25
a ver 00:29:27
es que esto no es una conexión 00:29:42
en realidad, se puede 00:29:45
en una aplicación pequeña, controlada 00:29:46
tú puedes hacer un entity manager que está 00:29:49
ahí vivo todo el rato, pero es que 00:29:51
esto no es solo una conexión 00:29:53
o sea, esto es todo un contexto con objetos 00:29:54
manejados, marcados 00:29:57
entonces si tú haces uno único 00:29:58
en una aplicación grande puede haber 00:30:00
muchos efectos secundarios 00:30:03
de mezcla de objetos 00:30:04
de que unos objetos tengan efectos 00:30:06
no deseados de otros 00:30:09
entonces no es lo recomendable 00:30:11
lo recomendable es que en el contexto 00:30:13
en el que tú vas a hacer algo, ahí te hagas tu contexto 00:30:14
de presidencia y ya está, pero bueno 00:30:16
también depende, depende de la situación 00:30:18
pero 00:30:20
lo que la respuesta 00:30:21
de fondo sería, es que esto no es solo una conexión 00:30:25
esto es una conexión más 00:30:27
un montón de información, de objetos, de cosas 00:30:29
entonces hacerla grande y que 00:30:31
entre ahí todo, puede ser peligroso 00:30:33
tan pequeña como para el método 00:30:35
de DAO, pues a lo mejor no es necesario 00:30:37
a nivel de servicio, vale 00:30:38
pues quizá un poco más 00:30:41
se puede jugar con eso también 00:30:42
dependiendo de la aplicación 00:30:45
entonces, aquí 00:30:46
vale 00:30:48
entonces, el create 00:31:12
sería esto, ya está 00:31:13
el recuperar 00:31:16
este ya no es tan sencillo 00:31:18
el recuperar 00:31:21
este tendríamos que hacer 00:31:23
pues esto mismo de aquí 00:31:24
bueno, a ver, perdonadme, la transacción no la he puesto aquí 00:31:25
que transacción 00:31:39
siempre me olvido de esta 00:31:43
entonces 00:31:44
si podríamos haberle 00:31:56
inyectado por constructor este 00:32:00
y haberlo pasado 00:32:02
a nivel de servicio 00:32:04
del entity manager que fuera uno por servicio 00:32:06
y no uno por método 00:32:08
atómico, pero bueno, son cosas que se pueden 00:32:10
son cosas que se pueden ir 00:32:12
diferentes posibilidades 00:32:14
vale, a ver, entonces este 00:32:16
tiene ahora ya, aquí no sería necesaria una 00:32:18
transacción, aquí no es necesaria 00:32:20
aunque bueno, la podamos poner 00:32:22
porque esto es recuperar, entonces aquí 00:32:24
uno haría el find 00:32:26
y como es el find 00:32:27
para recuperar por clave, que me devolvería 00:32:29
el objeto, este de aquí, verdad 00:32:32
t object 00:32:34
igual a n.find 00:32:37
y aquí yo devolvería el object 00:32:40
pero aquí tengo un problema 00:32:43
y es que 00:32:47
no sé la clase 00:32:49
ojalá 00:32:52
ojalá me dejaran poner esto 00:32:54
pero esto no lo puedo poner 00:32:56
esto no me dejan ponerlo 00:32:58
entonces 00:33:00
se la tengo que pasar 00:33:02
por parámetro 00:33:05
al dado, este de aquí 00:33:07
a ver, ¿qué es? cuando nosotros hablamos 00:33:08
en general, por si 00:33:11
ay Dios mío, tantos 00:33:13
papeles 00:33:15
aquí, pero esto no salió 00:33:16
vale, a ver 00:33:19
cuando nosotros, ¿qué es esto del punto 00:33:21
class? vamos a recordarlo 00:33:23
o verlo por si en ningún momento ha salido 00:33:25
ni lo sabemos, a veces hablamos 00:33:27
alegremente, pues eso 00:33:29
y hacemos, empleado.class 00:33:30
¿Por qué? Porque nos lo han pedido, porque lo necesita algún método. Muchas veces, por ejemplo, este lo necesitaba y hay otros métodos que necesitan que le pasemos esto. 00:33:35
¿Esto realmente qué es? Esto realmente es un objeto. Eso es empleado.class o departamento.class o alumno.class. Esto es un objeto, como todos los objetos de Java, un objeto en memoria, un objeto instanciado y creado en memoria. 00:33:48
por eso lo pasamos por parámetros 00:34:05
porque eso es lo que se pasa por parámetros 00:34:07
objetos de memoria, datos de memoria 00:34:09
es un objeto, y la pregunta sería 00:34:11
¿y qué tiene dentro ese objeto? 00:34:13
¿qué tiene el objeto empleado.class? 00:34:15
tiene información 00:34:18
sobre de qué va 00:34:19
esta clase, como su nombre 00:34:21
número de propiedades que tiene, cosas así 00:34:23
muy random 00:34:25
eso es lo que tiene ese objeto 00:34:26
información sobre esa clase 00:34:29
entonces, hay métodos 00:34:31
que la necesitan. El find 00:34:33
la necesita para 00:34:35
saber de qué va esta clase 00:34:37
para alojar en ella 00:34:39
los resultados del select. 00:34:40
Y muchos otros métodos la necesitan. 00:34:43
Vale, pues 00:34:47
entonces, siguiente pregunta. Si esto es un 00:34:47
objeto, todos los 00:34:49
objetos son de una clase, 00:34:51
¿a qué clase 00:34:54
pertenece este objeto? 00:34:55
Pues a... 00:34:57
¡Qué graciositos! Os quería yo ver aquí 00:35:03
con la pizarra 00:35:06
vale 00:35:08
pues a este 00:35:10
¿qué es esto? 00:35:15
calma, relájate 00:35:23
esto es una clase 00:35:24
esto es una clase 00:35:27
y los objetos 00:35:29
que se instancian 00:35:32
de esta clase, ¿cuáles son? 00:35:34
estos, este es el objeto 00:35:35
que se instancia de esta clase 00:35:37
luego yo puedo hacer 00:35:40
clase, imaginaos que tengo alumno 00:35:41
c igual a 00:35:43
alumno.class 00:35:48
¿vale? 00:35:51
esta asignación es perfectamente válida 00:35:53
el objeto alumno.class 00:35:55
que es el objeto que tiene la información 00:35:57
de la clase alumno 00:35:59
se lo asigno a un objeto 00:36:00
de esta clase 00:36:02
porque esto ya es una clase, esto no es un objeto 00:36:04
¿vale? clase alumno 00:36:07
vale, pues aquí podemos 00:36:09
aprovecharnos de esto porque, oye, yo necesito 00:36:11
un objeto de qué clase 00:36:13
de la clase, clase T. 00:36:15
Esto sí lo puedo poner. 00:36:18
Esto sí me deja jambo. 00:36:20
Pues voy a pasárselo, 00:36:22
voy a inyectárselo por constructor 00:36:24
y luego se lo doy aquí. 00:36:25
Es decir, ¿cómo hago 00:36:28
este arreglo de aquí? 00:36:29
Ese problemón de ahí. 00:36:31
Pues, dime. 00:36:33
¿Y alumno.class se puede guardar 00:36:34
en vez de class de alumno? 00:36:36
¿Se puede guardar directamente en alumno? 00:36:38
No, no, no, porque no es un objeto 00:36:41
alumno. En alumno se lo puedes 00:36:42
guardar objetos alumnos y los objetos alumnos pertenecen a la clase alumno y no pertenecen 00:36:44
a la clase alumno. Eso es otro tipo de objetos, son otro tipo de objetos. Una cosa es el objeto 00:36:49
que guarda información sobre la clase y otra cosa es el objeto que guarda un ejemplo concreto 00:36:55
de esa clase, un alumno en concreto. Vale, pues aquí lo que queremos es pasarle a este, 00:37:01
le queremos pasar 00:37:07
esto de aquí 00:37:11
le queremos pasar este objeto 00:37:13
yo que sé, tipo, como lo queráis llamar 00:37:18
esto le queremos 00:37:24
pasar 00:37:26
vamos a pasárselo por constructor 00:37:26
cuando lo llamemos 00:37:29
cuando instanciemos esto 00:37:30
vale, pues a ver 00:37:34
aquí haremos nuestro constructor 00:37:36
de esta de aquí 00:37:39
Y el constructor 00:37:41
No tenía los genéricos, ¿no? 00:37:55
Creo que ahora se los quito 00:37:57
Le pasamos aquí un class de t 00:37:58
Ahora se los quito 00:38:01
Dis 00:38:03
Punto tipo 00:38:10
Igual a tipo 00:38:12
Vale 00:38:14
Y esto de aquí me sobra 00:38:16
¿Verdad? 00:38:19
¡Hala! Ya está 00:38:22
Entonces cuando yo instancia este 00:38:23
Lo instanciaré como departamento íntegre 00:38:25
o empleado íntegre, ¿vale? 00:38:28
Así lo instanciaré. 00:38:31
Y lo instanciaré pasándole al constructor departamento.class 00:38:32
o empleado.class. 00:38:35
Y ya está. 00:38:37
Ahora lo instanciamos. 00:38:38
Con lo cual ya he solucionado el problema de abajo. 00:38:39
Ahora ya aquí le pongo tipo. 00:38:42
Y tan a gusto. 00:38:47
Qué guay. 00:38:49
¿Vale? 00:38:52
Vale, ya tenemos el punto class que sea, 00:38:55
que lo hemos cogido de aquí, 00:38:57
porque se lo vamos a pasar a este cuando lo inyectemos. 00:38:59
aquí quizá, efectivamente como decías tú 00:39:02
también habría sido casi mejor 00:39:05
pasarle 00:39:07
el manager 00:39:08
pasarle un manager 00:39:10
y tirar de él y no estarlo aquí creando 00:39:13
todo el rato, y que luego el que lo cree 00:39:15
sea el servicio, el método de servicio 00:39:17
que lo cree, que no sea uno global de aplicación 00:39:19
sino uno por caso de uso 00:39:21
eso quizá es menos 00:39:22
pesado que 00:39:25
y no solo eso 00:39:25
sino que tendríamos el problema de que aquí 00:39:28
como cerramos la sesión cada vez 00:39:30
cuando yo haga un get 00:39:33
si lo tengo como lazy 00:39:34
aquí habré cerrado la sesión 00:39:37
entonces después de hacer el get 00:39:39
como quiera desde el servicio 00:39:41
sacar los que cuelgan, no los voy a poder sacar 00:39:42
entonces 00:39:45
esto de, estoy pensando yo 00:39:46
que poner aquí el entity manager aquí 00:39:49
nos puede 00:39:50
complicar la vida 00:39:53
si queremos tirar 00:39:54
de los objetos que cuelgan 00:39:56
de este 00:39:58
teniéndolo como lazy 00:40:00
entonces vamos a hacer una cosa más 00:40:02
bonita que es pasárselo por aquí 00:40:04
entonces vamos a pasarle el entity manager 00:40:06
por aquí, por constructor 00:40:08
y al pasárselo por 00:40:10
constructor todo esto se va 00:40:16
a la basura 00:40:18
esto perdón se va a la basura 00:40:19
y el close también 00:40:22
porque si 00:40:23
y aquí tengo que poner lógicamente 00:40:24
la propiedad 00:40:29
y aquí 00:40:36
Dis.en 00:40:37
Igual a en 00:40:41
Así mejor 00:40:42
Se lo paso por constructor 00:40:43
Y ya me quito todo esto 00:40:45
De aquí 00:40:48
Vale 00:40:53
Ya tenemos el get 00:40:54
El remove 00:40:56
Pues será 00:40:57
En punto remove 00:41:00
Del objeto 00:41:03
Y ya está 00:41:07
No estoy validando nada 00:41:11
El en punto remove 00:41:12
me devuelve 00:41:13
un valor 00:41:15
¿verdad que sí? 00:41:17
el remove, ah no, también está hecho 00:41:19
como void aquí, pues entonces 00:41:21
malamente puedo usarlo 00:41:23
vale 00:41:26
te avisará por excepción 00:41:26
si hay algún problema 00:41:28
y ahora 00:41:30
el update como tal es raro 00:41:31
porque en realidad update como tal no existe 00:41:34
tú cambias el objeto, haces con él lo que quieras 00:41:37
y cuando según vayas 00:41:39
haciendo los commit, ya se actualiza 00:41:41
entonces el update como tal es raro 00:41:43
pero se suele usar el método merge 00:41:45
merge 00:41:47
como el equivalente a actualizar 00:41:47
porque con ese obligas 00:41:51
al objeto a que se actualice también 00:41:53
entonces, aquí 00:41:55
podríamos hacer en punto 00:41:58
merge object 00:42:01
pero el 00:42:03
update del 00:42:05
dao es raro 00:42:07
Sí, es que siempre se me olvida 00:42:07
Y aquí también 00:42:13
Y ahí también 00:42:13
Ya estamos con esto 00:42:14
Jolín, comid 00:42:24
Leches 00:42:36
Me estáis poniendo muy nerviosa 00:42:37
Da igual 00:42:44
Me ponéis nerviosa 00:42:46
Con vuestra sola presencia 00:42:47
Da lo mismo 00:42:49
Por favor 00:42:52
¿No sabéis desaparecer así automáticamente? 00:43:00
A veces te vendría muy bien, ¿verdad? 00:43:07
No, a veces te vendría bien a ti 00:43:12
en situaciones en las cuales no te apetece estar 00:43:14
En la mayoría, el 90% 00:43:16
Vale, pues entonces 00:43:19
ahora 00:43:22
yo sintiéndolo muchísimo 00:43:24
muchísimo 00:43:26
no, no, no, está estupendo 00:43:27
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:
11
Fecha:
19 de enero de 2026 - 12:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 31″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
189.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid