Saltar navegación

20251030 JSON_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 25 de noviembre de 2025 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Quizás no es solo la voz, pero bueno, para las tonterías que decimos es lo suficientemente. 00:00:00
Entonces, los JSON es otro formato de archivos de texto que admite metainformación. 00:00:08
Lo que pasa es que la metainformación en los XML era una estructura jerárquica de nodos, 00:00:15
como sabemos de memoria, y la metainformación en los JSON está adaptada a la programación orientada a objetos. 00:00:21
entonces, como recordatorio 00:00:31
por si alguien no tiene muy claro en la cabeza 00:00:33
lo que es un JSON 00:00:35
¿qué estructura tiene un JSON? 00:00:36
no tiene comentarios 00:00:39
el JSON está más orientado 00:00:39
a que lo parsen máquinas y aplicaciones 00:00:42
directamente, el XML 00:00:45
en su momento también estaba orientado 00:00:47
a que uno lo viera físicamente 00:00:49
viera su información, le diera incluso 00:00:51
un estilo y lo pudiera ver en un 00:00:53
navegador web 00:00:55
el JSON está esencialmente orientado 00:00:57
a que las máquinas lo parsen 00:00:59
para sacar su información 00:01:00
¿vale? por eso no tiene 00:01:02
ni comentarios 00:01:04
¿puedo pasar? 00:01:05
pero si vengo de esta clase 00:01:08
yo ya he estado aquí 00:01:10
pero has llegado tarde, has ido 00:01:11
y has llegado a mitad de la clase interrumpiendo 00:01:13
entonces 00:01:15
si has llegado a mitad de una clase 00:01:18
que ha arrancado, lo normal es decir 00:01:20
puedo pasar porque por defecto 00:01:22
no se interrumpe ningún acto 00:01:24
sea una clase, sea una conferencia 00:01:25
del presidente, no se interrumpe 00:01:28
ya, a ver, pasar 00:01:30
diciendo hola, interrumpir 00:01:35
y además interrumpir mostrando 00:01:37
una educación cuestionable 00:01:38
entonces, tenéis que mejorarla 00:01:40
tenéis que mejorar esa educación y sobre todo 00:01:42
esas pautas de funcionamiento 00:01:44
que todavía son adolescentes 00:01:46
para que salten al modo adulto 00:01:49
¿vale? entonces 00:01:51
cuando se entra en un sitio donde ya se está 00:01:52
hablando, se está haciendo cosas, como se asume 00:01:54
que se interrumpe, pues se hace una 00:01:56
pequeña muestra de que pudo pasar, entonces 00:01:58
lo normal es que te dejen pasar, se pasa 00:02:00
y ya está, ¿vale? Entonces tú 00:02:02
entrarías así en una reunión 00:02:04
informal que tiene tu jefe 00:02:07
con alguien 00:02:08
dices, no sé, eso es que te cuestionas 00:02:09
tu jefe ha contratado a tres personas 00:02:13
o sea, ha contratado, ha juntado a tres 00:02:14
personas en plan informal, entre las cuales una debería ser 00:02:16
tú, para charlar y está en 00:02:18
una habitación charlando en una sala de reuniones hablando 00:02:20
de ese tema, tú entrarías diciendo 00:02:22
hola 00:02:24
por muy informal que fuera 00:02:25
no deberías 00:02:27
tú darías y diría, disculpad 00:02:28
vengo un poco tarde 00:02:31
pero no sé qué, puedo incorporarme 00:02:34
puedo pasar, eso es lo que harías 00:02:36
¿verdad? 00:02:37
¿dudas? pues es lo, ¿vale? 00:02:39
bueno, pues son estas cosas evidentes 00:02:41
que por alguna razón para algunos de vosotros 00:02:43
no son tan evidentes, entonces que se empiecen a hacer evidentes 00:02:45
¿vale? más que nada para que 00:02:48
luego no nos lleguen los emails 00:02:49
que nos llega una vez tras otro de 00:02:51
¿qué es esto que nos estáis mandando? 00:02:53
Bueno, los JSON están pensados esencialmente 00:02:56
para que los parsen aplicaciones, 00:03:00
no tanto para que los miren humanos, 00:03:02
para que los parsen aplicaciones. 00:03:04
Por eso los comentarios han desaparecido, 00:03:05
ni se contemplan, 00:03:08
y por eso su estructura se adapta 00:03:09
al paradigma de programación habitual 00:03:12
en las aplicaciones comerciales, 00:03:14
que es la orientada a objetos. 00:03:15
Entonces, ¿cómo es la estructura de un JSON? 00:03:17
Pues un fichero JSON esencialmente 00:03:19
Esencialmente es lo que para nosotros es un objeto, que para el JSON es una cosa entre llaves y es una secuencia, lo que hay entre las llaves es una secuencia de pares. 00:03:25
Clave, valor, clave, valor, clave, valor. Eso es un objeto instanciado, ¿verdad? Un objeto instanciado es propiedad, valor, propiedad, valor, propiedad, valor. 00:03:37
Pues un fichero JSON es como si fuera un objeto instanciado. No es una plantilla, es una cosa que tiene datos. Los datos están en los objetos instanciados, no están en las clases. 00:03:46
Claro. Bueno, pues un objeto, un fichero JSON es como si fuera un objeto ya instanciado, pero sus valores no están en una RAM, sino que están guardados en un fichero de texto. ¿Vale? Entonces, la secuencia de pares, clave-valor, se va separando por comas. 00:03:55
Y la clave va entre comillas, por ejemplo, el nombre, dos puntos y el valor. ¿Vale? Y así podría haber, pues, edad. 00:04:12
no, no, no, es que esto no es 00:04:28
programación, con lo cual 00:04:31
esto no es variable, o sea, esto es 00:04:34
vale 00:04:36
entonces, bueno, así 00:04:37
en este caso, esto tendría 00:04:39
pues 00:04:42
tendría 00:04:43
dos 00:04:46
dos pares, clave, valor y ya está 00:04:47
siguiente pregunta 00:04:51
los valores 00:04:53
¿qué puedo poner ahí? ¿puedo poner cualquier 00:04:55
cosa? bueno, aquí 00:04:57
Ahí se pueden poner cadenas de texto, cadenas de texto, que sería texto entre comillas, cadenas, ¿vale? 00:04:59
Se podría poner ahí. 00:05:07
¿Qué se podrían poner? 00:05:09
Números, tanto enteros como decimales, ¿verdad? 00:05:11
Números enteros como números decimales. 00:05:15
Números. 00:05:18
También se puede poner boolean. 00:05:20
También admite poner true o false, ¿vale? 00:05:24
Para que un par clave-valor refleje el hecho de si algo pasa o no pasa. 00:05:29
También admite poner esa palabra que nos suena, null, que es nada. 00:05:35
Aquí todavía no hay nada. 00:05:40
Y el valor puede ser también otro objeto. 00:05:44
Podría ser otro objeto que a su vez es un conjunto de pares clave-valor. 00:05:53
Podría ser otro objeto. 00:05:57
Por ejemplo, aquí podríamos tener, pues, instituto es otra propiedad de este objeto. 00:05:58
Instituto es otra propiedad, ¿vale? 00:06:06
Entonces, instituto, como es un valor complejo, podría tener como contenido otro objeto. 00:06:15
Pues nombre del instituto, el que fuera y localización del instituto, la que fuera, ¿vale? 00:06:25
Luego los objetos pueden ser también valores posibles de un par clave valor, ¿vale? 00:06:35
Entonces esto ya es más parecido a la máquina, de hecho el hecho de que admita un null como valor 00:06:43
pues ya suena a que eso sobre todo tiene sentido para una máquina que lo está parseando, 00:06:47
no para un humano que lo está mirando. 00:06:52
¿Y qué otro concepto 00:06:55
incorpora un JSON? 00:06:59
El JSON es como el XML 00:07:01
El JSON, sí 00:07:02
El JSON es un formato 00:07:05
para guardar datos 00:07:07
en ficheros de texto 00:07:08
que son los más manejables, los más ligeros 00:07:11
Entonces 00:07:13
tú puedes guardar los datos escribiendo el fichero 00:07:14
de texto, hola, ¿qué tal? Mis datos son... 00:07:17
Pero es que, ¿quién saca 00:07:19
información de ahí? Un humano, si lo lee, sí 00:07:21
pero una máquina, ¿cómo saca información de un texto 00:07:23
escrito en lenguaje natural, entonces hay que darle 00:07:25
un poco de estructura para que una máquina 00:07:27
entienda qué significa cada dato 00:07:29
esa es la meta información 00:07:31
la estructura que le informa a una máquina 00:07:32
qué significa cada cosa 00:07:35
entonces en XML esa estructura es un árbol 00:07:37
entonces que un nodo 00:07:39
esté dentro de otro, te aporta información 00:07:41
que dentro de un nodo haya muchos 00:07:43
nodos repetidos, te aporta información 00:07:45
¿vale? pues el JSON es otro formato 00:07:47
para organizar 00:07:49
la información, entonces yo podría decir 00:07:51
oye, soy Pepito, tengo 28 años 00:07:53
y voy en el instituto no sé qué. 00:07:56
Para que una máquina saque información 00:07:58
de ahí se vuelve loco. Pero si esa misma 00:08:00
información la pones estructurada así, 00:08:01
Pepito, 28, Rosa, Charly, 00:08:04
Avizalda, 00:08:06
pues una máquina va a sacar esa 00:08:08
información muchísimo mejor. 00:08:09
¿Vale? Que no está puesto así. Pero es otro formato. 00:08:12
Vale, pues entonces, 00:08:14
los objetos 00:08:16
instanciados, 00:08:16
en nuestra noción de 00:08:19
objeto instanciado, que es algo que tiene valores, 00:08:21
Puede ser el valor también de otra propiedad, de otro par clave-valor. 00:08:23
Y ya, por último, también integra el concepto básico en cualquier lenguaje de programación, que es un array. 00:08:31
En un lenguaje de programación no hacemos nada sin arrays, porque es la manera de tener muchas cosas bajo una única referencia. 00:08:39
El array es un concepto fundamental sin el cual no podemos hacer nada. 00:08:48
otra cosa es que como el array 00:08:51
es costoso 00:08:53
de manejar a nivel 00:08:55
de código, lo envolvamos 00:08:57
en una clase 00:08:59
que tiene el array por debajo 00:09:01
o bueno, tiene otras cosas 00:09:03
y nos lo envuelvan, pues como el array list 00:09:04
o eso, ¿vale? pero el concepto 00:09:07
básico de caja 00:09:09
en la que yo meto muchas cosas bajo una única referencia 00:09:11
es imprescindible 00:09:13
para programar cualquier cosa 00:09:14
pues ese concepto se mete también en los JSON 00:09:16
Es un array en JSON, se hace entre corchetes con los elementos que tenga separados por comas y los elementos que tiene el array, de nuevo, pueden ser cadenas, números, los posibles valores que tiene el JSON o también objetos, también objetos puede tener el array, ¿vale? 00:09:19
Bueno, pues un valor posible también puede ser un array, ¿vale? 00:09:44
Un array. 00:09:49
Entonces, este de aquí podría tener instituto, módulos. 00:09:50
¿Qué tengo? 00:09:53
Como módulos son muchos, pues el valor de esta clave módulos 00:09:54
podría ser un array con todos los nombres de mis módulos, por ejemplo, 00:09:59
o con todos los objetos que guardan la información de mi módulo, 00:10:03
nombre, profesor, ¿vale? 00:10:09
pues ya está, combinando eso tenemos un JSON 00:10:11
entonces según 00:10:13
el estándar de JSON 00:10:16
pues un fichero JSON es válido 00:10:19
si contiene 00:10:21
un único objeto 00:10:22
de estos o también 00:10:25
si contiene un array de objetos 00:10:27
también 00:10:29
es un fichero JSON 00:10:31
válido según 00:10:33
el estándar de JSON, vale 00:10:35
tanto un fichero de objetos 00:10:37
y el objeto con dentro todo lo que haga falta 00:10:39
como un único objeto 00:10:45
ambos son, según el estándar 00:10:46
de JSON, son JSON válidos 00:10:49
que cualquier framework de JSON 00:10:51
puede parsear sin problema 00:10:52
tanto una RAI de muchos de estos 00:10:54
como uno único 00:10:56
entonces esto tiene un paralelismo claro con el XML 00:10:58
este JSON sería 00:11:01
un nodo RAID 00:11:03
un nodo RAID, alumno, usuario 00:11:07
lo que fuera, con su nodo nombre 00:11:09
su nodo edad, su nodo instituto 00:11:11
que tendría los subnodos dentro 00:11:14
que serían nombre y localización 00:11:15
su nodo módulos 00:11:18
que sería un envolvente de un montón 00:11:20
de módulos 00:11:22
es decir, el paralelismo 00:11:22
entre un JSON y un XML 00:11:25
es inmediato 00:11:26
pero 00:11:29
esto es mucho más 00:11:31
parecido a la 00:11:34
notación de objetos y de clases 00:11:35
y por tanto cualquier programa orientado a objetos 00:11:38
Pues lo va a parsear, se supone, con más facilidad 00:11:40
Vale, JSON no lo hemos dicho 00:11:43
Viene de 00:11:44
Javascript 00:11:46
Object Notation, juraría 00:11:48
Si alguien tiene 00:11:50
Un navegador abierto, que lo busque rápido 00:12:00
Viene de ahí, ¿verdad? 00:12:03
Vale 00:12:06
Bueno, pues a nosotros 00:12:07
Que nos interesa los JSON 00:12:09
Sí que se usan muchísimo, ¿vale? 00:12:11
Como ficheros de configuración 00:12:13
sustituyendo progresivamente 00:12:14
a los XML o en muchos casos 00:12:17
ya sustituidos, aunque bueno, se arrastre 00:12:19
mucho XML todavía, es inevitable 00:12:21
que se arrastre mucho XML 00:12:23
sobre todo 00:12:24
como traspaso de información 00:12:26
entre microservicios 00:12:29
ese es uno quizá de las cosas 00:12:31
en los que más ha entrado 00:12:33
el JSON 00:12:35
seguro que hay programas para 00:12:37
transmitir XML a JSON 00:12:38
seguro, seguro 00:12:41
claro 00:12:43
seguro 00:12:44
entonces 00:12:45
que es un 00:12:47
ya que lo 00:12:47
hemos mencionado 00:12:48
y luego 00:12:49
podemos hacer 00:12:52
un ejemplito 00:12:54
como 00:12:55
es inevitable 00:12:58
que si mencionamos 00:13:00
Jason 00:13:01
no nos venga 00:13:01
este término 00:13:02
a la cabeza 00:13:03
nos tiene que venir 00:13:03
pues bueno 00:13:04
que nos empiece 00:13:05
a sonar un poco 00:13:06
¿vale? 00:13:07
entonces 00:13:09
nosotros 00:13:09
estamos acostumbrados 00:13:10
a hacer aplicaciones 00:13:11
con su arquitectura 00:13:12
Pues sus clases, cuando yo tengo que resolver un problema, me hago mi método que me resuelve mi problema, lo llamo desde la otra clase y ya está. Y así tengo yo mi aplicación hecha, que se lo guisa y se lo come todo con sus métodos ahí ubicados. 00:13:15
Esto, ¿esto qué es? 00:13:32
Pues esto es una arquitectura 00:13:36
que es un poquito 00:13:37
monolítica 00:13:41
Pues ya está 00:13:43
Yo ahí tengo mi monolito 00:13:47
donde lo tengo todo 00:13:50
Y bueno, y no pasa nada 00:13:51
porque esto sigue siendo reutilizable 00:13:53
Yo puedo publicar 00:13:55
estas clases 00:13:56
en Mishar, en donde sea 00:13:59
y los pueden reutilizar y ya está, no pasa nada 00:14:01
Pero hombre, lo pongo quizá un poquito 00:14:03
más complicado 00:14:05
si quiero yo ser usado 00:14:06
de esta manera como más complicado 00:14:08
entonces, para hacer la arquitectura 00:14:10
más ágil, ahora ya en este mundo 00:14:12
de internet y de reutilización y de todo eso 00:14:14
para hacerla más ágil 00:14:16
pues podríamos hacer 00:14:17
podríamos programar 00:14:19
basándonos en una arquitectura 00:14:22
de microservicios 00:14:25
vale, ¿qué es un microservicio? 00:14:27
pues un servicio pequeñito 00:14:38
¿y qué es un servicio? 00:14:39
pues una utilidad para el universo 00:14:41
¿no? eso es un servicio, una utilidad 00:14:43
¿te estás enterando? 00:14:45
¿eh? 00:14:49
un microservicio es como el que tenéis ahí 00:14:51
encima cerrado, o sea, es que eso ya es un servicio 00:14:53
nulo, un null service 00:14:55
pues un microservicio es un servicio 00:14:57
eso, un servicio pequeñito 00:14:59
y un servicio es 00:15:01
una utilidad al universo 00:15:03
¿vale? entonces 00:15:05
uno, pues puede hacer una utilidad 00:15:07
para el universo, pues como 00:15:09
por ejemplo, validar la letra 00:15:11
del DNI, utilidades 00:15:13
que se pueden usar muchísimo, muchas 00:15:15
aplicaciones, entonces 00:15:17
pues uno hace esa 00:15:19
utilidad 00:15:21
consultar datos 00:15:21
de no sé qué para cualquier cosa 00:15:26
algo que necesite en su aplicación 00:15:28
pues va separando en servicios pequeñitos 00:15:30
utilidades pequeñitas 00:15:32
utilidades pequeñitas que van a usar 00:15:34
muchas de las aplicaciones de mi empresa 00:15:36
de donde sea, vale, pues esa utilidad 00:15:38
pequeñita yo ya la hago 00:15:40
y alguien tiene que llamarla 00:15:41
y tiene que devolver un valor 00:15:43
vale, esa utilidad pequeñita 00:15:45
¿cómo la publico? 00:15:47
bueno, pues de nuevo, podría yo meterla 00:15:50
en una clase, hacer el hard, decir toma el hard 00:15:51
y ya está, y llámame 00:15:53
vale, pero, bueno, es un poco feo, poco ágil 00:15:55
eso, ¿no? entonces, ¿cómo la podemos publicar? 00:15:58
pues podemos llevar esta utilidad 00:16:00
pequeñita a una 00:16:02
aplicación web 00:16:04
a un servidor web 00:16:05
perdón 00:16:08
¿vale? lo podemos llevar 00:16:08
Esta utilidad pequeñita 00:16:11
La programamos de tal manera 00:16:12
Ya veremos como 00:16:15
La programamos de tal manera 00:16:17
Que en lugar de arrancarla 00:16:19
La máquina virtual directamente 00:16:22
Como es una aplicación de escritorio 00:16:23
La arranca un servidor de aplicaciones 00:16:25
Que un servidor de aplicaciones es otra cosa distinta 00:16:28
¿Vale? 00:16:32
Un servidor de aplicaciones 00:16:33
Pues los que habéis hecho web 00:16:34
Lógicamente lo sabéis de memoria 00:16:35
Y cualquier cosa rara que diga 00:16:38
me la corregís 00:16:41
pero bueno, es un resumen muy resumido 00:16:43
un servidor de aplicaciones es otro tipo de máquina 00:16:45
no es una máquina virtual sin más 00:16:47
de mi ordenador, un servidor de aplicaciones 00:16:49
es capaz 00:16:51
que añade 00:16:52
pues un servidor de aplicaciones es capaz 00:16:53
de estar ahí escuchando con su oreja 00:16:57
de estar ahí escuchando peticiones 00:16:59
que le lleguen por un puerto 00:17:01
está ahí poco a poco arrancado 00:17:03
escuchando peticiones 00:17:05
y cuando esa petición le llega 00:17:06
él extrae de esa petición 00:17:08
get post 00:17:11
el tipo que sea y con los parámetros 00:17:11
que llegue, la información que le llegue 00:17:14
extrae de esa 00:17:16
todo ese paquete que le llega 00:17:18
soy get, soy post, tengo estos parámetros 00:17:20
voy a este sitio 00:17:22
te estoy invocando a este programa 00:17:24
te doy estos datos, de todo eso que le llega 00:17:26
ahí empaquetado, el servidor de aplicaciones 00:17:29
es capaz de pum 00:17:30
cargar este pequeño 00:17:32
código de ahí, es capaz de 00:17:34
cargarlo, lo carga 00:17:36
y esto ya sí que es un código Java que se ejecuta 00:17:38
accede a la base de datos, lo que haga 00:17:40
y ahí se queda cargado 00:17:42
ya él ahí cargadito, el servidor de aplicaciones 00:17:44
y ya esto se queda muy ágil 00:17:47
lo llama y el servidor de aplicaciones 00:17:48
pues es capaz de 00:17:51
mandar la respuesta 00:17:52
a ese request que le ha llegado 00:17:54
pues él ya puede construir 00:17:57
un response 00:17:59
¿vale? entonces mi aplicación 00:17:59
puede integrar llamadas 00:18:02
a estas 00:18:05
urls 00:18:07
y estas urls van invocando 00:18:08
esos pequeños servicios 00:18:11
¿vale? entonces eso es más ágil 00:18:12
que buscar mi dependencia, integrarla 00:18:15
en mi aplicación 00:18:17
eso va engordando, va engordando 00:18:18
dependo efectivamente de que la dependencia 00:18:20
esté disponible, sin embargo 00:18:23
los servicios se ejecutan en el 00:18:25
servidor de aplicaciones y ahí los tengo 00:18:27
yo los llamo 00:18:28
me da la respuesta y se acabó, entonces esta 00:18:30
arquitectura ya sí que está completamente distribuida 00:18:32
porque gran parte de mis funcionalidades 00:18:34
se están ejecutando en servidores de aplicaciones 00:18:37
y yo obtengo la respuesta y ya está 00:18:39
vale, pues a que venía 00:18:41
todo este rollo 00:18:43
todo este rollo venía a que 00:18:44
para 00:18:47
muchos de estos microservicios 00:18:49
una forma muy 00:18:51
ágil y muy fácilmente 00:18:53
parseable de recibirle 00:18:55
informaciones en un JSON, normalmente 00:18:58
cuando uno consulta datos de una base de datos 00:18:59
o pide cosas, lo que recibe 00:19:01
son objetos, eso es lo que quiere, objetos 00:19:03
porque objetos es con lo que trabaja su aplicación 00:19:05
trabaja con objetos, pues que mejor 00:19:07
manera de pasar 00:19:10
por esta tubería un objeto 00:19:11
que en un fichero de texto 00:19:13
JSON que lo representa 00:19:16
que mejor manera, bueno pues 00:19:17
el JSON ha encajado 00:19:19
perfectamente en esta arquitectura 00:19:21
¿vale? 00:19:23
entonces, estos pequeñitos 00:19:25
servicios web, pues 00:19:28
tendrán sus frameworks para 00:19:29
parsear estos JSON 00:19:31
para construirlos 00:19:32
cuando los mandan de salida, etc. 00:19:34
¿Vale? 00:19:37
Bueno, pues, ¿y de qué frameworks hablamos? 00:19:39
Que son necesarios, entonces, en cualquier 00:19:41
contexto en el que haya que parchear un JSON. 00:19:43
A ver, pues, 00:19:46
esencialmente, el 00:19:47
tocho, el gordo, el guapo, 00:19:48
el magnífico, 00:19:51
es el mismo. 00:19:53
Entonces, cuando tenemos una aplicación gorda 00:19:56
y nos ponemos a mirar sus dependencias, 00:19:58
es muy raro 00:20:00
que no aparezca entre sus dependencias 00:20:01
un paquete que diga 00:20:03
algo así, paster xml 00:20:06
punto jackson, bla bla bla 00:20:08
es raro, porque ese es un framework 00:20:09
enorme con un tocho con 00:20:12
millones de posibilidades y de cosas 00:20:14
entre ellas un parseo 00:20:16
muy eficiente del json 00:20:17
con miles de métodos 00:20:20
de los cuales uno 00:20:22
recuerda dos 00:20:24
pero no le hace falta recordar más, sabiendo la filosofía 00:20:25
de abajo, luego ya rápidamente 00:20:28
puede ir a hacer lo que 00:20:30
lo que necesite 00:20:31
¿vale? y el FasterXML 00:20:34
este, pues imagino que será otro 00:20:36
igual que el GlassFish 00:20:38
pues el FasterXML será otro 00:20:39
otro consorcio 00:20:42
de desarrolladores 00:20:43
¿vale? y entre lo que han desarrollado 00:20:45
pues esta cosa también 00:20:48
también está para 00:20:49
cuando nuestra 00:20:51
ambición está un poquito más 00:20:54
reducida 00:20:56
pues Google 00:20:57
tiene esta 00:20:59
¿Vale? 00:21:00
JSON 00:21:03
Y esta es más manejable, más amigable 00:21:04
Pero bueno, lo que hay de fondo es lo mismo 00:21:07
Tú parseas, te da un nodo 00:21:10
Un objeto 00:21:12
Nodo JSON y de ahí vas entrando 00:21:12
Y ya está 00:21:15
Esta es como más simplicita 00:21:16
Y esta es un poco más tocha 00:21:18
Entonces vamos a hacer un ejemplito con esta 00:21:20
¿Vale? 00:21:23
A ver, ejemplito que nos vamos a hacer 00:21:25
Eso 00:21:27
un lío completamente, porque 00:21:29
entre que encontremos los métodos, no sé qué 00:21:31
claro, pero es que ese es nuestro trabajo 00:21:33
hacernos un lío y sobrevivir 00:21:35
no, no, la simple la miráis vosotros 00:21:37
si la simple es la que vimos año pasado 00:21:39
pero es que cada año sois todos mucho 00:21:41
más listos, entonces este año ya pasamos 00:21:43
de la simple y nos vamos a esta directamente 00:21:45
pero no 00:21:48
no, al contrario 00:21:49
no quiero insultar vuestra inteligencia 00:21:50
Jason no tiene atributos 00:21:53
no, o sea 00:21:58
lo que está entre llaves 00:21:59
o hay que hacer como un xml 00:22:02
olvídate del xml 00:22:03
el xml lo hemos dejado atrás ahora mismo 00:22:05
vale, entonces 00:22:07
pues vamos a poner un ejemplito en el cual 00:22:10
con el jackson este, parseamos 00:22:12
un json, lo retocamos, lo volvemos a escribir 00:22:14
y ya está, y luego por último 00:22:16
lo vamos a 00:22:18
a usar 00:22:20
pues desde un servicio de estos 00:22:21
en un servidor de aplicaciones 00:22:23
vale, entonces nos vamos a hacer 00:22:25
un pequeñísimo 00:22:27
servicio de estos 00:22:30
un pequeñísimo servicio que use el 00:22:32
FasterXML 00:22:34
y ya está 00:22:34
pero lo vamos a hacer 00:22:37
desde sus tripas 00:22:39
desde lo que tiene en la base 00:22:41
de cero, no con esos envolventes 00:22:44
que se le ponen por encima de Spring Boot 00:22:46
de no sé qué, no, lo vamos a hacer con 00:22:48
destripado, desde cero 00:22:50
pero bueno, primero vamos a ver si nos aclaramos con el 00:22:51
Faster, con el Jackson este de aquí 00:22:53
venga 00:22:56
A ver 00:22:57
Pues vamos a ver 00:23:02
Abrimos 00:23:06
Ahora pongo la esta que no está puesta 00:23:12
Nuestro eclipse 00:23:14
Tengo 200.000 millones de eclipses 00:23:17
Ya no sé cuál es 00:23:20
El que tengo que abrir cada vez 00:23:22
Ahora mismo lo normal 00:23:24
Vamos a hacer un ejemplo con el XML 00:23:27
Para que la arquitectura nos funcione 00:23:29
Y luego ya mover eso 00:23:32
A un servicio web 00:23:34
Es moverlo al serplet y se acabó 00:23:36
No tiene más 00:23:37
Vale 00:23:38
Dígame 00:24:04
¿Eh? 00:24:08
Que lo haga grande 00:24:11
Vale 00:24:12
Venga, a ver 00:24:14
Lo empezamos de cero 00:24:16
Para que nos salgan todos los errores posibles 00:24:19
Del mundo y los arreglemos 00:24:21
no pasa nada porque tengo chuletitas 00:24:23
aquí de sobra para acudir a ellas 00:24:29
cuando haga falta y tenemos HGPT 00:24:30
así que vamos a sobrevivir 00:24:32
dentro de esta circunstancia terrible 00:24:34
que es trabajar con un Jason con el Jackson 00:24:36
entonces, vale 00:24:38
a ver, como vamos 00:24:40
lógicamente a necesitar dependencias 00:24:44
pues un Maven Project 00:24:47
todo lo más simple del mundo 00:24:48
vale 00:24:53
ficheros 00:25:06
Jason 00:25:09
Nuestro objetivo es ver solamente de qué va esto 00:25:10
¿Vale? No lógicamente 00:25:17
Meternos en todo el conocimiento posible 00:25:19
De Jackson porque es imposible 00:25:21
¡Hala! 00:25:23
Ya lo tenemos 00:25:27
Aquí 00:25:28
Vale 00:25:30
Vamos a, si decidimos que usamos Jackson 00:25:31
Pues vamos a necesitar poner aquí la dependencia 00:25:40
Bueno, antes que nada, que siempre se me olvida 00:25:43
Vamos a subir 00:25:44
La máquina virtual 00:25:46
Esto no es que sea crítico 00:25:48
La gran mayoría de las cosas que hacemos 00:25:51
Están soportadas en 1.8 00:25:53
Pero puede que algunas no 00:25:55
Entonces como 00:25:58
Estamos usando la última versión de todo 00:25:59
Pues venga 00:26:01
Yo voy a cambiar a la 00:26:02
Última mía 00:26:05
Aunque ahora ya tengo la 22 00:26:07
Ah perdón, este clip si igual no coge la 22 00:26:09
Vale 00:26:11
Y esto de aquí 00:26:18
En el 00:26:32
Web Developers 00:26:36
Que descargamos el otro día 00:26:39
Ya no me sale el POM rojo 00:26:40
Aunque esto no tenga la S 00:26:43
En el que 00:26:45
Es el primero en el que me ha pasado 00:26:48
Que ya no me salga 00:26:50
El plugin de Maven 00:26:52
Por lo que sea te cambia 00:26:55
Alguna versión que hay por aquí 00:26:56
Y en esa versión ya no sale ese error 00:26:58
No lo sé 00:26:59
Bueno pero no estás en el de Web Developers 00:27:00
Por eso, que a mí en el primero el que me he encontrado 00:27:06
Que no me sale es el de web developers del 25 00:27:08
Vale, pues nada, entonces 00:27:10
Dependencia 00:27:14
Ya sabemos cuál vamos a usar 00:27:15
Uy, estoy en 00:27:17
Sí 00:27:19
Nos vamos aquí al 00:27:19
Al repositorio 00:27:24
Uy, qué malo, aquí 00:27:28
Y ahora la palabra clave la tenemos 00:27:29
Que es 00:27:33
Esta 00:27:34
la palabra clave 00:27:41
la tenemos 00:27:43
pues esta 00:27:44
datavine 00:27:50
lo de tools 00:27:55
no lo había 00:28:04
venga, vamos a probar con esta 00:28:04
de axon core 00:28:07
la segunda que sale, espérate 00:28:09
si yo pongo esto 00:28:11
no, pero esta no 00:28:14
no, venga 00:28:26
vamos a probar con esto primero de aquí 00:28:28
y si no, pues 00:28:31
vale 00:28:33
es que claro 00:28:34
octubre, 22 de octubre 00:28:43
estas cosas que hacemos, en realidad no las 00:28:47
hacemos bien, o sea, tiramos por 00:28:49
defecto de lo 00:28:51
que se subió hace una semana 00:28:52
y normalmente uno trabaja 00:28:55
con arquitecturas que están ya más consolidadas 00:28:57
pero bueno, vamos a probar con esto y si no, ponemos 00:28:59
la dependencia que tengo yo en mis proyectos 00:29:01
y ya está 00:29:03
la cogí de aquí también 00:29:04
Venga, vamos a lanzarnos a esto 00:29:07
Ala 00:29:10
Y ahora 00:29:17
He cogido 00:29:31
Jackson Core 00:29:34
Core me suena pues al núcleo de 00:29:41
Si, he cogido lo último 00:29:43
Que me ha salido el Jackson Core 00:29:48
No, pero porque 00:29:50
No está sonando correcto 00:29:55
Vale, vamos a ver que 00:29:59
Dependencia nos han salido 00:30:01
Jackson Core, uff 00:30:03
es que esto ha cambiado mucho el nombre, es muy raro 00:30:06
bueno, vamos a ver si con estas 00:30:09
me vale, y si no 00:30:11
habrá que seguir buscando 00:30:12
recordad que si se os vuelve loco alguna vez 00:30:14
insiste en sacar errores 00:30:23
de que ha perdido rutas 00:30:25
siempre podéis 00:30:26
hacerle un 00:30:28
un actualizar 00:30:30
el proyecto 00:30:33
¿vale? 00:30:34
¿vale? 00:30:36
porque hay veces, cuando haya tantas dependencias 00:30:39
y tantos líos, hay veces que pierde 00:30:42
el class path, ya se desvirtúa 00:30:44
entonces actualizando 00:30:46
proyecto 00:30:48
con maven, actualizar proyecto 00:30:49
pues las rutas rotas 00:30:51
te las reconstruye, te recompila todo 00:30:54
porque hay veces que salen 00:30:56
cosas rojitas y dices, no tengo ni idea de donde salen 00:30:58
si es que está todo bien 00:31:00
está todo bien 00:31:01
esos rojos que salen estando todo bien 00:31:02
es porque se ha roto alguno de los 00:31:06
enlaces de las librerías 00:31:08
también siempre una cosa 00:31:10
buena 00:31:20
que en caso de desesperación cuando uno se le 00:31:21
rompe todo y le empiezas a ir rojo 00:31:24
cuando ya uno ha probado mil dependencias, las ha quitado 00:31:26
ha probado mil cosas para que funcionen 00:31:28
ha incorporado mil librerías, las ha vuelto a quitar 00:31:30
llega un momento en que ya 00:31:32
se ha vuelto loco 00:31:34
el eclipse y ya 00:31:36
no sabe ni que claspas tiene, cual no, ha roto 00:31:38
algunos, en algunos ha generado 00:31:40
los compilados y en otros no 00:31:42
pues una cosa que 00:31:44
muchas veces hace magia maravillosa 00:31:46
es en proyecto 00:31:48
¿vale? 00:31:50
esta 00:31:53
a ver, tenemos dos cosas 00:31:53
primero, caso de desesperación 00:31:57
me sale rojo 00:32:00
y no se debe a que 00:32:01
tenga yo errores en compilación 00:32:02
o que me falten dependencias, lo tengo todo 00:32:05
pero aún así el eclipse me dice que le falta 00:32:07
algo, eso suele deberse 00:32:09
a que le falta 00:32:11
a que no encuentra clases compiladas 00:32:12
en algún sitio donde debería, según el 00:32:16
Clashpad. Suele deberse siempre a eso. 00:32:18
Él necesita una clase 00:32:20
compilada, un punto clase en alguna parte 00:32:22
y ya la ha perdido. Con tanto 00:32:24
desmadre de incorporar, soltar, incorporar, 00:32:25
soltar, ya lo ha perdido. 00:32:28
Entonces, ahí conviene 00:32:30
recompilar todo de nuevas para que 00:32:31
todas las rutas ya se llenen 00:32:34
correctamente con lo que tienen que tener. 00:32:35
Bueno, pues en ese caso de desesperación, 00:32:37
tanto el actualizar el 00:32:40
proyecto Maven 00:32:41
y aquí 00:32:42
que también lo podéis hacer aquí 00:32:45
con botón derecho, Maven o 00:32:47
Date Project, como el 00:32:49
Clean, este 00:32:51
el Clean te dice, venga 00:32:53
¿qué proyecto quieres limpiar? Estoy desesperada 00:32:55
quiero limpiar este 00:32:57
pues te reconstruye un poquito, te recompila 00:32:58
todo, te hace cosas mágicas 00:33:02
y en muchas veces 00:33:03
después de llevar 00:33:05
varias horas diciendo, esto no tiene ningún 00:33:07
sentido, pum, haces un Clean y dices 00:33:09
Pero sí, ya está todo, todo arreglado 00:33:11
¿Por qué no lo habré hecho antes? 00:33:13
¿Vale? 00:33:16
Bueno 00:33:17
Vale, pues entonces 00:33:18
Esto que me ha importado aquí 00:33:21
Es que no me gusta nada, pero bueno, vamos a probar 00:33:23
Igual es que la versión del 22 de octubre 00:33:26
Se llama Tools y ya está 00:33:27
Pero bueno, vamos a probar 00:33:29
Si no, nos vamos a una anterior y listo 00:33:31
Vamos a hacer un JSON 00:33:33
Cualquerucho, normalucho 00:33:36
Venga, a ver 00:33:38
Lo podría hacer en cualquier lado 00:33:40
Vamos a hacerlo en el raíz para no arrastrar la ruta 00:33:43
Porque ya sabemos de memoria 00:33:45
En los files 00:33:47
Cómo poner la ruta para abrirlos 00:33:49
Si están fuera de mi proyecto 00:33:51
Entonces lo vamos a hacer aquí 00:33:52
Y nos ahorramos problemas 00:33:54
Pues te haces un nuevo fichero 00:33:56
Te vas al raíz, nuevo fichero y ya está 00:34:04
Venga 00:34:06
Esta va a ser mi información 00:34:08
La mía 00:34:11
Yo soy mi alumno 00:34:12
Pepit 00:34:13
Vale 00:34:14
Vale, pues esto sería 00:34:17
Un JSON válido 00:34:23
Porque tiene un objeto 00:34:24
Y aquí, pues que 00:34:27
Vale, cada uno ponga la información 00:34:32
Que le dé la gana, esto es un objeto instanciado 00:34:37
Vale 00:34:40
Para no volvernos 00:34:41
Muy locos, pues instituto 00:34:46
Instituto 00:34:48
Va a ser 00:34:49
Y aquí este objeto mío ya se ha terminado y ahora tengo, pues por ejemplo, módulos. 00:34:51
Aquí, módulos va a ser un array de objetos. 00:35:27
El primero, nombre, pues acceso a datos y nota, pues un 10. 00:35:31
Y otro módulo 00:35:46
Tengo por ahí 00:35:48
Procesos 00:35:48
Procesos 00:36:00
Vale 00:36:01
Este es un JSON válido 00:36:04
Uy, bueno, me falta la llave de cierre 00:36:08
¿Verdad que sí? 00:36:10
Vale 00:36:13
Este es un JSON válido que tiene un único objeto 00:36:13
Pero también sería un JSON válido 00:36:16
Un array 00:36:19
Con muchos de estos 00:36:20
¿Vale? 00:36:22
también sería un JSON 00:36:23
válido, un array con muchos de estos 00:36:25
y aquí no hay 00:36:27
esquema, ni hay nada 00:36:29
de eso, o sea, un segundín 00:36:31
aquí no hay esquema, cada objeto puede ser 00:36:33
de su padre, de su madre, de quien le dé la gana 00:36:35
en alguno le pueden faltar 00:36:38
propiedades que el otro tiene, aquí no 00:36:39
hay esquemas que validar, ni hay nada 00:36:41
¿vale? dime 00:36:43
¿por qué es un array? el valor 00:36:44
de la clave módulos es un array 00:36:49
y un array se hace entre corchetes 00:36:51
con los elementos separados por con. 00:36:53
Perdón, que este sí solo tiene dos. 00:36:55
Y a su vez, 00:36:58
los elementos del array, yo en este caso 00:36:59
he hecho que sean objetos, pero podría ser 00:37:01
un valor sencillo, una cadena, 00:37:03
un número, ¿vale? Dime. 00:37:05
¿Por qué hacía un corchete? 00:37:08
¿Pengo los corchetes? 00:37:10
No. Ah, que me da una llave. 00:37:12
Tengo la llave que me cierra este objeto, 00:37:14
este corchete que me cierra 00:37:16
este array, esta llave que me cierra 00:37:17
el valor instituto, 00:37:20
No, pero está cerrada por la llave de en medio 00:37:21
La de la coma 00:37:24
El de nombre localidad 00:37:25
En el medio 00:37:28
A ver, que lo mire aquí 00:37:29
Que ahí no veo nada, vamos a ver 00:37:32
A ver 00:37:34
Instituto 00:37:35
Ah, vale, vale 00:37:38
Que los módulos no están dentro del instituto 00:37:40
Vale, vale, vale 00:37:42
Entonces, el array 00:37:43
Se cierra aquí, con lo cual este objeto 00:37:45
Esta llave sobra, vale 00:37:48
Vale. Bueno, pues este es mi JSON. Pues, entonces, aquí lo normal, lógicamente, es trabajar con un modelo de objetos. No es necesario. Jackson puede parsear esto a object o a map de object y tú vas sacando de ahí. 00:37:49
Pero no es la forma de trabajo habitual 00:38:22
O sea, esto lo podría 00:38:25
Parsear a un map 00:38:26
Porque son pares clave de valor 00:38:27
A un map de object 00:38:31
¿Vale? 00:38:32
Lo podría parsear a un map 00:38:34
De string object, perdón 00:38:36
Esto se podría parsear a un map 00:38:39
Directamente 00:38:41
Donde los elementos del map serían 00:38:42
Clave nombre, el object valor esto 00:38:44
Clave instituto, el object 00:38:47
Valor todo esto 00:38:49
es decir, el map sería de string 00:38:50
object, donde cada 00:38:53
object sería cualquier cosa 00:38:54
aquí sería una lista 00:38:56
de elementos, aquí sería un objeto 00:38:58
aquí sería un string 00:39:00
pero bueno, parsear a map 00:39:02
object, ir entrando en el 00:39:04
object para ir haciendo casting 00:39:06
en función de lo que sea, pues bueno, es la forma 00:39:08
de trabajo habitual 00:39:10
no vamos a entrar por ahí, ¿vale? pero bueno 00:39:12
podríamos directamente no tener 00:39:14
ningún modelo en nuestra aplicación 00:39:16
pero vamos a hacerlo en modelo 00:39:18
Vamos a hacerle un modelo. Entonces, el modelo aquí implicaría que yo tengo mi clase alumno. Y aquí en el modelo yo tendría mi clase alumno y mi clase alumno pues tendría sus propiedades string nombre e instituto, instituto. 00:39:20
Y tendría también el que 00:39:53
Pues una lista 00:40:17
De módulos 00:40:18
¿Verdad? Instituto y una lista 00:40:23
De módulos 00:40:25
Getter y setter, por ahora dejamos 00:40:27
Constructores, tu string, todo eso por ser rápidos 00:40:40
Si nos hacen falta 00:40:43
Más adelante los ponemos 00:40:44
¿Vale? 00:40:46
Dime 00:40:48
Nada que te quede directamente 00:40:48
El punto JSON 00:40:52
Dentro de la distribución JDK 00:40:53
Que no sea a través de una dependencia 00:40:59
Como JSON, FasterXML 00:41:01
Porque lo que vamos a hacer ahora 00:41:03
Es precisamente lo que me estás diciendo 00:41:04
Pero con Jackson 00:41:05
Claro, pero me refiero 00:41:06
Tú haces un objeto 00:41:07
Y tienes un método 00:41:08
Y ese método te crea un JSON 00:41:11
Básicamente 00:41:14
A ver 00:41:15
Tú tienes un objeto 00:41:17
Para que ese objeto tenga un método 00:41:19
Tienes que haberlo metido ahí 00:41:21
O ser de object 00:41:22
¿No? 00:41:23
Entonces tú puedes hacer ahí un método 00:41:24
Pero dentro de ese método 00:41:26
Tendrás que llamar a Jackson para hacer eso 00:41:27
O sea, Jackson tiene un método que te coge un objeto 00:41:29
Y te lo pasa a Jason 00:41:31
Pero lo tiene Jackson 00:41:32
Este objeto alumno 00:41:34
Solo tiene lo que tú le pongas ahí o lo he heredado de object 00:41:37
Y no hereda nada de object 00:41:39
Jackson 00:41:41
Jackson o Jason 00:41:49
Son todos los frameworks que hay 00:41:52
Que lo hacen 00:41:53
Si te refieres a si el JDK 00:41:54
Te trae ya algo que integre eso 00:42:00
O sea, lo tienes 00:42:01
O usas Jackson, o usas Gison 00:42:04
O usas otras librerías que hay 00:42:07
A ver, paramos un segundín 00:42:09
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:
7
Fecha:
25 de noviembre de 2025 - 13:46
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
182.05 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid