Saltar navegación

20251120 EjerRepaso_Biblioteca - 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 21 de noviembre de 2025 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Yo voy a usar para corregir una plantilla de ejecución. 00:00:00
Entonces, lo voy a dejar claro en el examen. 00:00:07
Pero las firmas de las cosas que tenéis que hacer, 00:00:10
tenéis que respetarlas tal cual. 00:00:12
Para que yo pueda directamente ejecutar vuestro código 00:00:14
sin tener que adaptar a cada examen, 00:00:17
ver porque si no, me vuelvo loca. 00:00:20
Eso para empezar. 00:00:22
Pero voy a dejar claro el examen. 00:00:23
Todas las firmas que yo os diga de métodos y de cosas, 00:00:24
respetarlas tal cual. 00:00:27
Eso por un lado. 00:00:29
vale, si las cosas no funcionan 00:00:30
yo lo ejecuto y no funciona 00:00:32
a ver, ahí ya 00:00:33
la cosa apunta fea, pero eso significa 00:00:36
apunta fea 00:00:38
sí, o sea 00:00:40
apunta fea, pero significa que no miro 00:00:41
nada más, no 00:00:44
miro algo más, ¿por qué? porque podría 00:00:45
darse el caso de que no funcionara 00:00:48
por algo que se ha escapado de vuestro 00:00:49
control, pues porque efectivamente 00:00:52
yo lo estoy ejecutando mal 00:00:53
no, puede 00:00:55
estarlo yo ejecutando mal, o puedo yo 00:00:57
darme cuenta de que en mi portátil hay algo 00:00:59
que está colisionando con los ordenadores del aula. 00:01:02
Puedo darme cuenta ahí de mil cosas 00:01:04
que significan que no es un problema vuestro. 00:01:05
¿Y si no te das cuenta? 00:01:07
Hombre, normalmente 00:01:10
llego a saber 00:01:12
por qué no funciona. 00:01:13
Normalmente. A ver, es un trabajo gordo 00:01:15
porque ahí empiezo a ver un montón de letras rojas 00:01:17
y tengo que averiguar por qué no me funciona 00:01:19
para ver si es algo que dependía de vosotros o no. 00:01:21
Entonces, muchas veces concluyo 00:01:24
que es algo que no dependía de vosotros. 00:01:25
entonces si concluyo que es algo que no dependía de vosotros 00:01:28
si el código está bien, vale 00:01:30
pero, si yo entro en el código 00:01:32
y al margen 00:01:34
de que no funcione 00:01:36
porque algo, no 00:01:38
veo ahí cosas raras de programación 00:01:39
burradas de programación, veo cosas 00:01:43
eso también es suspenso 00:01:44
como yo vea 00:01:46
que programáis mal 00:01:48
Que no vas a hacer el ridículo 00:01:50
Venga, primer método que vamos a hacer 00:02:03
Dado un ID de un libro 00:02:09
Modificar su género 00:02:12
Y esto, vamos a hacerlo con DOM 00:02:14
Vale, pues entonces 00:02:15
Nos hacemos nuestra clase 00:02:17
de utilidades 00:02:18
antes que nada 00:02:21
por esto puntas algo 00:02:22
¿por qué? 00:02:25
que no puntúa con nada 00:02:28
ya, ya, ya 00:02:29
venga, pues ala, esta es nuestra clase 00:02:30
ala, pues nuestro método 00:02:38
el que luego invocará el controlador 00:02:51
con el fichero que ya ha recibido, lo que sea 00:02:56
nuestro método 00:02:58
que lo que hace es 00:03:00
dado una idea de un libro, modificar su género 00:03:01
de esto realmente es de lo que yo tengo 00:03:04
que evaluar según los contenidos de mi módulo 00:03:06
pues de hacer estas operativas 00:03:08
de modificación de cosas en ficheros 00:03:10
No, que estamos haciendo 00:03:12
estas utilidades en un método 00:03:18
y luego estas utilidades ya las llamará 00:03:19
quien sea en función de cómo es la aplicación 00:03:22
si la haces con un main de escritorio 00:03:24
pues el main, si lo haces en una 00:03:25
web, el controlador, ya quien sea 00:03:27
llamar a quien sea 00:03:29
vale, pues entonces 00:03:30
vamos a necesitar 00:03:33
modificar género 00:03:38
y aquí 00:03:40
jo, que sale todo siempre no binario 00:03:42
a ver, pero si 00:03:45
la o y la e están muy lejos, ¿por qué me sale siempre la e? 00:03:47
no lo sé 00:03:50
¿qué clases inclusivas? 00:03:50
pues yo que sé, va a ser eso 00:03:52
Pero hay manera de ponerla hoy 00:03:54
Vale, vamos a pasar el 00:03:55
Fichero 00:03:58
Lo de paz es por perderle un poco de respeto 00:03:59
El fichero 00:04:04
El nuevo género 00:04:07
El ID del género 00:04:09
A ver 00:04:10
El ID 00:04:11
Y el nuevo género 00:04:13
Y sin valor de retorno vamos mal 00:04:20
Venga, ¿qué queremos? 00:04:32
¿Un boy o un boolean? 00:04:35
Un boolean, he dicho por ahí 00:04:37
Se ha adelantado ella 00:04:39
Ya he dicho un boolean 00:04:41
Retún 00:04:43
Esto, ¿vale? 00:04:46
Retún 00:04:48
Ya lo cambiaremos al final 00:04:49
Vale, paz 00:04:55
Importar 00:04:57
¡Hala! Pues venga 00:04:59
¿Qué haríais aquí? 00:05:02
Nuestro fichero es este 00:05:06
¡No! 00:05:08
usas unos términos muy profesionales 00:05:11
no, desde luego 00:05:17
es que yo no sé 00:05:19
qué haces aquí 00:05:21
no, pero 00:05:22
te lo digo 00:05:27
con toda la buena voluntad del mundo 00:05:28
porque yo tengo una especial fobia 00:05:30
a la sensación de perder el tiempo 00:05:33
una cosa personal 00:05:34
y a lo mejor estás perdiendo mucho el tiempo 00:05:36
aumentar el link 00:05:39
Ah, bueno, vale, eso sí. 00:05:40
Tienes un título nuevo, eso sí. 00:05:42
Vale, pues ¿qué es lo primero que haríais 00:05:48
para modificar el género? 00:05:49
El objetivo de modificar el género es 00:05:52
llegar a este nodo 00:05:54
y este nodo cambiarlo. 00:05:57
Entonces, eso sería ser tan fácil 00:06:00
como crear otro nodo, 00:06:03
si digo por esto, ver los métodos que hay, 00:06:04
en el peor de los casos siempre puedo. 00:06:06
Si he llegado a este libro, 00:06:08
hacer un remove de este y hacerle un append 00:06:09
de este, que sería lo más fácil también, 00:06:11
pero tengo que llegar a este. 00:06:14
Entonces, para llegar a este, 00:06:16
pues como tengo 00:06:19
la suerte de que 00:06:20
no hay nodos libro que se llamen 00:06:22
también y dados aquí, me hago un getElementsByTagName 00:06:24
libro y ya 00:06:26
tengo todos los nodos libro. 00:06:28
Los recorro, me quedo con aquel 00:06:30
cuyo id, cuyo atributo 00:06:32
sea el que me han 00:06:34
dado y ya a ese nodo 00:06:36
le remuevo este hijo y le pego otro 00:06:38
o si hay algún método que me ofrezca 00:06:41
document, que me ofrezca la clase no 00:06:43
de element, para sustituir uno 00:06:44
por otro, pues sustituyo o para cambiar 00:06:46
el valor y ya está, ya hemos terminado 00:06:48
ese código, vale 00:06:50
bueno, tendré que leer lógicamente 00:06:52
primero 00:06:55
este fichero, lo vuelco 00:06:55
a document, me hago el 00:06:58
getElementsByTagName para sacarme 00:07:00
todos los nodos, lo recorro 00:07:02
hasta quedarme con el nodo cuyo atributo 00:07:04
es este y cuando ya me he quedado 00:07:06
remove child, append child 00:07:09
o si hay algún método que me lo facilite 00:07:10
cambiando el valor de este 00:07:12
pues lo hago y se acabó esa funcionalidad 00:07:14
¿vale? 00:07:17
pues venga 00:07:18
como lo que os falta 00:07:19
y nos falta a todos en general es 00:07:22
sobre todo a ti, es el que más te falta 00:07:24
puesto en orden de a quien le falta más 00:07:26
la facilidad para vencer la pereza 00:07:28
es a ti, el segundo 00:07:31
todavía no lo hemos puesto 00:07:32
Yo, o sea, de Juanjo diré 00:07:33
Que no es tan vago 00:07:37
Soy yo el vago 00:07:38
Bueno, él le da pereza 00:07:40
Hacer las cosas 00:07:43
A todos nos da pereza 00:07:44
Pero es que tenemos que examinarnos 00:07:48
Y para eso pues tenemos que ponernos a hacer algo 00:07:50
Para ponernos una nota, es que no hay tutía 00:07:51
De ahí mi conflicto interno 00:07:53
¿Hace falta todo esto para que aprendáis? 00:07:54
No, podéis aprender por vuestra cuenta perfectamente 00:07:56
Pero mientras no cambie el esquema 00:07:58
De funcionamiento de esta sociedad 00:08:01
Pues tendremos que seguir haciendo esto 00:08:02
Vale, pues venga 00:08:04
Vamos a intentarlo, 5 o 10 minutos 00:08:07
Para intentar hacerlo 00:08:09
Y así vencéis esa pereza 00:08:10
Que nos invade a todos 00:08:12
Daniel, yo creo que ya lo tienes hecho 00:08:14
¿Ya lo tienes hecho? 00:08:16
Ay, Daniel, estás de un serio 00:08:21
Últimamente que me estás 00:08:23
Preocupando 00:08:24
¿Qué habréis hecho aquí? 00:08:26
Bueno, pues 00:08:30
¿eh? ah, perdón 00:08:31
esto de aquí, vale, pues ¿qué habréis 00:08:34
hecho aquí? bueno, pues primero 00:08:36
llevar el fichero al document 00:08:38
esto habréis 00:08:39
copiado y pegado el método que tenemos ya en otro 00:08:41
proyecto, copiar y pegar el que 00:08:43
te carga de un fichero 00:08:46
a un document, pues nada, yo lo he copiado 00:08:47
y pegado del proyecto que teníamos ejemplo de clase 00:08:50
y ya está, ya tengo aquí 00:08:52
el document, ahora 00:08:54
me cojo todos los libros 00:08:55
mediante este método 00:08:57
Y ahora ya recorro libro por libro 00:09:00
Vale, aquí tengo cada libro 00:09:02
Para cada libro 00:09:04
Si su atributo id 00:09:06
Que se llama id 00:09:08
Es igual al que me han pasado como parámetro 00:09:10
Estoy en el libro 00:09:12
Al que quiero cambiar el género 00:09:13
¿Cómo saco el nodo género del libro? 00:09:16
Pues de nuevo con esto 00:09:18
Este me daría 00:09:19
Todos los hijos del libro que se llaman género 00:09:22
Solo tiene uno 00:09:24
Que se llama género 00:09:26
Por eso me quedo directamente con el ítem 0 00:09:27
me quedo con el ítem 0 y ahora 00:09:29
de este género, aquí 00:09:31
tendría que hacerle, pues 00:09:33
tengo que ver, ¿hay algún método que me permita 00:09:35
cambiar su contenido de texto? 00:09:37
Sí, igual que tenía el getTextContext 00:09:40
para darme 00:09:42
el texto que tenía, pues 00:09:43
rápidamente me he cogido un setTextContext 00:09:45
y así me ahorro 00:09:47
al género 00:09:48
borrarle el ítem o texto 00:09:50
y querrálo otra vez, pues ya está 00:09:53
ya lo tendríamos hecho con esto 00:09:55
a ver, me falta 00:09:57
volver a escribirlo 00:09:58
con lo cual tengo que hacer el 00:10:00
copiar aquí 00:10:02
copiar de aquí el 00:10:04
el de escribir, volver a guardar en el fichero 00:10:05
actualizar fichero 00:10:09
vale 00:10:12
pues copio y pego este 00:10:13
y ya está 00:10:15
y se acabó esa funcionalidad 00:10:16
copio y pego este, actualizar fichero 00:10:20
le voy a pasar 00:10:27
el, como no lo tengo 00:10:29
como variables estáticas 00:10:31
Se lo voy a pasar por aquí 00:10:32
Y aquí esto 00:10:34
Ah bueno, al fichero resultante 00:10:38
Se lo paso también como parámetro 00:10:43
Guárdame ese doc 00:10:46
En este 00:10:49
Entonces stream result 00:10:51
Fichero.toFile 00:10:55
Porque esta librería trabaja con file 00:10:57
No con par 00:10:59
El doc este 00:11:02
Es este doc 00:11:04
Ya está 00:11:05
Y ahora ya a este método 00:11:09
Actualizar fichero 00:11:11
Que tendrá que ser estático 00:11:12
Para poder llamarle desde el otro lado 00:11:15
A este método actualizar fichero 00:11:16
Lo llamo desde aquí 00:11:21
Pasándole doc 00:11:23
Y fichero 00:11:27
Y aquí return true 00:11:29
Entonces 00:11:33
Pues ya está 00:11:40
Siguiente 00:11:43
funcionalidad 00:11:44
que tenemos que hacer? 00:11:46
¿Cómo que por qué 00:11:51
no métodos de biblioteca? 00:11:52
A ver, ¿a mí qué me interesan? 00:11:58
Me interesan los nodos libro. 00:12:00
Pues hombre, este es el método clave 00:12:02
porque es el más cómodo. Este método 00:12:04
del XML 00:12:06
te saca una colección, 00:12:07
una lista de nodos, una colección 00:12:10
con todos los nodos 00:12:12
que se llamen así. 00:12:14
Y eso es lo que a mí me interesa 00:12:16
Los libros que se llaman así 00:12:18
El nodo biblioteca que los envuelve 00:12:19
Bueno, me interesa 00:12:21
¿Eh? 00:12:23
Pero es que no sé de qué idea es 00:12:31
Porque a lo mejor no están por orden 00:12:32
Claro, hay una idea de parámetro 00:12:34
Vale, pues ya está 00:12:37
Siguiente cosa 00:12:39
Ah, sí, no, lo he cambiado ya 00:12:41
Este, dices 00:12:46
Es que voy a dar true 00:12:46
Porque no tengo 00:12:51
aquí no hay ningún exception, ni hay ningún 00:12:52
nada 00:12:55
¿en qué punto podría salir como 00:12:55
falso? podría salir como falso 00:12:58
si no llega a encontrar estos, si no los encuentra 00:13:00
por ejemplo, entonces sí, podría incorporar aquí 00:13:03
un boolean 00:13:05
de encontrado 00:13:07
y ya está, y así 00:13:08
efectivamente si tengo muchos libros 00:13:17
añado en mi for 00:13:19
y mientras no he encontrado 00:13:21
y bueno, es verdad que queda un poco mejor 00:13:23
y así en cuanto, como los ideas se supone que son 00:13:25
únicos, en cuanto llegue al libro 00:13:29
con ese id, ya no sigue mirando más 00:13:31
porque sería una pérdida de tiempo 00:13:33
y ahora ya sí que 00:13:34
podría hacer aquí 00:13:37
si no he encontrado 00:13:38
retun false 00:13:40
efectivamente 00:13:47
me falta aquí 00:13:52
que he encontrado 00:13:54
a true 00:13:56
vale, entonces este método yo ahora aquí 00:13:57
claro, aquí lo ideal es que yo hiciera 00:14:00
una buena documentación 00:14:03
ahora, que especificara 00:14:04
lo que es fichero, lo que es id, lo que es 00:14:06
nuevo género, devuelve true 00:14:08
si ha pasado esto, false si no ha 00:14:10
encontrado el nombre, ahora ya aquí 00:14:12
pues bueno, lo tendría que documentar bien 00:14:14
para generar un javado, pero bueno 00:14:16
vale 00:14:18
vale, lo que hemos hecho está 00:14:19
claro, entonces al final 00:14:22
tirando de los métodos básicos 00:14:26
este para sacar los nodos 00:14:27
que a mi me interesan, recorrer 00:14:30
y luego ya pues ir 00:14:32
sacando el contenido 00:14:34
que tiene con GetTechContext 00:14:36
pues lo puedo hacer 00:14:38
todo de forma sencilla 00:14:42
con esta librería y no necesitamos nada más 00:14:43
lo siguiente 00:14:46
vale 00:14:48
insertar libros garantizando su unicidad 00:14:58
de ides y hacerlo con 00:15:01
Jaxby, vale 00:15:03
pues entonces vamos a hacer las clases rápidamente 00:15:04
y estas clases 00:15:07
son 00:15:15
Son 00:15:16
Libro y biblioteca 00:15:21
Ya está, dos clases 00:15:24
Tiene este modelo 00:15:25
Uy, ¿qué he hecho yo aquí? 00:15:27
Yo quería el paquete y he hecho una clase 00:15:30
Me he equivocado 00:15:31
Yo quería un paquete 00:15:34
Entonces 00:15:38
Hacemos libro primero 00:15:43
Si este modelo 00:15:44
Si este modelo 00:15:53
Me sirviera solo 00:15:56
Para recoger los 00:15:57
objetos del fichero 00:15:59
y consultarlos 00:16:01
solo para hacer consultas 00:16:02
pues podría hacerlo en lugar de con una clase 00:16:05
y la verdad es que sería mucho más cómodo 00:16:07
podríamos hacerlo así, ¿verdad? 00:16:10
¿eh? 00:16:15
esto es lo que mencionamos el otro día 00:16:17
entonces yo aquí pondría 00:16:19
las propiedades 00:16:20
y de lo que fuera 00:16:22
y ya está 00:16:24
y aquí ya directamente tengo como si tuviera 00:16:26
de la clase con propiedades 00:16:29
privadas y posibilidad de acceder. 00:16:31
Pero claro, de hecho, se llama récord, 00:16:33
bueno, digo yo que se llama récord, 00:16:35
intuido que se llama récord, porque esto 00:16:37
te vale solo para registrar 00:16:38
lo que hay fuera, 00:16:41
para quedarte con un registro, pero luego no vas 00:16:42
a modificarlo, ni vas a hacer nada. 00:16:44
Entonces tú luego consultas aquí para ver lo que 00:16:47
hay. Es como una especie de grabación 00:16:49
de lo que hay fuera, es una grabación. 00:16:50
Pero no es 00:16:53
el caso. Nosotros aquí tenemos que hacer 00:16:54
las clases enteritas, porque 00:16:56
bueno, aparte me estoy pasando de lista 00:16:59
aquí yo no puedo poner anotaciones 00:17:01
de XB, claro 00:17:03
yo quiero esto para poner anotaciones 00:17:05
de XB en las propiedades y cambiar de nombre 00:17:07
aquí no sé si podría integrar 00:17:09
anotaciones de XB 00:17:11
no lo sé, es que no he probado 00:17:12
a hacerlo en la vida 00:17:15
vale, no lo sé 00:17:16
si dejaría anotar con XM 00:17:18
y el problema es aquí 00:17:21
ponerlas aquí 00:17:23
no lo sé, se podría probar pero bueno 00:17:25
probadlo por curiosidad si queréis 00:17:27
pues igual las de JaxB también, no lo sé 00:17:29
pero como en nuestro caso 00:17:34
ni siquiera podemos usar récord porque queremos 00:17:36
hacer modificaciones 00:17:38
insertar libros nuevos y todo eso 00:17:40
pues no vamos a hacer 00:17:42
un récord 00:17:44
sino que vamos a hacer una clase 00:17:45
una clase libro 00:17:48
y la clase libro 00:17:55
ahora ya sí que tiene 00:17:57
tiene cinco cosas 00:17:59
y de título 00:18:02
autor, año y género 00:18:03
Cinco cositas tiene, el ID como string, claro, ID, título, autor, género, el año, 00:18:05
y ahora aquí sí que sí, los getter y los setters, de todo, vale. 00:18:31
Ahora, las anotaciones, las anotaciones para indicar qué es cada cosa, 00:18:46
Bueno, vamos a hacer primero biblioteca, que es el raíz. 00:18:52
Las anotaciones, las puedo poner tanto en la propiedad como en 00:18:55
el get. 00:19:01
Lo que pasa es que si las ponemos en la propiedad, 00:19:02
había que poner aquí lo de accessor type fill para que 00:19:04
JacksBee sepa qué tiene que hacer a través de la propiedad. 00:19:09
Yo lo pongo en el get y ya está. 00:19:12
Entonces, bueno, vamos a poner las que afecten aquí al libro. 00:19:15
El libro, por lo menos una de orden nos afecta. 00:19:19
si queremos cambiar el nombre de alguna la cambiamos 00:19:22
pero no, id hay que ponerlo 00:19:26
atributo, veis como estáis más 00:19:28
espabilados de lo que parece 00:19:30
pero claro, antes de poner yo una propiedad 00:19:31
¿qué me falta? pues la dependencia 00:19:34
de JaxB 00:19:36
la dependencia la copio y pego 00:19:36
de un proyecto que ya nos haya funcionado 00:19:40
y que 00:19:42
esté estable 00:19:43
pues JaxB 00:19:45
Aquí 00:19:51
Ala, esa será 00:19:53
Diego se arrepiente de haberse quedado 00:20:01
Porque está muy aburrido 00:20:04
Vale 00:20:05
Pues mira, no te puedo ayudar de eso 00:20:11
Ejercicio, repaso 00:20:14
Estamos aquí 00:20:18
Ala 00:20:19
Ponemos aquí esta cosa 00:20:21
Ahora ya si que puedo poner anotaciones 00:20:24
Sin que se queje 00:20:27
Id es un atributo 00:20:30
xml 00:20:33
Atribute 00:20:35
La he escrito bien 00:20:38
O entonces porque no me deja importarla 00:20:41
Así funciona 00:20:48
A ver que he escrito mal aquí 00:20:49
Pero no pasa nada 00:21:00
Porque como tenemos nuestros proyectos 00:21:02
La doble T es que 00:21:03
No, no, no es así 00:21:08
No, es que a mí con una doble 00:21:08
A ver, pero como tenemos nuestros proyectos 00:21:11
Para mirarlo, pues no pasa nada 00:21:14
No hay ningún tipo de pavor 00:21:16
Lo miramos 00:21:17
Mira, tenemos hasta uno que era un libro y todo 00:21:19
Pero espérate 00:21:21
Espérate que no sé lo que estoy abriendo 00:21:26
Vale, a ver 00:21:31
¿Pero qué hago yo aquí? 00:21:37
Ah, es que estoy donde no es 00:21:45
He hecho el paquete donde no es 00:21:47
Pero bueno, lo podría... vale 00:21:50
Lo has hecho en otro proyecto 00:21:52
Vale, pero da igual 00:21:56
Entonces, ahora, esta que estaba aquí, que sobra, la copiamos aquí. 00:22:00
Y esto se quita. 00:22:12
Este paquete entero se quita porque esto aquí no pintaba nada. 00:22:15
Este paquete entero se quita. 00:22:20
Y esto afuera. 00:22:28
Ahora. 00:22:31
Vale, libro. 00:22:39
Ahora. Vale. 00:22:42
Estaba en la clase que no era. 00:22:44
Estaba en DOM. 00:22:46
Ahí. Ya está. 00:22:48
Si alguna cambiara de nombre 00:22:50
lo pondríamos, pero no es el caso. 00:22:52
El orden lo voy a tener que poner 00:22:54
porque no está por orden alfabético. 00:22:56
Entonces hay que poner un XML 00:22:58
type. Ahí. 00:22:59
Igual. 00:23:13
Y esto era entre paréntesis y así. 00:23:13
Primero queremos el ID. 00:23:16
Luego queremos 00:23:18
el título. 00:23:19
Bueno, el id no lo queremos porque es un atributo 00:23:21
Perdón 00:23:26
Queremos primero el título 00:23:27
Luego queremos el autor 00:23:29
Luego queremos el año 00:23:31
Y luego queremos el género 00:23:37
Para que no ordene de manera alfabética 00:23:40
Exacto 00:23:42
Para que no ordene de manera alfabética 00:23:43
Y el libro no hay más cosas que poner 00:23:46
Y ahora nos falta la clase 00:23:49
Biblioteca 00:23:54
Un dopelota 00:23:57
Lleva una lista de libros 00:23:58
Depende de cómo esté el XML 00:24:02
Perdón, biblioteca 00:24:10
Vale, depende 00:24:13
¿Este tiene un envolvente? 00:24:18
No, no tiene un envolvente 00:24:19
Entonces no le hago un grupper 00:24:21
¿Veis? Esto no está metido dentro de libros 00:24:22
Están ahí sueltos 00:24:24
Entonces no hay un grupper aquí 00:24:25
Entonces 00:24:27
Un grupper habría 00:24:28
Si esto 00:24:32
Tú tienes aquí un nodo libros 00:24:33
Ah, vale 00:24:36
Que se cierra abajo 00:24:37
Entonces sí, pondríamos un grupper 00:24:40
Pero 00:24:44
Lo hemos puesto sin grupper 00:24:46
A propósito para 00:24:47
Están todos ahí seguidos a mogollón 00:24:50
Vale, pues entonces 00:24:54
La propiedad está claro 00:24:57
Es igualmente 00:24:59
Es que eso es un nodo raíz 00:25:00
No es un envolvente 00:25:04
Es el XML root element 00:25:05
Se lo podemos dejar puesto ya 00:25:07
Y lo quitamos de encima 00:25:09
Este es que ya es el raíz 00:25:10
Luego tiene ya su función 00:25:16
Y ahora 00:25:17
Private 00:25:22
Este 00:25:24
Una lista de libros 00:25:25
Ahora 00:25:28
Venga 00:25:30
¿A este cómo lo llamo? 00:25:35
Lo llamo libro 00:25:49
Porque el nombre que aparezca aquí 00:25:50
Es el nombre que aparece ahí 00:25:54
Entonces lo llamo libro 00:25:56
Para que aparezca libro 00:25:59
Es que no me gusta 00:26:00
Y lo quiero llamar libro 00:26:01
Es porque me apaño mejor en la parte de Java 00:26:03
Pues me tendría que hacer un xml element 00:26:05
¿Vale? 00:26:07
Poner aquí arriba xml element name libro 00:26:09
Para asegurarme de que este nodo 00:26:12
Cuando aparezca se va a llamar libro, no se va a llamar libros como aparezca aquí. 00:26:14
Pero si yo lo llamo así tal cual, este nodo cada vez que aparezca se llamará libro, 00:26:19
que es justo como aparece aquí, cada vez que aparece se llama libro. 00:26:24
Y este ya no tiene nada más que su get y su set. 00:26:28
Pues esto ya se ha acabado. 00:26:41
Ahora ya todo lo que falta es java. 00:26:43
Es irnos aquí, hacer el método correspondiente. 00:26:45
Y el método correspondiente es 00:26:48
Insertar libro 00:26:51
¿Vale? 00:26:54
Insertar libro 00:26:58
Y aquí ya podemos hacernos 00:26:59
Y aquí 00:27:03
Vamos a aprovechar el modelo 00:27:16
¿Vale? Vamos a aprovechar el modelo 00:27:23
Y en lugar de pasarle los datos 00:27:27
¿Vale? 00:27:29
Podemos reutilizar este modelo JaxB 00:27:35
Podemos reutilizar el modelo 00:27:37
Para Java 00:27:39
Entonces 00:27:40
¿qué tenemos que hacer aquí? 00:27:47
leer los libros 00:27:50
leer el fichero 00:27:52
y añadir a la colección este 00:27:54
pero cuidado con el id 00:27:56
porque el id lo genera automáticamente 00:27:58
luego aquí en este libro 00:28:00
no me vendrá id 00:28:03
porque es el dato que me dio el usuario 00:28:06
que el usuario mete solamente 00:28:08
título, autor, género y año 00:28:09
entonces el id lo generaré yo automáticamente 00:28:10
se lo pondré aquí a mano 00:28:13
antes de añadirlo al fichero 00:28:14
cuando lo leas, sí, pero es que ahora 00:28:16
esto es uno nuevo, pues el nuevo 00:28:26
los datos que vienen de fuera son 00:28:28
solo autor, título, no, el usuario 00:28:30
no me da ID, con lo cual este libro 00:28:32
su ID está sin setear 00:28:34
lo tengo que fijar yo 00:28:36
leyendo los que hay de antes 00:28:38
y generando uno único 00:28:40
¿vale? pues entonces 00:28:41
esto 00:28:43
Aquí, copiar el método 00:28:45
De leer de JaxB 00:28:48
Bueno, vamos a un proyecto de JaxB 00:28:50
Y aquí lo tendremos 00:28:52
En JaxB 00:28:58
Tendremos un método para 00:29:02
Escribir el XML 00:29:04
¿Eh? 00:29:05
Sí, pero no tengo 00:29:15
Uno que sea escribir porque lo tenía 00:29:16
Lo tengo aquí pegado, entonces lo tengo que extraer 00:29:17
Este es el de escribir, hacer el 00:29:20
Marshall, entonces este no lo tenía 00:29:22
Sacado a un método aparte, lo tenía directamente 00:29:24
aquí metido, entonces 00:29:26
este voy a hacer ahora ya así que un método 00:29:27
que sea escribir 00:29:30
en mi nuevo código aquí 00:29:31
vamos a hacernos aquí 00:29:33
public static 00:29:35
void 00:29:41
escribir xml 00:29:41
yaxb 00:29:45
¿qué le voy a pasar? le voy a pasar 00:29:48
el objeto biblioteca 00:29:50
este es el que le voy a pasar 00:29:52
y ¿dónde? pues al fichero 00:29:55
lo que sea. Y aquí ya sí que voy a pegar el código del Marshall, que era este. Lo 00:30:00
que pasa es que aquí lo cambio por biblioteca, lógicamente. Biblioteca. Importo biblioteca. 00:30:08
Y ¿dónde? Pues donde esté trabajando. Vamos a estar trabajando en el proyecto directamente. 00:30:19
me dio a olvidar de carpetas en el raíz 00:30:26
o sea 00:30:28
aquí es el fichero tal cual 00:30:30
pues paz 00:30:32
punto 00:30:36
perdón 00:30:37
el que hay subido 00:30:40
lo que pasa es que está dentro del método 00:30:43
sí, sí, sí 00:30:46
y ahora aquí me calca 00:30:47
es que no lo separé 00:31:04
Y ahora 00:31:06
Aquí se le daba 00:31:10
File 00:31:12
Uy, qué tontería, si ya lo tengo el file 00:31:13
¿Qué es este? 00:31:16
Ahora 00:31:19
Vale, pues ya tengo el de escribir xml 00:31:19
Que era hacer el contexto, crear el marshaler 00:31:24
Y mandar mi objeto biblioteca 00:31:27
Al fichero file que le estoy pasando 00:31:29
Y ya está 00:31:31
Ya tengo escribir xml 00:31:32
Y, pero perdonad, estaba buscando leer 00:31:36
Claro, cuando me he dicho leer es que estaba buscando leer 00:31:39
Claro, ya lo tenía 00:31:41
Voy a copiar leer, Polines 00:31:43
Era el que estaba buscando, parezco tonta 00:31:46
Vale, leer 00:31:48
Está aquí, que era efectivamente 00:31:48
El que estaba buscando 00:31:51
Sí, que sí, que me he liado 00:31:53
Por eso cuando me ha dicho, él tienes ahí leer 00:31:55
He dicho, pero quiero escribir, pues no, no quería escribir 00:31:57
Quería leer 00:31:59
Vale, es que me he liado 00:32:00
Vale, entonces 00:32:01
Ahora, leer xml 00:32:04
De JaxB 00:32:11
Mi fichero y ahora que lo que me va a dar 00:32:12
Es una biblioteca 00:32:17
Biblioteca 00:32:18
Vale 00:32:20
Dime 00:32:21
Pero a ver, se supone 00:32:25
Que no me estáis copiando 00:32:29
Que lo estáis haciendo en paralelo 00:32:32
Como ya pero 00:32:34
Vale, vale 00:32:35
Bueno, pues ahora revisamos 00:32:38
Pero 00:32:40
Vale, pues he copiado 00:32:40
el leer xml del proyecto 00:32:52
cambiando recetario 00:32:54
que era el ejemplo que teníamos por biblioteca 00:32:56
y pasándole el fichero 00:32:58
que le hemos dado como parámetro, ya está 00:33:00
he cambiado solamente eso, recetario por biblioteca 00:33:02
y el fichero 00:33:04
como se lo estoy pasando en path, pues lo convierto aquí a 00:33:06
file y ya está 00:33:08
este es el de leer xml 00:33:10
y ahora el de... vale 00:33:11
¿qué? ¿qué pasa? 00:33:15
¿qué no me pasa? 00:33:20
Bueno, pues ya está 00:33:24
Ahora ya nos vamos aquí a insertar libro 00:33:51
Leemos el fichero 00:33:54
Leer 00:33:55
xml 00:34:02
Sí, perdón 00:34:04
He visto libro arriba y me he liado 00:34:07
Biblioteca 00:34:13
Ler xml 00:34:15
El fichero 00:34:16
Insertar libro 00:34:22
Y no le he pasado el fichero 00:34:24
No le he pasado el fichero 00:34:25
Con el que estamos trabajando 00:34:28
Habría sido más cómodo ponerlo en un properties 00:34:29
O algo así para no arrastrarlo todo el rato 00:34:32
Pero bueno 00:34:34
Venga, leer XML, JAXB, fichero. 00:34:34
Ya está. 00:34:49
Ahora, mi único problema es... 00:34:53
Mi único problema sería... 00:35:01
Mi único problema sería... 00:35:03
A esta colección de libros, en realidad, añadirle el libro nuevo y luego ya escribir el XML. 00:35:07
¿Vale? 00:35:18
Vale, y aquí yo ya, librería y fichero. 00:35:28
vale, pero que ocurre 00:35:36
que no puedo hacerlo así sin más 00:35:44
porque antes de añadir el libro 00:35:45
tengo que fijarle un ID 00:35:48
que sea único, que no esté ya 00:35:49
entonces antes de hacer esto 00:35:51
tenemos que sacar los IDs de la colección 00:35:53
para generar uno único 00:35:56
entonces, ¿cuál sería 00:35:58
el argumento más fácil? vamos a sacar 00:36:00
el máximo de todos los IDs 00:36:01
que están en esta colección 00:36:04
y le sumo uno más para setearlo 00:36:06
y ya está, entonces, pues eso 00:36:09
¿Perdón? 00:36:10
¿Bajar a dónde? ¿A cuál? 00:36:18
¿Vale? 00:36:28
Vale 00:36:30
Bueno, pues ala 00:36:30
entonces, ahora, antes de hacer esto 00:36:36
tenemos que hacerle un set al libro del ID 00:36:38
y el ID que sea 00:36:41
una unidad más del máximo 00:36:43
de los que ya están 00:36:45
pues venga, ¿cómo me hacéis eso? 00:36:46
el máximo 00:36:50
de los IDs, pues eso con streams 00:36:51
lo hacéis a toda velocidad, ¿verdad que sí? 00:36:53
estos son los libros 00:36:57
de los libros quiero sacar 00:36:58
el máximo de los IDs que tienen 00:37:00
nos ponemos todos en fila 00:37:02
hasta ahí hemos llegado 00:37:05
todos en fila 00:37:07
De cada libro me quedo con su ID 00:37:07
Ahí que funciona habrá que hacer 00:37:10
No, un filter no 00:37:12
No hace falta 00:37:15
Un map 00:37:17
De cada fila de libros 00:37:19
Me quedo con su ID 00:37:21
Y ahora de esa fila de IDs 00:37:22
Le hago la función máximo 00:37:25
¿Vale? Pues que de cada fila 00:37:26
De libros 00:37:29
Map es cuando tienes una lista dentro 00:37:30
Flat map es cuando tienes una lista dentro de otra 00:37:33
Claro, pero aquí entonces 00:37:35
si no. Pues de cada 00:37:37
libro de estos, me 00:37:39
quedo con su 00:37:40
ID. 00:37:42
Pero con su ID a paloseco, no. 00:37:47
Lo tengo que convertir a entero, porque quiero hacer 00:37:49
el máximo. Entonces, 00:37:50
¿qué haremos aquí? 00:37:53
Casting. ¿Cómo que casting? 00:37:54
¿Cómo que casting? 00:37:58
Estas son las cosas que son de cero. 00:37:59
Pero un íntegro para seguir, por Dios 00:38:00
santo. 00:38:02
Un casting, dice. 00:38:06
Ah, sí 00:38:10
Vale 00:38:14
Ahora, tengo ya una filita 00:38:16
De IDES 00:38:23
¿Vale? 00:38:25
Vale, y ahora 00:38:34
No me ofrece el máximo 00:38:36
Porque no es una 00:38:40
Si le pongo map to int 00:38:42
Como son enteros 00:38:44
Yo creo que ya me ofrecerá la función máximo 00:38:46
Entonces map to int 00:38:48
No sé dónde estaba la mayúscula 00:38:49
Map to int 00:38:53
Aquí está 00:38:57
Con tu int 00:38:58
Vale 00:39:00
Map to int 00:39:00
Vale, ya tengo la filita de enteros 00:39:06
Y ahora esta filita de enteros 00:39:09
Me ofrece ya el máximo 00:39:12
De toda esta fila 00:39:15
Y ahora 00:39:16
De esta como es tan opcional 00:39:19
Pues la saco 00:39:22
Así a lo bestia 00:39:25
Venga, sácamelo como entero 00:39:26
Pues si a todo esto le sumo uno 00:39:28
Y se lo seteo 00:39:32
Al libro, ya está 00:39:34
A todo esto le sumo uno 00:39:36
Y todo esto se lo seteo 00:39:39
Al libro 00:39:41
Libro.set 00:39:41
pero lo tengo que convertir a íntegro otra vez 00:39:45
set id 00:39:50
y ahora 00:39:53
es que ya he perdido los paréntesis 00:39:58
pero 00:40:00
y ahora esto 00:40:02
para que me lo convierta 00:40:04
a string, porque el id es en string 00:40:08
bueno, he perdido los paréntesis 00:40:10
me falta uno, ¿de dónde? 00:40:11
Ah, me falta uno después de aquí 00:40:14
Ya está 00:40:16
Ya le he puesto 00:40:18
Un ID único 00:40:26
Tal cual 00:40:27
¿Eh? 00:40:28
¿Cómo? 00:40:35
Cuando te barren todos los libros 00:40:39
Ah, bueno, bueno 00:40:40
Ya, ya, ya, vale 00:40:43
No estamos en el examen 00:40:43
En el examen no tenemos esas consideraciones 00:40:46
¿Vale? 00:40:48
Bueno, tenemos ya libros 00:40:50
Y ya está 00:40:52
y me quedo 00:40:54
con el máximo 00:40:56
le sumo uno 00:40:58
claro, si la colección 00:40:58
es diferente de, o sea, realmente 00:41:04
esto 00:41:06
lo que pasa es que podríamos 00:41:07
hacer algo más infinito, el set ID podríamos ponerle aquí 00:41:11
un ternario, que es 00:41:14
live.getlibros 00:41:16
diferente de null o live.getlibros 00:41:20
.size 00:41:22
Mayor que cero 00:41:24
Esto 00:41:27
En el otro estremo 00:41:28
Uno 00:41:31
¿Vale? 00:41:32
Es decir, si nos venimos arriba 00:41:38
En plan fanfarrones 00:41:40
Y ponemos 00:41:41
Lit.get libro 00:41:43
Es diferente 00:41:45
De null 00:41:48
Y además de ser 00:41:50
Diferente de null 00:41:52
joder 00:41:54
y además de ser diferente de null 00:41:56
list.getLibro 00:41:59
size 00:42:03
es mayor que 0 00:42:05
pues en ese caso me plantas eso al id 00:42:07
y si no 00:42:11
me plantas 00:42:13
y aquí me falta un paréntesis y aquí me sobra 00:42:15
ala 00:42:23
como una reina 00:42:27
déjalo 00:42:28
bueno, venga, ¿qué vas a decir? 00:42:33
ah, tienes toda la razón 00:42:40
vale, vale, sí 00:42:41
ya no sabéis hacer esto tan bonito 00:42:42
vale, vale 00:42:43
que cuando sacas el int 00:42:44
este le pones y si no lo hay 00:42:50
en el sacar del optional 00:42:52
pues me da cero 00:42:53
pero bueno 00:42:54
así no nos olvidamos 00:42:58
de alternario 00:43:00
claro, lo he sacado 00:43:01
de un opcional, he asumido que existe 00:43:05
pero puede no existir 00:43:06
puede que en el opcional no haya nada 00:43:08
¿vale? 00:43:09
accediendo a él 00:43:14
bueno, venga 00:43:15
esto era un poco por a... 00:43:20
en el examen 00:43:23
en realidad, a menos que yo lo especifique 00:43:25
si no me tenéis en cuenta 00:43:27
si no hay libros o lo que sea, da igual 00:43:28
Bueno, pues esta funcionalidad ya está 00:43:30
Pero a mí me está... 00:43:41
Esta ya está 00:43:43
Y lo tengo bien 00:43:44
¿Cómo es posible que es que somos 00:43:48
Haceros un poco? 00:43:53
En plan, ¿en qué modo? 00:43:55
Pero vamos con él 00:43:58
Pero vamos a ver 00:43:59
Si realmente tú quieres hacer el máximo 00:44:06
De una serie de números 00:44:07
No te es mucho más fácil 00:44:08
O sea, es que hacer el máximo ha sido 00:44:10
El string y el map y el max 00:44:12
Ha sido esto 00:44:14
Esto realmente sí es más fácil que un for 00:44:14
Que te saca el máximo 00:44:18
Así que lo es 00:44:19
Porque un for que te saca el máximo 00:44:21
Pues tienes tú que hacer el algoritmo 00:44:24
Un for e ir sustituyendo el máximo 00:44:25
Entonces esto ya es más fácil 00:44:28
Claro, porque este es el máximo 00:44:29
De los IDs que ya hay 00:44:37
Entonces yo quiero crear uno nuevo y único 00:44:38
Pues esta funcionalidad ya estaría 00:44:39
Esto fuera 00:44:48
Vale, pues venga, siguiente 00:45:02
Un JSON 00:45:09
Pues es que esto es en el Jackson 00:45:11
Mandarle el valor y ya está 00:45:14
Pues venga, generamos el JSON 00:45:16
Dependencia de JSON 00:45:20
Pues vamos a buscarla 00:45:24
En otro fichero que ya esté 00:45:25
La dependencia de Jackson 00:45:27
Esto 00:45:35
La copiamos 00:45:36
Vale 00:45:41
Ya está 00:46:03
Pues venga. 00:46:08
Son dos dependencias, ¿no? 00:46:09
Pero la segunda era 00:46:11
cuando usamos lo de pasar directamente 00:46:13
de XML a... 00:46:15
La pusimos. O sea, el Jackson 00:46:17
básico era una. La otra 00:46:19
era otra dependencia. 00:46:21
Se me ha escapado una. 00:46:25
Aquí tengo solo las que... 00:46:26
A ver. 00:46:29
En mi U de uno picharro es Jason. 00:46:29
A ver. 00:46:31
Joder, ¿dónde está? 00:46:34
Acá. 00:46:37
jason dotavine y jackson corey solo 00:46:38
a donde estoy yo, jolines 00:46:41
jason 00:46:43
estoy 00:46:47
jason aquí 00:46:48
vale, tenemos esta 00:46:50
yo tengo esta solamente 00:46:53
yo solo tengo uno 00:46:55
yo tengo dotavine y corey 00:46:56
dotavine y corey 00:46:58
no lo sé 00:47:02
a ver 00:47:07
bueno, lo tengo solo con dotavine 00:47:08
Bueno 00:47:09
Voy a poner esa 00:47:20
Vale 00:47:22
Vale 00:47:22
Vale, pues a ver 00:47:39
El método que nos falta 00:47:45
Guardar en fichero json 00:47:46
Era, ¿no? 00:47:50
Public static 00:47:52
Voy a cambiarle el false 00:47:57
A true aquí 00:48:02
Vale, escribir public static 00:48:04
Voy a escribir 00:48:08
Jason 00:48:11
Escribir Jason 00:48:13
Entonces, ¿qué? 00:48:17
Pues vamos a escribir de Jason 00:48:19
Aquí, este, el biblioteca 00:48:21
¿Y en qué fichero? Pues en el que me digan 00:48:23
Escribir Jason 00:48:26
Bueno, pues aquí el mapper 00:48:33
Es el que hacía de todo 00:48:38
Pues tiro de él 00:48:39
A ver qué me ofrece 00:48:40
Vamos a tirar de él 00:48:44
Vale, pues el mapper 00:48:54
Podemos mirarlo en el proyecto 00:49:06
Tiene un método 00:49:08
Ya directamente para escribir 00:49:13
Sacamos el writer 00:49:15
Y luego era write value 00:49:26
O ya directamente write value 00:49:28
Vale 00:49:30
Pues vamos a escribir 00:49:31
En fichero 00:49:33
Punto 00:49:36
Tu file 00:49:40
Y vamos a escribir 00:49:42
Vamos a escribir 00:49:46
este 00:49:48
si, este era para que 00:49:49
fuera bonito, ¿verdad? 00:49:54
claro, pues vamos a usar 00:49:56
el que fuera bonito 00:49:58
write 00:50:00
with default 00:50:02
este, entonces 00:50:04
este te sacaba 00:50:09
vale, te sacaba 00:50:11
el writer, bonito 00:50:14
y ahora 00:50:16
escribíamos el fichero 00:50:18
Y el tema es que lo puedes hacer sin hacerlo bonito 00:50:20
porque hay que decidir 00:50:23
que tenías que hacerlo feo también. 00:50:25
Que crea por defecto. 00:50:28
Sí, hay informáticos que se la 00:50:29
refanficlan y se la ponen feo. 00:50:31
Entonces te dan la opción de yo lo quiero 00:50:33
feo. 00:50:35
El quererlo feo debería ser la opción 00:50:37
mala. 00:50:39
A ver, lo que pasa es que los JSON 00:50:41
esencialmente son para máquinas. 00:50:45
Y las máquinas, cuanto más feo 00:50:47
mejor porque no tienen que parsear espacio, 00:50:49
no tienen que parsear nada. 00:50:51
¿Eh? 00:50:53
Bueno. 00:51:02
Pues ya está. 00:51:03
¿Cuál? 00:51:10
¿Modificar? 00:51:15
¿Modificar el qué? 00:51:18
¡Ah! 00:51:21
modificar género 00:51:23
es esto 00:51:25
porque me ha dado 00:51:26
a mí por ahí, yo que sé 00:51:49
a ver, habrá 00:51:50
APIs que por las características 00:51:57
de PAD les interese PAD 00:51:59
sobre todo yo creo que 00:52:00
aparte del diseño es distinto 00:52:03
la arquitectura de diseño es distinto 00:52:04
creo que es compatible con 00:52:06
URIs, con cosas que File no lo es 00:52:09
entonces tu PAD lo puedes asociar a un 00:52:11
recurso genérico 00:52:15
o a una URI, pero 00:52:16
asociar un File a una URI no puedes 00:52:18
claro, File es para un 00:52:20
fichero, PAD es más amplio, es un camino 00:52:23
y un PAD puede ser 00:52:25
PAD to File, pero un PAD puede ser PAD to PAD 00:52:26
no creo que esté 00:52:28
No lo sé. 00:52:31
A ver, en File no, pero PAD. 00:52:33
Claro, pero tú puedes crear un PAD pasando en el File. 00:52:37
¿Eh? 00:52:43
Que hay un tu PAD dentro de File para convertirlo a PAD. 00:52:45
Pues no lo sé. 00:52:49
Bueno, pues a ver, siguiente método. 00:52:52
Ahora ya, usando el archivo, no usando biblioteca, 00:52:55
vamos a consultar libro por ID. 00:52:59
Pues venga, vamos a consultar libro por id 00:53:01
Ala 00:53:03
Vale, pues vamos a devolver 00:53:05
El libro con un id 00:53:19
Dado 00:53:21
String id 00:53:22
A fichero 00:53:29
Vale 00:53:33
Igual a 00:53:34
Venga, pues ala 00:53:50
El object mapper 00:54:01
Porque vamos a trabajar 00:54:03
Con el fichero JSON 00:54:05
Ahora, vamos a 00:54:06
Esto directamente con el Jackson 00:54:16
Se puede tal cual ya 00:54:23
Como tiene la biblioteca 00:54:24
Tiene el modelo 00:54:28
Pues es que ya directamente con el Jackson 00:54:29
Podemos hacer esto 00:54:31
Mapper.read 00:54:32
Reactree 00:54:35
¿No? 00:54:37
Y... 00:54:40
No, el Reactree te da el JSON node 00:54:40
Reactvalue será 00:54:42
ReactValue 00:54:44
Te da directamente 00:54:46
Tú le dices el fichero 00:54:50
Y luego le dices aquí la clase 00:54:52
En la que tiene que parsear 00:55:00
Biblioteca.class 00:55:01
¿Vale? 00:55:05
Y ya está 00:55:07
Y es que ya habría que sacar ahí el que tiene ese ID 00:55:08
Y se acabó 00:55:12
Entonces 00:55:12
el reactree cuando lo quieres 00:55:18
guardar en un json node 00:55:22
porque no tienes el objeto 00:55:24
biblioteca, podemos hacerlo ahora 00:55:26
entonces, ahora si lo 00:55:28
como tenemos el modelo y tenemos el objeto 00:55:29
la clase biblioteca, lo vuelco al modelo 00:55:31
y ya está, pero si yo no tuviera 00:55:34
estas clases no puedo volcarlo al modelo 00:55:36
entonces lo vuelco a un json node, que es una 00:55:37
estructura de json 00:55:39
de Jackson, vale, entonces aquí 00:55:41
me quedaría con mis 00:55:43
libros y quiero solo 00:55:46
que tiene el id, pues hombre 00:55:48
aquí hace uno su superfilter 00:55:49
bueno, primero se hace 00:55:52
su filita 00:55:53
y se hace 00:55:55
su superfilter y ya está 00:55:57
y que nos quedamos 00:56:00
pues quédate 00:56:01
solamente de cada libro 00:56:03
quédate con aquel que cumpla 00:56:05
que 00:56:08
x.getid 00:56:09
es igual 00:56:12
Al ID que tú le estás pasando 00:56:18
No lo sé 00:56:20
Ah, por este espacio que tengo aquí tan feo 00:56:28
Hombre, claro 00:56:33
El simbolito este 00:56:36
No le puedo poner separado 00:56:38
Entonces, aquí 00:56:39
Este es el libro que tengo que filtro 00:56:40
Entonces 00:56:44
De aquí me quiero quedar 00:56:45
Con 00:56:48
El primero de todos 00:56:49
Tendré una opción de quedarme 00:56:52
Con el primero de todos, ¿no? 00:56:54
Que es el único en este caso 00:56:55
Ah, es que me lo he saltado 00:56:56
Ah, que está aquí 00:57:07
Vale 00:57:09
Me lo he saltado 00:57:11
Vale 00:57:13
Este, find first 00:57:16
Y ahora 00:57:19
Yo es que aquí 00:57:21
Asumo que todo existe 00:57:22
Lo saco tal cual 00:57:24
Este es el libro 00:57:26
Que devolvemos 00:57:29
Eso es lo que iba a decir 00:57:32
Que yo aquí estoy 00:57:38
Vale, entonces 00:57:39
Aquí puedo 00:57:41
Find first 00:57:43
Entonces 00:57:45
De aquí me saco 00:57:46
Olers 00:57:48
Libro 00:57:49
Olers 00:57:50
Vale 00:57:52
Si no existe el libro 00:57:53
No devuelvo el null 00:57:55
¿Vale? 00:57:56
Te devuelvo un litro 00:58:06
O un null o el objeto libre 00:58:07
¿Vale? Entonces de hecho 00:58:09
Podríamos hasta 00:58:11
Meter 00:58:13
Esto aquí 00:58:14
Y el sumétodo de una sola línea 00:58:17
Pero bueno, ya demasiado frío, no hay necesidad de 00:58:19
¿Cómo? 00:58:38
Estamos jodidos 00:58:47
¿Pero de qué me estás hablando? ¿De esto? 00:58:48
¿Este método te da 00:58:52
error de compilación? ¿Que no lo encuentra? 00:58:53
¿O cómo? 00:58:56
¿Que no puede resolver el qué? 00:58:58
¿O sea, aquí le estás pasando? 00:59:03
Si se lo pasas a File 00:59:08
Tampoco te lo coge 00:59:10
Pero es muy raro porque 00:59:11
Como no sea la versión de Jackson 00:59:12
Pero me extraña mucho 00:59:15
Hombre, tendrá las firmas 00:59:16
Para los dos 00:59:22
Pero lo que me extraña es que 00:59:23
A él no le coja el de File 00:59:26
Pues 00:59:27
No sé decirte 00:59:34
¿Qué versión tienes? 00:59:36
Vamos a ver 00:59:39
Yo tengo la 3-0 00:59:44
No sé si será por eso 00:59:52
Que no le he cambiado esto 00:59:54
Entonces 01:00:05
Si uno no tuviera el modelo 01:00:06
Esto se complicaría un pelín este método 01:00:07
Porque yo no podría leer en biblioteca 01:00:10
Directamente, si uno no tuviera el modelo 01:00:13
Esto ya no sería tan sencillo 01:00:14
Si no lo tuviéramos, tendríamos que leer 01:00:16
A un JSON node 01:00:18
¿Qué? 01:00:20
Ni siquiera sé si la clave se llamaba así 01:00:29
Y ahora ya sí que sería 01:00:31
Mapper.reactree 01:00:35
¿Vale? 01:00:37
Y aquí ya el 01:00:38
Fichero 01:00:40
Y esta no sé si la he escrito bien 01:00:43
Sí, está bien escrita 01:00:45
Vale, entonces aquí sería un rollo 01:00:48
Porque aquí ahora ya tendríamos que navegar por aquí 01:00:51
Tendríamos que 01:00:53
Encontrar 01:00:55
Nodo tiene su find 01:00:57
A partir de los find 01:00:59
Pues tenemos que encontrar 01:01:06
Claro, o sea, este nodo 01:01:10
lo podemos cambiar con el método 01:01:22
tree to value, lo cambiaríamos a biblioteca 01:01:24
Bueno, si estás en otro 01:01:26
momento de tu método 01:01:30
porque aquí es que lo acabamos de leer 01:01:32
pero tú podrías estar en una zona de tu aplicación 01:01:33
donde tienes el JSON node 01:01:36
y ahí ya lo quieres convertir 01:01:37
a un modelo en ese momento 01:01:39
porque vienes de otro sitio 01:01:40
aquí en particular sería absurdo 01:01:42
leerlo como JSON node 01:01:44
para cambiarlo si ya lo podemos leer 01:01:46
con real value 01:01:48
simplemente para ver ese método 01:01:49
yo la 301 01:01:52
3.0.1 01:01:57
aquí por ejemplo 01:02:03
pues aquí tendríamos find values 01:02:06
que me saca 01:02:08
toda la lista de json nodes 01:02:14
vale 01:02:16
con esta propiedad, tendría que navegar 01:02:17
por ella, cuando encuentre 01:02:23
el ids así 01:02:25
pues tendría que sacarme 01:02:27
el resto de propiedades para hacer un libro 01:02:28
o sea, sería una, navegar a través de aquí 01:02:31
es un poco rollo, vale 01:02:33
venga, ni vamos a entrar en ello 01:02:35
ahora mismo, aparte de por la hora que es 01:02:37
entonces esto 01:02:39
Vale, ¿qué podríamos incorporar aquí? 01:02:40
Que no hemos incorporado 01:02:52
Que liste 01:02:53
Doctor, que liste 01:03:02
El informe, no entiendo nada 01:03:32
Punto PDF 01:03:34
Vale, pues un informe 01:03:34
Autor, tres libros 01:03:38
Autor, tal, cuatro libros 01:03:40
Autor, no sé cuánto, cinco libros 01:03:42
Para procesar un poquito el fichero 01:03:44
Y luego yo hago el informe y ya está 01:03:46
A ver 01:03:47
Ahora, si incorporamos los logs 01:03:51
Pues aquí 01:03:54
Para incorporar los logs, ¿qué haríamos? 01:03:55
Primero, necesitaríamos la dependencia 01:03:59
Pues vamos a copiar la dependencia 01:04:00
Venga 01:04:02
Vamos a generar archivos de logs aquí 01:04:03
A ver 01:04:07
La dependencia de log4j 01:04:08
Imagino 01:04:13
Aquí está 01:04:15
Venga 01:04:16
Aquí 01:04:19
Aquí 01:04:22
Eran estas dos 01:04:23
Vale 01:04:25
Y esta de Jackson 01:04:30
era necesaria si el archivo de configuración 01:04:32
de xml 01:04:35
era json 01:04:36
si el archivo de configuración de log4j 01:04:37
era json, si era xml no 01:04:40
entonces 01:04:42
vamos a copiar 01:04:44
estas dos 01:04:47
¿vale? 01:04:51
por ejemplo 01:04:54
copiamos esta dependencia 01:04:55
a nuestro 01:04:58
pom 01:04:59
porque si el archivo 01:05:00
de configuración de 01:05:03
logs, era con JSON 01:05:04
que era una posibilidad 01:05:07
entonces le quitabas la dependencia de Jackson 01:05:08
vale, si es con XML no te hace falta 01:05:11
entonces, a ver, vamos a ver 01:05:13
vamos a ponerle los logs 01:05:17
y nos vamos 01:05:18
pues venga, voy a añadir 01:05:19
vamos a ponerle los logs, como lo haríamos 01:05:22
Le pongo la dependencia esta de logs 01:05:30
Esta de jacksons, se me ha escapado 01:05:33
Que ya la tengo arriba 01:05:35
Entonces esto lo voy a quitar porque se me ha escapado 01:05:36
Le pongo la dependencia de logs 01:05:38
Vale 01:05:41
Un fichero de configuración me va a hacer falta 01:05:42
Pues vamos a coger un fichero de configuración 01:05:45
Y lo retocamos 01:05:47
Pues venga, un fichero de configuración 01:05:48
Lo tenemos en nuestro ejemplo 01:05:51
De logs 01:05:53
En recursos 01:05:54
Vale 01:05:56
el xml 01:05:58
por ejemplo 01:06:00
lo copiamos en los recursos 01:06:03
de aquí 01:06:09
vale, que le voy a cambiar el nombre 01:06:10
porque ahí estaba 01:06:16
mal llamado 01:06:17
venga, ok 01:06:21
ala, he puesto la dependencia 01:06:26
Y el archivo de configuración en resources 01:06:30
Vale, vamos a abrirlo 01:06:32
Para adaptarlo a nuestra situación 01:06:34
Venga 01:06:36
Que appenders tenemos, este de consola 01:06:39
Muy bien, este fichero 01:06:41
Quiero que se llame así, venga 01:06:43
Y tengo un fichero, este fichero de aquí 01:06:45
Quiero que se guarden 01:06:48
Logs, aplicación.log 01:06:50
Venga, si, si no le cambio de nombre y ya está 01:06:51
Estos appenders me gustan 01:06:53
Ahora, los logger 01:06:55
Vamos a ver, lo vamos a configurar 01:06:57
Los logger, cuidado con esto 01:07:01
Logger raíz, quiero que todas las clases se configuren 01:07:03
Igual, pues de esto 01:07:06
Paso, porque esto es para configurar 01:07:08
Cada clase por separado 01:07:10
Para que cada una tenga un nivel 01:07:11
De logs distintos 01:07:13
Entonces, venga, esto lo quito 01:07:15
Y aquí ya 01:07:18
Decido 01:07:20
Nivel de logs 01:07:21
One, no es a ver 01:07:24
One, info, el que sea 01:07:26
Vamos a ponerle 01:07:27
Pues yo pongo info, ala 01:07:29
Tú pones Juan, pues yo pongo info 01:07:32
¿A dónde queremos que vayan los logs? 01:07:36
Al fichero y a la consola 01:07:38
¡Hala, ya está! 01:07:40
Ahora, si hemos hecho esto 01:07:42
Es para ahora 01:07:43
Hacer aquí cosas un poco más 01:07:45
Monas, por ejemplo 01:07:47
Hay que crear un log 01:07:49
Aquí, pues yo haría 01:07:53
Ah, claro, hay que crear el log, jolines 01:07:56
Me pongo el log 01:07:58
On fire 01:08:00
Vale, entonces 01:08:03
Voy a copiar la línea directamente 01:08:06
De aquí 01:08:08
A la mi logger 01:08:11
Ahí 01:08:18
Venga 01:08:21
Y ahora la clase se llama lógica 01:08:27
Vale, pues este es el logger 01:08:37
De mi clase lógica 01:08:38
Que como no tiene una configuración específica 01:08:40
Para él en el fichero de configuración 01:08:43
No tiene una específica para él 01:08:45
Pues se va a configurar con el del raíz 01:08:48
Esto fuera 01:08:50
Ahora 01:08:56
Y ahora ya, pues por ejemplo aquí 01:08:59
Y no he encontrado 01:09:01
Pues yo que sé, uno podría a lo mejor 01:09:06
Querer hacer esto 01:09:09
Log.one 01:09:10
No se actualizó 01:09:16
Antes 01:09:24
No se actualizó 01:09:25
Ningún fichero 01:09:31
Yo que sé, cualquier cosa que yo quiera 01:09:33
Dejar registro 01:09:35
Y mi variable no se llamaba log 01:09:36
Sino 01:09:40
Y ya está 01:09:41
Y ahora ya aviso donde a mí me dé la gana 01:09:47
Aviso y se acabó 01:09:49
Cuando yo quiera 01:09:50
Claro, con el nivel que yo quiera 01:09:52
Que luego estoy en fase de desarrollo 01:09:57
Quiero que me lleguen todos los logs 01:09:59
Pues me aseguro de que en mi fichero de configuración 01:10:00
Que 01:10:03
Es este 01:10:04
Me aseguro de que aquí está el nivel que yo quiero 01:10:07
Que ya estoy en producción 01:10:09
Ya en el servidor final 01:10:10
Pues aquí pondré error 01:10:12
Para que solo vayan a log los importantes 01:10:14
Que quiero una configuración 01:10:16
Específica para mi clase cualquiera 01:10:19
Pues me añado aquí un log 01:10:21
Para esa clase 01:10:23
Acabo de eliminar 01:10:24
para que las clases vayan con diferentes niveles 01:10:25
esta que vaya con info y ya está 01:10:29
hay poco más que esto, ¿vale? 01:10:30
muy sencillito 01:10:36
falta la parte del controlador 01:10:37
es sencillín, pero bueno 01:10:40
ahora esto 01:10:41
tendríamos que meterlo 01:10:44
en la arquitectura 01:10:46
estos son las funcionalidades 01:10:49
ahora ya pues uno que lo quiere como 01:10:50
aplicación de escritorio, se hace su menú 01:10:52
y llama esto 01:10:54
que lo quiere como aplicación web 01:10:55
se hace su controlador 01:10:57
y desde el controlador llama a esto 01:10:59
y ya está 01:11:01
venga, pues nos vamos 01:11:02
bueno, tenéis menos miedo 01:11:17
No me lo creo 01:11:25
¿Habéis visto que lo habéis podido hacer todo? 01:11:30
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
21 de noviembre de 2025 - 13:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 11′ 38″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
332.74 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid