Saltar navegación

20251204 UD2-BDR_6 - 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 6 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, ¿cuándo se pone? 00:00:00
Puedes hablar, Jesús. 00:00:00
Muchas gracias. 00:00:01
¿Cuándo se pone execute, 00:00:02
query y update? 00:00:04
O sea, ¿en qué caso se pone uno? 00:00:06
A ver, tenemos sentencias de CRUD 00:00:07
y sentencias de manipulación 00:00:08
de la base de datos en general. 00:00:10
Las sentencias de CRUD son 00:00:12
las que hacen insert, update, delete o select. 00:00:13
Esas son las de CRUD. 00:00:17
¿Y de DROP? 00:00:18
DROP no, porque esa no es de CRUD. 00:00:20
Esa te borra la base de datos enterita. 00:00:21
DROP database no. 00:00:23
Las de CRUD son 00:00:25
delete, update, insert y select. 00:00:25
Vale. 00:00:28
esas 00:00:28
la de select 00:00:29
es una query 00:00:31
se hace con execute query 00:00:32
y te devuelve 00:00:34
un objeto 00:00:35
result set 00:00:35
que ya manejaremos 00:00:36
cuando hagamos 00:00:36
un execute query 00:00:37
y las otras tres 00:00:38
update, delete 00:00:40
se ejecutan 00:00:41
con execute update 00:00:43
las tres 00:00:44
esas no te devuelven 00:00:45
datos 00:00:46
te devuelven información 00:00:47
que tú puedes recoger 00:00:48
si quieres o no 00:00:49
pues filas que he actualizado 00:00:49
cosas 00:00:51
tú la puedes recoger 00:00:52
o no 00:00:53
¿vale? 00:00:53
no es como la execute query 00:00:54
que te tienes que quedar 00:00:55
con el select 00:00:56
¿vale? 00:00:56
Y luego hay sentencias que no son de cruz 00:00:57
Pues de alterar un esquema, poner una clave 00:01:00
Hacer cualquier cosa que haces con SQL 00:01:02
Pues esas con el execute a palo seco 00:01:04
Y ya está 00:01:07
Ese es el principio básico general 00:01:07
Que luego en cada clase de estas de JBC 00:01:09
Luego tiene un montón de mamonaditas 00:01:12
Pero bueno, esto es luego 00:01:14
¿Vale? 00:01:15
Entonces, bueno, pues 00:01:17
Habíamos dicho que esto de aquí 00:01:21
Es que es verdad que con tantas clases 00:01:23
Esto es un desmadre 00:01:25
que esto de aquí es feo 00:01:27
muy feo 00:01:32
por el INGE, por la inyección de SQL 00:01:33
pero eso lo arreglamos en la siguiente 00:01:36
práctica que hagamos 00:01:38
lo arreglamos con una sentencia precompilada 00:01:39
y ya está, ¿vale? 00:01:42
y excelente 00:01:44
un prepare statement 00:01:44
¿no lo pusisteis en el trabajito del año pasado? 00:01:48
sí, sí, pero es hacer lo mismo 00:01:50
claro, es hacer lo mismo 00:01:52
pero al precompilar el SQL 00:01:53
ya no 00:01:56
lo dejas ya 00:01:57
en un formato 00:01:58
diferente al string 00:01:59
con lo cual 00:02:00
ya no puedes 00:02:00
hacer la inyección 00:02:01
¿ya no lo ves? 00:02:01
¿ya no lo ves? 00:02:03
pero cuando 00:02:04
lo vas a un 00:02:05
¿te acuerdas 00:02:06
si es que 00:02:06
lo comprobamos 00:02:07
tú y yo 00:02:07
que lo pasas 00:02:08
a que te descompila 00:02:09
lo sacas 00:02:10
pero a ver 00:02:11
sí pero tienes que 00:02:14
tener el código 00:02:15
de la aplicación 00:02:16
o sea estamos hablando 00:02:16
que yo tengo 00:02:17
mi vista 00:02:18
con mi aplicación 00:02:18
y lo paso 00:02:19
en un formulario 00:02:20
el string 00:02:21
claro 00:02:21
hombre tú tienes 00:02:22
el código 00:02:23
de la aplicación 00:02:23
lo haces donde 00:02:24
compila 00:02:24
y ahí tienes todo 00:02:25
claro 00:02:25
Hombre, claro 00:02:26
Si sacas el properties, imagínate 00:02:29
Vale, pues esto ya lo 00:02:31
Quitaremos para que sea más bonito 00:02:33
Con el prepare statement, también haremos 00:02:35
Select, pues para iterar por 00:02:37
ResultSet, eso en un plis-plas el próximo 00:02:39
Día, y que plis-plas 00:02:41
Nos queda ahora antes de irnos 00:02:43
Pues hombre, vamos a 00:02:45
Meterle un pool de conexiones 00:02:47
Por si acaso 00:02:50
Esta aplicación se hace multilo, no me gusta 00:02:51
Usar solo una conexión, que abro 00:02:54
aquí y ya está, vamos a meterle 00:02:55
un pool de conexiones 00:02:57
lo podemos meter aquí en este mismo singleton 00:02:59
para que nos funcione 00:03:02
como singleton de la conexión 00:03:03
y singleton del pool 00:03:05
voy a hacerme aquí un pool de conexiones 00:03:07
este va a ser 00:03:10
mi pool que yo devolveré 00:03:18
con un get pool, ¿verdad? 00:03:20
obviamente 00:03:23
hombre 00:03:24
por dios 00:03:25
public static 00:03:27
sí, que listilla eres 00:03:36
A ver, que lo he puesto aquí 00:03:38
porque todavía no hemos dicho el tipo 00:03:45
Claro, entonces 00:03:47
¿Qué tipo de datos es el tipo 00:03:48
pool de conexiones? 00:03:51
Uno diría pool 00:03:53
o diría connection pool 00:03:55
o diría no sé qué 00:03:57
Pues es data source 00:03:58
Creo 00:03:59
porque ya me tenéis la memoria frita 00:04:05
Data source 00:04:08
¿De qué? De Java SQL 00:04:11
Vale, es este 00:04:13
Ahora es donde me toca a mí 00:04:16
Instanciar aquí el data source 00:04:19
Este 00:04:21
Vale 00:04:22
En mi data source este 00:04:36
Lo tengo que instanciar, ahora ya sí 00:04:38
Si mi 00:04:40
pool es 00:04:42
igual a null 00:04:44
lo instancio 00:04:46
vale, ¿cómo instancio un pool 00:04:48
de conexiones? pues esto de nuevo 00:04:50
es una interfaz, es una clase abstracta 00:04:53
o es algo vacío 00:04:55
tenemos que darle una implementación 00:04:56
hay muchas implementaciones para pool de conexiones 00:04:58
hay un montón 00:05:01
¿cuál vamos a coger? 00:05:02
pues yo que sé 00:05:05
la que más se usa en principio 00:05:06
sería 00:05:09
esta que tengo yo aquí abierta 00:05:10
en otro proyecto 00:05:13
pero vamos a preguntarle ya que estáis tan 00:05:14
¿qué? 00:05:17
además con tildes y mayúsculas para no gastar agua 00:05:21
¿qué 00:05:23
implementación 00:05:24
pool 00:05:29
pool de conexiones 00:05:30
para data source 00:05:34
es la más 00:05:37
más usada, qué mal 00:05:39
lo he escrito, sería cuál implementación 00:05:41
no, bueno, da igual, es la más usada 00:05:43
actualmente, aunque yo no sé 00:05:45
qué significa actualmente para echar GPT 00:05:47
¿sabéis cada cuánto actualizan su base de datos? 00:05:48
o es todo el rato 00:05:51
si yo pongo eso 00:05:54
actualmente quiero decir, ¿significa 00:05:55
algo en mi conversación con una IA o no significa 00:05:59
nada? 00:06:01
claro 00:06:05
vale 00:06:05
más vale que me diga de la que tengo la chuleta 00:06:08
Fijaos que estamos en un nivel 00:06:14
Pro de backend 00:06:18
Toma ya 00:06:19
Ikari, que suerte hemos tenido 00:06:21
Vale 00:06:23
Ikari 00:06:24
Como bien dice él, no yo 00:06:27
Es el estándar 00:06:29
De facto para pool de conexiones 00:06:31
Para todos estos, estos lo usan 00:06:34
¿Vale? 00:06:38
Y si lo usan todos estos, que estas serían capas 00:06:38
Que van por encima de 00:06:41
JDBC, todo esto va montado 00:06:43
por encima de lo que hemos visto ahora 00:06:46
por encima de JDBC 00:06:47
pues si lo usan esto, vamos a usarlo nosotros 00:06:49
de hecho 00:06:51
es que es un print por defecto 00:06:54
ya te, como me está diciendo aquí 00:06:56
ya te crea este pool en instancia 00:06:58
nosotros como no estamos usando ninguna capita de abstracción 00:06:59
directamente todo a mano 00:07:02
vamos a tener que hacer nuestro propio 00:07:04
pool nosotros 00:07:06
porque estamos poniendo 00:07:06
las capas una tras otra 00:07:09
Vamos a ir poniéndole capas de abstracción 00:07:11
Claro, pero es que así funcionan las cosas 00:07:23
Sí, pero aquí si me apuras 00:07:24
Es que tú, JDBC, lo tienes que conocer 00:07:26
No puedes irte de aquí 00:07:28
Sé hacer un acceso a datos con Spring 00:07:30
Pues te vas de aquí 00:07:33
Pues yo qué sé 00:07:35
Siendo una adolescente de Java 00:07:38
¿Vale? No puede ser 00:07:41
JDBC, hay que conocerlo 00:07:43
Es lo básico 00:07:45
¿Vale? 00:07:46
Y os lo vais a encontrar 00:07:49
En muchos, todavía en sitios 00:07:50
¿Eh? 00:07:53
Seguramente podéis ir a hacer prácticas 00:07:55
A algún sitio que hasta el año pasado 00:07:57
Ha ocurrido 00:07:59
Y parte del código pues 00:08:00
Está hecho con JDBC 00:08:02
Vale, pues a ver, vamos a usar Ikari 00:08:04
¿Cómo se implementa 00:08:10
Un pool de conexiones con Ikari? 00:08:11
Pues ahora ya sí que sí, esto lo voy a copiar 00:08:14
Porque si no me vuelvo loca 00:08:16
¿Vale? 00:08:18
Esto 00:08:23
Sí, sí, sí, sí 00:08:23
Os doy tiempo 00:08:25
A ver 00:08:27
Un momentito, que esta declaración la saco fuera 00:08:29
¿Eh? 00:08:34
Sí, sí, sí 00:08:38
Hay que poner la dependencia, un momentito 00:08:39
perdón, que es que 00:08:42
estoy volviendo tonta 00:08:51
entonces 00:08:53
esto sería pool 00:08:54
vale, ahora ponemos la dependencia 00:08:57
entonces, esta es 00:09:05
una posible 00:09:09
implementación de data source 00:09:11
una posible implementación, es esta 00:09:13
que voy a guardar en pool 00:09:15
una posible implementación 00:09:16
y la configuro con esto de aquí 00:09:18
Entonces este es un pool de conexiones 00:09:21
Para la base de datos que yo le diga aquí 00:09:24
Que en mi caso va a ser 00:09:26
Coches 00:09:28
Este es un pool de conexiones 00:09:29
Y ahora ya este método me devolvería 00:09:32
Pool 00:09:35
Nos devolvería pool 00:09:36
Vale, pero obviamente nos falta 00:09:40
La dependencia 00:09:42
Porque Icari no viene 00:09:44
Es una implementación más 00:09:46
Y no viene con JDK como era de 00:09:47
Esperar 00:09:49
Entonces 00:09:50
Si vosotros buscáis 00:09:52
En el repositorio de Maven 00:09:55
Espera, se lo voy a pedir a HGPT 00:09:57
Porque en el repositorio de Maven 00:10:02
Tienes que hacer unas 00:10:04
Búsquedas enlazadas 00:10:06
Y es un rollo 00:10:08
Entonces, como vosotros en la realidad 00:10:09
Se lo diríais a él, ¿verdad? 00:10:11
En lugar de buscar el repositorio de Maven 00:10:13
¿A que sí? 00:10:14
Dame 00:10:19
El POM 00:10:19
Para usar Icari 00:10:21
Vosotros no le dais tantos detalles, ¿verdad? 00:10:23
Pondríais POM 00:10:26
Y ya está, y no le diríais más 00:10:27
Joder, es que cómo sois 00:10:29
Y luego, ¿entre vosotros os entendéis cuando habláis los unos con los otros? 00:10:31
A ver, o sea, pondríais POM 00:10:36
Y ya está 00:10:38
El conector lo tenemos 00:10:39
A ver, juraría que 00:10:53
Sí, sí, sí, pero es que 00:10:54
Creo que con esto va a faltar una 00:10:56
Paso obligado 00:11:00
Creo que 00:11:01
A ver, vamos a poner esta sola 00:11:02
Pero creo que le va a faltar una 00:11:05
Sí, pero esta es la del conector que ya la tenemos 00:11:06
Venga 00:11:09
Vamos a poner esta 00:11:11
O sea, con esta va a compilar 00:11:12
Pero no sé si va a ejecutar bien 00:11:14
Porque le va a faltar el log 00:11:17
Le falta una librería de logs 00:11:18
Porque esta usa una librería de logs 00:11:21
Que no trae dentro 00:11:23
¿Te la ha dado cuando lo has buscado en el repositorio? 00:11:24
No, le he dicho 00:11:28
Algo de log te tiene que haber dado 00:11:29
Porque si no este se queda corto 00:11:35
Vale, entonces 00:11:37
Yo aquí 00:11:40
En el pom 00:11:42
Le pongo esto 00:11:45
Y ya 00:11:52
Sí, la dependencia 00:11:54
Está 00:11:59
Es que lo he cerrado 00:12:00
Espera, me hace una cosa 00:12:11
Que termine todo el mundo de copiar esto 00:12:13
Y luego ya salga la falta de dependencia y que lo ponga 00:12:15
¿Todo el mundo ha copiado esto? 00:12:16
Bueno, a ver, perdonadme 00:12:20
Cuando copia y pega 00:12:27
Esto tendría que salir del properties, lógicamente 00:12:28
¿Vale? 00:12:31
Esto tendría que salir del properties 00:12:33
Porque aquí arriba, ¿veis? 00:12:35
Aquí arriba 00:12:39
Es decir, tendría que hacer esto mismo 00:12:40
Que he hecho aquí 00:12:45
Esto que salga del properties 00:12:45
Por Dios, si no, no hemos hecho nada 00:12:51
Y aquí 00:12:54
Claro 00:12:55
Aquí sería 00:12:56
Prop.getProperty 00:12:58
Sí, podríamos sacar el property pero 00:13:01
No vamos a hacer otra clase 00:13:03
Nada más para sacar el property 00:13:06
O sacarlo a un método 00:13:07
Yo lo decía sacarlo a un método 00:13:10
Sí, claro 00:13:12
Sacarlo a un método dentro de esta clase 00:13:13
Pues sí, pero bueno 00:13:15
Ya hemos arrancado así 00:13:17
Prop.getProperty 00:13:18
Property 00:13:21
Sí, una clase 00:13:23
Claro, una clase que además 00:13:30
Sea un singleton del properties 00:13:32
Que haya solo un properties del que tiren todos 00:13:34
Eso sería lo ideal 00:13:36
¿Vale? 00:13:38
Eso sería lo ideal 00:13:41
Pero no vamos a meter otro singleton para el properties 00:13:42
Porque 00:13:44
Os enfadáis porque sois unos flojos 00:13:45
Y me sobra un paréntesis 00:13:49
Ah, es verdad 00:13:58
Que el pobre no ve hoy 00:14:00
Mala clase para copiar, efectivamente 00:14:02
Espera, espera 00:14:05
Justo cuando ha terminado, lo he puesto grande 00:14:09
A ver, el prop es lo mismo de arriba 00:14:16
Claro, copia y pegado 00:14:29
Que hombre, me ha quedado feo el fichero 00:14:32
Debería sacar el properties 00:14:34
Fuera, para no, porque es un copia y pega 00:14:35
Pero bueno, vamos a dejar de poner 00:14:38
Lo que le decía él, que lo ideal sería 00:14:40
Hacer otro singleton para el properties 00:14:41
Para que el properties 00:14:43
solo tenga una instancia en todo él 00:14:45
¿vale? entonces como veis aquí 00:14:48
hay una serie de gestiones 00:14:49
gestiones de los 00:14:51
bins, de las propias clases, pues el properties 00:14:53
la conexión, el no sé qué 00:14:55
perdón 00:14:57
gestión de los trycatch 00:14:58
hay un montón de gestiones que las capas 00:15:05
adicionales son las que te lo van haciendo 00:15:07
pero lo que te van haciendo ellos es lo que hay 00:15:09
aquí debajo, es que no hay otra 00:15:11
Ah, es que ahora lo explicamos 00:15:13
Ahora lo explicamos, ¿vale? 00:15:19
Ahora lo tenía puesto ahí para que no se me olvidara 00:15:21
Vale, estos tres primeros parámetros 00:15:22
Del pool están claros 00:15:25
Son los tres parámetros 00:15:26
Que necesitamos 00:15:29
Entonces el pool se va a enganchar a esa base de datos 00:15:30
Y aquí, pues estos son 00:15:33
Parámetros que se pueden configurar 00:15:35
Hay más parámetros que se pueden configurar 00:15:36
Si no los configuramos, coge unos por defecto 00:15:38
Creo 00:15:41
o eso me ha parecido comprobado alguna vez 00:15:41
pero bueno, está claro lo que significa 00:15:44
pues 00:15:46
el tamaño máximo 00:15:47
¿vale? de conexiones 00:15:50
que puede mantener el pool 00:15:52
¿vale? 00:15:54
entonces, hombre, ¿hacéis multi-hilo 00:15:56
de más de 10 hilos? 00:15:58
no, ¿verdad? 00:16:01
o sea, yo creo que un programa de más de 10 hilos 00:16:02
¿no es mucho hilo eso? 00:16:04
no, no es mucho hilo, ¿no? bueno, sí, claro 00:16:06
depende de lo que estés gestionando 00:16:08
Bueno, pues el tamaño máximo de conexiones 00:16:09
El pool 00:16:16
Se reserva siempre 00:16:18
Unas cuantas vacías sin usar 00:16:20
Pues para ir rápido 00:16:22
¿Significa que pone más de 10? 00:16:24
¿O que tú le pones 10? 00:16:26
No, no, no, eso me refiero a este parámetro 00:16:27
Entonces él se las va apañando 00:16:29
Para tener siempre dos disponibles 00:16:31
Por si te llega un hilo, punto, y estas dos 00:16:32
Y ahora me cree otra y me la mantengo ahí disponible 00:16:34
Pero el pool es para abanacar los datos 00:16:36
para abrir varias conexiones simultáneas 00:16:37
Pool es una clase que está ahí preocupándose 00:16:40
de tener unas cuantas conexiones 00:16:42
ahí creadas, irlas entregando 00:16:44
a quien le pide, irlas cerrando 00:16:46
cuando haga falta, etc. 00:16:48
Esto es el tiempo máximo que va a estar 00:16:49
esperando el pool a hacer una conexión 00:16:52
Si pasan 30 segundos 00:16:53
y una conexión no la ha respondido, te da 00:16:55
otra del pool, te da otra y ya está 00:16:58
Si no tenemos un pool, tenemos que 00:16:59
gestionar el time aún nosotros 00:17:01
y si no me llega, pues me va a salir un exception 00:17:03
a menos que capture la exception 00:17:05
exception time out 00:17:07
no sé qué, la capturo y la hago otra vez 00:17:09
sería un rollo, pues él te 00:17:11
gestiona eso, te da otra 00:17:13
y se acabó, pero bueno 00:17:15
un pool, usaríamos un 00:17:17
pool en una aplicación 00:17:19
monohilo, bueno 00:17:21
porque metemos aquí a este tío 00:17:23
que está ahí metiendo o dando 00:17:25
guerra, vale 00:17:27
entonces, ahora 00:17:29
si nosotros 00:17:31
queremos aquí 00:17:32
Ah, es verdad, la dependencia 00:17:34
La dependencia de Ikari 00:17:39
Esta, si la buscas tú 00:17:41
En el repositorio de Maven 00:17:43
Te va a salir algo como esto 00:17:45
La puedes buscar 00:17:47
Y te sale esto 00:17:49
Te sale esto u otra versión, pero vamos 00:17:50
Te saldrá algo como esto 00:17:56
Vamos a probar 00:17:57
Bueno, a ver, se lo he preguntado a HGPT 00:17:59
Pero si lo buscáramos en el repositorio 00:18:04
Bueno, vamos a pedirlo 00:18:06
Sí, vamos a buscar el repositorio 00:18:08
Que siempre es 00:18:10
Joder, que no he puesto el repositorio 00:18:11
Aquí está 00:18:13
Vale, si ponemos aquí 00:18:14
Icari 00:18:16
Pues 00:18:20
Me sale 00:18:21
Esta cosa 00:18:24
Y esta cosa 00:18:25
Que esta sí que es la última versión 00:18:28
Pues venga, 702 00:18:32
Cogemos 00:18:35
Porque la que me había dado chat GPT 00:18:36
era 510 00:18:39
venga, pues vamos a dejarle esta 00:18:40
yo que sé 00:18:45
por probar 00:18:46
si es que esto funciona o no funciona 00:18:48
pues yo que sé, ya veremos 00:18:50
como Christian se ha dormido, pues se lo perderá 00:18:51
vale, pues entonces 00:18:54
vamos ahora a nuestra implementación 00:18:58
esta de aquí 00:19:01
claro, ahora ya 00:19:02
este 00:19:07
venta dao implementación 00:19:13
cuando lo 00:19:15
insertamos desde el 00:19:17
venta service 00:19:19
desde el 00:19:20
venta dao 00:19:25
y ahora 00:19:26
venta dao 00:19:30
ya me he perdido 00:19:31
¿dónde estamos? 00:19:35
sí, sí, me he perdido, me he encontrado yo 00:19:37
que tenemos un día 00:19:39
hoy espeso, a ver 00:19:42
vale 00:19:44
aquí era donde 00:19:46
hemos cogido la 00:19:47
conexión 00:19:50
vale, cuando hemos hecho el venta de implementación 00:19:51
hemos cogido 00:19:54
pues podemos ahora en lugar 00:19:55
de pasarle, esta era la versión 00:19:58
cuando le pasábamos una única 00:20:00
conexión del principio sin pool 00:20:02
y sin nada, vale 00:20:04
que le quiero yo decir, oye no 00:20:06
Esta aplicación es multi-hilo, este main 00:20:07
Esto en lugar de un main será un hilo 00:20:09
Que esté por ahí de algún lado 00:20:12
Pues quiero, cógete una conexión de la piscina 00:20:13
No te cojas la única 00:20:16
Y madre 00:20:18
Pues entonces 00:20:18
Esto no, lo cargamos no 00:20:20
Vale, pues 00:20:24
Aquí 00:20:31
Haríamos, oye hazme un ventadao 00:20:32
Pero la conexión 00:20:44
Que me tienes que crear, que sea 00:20:46
Conexión.getpool 00:20:47
Y la piscina esta tendrá algún método 00:20:49
Para regalarte una 00:20:52
GetPool 00:20:53
Me da el data source y este me da 00:20:56
La conexión 00:20:58
Me da una conexión 00:20:59
Para esa piscinilla 00:21:02
Vale 00:21:03
GetConnection 00:21:05
Es como antes 00:21:08
O sea, esto me da el pool 00:21:08
Y esta ya me da una de esas 00:21:14
Una de las que haya 00:21:15
Me da una de las que haya 00:21:16
Y ya está 00:21:20
Que efectivamente tengo que capturarlo 00:21:20
Pero no pasa nada 00:21:25
Lo capturo y se acabó 00:21:34
Vale, ya está 00:21:36
A ver si funciona 00:21:43
Hemos cambiado en lugar de una única conexión 00:21:44
A una conexión del pool 00:21:47
¿Va a seguir insertando 00:21:48
Un bicho de estos? 00:21:51
Pues no sé 00:21:52
Debería si hemos configurado bien el pool 00:21:53
Y la dependencia es buena y todo eso 00:21:57
Que no lo sé 00:21:58
no lo sé, yo creo que no, creo que nos faltan 00:21:59
cosas, creo que nos faltan 00:22:02
cosas, entonces lo bonito es 00:22:04
averiguarlo, vale 00:22:06
esto es lo que yo me esperaba 00:22:08
esa dependencia de Icari 00:22:09
usa logs 00:22:13
y no tiene logger 00:22:16
no tiene logger, pues hay que ponerle 00:22:18
una dependencia de log 00:22:20
entonces 00:22:22
¿cuál es una que yo he verificado que 00:22:23
funciona? pues la tengo 00:22:26
Por aquí arriba 00:22:28
Esta 00:22:30
La copio y la copiáis 00:22:34
Es una herramienta de log 00:22:38
Para que funcione bien con el zucker 00:22:40
Este o como se llame 00:22:42
Y ya eso es lo último que vais a copiar hoy 00:22:43
Ahora 00:22:47
Si salen errores ya no los espero 00:23:00
Pues mal rollo 00:23:03
Porque nos tenemos que ir 00:23:06
Vamos a ver 00:23:08
Sí, pero ya me estáis dando miedo 00:23:09
Porque me estáis diciendo que no funciona 00:23:15
Así que vamos a ver 00:23:16
Ya, pero es que me habéis dado mucha inquietud 00:23:19
Oye, me ha funcionado perfectamente 00:23:23
Este es el log que le faltaba 00:23:25
Pongo otra vez el 00:23:28
¿Tú le has puesto el root 1, 2, 3, 4? 00:23:29
¿Cuándo lo has configurado? 00:23:41
Sí funciona, ¿verdad? 00:23:50
Y lo ha insertado aquí 00:23:52
Ahí tengo todo 00:23:55
Pues 00:23:57
Qué bien y qué chulo 00:24:05
¿No le estarás dando el usuario y la contraseña correctas? 00:24:10
Si nos vamos a este 00:24:23
Esto ya está copiado, ¿no? 00:24:25
Si nos vamos a este DAO 00:24:27
el insert venta 00:24:29
que bien, que estupendo 00:24:31
pero y el 00:24:33
find by id 00:24:35
pues hombre vamos a hacer por lo menos 00:24:36
el find by id este de aquí 00:24:39
y luego 00:24:41
ya os quedáis 00:24:45
haciendo vosotros para el próximo día 00:24:46
el find all y el delete 00:24:48
porque el delete sería una sentencia con 00:24:50
sqt udat y este sería también 00:24:52
una select, pero otro tipo de select 00:24:54
vamos a hacer el find by id este 00:24:56
Pues es que es copiar y pegar todo 00:24:58
Pero cambiar la sentencia 00:25:02
Y luego aquí recoger el resultado 00:25:03
Vamos a copiar y pegar todo esto 00:25:05
Pues 00:25:07
El resto, los dos métodos del DAO 00:25:11
Que se quedan sin hacer 00:25:14
El find all y el delete event 00:25:15
Este es interesante 00:25:18
Porque aquí tenéis que reconstruir 00:25:19
Toda la lista de objetos 00:25:21
Bueno, ya el de arriba va a ser interesante 00:25:23
A ver, callaos un rato 00:25:26
Vamos a hacer el 00:25:27
Vamos a hacer este 00:25:29
Y cuando hagamos este ya entenderéis lo que tenéis que hacer vosotros 00:25:31
¿Verdad que sí? 00:25:34
Vale, pues entonces hemos dicho 00:25:36
Find by id 00:25:37
Vamos a copiar y pegar el de arriba 00:25:39
Y cambiamos la sentencia 00:25:40
Tirando 00:25:42
Vale, pues find by id 00:25:44
Ahora, nuestra sentencia ahora no va a ser 00:25:47
Insering to ventas, bla bla bla 00:25:50
Nuestra sentencia 00:25:52
Ahora va a ser todo fuera 00:25:54
Y ahora va a ser 00:25:56
Select 00:25:58
asterisco 00:26:00
¿por qué asterisco? 00:26:02
porque quiero todos los campos 00:26:05
porque voy a construir luego un objeto venta 00:26:06
seled asterisco 00:26:08
from 00:26:10
ventas 00:26:11
where 00:26:13
igual a 00:26:22
y aquí ya sí que me toca romper la cosa 00:26:23
esta y concatenarlo 00:26:26
con 00:26:28
id es un número 00:26:31
afortunadamente, así que no tengo que poner las comillas 00:26:33
simples 00:26:36
aquí, de nuevo, esto 00:26:36
lo cambiamos el próximo día 00:26:40
para hacerlo con una sentencia precompilada 00:26:42
y que nos haga inyección, pero bueno, eso es un detallito 00:26:44
vale, ya tenemos el SELECT 00:26:46
ahora, el SELECT 00:26:48
se ejecutaría con 00:26:50
execute query 00:26:51
exacto, SQL 00:26:53
pero claro, este me devuelve 00:27:02
toda una lista de registros, bueno, uno en este 00:27:04
caso, pero bueno, registros 00:27:06
En este caso uno porque hay de esclave primaria 00:27:08
Pero él me lo mete en una caja de registros 00:27:10
La caja de registros 00:27:12
¿Cómo se llamaba? 00:27:15
La caja de registros 00:27:16
Se llama result set 00:27:18
Esta es la caja de registros 00:27:21
Result set 00:27:30
De javasql 00:27:31
Y ahora 00:27:34
Tendré que sacar los tres apartaditos 00:27:35
De esa caja 00:27:38
Para construir con ellos el objeto venta 00:27:39
Que voy a devolver 00:27:42
Ahora, ahora, ahora 00:27:43
Lo vemos 00:27:47
Ese es el objeto venta que vamos a devolver 00:27:48
¿Vale? 00:27:50
Retun V 00:27:52
Ese es el objeto venta a devolver 00:27:52
Y ahora vamos a construirlo 00:27:55
Vamos a recorrer el ResultSet 00:27:57
A ver, lo voy a hacer a toda leche 00:27:59
Porque nos vamos a ir 00:28:01
En 5 minutos 00:28:03
Pero no os preocupéis que vamos a volver sobre ello 00:28:04
Mientras 00:28:08
esta es mi caja de registros 00:28:10
de todas formas, si hicisteis el trabajo el año pasado 00:28:15
todo esto será familiar 00:28:17
ah, que se llama registros 00:28:18
perdón, vale 00:28:21
mi caja de registros 00:28:24
tiene un posicionador 00:28:26
que empieza posicionado antes del 00:28:28
primero, cada vez que hago 00:28:31
un next, avanza 00:28:33
pues un bucle y además devuelvo boolean 00:28:34
para decir si hay o no hay 00:28:37
entonces, pues yo voy avanzando 00:28:38
este well se va a hacer una vez solo 00:28:41
porque si la clave es id y es primaria 00:28:42
se va a hacer una vez o ninguna 00:28:44
porque podría ya dar yo una id que no está 00:28:46
y ahora, ¿cómo saco los datos? 00:28:48
pues venga, el id 00:28:51
que es ínteger 00:28:52
bueno, ni siquiera hace falta, directamente os voy a poner en v 00:28:53
v.set 00:28:56
¿cómo saco el id? 00:28:59
pues de registros 00:29:02
que ahora estoy posicionada en mi cajita 00:29:03
en la primera 00:29:06
registros.get 00:29:07
Int, porque es el campo entero 00:29:09
Nombre del campo 00:29:12
Que se llama id, ¿verdad? 00:29:13
Ahora, siguiente 00:29:16
V.set 00:29:18
Set coche, perdón 00:29:19
De registros 00:29:21
Sácame un 00:29:24
String que sea 00:29:26
Coche 00:29:28
Se llama coche, ¿verdad? 00:29:29
En mi, el campo 00:29:32
Claro, que lo... 00:29:33
Color 00:29:37
Pues sácame 00:29:38
el campito color 00:29:41
lo hicisteis todos 00:29:44
y ahora 00:29:53
¿puedo confesaros algo? 00:29:54
no miramos casi 00:29:58
lo siento, no teníamos tiempo 00:29:59
era un agobio el copón 00:30:03
pero al menos aprendisteis haciéndolo 00:30:04
¿a que sí? 00:30:07
sí, los que miren clase 00:30:07
que algunos miren clase 00:30:09
pero los que me llevé para 00:30:10
los que estaban a la virtual 00:30:11
¿y por qué te lo marcan amarillo? 00:30:12
Porque está sin usar todavía 00:30:16
Registros 00:30:18
Ah, no lo sé 00:30:21
Registros.getString 00:30:22
Nif, barra baja 00:30:25
Comprador, ¿verdad? 00:30:27
Pues ya tenemos 00:30:33
Entonces 00:30:34
Si hubiera más while 00:30:36
O sea, si hubiera más registros 00:30:39
Estaría pisando todo el rato el mismo 00:30:40
Pero no es el caso 00:30:42
Porque de haber ahí solo uno 00:30:43
Y si no hay ninguno, la caja ResultSet está vacía 00:30:44
Con lo cual no entro en el while 00:30:48
y me va a devolver null, que tiene sentido 00:30:49
que me devuelva null si no hay 00:30:51
entonces, ahora 00:30:52
null pointer access 00:30:55
ah, claro, porque no he hecho el new 00:30:58
venta, por Dios 00:30:59
bueno, es que el new venta no lo voy a hacer aquí, porque quiero que me 00:31:01
devuelva null si no hay campos 00:31:05
entonces el new venta lo hago aquí 00:31:07
venta 00:31:09
v igual a new 00:31:11
venta 00:31:13
sí, perdón 00:31:14
es v directamente, claro 00:31:17
v igual a 90, lo fijo 00:31:19
devuelvo v y ya tengo 00:31:21
el find by id 00:31:23
a ver, es un rollo 00:31:24
porque he tenido que hacer a mano 00:31:27
el famoso 00:31:29
mapeo objeto relacional 00:31:31
que es 00:31:34
yo tengo campos de tablas 00:31:35
y he tenido que convertirlos 00:31:37
a propiedades de objetos 00:31:39
lo he tenido que hacer a mano, que pereza 00:31:41
pero como somos tan vagos 00:31:43
pues claro, al final siempre hay una 00:31:45
capa que te lo hace. Ese mapeo. 00:31:47
Vamos a ejecutarlo 00:31:52
y si funciona nos vamos ya con mucha satisfacción. 00:31:53
Debería. 00:31:58
Si no funciona, no sé por qué será. 00:31:59
Venga, ventas service. Pues vámonos 00:32:01
aquí. Este dame datos que no vale para nada, lo vamos a 00:32:03
quitar. 00:32:05
Y vamos a dejar de insertar ventas, porque 00:32:07
es que estamos aquí insertando una venta tras otra 00:32:09
todo el rato. Me hago mi ventas 00:32:11
service y ahora voy a mostrar 00:32:13
service.find 00:32:16
Ah, bueno, que es que no me he hecho el servicio 00:32:22
Tranquilos, no os pongáis nerviosos 00:32:25
Nos falta el servicio 00:32:27
Que el servicio sería 00:32:29
public venta 00:32:30
get venta 00:32:33
por ejemplo 00:32:36
get venta integer id 00:32:37
Y ahora, este que me devolvería 00:32:39
este me devolvería 00:32:44
dao.findbyid 00:32:45
ala 00:32:49
ya tengo el servicio hecho 00:32:52
que tira del dao 00:32:55
ahora me voy a mi 00:32:57
main que estaba aquí 00:32:59
y ahora service.get 00:33:00
venta 00:33:03
vamos a el 1 00:33:04
venta 00:33:06
voy a hacerle un siso rápido a 00:33:09
venta para que 00:33:11
me muestre algo interesante 00:33:12
venta, le hacemos 00:33:14
un to stream, perdón 00:33:17
si es un to stream rápido 00:33:18
un to stream rápido 00:33:21
y ahora ya si 00:33:26
vamos a ver si 00:33:28
el servicio me saca la venta 00:33:29
con uno 00:33:32
si no lo hace, pues nos viene fatal 00:33:32
bien, magnífico 00:33:36
vale, aquí nos ha sacado 00:33:42
toda la venta 00:33:43
vale, pues aquí 00:33:44
aunque no os guste y os resistís 00:33:50
la clase principal 00:33:52
que puede ser el 00:33:56
serlet, puede ser lo que sea, aquí como es una 00:33:58
aplicación de escritorio es el main 00:34:00
pues se queda muy limpio, crea un servicio 00:34:01
y el servicio me dice 00:34:04
estos son los servicios que te doy 00:34:06
te doy el servicio de crear un usuario 00:34:07
te doy el servicio de no sé qué, tú los llamas y ya está 00:34:10
y luego ya las complejidades se van metiendo 00:34:11
pues 00:34:14
en sus capitas 00:34:15
pero tú desde tu 00:34:17
desde 00:34:19
tu parte de llamada al servicio 00:34:20
Sí, claro 00:34:26
Entonces, ¿qué sería lo bonito 00:34:31
que hicierais ahora vosotros? 00:34:33
De aquí al martes 00:34:36
No solo 00:34:37
Yo lo pido y yo que sé 00:34:38
Los dos métodos del service que quedan 00:34:41
No, del service no, bueno, del DAO y del service, claro 00:34:45
El find all 00:34:47
tendréis que devolver, este es un select 00:34:49
asterisco, punto pelota 00:34:51
y construir toda la lista 00:34:53
y el borrar 00:34:55
hacer el servicio correspondiente 00:34:57
y probarlo, claro, pero 00:35:00
¿has venido a 00:35:02
procesos 00:35:03
videojuegos? 00:35:05
pues Estefano ha venido 00:35:07
¿has venido por un tiempo 00:35:09
con una charla LGTBIQ? 00:35:11
si, además te viene muy bien 00:35:13
mira, alguien que responde 00:35:15
así le viene mucho mejor que a nadie 00:35:18
la charla LGTBIQ 00:35:19
hombre, machista, machirulo 00:35:21
por favor 00:35:24
vale, y no solo eso 00:35:25
me queda bravo 00:35:29
ostras 00:35:30
bueno, no me denuncies 00:35:31
vale 00:35:38
y que sería ya 00:35:42
como seguro que este fin de semana 00:35:45
como no tenéis exámenes 00:35:47
pues yo que sé, ¿os apetece poneros con esto en plan relax? 00:35:48
si hombre 00:35:52
Pues que probéis estos servicios 00:35:53
Que vais a hacer estos dos 00:35:55
En una aplicación web con un servlet 00:35:56
Un formulario 00:35:59
Que pedís los datos 00:36:01
Los dais con un formulario 00:36:03
¿Y quién se va a conectar a la base de datos? 00:36:05
¿Quién va a llamar al servicio? 00:36:08
Al servicio no lo va a llamar el main 00:36:09
Al servicio lo va a llamar el servlet 00:36:11
Ni sprint 00:36:13
Ni idems 00:36:15
¿Eh? 00:36:17
¿Tenéis el proyecto subido 00:36:20
en el aula virtual, reflejáis la estructura 00:36:22
tenéis que ser los más poderosos 00:36:24
de España que entienden perfectamente la arquitectura de servlets 00:36:30
y por tanto, un servlet es 00:36:33
un programa que se ejecuta en un servidor 00:36:37
de aplicaciones como resultado de una petición 00:36:42
HTTP, eso es un servlet, al igual que esto es una aplicación 00:36:46
que se ejecuta 00:36:50
un servidor, es un trozo de código 00:36:51
un programa, que 00:36:56
lo ejecuta un servidor de aplicaciones 00:36:58
que está en un servidor web 00:37:00
como respuesta a una 00:37:01
petición HTTP 00:37:04
al igual que 00:37:05
un mail, que es un programa 00:37:07
que se ejecuta en un PC 00:37:10
normal y corriente 00:37:12
como respuesta de 00:37:13
la marca 00:37:15
actual 00:37:18
Pues así 00:37:18
Venga, pues ya está 00:37:21
Un momento que pase 00:37:23
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:
6 de diciembre de 2025 - 11:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
37′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
171.25 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid