Saltar navegación

20251209 BDR-Servlet_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 9 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues ahora 00:00:00
Tener una entidad del modelo 00:00:03
Sobre el que vamos a hacer 00:00:05
Tareas de CRUD 00:00:07
Si seguimos el patrón DAO 00:00:09
Que es lo que normalmente hacemos 00:00:11
Implica tener una interfaz DAO 00:00:12
En la que recogemos esas funciones 00:00:14
Esas operaciones 00:00:17
Entonces estas son las operaciones 00:00:18
Directamente tocando la base de datos 00:00:20
Insertar un objeto de venta 00:00:22
Recuperar por ID, recuperar todos 00:00:24
Borrar una venta por ID 00:00:27
Y ahí podríamos poner más 00:00:28
No me digas que ya voy de pisa 00:00:30
Dime, dime 00:00:31
Sería una por entidad 00:00:33
En principio 00:00:44
Una para todas 00:00:45
Qué necesidad 00:00:51
Sí, pero una por entidad 00:00:53
O sea, si tú tienes ahora una tabla que es coche, pues tendrás tu propio coche DAO, donde tendrás insert coche, find by del coche, entonces son separados porque así es como tiene que ser, sino que vas a hacer un único DAO que sea DAO en general y ahora insert coche, insert 20, insert no sé qué, no se queda muy acoplado eso, muy easy. 00:00:57
Y luego, la idea es que yo quiero cambiar el relacionado con coche. 00:01:24
Pues rápidamente me voy a la parte de coche, que está aquí metidita. 00:01:28
Precisamente lo que queremos es separar muchas clases pequeñitas, 00:01:33
semánticamente distintas, en lugar de una clase gorda con cosas. 00:01:37
El principio básico es muchas clases pequeñitas y no una gorda con muchas cosas. 00:01:43
Es todo lo contrario a la filosofía del desarrollo. 00:01:47
Es que, de hecho, la aprobación estructurada... 00:01:51
Reconocimiento de objetos 00:01:53
Precisamente 00:01:56
Nació por eso 00:01:57
Para olvidarnos de los programas estructurados 00:01:59
Quedan 200.000 líneas de código 00:02:02
Que eso no había manera de mantener nada 00:02:03
De incorporar ninguna funcionalidad nueva 00:02:06
Nada, es decir, vamos a separar 00:02:08
Lo relacionado con la vista 00:02:09
Aquí lo relacionado con no sé qué, aquí vamos a separar 00:02:12
Entonces nos volvamos a juntar otra vez 00:02:14
Entonces hemos perdido lo que hemos ganado 00:02:16
¿Sí o no? 00:02:17
Bueno 00:02:20
No solo 00:02:21
vale, entonces, ahora como solo tenemos 00:02:24
una entidad y una única tabla 00:02:27
estamos en versión sencilla, pues una única clase 00:02:28
con los métodos que uno quiera poner 00:02:30
vale 00:02:33
entonces 00:02:34
que poco veo aquí 00:02:35
que poco brillo tiene esto 00:02:38
ahí me va 00:02:41
vale, entonces 00:02:49
esto es una interfaz en la que nos 00:02:52
comprometemos 00:02:54
a realizar ciertas funciones pero no especificamos 00:02:55
cómo, porque cómo lo vamos a hacer 00:02:58
Puede cambiar en un momento dado 00:03:00
Entonces el cómo lo vamos a hacer 00:03:02
Lo especificábamos en la DAO implementación 00:03:04
Que implementaba la DAO 00:03:07
Y la DAO implementación 00:03:10
Ya tiene los detalles sobre cómo se hacen 00:03:12
Las operaciones 00:03:14
En este caso hicimos el insert de esta manera 00:03:15
¿Vale? 00:03:18
Aquí pues aprovechamos para recordar 00:03:20
Que todos los recursos 00:03:22
Que se usan y necesitan ser cerrados 00:03:23
Si lo que yo estoy haciendo 00:03:26
O como lo estoy diseñando 00:03:29
me permite meterlo en un try con 00:03:30
recursos, pues mejor, porque entonces ya se va 00:03:32
a cerrar solo, no tengo que preocuparme de los 00:03:34
close. Y statement es 00:03:36
un objeto que se 00:03:37
cierra, tiene un close, ¿vale? 00:03:40
Entonces, lo metíamos aquí y ya está. 00:03:42
Aquí lo abrimos 00:03:47
aquí, ¿vale? Suele ser lo habitual. 00:03:48
Los recursos que se cierran, 00:03:50
que además van a generar excepción y meterlo en un try catch. 00:03:52
Pues nada, aquí teníamos ya las particularidades. 00:03:54
Insert, venta, 00:03:56
encontrar por ID, 00:03:58
Que este le hicimos 00:03:59
Y dejamos pues 00:04:02
Estos dos de abajo vacíos 00:04:04
¿Vale? 00:04:06
Entonces este ya necesita 00:04:08
Tocar el barro 00:04:10
Entonces necesitar tocar el barro 00:04:12
Necesita 00:04:14
Implica que necesita una conexión 00:04:15
Porque las sentencias se crean a partir de conexiones 00:04:17
Bueno pues 00:04:20
Necesita una conexión que ya va a ser una propiedad suya 00:04:21
Una propiedad suya 00:04:24
Que le inyectamos aquí por parámetro 00:04:26
¿vale? 00:04:28
ahora, esta es la parte que toca 00:04:31
el acceso a datos, luego ya 00:04:32
la aplicación tiene unas funciones 00:04:34
más generales 00:04:36
que seguramente necesiten 00:04:38
tocar la parte de acceso a datos, pero ya son 00:04:40
sus propias funciones, las funciones que de la 00:04:42
aplicación, esas funcionalidades 00:04:44
que me da mi aplicación son 00:04:47
los servicios que me da mi aplicación 00:04:48
eso tiene sentido, que ahora ya lo metamos en otra 00:04:50
clase de servicios, que recoge 00:04:52
que recoge los servicios que me da la aplicación 00:04:54
que esos servicios lógicamente 00:04:56
van a tener que llamar muchos de ellos a esto de aquí 00:04:58
porque lo que hacen es actualizar la base de datos o consultar 00:05:01
bueno pues para eso teníamos esta clase de aquí 00:05:05
y esta clase de aquí pues me daba crear una venta 00:05:08
para lo cual yo llamaba insert venta 00:05:14
para lo cual tenía que usar un objeto dado 00:05:16
bueno pues claro entonces 00:05:19
ventaservice tendrá como propiedad suya un objeto dado 00:05:21
y ya está que le inyectamos también por parámetro 00:05:24
y este objeto dao 00:05:27
nos permite aquí 00:05:30
pues hacer lo que haya que hacer 00:05:31
¿y cómo sabe ese objeto dao cuál es su implementación? 00:05:33
si dao era la... 00:05:35
eso 00:05:36
da igual como sea, aquí no estamos en tipo de ejecución 00:05:37
todavía, o sea cuando ya 00:05:41
la aplicación se ejecute, instancia es un servicio 00:05:42
ahí es donde importa darle valor 00:05:45
a este, aquí está simplemente declarando 00:05:47
entonces aquí nos da igual 00:05:49
el dao cual sea, nos da igual 00:05:51
claro, con que sea 00:05:53
una instancia de algo que 00:05:55
implemente esto o herede de eso 00:05:57
¿vale? entonces 00:05:59
crear venta era llamar a inserventa 00:06:01
get venta era 00:06:04
llamar a find by id 00:06:05
y podría tener mucho más servicios 00:06:07
relacionados con acceso a datos o no 00:06:09
estos dos en particular están relacionados con acceso a datos 00:06:11
y ahora ya si que teníamos 00:06:13
nuestra aplicación 00:06:15
que en este caso 00:06:18
en esta versión era de escritorio 00:06:19
y esta aplicación de escritorio 00:06:21
pues ahora tenía que crear 00:06:23
un objeto servicio para hacer las cosas 00:06:25
para eso tenía que crear un objeto servicio 00:06:27
para hacer las cosas 00:06:29
y ahora, para crear un objeto servicio 00:06:30
hay que tener creado ya previamente un objeto DAO 00:06:32
entonces aquí sí que hay que instanciar 00:06:35
un objeto que implemente DAO 00:06:38
aquí ya sí, porque va a haber que metérselo al service 00:06:41
y una vez que tengamos el service 00:06:43
pues ya hacemos lo que nos da la gana 00:06:45
como hicimos aquí, crear una venta 00:06:46
que comprobamos que funcionaba 00:06:48
recuperar una venta por ID 00:06:49
que comprobamos también que funcionaba 00:06:51
las dos únicas cosas que teníamos 00:06:53
entonces para instanciar 00:06:54
este objeto DAO 00:06:57
pues ahora yo ya si elijo 00:06:58
que 00:07:00
como lo instancio 00:07:01
pues probamos 00:07:05
dos versiones 00:07:07
haciendo 00:07:08
instanciando con nuestra única 00:07:11
implementación que teníamos hasta ahora hecha 00:07:15
de DAO, la única implementación que teníamos hecha era esta 00:07:17
entonces tengo que implementar esta 00:07:19
y entonces pasándole una conexión 00:07:21
única 00:07:23
o pasando una conexión sacándola de un pool. 00:07:24
Entonces, para eso habíamos hecho esta clase conexión 00:07:29
y esta clase conexión es una clase simplemente 00:07:32
que me sirve para sacar conexiones. 00:07:36
Sacar conexiones que necesita este de aquí. 00:07:38
Porque este de aquí es el que ya habíamos dicho 00:07:42
que ya tocaba la base de datos y necesita este objeto. 00:07:44
Lo necesita, porque si no, no puede tocar la base de datos 00:07:48
y hacer sentencias ni nada. 00:07:50
entonces esta aplicación 00:07:51
para instanciar el venta 00:07:54
de la implementación necesita una conexión 00:07:56
pues en esta clase 00:07:58
recogíamos toda la complejidad 00:08:00
de crear las conexiones 00:08:02
y esta clase 00:08:03
y esta clase era esta 00:08:07
vale 00:08:09
y en esta clase metíamos 00:08:11
las dos posibilidades 00:08:14
una conexión única 00:08:15
o un pool de conexiones 00:08:18
entonces la conexión única 00:08:20
la sacamos con getConnection 00:08:23
este es el singleton para la conexión 00:08:24
el singleton para un objeto significa 00:08:26
la clase que te garantiza 00:08:29
que solo vas a tener una instancia 00:08:31
de ese objeto en todo el ámbito de la aplicación 00:08:32
en todo el ámbito 00:08:35
lo que te dirían 00:08:37
en todo el scope, porque queda más fino 00:08:39
pero es el ámbito 00:08:41
se refiere al ámbito 00:08:42
vale, pues el getConnection si la conexión es null 00:08:43
creo una nueva 00:08:47
si la conexión es null, creo una nueva 00:08:49
este con de aquí, no sé para qué está puesto 00:08:52
pero bueno, da igual que esté puesto 00:08:53
que no, si la conexión es nueva 00:08:55
perdón, si la conexión es null, cada vez que llamen 00:08:57
a getConnection, instancio 00:08:59
una nueva, sacando del properties 00:09:01
sacando del properties 00:09:04
las propiedades, la instancio 00:09:05
con el driver manager getConnection 00:09:07
instancio la conexión y ya está 00:09:09
y si la conexión 00:09:11
no es null, ya existe 00:09:14
alguien la ha instanciado antes, no tengo que hacer nada 00:09:16
entonces este retuncon o me devuelve 00:09:18
la que ya está instanciada 00:09:21
de antes 00:09:22
o si no hay ninguna porque es la primera vez 00:09:23
que se llama el getConnection 00:09:27
pues me instancia una, me instancia una con las propiedades 00:09:28
del fichero properties 00:09:31
y ya está 00:09:33
entonces este getConnection ya me devuelve una conexión 00:09:33
pues entonces yo lo puedo llamar desde aquí 00:09:37
este getConnection lo puedo llamar desde aquí 00:09:39
para implementar 00:09:42
un venta da implementación, desde ahí lo puedo llamar 00:09:44
llamar, que 00:09:47
tenga una aplicación multilo y no quiero 00:09:48
una única conexión 00:09:50
que luego voy a tener que cerrar 00:09:52
sino que quiero 00:09:54
un pool de conexiones y pedirle 00:09:55
a él la conexión 00:09:58
bueno, pues 00:09:59
esta clase de conexión la hicimos para que 00:10:02
también me pudiera dar un objeto pool de conexiones 00:10:04
el objeto pool de conexiones es 00:10:07
data source 00:10:08
y entonces este objeto pool de conexiones pues lo mismo 00:10:09
que es la primera vez que instancio 00:10:12
a dame el pool 00:10:15
que es la primera vez que lo instancio, pues lo creo 00:10:16
de nuevas, lo creo de nuevas 00:10:18
de esta manera 00:10:20
vale, esta era una de las posibles 00:10:22
implementaciones 00:10:24
de un pool de conexiones 00:10:26
vale, la que más se usa actualmente 00:10:28
es una de las posibles 00:10:31
que no es null 00:10:32
porque ya lo has instanciado de antes 00:10:34
pues no hagas nada, en cualquier caso me devuelves 00:10:36
ese pool de conexiones 00:10:38
entonces este get pool es la 00:10:39
implementación del 00:10:42
Singleton para este objeto pool 00:10:44
DataSource. Bueno, pues 00:10:46
entonces aquí probamos 00:10:48
las dos posibilidades. O instanciar 00:10:50
un venta dado con una 00:10:52
conexión única 00:10:54
o instanciar un venta dado 00:10:55
con una conexión sacada 00:10:58
del pool. Porque una vez que yo tengo el 00:11:00
pool, pedirle una conexión es 00:11:02
goodConnection y ya está. Vale, una vez 00:11:04
que tengo el pool, pedirle la conexión 00:11:06
es esto. Pues bien, sacando 00:11:08
una conexión del pool o bien 00:11:10
creando una única en ese momento 00:11:12
pues hicimos las comprobaciones 00:11:14
y este servicio funcionaba, hacía las cosas 00:11:16
con la base de datos y todo eso, ¿vale? 00:11:18
Correcto 00:11:22
pues entonces, vamos a 00:11:22
completar 00:11:25
esto, completando los 00:11:26
métodos que nos faltan, pero moviéndonos 00:11:28
de esta arquitectura a 00:11:30
una arquitectura web 00:11:32
desde cero, desde la base con serlets 00:11:33
¿vale? 00:11:36
Entonces va a ser mucho copia y pega 00:11:38
es llevarme toda esta arquitectura de modelo 00:11:40
de servicio de DAO es llevármelo 00:11:42
todo a mi 00:11:44
aplicación ahora ya web 00:11:46
y luego en lugar de 00:11:48
hacer un ventas app como este 00:11:50
con un main, pues hacerme un serlet 00:11:52
y punto pelota 00:11:53
punto pelota con los pequeños matices 00:11:56
que pueden ir surgiendo, pero ya está 00:11:58
¿vale? 00:12:00
entonces lo que es importante es tener 00:12:02
en la cabeza las ideas claras 00:12:04
de que es cada cosa, que es 00:12:06
porque si tú tienes las ideas claras de que 00:12:08
es cada cosa y ese puzzle está más o menos ahí 00:12:10
luego ya cuando vas a construir algo nuevo 00:12:12
pues coges las piezas correctas 00:12:15
porque las conoces, sabes lo que significa cada una 00:12:17
entonces coges las piezas correctas 00:12:19
y ya haces el montaje, durante el montaje 00:12:21
te pueden fallar cositas, pero no pasa nada 00:12:23
porque tú más o menos sabes de que va todo 00:12:25
y esas cositas que te fallan 00:12:27
pues si le preguntas a HGPT 00:12:28
a internet, rápidamente 00:12:31
vas a encontrar la solución 00:12:33
pero tienes que conocer las piezas 00:12:34
pues venga entonces, ahora ya 00:12:36
abrimos el otro 00:12:39
web developer 00:12:40
el otro eclipse 00:12:42
el de desarrolladores web para 00:12:44
hacer esta aplicación, ¿qué te pasa? 00:12:46
no puedo hacerla en español 00:12:48
pues no, porque tú, ¿qué quieres ser? ¿listo o tonto? 00:12:49
tonto 00:12:53
no, tú quieres ser alguien que lo controles 00:12:54
todo 00:12:56
¿vale? 00:12:57
estoy segura, mira, no se lo he preguntado 00:13:00
pero estoy segura que si le preguntas a chat GPT 00:13:02
¿tiene sentido que mis alumnos de acceso 00:13:04
a datos de segundo de edad 00:13:06
conozcan la arquitectura de Servlet 00:13:07
o directamente les empecéis a hablar en Spring 00:13:10
no se lo he preguntado 00:13:12
pero estoy segurísima de lo que te voy a contestar 00:13:14
otra cosa es que no opinemos de él o no 00:13:17
no, Aitor 00:13:19
se lo he preguntado 00:13:21
se lo preguntamos luego si quieres 00:13:22
pero vamos a ver, es que es verdad 00:13:24
sois una generación que no estáis acostumbrados 00:13:25
a entender las tripas de las cosas 00:13:29
hay que entenderlo todo 00:13:31
porque eso es lo que realmente 00:13:32
te puedes mover de contexto 00:13:34
y te va a haber quedado 00:13:36
unas conexiones neuronales 00:13:38
que al final 00:13:40
le sacas rendimiento 00:13:41
bueno ya, pues por eso os he dicho 00:13:43
espabilitos y rapiditos 00:13:51
porque si hoy estáis 00:13:53
porque si estáis espabilados hoy 00:13:54
he dicho cuando he empezado la clase 00:13:56
si estáis espabilados y hoy 00:13:58
esto queda claro y entendéis 00:14:00
realmente lo que es un servlet 00:14:03
pues entonces os dejo tranquila 00:14:05
con los seres el resto del curso, es lo que he dicho 00:14:07
¿vale? pero no podéis salir 00:14:09
de aquí 00:14:11
pero si yo no le he dicho 00:14:11
la pregunta no es esa 00:14:17
es si empezar directamente 00:14:18
a ver, le voy a hacer yo 00:14:20
la pregunta 00:14:23
vamos a ver 00:14:23
ya no, pero 00:14:26
la pregunta que le voy a hacer 00:14:29
Con mis alumnos de acceso a datos de Damm. 00:14:30
Si quiero darles aplicaciones web y UMBC, ir directamente a frameworks como Sprint, 00:14:45
sprint 00:15:08
o conviene pasar 00:15:08
por servlets. 00:15:14
Vale, a ver. 00:15:17
Honestidad. 00:15:19
No se lo he preguntado nunca. Vamos a ver 00:15:19
qué dice. 00:15:21
Justo. Conviene 00:15:30
pasar por servlets, pero no eternizarse en ellos. 00:15:31
Por eso os he dicho, si de una vez 00:15:33
¿cuánto tiempo os he dedicado? Un día 00:15:35
y hoy para que lo entendáis de una puñetera vez 00:15:37
y me veáis vuestro oxidado cerebro 00:15:39
¿vale? 00:15:42
creo que si me ponéis un poquito en la pantalla 00:15:42
para gastar mi atención, perfecto 00:15:44
por supuesto que no, con lo cual 00:15:45
conclusión 00:16:02
yo decido, pues ya está 00:16:04
y además la que os va a aprobar o suspender 00:16:05
desgraciadamente sea justo o injusto 00:16:08
voy a ser yo 00:16:10
y yo quiero gente lista 00:16:11
en mi clase 00:16:14
¿eh? 00:16:15
¿qué dices? 00:16:19
vamos a estar muy bien 00:16:20
Luis dice toma nota y lo hace 00:16:21
lo que sea 00:16:24
ya, bueno 00:16:25
toma nota tú también 00:16:27
ya estamos acostumbrados 00:16:29
bueno, a ver 00:16:30
de todas maneras 00:16:34
de verdad 00:16:37
vale, pues repito 00:16:38
no quiero dedicar 00:16:42
más del día de hoy, le estoy haciendo caso 00:16:44
en lo de no eternizarme 00:16:46
así que vamos a ello 00:16:47
venga 00:16:49
pues donde tenemos 00:16:50
el web developers 00:16:54
aquí, vamos a cerrarlo 00:16:56
todo, tenéis a mano el proyecto ese 00:16:58
de copiar y pegar, de hecho lo he preparado 00:17:00
todo en copiar y pegar 00:17:02
precisamente para que nos eternicemos 00:17:03
y poder terminarlo hoy. 00:17:05
Lo tenéis descargado, es un zip, tiene que tener 00:17:07
una clase, que es la clase servlet 00:17:09
y dos formularios, 00:17:11
creo. La clase servlet 00:17:13
la abrís en un bloc de notas 00:17:15
y de esa clase servlet vamos a ir 00:17:17
copiando y pegando en nuestro servlet 00:17:19
según vayamos necesitando. No es que abráis el servlet 00:17:21
sin más, porque entonces no entendemos nada. 00:17:23
Pues venga, vamos a hacer... 00:17:25
Buenos días. 00:17:27
Vale, pues vamos a hacer nuestra 00:17:32
aplicación web desde el principio. 00:17:34
Venga 00:17:36
Todo el mundo está conectado, ¿no? 00:17:39
Al universo 00:17:42
Venga 00:17:42
Aplicación web dinámica 00:17:44
¿Qué nombre le queremos poner? 00:17:48
Yo le voy a poner unidad didáctica 2 00:17:50
Esta misma de aquí para no liarme 00:17:53
Pero clase 00:17:56
Llamadla como os organizéis vosotros 00:17:58
Aunque yo esta, tal y como nos quede ya completa 00:18:04
La voy a subir a la ola virtual 00:18:06
Vale 00:18:07
La vamos a ejecutar en el servidor 00:18:09
Tomcat que tenemos instalado 00:18:12
En el equipo e integrado 00:18:14
Con el Eclipse 00:18:16
Todos tendréis en vuestro 00:18:17
Web Developers un entorno 00:18:20
De ejecución Apache 00:18:22
Pues tendrás que 00:18:23
Habilitarlo con el New Runtime 00:18:26
Vale, todo por defecto 00:18:28
Se queda así, estamos yendo 00:18:32
Muy despacito y muy relajados 00:18:34
Para que nadie se estrese 00:18:36
No, aquí lo tenemos 00:18:38
Vale, pero esta estructura 00:18:43
No nos gusta 00:18:45
Nos gusta la de Maven 00:18:46
Porque lógicamente querremos poner 00:18:48
Un Pong con dependencias 00:18:50
Pues entonces 00:18:52
Botón derecho 00:18:54
Configure 00:18:57
Si te la sabías 00:19:01
Porque ya la hemos hecho 00:19:05
Vamos a convertirlo a estructura de Maven 00:19:06
Venga, el grupo 00:19:09
Pues nuestro grupo de siempre 00:19:11
Aunque puede poner uno del dominio que quiera 00:19:13
Vale, ya está 00:19:15
Venga 00:19:17
El de convertir a Maven 00:19:18
Botón derecho 00:19:26
Configure, convert to Maven project 00:19:28
Se te abrirá esta ventanita 00:19:30
Yo he cambiado el grupo 00:19:34
Que me da por defecto 00:19:36
Porque ese grupo es muy feo 00:19:37
Se supone que ahí va un nombre de dominio 00:19:39
Y ya está 00:19:40
Vale, luego 00:19:41
Si nos da tiempo y si no igual echamos a Alejandra 00:19:46
Un rato, hoy teníais algo muy importante 00:19:49
Pues si nos da tiempo 00:19:51
Para dejarlo ya hoy completo 00:19:53
Podemos ya por fin empaquetar en un guard 00:19:54
De una puñetera vez y desplegarlo en un guard 00:19:57
En un Tomcat externo para que no se quede esto tan 00:19:59
Tan eclipse 00:20:01
¿Perdón? 00:20:03
En el developers 00:20:07
Dynamic Web Project 00:20:09
Vale 00:20:12
Vale, pues ala 00:20:13
Aquí ya tenemos el proyecto Maven 00:20:24
Que 00:20:26
Que máquina virtual 00:20:27
Me ha puesto, lo abrís en librerías 00:20:30
Como veis este proyecto 00:20:32
Como es una aplicación web, tiene dos 00:20:34
Librerías estándar 00:20:36
Con los papelitos, cuánto gasto el Amazonas 00:20:37
Está sufriendo mucho con vuestro justificante 00:20:42
Si es para el jueves 00:20:44
No hace falta que lo olvidéis 00:20:49
Vale, como veis la aplicación web 00:20:50
Tiene dos librerías 00:20:55
La de Jota 00:20:57
La máquina virtual de toda la vida 00:20:59
Y la del Tomcat 00:21:01
Porque ahora aquí va a haber 00:21:03
Y eso va a tener su implicación 00:21:04
Que la vamos a ver ahora 00:21:06
Dos contextos de programa 00:21:07
Nuestra propia aplicación 00:21:11
Es un contexto 00:21:13
Y el Tomcat es otro 00:21:14
Ahora va a haber dos aplicaciones ejecutándose 00:21:16
El Tomcat 00:21:19
Y nuestra aplicación 00:21:21
Y eso tiene ciertas implicaciones 00:21:22
¿Vale? Con una aplicación de escritorio 00:21:25
Está nuestra aplicación y ya está 00:21:27
Bueno, por supuesto la máquina virtual, claro, pero es que esa está siempre 00:21:28
Pero una aplicación web 00:21:31
Está nuestra aplicación y el Tomcat 00:21:33
Y las dos son aplicaciones Java ejecutándose 00:21:35
Y ahí hay ciertos conflictos 00:21:37
Vale 00:21:39
A mí me ha puesto 00:21:40
esta 22, pues nada, se lo dejo así 00:21:43
y se acabó 00:21:45
y vamos a quitar 00:21:46
lo rojo del POM 00:21:49
este de aquí 00:21:51
para no angustiarnos 00:21:52
era este, ¿no? yo creo 00:21:54
ya tenemos 00:22:00
quitado lo rojo del POM 00:22:02
vale, pues ahora vamos a construir la aplicación 00:22:03
pues vamos, pues los mismos 00:22:06
paquetes, el de modelo, el de DAO 00:22:08
el de implementación, el de servicio 00:22:10
el de connect, menos el de la aplicación 00:22:12
ese no 00:22:15
Pues venga, en nuestro main java 00:22:15
Vamos a crearlos antes de nada 00:22:18
Y luego ya arrastramos las clases 00:22:20
Yo no arrastro los paquetes directamente 00:22:22
De una a otra porque me cambia la estructura 00:22:26
Y eso desmadre 00:22:28
Pero 00:22:30
Prefiero ir sobre seguro siempre 00:22:30
Pues venga 00:22:33
Este va a ser el paquete para las clases del modelo 00:22:35
Este va a ser 00:22:38
El paquete para las clases 00:22:43
DAO 00:22:45
Este va a ser el paquete 00:22:46
Para las clases 00:22:55
Implementación de DAO 00:22:56
Este va a ser el paquete 00:23:00
Para 00:23:07
Las clases del servicio 00:23:08
Y este va a ser el paquete 00:23:11
Para 00:23:18
Lo relacionado con crear la conexión 00:23:21
Quiero mantener el nombre 00:23:24
De los otros para luego no cambiar 00:23:28
Y estos serán los cinco paquetes 00:23:29
Que nos interesaba 00:23:33
¿Vale? 00:23:34
Sí, pero ahora después vamos a copiar primero lo de la otra 00:23:36
Y cuando ya tengamos copiado lo de la otra 00:23:39
Ahora ya hacemos nuestro controlador 00:23:40
¿Vale? 00:23:43
Venga, pues a ver 00:23:46
De la otra 00:23:47
Pues me llevo yo 00:23:49
Pues ya está, del modelo 00:23:50
Venga, se acabó 00:23:52
Pues copy 00:23:54
Las vais copiando todas 00:23:55
Y ya está 00:23:57
Sí, se pega raro 00:24:00
Pero no pasa nada 00:24:13
Conexión 00:24:13
Si miras luego la estructura de carpetas por dentro 00:24:17
Está bien 00:24:22
Pero el Eclipse a veces se raya 00:24:23
Dao 00:24:27
Dao 00:24:37
Dao implementación 00:24:45
Y servicio 00:24:52
Un segundo 00:25:02
Servicio 00:25:04
Bueno, pues estas son las mismas 00:25:11
Me da igual que arquitectura de aplicación tenga 00:25:18
Me da exactamente igual 00:25:20
Sí 00:25:23
Una cosa, por ejemplo, a mí no me saca la clase 00:25:26
Con la arquitectura de web 00:25:29
Y por lo de deployment 00:25:31
De script, de script, no me sale 00:25:33
Me sale solo lo de maven 00:25:35
O sea, tú has creado una aplicación 00:25:37
Esta 00:25:41
Sí, sí, el dynamic web project 00:25:42
Y luego le has convertido a maven project 00:25:45
Sí, pero es que ni con el dynamic web project 00:25:47
Me sale como una clase normal 00:25:49
Bueno 00:25:55
Vamos a tirar 00:26:02
Porque si no, no acabamos 00:26:03
Y luego ya, pues los que hayan 00:26:05
Fallecido en alguno de los 00:26:07
Momentos 00:26:09
Pues ya vemos, ¿vale? 00:26:11
Vale, hasta aquí estamos, ¿no? 00:26:14
Entonces, lógicamente 00:26:16
Tenemos 00:26:17
Ciertos problemas 00:26:19
Aquí, este import 00:26:21
lo vamos abriendo 00:26:23
lógicamente tenemos 00:26:25
el problema de las dependencias 00:26:26
aquí ya nos aparece la de 00:26:29
Icari, ¿verdad? 00:26:31
entonces vamos a copiar el POM, claro, lógicamente 00:26:32
entonces 00:26:35
las mismas dependencias que teníamos 00:26:37
en este 00:26:39
que eran el conector 00:26:39
de MySQL, fundamental 00:26:43
el del pool de conexiones 00:26:45
y esto que 00:26:47
hacía falta para el pool 00:26:49
pues las tres eran nuestras únicas tres 00:26:50
dependencias, las que estábamos usando, nada más 00:26:56
pues estas mismas tres se van 00:26:58
al otro lado, se van aquí 00:27:00
al otro lado 00:27:08
¿Cómo que tres? ¿Perdón? 00:27:08
¿Perdón? 00:27:14
La de arriba, ¿cuál es? 00:27:15
La del driver MySQL 00:27:17
y las dos relacionadas con 00:27:19
las tres que teníamos en el otro 00:27:21
proyecto, las he copiado tal cual 00:27:23
vale, pues ya efectivamente 00:27:24
se nos han quitado todos los 00:27:34
errores de 00:27:36
desarrollo, ya se nos han 00:27:37
quitado de compilación 00:27:40
y aquí tenemos todos los paquetitos 00:27:45
con todas sus clases 00:27:50
bueno, pues ahora ya sí que sí 00:27:51
¿quién va a llamar ahora al servicio? 00:27:56
pues al servicio 00:28:00
lo va a llamar nuestro controlador 00:28:00
cuando sea invocado 00:28:02
desde una HTTP, desde una 00:28:04
petición HTTP, ¿vale? 00:28:06
y eso aplica 00:28:09
a Spring y al mundo entero 00:28:10
una petición HTTP 00:28:12
te va a invocar 00:28:14
a algo que despierta 00:28:16
a un serlet. Ese algo puede 00:28:19
ser una clase de sprint que despierta 00:28:21
al serlet o puede ser el propio serlet. 00:28:23
Bueno, perdón, 00:28:26
no a una clase de sprint, no al serlet de sprint. 00:28:27
Sprint es un serlet, eso es sprint. 00:28:29
Un serlet gordote que se 00:28:31
encarga de reencaminar a otras cosas. 00:28:33
Bueno, pues entonces 00:28:36
vamos a hacer nuestro controlador, 00:28:37
nuestro serlet directamente. 00:28:39
Pues venga, nos vamos a hacer un paquete. 00:28:41
A ver. 00:28:47
Podemos directamente decirle, oye, 00:28:49
que quieres, una clase y poner la 00:28:51
creed de serlet 00:28:52
o hacer un new serlet 00:28:53
porque el eclipse 00:28:56
web developer, pues ya 00:28:58
vale, pues le hacéis un new serlet y ya nos 00:29:00
pero en la hora que creamos 00:29:02
un paquete 00:29:07
ay perdón, que no he creado el paquete todavía, es verdad 00:29:07
si, si, si 00:29:10
vamos a hacer 00:29:12
un paquete pues con 00:29:13
.dam2.controller 00:29:16
por ejemplo 00:29:18
controller, y ahora ya si 00:29:19
Dentro de este paquete 00:29:22
Hacemos un nuevo serlet 00:29:24
Vale 00:29:26
¿Cómo vamos a llamar al serlet? 00:29:28
Bueno, pues 00:29:32
Como es el serlet 00:29:33
Que va a gestionar las ventas 00:29:35
Pues podríamos llamarlo 00:29:37
Venta serlet, ¿vale? 00:29:39
Espera, lo que pasa es que 00:29:50
Si vais a copiar y pegar 00:29:51
Bueno, no, porque iba a decir 00:29:53
Por llamarlo igual que lo que sé, pero no 00:29:55
Porque si hay cosas que son distintas 00:29:56
Al cambiarlas, lo vamos a entender mejor 00:29:58
Lo vamos a llamar venta a Serlet 00:30:01
Ya está 00:30:02
Aquí ya lo tenemos todo 00:30:03
Los Serlet se heredan 00:30:10
De este, next 00:30:11
Vale 00:30:13
Y ahora, el Serlet 00:30:13
¿Cómo se lanza? 00:30:17
Se lanza en respuesta a una 00:30:19
URL, a una petición 00:30:21
HTTP 00:30:24
A una URL 00:30:25
Vale, pues aquí te está diciendo 00:30:27
oye, ¿qué URL 00:30:29
quieres que despierte a este 00:30:31
serlet? Esta 00:30:32
URL nos gusta, es decir, la 00:30:34
raíz donde esté desplegado nuestro proyecto 00:30:36
la raíz que sea, yo despliego donde me dé la gana 00:30:38
pues aquí se refiere, donde esté 00:30:41
desplegado tu aplicación 00:30:42
y a continuación ventas serlet 00:30:44
ahí quieres que se despierte, bueno, pues no sé 00:30:46
nos gusta 00:30:49
a mí es que las rutas 00:30:49
con mayúsculas y minúsculas 00:30:52
pues en la URL no me 00:30:54
gustan, porque es una 00:30:56
es indistinguible 00:30:58
para una petición HTTP las mayúsculas y minúsculas 00:31:00
entonces como que crea confusión 00:31:02
entonces yo prefiero 00:31:04
a este le vamos a llamar por ejemplo 00:31:06
ventas, sin más 00:31:07
cuanto más sencillita sea la URL 00:31:09
mejor para todos, y si no tiene mayúsculas y minúsculas 00:31:11
mejor, ventas 00:31:14
vale, pues entonces, este servlet 00:31:16
se va a despertar 00:31:20
cuando la URL sea ventas 00:31:21
que es que 00:31:24
que 00:31:28
Parámetro de iniciación del servlet 00:31:31
No, no nos metemos en historias de esas 00:31:37
Ya está 00:31:38
Next, vale 00:31:39
Esto lo podemos dejar así 00:31:42
Todo por defecto 00:31:44
Vale, pues este es 00:31:46
Mi servlet 00:31:52
Entonces aquí 00:31:53
Hay, cuidado 00:31:55
Pero aquí tenemos que tocar cosas 00:31:58
Recordad que a partir de 00:31:59
Java 00:32:01
Es en Navidad, ¿cuál era? 00:32:02
10, 11, 12, no me acuerdo 00:32:05
cuando JavaX pasó a Yakarta 00:32:07
porque de Oracle pasó a Eclipse 00:32:09
toda la parte de desarrollo empresarial 00:32:11
con Java 00:32:13
pues 00:32:14
él te pone el import este 00:32:16
de JavaX Serlet 00:32:19
pero como tenemos una versión de máquina virtual 00:32:20
posterior, pues no es este 00:32:23
el que queremos, entonces quitar todos estos import 00:32:25
para hacer los import buenos 00:32:27
quitamos todos estos 00:32:29
y ahora vamos a importar 00:32:32
de Yacarta, que es la 00:32:34
que ahora ya sí que sí tiene 00:32:36
coherencia con la versión de Java 00:32:38
en la que estamos. 00:32:41
Importamos de Yacarta 00:32:43
y algo más 00:32:45
hay por ahí. Sí, el response 00:32:47
este de aquí, el request 00:32:49
y el response. 00:32:51
Y sigue faltando algo. 00:33:02
Sí, el serlet exception. 00:33:05
Y ahora ya sí que está todo. 00:33:13
Importado de la librería buena. 00:33:14
¿Vale? 00:33:17
Vale, como veis, esta anotación es la que le dice al Tomcat, oye, si te llega la URL punto de despliegue de la aplicación, el que sea punto de despliegue barra ventas, este es el que tiene que, pum, despertarse, este es el que tiene que despertarse. 00:33:17
Cuidado porque esa información sobre quién tiene que despertarse a consecuencia de invocar una URL puede llegar por esta anotación o puede llegar también por el web.xml, por este ficherito que está aquí y nos la ha metido en los dos sitios. 00:33:37
Problemón 00:34:03
Cuando ahora lancemos esta aplicación 00:34:06
Nos va a decir 00:34:08
Tomcat 00:34:10
Que tienes dos serles que se llaman igual 00:34:12
No tienes dos serles que se llaman igual 00:34:15
Es que le clisen medio tonto 00:34:16
Y te ha metido 00:34:18
La declaración del serle 00:34:20
Tanto en el web xml como como una anotación 00:34:22
Te quedas con una o te quedas con la otra 00:34:25
Nunca con las dos 00:34:27
Porque si coexisten las dos 00:34:28
Parece que tienes dos serles que responden a la misma clase 00:34:30
Y eso nunca puede ser 00:34:33
¿Vale? Entonces vamos a quitarla 00:34:34
De aquí, ¿vale? 00:34:37
Para ahorrar tiempo y no eternizarnos 00:34:39
Vamos a hacer caso 00:34:40
Antes de esperar a ver ese error 00:34:42
¿Tienes dos serles con el mismo nombre? 00:34:44
Pues antes de esperar a eso, vamos a quitarlo de aquí 00:34:47
Y ya está 00:34:49
Lo podríamos quitar de anotaciones 00:34:50
Y quitarlo de aquí 00:34:55
Pero hombre 00:34:56
Es más moderna 00:34:57
La configuración por anotaciones 00:34:59
Que por el web.xml 00:35:01
Entonces vamos a quitarlo de aquí 00:35:03
Entonces de aquí, cuidado, no quitéis lo que no es 00:35:05
Solamente esto, esta parte de aquí 00:35:08
La que describe al serles, solo a esta 00:35:10
Entonces ya la aplicación sí que responde 00:35:12
A la clase 00:35:14
Ahora ya la aplicación cuando reciba 00:35:15
La URL de ventas no va a decir 00:35:18
Oye, que tienes dos serles que responden a ventas 00:35:20
Ahora ya solo va a haber uno 00:35:22
El que está anotado 00:35:24
Dime 00:35:25
El pon es el mismo 00:35:27
Que la otra aplicación 00:35:30
El mismo 00:35:31
O sea, en las dependencias 00:35:33
Tiene el driver y tiene estas dos 00:35:35
Que eran para el pool de conexiones 00:35:37
Dime 00:35:39
Vale 00:35:41
Entonces, ahora 00:35:50
El servlet 00:35:52
Se despertará cuando la URL 00:35:55
Sea ventas, pero claro 00:35:59
Nosotros tenemos 00:36:00
Varias acciones que podemos hacer 00:36:02
Insertar una venta, recuperar venta 00:36:04
Por IDE, recuperar todas y borrar 00:36:07
son las cuatro que hemos elegido nosotros 00:36:09
podían ser más, pero son esas cuatro 00:36:11
entonces 00:36:12
pero solo hay un serlet 00:36:14
¿cómo hacemos? entonces aquí habría varias 00:36:16
filosofías de diseño 00:36:19
hacer un serlet por cada 00:36:20
operación, un serlet 00:36:23
insertar, serlet 00:36:25
no sé qué, serlet 00:36:27
borrar, y ponerle 00:36:29
a cada uno una ruta 00:36:31
y que la decisión de que 00:36:32
operación CRUD haces sea por URL 00:36:35
hombre, como poder 00:36:37
pues se puede, pero es muy feo 00:36:38
¿qué es lo más 00:36:41
habitual? en un solo 00:36:42
servlet, hacer 00:36:44
todas las operaciones 00:36:46
insertar, eliminar 00:36:48
¿cómo distingue ese servlet 00:36:50
qué operación quieres hacer? 00:36:52
pues por un parámetro del formulario y punto pelota 00:36:54
¿vale? tu formulario que te lleva 00:36:56
a ventas, tú le puedes pasar parámetros 00:36:58
lógicamente los formularios 00:37:00
llevan parámetros, pues que uno 00:37:03
de esos parámetros sea 00:37:04
la operación que quieres hacer 00:37:06
Si quieres hacer, insertar, eliminar 00:37:08
Entonces ahora el servlet aquí dentro 00:37:10
El servlet aquí dentro 00:37:12
Vamos a borrarle 00:37:15
Lo que tiene el doGet y el doPost 00:37:18
Es que esto queda muy feo todo 00:37:20
Vamos a quitárselo para que quede más claro 00:37:21
Ahora 00:37:23
Cuando el 00:37:29
Tomcat llegue aquí 00:37:31
Porque hemos mandado un formulario con el método get 00:37:34
O cuando llegue aquí 00:37:36
Porque le hemos mandado con post 00:37:38
y llega igual porque 00:37:40
pues lo primero que hará será 00:37:41
meterse al request 00:37:44
que es toda la petición que viene por el url 00:37:45
meterse al request y sacar 00:37:48
el parámetro acción, por ejemplo 00:37:50
y de ese parámetro acción decir 00:37:52
oye, si el parámetro acción 00:37:54
es eliminar, hago eliminar, si es insertar 00:37:56
hago insertar, entonces vamos a hacer 00:37:58
el de consulta, dime 00:38:00
si lo de 00:38:01
acción let sale 00:38:03
en 1, 2 00:38:06
claro, es que los 00:38:07
import que te hace son de JavaX 00:38:10
y eso no los queremos 00:38:11
porque nuestro JDK es posterior 00:38:14
entonces los tienes que borrar y hacer los import 00:38:15
nuevos y ya los import nuevos te va a hacer 00:38:18
los tuyos, los de tu verdadera JDK 00:38:19
los de la actualizada 00:38:22
vale, pues entonces, este serle 00:38:23
tendrá que tener algo parecido a 00:38:25
request 00:38:28
punto 00:38:31
get parameter 00:38:33
a este parámetro como le queremos llamar 00:38:35
pues action, por ejemplo 00:38:38
si este resulta 00:38:39
que es igual a 00:38:42
consultar 00:38:44
o lo que sea, pues 00:38:46
ahora hago todo lo 00:38:50
relacionado con consultar. 00:38:52
El save, no sé qué, hago 00:38:54
todo lo relacionado con no sé cuántos. 00:38:56
Pues entonces, ahora ya 00:38:58
para no ponernos a escribir 00:39:00
como locos, ahora ya sí que 00:39:02
abrid 00:39:04
Bueno, no abréis 00:39:05
todavía, vais a copiar, vale 00:39:10
entonces vamos a hacer primero nuestro formulario 00:39:12
raíz de la aplicación 00:39:14
nuestro index 00:39:16
nuestro index 00:39:17
es el que se verá cuando se arranque 00:39:19
la aplicación, porque así me lo dice 00:39:23
el web xml, el web xml me dice 00:39:25
si tienes un index, arranca ese, vale 00:39:26
y ahora nuestro index 00:39:28
vamos a hacer un formulario 00:39:30
pues que te lleve al formulario 00:39:32
correspondiente de insertar, de eliminar 00:39:34
de no se que, vale, pues ese index 00:39:36
Para no escribirlo a mano 00:39:39
Yo ahí le pedí 00:39:41
Un estilo bonito 00:39:43
Alcha GPT 00:39:44
Y me dio el estilo del formulario 00:39:46
Que os he puesto ahí en la carpeta 00:39:49
¿Vale? Entonces copia del index 00:39:50
El index tal cual 00:39:52
Y llevarlo a donde se mete 00:39:54
El contenido web de una aplicación 00:39:56
Directamente a webapp 00:39:58
Directamente colgando de la carpeta webapp 00:39:59
Colga, mete de ese index 00:40:03
¿Vale? 00:40:05
Vale, entonces yo lo tengo 00:40:10
aquí arriba. Vale, pues 00:40:12
repito, el índex que está en el proyecto 00:40:33
o sea, en el ficherito, en el zip 00:40:36
que os habéis descargado, ese índex 00:40:37
colgarlo aquí de hueva 00:40:39
y vamos a verlo por dentro que tiene 00:40:40
aparte 00:40:43
del estilo, que este sí que es el que me ha dado 00:40:45
ChagPT 00:40:47
a ver si os gusta o no os gusta 00:40:48
pues tiene 00:40:51
las acciones generales del club 00:40:52
¿vale? 00:40:55
Insertar 00:40:59
Pues eso, buscar, actualizar, eliminar 00:40:59
Y listar todos 00:41:02
Listar todos 00:41:04
Entonces, este como veis 00:41:05
Lo he puesto de forma distinta 00:41:08
Porque para listar todas las ventas 00:41:10
No tienes tú que meterle 00:41:13
Ningún parámetro 00:41:15
No tienes que meterle nada 00:41:16
Es listar ventas y ya está 00:41:17
Pues este enlace no hace falta 00:41:19
Que me lleve a ningún formulario 00:41:21
Estos sí, estos me llevan a un formulario 00:41:23
Para que yo meta los datos para insertar 00:41:26
insertar, para que yo meta el ID para 00:41:27
buscar, para que meta los datos 00:41:29
para actualizar y para que meta el ID 00:41:31
para eliminar. O sea, estos enlaces sí que 00:41:33
me ayudan a un formulario, porque hay datos adicionales. 00:41:35
Pero este, que es listar, 00:41:38
no hay datos adicionales. 00:41:40
Tú le das a listar y ya que vaya al 00:41:41
sharelet y se da el find all. 00:41:43
Claro, que te muestre. 00:41:46
Por eso este es un enlace que te 00:41:47
va directamente a la acción listar. 00:41:49
Esta, vamos a 00:41:52
cambiarla. ¿Aquí qué habría que poner? 00:41:53
En lugar de coches. Según lo que acabamos de 00:41:55
hacer ahora mismo, hace un ratito. Muy bien, ventas. Porque he dicho, el servlet se va 00:41:57
a despertar con la ruta ventas. Pues esto lo cambiamos a ventas. Y ahora vamos a hacer 00:42:02
esta acción. Vale, pues cuando el parámetro acción, ¿vale? Sea listar, es decir, cuando 00:42:10
mi parámetro action sea 00:42:20
listar 00:42:22
ahora, habrá que hacer 00:42:23
ahora ya sí 00:42:26
instanciar el service 00:42:27
y hacer las funciones de service 00:42:30
y ya está 00:42:32
¿hace falta parar? 00:42:33
no, ¿verdad? 00:42:43
el index 00:42:46
entonces, ¿no habría que tener una sistema 00:42:47
por cada formulario? 00:42:50
porque como hay... 00:42:52
sí, bueno, claro, pero es que estos cuatro también 00:42:54
sí, sí, sí, bueno, claro 00:42:55
Faltarían estos 4 HTML 00:42:58
Pero estamos yendo por partes, ¿vale? 00:42:59
Vale, entonces 00:43:02
Un momentito 00:43:03
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:
1
Fecha:
9 de diciembre de 2025 - 14:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
196.49 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid