Saltar navegación

20251021 JAXB_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 22 de octubre de 2025 por Raquel G.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

tú ya eres de una generación 00:00:00
casi más parecida a la mía 00:00:06
vale, bueno pues 00:00:08
siguiente arquitectura para acceso a ficheros 00:00:11
xml, os voy a decir 00:00:13
lo que siempre os digo, es muy fácil 00:00:15
pero, es verdad, lo es 00:00:16
entonces, Jaxb 00:00:19
viene, si 00:00:21
mi memoria para variar 00:00:22
no me falta 00:00:25
no me falla 00:00:27
arquitectura java 00:00:28
para hacer el enlace 00:00:32
xml 00:00:34
¿vale? entonces esta 00:00:35
sí que es de alguna 00:00:40
manera la 00:00:42
estándar para acceder a ficheros xml 00:00:43
¿vale? Jaxway 00:00:47
más que DOM, DOM tiene la ventaja que dijimos 00:00:48
que para aplicaciones pequeñitas 00:00:50
y en la que yo no quiero tener ninguna 00:00:52
dependencia pues es muy cómoda 00:00:54
pero esta es la estándar 00:00:56
¿por qué? porque esta 00:00:58
se fusiona muy bien con el modelo de objetos. 00:00:59
Entonces DOM insiste en la arquitectura de árbol, lógicamente, 00:01:06
y nosotros tenemos que cambiar nuestra forma de pensamiento a un árbol 00:01:11
cuando estamos trabajando con DOM. 00:01:14
Pero esta nos permite seguir en el mundo de los objetos. 00:01:16
¿Y el mundo de los objetos cuál es? 00:01:20
Pues la lógica de negocio de nuestra aplicación. 00:01:21
Nuestra aplicación va a tener un modelo de negocio que son las entidades. 00:01:24
Y yo debería pensar todas las funcionalidades, en especial las de acceso a datos, orientadas a las entidades. Insertar o recuperar alumnos. Consultar facturas. Debería pensar todas las funcionalidades de acceso a datos en términos de la lógica de negocio de las entidades. 00:01:28
entonces, si esas entidades 00:01:45
están en un XML 00:01:47
todo se me desbarata, porque de repente hay un árbol 00:01:49
entonces, jolín, que pesado 00:01:52
bueno, pues JaxB trata de 00:01:54
y consigue 00:01:56
lógicamente 00:01:57
ocultar ese salto y convierte 00:01:59
el XML de nuevo 00:02:01
en un modelo de negocio de entidades normal y corriente 00:02:03
y es muy natural 00:02:06
muy natural 00:02:07
en realidad que así sea, porque cuando tenemos por ejemplo 00:02:08
un XML normal 00:02:12
que podría ser algo como esto, alumno, pues nombre, nota, aquí muchos alumnos, aquí se acaba el nodo de ahí, 00:02:16
esto lo podemos mapear en nuestra cabeza de forma bastante intuitiva a un modelo de negocio 00:02:34
donde yo tengo una clase alumnos y esta clase alumnos se contiene, pues esta clase alumnos contiene 00:02:42
una colección 00:02:51
de alumno 00:02:53
y nada más 00:02:55
y luego tendría la clase alumno 00:03:01
que a su vez 00:03:03
contiene una propiedad 00:03:08
nombre y una propiedad 00:03:10
nota ¿vale? 00:03:12
entonces una estructura jerárquica 00:03:14
se puede mapear 00:03:16
a una estructura de 00:03:18
entidades y de clases 00:03:20
entonces JaxB 00:03:21
lo que está organizado 00:03:23
de tal manera que tú 00:03:26
haces la estructura de clases 00:03:27
que representa, que se corresponde 00:03:30
exactamente con el XML 00:03:32
y una vez que ya la tienes hecha 00:03:34
ya te olvidas del XML 00:03:36
y de su árbol y de su jerarquía completamente 00:03:37
y simplemente trabajas con estas 00:03:40
entidades, poniendo 00:03:42
las propiedades que sean, cambiándolas 00:03:44
añadiendolas, lo que haga falta 00:03:45
y en el momento en el que tú quieras 00:03:47
haces ya 00:03:49
la transferencia 00:03:50
¿vale? 00:03:53
entonces 00:03:54
la aplicación que trabaja 00:03:55
haciendo acceso a datos con JSB 00:03:58
hará una operación 00:04:00
de unmarshal que se llama 00:04:02
y esta operación de unmarshal 00:04:04
es la que lleva del XML 00:04:08
a los objetos 00:04:10
y luego tú ya trabajas 00:04:12
con los objetos haciendo lo que te da gana 00:04:15
y cuando has terminado 00:04:17
o quieres reflejarlo ya en el 00:04:19
fichero, haces una operación de marshal 00:04:21
que se llama 00:04:23
y esta ya lleva de los objetos 00:04:25
al XML 00:04:27
de nuevo, todo esto 00:04:28
está cargado en una lista 00:04:33
de objetos, o sea, todo el XML 00:04:35
va a estar en memoria en realidad 00:04:37
pero ahora no va a estar en memoria 00:04:38
no va a estar en memoria en una 00:04:40
variable document DOM 00:04:43
que pesará lo que pesa, ahora va a estar en memoria 00:04:45
pero en objetos que forman parte de tu 00:04:47
aplicación y objetos que tú estás usando 00:04:49
entonces no pasa nada porque estén en memoria 00:04:51
porque son los objetos de tu aplicación con los que haces cosas 00:04:53
vale, no necesitas 00:04:55
toda esa variable document 00:04:57
solo para hacer la parte de acceso 00:04:59
a xml 00:05:02
esto la idea es integrarlo 00:05:03
con mi modelo de clases 00:05:05
entonces tienes tu aplicación 00:05:08
que tiene tus clases, con todas tus cosas 00:05:09
y luego 00:05:12
además 00:05:14
quieres que 00:05:14
en los momentos correspondientes 00:05:17
todo lo que hay ahí se refleja en un xml 00:05:19
pues entonces lo único que tienes que hacer 00:05:22
lo único que tienes que incorporar a la aplicación 00:05:24
es unas pequeñas 00:05:26
anotaciones 00:05:28
para indicar estas clases 00:05:29
mías con las que yo trabajo y hago mis cosas 00:05:32
además cuando yo quiera 00:05:34
se van a conectar con un XML 00:05:36
¿vale? esas anotaciones 00:05:38
que es lo único 00:05:40
que yo tengo que añadir, esas anotaciones 00:05:42
convierten a estas clases 00:05:44
en mapeables a un XML 00:05:46
no tengo que añadir nada 00:05:48
adicional, ni un document, ni nada 00:05:50
y luego yo cuando ya quiera hacer 00:05:52
ese mapeo, bien sea hacia allá para cargar los datos 00:05:54
o bien sea hacia acá para reflejarlo, pues lo hago con un método 00:05:57
Marshall a Marshall y ya está. Pues este es el funcionamiento 00:06:02
de JASB. Luego, la única complejidad que tiene 00:06:06
es saber qué anotaciones tengo que poner 00:06:10
para que estas clases reflejen este XML y ya está. 00:06:14
Pero anotaciones, pues bueno, JASB tiene unas cuantas, pero al final 00:06:18
las que acabas usando son 5, 6 o 7 como mucho 00:06:21
que son las que te dicen 00:06:24
esta clase es mi nodo raíz 00:06:26
este es un nodo elemento 00:06:27
este 4 o 5 anotaciones y ya está 00:06:33
nada más, ahora las veremos 00:06:35
entonces esto en origen 00:06:38
estaba incorporado en todo el JDK 00:06:42
cuando Java era todo Java enterito 00:06:46
Enterito, enterito 00:06:50
Era de Oracle, todo entero 00:06:51
Pues 00:06:53
Hasta el 2017 creo 00:06:55
Por ahí 00:06:59
Ahora ha cedido de parte 00:07:00
Era de Oracle 00:07:03
Pues todas las tecnologías 00:07:05
Asociadas a aplicaciones empresariales 00:07:07
Como esta de JaxB 00:07:12
Como la de los 00:07:14
Enterprise Java Beams 00:07:15
Como todo lo del JPA 00:07:17
que también lo veremos este año, todas las tecnologías asociadas a aplicaciones ya empresariales 00:07:19
con una arquitectura más compleja, todas esas tecnologías estaban incluidas dentro de lo que se llamaba 00:07:25
el Java Enterprise Edition, entonces Java Enterprise Edition era la parte de Java 00:07:31
que incorporaba esas tecnologías más avanzadas, más específicas, aplicaciones que hacían ya acceso a datos 00:07:38
que tenían patrones más complejos 00:07:45
entonces en el 00:07:48
2017, entonces Jax B 00:07:49
era una de esas 00:07:51
y venía 00:07:52
dentro del JDK 00:07:56
y no había que incorporar ninguna 00:07:57
dependencia, ninguna 00:07:59
entonces en el 2017 00:08:01
más o menos, no lo sé 00:08:04
podríamos buscarlo, da igual 00:08:05
en algún momento 00:08:07
después de que vosotros nacierais 00:08:08
eh, verdad que sí, ¿no? 00:08:11
sí 00:08:13
Sí, aquí el más joven de vosotros 00:08:14
que será del 2006, supongo, ¿no? 00:08:19
El 2006 eres tú. 00:08:22
Pues eso, joe, tú eres casi como mi hija. 00:08:23
Dios, qué triste. 00:08:25
¿Por qué? 00:08:27
Bueno. 00:08:31
Es del 2007. 00:08:32
No, del 2008. 00:08:34
Vale, pues aproximadamente por ahí, 00:08:38
en el 2017, cedió 00:08:40
estas tecnologías 00:08:42
Yo creo que ahora a Cleia le daba pereza 00:08:44
Ya tiene demasiados frentes 00:08:46
Y tampoco le daba tanta pasta 00:08:47
Pues te dio esto 00:08:49
¿A quién? 00:08:52
A este que tanto queremos 00:08:53
A la Fundación Eclipse 00:08:55
Que aparte del entorno de desarrollo 00:08:58
Que todos sabemos 00:09:00
El maravilloso éxito que ha tenido 00:09:02
Pues la Fundación Eclipse 00:09:04
Bueno, ¿qué? 00:09:05
¿Qué tienes que decir en contra de él? 00:09:08
No me gusta mucho 00:09:10
Bueno, pues 00:09:11
Es el más extendido, sí 00:09:12
Acabó con NetBeans o prácticamente acabó 00:09:15
Intel IE está ahí, vale 00:09:17
Pero no acaba de sacarlo del mercado tampoco 00:09:19
Bueno, pues a la fundación Eclipse esta 00:09:21
El mérito que tiene 00:09:25
Es que aparte del entorno de desarrollo 00:09:27
Que conocemos 00:09:29
Incorpora una comunidad maravillosa y gigante 00:09:30
De desarrolladores 00:09:33
Y lo que ofrece es libre 00:09:35
¿Vale? Entonces esa parte 00:09:37
Pues se ofrece dentro de toda esa comunidad libre 00:09:39
y se sigue desarrollando 00:09:42
y se sigue desarrollando 00:09:45
pero ¿cuál es el problema? que exclusivamente 00:09:47
por cuestiones de copyright y todas 00:09:49
esas cosas, pues ha tenido 00:09:51
que cambiar de nombre 00:09:53
entonces, ahora se llama 00:09:54
todas estas tecnologías 00:09:57
de Java Enterprise Edition 00:09:59
que ahora 00:10:01
las tiene 00:10:02
que ahora 00:10:04
las tiene 00:10:07
Eclipse 00:10:10
Puedes hacer una nueva página 00:10:10
No, no, no, pero es que quiero 00:10:13
Quería borrar 00:10:16
Puedes borrar con el otro método 00:10:17
Lo veas 00:10:20
Y borras lo que tú quieras 00:10:22
¿Ese cuál es? ¿Este? 00:10:24
Este 00:10:26
Vale, pues 00:10:26
Por temas de copyright 00:10:32
Cuestiones 00:10:34
Cuestiones técnicas 00:10:37
Administrativas, no técnicas de Java 00:10:41
lo que sí que hubo que hacer es cambiarlo de nombre 00:10:43
entonces, ahora ya 00:10:46
se llama Yakarta 00:10:48
Yakarta 00:10:50
Enterprise Edition 00:10:52
¿por qué? pues no lo sé 00:10:53
Yakarta es una isla, ¿no? 00:10:56
claro, pues que es lo más parecido 00:10:58
a la isla de Java, pues la isla de Yakarta 00:11:00
supongo, la verdad es que nunca lo había pensado 00:11:02
pero imagino que vendrá por ahí 00:11:04
es la capital de Indonesia 00:11:05
¿eh? 00:11:06
claro, y el nombre actual de la isla de Java 00:11:10
¿cuál es? 00:11:12
¿Ha cambiado? 00:11:13
Sí, la isla de Java como tal ya no existe 00:11:16
La isla de Java 00:11:18
es donde está Yacarta 00:11:21
Pues no ha cambiado 00:11:23
Bueno, pues escogieron un nombre 00:11:26
para no moverse demasiado de la zona 00:11:29
Vale 00:11:31
No, al contrario 00:11:32
para facilitar las cosas a los desarrolladores 00:11:35
Entonces 00:11:37
¿Eso qué implicaciones tiene? 00:11:38
Pues que si uno está 00:11:42
en la versión 1.8 00:11:43
o anterior, que esté en la anterior 00:11:45
es difícil, que esté en la versión 00:11:47
1.8 es muy 00:11:49
habitual en un contexto 00:11:51
de aplicaciones empresariales, es relativamente 00:11:53
habitual, pues si uno está en la 1.8 00:11:55
sigue usando 00:11:57
Java Enterprise Edition 00:11:59
y eso que implica 00:12:01
que todas las dependencias 00:12:02
asociadas a 00:12:05
frameworks de estas tecnologías 00:12:07
empiezan con 00:12:09
los paquetes empiezan con JavaX 00:12:11
bla bla bla 00:12:13
entonces el nombre de JavaX de hecho nos suena mucho por 00:12:14
swing ¿verdad? las dependencias de swing 00:12:17
empezaban por JavaX 00:12:19
pues JavaX es el prefijo 00:12:21
común 00:12:23
de todas las dependencias, de todas las 00:12:24
tecnologías de Java Enterprise Edition 00:12:27
al cambiar a 00:12:29
ya carta pues hay que cambiar los 00:12:31
nombrecitos pero lo que hay debajo 00:12:33
es lo mismo, salvo las 00:12:35
actualizaciones que van llegando que al final acaban 00:12:37
desmoronando la aplicación 00:12:39
Pues ahora, si está uno por detrás del 1.8 00:12:40
Pasan dos cosas 00:12:44
Primera, que muchas tecnologías ya han salido de la distribución 00:12:46
Luego hay que ponerlas como dependencia externa 00:12:50
Antes de 1.8, Java, JaxB y muchas otras ya estaban incluidas 00:12:52
No necesitábamos dependencia y nada 00:12:57
Prefijo JavaX para los paquetes y ya está 00:12:59
Del 1.8 en adelante se han ido sacando 00:13:01
Entre ellas JaxB, hay que incorporarla ya como dependencia externa 00:13:04
Y además el prefijo común para todas las dependencias que se refieren a estas tecnologías de aplicaciones empresariales ahora es jajacarta, no, jacarta. 00:13:08
entonces, lo digo porque 00:13:22
bueno, para que os vaya sonando, porque hay mucha confusión 00:13:28
entre JavaX, Yakarta, uno a veces ve aplicaciones 00:13:31
y tiene algunas dependencias de JavaX 00:13:34
otras de Yakarta, porque 00:13:37
hay mucho desmadre y mucha confusión mental 00:13:39
incluso en las empresas 00:13:43
y en desarrolladores y en cosas que veo yo por internet 00:13:46
hay mucha confusión mental entre ellos 00:13:49
Bueno, pues que os quede claro a vosotros 00:13:50
Que es cada cosa 00:13:53
Entonces, nosotros 00:13:54
Pues lógicamente deberíamos desarrollar 00:13:57
En versiones posteriores a la 1.8 00:13:59
Aunque a lo mejor si llegáis a una empresa 00:14:01
Tengáis que ir aquí atrás 00:14:03
Y entonces por eso vamos a trabajar 00:14:04
Con dependencias 00:14:07
Que habrá que incorporar desde fuera 00:14:09
Porque ya no están en la jdk 00:14:11
Y encima este 00:14:12
Eso que acabo de quitar 00:14:13
Va a ser 00:14:16
el prefijo común de todas las 00:14:18
tecnologías que 00:14:22
incorporemos, entonces cuando 00:14:23
uno busca el repositorio de maven, claro 00:14:26
maven te ofrece mil cosas, pues algunas serán 00:14:28
ya carta, java, x, pues os situáis rápidamente 00:14:29
a que se refiere cada cosa 00:14:32
¿vale? bueno 00:14:33
después de este rollo 00:14:35
vamos entonces 00:14:38
a probar con 00:14:41
un xml, a este le he dicho 00:14:43
hgpt que sea original y me ha dado 00:14:46
un xml con recetas de cocina 00:14:47
entonces 00:14:49
lo voy a subir a la virtual para que 00:14:50
lo descarguéis y lo uséis vosotros también 00:14:54
ahora como aplicación 00:14:55
de ejemplo, que vamos a hacer 00:14:58
y ya está 00:15:01
vale, a ver bueno 00:15:04
vamos a parar aquí mientras 00:15:38
sin grabar, vale 00:15:40
bueno pues aquí tengo el proyecto, he cambiado a máquina 00:15:41
virtual 00:15:44
voy a abrirlo desde aquí 00:15:45
para tenerlo aquí visualizado ese archivo 00:15:48
siempre, entonces voy a abrirlo desde aquí 00:15:50
vale, pues este es mi fichero xml 00:15:54
lo he abierto desde el editor de texto del eclipse, aunque no está 00:16:04
dentro del workspace, está, bueno 00:16:07
si está dentro del workspace, no mezclemos conceptos 00:16:14
o sea, el workspace no es la carpeta 00:16:18
el workspace es una serie de referencias que hay aquí 00:16:21
pero cada uno de estos puestos en una carpeta distinta 00:16:25
y de hecho 00:16:28
recetario 00:16:29
me habrá 00:16:31
vale 00:16:33
entonces estos proyectos 00:16:39
podrían estar en otra carpeta 00:16:41
diferente a la carpeta por defecto 00:16:43
asociada al workspace 00:16:45
lo he abierto 00:16:46
me he limitado a abrirlo 00:16:51
esto es un editor de texto más 00:16:52
como cualquier otro editor 00:16:53
pues lo puedo usar como editor 00:16:54
y le he dado a abrir 00:16:56
Y lo he buscado por aquí 00:16:57
¿Vale? Entonces lo tengo aquí abierto 00:16:59
Aunque no me aparece aquí 00:17:02
¿Vale? 00:17:03
Aquí no lo tengo, claro 00:17:05
Pero está abierto en este editor de texto 00:17:07
Del Eclipse 00:17:10
Para ver las modificaciones que haga y lo que sea 00:17:10
¿Vale? 00:17:13
Venga, pues vamos a hacer el modelo 00:17:18
De datos 00:17:20
Asociado a estas 00:17:21
A esta 00:17:23
A este XML de aquí 00:17:28
Entonces lo que pasa es que, claro, se ve ahí tan grande 00:17:30
Vemos que hay una clase recetario 00:17:32
Vamos a hacer primero un vistazo por encima 00:17:35
Tendrá una propiedad autor 00:17:37
Esa propiedad autor ya será un string 00:17:39
Directamente 00:17:42
Pero luego tendrá ¿qué? 00:17:43
Pues una colección de recetas 00:17:45
Tiene un montón de recetas 00:17:47
¿Vale? 00:17:48
Receta a su vez será una clase 00:17:51
Porque receta tiene dentro propiedades 00:17:53
Tiene una propiedad string 00:17:55
Y a su vez tiene una colección de ingredientes 00:17:57
E ingredientes también será una clase 00:18:00
Porque ingredientes tiene dentro propiedades 00:18:02
Luego he mencionado así de pasada 00:18:04
Creo que cuatro clases 00:18:06
La clase recetario 00:18:09
La clase receta 00:18:10
Tres 00:18:13
Y la clase ingrediente 00:18:14
Tres clases 00:18:17
Van a mapear esto 00:18:19
Vamos a ir haciéndolas y luego vamos a ir viendo 00:18:20
Como con las anotaciones podemos conectar 00:18:22
Donde va cada una, etc 00:18:24
Vale 00:18:25
Pues nos vamos a hacer 00:18:27
Nuestro paquete 00:18:30
Esto si lo hiciéramos bien 00:18:31
El nombre de nuestro paquete 00:18:34
Tendría que 00:18:36
Estar en coherencia con el identificador 00:18:37
Este del grupo del proyecto 00:18:40
No es que sea obligatorio, no es una restricción 00:18:41
Pero bueno 00:18:44
Esto sería lo normal, lo que nos encontraríamos 00:18:46
Vale, pues yo tengo aquí mi paquete con el modelo 00:18:50
Con el prefijo 00:18:54
Común para todos los paquetes de la empresa 00:18:56
Y ya está 00:18:58
Y ahora, aquí voy a tener mi clase recetario. 00:19:01
Vale, la clase recetario tiene dentro una propiedad autor. 00:19:15
Pero esto ya es directamente una propiedad string. 00:19:20
Porque no tiene más elementos dentro metido. 00:19:23
No tiene más elementos dentro. 00:19:26
Tiene solamente un string. 00:19:27
Luego, autor lo puedo poner como propiedad string sin más. 00:19:29
Podríamos poner el modificador privado. 00:19:39
Porque luego vamos a hacer los getter y setter. 00:19:41
Da igual. 00:19:44
Vale. 00:19:45
Ahora, ¿qué más tiene recetario? 00:19:47
Tiene, ahora ya sí, un montón de cosas de estas, que son recetas. 00:19:49
¿Vale? 00:19:55
Aquí me aparece solo uno en el ejemplo, pero podría tener más, porque de hecho está metido en un nodo recetas. 00:19:56
Luego, receta puede tener muchas. 00:20:02
Entonces va a tener una colección de cosas de estas. 00:20:05
¿Y cada cosa de estas qué va a ser? 00:20:08
Pues a su vez un objeto, porque tiene un montón de cosas dentro. 00:20:10
¿Vale? 00:20:14
Cada receta tiene muchas cosas dentro, desde su atributo hasta todo esto. 00:20:14
Luego tendrá que haber una clase receta por ahí. 00:20:18
Y recetario tendrá una colección de recetas. 00:20:21
Entonces, la clase receta habrá que crearla. 00:20:37
Ahora la creamos, la clase receta. 00:20:43
¿Vale? Por ahora vamos a completar esta con lo mínimo. 00:20:45
Que será... 00:20:49
Poner los get y set. 00:20:50
Vale, vamos a poner lo mínimo. 00:21:03
Y luego según vayamos ejecutando 00:21:05
Pues igual vemos que nos dan errores 00:21:08
Porque nos faltan cosas 00:21:09
Pues lo vamos incorporando 00:21:11
Y así nos vamos familiarizando 00:21:13
Con la forma que tiene de trabajar Jasper 00:21:15
Vale, receta 00:21:16
¿Receta que va a tener dentro? 00:21:19
Pues receta tiene dentro 00:21:22
Nombre de ingredientes 00:21:23
Una cosa 00:21:25
Dificultad que es una propiedad más de ellas 00:21:26
Que es de tipo stream 00:21:29
Dificultad fácil 00:21:31
Pues venga, tendrá esto dentro 00:21:33
Es decir, ¿qué la describe? 00:21:35
La describe 00:21:38
Una cosa que es 00:21:39
Dificultad 00:21:43
Que es un atributo, pero da igual 00:21:44
La describe también a la receta 00:21:47
¿Qué más? La describe un nombre 00:21:49
Un nombre que ya directamente es un string 00:21:51
Pues venga 00:21:54
String 00:21:55
Nombre 00:21:58
qué más describe a la receta 00:22:00
pues un montón 00:22:07
de cosas ingrediente 00:22:09
y cada cosa ingrediente 00:22:11
a su vez es un objeto porque tiene cosas dentro 00:22:13
vale, pues entonces tendrá una lista 00:22:15
de ingrediente 00:22:30
ingredientes 00:22:31
vale 00:22:43
entonces ingrediente habrá que crearlo 00:22:43
Ya lo crearemos 00:22:47
Ya crearemos ingrediente 00:22:50
Y por lo pronto vamos a terminar esta con lo básico 00:22:53
Que lo básico en cualquier entidad de un modelo 00:22:56
Son Getter y Setter por supuesto 00:23:03
Y ahora nos falta ingrediente 00:23:04
¿Qué ingrediente? ¿Qué tiene dentro? 00:23:17
Pues ingrediente tiene tres cosas 00:23:19
Nombre, cantidad y unidad 00:23:21
que esta podría ser un string 00:23:24
esta puede ser 00:23:26
un double, es un double 00:23:28
y unidad pues un string 00:23:30
también, pues venga 00:23:32
entonces ingrediente va a tener dentro 00:23:34
el nombre del ingrediente 00:23:36
la cantidad 00:23:42
se llamaba 00:23:45
que hemos dicho que un double le pega 00:23:46
la unidad 00:23:53
en la que está medida la cantidad 00:23:56
que esto pues 00:23:58
String unidad 00:24:02
Vale, pues estas tres 00:24:04
Clases, recetario 00:24:18
Con su lista de recetas y el autor del recetario 00:24:20
Receta con su 00:24:23
Dificultad, su nombre y su lista de ingredientes 00:24:24
E ingrediente 00:24:27
Con sus tres propiedades 00:24:28
Son exactamente 00:24:30
Este recetario de aquí, lo mismo 00:24:32
Ah, perdón, no lo he visto 00:24:34
¿Dónde está? 00:24:37
Ah, que ingrediente 00:24:37
Tiene un ID, vale 00:24:39
Pues entonces al ingrediente le falta aquí 00:24:41
Un ID 00:24:44
Que se lo añadimos 00:24:46
Como 00:24:49
Me lo ha mezclado ahí en medio, da igual 00:24:50
Vale 00:25:00
Vale 00:25:00
Entonces, JaxB ya sería capaz de 00:25:02
Si yo creo 00:25:06
Estoy trabajando con recetarios 00:25:07
Recetas, tengo 00:25:10
Pues lo he leído en una base de datos 00:25:11
Lo he pedido por teclado, he modificado 00:25:13
Ya sería capaz de 00:25:15
Parsear esto al XML 00:25:16
En el momento en el que yo decida 00:25:19
Pues no, porque le faltan 00:25:21
Le falta información 00:25:23
Del tipo, oye, ¿y esto dónde va? 00:25:25
¿Esto cómo se llama? 00:25:29
¿Esto es un atributo o no es un atributo? 00:25:30
¿Esto va dentro de un nodo 00:25:32
Que lo envuelve recetas o no? 00:25:33
Le falta información para construirlo 00:25:35
¿Vale? Pues esa información 00:25:37
La vamos a dar con anotaciones 00:25:39
¿Vale? Recordad que las anotaciones 00:25:41
Eran esa cosa 00:25:44
que ya hemos usado en situaciones básicas 00:25:45
como para el overwrite 00:25:47
para indicarse un método 00:25:49
sobreescrible de la superclase 00:25:51
y las anotaciones no son comentarios 00:25:55
porque el compilador por supuesto las tiene en cuenta 00:25:59
las anotaciones se corresponden a clases 00:26:04
porque tienen mucha información 00:26:05
entonces cuando el compilador ve una anotación 00:26:06
tiene que mirar dentro de esa clase 00:26:09
para ver si todo es coherente con el resto del código 00:26:12
Entonces, anotaciones que va a necesitar JaxB 00:26:15
Pues tiene unas cuantas, tiene muchas anotaciones 00:26:20
Para hacer cosas muy sofisticadas con JaxB 00:26:22
Pero lo básico, pues es 00:26:25
Primera cosa que necesita saber 00:26:27
¿Cuál es la clase raíz? 00:26:30
¿Cuál es la raíz de cuál parto yo para construir mi XML? 00:26:33
Recetario 00:26:37
Pues entonces esta clase la tenemos que anotar 00:26:38
con la anotación xml 00:26:42
root element 00:26:44
esta es básica 00:26:46
vale 00:26:48
tenemos que anotarla 00:26:49
con esta anotación para decir 00:26:52
esta es la clase raíz 00:26:53
pero esta es una clase 00:26:56
que no la encuentra 00:26:57
vale, porque estoy en una versión 00:26:59
la 21 en la cual ya 00:27:02
se ha sacado 00:27:04
la tecnología 00:27:06
yaxbe, entonces la tengo que incorporar 00:27:08
como dependencia externa 00:27:10
Esto ya forma las anotaciones 00:27:11
Junto con las clases que usemos ahora 00:27:14
Para hacer el parseo 00:27:17
Forman parte de JaxB 00:27:19
Y están fuera ya del JDK 00:27:20
Entonces tenemos que 00:27:22
Incorporar la dependencia 00:27:25
Pues nada, es que a nuestro POM este de aquí abajo 00:27:26
Que lo tenemos ahí vacío 00:27:29
Y olvidado 00:27:31
Le faltan aquí 00:27:31
Vamos a quitarle el rojito 00:27:33
Poniéndole la S aquí 00:27:36
Le quitamos el 00:27:39
Ah, vale, decía con una guanita al rojo 00:27:42
Que estaba mirando en otro sitio 00:27:47
Vale, pues a este 00:27:48
POM le faltan 00:27:51
Le faltan aquí las dependencias 00:27:53
De JaxB 00:27:58
Entonces, sí 00:27:59
Sí 00:28:03
Entonces 00:28:05
Como siempre 00:28:07
Esto 00:28:09
Los frameworks en general siempre se estructuran 00:28:11
Una API y una implementación 00:28:14
Esa como idea general 00:28:16
Una API que tendrá 00:28:18
Los métodos vacíos 00:28:19
Y las anotaciones que especifican las cosas 00:28:21
Y una implementación 00:28:24
Pues aquí igual 00:28:25
Vamos a por la dependencia y luego paramos un poco 00:28:27
Nos vamos al 00:28:29
Repositorio 00:28:32
De Maven 00:28:35
Bueno, venga, vamos a parar aquí 00:28:36
No vaya a ser que nos estendamos buscando 00:28:42
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:
17
Fecha:
22 de octubre de 2025 - 10:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 46″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
130.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid