Saltar navegación

20251104 EjemploAppWeb_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 4 de noviembre de 2025 por Raquel G.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

he empezado a grabar. ¿Qué decías 00:00:00
Estefano el año pasado? ¿Alguien tiene algo en contra 00:00:02
de que salga su voz en la grabación? 00:00:04
Ah, es verdad. 00:00:06
Que hable ahora o le doy dos hostias. 00:00:07
Eso decía, ¿no? 00:00:10
Pero no tienes que romperme, voy a casa. 00:00:10
Venga. 00:00:13
Pues ya está. Entonces, vamos a hacer primero 00:00:15
el formulario, ¿vale? 00:00:17
Entonces, 00:00:21
a ver, el formulario, vosotros sabéis hacer 00:00:23
un formulario muchísimo mejor que yo. Lo estoy haciendo, 00:00:25
insisto, todo así, a pelo, sin framework 00:00:27
ni nada, entonces 00:00:29
este es 00:00:30
un formulario sencillito 00:00:32
esto lo he ido poniendo 00:00:35
comentarios porque como lo 00:00:37
he ido poniendo comentarios porque como lo voy 00:00:39
a subir pues para que se queden los 00:00:44
vale, que yo he ido 00:00:46
poniendo comentarios porque como este proyecto 00:00:50
cuando esté completo ya sí que lo voy a subir 00:00:52
pues para que tengáis aquí 00:00:55
las cosas que vamos diciendo, algunas porque 00:00:56
otras irán surgiendo, vale 00:00:58
pues entonces, este es un formulario 00:01:00
normalito y corrientito que claro que sabéis hacer 00:01:02
¿vale? y este formulario 00:01:05
tiene 00:01:07
dos 00:01:07
únicos comandos 00:01:10
etiquetas 00:01:12
de subida de datos 00:01:14
¿vale? 00:01:16
esta input 00:01:18
para coger un fichero binario 00:01:19
¿vale? 00:01:22
coger un fichero y meterlo en binario 00:01:24
dentro del cuerpo 00:01:27
de la petición 00:01:29
vale 00:01:30
y este, que es el que 00:01:31
desencadenar ya la acción de subida 00:01:33
lógicamente, vale 00:01:36
los dos 00:01:38
comandos de 00:01:39
entrada 00:01:42
estos dos los conocéis, los dos 00:01:44
símbolos, vale 00:01:46
vale, entonces este formulario 00:01:46
tendría 00:01:50
dos opciones 00:01:52
de envío, get y post, como también 00:01:53
sabéis, pero repito, este formulario 00:01:56
va a llevar dentro metido 00:01:58
un fichero binario, que es el fichero local 00:02:00
que yo voy a seleccionar a través de este comando 00:02:02
entonces el fichero 00:02:04
el método get 00:02:06
¿cómo envía las cosas? 00:02:07
las envía en la cabecera 00:02:10
de la url, ¿verdad? 00:02:12
en la misma cabecera 00:02:14
entonces un fichero binario tocho en la cabecera 00:02:15
de la url, pues no mola 00:02:18
con lo cual, post 00:02:20
entonces, si el método 00:02:21
la forma de envío del formulario 00:02:24
es post, pues 00:02:26
todo ese fichero binario ahora va en el cuerpo 00:02:28
de la petición, en el cuerpo, no va en la 00:02:30
cabecera 00:02:33
¿vale? y luego además 00:02:33
para que realmente, para cuando 00:02:37
vamos a subir un fichero, pues 00:02:38
tenemos que poner esto 00:02:40
para indicar que 00:02:41
en el cuerpo van cosas 00:02:44
de diferente 00:02:46
información, que pueden ir 00:02:48
parámetros en la cabecera, pero luego 00:02:50
van a ir binarios en el cuerpo 00:02:52
entonces para decir que es un, que tiene 00:02:54
muchas partes de alguna manera ¿no? 00:02:56
Bueno, entonces, y esta es la URL que se va a invocar en el servidor cuando se haga el submit. 00:02:58
Entonces, ¿verdad que sí? 00:03:14
Esta se supone 00:03:17
Que esta URL 00:03:18
Lógicamente, se supone que esto va 00:03:21
Concatenado 00:03:23
A la URL base 00:03:25
En la que estaba 00:03:26
Este formulario colgado 00:03:29
Este formulario lo hemos invocado en una URL 00:03:30
Se ha servido desde 00:03:33
Este recurso 00:03:34
¿Verdad? El formulario es un recurso 00:03:36
Del servidor 00:03:38
Y ese recurso se ha invocado desde una URL 00:03:39
barra el recurso 00:03:42
¿verdad? 00:03:45
Bueno, pues esa URL base 00:03:46
será la que concatenada 00:03:48
a esto que yo he puesto aquí 00:03:50
construya la URL 00:03:52
que el servidor 00:03:55
va a tratar de localizar 00:03:57
para hacer 00:03:59
lo que tenga que hacer 00:04:01
Bueno, pues tenemos ya toda la información en el formulario 00:04:02
lo que vamos a mandar 00:04:05
y la URL 00:04:07
que ese formulario 00:04:09
va a invocar 00:04:11
En el servidor 00:04:12
Y ya veremos como el servidor se las apaña 00:04:14
Para sacar algo de ahí 00:04:16
Bueno 00:04:18
¿Tenéis el formulario? 00:04:19
No tiene obviamente ni estilo 00:04:31
Ni tiene nada 00:04:33
En el meset estaba puesto get 00:04:34
¿Qué? 00:04:36
Sí, estaba puesto get 00:04:37
En el meset 00:04:39
¿Que estaba puesto get? 00:04:40
No, que había dos opciones, o post o get 00:04:42
Sí, claro, las que acabo de decir 00:04:45
Claro, claro 00:04:47
Cuando he dicho que había dos opciones Getty Post 00:04:50
Me refería a que había dos opciones Getty Post 00:04:53
Que nos estamos durmiendo 00:04:55
Vale, pues entonces 00:04:58
Vamos a hacer 00:05:01
A ver, vamos a ejecutar la aplicación 00:05:02
A ver si el formulario 00:05:05
Al menos lo sirve 00:05:06
Que lo servirá porque ya el otro día 00:05:07
La ejecutasteis 00:05:10
Y, ala 00:05:12
Venga, pues efectivamente 00:05:17
Esta es 00:05:22
la URL base 00:05:24
y este es el recurso servido 00:05:26
que se llama index.html 00:05:29
y como en el web.xml 00:05:31
está puesto que este sea el archivo por defecto 00:05:33
pues aquí no hace falta 00:05:35
ponerlo, pero sería lo mismo 00:05:37
bueno, pues entonces, dime 00:05:38
que te pide 00:05:41
contraseña para qué 00:05:44
para ejecutarlo 00:05:45
pero como no voy a parar 00:05:50
Bueno 00:05:56
Entonces duraría 00:06:01
Mil años 00:06:05
Ay, ¿dónde estamos? 00:06:07
Concha, aquí 00:06:10
Vale, pues entonces 00:06:11
Esta URL 00:06:13
El servidor cuando intenta 00:06:17
Localizar un recurso 00:06:19
No lo encuentra por ningún sitio 00:06:21
Ni es una página web 00:06:23
ni es un código Java 00:06:25
bueno, nosotros queremos que sea directamente 00:06:26
la invocación de un código Java 00:06:29
que ese código Java 00:06:31
saque el fichero binario del cuerpo 00:06:32
de la petición 00:06:35
lo convierta a JSON 00:06:36
y lo deje ahí almacenadito 00:06:39
y nos devuelva una URL 00:06:40
de descarga 00:06:43
queremos ya que esto 00:06:44
sea la 00:06:47
llamada a un servidor 00:06:49
¿vale? 00:06:50
Queremos que esta ruta sea ya la llamada al código Java. 00:06:55
Vale, pues entonces, ¿qué es lo siguiente que tenemos que hacer? 00:07:09
Tenemos que hacer un código, un servlet, 00:07:12
y asociar ese servlet a esta ruta. 00:07:15
¿Vale? Asociar ese servlet a esta ruta. 00:07:19
Vale, pues... 00:07:23
Como tenemos que hacer dos, el servlet este de subida 00:07:25
Y el serlet de bajada 00:07:34
Este primero lo vamos a hacer directamente a mano 00:07:35
El otro ya que nos lo genere el eclipse 00:07:38
Vale, pues a ver 00:07:39
¿Dónde vamos a meter el serlet? 00:07:41
Pues el serlet lo metemos ya aquí 00:07:43
Nos vamos a nuestro código 00:07:45
A nuestra base de nuestros 00:07:51
Y vamos a hacernos 00:07:54
Pues un paquete 00:07:55
Este va a tener los serlet 00:07:56
¿Vale? 00:08:05
Este va a tener los serlet 00:08:08
Y nos vamos a hacer 00:08:10
Así, a lo bestia 00:08:12
Por ser el primero 00:08:15
Un serlet que 00:08:16
Recoger xml 00:08:18
Por ejemplo, recoger 00:08:23
xml, que nombre tan feo 00:08:25
Serlet, pero bueno 00:08:27
Así lo vamos a llamar 00:08:29
Ser 00:08:30
Porque este es el serlet que va a servir para recoger 00:08:32
El xml 00:08:35
Bueno, y pasarlo a json y todo eso 00:08:36
Venga 00:08:38
Este va a ser nuestro serlet 00:08:40
Para que sea un serlet 00:08:45
Tiene que heredar 00:08:47
De la superclase 00:08:48
¿Qué? 00:08:50
Vale, pues para que sea un serlet 00:08:59
Tiene que heredar de la superclase 00:09:04
¿Vale? 00:09:06
Entonces 00:09:09
Lo importáis 00:09:09
De Yacarta 00:09:12
Recordad que la otra acción es 00:09:13
JavaX 00:09:17
JavaX 00:09:17
si estuviéramos en versiones 00:09:19
previas a la del paso 00:09:21
de Oracle a Eclipse 00:09:24
es relativamente común 00:09:26
todavía yo creo encontrarse en lugar de 00:09:29
ya carta JavaX 00:09:32
no es tan raro 00:09:33
vale, pues entonces 00:09:35
HTTP Servlet tiene 00:09:37
los dos métodos básicos 00:09:39
el doget y el do post 00:09:41
que son los que 00:09:43
invoca 00:09:45
el formulario cuando va por GET 00:09:46
o cuando va por POST respectivamente 00:09:51
entonces, a ver si me acuerdo exactamente de la cabecera 00:09:53
y si no, la miramos 00:10:06
importamos 00:10:10
HttpRequest 00:10:30
Havanet Http es de aquí 00:10:32
En un momento que me extraña mucho 00:10:43
El paquete que me ofrece 00:10:48
Me está extrañando un poco 00:10:49
Uy, este paquete se me hace a mi un poco raro 00:10:51
Eso es para flojos 00:10:56
Por lo pronto voy a asegurarme 00:11:03
De si he puesto bien la cabecera 00:11:06
Con el override 00:11:07
Vale, la he debido poner bien 00:11:08
Bueno, a ver, vamos a mirarlo 00:11:17
¿Dónde estará? Por aquí 00:11:20
Voy a 00:11:21
Mirarlo aquí 00:11:24
Claro, porque 00:11:27
Request 00:11:29
Request, es que 00:11:32
Claro, es que me ofrece 00:11:37
No me está ofreciendo esta 00:11:40
No me está ofreciendo esta 00:11:43
Bueno, pues si no me ofrece esta 00:11:47
Que no vamos a tener que escribir la mano 00:11:49
Ah, que se me ha olvidado 00:11:51
A ver 00:12:02
Ah, simple request 00:12:03
Ah, vale, vale, vale, vale 00:12:06
Que se me ha olvidado esto 00:12:07
Claro, es que 00:12:08
Esto siempre lo hace uno generándolo 00:12:11
De forma automática 00:12:14
Entonces rara vez lo escribes 00:12:14
Normalmente siempre lo haces generándolo 00:12:16
Como vamos a hacer el siguiente 00:12:19
Entonces cuando te pones a escribirlo 00:12:20
Y tratar de tirar de la memoria 00:12:23
Que está muy bien hacerlo de vez en cuando 00:12:24
Yo intento hacerlo de vez en cuando 00:12:26
Para que la memoria no se 00:12:29
No, obviamente no 00:12:30
No lo tengo en la memoria 00:12:35
Por mucho que lo haya escrito 00:12:36
No lo tengo en la memoria 00:12:37
Pero es que es muy buen ejercicio 00:12:39
De vez en cuando 00:12:41
Tirar solo de la memoria 00:12:41
vale, entonces 00:12:43
intento que lo hagáis vosotros también 00:12:47
vale, pues este es el método 00:12:50
do-get y el do-post 00:12:52
pues será 00:12:53
a ver, no es que haga falta 00:12:54
esas preguntas del año pasado 00:12:57
es recomendable 00:13:00
¿por qué es recomendable? 00:13:02
porque es una anotación comprobatoria 00:13:04
de que has escrito bien el método 00:13:06
con lo cual estás tirando del de la superclase 00:13:08
porque si yo no pongo 00:13:10
override 00:13:12
Y aquí pongo 00:13:13
Doget 00:13:14
Pues este le parece magnífico 00:13:17
¿Vale? 00:13:20
Pero si pongo 00:13:21
¿Vale? 00:13:22
Vale 00:13:29
Y este sería 00:13:29
El doPost 00:13:32
¡Hala! Entonces 00:13:33
Este sería el equivalente al main 00:13:43
En realidad 00:13:45
Este método es el que queremos 00:13:46
Que sea llamado 00:13:49
cuando el formulario 00:13:51
sea enviado. Luego, de alguna 00:13:53
manera, queremos vincular 00:13:55
este servlet, necesitamos 00:13:57
vincular este servlet 00:13:59
a esta ruta. 00:14:01
¿Vale? Necesitamos vincular 00:14:04
este servlet a esta ruta de aquí. 00:14:05
Necesitamos vincularlo 00:14:08
de alguna manera, para que 00:14:09
el servidor de aplicaciones sepa 00:14:11
que cuando 00:14:13
tiene que ir a esta ruta, que es la que el 00:14:14
formulario le pide, él tiene que saber 00:14:17
que es aquí a donde va. 00:14:19
Entonces hay dos formas, la vieja y la nueva. 00:14:21
El que dice la vieja, pues dice de hace 5 o 6 años, tampoco creáis que es una cosa. 00:14:26
Pero bueno, vamos a ponerla, vamos a ponerla para que os suene. 00:14:32
¿Cómo asociamos ahora nosotros este serlet a esa ruta? 00:14:37
Forma vieja, pues en este ficherito tan mono que tenemos aquí, que le teníamos aquí olvidado. 00:14:43
En este fichero tan mono que tenemos aquí olvidado 00:14:50
Este fichero que por ahora solamente tenía 00:15:00
Las páginas por defecto 00:15:07
Pues este fichero, aquí se puede centralizar 00:15:09
Un montón de información sobre la aplicación 00:15:12
Se puede centralizar mucha información 00:15:14
¿Qué es la tendencia antigua en aplicaciones web? 00:15:16
Centralizarla aquí 00:15:20
Lo que pasa es que luego con la moda 00:15:20
la moda y que tiene su sentido de las anotaciones 00:15:23
ya las 00:15:25
configuraciones se han ido desviando 00:15:27
de ficheros que la centralizaban 00:15:29
a anotaciones en el 00:15:31
código, ventaja 00:15:33
desventaja, a ver, tener las 00:15:37
cosas centralizadas en archivos fuera 00:15:39
realmente está muy bien 00:15:41
sus ventajas son obvias, no tienes que 00:15:42
irte nunca al código para 00:15:44
mirar nada, pero a su vez 00:15:47
tener las cosas configuradas mediante 00:15:49
anotaciones en el código, también hace 00:15:51
cuando tú estás viendo un código 00:15:53
a la vez estás viendo mucha información añadida 00:15:54
en esas anotaciones, ¿vale? 00:15:57
No tienes que irte al fichero de configuración. 00:16:00
Bueno, pues si nosotros queremos configurar ese mapeo 00:16:02
entre URL y servlet en el fichero de configuración, 00:16:05
pues tendríamos que escribir algo como esto, 00:16:10
que esto sí que lo voy a copiar de aquí 00:16:13
porque no me apetece recordarlo entero, que es muy largo. 00:16:15
¿Dónde lo podemos tener? 00:16:20
Aquí. 00:16:23
Vale, como tengo que cambiar cosas, vale, pues a ver, esto sería, tengo, mi aplicación tiene un serlet, vale, lo voy a declarar aquí, lo voy a registrar aquí, mi aplicación tiene un serlet, lo registro aquí en el web xml, pongo la descripción que me dé la gana, si es que quiero este serlet, vale, pues no sé qué, pongo el nombrecito que le doy al serlet, el que me dé a mí la gana, 00:16:31
pues le voy a llamar 00:16:56
subir xml 00:17:01
por ejemplo 00:17:04
el nombrecito que yo le doy 00:17:05
el servlet no es el nombre de la clase 00:17:07
¿vale? 00:17:09
el nombrecito con el que la aplicación 00:17:11
lo identifica 00:17:13
y ahora aquí sí que sí 00:17:14
le digo cuál es la clase 00:17:17
en la que está este servlet 00:17:20
que estoy registrando 00:17:21
pues la clase mía se llamaba 00:17:22
recoger xml 00:17:25
serlet y estaba 00:17:27
en el paquete 00:17:29
cam2 com2 serlet 00:17:31
vale, pues entonces 00:17:33
así 00:17:35
así, vale 00:17:37
con esto registro el serlet 00:17:43
lo registro 00:17:46
que se llama, que es decir, oye tú servidor 00:17:48
de aplicaciones Tomcat 00:17:50
cuando te despliegues y despliegues 00:17:51
esta aplicación que te doy 00:17:54
que sepas que tiene un serlet que está 00:17:56
aquí en esta ruta, en este java 00:17:58
vale, pero ahora ya nos falta el mapeo 00:18:00
mapearlo a la url correspondiente 00:18:02
pues el mapeo 00:18:05
a la url correspondiente 00:18:07
ya lo hacemos aquí, decimos 00:18:08
oye, el servlet que yo le he dado 00:18:10
este nombrecito 00:18:12
el servlet que yo le he dado este nombrecito 00:18:13
¿en qué ruta está? 00:18:16
en esta ruta 00:18:18
cuando el servidor de aplicaciones 00:18:19
reciba la orden 00:18:22
ruta base, la que sea 00:18:24
ruta base, el contexto 00:18:26
de la aplicación 00:18:28
Habloa, que sepas que es este el servlet 00:18:29
Que tienes que ir 00:18:33
¿Y este cuál es? Pues este, te lo acabo de decir aquí 00:18:34
Pues hala, ya hemos registrado el servlet 00:18:37
Vale, esta forma de registrar el servlet 00:18:41
Repito 00:18:52
Es antigua 00:18:52
Por decirlo de alguna manera 00:18:55
Pero vamos, que cuando hablamos de antiguo en este mundo 00:18:56
Es un antiguo relativo 00:18:59
Porque aparte de que te lo puedes encontrar 00:19:01
Tampoco hablamos de hace tantos años 00:19:04
entonces 00:19:05
esta está más asociada 00:19:06
al código 00:19:20
que llamamos así, ¿verdad? 00:19:21
uno puede trabajar 00:19:24
si es 00:19:26
relativamente habitual 00:19:27
que uno trabaje con código 00:19:30
que viene de aplicaciones más antiguas 00:19:32
porque tú no tiras las aplicaciones a la basura 00:19:34
cuando quieres cambiar algo y la haces 00:19:36
entera desde cero, es imposible 00:19:38
entonces 00:19:40
en las aplicaciones heredas mucho código 00:19:41
de sus primeras versiones 00:19:44
¿vale? y este es el código 00:19:47
legacy que se llama, el código que esa aplicación 00:19:49
tiene de sus primeras versiones 00:19:51
que todavía no has cambiado 00:19:53
pero con el que tienes que convivir 00:19:55
¿vale? es un código 00:19:57
con el que tenemos que convivir muy a menudo 00:19:59
dentro de una aplicación Word 00:20:01
bueno pues, esto entraría 00:20:02
dentro de ese concepto 00:20:05
de partes que no hemos cambiado de la aplicación 00:20:06
para adaptarlo a la forma 00:20:09
nueva de registrar 00:20:11
el SERLET, que en el siguiente SERLET 00:20:13
pues lo registramos así. 00:20:15
Vale. 00:20:18
Ahora, vamos a comprobar 00:20:19
a ver si realmente 00:20:21
lo hemos registrado bien y ahora ya sí 00:20:22
cuando 00:20:25
llamemos al SERLET, 00:20:26
el SERLET va a ser llamado. 00:20:29
Entonces, vamos a hacer que 00:20:32
haga algo. Como lo llamamos 00:20:33
por POST, pues que nos devuelva 00:20:35
una 00:20:37
página web sin más. 00:20:38
Que diga 00:20:41
Has invocado al serle correctamente 00:20:42
Así todo a lo bruto 00:20:44
H1 es la grandota 00:21:08
Me llamaste 00:21:18
Pero no sé hacer nada 00:21:21
Todavía no sé hacer nada 00:21:23
Pero dentro de nada 00:21:38
Verás 00:21:39
Que tengo que cerrar 00:21:41
Ah, perdón 00:21:46
Vale, pues entonces 00:21:48
A ver, que he escrito mal 00:21:53
Ah, la excepción 00:21:58
Así se queda 00:22:00
Vale, pues entonces 00:22:07
Estos métodos 00:22:09
Como son los métodos que se invocan 00:22:11
A raíz de la llegada de un formulario 00:22:13
Tienen estos dos parámetros 00:22:15
Implícitos de los que todavía no hemos hablado 00:22:17
Pero bueno 00:22:19
Cuando el método get o el post 00:22:20
Me da igual, se ha invocado 00:22:23
Es porque 00:22:24
un formulario lo ha invocado 00:22:25
con nuestra petición 00:22:28
y ha llegado una petición HTTP 00:22:29
entonces 00:22:32
a través de este objeto request 00:22:33
podemos sacar todo lo que va 00:22:36
en esa petición HTTP 00:22:38
todo lo que lleva 00:22:39
desde lo que va en la cabecera 00:22:42
hasta lo que va en el cuerpo, por ejemplo el fichero 00:22:43
todo, cualquier cosa la podemos sacar de aquí 00:22:46
¿vale? 00:22:48
nosotros en particular queremos sacar de aquí 00:22:50
el fichero, el fichero que va en el cuerpo 00:22:52
queremos sacar 00:22:54
Y este objeto response es el objeto que el servlet va a enviar como respuesta 00:22:55
Y nosotros lo tendremos que rellenar con lo que queramos que se envíe como respuesta 00:23:01
Ahora mismo lo hemos rellenado con una página web simplemente 00:23:06
Pero podríamos meterle un fichero de descarga 00:23:12
Podemos meterle más cosas al response 00:23:18
bueno, pues vamos a ver 00:23:21
si realmente llegamos a este servlet 00:23:23
ahora invocando la aplicación 00:23:25
entonces esto 00:23:27
se supone que esto cada cierto 00:23:28
tiempo 00:23:31
que dice, se recargó 00:23:32
se hizo la recarga del contexto, se hizo no sé qué 00:23:35
con lo cual no hay que reiniciar el servidor 00:23:37
y la aplicación todo el rato 00:23:39
pero, no perdemos 00:23:40
como aquí no me ha parecido nada de que 00:23:43
se haya reiniciado 00:23:45
lo voy a forzar que se reinicie 00:23:46
y así ya me aseguro de ejecutar 00:23:49
La versión buena 00:23:51
Venga 00:23:52
Vamos a volver a ejecutar 00:23:54
La aplicación 00:23:59
Reinicia el servidor 00:23:59
Así me aseguro de que lo inicia todo 00:24:02
Vale, venga, vamos a ver 00:24:04
Si me llama 00:24:07
Ese servidor 00:24:09
Vale 00:24:10
Bueno, pues hasta ahí, bien 00:24:13
Que bien, nos está saliendo todo 00:24:16
Pero no sao 00:24:18
Pero no sao hacer nada, corazao 00:24:19
Venga, vamos a 00:24:23
Ponerlo bien, que no nos gustan tantas faltas de ortografía. 00:24:25
¿Cómo era esto? 00:24:33
¿Así? 00:24:37
¿Así sí? 00:24:42
A ver. 00:24:46
Sí, vale, lo he escrito bien. 00:24:57
¿Veis? Aunque cambiéis el contenido a HTML, no hace falta que reiniciéis la aplicación. 00:25:01
¿Vale? 00:25:06
Dime, el web XML, ¿vale? 00:25:07
Esta tiene que ser la clase, donde está tu server, 00:25:18
y esta la ruta. 00:25:24
Ahí tiene que haber lo mismo que hay en el formulario. 00:25:28
Lo que pasa es que en el formulario va sin barra y aquí 00:25:31
va con barra. 00:25:33
¿Vale? 00:25:37
O sea, en el formulario no lleva la barrita, 00:25:38
Pero aquí si tiene que llevarla 00:25:40
Para que interprete 00:25:45
Que concatena con la base 00:25:47
¿Vale? 00:25:48
Pero que te dice 00:25:59
Algo te dirá 00:26:00
Bueno 00:26:01
Pues ahora 00:26:05
Ahora ya si que podemos 00:26:08
Aquí 00:26:14
Modificar este 00:26:18
Para en lugar de pedir la página web sin más 00:26:20
O sea de servir la página web sin más 00:26:23
saque el fichero 00:26:25
del body 00:26:28
del cuerpo de la petición 00:26:29
lo convierta 00:26:31
a Jason 00:26:33
y te lo 00:26:34
y te devuelva 00:26:36
ahora ya sí, un formulario de descarga 00:26:39
vale, pues esto sí que 00:26:42
no voy a tirar de memoria 00:26:43
lo vamos a ir cogiendo poco a poco 00:26:46
vale, donde 00:26:47
vale 00:26:49
Vamos primero a hacer esta primera parte, primero del request sacamos la parte que se llama file, del request sacamos lo que se llama file. 00:26:59
Aquí pone file no porque sea un fichero, sino porque en nuestro formulario lo hemos llamado file a este, ¿vale? 00:27:42
vale, entonces 00:27:55
como lo hemos llamado file 00:28:00
a esta parte, recordad que esto es multiparte 00:28:01
o sea, tiene la cabecera, tiene el cuerpo 00:28:04
bueno, pues de las partes 00:28:06
de las partes 00:28:08
nos sacamos la parte que se llama 00:28:10
file, ¿qué parte se llama file? 00:28:12
el propio fichero 00:28:14
el propio fichero, ¿vale? 00:28:15
lo llama 00:28:19
te lo coge por el nombre 00:28:19
por el nombre, no por el id 00:28:22
Es que eso nunca jamás me acuerdo 00:28:24
Si lo coge por nombre o por ID 00:28:26
Creo que es por nombre 00:28:27
¿No lo recordáis del año pasado? 00:28:28
Es por nombre 00:28:31
El ID es para identificarlo 00:28:32
En el otro contexto 00:28:36
Pero en el request se lo coge por nombre 00:28:37
Vale 00:28:40
Entonces, dime 00:28:40
Aquí, sí, sí, sí 00:28:43
Sí, sí, me voy a quedar un rato 00:28:48
Aquí 00:28:50
Vale 00:28:51
Cogemos la parte de toda la request 00:28:52
es http que se llama fichero 00:28:55
se llama file 00:28:57
entonces esa parte 00:28:58
es un fichero, pero un fichero que también lleva 00:29:01
su nombre, lleva muchas cosas 00:29:03
no solo el fichero 00:29:05
entonces vamos a sacar de esa parte 00:29:06
que es una parte, vamos a sacar dos cosas 00:29:09
primero 00:29:11
el flujo de bytes 00:29:13
para tirar de él, para leerlo 00:29:15
aquí ligamos 00:29:17
con java.io directamente 00:29:19
saber de java.io también era importante 00:29:20
vale, o sea de esta parte 00:29:23
de esta parte, sacamos primero el flujo binario 00:29:25
el flujo binario para leer de él 00:29:28
y luego vamos a sacar también el nombre del fichero 00:29:31
el nombre, porque en esta parte 00:29:38
en la parte venía nombre del fichero 00:29:40
igual a todo el flujo binario, venía ahí la parte 00:29:43
todo metido a mogollón, pues de la parte sacamos 00:29:46
el flujo binario con los datos de aquí 00:29:49
y de aquí el nombre del fichero, esto con un método auxiliar que ahora ponemos 00:29:51
Luego tenemos ya dos datos aquí 00:29:55
El flujo con la información binaria del fichero y su nombre 00:29:59
Vale, ¿tenéis copiadas estas tres cosas? 00:30:03
Para que vayamos a hacer este método 00:30:12
¿Ya las tenéis copiadas? 00:30:13
¿Perdón? 00:30:34
no, no, no, es que este es un método auxiliar 00:30:39
que vamos a mirar ahora, por eso me aparece en rojo 00:30:49
por eso este es un método auxiliar 00:30:52
para sacarlo, no es un método 00:30:54
de par 00:30:56
vale, ¿ya? ¿no tenéis copia? 00:30:57
vale, pues vamos a sacar 00:31:16
vamos a 00:31:18
hacer este método auxiliar 00:31:20
este método auxiliar lo vamos a hacer 00:31:21
aquí abajo, para sacar 00:31:23
el nombre de esta parte de aquí, 00:31:25
para sacar el nombre. ¿Para qué queremos el nombre? 00:31:27
Para luego guardar el JSON con el mismo 00:31:30
nombre, simplemente. 00:31:32
Vale, pues entonces, 00:31:34
este es el método auxiliar. 00:31:35
¿Vale? 00:31:50
Que se me ha 00:31:55
destabulado. 00:31:59
¿Cómo era el 00:32:04
formato automático? 00:32:05
Control-Shift-F, ¿verdad? 00:32:07
Vale. 00:32:10
Vale, pues 00:32:10
este es el método. 00:32:12
el que saca de la parte el nombre 00:32:15
copiadlo y ahora lo 00:32:18
lo explicamos 00:32:20
pero vamos, esto no es ni algo 00:32:23
que haya que prenderse en memoria por supuesto 00:32:33
ni nada, sino entender la arquitectura 00:32:35
de esta aplicación hecha de cero 00:32:37
entenderla y que ya sepamos 00:32:39
que tienen las aplicaciones por debajo 00:32:41
aunque luego se hagan con un framework, se hagan como sea 00:32:43
vale, pues a ver 00:32:45
Esto es para de la parte, recordad que esa parte file tiene información sobre el fichero en general y los propios datos binarios, ¿vale? Pues de este método es para de esa parte sacar el nombre simplemente y guardarlo ahí. 00:33:23
Entonces, esto, lógicamente, uno, o se mira bien la documentación de Yakarta o de JavaX para ver qué métodos tiene PARP, cómo encapsula para sacar todo eso, eso, si lo hacía hace unos años, o se lo pide a HGPT, lógicamente. 00:33:39
esto está hecho según el primer método 00:34:00
porque la primera vez que lo hice 00:34:03
pues no existía 00:34:05
charGPT, pero si le pedimos a charGPT 00:34:07
cómo sacar, pues no lo he hecho por curiosidad 00:34:10
cómo sacar el nombre de la parte 00:34:12
pues no sé si te lo sacará exactamente 00:34:13
así o no, pero bueno 00:34:15
vale, pues aquí de la parte 00:34:16
tiene una cabecera 00:34:19
que separados por punto y coma 00:34:23
tiene información sobre el fichero 00:34:26
o sea, la parte esa tiene 00:34:27
una cabecera separada por punto y coma con información sobre el fichero 00:34:29
y luego ya tiene el fichero, pues entonces vamos 00:34:34
de toda esa información que tiene separadas por punto y coma de la cabecera 00:34:37
vamos hasta que lleguemos a la que se llama nombre del fichero 00:34:41
y sacamos, quitamos el igual 00:34:45
porque será filename igual a nombre del fichero y con esto 00:34:49
ya sacamos el nombre del fichero, quitando la barrita 00:34:55
si es que tiene barras 00:34:59
porque antes o al final 00:35:01
por la concatenación con la 00:35:03
ya está 00:35:04
es decir, la cabecera 00:35:06
una parte de la cabecera de la parte es 00:35:09
filename igual al nombre 00:35:11
de fichero 00:35:13
pues es sacar esa parte 00:35:14
lo que empiece por filename, le quito el igual 00:35:17
y le quito la barra 00:35:19
ya está, y ya tengo el nombre del fichero 00:35:21
y en esa cabecera hay más cosas 00:35:23
separadas por puntos y comas. 00:35:27
Por eso es un equipo. 00:35:28
Me quedo solo con la que empieza por file name. 00:35:29
Vale, pues entonces, 00:35:37
tenemos este método, ¿no? 00:35:39
Pues ya está. 00:35:41
Ya tenemos las dos informaciones. 00:35:42
El flujo binario y el nombrecito. 00:35:45
Y aquí, 00:35:48
throws. 00:35:53
Lo lanzamos todo para no tener problemas. 00:35:54
Vale. 00:36:01
Y ahora ya nos viene el problema de que tenemos que, claro, convertir un, ahora ya nos viene la parte Java, que es convertir este fichero, ya lo podemos leer, pasar a un objeto file y ya con ese objeto file trabajar ya con Java como esto hasta ahora, olvidarnos a partir de aquí. 00:36:02
entonces, pasar un XML a JSON 00:36:25
claro, si el XML 00:36:27
puede tener cualquier estructura del mundo 00:36:29
no es tan sencillo 00:36:31
se podría hacer 00:36:33
lógicamente, en este caso 00:36:35
¿cómo se haría? como yo desconozco 00:36:37
las etiquetas, desconozco las clases 00:36:39
y todo, no puedo hacerme clases de XB 00:36:41
es imposible, no puedo hacerlas 00:36:43
entonces tendríamos que leerlo con DOM, eso para empezar 00:36:44
para continuar 00:36:47
de forma recursiva, porque no sé hasta 00:36:49
cuándo me acaban los nodos 00:36:51
Tendríamos que ir leyendo el árbol de forma recursiva 00:36:52
Ler nodo, ler nodo 00:36:55
Que también podríamos hacerlo 00:36:57
De hecho, lo tengo hecho 00:36:58
Que no lo he sacado para que no os angustiarais 00:37:01
Y según vas 00:37:03
Leyendo los nodos 00:37:05
Te vas haciendo objetos 00:37:07
Y luego 00:37:09
Te vas haciendo JSON nodes, perdón 00:37:11
Objetos no, porque no tienes clases 00:37:13
Y luego ya esos JSON nodes los vas pasando al JSON 00:37:14
Es decir, para un XML genérico 00:37:17
Se podría hacer el método 00:37:20
que pasa de XML a JSON, pero no sería una tontería 00:37:21
en absoluto, sería un método bueno, que habría que 00:37:24
trabajárselo, entonces vamos a hacer una versión más sencilla, que es 00:37:27
que esta aplicación sirva para pasar 00:37:30
XML a JSON de esquemas de ficheros 00:37:33
que ya conocemos, por ejemplo, como teníamos las clases de 00:37:36
AXB del recetario famoso, pues para pasar 00:37:39
yo tengo un XML de recetas, pasarlo a JSON 00:37:42
¿vale? Entonces, así va a ser 00:37:45
mucho más fácil, porque lo leemos con AXB 00:37:48
con las clases de recetas 00:37:51
y luego pasamos el objeto a Jason y se acabó. 00:37:52
Pero claro, necesitamos las clases 00:37:55
de Axbay. Pues venga, vamos 00:37:57
a hacernos aquí en nuestra aplicación 00:37:59
un paquete 00:38:00
con el modelo de las clases. 00:38:03
Vale. 00:38:15
Aquí van a ir las clases de Axbay para 00:38:16
poder yo leer 00:38:18
ese XML y 00:38:19
convertirlo a objeto. Y luego de ahí pasarlo 00:38:22
a Jason, como vimos el otro día, que es 00:38:25
inmediato. Bueno, 00:38:26
Pues ahora ya sí que sí tendréis que copiaros 00:38:28
Las clases de AXB 00:38:31
Bueno, del XML con el que queráis hacer pruebas 00:38:33
Yo como las tengo aquí 00:38:37
Estás a mano, pues lo voy a hacer 00:38:38
Del que hicimos de recetas 00:38:40
Vale, pues os hacéis 00:38:42
Un paquete modelo con las clases 00:39:01
Lógicamente 00:39:03
Nos sale rojito porque 00:39:12
Nos falta 00:39:14
Nos falta 00:39:16
La dependencia de AXB 00:39:18
Hasta ahora 00:39:20
Nuestro Pong 00:39:22
Estaba vacío 00:39:24
Sin dependencias 00:39:25
Porque no hemos necesitado nada 00:39:27
Porque todo lo de HTTP server request 00:39:29
Todo eso está en la librería del Tomcat 00:39:32
Pero ahora ya sí 00:39:34
Ahora ya sí que vamos a tener que meter ahí 00:39:36
Las dependencias de JaxB 00:39:38
Bueno, como ya las hemos hecho a veces 00:39:39
Ahora ya sí que viene nuestro copia y pega 00:39:42
Nuestro copia y pega 00:39:44
Las de JaxB 00:39:47
Eran 00:39:49
Estas 00:39:50
La API y la Runtime 00:39:52
La API y la Runtime 00:39:57
Las copiáis 00:40:01
Las copiáis de 00:40:03
Cualquier aplicación que tengáis 00:40:18
Y ya os veis nuestras dos dependencias 00:40:20
Y efectivamente 00:40:22
Habrán aparecido 00:40:27
Aquí 00:40:28
Habrán aparecido aquí 00:40:30
Y ya se nos han 00:40:32
Quitado los rojitos 00:40:38
Tiene las dos 00:40:45
de jazz, las dos que usábamos 00:40:50
la API y la runtime 00:40:52
bueno, pues ahora ya sí que sí 00:40:54
podemos volver a nuestro servlet 00:41:01
y ya 00:41:03
vale, vamos a 00:41:05
guardar 00:41:11
de este input string 00:41:12
vamos a guardarlo, vamos a leer 00:41:15
para guardarlo en un fichero 00:41:17
esto lo sabemos hacer con java.io 00:41:19
perfectamente, entonces voy a 00:41:21
dime 00:41:23
aquí 00:41:28
No tiene nada 00:41:30
Vale, entonces 00:41:32
Vamos a esto de aquí 00:41:37
Vale 00:41:39
A ver 00:41:40
Vamos a hacer esta parte 00:41:49
Ahora 00:41:53
Vale, pues vamos a hacer la parte 00:41:54
ahora de ir leyendo 00:41:59
del input string 00:42:01
para que se quede en un fichero local 00:42:02
vale 00:42:05
entonces estamos aquí 00:42:06
vale 00:42:11
esta primera cosa que he hecho 00:42:12
esto es porque 00:42:15
bueno 00:42:22
a ver 00:42:25
porque no 00:42:25
vale pues 00:42:26
esto de aquí es lo nuevo que he escrito 00:42:33
vale, este código 00:42:36
y este 00:42:38
Escribirlo y ahora lo 00:42:39
Comentamos 00:42:45
A ver, este proyecto lo voy a subir luego 00:42:47
Pero es que os quería hacer escribir un poco 00:42:55
Esto sigue, estamos siguiendo con el serle 00:42:57
Estamos siguiendo con el serle 00:43:05
Sí, por eso he dicho, escribidlo 00:43:07
Y ahora lo comentamos 00:43:10
Pero vamos, que esto 00:43:13
Es leer del flujo 00:43:14
Vale, a ver 00:43:17
Esto simplemente porque 00:43:19
Esto está a continuación de lo que hemos hecho 00:43:21
Sacar el nombre del fichero y el flujo de entrada 00:43:24
Está justo a continuación 00:43:26
Vale 00:43:28
Entonces, el file name 00:43:28
Es el nombre del fichero 00:43:32
Recordad que me ha sacado de la parte 00:43:34
Esa que ha subido, el nombre del fichero 00:43:36
Pero es que hay una diferencia 00:43:37
Cuando haces las pruebas 00:43:40
En el Tomcat integrado en Eclipse 00:43:42
Que cuando lo haces desplegado 00:43:44
En un Tomcat aparte 00:43:46
Con un guard que lo has desplegado 00:43:48
Bueno 00:43:50
Entonces, hay una diferencia 00:43:51
El filename cuando haces las pruebas 00:43:54
Integrados en Eclipse 00:43:56
Trae toda la ruta de tu sistema de archivos 00:43:57
Queremos quitarlo 00:44:01
Queremos quitar la ruta 00:44:04
Entonces, este código es un código que he hecho 00:44:06
Simplemente 00:44:08
Para que en el caso de que el filename 00:44:10
En el caso de que el filename 00:44:12
Traiga toda la ruta 00:44:15
Archivos 00:44:17
archivos, no sé qué, mi archivo XML. Bueno, pues en las pruebas que haces en local con 00:44:18
el Eclipse, el file name te puede traer toda la ruta de tu sistema de archivos local, porque 00:44:30
estás en local. Entonces, para él, el file name es todo, porque estás en local en tu 00:44:37
propio ordenador. Entonces, mi nombre de archivo yo no quiero todo esto, solo quiero 00:44:43
esto, entonces esto es un pequeño 00:44:47
código que he hecho solamente 00:44:51
para quedarse 00:44:53
con esto hacia acá 00:44:55
eliminar todo de aquí hacia arriba 00:44:56
¿verdad? me quedo 00:44:58
con file separator es 00:45:01
el separador que usa mi sistema 00:45:03
de archivos, que sea 00:45:05
esto es para hacerlo independiente 00:45:07
de Linux, Windows, lo que sea 00:45:09
entonces me quedo 00:45:10
con la última aparición 00:45:12
de ese separador, con la última aparición 00:45:14
y me quedo con el substring 00:45:16
de él hacia Landry 00:45:18
¿vale? 00:45:19
luego esto, en realidad en la aplicación 00:45:22
real ya desplegada, esto no haría 00:45:25
ninguna falta 00:45:26
¿vale? porque el nombre no va a contener 00:45:27
el separador del sistema de archivos local 00:45:31
o sea, si esto realmente 00:45:33
se hace en un entorno real 00:45:34
tú haces tu formulario, lo subes 00:45:35
el fichero a través de la aplicación web 00:45:38
ese fichero, su nombre 00:45:41
no llega con la ruta local de tu sistema 00:45:42
de archivos, llega con su nombre 00:45:44
punto pelota, con lo cual 00:45:46
Este contain siempre sería falso 00:45:48
Nunca se ejecutaría 00:45:50
Pero en las pruebas locales 00:45:51
El filename sí que te puede llegar 00:45:54
Con toda la ruta de tu 00:45:56
Sistema de archivos local 00:45:58
Entonces no la queremos 00:46:00
Pues por eso hago este código 00:46:02
Solamente para eso, ¿vale? 00:46:03
Ya está 00:46:06
Vale, ¿y ahora ya qué hacemos? 00:46:06
Bueno, pues el servidor 00:46:10
Tendrá que tener algún sitio 00:46:11
Para 00:46:13
Guardar los archivos que le estamos subiendo 00:46:14
algún sitio para guardarlo 00:46:18
bueno, yo he puesto en esta ruta 00:46:19
vosotros poned la que queráis 00:46:21
este es mi servidor 00:46:22
y esta es la ruta de mi servidor 00:46:25
donde voy a guardar los archivos 00:46:27
los archivos subidos 00:46:29
estoy en el servidor ahora 00:46:31
entonces ya me crea un nuevo file 00:46:32
en esta ruta 00:46:36
con el nombre que acabo de 00:46:38
leer 00:46:40
entonces, sí 00:46:41
entonces este es el objeto 00:46:54
file, el objeto file 00:46:56
que yo creo en el servidor 00:46:58
le asocio un file output 00:47:00
stream, y ahora me hago el bucle de toda la vida 00:47:02
voy leyendo del input stream 00:47:04
del fichero que he subido 00:47:06
de la parte que he subido y voy escribiendo 00:47:08
leo, escribo, leo, escribo 00:47:10
creo que 00:47:12
a partir de la versión 9, pero eso 00:47:20
creo que lo tengo en el otro servlet 00:47:22
no hace falta 00:47:24
leer byte, escribir byte, leer byte, escribir byte 00:47:26
hay un método que pum 00:47:29
te conecta un flujo con otro y te lo hace 00:47:30
toda la bestia 00:47:32
vale, pues llegados a este 00:47:33
punto del servlet 00:47:40
todo lo que ha hecho mi servlet 00:47:41
ahora lo recopilamos desde arriba es 00:47:43
coger la parte que se llama 00:47:45
file, que el formulario 00:47:48
ha llamado file, es decir, coger el fichero 00:47:50
sacar de esa parte 00:47:51
el flujo binario, el output stream 00:47:53
y el nombre. Crear un 00:47:56
objeto file asociado a una 00:48:00
ruta del servidor para guardar ese 00:48:02
fichero. Y ahora 00:48:04
ya, mi input 00:48:06
stream 00:48:08
donde viene el fichero, voy escribiendo 00:48:10
en ese otro. Output stream de aquí. 00:48:12
¿Verdad? Vamos a recopilarlo desde el principio. 00:48:16
Tengo 00:48:20
saco 00:48:20
el file 00:48:22
que era este 00:48:23
el file que he mandado por post 00:48:25
lo saco de la parte 00:48:28
saco un input stream 00:48:30
asociado a sus 00:48:32
datos binarios de ese fichero 00:48:34
saco el nombre 00:48:36
a través de su cabecera con este 00:48:38
método auxiliar, saco el nombre 00:48:40
del fichero 00:48:42
me creo un fichero en el servidor 00:48:43
en la ruta que a mí me dé la gana 00:48:46
un fichero en el servidor con ese mismo nombre 00:48:48
¿vale? 00:48:50
y ahora ya 00:48:53
del input stream 00:48:54
del fichero binario que me ha llegado en la 00:48:56
request 00:48:58
voy sacando para escribir 00:48:58
en este fichero file output stream 00:49:01
vale, pues vamos a ejecutarlo hasta aquí 00:49:04
cread esta carpeta 00:49:07
la que hayáis puesto vosotros 00:49:11
y vamos a ver si realmente 00:49:12
se sube ahí el archivo 00:49:15
entonces yo 00:49:17
lo tengo 00:49:19
archivos de servidor, voy a quitar 00:49:20
lo que tuviera aquí de las pruebas 00:49:23
vale, esta es mi carpeta 00:49:25
archivos de servidor que está completamente 00:49:27
vacía, que es la carpeta 00:49:29
local del servidor a donde van a ir a 00:49:31
parar los archivos que yo suba desde la aplicación 00:49:33
web 00:49:35
venga 00:49:36
error de compilación 00:49:38
entonces, déjame ejecutarlo 00:49:42
por si he escrito algo mal 00:49:45
y entonces voy a ejecutar la aplicación 00:49:46
que 00:49:49
estamos 00:49:50
aquí, xml to json 00:49:51
vale, esta es mi 00:49:55
aplicación 00:50:08
¿qué archivo XML quiero subir? 00:50:09
Este. 00:50:12
Subir. 00:50:14
Imposible procesar debido a que se ha prohibido 00:50:19
no multipartes. 00:50:22
¡Ah! 00:50:23
Maravilloso que nos haya salido este error. 00:50:24
Vale, entonces, ¿a uno un error típico? 00:50:26
Claro, un error típico. 00:50:29
¿Vale? 00:50:33
Ya hemos mencionado, 00:50:33
o sea, uno ve este error 00:50:37
y pues lo busca o hasta que lo encuentra. 00:50:38
¿Qué significa? A ver, nosotros en el formulario le hemos dicho que el formulario tiene que ser multipartes porque lleva un fichero, ¿verdad? Lleva un fichero. Vale, pues al SERLET hay que avisarle de que es multiparte. Al SERLET hay que avisarle. 00:50:41
¿Y cómo se le avisa? Con una anotación. Entonces, me voy al Serlet y al Serlet hay que avisarle con una anotación. Voy a ver si es esta o si no la miro. Porque si no me deja importar esta es que no es esta. Multipart config. 00:50:57
esta, es, vale 00:51:22
vale 00:51:26
esto ha sido un olvido, vale 00:51:28
pero 00:51:32
bienvenidos esos olvidos 00:51:34
porque nos hacen que nos salgan 00:51:37
errores 00:51:39
típicos 00:51:39
vale, pues este serlet 00:51:42
tiene que poder trabajar con multipartes 00:51:45
pues lo tengo que avisar con una anotación 00:51:47
¿a dónde? 00:51:49
Vale, pues entonces 00:51:52
Vamos a volver a ejecutarlo 00:52:13
Ya, pero lo que importa es si nos ha subido el archivo 00:52:14
Eso es lo que tenemos que mirar 00:52:26
Claro 00:52:28
Vale, a ver 00:52:29
Pues aquí lo tenemos 00:52:31
Elegimos un archivo cualquiera 00:52:34
Este, subir archivo 00:52:36
Vamos a ver 00:52:38
Si en archivos de servidor está 00:52:40
Efectivamente ha aparecido 00:52:42
Lo ha subido al servidor 00:52:45
Luego el archivo ya está en el servidor 00:52:47
Ahora ya sí que viene la parte Java 00:52:50
Ya está 00:52:52
¿Vale? 00:52:53
Creo que no sabría 00:52:57
Si sabrías 00:52:58
Porque a ver 00:53:03
Pues nos falta un poco 00:53:04
luego hacemos la revisión global de todo 00:53:11
a ver, he hecho una página web 00:53:14
que invoca un serlet 00:53:17
y el serlet hace cosas 00:53:18
¿vale? pero luego lo revisamos 00:53:20
todo desde el principio 00:53:22
luego lo revisamos todo desde el principio 00:53:23
a ver, si es el primer 00:53:32
contacto con un serlet o con un formulario 00:53:34
todo junto, pues uno se lía 00:53:37
pero una vez que ya uno ha hecho 00:53:39
su primer formulario con un 00:53:40
serlet y lo revisa al completo 00:53:42
ya se le queda la idea 00:53:44
y ya está, y a partir de ahí 00:53:46
pues ya puedes, pero claro 00:53:48
si es el primer contacto con 00:53:50
esto 00:53:52
a ver, subir 00:53:53
la anotación del serlet es esta 00:54:00
está en la clase 00:54:05
multipart config 00:54:07
vale 00:54:08
vale, pues ahora 00:54:10
Llamamos a la parte Java, que esta ya 00:54:21
Si que no nos queda ninguna duda 00:54:23
A ver 00:54:24
Voy a cerrar aquí cosas 00:54:26
Que tengo un lío, vale 00:54:31
Vamos al serlet que está aquí 00:54:32
Bueno, pues llegados 00:54:34
A este punto del serlet 00:54:37
Ya tenemos 00:54:38
Nuestro 00:54:40
Objeto file aquí 00:54:42
Nuestro objeto file 00:54:45
Este 00:54:48
Con el xml subido 00:54:48
Pues vamos a hacerlo a través de un método 00:54:52
auxiliar, claro, que me devuelva aquí el file json, por ejemplo, xml to json, al que 00:54:54
le paso f, que es el fichero, ¿vale? Entonces ahora vamos a hacer ya este método, que te 00:55:13
pasa este fichero f 00:55:21
a un 00:55:22
json y te devuelve 00:55:25
la referencia a ese json 00:55:27
pues venga, vamos a hacernos 00:55:29
la clase utilidades 00:55:33
vale, vamos a hacer este método y ahora 00:55:34
a partir de aquí, ahora ya si que 00:55:38
este response 00:55:41
perdón, que tengo yo aquí 00:55:42
que lo llevo ahí arrastrando 00:55:44
pues ahora ya si que en lugar de que me 00:55:46
de este mensaje, que me de una página web 00:55:48
con un enlace de descarga o con un 00:55:50
formulario de descarga, pero por lo pronto 00:55:52
vamos a hacer esta parte y ya está 00:55:55
vale, pues nos vamos a hacer 00:55:56
otro paquete con la lógica 00:56:00
nos hacemos 00:56:03
un paquete 00:56:08
ay, que 00:56:10
sos feliz 00:56:21
pero 00:56:23
a ver, he puesto ya esto 00:56:24
ah, vale, vale 00:56:27
con punto 00:56:36
dan dos, punto 00:56:38
lógica, por ejemplo 00:56:39
Venga, ya está 00:56:41
Vale, y aquí nos vamos a hacer la clase utilidades 00:56:43
Con ese método estático 00:56:47
Y ahora este va a tener un método estático 00:56:49
Public static 00:56:59
Que devuelve un file 00:57:01
JSON 00:57:07
Al que se le pasa un file 00:57:09
File xml 00:57:12
Vamos a ponerle un return null 00:57:14
Ahí para que se calle 00:57:26
Y ahora ya está 00:57:27
Ahora ya 00:57:30
Vamos a 00:57:33
Copiar y pegar 00:57:35
Como se leía 00:57:37
Un xml, el jacksb context 00:57:39
Bla bla bla 00:57:41
Pues venga, esto ya es copiar 00:57:42
Y pegar de cualquier 00:57:45
Del método de leer 00:57:47
Un jacksb 00:57:49
Que yo 00:57:52
Lo tengo aquí 00:57:53
Vale, aquí 00:57:55
Esto ya era 00:58:05
Pues hacer el context 00:58:07
Hacer una nueva instancia 00:58:09
De la clase que sea 00:58:11
Que era recetario 00:58:15
Esto 00:58:17
A ver, recetario 00:58:28
Vamos a poner aquí la 00:58:34
Ah, vale, vale 00:58:35
Vale 00:59:01
Este no es 00:59:07
File, sino file 00:59:10
XML 00:59:12
Bueno, pues esto es la parte de JaxB 00:59:13
Que ya conocemos, que es 00:59:23
Pasar del fichero 00:59:25
Al objeto 00:59:27
Si las clases están bien, que lo estarán 00:59:28
Porque las hemos usado ya 00:59:31
Ya tengo el objeto 00:59:32
Y ahora ya recordad que 00:59:34
Escribir en un JSON 00:59:39
Si yo no quiero cambiar 00:59:41
Los nombres de los campos, ni de nada 00:59:43
Con un solo método, le envío el objeto 00:59:45
Y lo escribía 00:59:47
Y ya está, pero vamos a crear 00:59:48
El fichero, el fichero que se llame igual que este, pero con extensión .json. 00:59:51
Entonces, vamos a crear el fichero .json. 00:59:58
Este file .json que vamos a crear, ¿qué nombre le tenemos que dar? 01:00:04
El nombre del de arriba, pero cambiando la extensión .xml por .json. 01:00:12
Con lo cual, vamos a ver, el nombre del de arriba sería el file xml.getName, ¿verdad? 01:00:16
Este es el nombre del fichero de arriba. 01:00:28
Pero nos vamos a quedar con el substring que va desde cero hasta la aparición del punto. 01:00:31
pero 01:00:40
vamos a ver 01:00:44
get name 01:00:48
punto last index 01:00:48
of el punto 01:00:55
vale 01:00:57
y ahora 01:00:59
a esto le concateno 01:01:01
con 01:01:03
punto jason 01:01:05
ya tengo el nuevo nombre del fichero 01:01:06
jason 01:01:12
para si mi fichero se llama 01:01:13
pepito.xml que ahora se llama 01:01:16
pepito.json 01:01:18
para eso 01:01:19
a su nombre me quedo con el substring 01:01:20
que va desde cero 01:01:23
hasta la posición anterior a la del punto 01:01:24
y le concateno con JSON 01:01:27
bueno me podría quedar 01:01:29
bueno te elimina 01:01:31
la que tenía y te pone otra 01:01:35
vale pues ahora ya 01:01:36
creamos un fichero 01:01:39
con este nombre 01:01:41
pero lo creamos 01:01:42
en esa ruta 01:01:45
en la ruta 01:01:47
Donde está todo eso de aquí 01:01:48
Vale 01:01:51
Vale, entonces para 01:01:52
Puedo concatenar la ruta 01:01:54
Es decir, podéis concatenar aquí la ruta 01:01:56
C, no sé qué, archivos de servidor 01:01:59
Barra 01:02:01
Y concatenarle name json 01:02:02
Esto lo podemos hacer también 01:02:05
Como 01:02:10
Con otra versión del constructor 01:02:10
Como se llama el fichero xml 01:02:13
File xml 01:02:17
.getParent 01:02:18
y ahora 01:02:20
name 01:02:21
JSON 01:02:23
este es otro constructor del objeto file 01:02:25
el objeto file le puedes dar 01:02:30
tú toda una ruta 01:02:32
enterita, que se la podríamos 01:02:34
dar, que sería concatenar el p 01:02:36
archivos de servidor, vuestra ruta 01:02:38
concatenarlo a name JSON directamente 01:02:39
o le podemos dar un directorio 01:02:42
y un nombre 01:02:44
y te asocia 01:02:46
un objeto file 01:02:47
de un fichero de ese directorio 01:02:49
con ese nombre 01:02:52
a el objeto. Entonces, ¿qué directorio 01:02:52
he cogido? El directorio padre 01:02:56
del fichero que lo he enllogado. 01:02:57
Vale, entonces ya tengo 01:03:05
el objeto file creado. 01:03:13
El objeto creado, el fichero no, 01:03:15
lógicamente, el objeto file creado. 01:03:17
Ahora ya lo paso 01:03:19
a JSON ese objeto. 01:03:20
Recordad que pasar a JSON 01:03:23
era con el object mapper 01:03:24
que era el que lo hacía todo en la librería 01:03:26
Jackson, vale, la librería 01:03:28
Jackson 01:03:32
hacía un montón de cosas, pero todas las 01:03:33
hacía el object mapper que creaba los JSON 01:03:36
node, etcétera, pues de nuevo 01:03:38
el object mapper necesito la dependencia 01:03:40
de Jackson 01:03:42
pues otra vez al POM, a copiar y pegar 01:03:43
la dependencia de Jackson, que afortunadamente 01:03:48
la tenemos estable 01:03:50
porque ya nos ha funcionado 01:03:51
en otro 01:03:54
la dependencia del Jackson 01:03:54
que era 01:03:59
esta, que era 01:04:00
esta 01:04:15
esta era la dependencia 01:04:17
bueno 01:04:23
parte de mi objetivo 01:04:32
era que sufrieran 01:04:34
que os sintierais desconcertados 01:04:36
que copiarais y no supierais lo que estáis copiando 01:04:42
que os sintierais 01:04:45
fuera de vuestra zona de confort 01:04:47
con la programación y el desarrollo 01:04:49
Vale 01:04:50
¿Cómo que no tienes ni el POM? 01:04:55
A ver, he entrado al POM a copiar esto 01:05:03
¿El Jacksby ya lo tenéis? 01:05:06
Era bastante 01:05:15
No, sí, sí, sí, vais a volver enseguida 01:05:16
en cuanto reconstruyáis 01:05:21
la aplicación, a ver, que yo ahora mismo 01:05:23
esta aplicación la voy a subir para que la tengáis completa 01:05:25
antes de subirla 01:05:27
vamos a revisar todo lo que hemos hecho 01:05:29
No, no estáis perdidos 01:05:31
Vale, dependencia 01:05:36
La dependencia 01:05:38
Vale, pues 01:05:41
es que esa va a ser vuestra vida 01:05:43
Si desarrolláis, claro 01:05:45
A lo mejor hacéis otra cosa 01:05:47
¿La dependencia de Jackson la habéis puesto? 01:05:48
A eso sí 01:05:57
Vale, pues si hemos puesto 01:05:58
La dependencia de Jackson 01:06:08
El object mapper este 01:06:09
Ya me lo deja importar, menos mal 01:06:11
Y ahora ya 01:06:13
Pasar al JSON 01:06:16
Si yo no quiero cambiar nombres de campos 01:06:17
Ni de nada 01:06:19
Era el object mapper 01:06:20
Que 01:06:21
Para 01:06:23
Un momento para no 01:06:31
Vale 01:06:32
Y esto el mapper 01:06:41
Tenía 01:06:46
Vamos a sacar 01:06:47
era esto, el writer with 01:06:48
default pretty printer este 01:06:50
sacábamos el writer que te imprimía 01:06:53
bonito 01:06:55
y aquí ahora este tenía 01:06:55
un write 01:06:58
un writer, ¿sabéis lo que? 01:07:00
y aquí ya escribíamos 01:07:05
nuestro 01:07:07
objeto que era 01:07:09
al recetario 01:07:12
¿a dónde? 01:07:13
al fichero F 01:07:17
que era file json 01:07:22
¿lo he puesto al revés? 01:07:24
lo sabía 01:07:28
según lo escribía me parecía 01:07:28
algo me 01:07:30
angustia por aquí 01:07:32
vale 01:07:33
¡hala! ¿ya está? 01:07:34
ya está, solo nos falta 01:07:40
generar un formulario de descarga del json 01:07:42
y ya hemos terminado 01:07:45
y podemos empezar desde el principio 01:07:46
dime 01:07:48
esto de aquí 01:07:49
a eso te refieres 01:08:02
que qué es esto 01:08:06
claro, crea el objeto file 01:08:07
con un nombre que es el mismo 01:08:12
que tiene este 01:08:14
pero cambiando la extensión .xml 01:08:15
por .js 01:08:18
¿vale? 01:08:19
Y ahora ya el mapper es lo que vimos el otro día, 01:08:21
que te escribe el objeto como JSON. 01:08:25
El objeto es de Recep, que yo he leído del XML, 01:08:28
me lo escribe como JSON. 01:08:32
Ya está. 01:08:34
¿Vale? 01:08:35
Vale, pues vamos a probarlo. 01:08:35
No me va a ofrecer el formulario de descarga todavía, 01:08:36
pero vamos a ver si en la carpeta archivos del servidor 01:08:39
me ha hecho el JSON, que es lo que importa. 01:08:42
Luego ya que me ofrezca el formulario de descarga, 01:08:45
ya es lo de menos. 01:08:48
vale, entonces 01:08:51
aquí vamos a 01:08:55
import 01:08:57
vale, pues mi json, mi serlet 01:08:58
al que acabo de volver, mi serlet 01:09:01
ahora ya va a convertir 01:09:03
a json 01:09:06
este fichero f 01:09:07
que es el fichero 01:09:09
que yo he leído 01:09:12
del 01:09:14
request 01:09:15
uy, no mandé 01:09:17
Perdón, sí, no lo he devuelto 01:09:22
Lo va a haber creado, pero no lo va a haber devuelto 01:09:25
Vale, return file.json 01:09:29
Venga, vamos a ejecutar ahora nuestra aplicación otra vez 01:09:31
Voy a vaciarle archivos de servidor 01:09:43
Está todo limpio, vacío 01:09:47
Ejecutamos la aplicación 01:09:50
XML to JSON 01:09:54
Venga 01:09:56
¿Qué fichero quieres subir? 01:10:05
Tiene que ser uno con esa arquitectura 01:10:10
Jaxb, porque si no, lógicamente 01:10:12
El Jaxb context va a fallar 01:10:14
Ese, vale 01:10:16
Súbelo, me llamaste 01:10:18
Pero no sé hacer nada, mientes 01:10:21
Seguro que en archivos de servidor me has creado 01:10:23
El JSON, míralo, aquí está 01:10:25
Este Serlen maravilloso 01:10:27
Nos ha convertido 01:10:29
Este recetario XML 01:10:31
Tan feo de JSON 01:10:32
de XML 01:10:35
nos lo ha convertido 01:10:37
en JSON. 01:10:38
Hombre, lo puedes hacer con DOM, 01:10:45
pero es un rollo, mucho más fácil con JaxB. 01:10:46
Sí, bueno, 01:10:53
clic derecho no, 01:10:54
generate JaxB classes. 01:10:55
Pero cuidado porque esas 01:10:57
luego te las genera como internas, 01:10:58
además. Dime. 01:11:00
¿El secretario XCPL 01:11:02
dónde lo ha inscribido? 01:11:03
donde yo le he dicho 01:11:05
que me lo suba el Sherlet 01:11:08
bueno, es con el que estuvimos haciendo este ejemplo 01:11:10
lo tenéis que tener en el archivo 01:11:17
pues bueno, en su momento es que lo hicimos 01:11:19
pero vamos 01:11:24
repetición rápida 01:11:25
que sí, que le he dado 01:11:34
hombre, no le he dado, no le he dado 01:11:37
así que te voy a dar 01:11:39
venga 01:11:40
vale, mi aplicación es esta 01:11:42
repito 01:11:45
mi aplicación es esta 01:11:48
cuando el Tomcat 01:11:50
detecta esta URL 01:11:52
se va a buscar el index 01:11:54
lo que sea, lo que el web 01:11:57
XML le ha dicho 01:11:58
bueno, pues mi index, que es el que se va a buscar 01:11:59
era este, este index 01:12:02
Es un formulario que sube un fichero de nombre file, el que a mí me ha dado la gana ponerlo ahí, y lo sube en una petición tipo post y además una petición multiparte, porque tiene un fichero y luego es multiparte, una petición tipo post. 01:12:04
Y además, cuando ese request llegue con este fichero file metido dentro a través del método post, va a invocar a la ruta a Bloat, va a invocar a esa ruta, ¿vale? 01:12:20
Entonces, todo esto llega al servidor. 01:12:34
Ese multiparte con el file dentro diciéndole, oye, que el que va a procesar este multiparte, el que lo va a procesar, es esta URL. 01:12:37
El Tomcat dice, ¿y esa URL a dónde va? 01:12:46
bueno, pues en el web xml 01:12:48
tenemos la información 01:12:51
de a dónde va esa url 01:12:52
entonces el Tomcat 01:12:54
a falta de otra forma de decírselo 01:12:56
busca aquí 01:12:58
busca aquí y dice 01:13:00
ah, espérate que la ruta 01:13:02
a Bloat tiene un destino 01:13:03
que es el destino 01:13:06
este, vale, genial 01:13:07
pues me voy a este destino 01:13:10
para procesar 01:13:11
esa petición 01:13:12
para procesar esa request que lleva el fichero 01:13:14
se va a este destino 01:13:18
que está aquí 01:13:21
en el request 01:13:23
va el fichero 01:13:27
y él construirá ya el response 01:13:29
bueno, pues vamos a sacar 01:13:32
el fichero del request 01:13:33
el fichero es una parte enterita 01:13:35
que tiene información como nombre 01:13:39
etcétera, etcétera 01:13:41
y los datos binarios 01:13:42
pues primero nos generamos 01:13:43
un flujo de datos binarios 01:13:47
asociadas a la parte 01:13:49
lo que es los datos binarios del archivo. 01:13:51
Y luego sacamos el nombre del archivo, 01:13:53
que también lo sacamos de la parte enterita. 01:13:56
Nos sacamos el nombre. 01:13:58
El nombre lo sacamos con este método 01:14:00
que se metía en la cabecera. 01:14:02
De la cabecera encuentra la información file name 01:14:05
igual a lo que sea 01:14:08
y se saca el nombre de ahí. 01:14:10
Pues con este método auxiliar 01:14:13
sacamos el nombre del fichero. 01:14:15
Luego tenemos request con un input string. 01:14:17
Ahora, ¿qué hacemos? 01:14:21
Creamos un fichero con el nombre del fichero subido. 01:14:23
Creamos un fichero local. 01:14:29
Si ese nombre tuviera separadores, los quitamos. 01:14:32
No queremos la ruta, queremos solo el nombre. 01:14:35
Luego tenemos ahora ya, request con el input string, 01:14:38
con los datos binarios y un fichero local, 01:14:41
con un output string asociado. 01:14:44
Pues del input string del request, 01:14:47
escribimos en el output string del fichero local 01:14:49
vamos sacando byte 01:14:51
del request y los vamos 01:14:53
escribiendo en el fichero local 01:14:55
ya está, cuando ya hemos terminado 01:14:56
ya tenemos en mi 01:14:59
objeto file 01:15:01
tengo el fichero que venía en el request guardado 01:15:02
local, convertimos 01:15:05
ese objeto file 01:15:07
que está ahí ya local, guardado 01:15:09
en local, con los datos 01:15:11
del request, lo convertimos a 01:15:13
JSON, con este 01:15:15
método, que este método ya 01:15:17
pues no tiene nada de aplicaciones web 01:15:19
es lo que hemos visto, leemos 01:15:21
el objeto JaxB y lo 01:15:23
mandamos a JSON 01:15:25
y ya se ha acabado, ya lo tenemos 01:15:26
en un fichero JSON 01:15:31
guardado 01:15:33
y aquí lo que nos falta es 01:15:33
que la respuesta sea un formulario que me 01:15:36
permita descargar este archivo 01:15:38
porque ahora mismo se ha quedado local 01:15:40
en el servidor Tomcat, se ha quedado 01:15:43
local y ha convertido, ¿vale? 01:15:44
¡Hala! Ya está 01:15:47
Ahora, dudas. 01:15:48
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:
21
Fecha:
4 de noviembre de 2025 - 12:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 15′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
367.26 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid