Saltar navegación

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

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Tendríamos dos opciones, la A y la B, y seguro 00:00:00
que la A nos gusta y la B sí. 00:00:01
La A, pues sería 00:00:04
desde el XML hacer el esquema 00:00:06
a mano, que sabéis 00:00:07
porque habéis estudiado 00:00:10
esquemas el año pasado y sabéis hacerlo, 00:00:11
pues es el Complex Diver y poniendo la 00:00:13
Sequence, si es una lista, el Unbounded 00:00:15
Unlimited, el todo, 00:00:17
el Unbounded no sé qué, sabéis 00:00:19
hacer un esquema. 00:00:21
Vale, pero bueno, no podemos 00:00:23
repasarlo todo, entonces 00:00:25
pues seguramente preferir la opción B 00:00:27
Que generarlo 00:00:29
Automáticamente a alguna herramienta online 00:00:30
¿Verdad? Lo sabía 00:00:33
Vale, entonces, por curiosidad 00:00:34
¿Qué herramientas online usáis vosotros 00:00:37
Para generar? Porque yo, el otro día 00:00:39
Cuando lo generé, puse la primera 00:00:41
Que me salió en Google, porque yo no trabajo 00:00:43
Con NXML normalmente 00:00:45
Y sí, me salió el esquema, pero 00:00:46
Me salió un poco feo 00:00:49
¿Qué herramientas usáis vosotros para 00:00:51
De hecho 00:00:55
Más que feo, me salió mal 00:00:57
lo tuve que cambiar porque no había 00:00:58
generar xml 00:01:00
xsd 00:01:01
desde xml 00:01:04
¿El año pasado 00:01:06
usabais alguna herramienta en concreto? 00:01:08
Yo usé alguna, pero no me acuerdo 00:01:11
Yo he probado varias 00:01:12
Pero en clase, ¿en ningún momento generasteis 00:01:14
esquemas con las herramientas online? 00:01:16
No, de hecho es que nos mandó un porro 00:01:18
donde tal vez dijo, bueno, hacerlas 00:01:20
Como no había tiempo, nos mandó 00:01:22
Vale, pues bueno 00:01:24
Uno puede usar una herramienta cualquiera de estas 00:01:28
O como yo ya lo generé el otro día 00:01:31
Pues coger el mío y ya está 00:01:34
¿Qué era? 00:01:36
Si hubierais dicho el de recetario 00:01:38
Eso no lo tenía 00:01:39
Pero bueno, lo hubiéramos generado y ya está 00:01:40
¿Qué? ¿Dónde lo tengo? 00:01:41
Mezco tonta 00:01:47
Ah, estoy en el de abajo 00:01:48
Vale 00:01:53
Ah, esquemas, lo tengo aquí 00:01:55
Vale 00:02:01
Tengo que hacerlo en inglés 00:02:02
Vale, pues voy a subirlo 00:02:06
Bueno, a ver, voy al botón derecho 00:02:08
Guardar enlace como, ¿vale? 00:02:10
Muy bien 00:02:13
Y ponerlo donde queráis 00:02:16
Pues en la carpeta 00:02:21
SRC Main Resources 00:02:23
Si queréis, os abrís una 00:02:24
Que sea esquemas 00:02:26
Y lo guardáis en esquemas, donde queráis 00:02:27
¿Vale? Entonces 00:02:30
Yo me lo voy a abrir en una carpeta 00:02:31
Y ahí me lo pongo 00:02:35
ahí no está 00:02:44
está nuestro esquemita 00:03:01
entonces efectivamente 00:03:04
es un poco feo 00:03:06
porque no lo ha hecho 00:03:09
generando los tipos aparte 00:03:10
al no haber generado los tipos aparte 00:03:11
al no haber hecho un tile 00:03:14
y luego haber hecho referencia al tile 00:03:16
pues le queda un nivel de anidamiento horroroso 00:03:18
claro 00:03:20
pero bueno 00:03:21
pero lo entendemos 00:03:22
lo entendéis que es lo que importa 00:03:26
universidad es una lista 00:03:27
de facultades 00:03:30
facultades a su vez es una lista 00:03:31
de facultad 00:03:33
de hecho 00:03:39
de hecho 00:03:41
no está bien este esquema 00:03:46
porque 00:03:49
como el xml que le pasé 00:03:49
para generarlo solo tenía 00:03:52
ah no no perdón perdón 00:03:54
perdón facultades es el nodo envolvente 00:03:56
que es solo uno perdón perdón está bien 00:03:58
que tienen varias 00:04:00
Tiene un montón de facultades, por eso facultades es unbounded este. Y ahora ya tiene el envolvente carreras, que tiene un montón de carreras. Y luego ya cada carrera tiene nombre, departamento y estudiantes, que es el envolvente de estudiante, que puede tener muchos cada carrera. 00:04:01
y cada estudiante tiene su nombre, su edad y su email 00:04:20
y un envolvente de materias que puede contener muchas materias. 00:04:29
Cada materia con su nombre, nota y código. 00:04:35
Algunos de ellos son atributos además. 00:04:39
Bueno, pues esto sí, lo podríamos haber hecho. 00:04:42
Este es el atributo del estudiante, creo. 00:04:45
No sé, ya he perdido la... 00:04:47
y podríamos haberlo hecho a mano 00:04:49
lógicamente, pero bueno, se hace un poquito 00:04:52
pesado hacerlo a mano 00:04:54
entonces 00:04:56
lo único 00:04:57
cuidado con las herramientas que lo generan online 00:05:00
porque 00:05:02
a mí claro, como el XML que le pasé 00:05:05
creo que solo tenía un estudiante 00:05:08
o solo tenía una facultad, no sé, entonces 00:05:10
él no interpretó que podía tener varias 00:05:12
entonces le tuve que añadir 00:05:14
el maxocus este para que 00:05:17
incorporara que podía tener más de una 00:05:19
pero bueno, salvo por ese detalle 00:05:21
lo normal es que lo genere bien 00:05:23
vale, pues si tenemos el esquema 00:05:25
ahora ya la herramienta 00:05:28
esta xjc 00:05:30
bueno, pues la herramienta 00:05:31
xjc 00:05:42
que es otro conjunto de clases 00:05:43
es la que nos permite 00:05:45
a través de un 00:05:47
a partir de un XSD generar las clases 00:05:49
JaxB 00:05:51
entonces el otro día ya dijimos que podíamos 00:05:52
invocarla desde consola 00:05:55
pues XJC 00:05:57
claro, habría que ponerse en la ruta 00:05:59
donde está el bin de XJC 00:06:01
que no está dentro del JDK 00:06:03
porque desde Java 11 00:06:05
la tecnología 00:06:07
de JaxB ha salido de la máquina 00:06:11
virtual, entonces 00:06:13
XJC tendría que descargarlo como 00:06:14
un JAR o como dependencia como haremos nosotros 00:06:17
y si yo ya lo añado al pad 00:06:19
pues entonces puedo invocar al comando 00:06:21
claro, si he añadido al pad 00:06:23
ese hard y lo invoco 00:06:25
le doy el XSD 00:06:27
y me genera las clases y ya está 00:06:29
pero si estamos trabajando con el Eclipse 00:06:31
pues hombre 00:06:34
podemos usar el plugin que me da Eclipse 00:06:35
y ese plugin 00:06:37
¿cómo lo invocamos? 00:06:39
pues nos ponemos en el 00:06:41
ah, perdón 00:06:43
nos ponemos en el botón 00:06:45
derecho del esquema 00:06:47
y en algún momento nos sale 00:06:49
el generar 00:06:53
y aquí yo puedo generar las clases 00:06:55
yaxb o un xml file de ejemplo 00:06:59
si quiero 00:07:01
genero las clases yaxb 00:07:02
y el ya 00:07:04
vale 00:07:06
lo quiero aquí 00:07:08
pues las quiero aquí 00:07:10
y esto lo dejamos todo por defecto 00:07:13
defecto. Podríamos empezar a entrar a ver qué significa cada una. Tendríamos dos problemas. 00:07:20
Uno, que la mayoría de las cosas no lo sé. Dos, que perderíamos mucho tiempo. Entonces, 00:07:26
en la operativa nuestra de trabajo, pues si no funciona con las opciones por defecto, 00:07:31
así nos quedamos y ya está. Vale. Puede que sobre escribas las clases que ya tenías. 00:07:35
¿No te importa? No, hombre, no me importa. Y ¡pum! Claro, normal. ¿Vale? ¿Qué es 00:07:48
lo que me está diciendo? Rápido. 00:07:56
Ya, pero ¿qué es lo del 00:07:59
XJC? ¿Qué me está diciendo? Traducidmelo a mi 00:08:00
idioma. 00:08:02
Ya, pero ¿qué me está diciendo? 00:08:04
¿Qué hay que importar? 00:08:06
¿Qué me está diciendo? 00:08:09
¿Que le falta la dependencia? 00:08:10
Pues eso, ¿vale? No es que haya que importar. 00:08:12
Tú importas cuando ya tienes la dependencia integrada 00:08:14
en tu proyecto. Eso es lo que me está diciendo. 00:08:16
¿Vale? 00:08:18
Entonces, en cuanto 00:08:19
al class not found exception, 00:08:20
ahora ya en nuestro idioma es 00:08:23
Al POM le faltan cosas 00:08:24
Al POM le faltan cosas 00:08:27
Traducido a nuestro idioma 00:08:28
Pues sí, es que nuestro POM efectivamente 00:08:30
Le hemos dejado aquí 00:08:32
Más solo 00:08:34
Que es que no tiene ahí nada de nada 00:08:35
No le hemos quitado ni el rojito 00:08:39
Que eso ya sí que 00:08:41
Ah, no era ese 00:08:43
Me he equivocado de ese 00:08:47
Era este 00:08:48
No le hemos quitado ni el rojo 00:08:50
Vale 00:08:55
¿Cómo que ni te sale? 00:08:55
¿No te sale el rojo? 00:09:00
¿Sin la S puesta? 00:09:02
Pues no lo sé 00:09:11
Alguna combinación extraña de versiones 00:09:12
Que tienes en tu arquitectura 00:09:15
Vale, entonces 00:09:16
La dependencia de JaxB lógicamente nos falta 00:09:20
Porque vamos a trabajar con las anotaciones 00:09:23
Las clases generadas 00:09:25
Van a tener las anotaciones 00:09:26
Si no está en la dependencia de JaxB 00:09:28
Esas anotaciones no van a 00:09:31
Poder ser resueltas 00:09:33
Bueno, pero es que eso ya lo sabemos de memoria 00:09:35
Y eso lo copiamos de 00:09:38
Otro proyecto 00:09:39
Claro que lo tenéis en el otro Eclipse 00:09:40
Eso 00:09:42
Eran la API 00:09:46
Que era esta de aquí 00:09:50
La API que era esta y luego la 00:09:51
Runtime que era la implementada 00:09:58
¿Eh? 00:10:00
Te coge todos los proyectos 00:10:01
O sea que no hay problema 00:10:03
Ah, bueno, sí, sí 00:10:04
Pero lo tienes que abrir 00:10:06
Ah, que estás usando el mismo workspace, te refieres 00:10:07
Sí 00:10:10
Y la otra 00:10:17
Que es 00:10:19
Implementación 00:10:23
Vale 00:10:24
Esta por lo menos nos falta 00:10:26
Pero si uno 00:10:34
Si volvemos a intentar 00:10:41
Generarlo 00:10:43
Pongo cualquier cosa 00:10:44
Porque nos va a salir error, da lo mismo 00:10:53
No, no, no, perdona 00:10:54
He debido irme al proyecto que no es 00:11:05
Efectivamente 00:11:08
Vale 00:11:10
Lo que sea 00:11:15
Me da igual 00:11:23
Vale, nos sigue diciendo lo mismo 00:11:24
Claro, entonces 00:11:33
Ah, es que x, j, c 00:11:35
No me he acordado 00:11:37
No me he dado cuenta 00:11:39
de que, espérate, es una tecnología 00:11:40
diferente, vale 00:11:43
son situaciones típicas que nos pasan 00:11:44
es que es otra tecnología, aunque tenga que ver con JaxB 00:11:46
entonces va a ser que está en otro lado 00:11:48
va a ser que está en otro lado 00:11:51
bueno, pues uno se pone a buscar 00:11:52
si está completamente perdido 00:11:55
pues claro, tiene que buscar en el repositorio 00:11:57
de Maven, pero lo 00:11:59
claro, pero lo normal es que 00:12:00
tú partas ya de un proyecto base 00:12:02
y lo puedas copiar 00:12:04
vamos a, antes de ponerla 00:12:06
A ver si el repositorio de Maven 00:12:08
Nos 00:12:16
Vale, pues aquí buscaríamos 00:12:17
Por lo que sabemos 00:12:25
Que es XJC, es lo único que 00:12:27
XJC 00:12:30
Nosotros nos vamos siempre a lo moderno 00:12:33
Pues vámonos a esta, ¿no? 00:12:35
Venga 00:12:38
Vamos a esta 00:12:39
Septiembre del 2025 00:12:44
Ahí nos vamos 00:12:48
copiamos 00:12:50
y otra vez 00:12:52
aquí 00:12:57
vale 00:12:57
entonces después de grabar 00:13:06
tendremos aquí 00:13:10
la dependencia de maven 00:13:12
en las dependencias de maven 00:13:14
ya se nos ha metido ahí la leche 00:13:16
entre ellas 00:13:18
de xbx, jc, esta de aquí 00:13:21
y algunas de las que tira 00:13:22
vale 00:13:24
es que plantearse hacer cualquier cosita 00:13:25
Ya sin Maven es una locura 00:13:28
Porque Maven ya sabe 00:13:29
Que cuando tú buscas una dependencia 00:13:31
Esa va a depender de muchas otras 00:13:34
Y te las descarga también 00:13:36
Si no tendrías que hacer tú el rastreo 00:13:37
De hecho aquí pues 00:13:43
Aquí las tenemos 00:13:45
Ahora ya sí 00:13:48
Me genera las clases 00:13:51
Voy a borrarlas 00:13:52
Porque 00:13:55
Ah por cierto yo no la he cambiado 00:13:56
Voy a cambiarla 00:14:07
Esto siempre se me olvida 00:14:10
La máquina virtual 00:14:13
Y el nivel de compilación 00:14:16
Es que tú tienes un problema 00:14:17
Con las rutas, con el classpath 00:14:20
Por eso es por lo que 00:14:22
Por eso digo 00:14:23
Que tú tienes un problema con el 00:14:26
Pero bueno, solo cambias con el classpath 00:14:27
Entonces por eso ese clip se no te reconoce nada 00:14:29
Pero ahora lo ponemos 00:14:32
Vale, entonces yo que iba a hacer 00:14:34
Cambiar el 00:14:36
el nivel este de compilación 00:14:37
al, en mi caso 00:14:41
es el 22, no es el vuestro 00:14:43
máquina última es la 22 00:14:45
vale, vamos a verificar que ahora salen 00:14:50
y si a alguno no le sale lo miramos 00:14:52
rápidamente y luego las 00:14:54
pues ahora ya si, generamos 00:14:55
las clases jacks b 00:14:58
en que paquete 00:15:00
pues en este, que es donde 00:15:04
va a estar el modelo de clases 00:15:09
todo esto 00:15:11
lo dejamos igual, bla bla bla 00:15:13
Vale, o sea, ha generado a todo el mundo 00:15:15
Dos miserillas clases en lugar de las tropecientas 00:15:25
Que hacíamos nosotros 00:15:28
Una por entidad 00:15:30
¿De dónde te la tienen que decir? 00:15:32
En el nombre de paquete que tú le hayas dicho 00:15:37
Que si no existe te lo crea 00:15:39
Vale 00:15:41
Y tú ahí, pues 00:15:43
Vamos a ver 00:15:45
No, no, pero espera 00:15:49
Bueno, a ver, lo que no tienes es incorporar 00:15:56
Las par 00:15:59
No, pero ayer el proyecto 00:15:59
Vamos a ver 00:16:02
Vamos a ver 00:16:14
Cómo le arreglamos el problema 00:16:17
A este muchacho 00:16:20
Vale, entonces lo puede hacer un poquito más legible 00:16:22
Porque están todas arriba juntitas 00:16:29
No tienes que ir buscando en cada get 00:16:30
¿Vale? Pero tienes que poner esto antes 00:16:32
Para que JaxB 00:16:35
Se entere de que tiene que ir aquí 00:16:36
No lo tiene que obtener desde el get 00:16:38
¿Vale? Esto ya sabemos lo que es 00:16:40
Esto ya sabemos lo que es 00:16:43
Y aquí ya 00:16:45
Lo empieza a anotar en anotaciones que conocemos 00:16:47
Pues esta es la 00:16:48
Facultades que es un elemento 00:16:49
Este es el atributo 00:16:52
De universidad 00:16:55
De la clase universidad 00:16:58
Y así todo 00:16:59
¿Qué es lo que cambia? Lo hace de tal manera que las genera como clases internas. Entonces, a ver, esto está bien en realidad si estas entidades las vas a usar solamente para la parte de acceso al fichero, porque lo tienes todo ahí compacto en una sola clase y ya está. 00:17:01
pero si forman parte de tu modelo 00:17:24
para el resto de la aplicación 00:17:26
que interacciona con otras cosas, pues hombre 00:17:27
las entidades de un modelo 00:17:30
están siempre por separado 00:17:31
¿vale? 00:17:34
entonces, puede 00:17:36
que en alguna de las cosas 00:17:38
que yo he dicho 00:17:40
aquí lo ponemos todo por defecto 00:17:41
seguramente, no estoy segura 00:17:44
podríais investigar si quisierais, tampoco 00:17:45
creo que con XML debáis perder mucho tiempo 00:17:47
porque bueno, los XML 00:17:50
ya ahora mismo llegan hasta donde llegan 00:17:52
seguramente cambiando alguna de esos 00:17:54
check, pues te las genera 00:17:57
como clases separadas 00:17:59
¿vale? pero yo he preferido 00:18:01
que las genere como internas 00:18:03
para que recordemos 00:18:05
brevemente en 5 minutos, por si alguien no lo tiene 00:18:07
fresco, lo de las clases internas 00:18:09
porque es 00:18:11
una forma de organizar las clases que se usa 00:18:12
a veces en ciertos contextos 00:18:15
y si alguien no lo tiene claro 00:18:17
pues conviene recordarlo 00:18:18
¿vale? 00:18:21
Entonces, la clase universidad tiene dos propiedades que están anotadas y una de las propiedades que es facultades es una clase interna de universidad que está aquí dentro, ¿veis? 00:18:22
esta clase está dentro 00:18:47
de la otra, está dentro 00:18:50
y una clase interna 00:18:52
puede ser estática 00:18:54
una clase interna es el único 00:18:56
caso de clase 00:18:58
que puede recibir un 00:19:00
modificador estático, porque en ese contexto 00:19:02
tiene sentido 00:19:04
¿recordáis mínimamente 00:19:04
lo de las clases internas, clases estáticas 00:19:08
o algo así? 00:19:10
no hace falta ni que repasemos nada 00:19:11
de las clases 00:19:13
internas porque eran como se usaban 00:19:16
y cuando son estáticas y cuando no 00:19:18
ah, creía que decías 00:19:20
sí, sí, lo recuerdo perfectamente 00:19:22
bueno, pues venga 00:19:23
vamos a recordarlo en 5 minutos 00:19:26
porque lo podemos encontrar en otros contextos 00:19:28
¿qué? 00:19:30
a ver 00:19:34
pues vamos a hacer un proyecto normal 00:19:35
este no hace falta que sea Moven, Maven, porque es para 00:19:38
jodida 00:19:40
Moven, no hace falta que sea, joe, aquí es que 00:19:42
hombre 00:19:44
Has triunfado 00:19:45
No hace falta, ahora lo 00:19:48
Vale 00:19:50
Lo que cuesta aquí 00:19:51
Encontrar un proyecto normal y corriente 00:19:54
Lo voy a tener que hacer en other 00:19:56
Y ya está, other 00:19:57
En java 00:19:59
Java 00:20:02
Un proyecto normal y corriente 00:20:04
Un proyecto java project normal 00:20:05
Para hacerlo de las clases internas 00:20:07
Para recordarlo 00:20:09
Vale 00:20:10
Recordatorio 00:20:15
Recordatorio 00:20:19
Clases internas 00:20:21
Vale, y con esto, interpretando un poquito 00:20:25
Luego esas clases 00:20:32
Y mencionando unas cuantas cosas más 00:20:33
Los XML los vamos a dar por 00:20:35
Ventilados 00:20:37
Vale, está en la perspectiva 00:20:39
De aplicaciones 00:20:46
Web, empresariales 00:20:48
Entonces me dice, ¿quieres que te hable la perspectiva normalita 00:20:50
Y corrientita de toda la vida? 00:20:52
Pues sí, esta perspectiva ya es la igualita del otro eclipse, es la perspectiva que se olvida de aplicaciones empresariales, me ha quitado el icono de explorador web, de hecho, y me ha quitado un montón de cosas. 00:20:54
Bueno, pues a ver 00:21:08
Vale, pues por ejemplo 00:21:11
Vamos a hacer una clase normal y corriente 00:21:21
Una clase que sea 00:21:23
La clase 00:21:25
Instituto, por ejemplo 00:21:26
Yo que sé 00:21:33
Vale, entonces 00:21:34
Esta clase 00:21:44
Pues puede tener sus propiedades 00:21:46
Como siempre 00:21:48
Y ahora podría tener una propiedad más 00:21:49
Que fuera 00:21:55
la secretaría, que a su vez 00:21:56
tiene, ¿verdad? 00:21:58
Podría tener una propiedad secretaría 00:22:02
con todos los 00:22:04
detalles de la secretaría, para lo cual 00:22:06
habría una clase aparte que fuera 00:22:08
clase secretaría, como siempre. Hemos diseñado, 00:22:10
¿verdad? Entonces, bueno, ese diseño 00:22:12
es relativamente habitual, es el que 00:22:14
estamos acostumbrados. Una clase por 00:22:16
entidad y ya está. Y luego 00:22:18
relaciones entre ellas, porque unas contienen 00:22:20
a otras. Diseño el que estamos acostumbrados. 00:22:22
Pero bueno, 00:22:25
ese diseño implica 00:22:25
que pueden existir secretarías 00:22:28
por el mundo sin que haya 00:22:31
institutos 00:22:32
en función de 00:22:33
cómo programe uno la aplicación 00:22:36
podría darse una situación 00:22:38
que a lo mejor no tiene mucho sentido 00:22:40
que es que existan objetos secretaría 00:22:42
a los que se le puedan pedir 00:22:45
funcionalidades 00:22:46
pero es una estupidez 00:22:47
que eso se dé porque no puede existir 00:22:51
una secretaría en medio de la calle si no está dentro 00:22:52
de un instituto, claro 00:22:54
entonces si queremos recoger eso 00:22:56
para que nuestra aplicación 00:22:59
de alguna manera se adapte 00:23:01
a esa situación y por tanto 00:23:03
programemos en consecuencia 00:23:05
y se nos faciliten ciertas cosas 00:23:06
vale, pues en lugar 00:23:08
de programarlo así como una referencia 00:23:10
a una clase aparte 00:23:13
podemos hacerlo 00:23:14
como clase interna 00:23:17
claro, pero tendría, y que significa 00:23:25
requerir un instituto, buscar 00:23:27
los objetos existentes 00:23:29
Claro, pero 00:23:31
¿Dónde sacas el instituto? 00:23:34
Se lo pasas al constructor por parámetros 00:23:39
El constructor de secretaría necesite 00:23:40
Obligatoriamente que le pases un instituto 00:23:42
Sí, bueno, puedes hacer muchas posibilidades 00:23:44
Efectivamente 00:23:52
Vale, entonces, pues nada, esto me da igual 00:23:53
Pues tendría su 00:23:56
Yo que sé 00:23:57
El director de la secretaría 00:24:01
Y cualquier chorrada y ya está 00:24:03
Bueno, no merece la pena 00:24:04
Ni Getter ni Setter ni nada 00:24:10
Porque para lo que vamos a repasar 00:24:11
Quito esto, no pongo Getter y Setter 00:24:12
Porque para lo que vamos a repasar 00:24:16
Vale, pues entonces 00:24:17
Esta es una clase interna, una clase que va dentro de otra 00:24:19
Luego dentro de una clase 00:24:22
Ahora ya hay cuatro cosas 00:24:23
Que puede haber 00:24:25
Propiedades 00:24:26
Métodos 00:24:28
bloque static y clases internas, ¿vale? 00:24:30
Esas son las cuatro cosas que puede haber. 00:24:35
Recordad que el bloque static es esto. 00:24:37
El bloque static es un bloque con static delante 00:24:42
donde aquí puede haber sentencias 00:24:48
que trabajen solo con propiedades estáticas, ¿vale? 00:24:52
Por ejemplo, a lo mejor aquí yo tengo una propiedad estática 00:24:56
que afecta a todos los institutos, que es la comunidad, comunidad autónoma. 00:24:59
Entonces, en mi aplicación, todos los institutos pertenecen a la misma comunidad. 00:25:11
Pero bueno, esta aplicación puede funcionar en diferentes comunidades autónomas, 00:25:20
con lo cual esto lo pongo como variable. 00:25:24
Pero claro, lo pongo como variable estática, porque todos van a pertenecer a la misma. 00:25:25
Aunque en función de donde se arranque la aplicación el contenido pueda ser distinto 00:25:30
Pero común para todos los institutos 00:25:35
Entonces en el bloque estático, pues aquí puede haber sentencias y cualquier cosa 00:25:38
Puede haber cualquier código que afecte a las variables estáticas 00:25:43
Entonces, ¿cuándo se ejecuta el bloque estático? 00:25:56
La primera vez que se hace referencia a esa clase 00:25:59
Bien para instanciar un objeto instituto 00:26:02
Bien para acceder a alguna de sus propiedades estáticas 00:26:04
En cuanto se haga referencia a esta clase por primera vez 00:26:08
Automáticamente aparecen las variables estáticas y se ejecuta esto 00:26:13
Bueno, esto era por completar 00:26:17
Ahora ya sabemos, después de dos años por fin 00:26:18
Las cuatro cosas que puede haber dentro de una clase 00:26:21
Vale, pero ahora la que nos interesa aquí es la clase interna 00:26:23
Entonces, diseñar la secretaría como clase interna 00:26:26
Nos permite ahora en nuestro main 00:26:31
Yo tengo ya mi aplicación 00:26:33
Y ahora pues me hago 00:26:36
Un instituto 00:26:41
Vale, al instituto le puedo poner 00:26:42
Nombre, así directamente 00:26:56
Ver este acceso 00:26:59
Así ya hace daño 00:27:01
Al corazón 00:27:02
Ya no acostumbra uno a los getty eso 00:27:04
Ver un acceso así 00:27:06
Pero bueno, vamos a ahorrarnos tiempo 00:27:08
Instituto tenía nombre 00:27:10
¿No? Porque me dice 00:27:13
instituto.nombre 00:27:14
pues igual a lo que sea 00:27:19
vale, y ahora yo voy a instanciar 00:27:20
una secretaría, efectivamente la secretaría 00:27:27
no la puedo instanciar por libre 00:27:29
no puedo hacer esto 00:27:31
con el 00:27:32
otro modelo de diseño que la clase 00:27:37
secretaría forma parte del modelo 00:27:40
como entidad aparte, yo podría 00:27:41
hacer esto 00:27:43
entonces, esto a lo mejor podría 00:27:44
generar en una aplicación muy 00:27:48
gordota que se va ampliando, poniendo 00:27:50
parches y parches, el hecho 00:27:52
de que esto se pueda hacer 00:27:54
podría generar un efecto secundario 00:27:55
indeseado, ¿vale? 00:27:58
Entonces en nuestras aplicaciones queremos que tengan 00:27:59
los mínimos efectos secundarios indeseados 00:28:01
entonces que exista una secretaría ahí suelta 00:28:03
a lo mejor genera un 00:28:05
funcionamiento incoherente 00:28:07
de la aplicación, pues si yo 00:28:09
la he 00:28:11
declarado así como clase interna 00:28:13
en lugar de como propiedad y clase aparte 00:28:17
solamente puedo instanciar una secretaría asociada a un instituto, ¿vale? 00:28:19
Solamente asociada a un instituto. 00:28:29
Tengo que tener un objeto instituto ya creado 00:28:32
y una vez que tengo un objeto instituto ya creado puedo instanciar una secretaría. 00:28:36
Y este objeto automáticamente, aparte de existir, está vinculado a este instituto. 00:28:41
Lo que pasa es que el nombre de la clase 00:28:45
Perdón, perdón 00:28:48
No quiero que lo haga con in porque no se ve bien 00:28:52
El nombre de la clase interna 00:28:54
Cambia, el nombre de la clase interna 00:28:56
Ahora es compuesto 00:28:58
¿Vale? Una clase interna 00:28:58
Su nombre es el suyo 00:29:02
Más el de la 00:29:04
Superclase, no, porque no hereda de ella 00:29:05
Más el de la clase que lo contiene 00:29:08
Y secretaría podría tener otra clase interna 00:29:09
secretaría podría tener aquí otra clase 00:29:19
dentro de la secretaría podría tener 00:29:21
una clase directores 00:29:23
yo lo he hecho aquí como string, pero podría haber 00:29:25
quitado eso y haber hecho una clase interna director 00:29:27
para que no pueda haber directores sueltos 00:29:29
tengan que existir una secretaría 00:29:30
dentro de un instituto, o sea eso 00:29:33
las clases internas se pueden anidar hasta el infinito 00:29:34
pero como de costumbre no queremos 00:29:37
hacer aplicaciones para liar 00:29:39
o para lucirnos, sino 00:29:40
para que sean lo más entendibles posibles 00:29:43
vale, pues entonces 00:29:45
en cuanto a las clases internas normales y corrientes 00:29:47
no estáticas, ya está 00:29:49
no hay más que saber 00:29:51
uno las puede usar 00:29:52
en las situaciones en las que quiera 00:29:54
evitar que proliferen objetos 00:29:56
que no tienen sentido que existan 00:29:59
si no está el que los contiene 00:30:03
entonces 00:30:05
aquí 00:30:06
esto tiene sentido 00:30:08
tiene sentido 00:30:11
porque no tiene sentido que existan universidades 00:30:13
perdón, que existan facultades 00:30:15
si no existe una universidad 00:30:18
y solamente tiene sentido que existan 00:30:19
carreras si existe una facultad 00:30:21
y solo hay estudiantes y existe una carrera 00:30:23
entonces aquí tiene todo el sentido del mundo 00:30:25
por eso por defecto se hace como clases 00:30:27
internas 00:30:29
vale, pero 00:30:30
y el modificador 00:30:32
static delante 00:30:35
¿qué significa? 00:30:37
vale, pues la clase 00:30:40
una clase puede ser estática 00:30:41
una clase interna 00:30:42
puede ser estática, por ejemplo, yo me puedo hacer aquí una clase interna estática 00:30:44
y esta clase interna estática, ahora no se me ocurre un concepto, 00:30:52
¿para qué me sirve esta clase? 00:31:03
Esta clase interna, si yo le pongo el modificador static, 00:31:09
es una clase a través de la cual puedo yo acceder solamente al contexto estático de la clase de arriba. 00:31:12
Es decir, solamente puedo acceder al contexto estático de instituto. 00:31:23
Entonces, esta clase es como si mi clase instituto tuviera una propiedad estática, 00:31:28
pero una propiedad estática que además puede hacer cosas. 00:31:37
¿Vale? Puede hacer, por ejemplo, esta es una propiedad estática, sin más, ¿verdad? 00:31:42
Una propiedad estática que es de clase stream. 00:31:49
Y comunidad, pues sí, puede llamar a los métodos de stream. 00:31:51
¿Vale? Entonces, yo podría haber hecho aquí, por ejemplo, cosas de la comunidad, cosas específicas de la comunidad. 00:31:55
Entonces, automáticamente 00:32:09
se crea, cuando aparezca un instituto 00:32:15
la primera vez que a un instituto se hace referencia 00:32:19
como se crea todo su contexto estático 00:32:23
se va a crear esto y se va a ejecutar el bloque estático 00:32:25
también se van a crear instancias 00:32:28
de sus clases internas estáticas 00:32:31
también se van a crear instancias de esto 00:32:33
igual que se ha creado instancia de esto 00:32:35
se van a crear instancias de esto 00:32:38
Y aquí dentro yo puedo hacer cualquier cosa 00:32:39
Pues cualquier método 00:32:45
Que use las variables estáticas de la clase 00:32:48
Por ejemplo, cambia comunidad 00:32:52
Y le paso aquí un string con la nueva comunidad 00:32:59
Y aquí yo puedo acceder a la variable estática 00:33:04
Comunidad 00:33:13
Igual a nueva 00:33:14
Comunidad 00:33:19
¿Vale? 00:33:21
Entonces a través de esta clase 00:33:24
Estática interna 00:33:26
Puedo acceder al contexto estático de arriba 00:33:27
Entonces recojo dentro de la clase 00:33:29
Recojo dentro de la clase 00:33:34
Muchas cosas 00:33:36
Sin necesidad de ponerlo como clases aparte 00:33:36
Esta es la idea 00:33:40
De las clases internas 00:33:42
Sobre todo la idea es que 00:33:43
Bueno, que no os olvidéis de que están, por si veis diseños hechos así, ¿vale? 00:33:45
Y ya sabemos que pueden ser no estáticas, con lo cual hay que instanciarlas específicamente, 00:33:52
hay que instanciarlas específicamente asociadas a un objeto que tiene que existir, como hemos hecho aquí, 00:34:00
y pueden ser estáticas, ¿vale? 00:34:05
Si son estáticas, no hay que instanciarlas específicamente, 00:34:09
Por ejemplo, aquí vamos a cambiar la comunidad 00:34:14
Aquí sería instituto.cosasdelacomunidad 00:34:20
Instituto, el nombre de la clase sigue siendo este, cosasdelacomunidad 00:34:27
¿Vale? Entonces, aquí 00:34:34
Este no necesita que exista un instituto 00:34:39
Esta la instancio a sí misma por libre 00:34:50
No necesita que exista 00:34:52
Esta la instancio así 00:34:54
¿Vale? El instituto podría no existir 00:34:56
Podría no existir 00:35:01
El instituto 00:35:03
Podría yo no haber creado ningún instituto 00:35:04
Sin embargo 00:35:10
Esto puede existir 00:35:12
Esto puede existir 00:35:14
Y yo puedo pues cambiar la comunidad 00:35:17
Sin necesidad de que exista ningún instituto 00:35:20
¿Vale? 00:35:22
¿Vale? 00:35:31
Claro, porque todos los institutos, efectivamente, claro, todos los institutos comparten todo lo estático. 00:35:33
Esta propiedad y esta también. 00:35:56
Vamos a instituto.comunidad Valencia, ¿vale? 00:36:00
Entonces, las clases estáticas es una manera de recoger dentro de la clase cosas que tú puedes querer hacer con el contexto estático, con las variables estáticas y ya está, ¿vale? En lugar de hacer una clase aparte que recoja todo eso o hacerlo como métodos aquí dentro, lo podrías hacer como métodos aquí dentro, ¿no? Cambiar comunidad, pero claro, entonces a lo mejor el cambiar comunidad, hacerlo como método estático dentro del instituto podría ser un diseño feo, 00:36:36
Porque en realidad no es el instituto el que cambia la comunidad, o sea, son todos en global. Entonces, pues bueno, es una cuestión de diseño simplemente, no es que haya que hacer las cosas así. Entonces, meto yo dentro de una clase estática todo aquello que se refiere a tocar el contexto estático y parece como que está más recogido, más aparte y no está como métodos a la misma altura de los métodos propios de instituto. 00:37:07
Los métodos propios de instituto deberían ser los que hacen cosas con el instituto, ¿vale? Y los métodos que hacen cosas con el contexto estático los puedo poner también ahí, por supuesto, dentro de la clase instituto que hemos hecho hasta ahora, o los puedo recoger dentro de una clase estática. Bueno, diferentes posibilidades de diseño, sin más. 00:37:30
vale, pues 00:37:48
ahora ya 00:37:50
que tenemos lo de las clases internas 00:37:52
recordado, porque no hay más historia que esto 00:37:54
pues bueno 00:37:56
ya entendemos esto un poco más 00:37:57
entonces, ¿por qué las ha puesto 00:37:59
estáticas? porque es que 00:38:01
ninguna de estas clases internas 00:38:04
accede, necesita usar 00:38:05
ninguna de las propiedades de aquí 00:38:07
es decir 00:38:09
JAXB 00:38:11
te crea una única universidad 00:38:13
¿vale? 00:38:16
Te crea una única universidad. 00:38:18
No hay muchas universidades. 00:38:20
Entonces, todo se trabaja como estático. 00:38:22
¿Vale? 00:38:25
Entonces, la clase facultades. 00:38:25
La clase facultades, ¿dónde está declarada? 00:38:28
Aquí. 00:38:32
Está como estática. 00:38:33
¿Por qué? 00:38:34
Porque no accede a ninguna propiedad de universidad. 00:38:35
No la usa para nada. 00:38:38
Ninguna propiedad de universidad. 00:38:40
Entonces, vamos a quitarle todo esto para que se vea más claro. 00:38:41
Hombre, son comentarios 00:38:45
Que te explican solamente 00:38:47
Cómo es el XML 00:38:49
O sea, que mete ahí una 00:38:51
Es que hay tanta clase interna 00:38:53
Que en este ejemplito 00:39:34
Pues cuesta verlo 00:39:38
Porque es que es mucha clase interna 00:39:39
Teníamos que haberlo hecho en un XSD más sencillo 00:39:40
Para 00:39:44
Para verlo mejor 00:39:45
Porque aquí tenemos una cantidad de anidamiento 00:39:47
Brutal 00:39:49
Claro, hay un montón 00:39:51
De clases internas, claro 00:39:53
Entonces, si uno genera las clases con esto 00:39:55
Pues vale, ya las tiene y funcionan 00:39:58
Pero es que luego para construirlas 00:39:59
Tiene que acordarse de que 00:40:02
Cada vez que instancia 00:40:03
Uno de los objetos de la universidad 00:40:04
Pues los tiene que instanciar 00:40:08
Con su nombre de clase interna 00:40:09
Pero ya está 00:40:11
No pasa nada 00:40:12
Vamos a ver si podemos hacerlo rápidamente 00:40:14
Sin volvernos locos 00:40:19
Claro, entonces 00:40:20
Vamos a hacer aquí un main 00:40:23
Vamos a hacer aquí un main 00:40:26
Y vamos a hacer un poco de 00:40:37
Gimnasia 00:40:39
A ver, nuestro xml 00:40:41
Que nos va a ser más fácil verlo desde el 00:40:44
xml 00:40:46
Voy a generar 00:40:48
Desde mi esquema 00:40:51
Un xml de ejemplo 00:40:53
Para 00:40:54
Sí 00:40:56
Porque así vamos a ver más claro 00:41:01
Venga 00:41:03
Venga, pues esto es un xml 00:41:05
de ejemplo cualquiera, entonces lo más interno es, vamos a crear 00:41:20
una materia cualquiera, pero claro, materia 00:41:23
está dentro de materias, es que ni siquiera 00:41:28
lo hace con envolvente, o sea, es que lo ha hecho la clase materias, que a su vez 00:41:32
tiene dentro materia, entonces vamos a crear, mi main está 00:41:36
aquí, no, este no era, mi main está 00:41:43
aquí 00:41:48
Vale, pues la clase materia está 00:41:49
Dentro de universidad 00:42:02
Que a su vez está en facultades 00:42:05
Que facultades es una clase que solo sirve para tener una lista de facultad 00:42:09
Es que ni hace envolvente ni hace nada además 00:42:13
Facultad tiene carreras 00:42:16
Carreras tiene carrera 00:42:18
Carrera tiene estudiantes 00:42:20
y estudiantes tiene estudiante 00:42:23
y estudiante 00:42:26
tiene materias 00:42:28
y materia tiene materia 00:42:29
esto es 00:42:31
absurdo 00:42:34
usar el plugin 00:42:36
y dejarte, a ver, no es absurdo 00:42:37
porque si lo haces solo 00:42:40
para la parte del xml, pues ya veis que esto 00:42:41
es ir tirando de puntito, completar y ya está 00:42:44
pero un modelo de clases 00:42:46
con tantas clases internas 00:42:47
para otras cosas que no fuera para xml 00:42:49
Pues si es que no lo generaríamos 00:42:52
Vale, pues nos vamos a hacer una materia 00:42:54
Que es 00:42:56
New, madre mía 00:42:56
No me digas que tengo que volver a escribir todo eso otra vez 00:43:00
Tiene que haber alguna forma 00:43:02
¿Eh? 00:43:04
Claro, pero 00:43:08
Y no puedo usar el new instance 00:43:09
Pero el new instance tengo que poner la clase otra vez 00:43:10
Con lo cual no ahorro nada 00:43:12
Entonces sí, venga, control c, control v 00:43:14
Que barbaridad 00:43:16
A ver, me puedo hacer el import, porque parecemos tontos 00:43:18
Claro 00:43:20
Porque el import también funciona 00:43:22
Para todo esto 00:43:25
También no solo con paquetes 00:43:27
Sino con clases internas 00:43:30
Es decir, yo puedo hacer un import 00:43:31
Y aquí me importo 00:43:34
Con .dam2 00:43:37
.todoelchorizoeste 00:43:40
De clases internas 00:43:42
Materias, materia 00:43:43
Con .dam2.model 00:43:46
Model, efectivamente 00:43:48
Me falta el model 00:43:49
Vale, me hago el import 00:43:51
Y no tengo que arrastrar eso todo el rato 00:43:56
Pongo materia y se acabó 00:43:57
Me hago materia 00:44:12
¿Cómo que no sabe a qué materia me refiero? 00:44:14
¿Me refiero a esta? 00:44:17
No, no, no 00:44:19
Es que si hubiera más materia sería 00:44:20
¿Es el nombre de la variable lo que lo distingue? 00:44:22
Claro, es como 00:44:25
Ah, que estuviera en otra línea 00:44:25
De clases internas, en otro import 00:44:31
Ah, bueno, ya claro, pero es que entonces no puedo hacer import 00:44:32
Claro, si hubiera otra clase materia en otra ruta del import 00:44:35
Él cogería la primera de todas siempre 00:44:38
Entonces no podría hacerlo así 00:44:41
¿Vale? 00:44:43
Pero claro, no es el caso 00:44:44
Entonces, materia.setCódigo 00:44:46
Pues esto no me acuerdo si era string o sería string, seguro 00:44:50
setCódigo1 00:44:54
Materia.setNombre 00:44:57
Acceso a datos 00:45:01
Materia.set 00:45:05
Nota 00:45:07
Un 10 00:45:09
Pero lo tengo que convertir 00:45:11
A big decimal 00:45:14
Y esto 00:45:15
Me dejará con el constructor 00:45:18
Porque fijaos que 00:45:20
El plugin 00:45:22
En lugar de double 00:45:23
Me lo ha puesto como big decimal 00:45:26
Entonces 00:45:28
No, el big decimal 00:45:29
Ah bueno 00:45:34
Import 00:45:36
Ah, pues sí, puedo hacer un big décima a través de un double normal y corriente 00:45:36
Vale, ya tengo la materia 00:45:41
¿La materia está dentro de qué? 00:45:42
La materia está dentro de materias 00:45:45
Entonces tendré que instanciar materias 00:45:46
Copia y pega del libro 00:45:49
Venga, esta es clase de velocidad 00:45:51
Este tipo de trabajos es que es el pan nuestro de cada día 00:45:53
Más que pensar 00:46:03
Vale, ya tengo materias aquí importado 00:46:04
De hecho, vamos ya a hacernos rápidamente 00:46:07
Todos los import con todas las clases que vamos a usar 00:46:11
Para no volvernos locos 00:46:14
Estudiante, ya la tengo 00:46:15
Ala, otro import 00:46:18
Estudiantes, ya lo tengo 00:46:21
Otro, carrera 00:46:25
Que bonito, de verdad 00:46:28
Pues en situaciones de estas os veréis 00:46:37
Y cosas más raras 00:46:45
Y el mundo del desarrollador es 00:46:46
Una cosa extraordinaria 00:46:48
Sí, ¿verdad? 00:46:50
Universidad 00:47:00
¿Ya las tengo todas? 00:47:00
Sí, ya tenemos la escalera perfecta 00:47:07
Universidad la tengo duplicada 00:47:09
Vale, la voy a quitar 00:47:12
Para que esté dentro de la escalera 00:47:13
Ay, qué bonito 00:47:14
Vale, pues ahora ya 00:47:18
Ahora ya nos hacemos 00:47:21
Materias 00:47:23
Igual a new 00:47:25
Materias 00:47:28
Y ahora 00:47:30
A materias punto 00:47:32
Get materias 00:47:34
Punto add 00:47:36
Materia, ojo 00:47:38
Habrá hecho el plugin la instanciación 00:47:40
Por defecto para que no la liemos 00:47:43
Con el null pointer, pues seguro que no 00:47:45
Pero yo que sé, bueno, digo seguro 00:47:47
Por decir, igual sí 00:47:49
Vamos a ver 00:47:50
Vamos a ver 00:47:52
Cómo ha hecho 00:47:54
Mal 00:47:55
Vámonos a 00:47:57
Materias, a ver cómo ha hecho materia 00:48:00
Vamos, vamos, vamos 00:48:02
Vamos 00:48:07
Va, no, me pasa, ah sí 00:48:08
Es la última de todas, claro 00:48:11
Venga, vamos, vamos 00:48:12
Vamos, vamos 00:48:15
Materias, vale, pero yo veo la propiedad 00:48:16
Universidad, facultades, no, estoy en el estudiante, aquí, vale, entonces, pues esta lista no la he instanciado por defecto, podría ser que el get fuera listo y diera, si es null, instánciame una lista nueva, pero no creo, ah, mira, sí, vale, es una construcción habitual realmente en muchos frameworks, que si es null, te lo instancie, con lo cual no vamos a tener problema en el null pointer exception. 00:48:19
Vale 00:48:53
Mira que bien 00:48:55
Pues hala, ya está 00:48:57
Ahora, ya tenemos la materia 00:48:58
Ahora hay que crear el estudiante 00:49:01
Y ponerle las tres cosas 00:49:02
No pasa nada, esto lo hacemos a toda leche 00:49:04
Estudiante 00:49:06
Al estudiante 00:49:11
Edad 00:49:20
E-mail 00:49:23
Cualquiera 00:49:29
Y de tres 00:49:32
Materias 00:49:38
Pues la lista que acabamos de hacer 00:49:45
Y nombre del estudiante 00:49:46
Juanito 00:49:52
Ala 00:49:53
Venga 00:49:55
Es que Pepitos no tenemos ninguno 00:49:56
Ah bueno, algún José hay, no hay ningún José en clase 00:49:59
Ah bueno, pues Juan Pepito 00:50:01
Vale, ya tenemos al estudiante 00:50:04
El estudiante va metido 00:50:08
Dentro de una lista de estudiantes 00:50:10
¿Verdad? Creo 00:50:12
Estudiantes 00:50:13
Estudiantes 00:50:15
Lo ha metido dentro de una lista 00:50:18
Todo esto por no hacer el graper 00:50:19
Así de vago 00:50:21
Ha sido 00:50:23
Y ahora a estudiantes.get 00:50:26
Ni lo miramos 00:50:30
Porque si ya en las materias 00:50:31
Ha hecho el get para que te instancie 00:50:33
Si no tiene nada, seguro que aquí también lo ha hecho 00:50:35
Así que 00:50:37
Ya tenemos estudiantes 00:50:39
Y ahora 00:50:41
Esta lista de estudiantes estaba en la carrera 00:50:44
Luego nos falta una carrera 00:50:46
Vale 00:50:49
La carrera tiene 00:50:57
Un código 00:50:59
Bueno, un departamento 00:51:01
Bla, bla, bla 00:51:03
Tiene un código 00:51:04
Bla, bla, bla 00:51:09
Tiene unos estudiantes que son los que acabamos de hacer 00:51:11
Y tiene un nombre 00:51:18
Carrera de mates 00:51:22
Y la carrera está en la facultad 00:51:24
Ah, perdón, jolines 00:51:28
De verdad 00:51:31
Ah, teníamos que haber cogido otro esquema 00:51:32
Esto no puede ser 00:51:36
Carreras 00:51:38
Y ahora ya sí 00:51:41
Cars.get.add 00:51:48
Carrera que acabamos de hacer 00:51:52
Y ahora ya sí que las carreras están en la facultad 00:51:53
Y la facultad tiene un nombre 00:52:00
Pues la facultad de mates 00:52:11
Y tiene unas carreras que acabamos de hacer 00:52:12
Perdón, set carreras 00:52:16
Punto set 00:52:24
Carreras, estas carreras que acabamos de hacer 00:52:25
Y ahora ya 00:52:28
Esto está en las facultades 00:52:30
Y en las facultades 00:52:32
Tiene una lista de facultades 00:52:44
A la que le añadimos 00:52:46
La facultad 00:52:48
Benditos imports 00:52:49
Porque si no, vale 00:52:55
Y las facultades están, ahora ya sí que sí 00:52:56
En la universidad 00:52:59
Y terminado 00:53:01
Podemos ya generar a ver si las clases están bien 00:53:02
Porque claro 00:53:05
Podrían no estar bien 00:53:05
La universidad 00:53:08
Vale 00:53:10
Y la universidad 00:53:17
Tiene su nombre 00:53:20
Universidad 00:53:21
Y la universidad tiene 00:53:23
Su lista de facultades 00:53:28
Que son los que acabamos de hacer 00:53:31
Y ahora esto 00:53:32
Podríamos mandarlo a un xml 00:53:34
Ni método aparte 00:53:36
Ni nada 00:53:38
Recordad que esto 00:53:39
Hacíamos un contexto 00:53:41
Que era 00:53:42
Juraría 00:53:47
Y lo instanciábamos 00:53:48
Con new instance 00:53:51
Y aquí le dábamos 00:53:53
La clase 00:53:55
Raíz 00:53:57
Y hacemos hasta un throw 00:53:58
Solamente queremos probar que las clases 00:54:07
Que ha generado están bien 00:54:10
Y ahora ya creábamos el 00:54:11
Marshaller 00:54:13
Que este yo creo que se hacía desde aquí 00:54:14
Create Marshaler 00:54:23
Y ahora 00:54:25
Al Marshaler 00:54:27
Le poníamos la propiedad 00:54:29
De que estuviera formateada 00:54:31
La salida 00:54:33
SetProperty 00:54:34
Y es 00:54:38
Esta propiedad 00:54:40
Yo creo que era una 00:54:43
Propiedad final del contexto 00:54:44
Jaxbeck 00:54:47
No era formate 00:54:48
Luego de aquí no puede ser 00:54:51
Porque solo me ofrece 00:54:55
Podría ser de marshaller 00:54:56
Imagino 00:54:59
Marshaller.si 00:55:00
Y a este a true 00:55:02
Vale, la propiedad del marshaller 00:55:06
Salida formateada se la ponemos a true 00:55:11
Y ahora ya 00:55:13
Hacemos el marshaller 00:55:15
Desde 00:55:17
Mi objeto 00:55:18
Unif 00:55:21
Y aquí poníamos el fichero 00:55:21
Universidad.xml 00:55:25
E importamos file 00:55:38
¿Por qué no se ha unido? 00:55:41
¿Cómo? 00:55:49
No, no quiero añadir esto 00:55:50
Espera, crear 00:55:52
File 00:55:53
Vale, ya está 00:56:04
Venga, no hemos tocado las clases que ha generado el plugin 00:56:08
Vamos a ver si nos genera un xml en condiciones 00:56:12
¿Error? 00:56:15
Universidad XML 00:56:19
Refresh 00:56:26
¿Vale? 00:56:28
Jolín, qué salida formateada tan horrible 00:56:35
¿Por qué materia me la ha puesto aquí? 00:56:37
Sí, sí 00:56:47
El tema es 00:56:47
¿Por qué? 00:56:49
Porque no me lo ha formateado bien 00:56:57
O sea, está bien 00:56:58
El XML está bien generado 00:56:59
Tiene todos los datos correctamente 00:57:01
Pero no sé por qué esto no me lo ha puesto bien 00:57:03
Igual es que ya tiene un límite 00:57:06
Dentro del cual ya deja de formatear 00:57:07
Cuando hay tantos internos 00:57:09
Qué raro, no lo sé 00:57:11
Pero bueno, lo ha generado bien y ya está 00:57:13
¿Vale? 00:57:15
No tendrá dinero suficiente 00:57:19
Para indexar más 00:57:20
A parte de la clase universitaria 00:57:24
nos ha generado aquí 00:57:33
este objeto 00:57:35
este objeto 00:57:40
object factory 00:57:42
es como su nombre indica 00:57:44
una factoría de objetos 00:57:46
de la que podemos pasar 00:57:48
completamente 00:57:50
entonces, una factoría de objetos 00:57:51
¿qué hace? crear objetos 00:57:54
efectivamente, me está creando 00:57:56
simplemente instancias 00:57:58
instancias 00:58:01
de los objetos de mi contexto 00:58:02
de Jax B 00:58:04
vale 00:58:05
universidad facultades me ofrece un 00:58:07
create 00:58:10
para cada uno de los objetos de mi contexto 00:58:11
vale 00:58:14
es una factoría de objetos 00:58:16
entonces tiene sentido 00:58:18
usar esta factoría de objetos 00:58:20
en un caso muy concreto 00:58:22
en el contexto de Jax B si 00:58:24
porque a ver 00:58:25
podría ocurrir que por la razón 00:58:26
que fuera 00:58:30
esta clase mía universidad 00:58:31
esto lo menciono solo, no vamos a trabajarlo 00:58:36
porque es que no merece la pena seguir insistiendo más en el XML 00:58:39
podría ocurrir que aquí no existiera 00:58:41
la anotación XML root element 00:58:44
porque esto estuviera dentro de otra jerarquía 00:58:46
es decir, que hubiera otra clase por ahí 00:58:49
que es la verdadera clase raíz que tiene una universidad dentro 00:58:52
entonces aquí no estaría el XML root element 00:58:56
sino que estaría en la otra clase 00:59:00
que esa otra clase tiene una propiedad universidad dentro 00:59:01
que es un subnodo de ella 00:59:05
pero puede ocurrir que en un momento dado 00:59:06
yo quiera hacer un XML que solo tenga esta parte 00:59:09
entonces si quiero hacer un XML que solo tenga esta parte 00:59:12
tendría que venirme aquí 00:59:15
poner el XML root element 00:59:16
generarlo y luego quitarlo 00:59:19
porque en realidad esta clase universidad 00:59:21
está dentro de otra clase 00:59:24
que es la que sí que tiene el root element 00:59:26
No sé si me explico la situación a la que me refiero. 00:59:28
Sí, ¿no? 00:59:32
Vale, pues si estoy en esta situación 00:59:32
y yo tengo que generar un sub-XML, entre comillas, 00:59:35
que solo tenga de universidad hacia abajo 00:59:39
y no puedo poner aquí el XML root element 00:59:41
porque no puedo entrar al código fuente para cambiarlo, 00:59:44
pues ahí es donde entra en ese contexto 00:59:48
y solo en ese que a mí se me ocurra, 00:59:51
en el que tiene sentido el Object Factory. 00:59:54
¿Por qué? Porque el ObjectFactory genera objetos, pero tiene una anotación aquí, una anotación que nos pasa por alto, que es una anotación de JaxB. 00:59:58
Entonces, esta anotación hace que estos objetos tú los puedas instanciar no solo como el propio objeto universidad, sino como JaxB element. 01:00:08
Es decir, tenemos aquí una 01:00:19
Tenemos una clase 01:00:23
Que no hemos 01:00:26
Trabajado, pero nos ha hecho falta 01:00:27
Y no hace falta a la mayoría de los 01:00:29
Que es JaxbElement 01:00:30
¿Vale? 01:00:33
Por ejemplo, me voy a hacer un JaxbElement 01:00:35
Asociado a universidad 01:00:37
¿Vale? 01:00:39
Entonces 01:00:45
Esto 01:00:45
No me acuerdo como se instanciaba 01:00:47
JaxbElement 01:00:50
Ah, con el ObjectFactory 01:00:52
Eso vale 01:00:56
Claro 01:00:58
ObjectFactory 01:00:59
Factory 01:01:02
Punto 01:01:04
A través del ObjectFactory 01:01:06
Lo instancias, pero necesitas 01:01:09
El ObjectFactory, claro 01:01:10
Necesitas crear porque no es el método estático 01:01:12
Necesitas crear 01:01:14
El ObjectFactory 01:01:16
Cuidado con el 01:01:18
Veis la cantidad de import 01:01:33
Que hay para cualquier cosa 01:01:36
Y ahora este object factory 01:01:37
Te permite ahora ya si 01:01:40
Crear 01:01:42
Una 01:01:44
Crear una universidad 01:01:46
Vale 01:01:51
Y aquí me falta el punto y coma 01:01:53
Efectivamente 01:01:55
Y aquí me falta 01:01:56
Importar 01:01:59
Jaxpe element 01:02:01
Y aquí yo puedo hacer un casting 01:02:02
sin problema 01:02:05
no, pero no quiero hacer esto 01:02:07
no, es que no quiero hacer esto 01:02:18
porque yo quiero un Jaxby element 01:02:22
aquí 01:02:24
haces un casting, vale, es que no quiero que 01:02:27
lo quería solo mencionar por encima 01:02:33
no quiero que nos 01:02:34
Jaxby element de 01:02:36
adversidad 01:02:38
Porque no puedes hacer 01:02:40
A ver, espera 01:02:48
Antes de seguir pidiendo el tiempo probando 01:02:50
Voy a 01:02:52
Preguntárselo a este 01:02:54
¿Cómo 01:02:56
Instancio 01:02:59
Un Jaxb 01:03:01
Element 01:03:04
Con mi 01:03:05
Object 01:03:07
Factory? Seguro que sabe a lo que me refiero 01:03:10
Bueno 01:03:12
Bueno, el factory es el object factory 01:03:30
Llamas al método 01:03:32
Y yo lo que no le he pasado es el 01:03:35
Ah, vale, vale, vale 01:03:37
Claro, es que no le he pasado 01:03:41
Vale, vale, vale, vale, es que no le he pasado el este 01:03:42
Lógicamente, es que soy imbécil 01:03:44
Vale, a ver 01:03:46
Tenemos que dar el elemento asociado 01:03:48
Lógicamente 01:03:51
Asociado 01:03:52
A la universidad que yo acabo de hacer 01:03:54
Claro 01:03:56
Vale 01:03:58
Y ya, claro 01:04:01
Que no le pasa al parámetro 01:04:03
Y luego 01:04:04
Ya está 01:04:07
Vale 01:04:16
Vale, vale, es que no le había pasado esto 01:04:19
Y aquí que me dice 01:04:21
Es que este object factory 01:04:24
No está bien 01:04:35
Es que este object factory 01:04:37
Un momentito, vale, de xml 01:04:48
Que nos falta 01:04:56
Muy poca cosa 01:04:58
Solamente 01:04:59
voy a mencionar, por mencionarlo 01:05:02
por mencionarlo y podemos ver un ejemplo 01:05:04
de cómo es, pero sin hacerlo ni practicarlo 01:05:06
no lo voy a preguntar en el examen 01:05:08
¿vale? 01:05:10
estas tecnologías que hemos visto 01:05:12
DOM y JaxB 01:05:13
todas ellas están basadas 01:05:15
en volcar 01:05:20
todo el contenido de mi XML 01:05:21
en memoria principal 01:05:24
bien sea en una variable document 01:05:25
o bien sea en mis entidades 01:05:27
siempre mejor esta opción 01:05:30
porque mis entidades aparte juegan 01:05:32
en la aplicación en más bandos, juegan haciendo 01:05:34
cosas por otras partes, aquí el document 01:05:36
solo juega para el xml 01:05:38
luego es una carga en ram 01:05:40
innecesaria, siempre mejor esto 01:05:42
¿vale? porque aprovecho mis propios 01:05:43
objetos que hacen cosas para serializarse 01:05:46
¿vale? pero 01:05:49
si nosotros el aprovechar 01:05:51
mis propios objetos que están ahí 01:05:54
haciendo cosas para serializarse 01:05:56
Pues no es interesante porque yo solamente quiero la parte de XML y no quiero cargarlo todo en memoria como DOM, pues puedo usar una tercera herramienta, SACS, que os suena el nombre, SACS, que es para serializar XML, ¿verdad? 01:05:58
pero esto vale solo para leer 01:06:14
esta tecnología 01:06:16
vale solamente para leer 01:06:18
XML en plan rápido 01:06:21
y sin cargar la memoria principal para nada 01:06:22
y está basado 01:06:25
en eventos 01:06:27
en lo que podría ser remotamente 01:06:29
una programación reactiva 01:06:32
pero no, en realidad no 01:06:35
¿vale? entonces 01:06:36
¿en qué está basado SACS? 01:06:38
pues tú declaras una clase 01:06:40
vamos a ver un ejemplito para que no se quede demasiado 01:06:42
tú declaras una clase 01:06:44
y declaras lo que vas a hacer 01:06:46
según pasen 01:06:49
eventos una vez que has lanzado 01:06:50
un proceso, entonces el proceso 01:06:52
que tú vas a lanzar es 01:06:54
enganchar el xml a un flujo 01:06:56
de entrada, eso es el proceso 01:06:58
que vamos a lanzar en nuestro 01:07:01
main, nuestro main lo que hace es 01:07:03
enganchar el xml a un flujo 01:07:05
de entrada, entonces desde el momento en el que 01:07:07
el xml se engancha al flujo 01:07:09
de entrada, empiezan a salir por ahí 01:07:10
las cositas que están en el PSML. 01:07:13
Empiezan a salir por ahí. 01:07:14
Por ejemplo, el arranque de un nodo, 01:07:16
el cierre de un nodo, 01:07:19
el arranque de un nodo texto, 01:07:20
el cierre del nodo raíz. 01:07:22
Empezan a pasar cosas según van saliendo. 01:07:24
Empiezan a pasar cosas. 01:07:26
Bueno, pues resulta que yo en una clase 01:07:28
he programado 01:07:30
qué quiero hacer según vayan pasando 01:07:32
mis cositas. Nodo que se abre, 01:07:34
nodo que se cierra, nodo texto que se abre. 01:07:36
¿Qué programaré ahí? 01:07:39
pues lo que quiera, pues coger el contenido 01:07:40
y mostrarlo, coger el contenido 01:07:42
e ignorarlo, coger el contenido y llevarlo a variables 01:07:44
lo que yo quiera, entonces aquí 01:07:47
no se guarda nada en memoria RAM 01:07:48
aquí van llegando las cosas 01:07:50
las procesos, según haya 01:07:52
puesto yo en mi clase, las procesos 01:07:54
y van a la basura 01:07:56
van llegando las procesos 01:07:57
y a la basura, van llegando las procesos 01:08:00
y a la basura, esta es una programación 01:08:02
basada en 01:08:05
captura de puntos 01:08:06
¿vale? una 01:08:08
un diseño habitual en otros contextos 01:08:09
como en interfaces gráficas 01:08:13
etcétera 01:08:14
y es el que motiva 01:08:16
motivó la actual programación reactiva 01:08:18
vale pues 01:08:21
vamos a verlo en un ejemplito 01:08:22
y ya está 01:08:25
para que no se quede así 01:08:26
por ejemplo 01:08:31
aquí tendré un ejemplo 01:08:33
del año pasado 01:08:42
Vale, pues esto de aquí 01:08:46
Por ejemplo, tenemos aquí un archivo cualquiera 01:09:36
Del que quiero leer 01:09:42
Y solo leer 01:09:44
Porque SACS es solo para leer rápido 01:09:45
Y sin cargar la memoria principal 01:09:47
Quiero solamente leer 01:09:49
Vale, pues para leer mi main 01:09:50
¿Qué va a hacer? 01:09:53
Mi main lo único que va a hacer va a ser 01:09:55
Bueno, instanciar 01:09:56
Como siempre, el que va a parsear 01:09:57
Este parser que se instancia 01:10:01
Desde una factoría 01:10:02
como casi siempre 01:10:03
vale, y ahora 01:10:05
aquí se lanza 01:10:07
el parse 01:10:09
entonces desde el momento en que se lanza 01:10:10
el parse 01:10:14
¿qué empieza a pasar? que este fichero 01:10:14
entra en una especie de tubería 01:10:18
y va metiendo ahí sus cosas 01:10:20
pa pa pa pa 01:10:22
y según van saliendo las cosas por el otro lado 01:10:22
esta clase 01:10:26
va decidiendo qué hacer con ellas 01:10:27
bueno, pues esta clase 01:10:29
este objeto es el que tendremos que haber 01:10:31
declarado nosotros 01:10:33
luego la lectura del 01:10:35
xml consiste en 01:10:37
un parser 01:10:39
lanza que el xml 01:10:41
empiece a llegar por una tubería 01:10:43
el xml va saliendo 01:10:45
por la tubería y este objeto que yo he 01:10:47
programado decide que hago 01:10:49
con cada cosa que pase 01:10:51
y ya está 01:10:52
¿vale? 01:10:54
ahora, claro, eso lo tendremos que haber declarado, vamos a ver 01:10:56
¿cómo declaramos todos pedidos handler? bueno, pues pedidos handler 01:10:58
esta clase de aquí 01:11:03
que tiene que ser un manejador 01:11:06
por eso lo heredo de un manejador 01:11:09
vale, y yo aquí programo 01:11:10
lo que quiera, siempre y cuando 01:11:12
sobreescriba los métodos 01:11:15
de un manejador por defecto 01:11:16
vale, entonces 01:11:19
¿qué métodos tengo que sobreescribir? 01:11:20
bueno, los que yo quiera, no todos 01:11:23
porque esto no es una implementación de una interfaz 01:11:25
es una herencia, entonces no estoy 01:11:27
obligada a sobreescribirlos todos 01:11:29
Vale, pues el método StartElement 01:11:30
Aquí escribo lo que quiero yo que pase 01:11:33
Cuando llegue el evento de que arranca un nodo 01:11:36
En este caso, pues si el nodo es cliente 01:11:39
Quiero que hagas no sé qué 01:11:42
Este método, este método es el que arranca 01:11:43
Cuando llegue un nodo texto 01:11:48
Cuando llegue un nodo texto 01:11:49
Pues aquí tenía puesto lo que quiero que pase 01:11:51
Cuando llegue un nodo texto 01:11:54
Esto es lo que yo quiero que pase 01:11:55
Cuando llega la etiqueta de cierre 01:11:58
Pues aquí tengo puesto lo que pasa, etc. 01:12:00
Vale, este manejador lo programo yo. 01:12:03
Entonces, en particular, ¿qué es lo que quiero que haga? 01:12:05
Este en particular iba yo cogiendo las cosas que iban llegando y las iba guardando en una lista de objetos. 01:12:07
Las iba guardando ahí, ¿vale? 01:12:13
Y luego ofrecía un método para sacarlo. 01:12:15
Bueno, pues mi lectura se convierte en muy ligera. 01:12:18
hago el parse, este manejador va haciendo 01:12:21
lo que yo le haya dicho que haga con cada cosa que va pasando 01:12:25
en secuencia dentro de este xml 01:12:28
y dentro del handler se habrá quedado mi objeto pedidos 01:12:32
y ya está, entonces que sepáis que existe 01:12:36
una forma más ligera de leer de un xml, solo de leer 01:12:43
que es esta tecnología, sax, voy a subir el proyecto 01:12:46
como ejemplo para que esté ahí subido el ejemplo 01:12:53
pero bueno, no voy a preguntar 01:12:55
nada en el examen de esto 01:12:57
pero lo único que quiero es que os suene 01:12:58
para que se quede completo 01:13:00
lo de XML 01:13:03
y con esto damos por terminado 01:13:04
XML por siempre 01:13:07
jamás, salvo que hay ficheros de configuración 01:13:09
que son XML 01:13:12
y que muchos frameworks 01:13:13
usan XML 01:13:17
para muchas cosas, con lo cual 01:13:19
tendrán que usar JaxB 01:13:21
Y puede que alguno de los fallos 01:13:22
Cuando yo estoy haciendo cualquier cosa 01:13:25
Con algún framework 01:13:26
Uno de los millones de fallos que pueden salir 01:13:27
Puede decir a la palabra clave 01:13:30
Jaxb 01:13:33
Entonces, pues ya sabemos a qué se refiere 01:13:33
Tiene algún fichero de configuración xml 01:13:36
No lo está sabiendo leer internamente 01:13:38
A lo mejor me falta dependencia de Jaxb 01:13:39
O la versión que he puesto 01:13:41
No es compatible con la de mi framework 01:13:44
Entonces la dependencia de Jaxb 01:13:46
La usan internamente muchos frameworks 01:13:47
Porque necesitan parsear xml 01:13:49
hombre no 01:13:51
porque todo esto formaría parte 01:13:56
del 01:13:58
toda la granja o como lo queráis llamar 01:13:59
o granja o universo o ecosistema 01:14:02
de Java 01:14:04
pues esto es una cosa más dentro de esa enorme 01:14:05
granja 01:14:08
entonces pues el tema es que 01:14:09
claro, cuando vosotros decís que sabéis 01:14:12
Java, no vale con 01:14:14
decir yo sé hacer un programa en Java 01:14:16
eso lo sabe hacer cualquiera 01:14:18
vosotros tenéis que decir que sabéis 01:14:19
Raquel me dio Java 01:14:22
No, eso tampoco 01:14:23
Porque 01:14:25
Que sabéis de tecnologías Java 01:14:25
Hombre, ahora mismo nos faltan muchas 01:14:29
Pues claro, nos faltan frameworks de acceso a datos 01:14:31
Nos falta Spring 01:14:33
Nos falta conocer muchas cosas 01:14:34
De ese ecosistema enorme 01:14:37
Pero tenéis que haceros valer a que 01:14:38
No sabéis Java a nivel 01:14:40
Hacer una aplicación en Java 01:14:42
Sabéis Java a nivel aplicaciones empresariales 01:14:44
Y sabéis Spring 01:14:47
Y sabéis muchas cosas 01:14:48
Sabréis o conoceréis por encima 01:14:50
Pero podéis decir que sabréis 01:14:52
y sabéis programación 01:14:53
reactiva, la conoceréis 01:14:55
por encima, pero bueno, podéis decir 01:14:58
que sabréis, vale, ese tipo 01:15:00
de cosas, y ya está 01:15:02
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:
8
Fecha:
31 de octubre de 2025 - 12:16
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 15′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
361.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid