Saltar navegación

Persistencia datos 2: Serializable - 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 17 de marzo de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a acabar esta clase, por lo tanto, si habláis, me estáis dando la autorización a que grabe vuestra voz. 00:00:00
Vale, entonces, hasta ahora hemos visto cómo escribir un fichero de texto, escribir un fichero binario, ¿vale? 00:00:08
Hemos empezado a mirar la posibilidad de guardar objetos y la primera opción que hemos tenido es, 00:00:15
oye, mira, mi objeto lo represento como una cadena de texto, como un string, y lo guardo en un fichero de texto. 00:00:22
Cuando lo voy a leer, pillo ese fichero de texto, lo reinterpreto según el formato que había elegido, 00:00:31
y a partir de allí me recreo el objeto, ¿vale? 00:00:37
Hemos visto también, en el ejemplo que hemos hecho en clase, que esta materialización-desmaterialización de los objetos, 00:00:40
o sea, de cómo los creo, cómo los deshago, cómo los guardo, pues se va complicando, sobre todo cuando aumento las referencias a otros objetos. 00:00:48
O sea, cuando mi objeto tiene como atributos alguna variable cuyo tipo es otros objetos, pues allí se puede complicar. 00:00:57
Se complica todavía más cuando tengo objetos bidireccionales, entre comillas, o sea, un alumno que tiene materias y las materias que tiene una lista de alumnos. 00:01:08
Pues puede ser algún problema por ahí. Habría que hacer varios pasos, dejar la primera vez que intento crear, por ejemplo, las materias, dejar esa parte de alumnos vacía, luego crear todos los alumnos con sus materias y luego volver a rellenar las materias y cosas así. 00:01:18
De esta forma es un trabajo complejo y que hoy en día no se hace, ¿vale? 00:01:35
La empresa nunca suspirará de hacerlo de esta forma, ¿vale? 00:01:43
Nos viene bien a nosotros porque es un mecanismo de razonar, de razonamiento, que está bien para nosotros 00:01:49
y porque tenemos que aprender a escribir y leer los ficheros y esto nos viene bien para leer los ficheros. 00:01:55
¿Cómo se hace entonces en la realidad? 00:02:02
En realidad hay varias soluciones, ¿vale? Desde la serialización RAW, que es la que vemos ahora, a la serialización textual, es decir, guardar los ficheros en un formato XML o JSON o lo que sea. 00:02:03
Normalmente hay librerías, hay dependencias que yo puedo poner en mi proyecto para que tenga 00:02:21
sustancialmente un elemento que me diga, oye mira, guárdame este fichero, guárdame este objeto en un fichero 00:02:29
y él lo interprete como él quiere, él lo ponga ahí como un XML o como un JSON, ¿vale? 00:02:35
Con las ventajas que puede tener XML o JSON, o sea que son interpretables por el ser humano. 00:02:41
si yo escribo un fichero xml 00:02:47
luego lo puedo abrir y ver 00:02:49
que está escrito allí dentro hasta modificar 00:02:51
si yo quisiera, ¿vale? 00:02:53
Pero con las desventajas de xml 00:02:55
y json, muchas veces son 00:02:57
lentos porque 00:02:59
tienes que procesar un fichero de texto 00:03:00
al final 00:03:03
La solución 00:03:03
más práctica, más 00:03:07
avanzada sería utilizar 00:03:09
una base de datos con un 00:03:11
object relational mapping 00:03:13
¿vale? Pero esto 00:03:15
en años futuros en segundo posiblemente veréis algo de estas cosas aquí vale aquí donde llegaremos 00:03:17
nosotros es si tenemos el tiempo a ver un poquito de conexión a una base de datos vale pero no la 00:03:24
parte de OR simplemente tengo una base de datos necesito datos de esta base de datos pues se lo 00:03:31
pido y me da los datos como si hiciera solamente hacer una query SQL y los datos en vez de tenerlos 00:03:37
en la consola de mi sgbd pues lo tengo dentro del programa definido como una lista de récords 00:03:45
que puedo ir a mirar vale entonces nosotros hoy vemos la serialización raw si objetos serializables 00:03:53
vale para que un objeto sea serializable tiene que implementar la clase serializable 00:04:05
Sostancialmente, no sé cuánto esto sea correcto desde una perspectiva de purismo, de informática, 00:04:11
pero pensarlo como yo puedo pillar un objeto y describirlo como una serie de ceros y unos. 00:04:22
si mi objeto puede hacer esto 00:04:37
o sea, implementa la clase serializable, entonces yo le estoy diciendo 00:04:42
oye mira, tú puedes transformar este objeto en una secuencia 00:04:46
de ceros y unos, estos ceros y unos los puedo disparar 00:04:49
en uno de los canales de comunicaciones que tengo, como por ejemplo 00:04:54
un output streamer o un input streamer 00:04:58
o un file reader o lo que sea, ¿vale? y como 00:05:01
este objeto, al fin y al cabo todo en informática 00:05:05
son una tira de ceros y unos, si yo puedo escribir estos ceros y unos 00:05:09
en un fichero y guardarlos allí, es sustancialmente 00:05:14
guardado el objeto, y si luego estos mismos ceros y unos 00:05:18
los vuelvo a leer al revés, pues sustancialmente estoy importando 00:05:21
otra vez lo que estaba escrito en mi memoria RAM cuando había creado ese objeto. 00:05:26
Claramente es más complejo de así, hay que 00:05:31
ver si este objeto como atributos tiene otros objetos pues entonces que hago 00:05:34
posiblemente todo un objeto que sea serializable puede contener como 00:05:38
atributos sólo otros objetos que sean serializable porque si no tengo un 00:05:45
problema tengo dentro un objeto que no puedo serializar no puedo 00:05:49
escribir en un fichero o leer de un fichero pues sería un problema escribir 00:05:53
todo el objeto que he creado. Esto, cuando y si en un futuro veréis la parte de comunicación con 00:05:59
Socket, que sirve para que dos procesos o dos programas en ordenadores distintos comuniquen 00:06:10
entre ellos, pues vuelve a ser lo mismo. Yo puedo pasar un objeto de un lado a otro serializándolo 00:06:17
y pasándolo por un canal de este estilo, en vez de escribirlo en un fichero, en un tubo que 00:06:23
un file reader o un output stream o lo que sea, que en vez que al otro lado 00:06:30
haber un fichero, entonces lo que escribo allí dentro acaba en este fichero, pues al otro 00:06:36
lado tengo otro programa que está allí con un input stream, entonces lo que escribo por un lado 00:06:41
lo lee el otro. Claramente, cuando yo paso un objeto de este estilo, no es el mismo objeto. 00:06:45
Si tengo dos ordenadores, serán dos objetos distintos. Entonces, si luego modifico un 00:06:53
objeto en uno de los ordenadores, el otro ordenador no ve afectado ese objeto. Es una copia, no es una 00:06:58
referencia. Aún así, es realmente complejo esto de la señalización de cómo poner los 00:07:05
oficieros y cosas por el estilo, de cómo poner los datos tanto del oficiero como del otro lado, 00:07:16
y la otra máquina hace lo que puede para mantener las referencias y cosas así. Pero si vosotros os 00:07:21
os empeñáis, posiblemente conseguís destruir lo que es la consistencia de datos de JavaScript. 00:07:29
Repito que esto se usaba, era una forma de guardar los datos, pero hoy en día no es 00:07:41
la forma más propia. 00:07:48
Aún así, os introduzco al concepto de serialización que sí sigue siendo necesario para poder 00:07:51
escribir ficheros donde sea, o mandarlos. Entonces, hemos dicho que el objeto que tengo 00:07:56
que utilizar tiene que ser implementar la interfaz serialized. Estos atributos han de ser de tipo 00:08:04
simple, o sea de tipo primitivo, o otros objetos serialized. Para escribir un objeto en disco, 00:08:12
ahora tengo 00:08:20
object output stream 00:08:21
¿vale? entonces es un 00:08:24
output stream que 00:08:26
aumentado, es mejorado 00:08:29
para la gestión de objetos 00:08:31
¿vale? entonces por ejemplo 00:08:33
aquí tengo, como antes hacía como un buffer 00:08:35
de lo que sea, pues ahora tengo 00:08:38
un object output stream 00:08:39
que tiene dentro un file output stream del fichero 00:08:41
que yo quiera, donde quiero escribir 00:08:44
¿vale? para escribir un objeto 00:08:46
tengo una 00:08:48
un método que es WriteObject. Entonces WriteObject de un objeto serializable pues me permite escribir 00:08:49
esto en Fichero. ¿Con qué formato? No tengo idea, no quiero saberlo. Quiero que sea la Java 00:08:58
Virtual Machine que se encargue de guardarlo y si hay alguna referencia que se encargue ella, 00:09:10
si hay algún problema que se encargue ahí. Está claro que tiene su limitación. Para leerlo pues tengo 00:09:16
un object inputStream, se crea así, y tengo un readObject. Tened en cuenta que cuando leo un 00:09:23
objeto pues leo un objeto y luego también tendré que ver qué pasa. Si lo he podido leer, si lo que he leído es null, si... 00:09:32
Una vez que tenga este objeto, pues puedo intentar castearlo al tipo correcto de este objeto, ¿vale? 00:09:46
Pero, cuidado. 00:09:55
También se suele utilizar la serialización para transmitir objetos en red, ¿vale? 00:09:57
Y, en ambos casos, la JavaScript gestiona el formato de los datos del objeto u objetos serializados, ¿vale? 00:10:02
Si yo le digo, guárdame este objeto en el fichero, luego es ella que se encarga de todo. 00:10:11
Inconvenientes de la serialización. 00:10:20
¿Qué puedo encontrarme por ahí? 00:10:22
La clase OutputStreamer no funciona bien del todo cuando intentamos reutilizar una misma referencia para serializar objetos diferentes. 00:10:25
Si yo tengo la referencia, el objeto X, y lo guardo. 00:10:34
Luego modifico cosas e intento guardarlo otra vez, a veces se guía. 00:10:41
Esto es basado sobre todo por el hecho que se intenta optimizar estas cosas. 00:10:48
Entonces hay veces que si yo ya he hecho una escritura de un fichero, 00:10:57
en un fichero de un objeto, y tú me dices vuelve a escribirlo, 00:11:02
pues yo no te lo reescribo porque asumo que ya lo he escrito, 00:11:05
porque lo tengo que escribir otra vez. 00:11:08
entonces 00:11:09
muchas veces para poder 00:11:11
lograr esto tengo que 00:11:13
cerrar 00:11:16
todos los canales de comunicación que tenía 00:11:16
volver a abrirlos 00:11:20
y entonces él no se acuerda que 00:11:22
antes lo había guardado otra vez y volver 00:11:24
a guardarlo 00:11:26
lo que hace engorrosas algunas 00:11:26
opciones porque a veces 00:11:30
para hacer esto pues tengo que reescribir 00:11:31
el bloque de datos enteros 00:11:34
en vez de modificar una cosa pequeña 00:11:35
también cuando output stream escribe 00:11:37
usa una cabecera 00:11:41
¿vale? entonces 00:11:43
escribe en el fichero 00:11:45
no escribe directamente 00:11:47
los objetos, antes pone una cabecera 00:11:49
pone con una introducción 00:11:51
y luego pone los objetos que tú has dicho que guardas 00:11:53
¿vale? si ahora tú vienes 00:11:55
y en vez de crear un objeto 00:11:58
nuevo desde cero 00:11:59
tú dices añádeme más objetos 00:12:00
al añadir más objetos 00:12:03
como hemos hecho en el ejemplo nuestro 00:12:06
de append, de añadirlo al final del fichero 00:12:08
él vuelve a escribir la cabecera 00:12:11
entonces encontramos un fichero 00:12:13
que tiene una cabecera, luego unos objetos 00:12:17
otra vez una cabecera, otra vez unos objetos 00:12:20
y esto cuando lo va a leer no lo interpreta bien 00:12:22
porque no se esperan dos cabeceras 00:12:26
entonces aquí hay 00:12:30
o que reescribir el fichero entero siempre 00:12:32
o si quiero añadir las cosas 00:12:34
al final, pues tengo que 00:12:36
toquetear otro método 00:12:38
y hacer algunas cosas avanzadas. 00:12:39
¿Vale? 00:12:44
Intentaremos hacerlo. 00:12:44
Por estas razones, es mejor 00:12:47
no utilizar ficheros 00:12:48
ni civilización con métodos de persistencia. 00:12:50
Sí, no uno de ellos. 00:12:52
¿Vale? 00:12:55
¿Por qué entonces no hacemos eso directamente? 00:12:56
Porque lleva un mogollón 00:12:59
de tiempo 00:13:01
aparte saber la parte teórica 00:13:01
que necesitamos saber, pero luego también habría 00:13:06
que desplegar una base de datos, hacer que funcione 00:13:10
crearse la base de datos, crear un ORM, configurar 00:13:12
el ORM y eso se vuelve un poco 00:13:16
complejo y digamos que para el nivel 00:13:18
que estáis vosotros y para lo que es programación 00:13:21
tampoco es tan útil, o sea, vosotros estáis a un nivel muy bajo 00:13:24
de aprender a programar, ¿vale? Entonces las cosas avanzadas 00:13:28
la veréis el próximo año, cuando hayáis aprendido, habréis pasado este curso, sepáis programar, 00:13:31
y entonces, sobre la base de programación, pues los profesores de segundos os harán ver cosas bastante más avanzadas. 00:13:38
¿Dudas? Hasta aquí. 00:13:47
Entonces, aquí viene, este de aquí es otro ejemplo de lectura de texto sin báceres reader, ¿vale? 00:13:51
Esto es solo un FileWriter, perdón, esta es una escritura sin nada más, es solo utilizando FileWriter, veis que escribe un string, ¿vale? 00:13:57
Este es otro ejemplo de lectura de texto sin utilizar el BufferedReader, ¿vale? 00:14:07
Va utilizando read, ¿vale? Utilizando sustantivamente carácter por carácter. 00:14:13
Estos son ficheros binarios de escribir un fichero binario utilizando FileOutputStream 00:14:19
y escribiendo cosas, este de aquí es un fichero binario de lectura, ¿vale? 00:14:28
Entonces lo tenéis allí en los ejemplos, lo podéis mirar. 00:14:34
Lo que nos interesa es esto, ¿vale? 00:14:38
Es ficheros binarios donde utilizo ObjectsOutputStream. 00:14:41
Sustantialmente esto es voy a escribir un objeto en un fichero, pero recuerda que cuando yo escribo 00:14:46
un objeto en un fichero, este fichero no es un fichero de texto, si lo abro no entiendo lo que 00:14:54
está escribiendo, es un código, es binario que entenderá la Javascript Machine a la hora de 00:15:03
importar otra vez a la hora de materializar otra vez esto entiende vale entonces por ejemplo aquí 00:15:09
tengo un file output stream la base es siempre la misma el file output stream se conecta a este 00:15:19
fichero de aquí que tengo por aquí pues lo que tengo ahora es también un object output stream 00:15:25
el object output stream pilla el file output stream que está conectado con el fichero y luego tengo 00:15:31
varios métodos como WriteBoolean, WriteDouble, WriteCharge, WriteInt, Write2tf. En particular 00:15:38
a nosotros nos interesa el método WriteObject, que me pide un objeto y me escribe un objeto. 00:15:46
Pero puedo usar este, el ObjectOutputStream también para escribir un tipo booleano, o 00:15:52
sea un tipo primitivo, usando el método correcto. Desde la perspectiva de layer, misma cosa, 00:15:59
inputStream, objectInputStream 00:16:06
con esto de aquí los conecto 00:16:08
de esta forma y luego puedo 00:16:10
leer varias cosas. En particular 00:16:12
puedo leer el 00:16:14
readObject que lee un 00:16:16
objeto. 00:16:18
Esto es una clase 00:16:22
¿vale? Para que sea 00:16:24
serializable tiene que implementarse en el 00:16:25
IceBall. Si no pongo implementarse en el IceBall 00:16:27
no funciona. Es que aquí tiene 00:16:30
sus cosas. Ahora cuando la voy a escribir 00:16:31
pues me escribirá esta 00:16:34
sin forma. 00:16:35
Tengo aquí, por ejemplo, varias personas y lo que está haciendo aquí es BrightObject. 00:16:36
Está claro que este es un ejemplo básico. Si tuviera esto sería mejor tenerlo en una lista, 00:16:43
recorrer la lista y escribir los objetos en la lista. O un array o lo que sea. 00:16:50
Lectura, pues me pongo aquí y hago muchas veces, mientras haya sustancialmente bits 00:16:56
para leer en lo que estoy leyendo, que es un FileInputStream, pues entonces me creo 00:17:07
una nueva persona y esta persona, bueno, esto en realidad podría evitarlo, la leo con ReadObject. 00:17:15
fijaos que obj.readObject me daría un objeto y entonces lo casteo a la persona asumiendo 00:17:24
que sepa que es una persona. Y a este punto la tengo. Y ya está. Aquí viene un poco 00:17:33
de jerarquía de clases de qué deriva de quién, qué opciones hay, cosas por el estilo. 00:17:44
que pasaréis el fin de semana mirando la diferencia entre estas varias clases porque sé que os encanta 00:17:51
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
17 de marzo de 2026 - 12:53
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
18′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
151.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid