Saltar navegación

20260519 AccesoBD_5 - 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 19 de mayo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Qué nos falta de nuestro CRUD? 00:00:01
Entonces, pues nos falta recuperar personas. 00:00:02
Por ejemplo, podemos hacer recuperar por clave. 00:00:09
Entonces, si recupera... 00:00:16
Uy, perdón. 00:00:17
Vale, pues si recuperamos por clave primaria, 00:00:19
este método me va a devolver una persona. 00:00:23
¿Verdad? 00:00:27
Me va a devolver una única persona, 00:00:28
que puede ser null si la clave primaria no existe, 00:00:29
Pero en el caso de que la clave primaria exista 00:00:32
Será una como mucho 00:00:33
Entonces 00:00:34
Pues get persona 00:00:36
Y aquí que le daríamos como parámetro 00:00:39
Esto de aquí 00:00:42
Vale, mira los de al lado también están con personas 00:00:43
Que originales somos 00:00:54
Todos 00:00:55
Vale, pues a ver 00:00:56
Aquí la conexión hay que hacerla 00:00:59
Igualmente, exactamente igual 00:01:01
Entonces vamos a hacer nuestro try con la conexión 00:01:03
Exactamente igual 00:01:06
De hecho como le voy a copiar todo 00:01:07
y ahora quito lo que me sobre, voy a copiar 00:01:12
mi código del anterior y ahora vamos a eliminar 00:01:16
todo lo que nos sobre, nos sobra este retun 00:01:20
este retun falso, en lugar de retun falso sería retun 00:01:24
null, muy bien, y aquí ya devolveremos 00:01:29
lo que toque devolver, de hecho 00:01:34
lo que yo voy a devolver, esta persona 00:01:38
persona que es igual a nul 00:01:41
se supone que la voy a 00:01:46
aquí 00:01:48
la voy aquí 00:01:49
a instanciar, a construir como sea 00:01:52
y luego la devolveré aquí 00:01:54
persona, vale 00:01:56
entonces la conexión la voy a necesitar igualmente 00:02:00
pues la conexión se queda 00:02:03
y una sentencia también la vamos a necesitar 00:02:04
igualmente 00:02:07
ahora el tema es esta sentencia 00:02:07
que tiene que hacer 00:02:11
vale 00:02:12
pues ahora esta sentencia 00:02:13
en lugar de llamar a un 00:02:16
execute 00:02:18
ubdate como en el caso anterior 00:02:20
porque tanto si yo quiero hacer insert 00:02:22
como aquí 00:02:24
como si quiero hacer deletes 00:02:26
como haré aquí, como si quiero hacer 00:02:28
ubdates como haré aquí, en cualquiera de esos casos 00:02:30
esta sentencia llamaría 00:02:32
al execute 00:02:34
ubdate 00:02:36
llamaría al execute 00:02:37
ubdate con lo que fuera 00:02:40
pero si lo que yo quiero es hacer una consulta 00:02:41
un select 00:02:45
pues entonces al que tiene que llamar es al execute query 00:02:47
el execute query poniendo aquí el SQL que toque 00:02:51
ahora lo haremos, poniendo ahí el SQL que toque 00:02:57
pero claro, este execute query 00:03:00
ahora ya sí que me va a devolver cosas 00:03:03
es el conjunto de registros 00:03:05
en este caso será uno como mucho 00:03:08
pero bueno, en principio el query me va a devolver un conjunto de registros 00:03:10
que es el resultante de la select, vale, pues 00:03:15
donde, en qué estructura guarda 00:03:19
el estándar JDBC los resultados de una select 00:03:22
pues los guarda en una estructura de datos que se llama 00:03:27
result set, result set que es 00:03:31
efectivamente de la API JDBC 00:03:41
bueno, pues en la estructura 00:03:45
result set, que es un set 00:03:49
en realidad, en esta estructura 00:03:51
me guarda todos los registros 00:03:54
resultantes de esta 00:03:55
select que yo ponga aquí 00:03:57
ahora tenemos que hacer nuestra select, claro 00:03:59
pues nuestra select va a ser 00:04:01
select, quiero todos los 00:04:03
campos, venga, sí 00:04:06
porque quiero construir la persona 00:04:07
enterita con todos sus campos 00:04:09
devuélveme todos los campos 00:04:11
from la tabla que sea 00:04:14
que mi tabla se llamaba 00:04:16
personas 00:04:18
yo la llamé personas 00:04:20
y tiene un where esto 00:04:24
where 00:04:27
id igual 00:04:35
igual a que 00:04:38
a este parámetro 00:04:39
con lo cual voy a tener que romper este de aquí 00:04:42
concatenarlo 00:04:46
con esto 00:04:47
entonces este select 00:04:49
ahora ya será selet asterisco from personas 00:04:55
query de igual 00:04:58
y después va a venir esto 00:05:00
3, 7, 15, lo que sea 00:05:02
vale 00:05:04
ahora yo ya 00:05:10
una vez que se ha ejecutado el query 00:05:14
tengo aquí un montón de registros con el resultado 00:05:16
como itero 00:05:19
por el result set 00:05:21
no itero como una colección normal y corriente 00:05:22
como nuestro set con un for each y con nada de eso 00:05:24
porque lo que tiene cada registro 00:05:27
dentro a su vez son un montón de campos 00:05:29
entonces no 00:05:31
itero de una manera propia 00:05:33
suya, entonces registros 00:05:35
tiene un método 00:05:37
que es el método 00:05:38
vale 00:05:40
next, el método 00:05:42
next 00:05:48
te dice si 00:05:49
a ver 00:05:52
el result set 00:05:52
internamente 00:05:56
este result set de aquí internamente 00:05:59
es como 00:06:01
una tablita 00:06:03
con los registros y cada registro 00:06:03
con su campo, ¿verdad? 00:06:06
id, nombre, edad, id, nombre, edad 00:06:08
vale, pues la estructura result set 00:06:10
inicialmente 00:06:12
se queda apuntando 00:06:13
o se queda posicionada 00:06:16
se queda posicionada en la anterior 00:06:18
a la primera 00:06:20
cada vez que hagamos un next 00:06:20
cada vez que hagamos un next 00:06:23
avanza una posición 00:06:25
entonces yo tengo que hacer un primer next 00:06:28
sí o sí, para quedarme en la primera 00:06:30
entonces este next además de avanzar 00:06:31
una posición en mi lista de registros 00:06:34
me devuelve true o false 00:06:36
si realmente 00:06:38
hay un registro en el que posicionarse 00:06:40
es decir 00:06:42
si yo aquí en mis registros next 00:06:44
me diera false desde el principio 00:06:46
es que 00:06:48
no ha habido resultado 00:06:49
en esta consulta 00:06:52
no ha habido resultado, con lo cual el primer next 00:06:54
ya me sale false, porque no hay ni un primero 00:06:56
en el que posicionarse, no hay ni un primero 00:06:58
¿vale? 00:07:00
entonces yo puedo jugar con ese hecho 00:07:01
con el hecho de que el next se posiciona 00:07:04
y además se devuelve true 00:07:07
si se posiciona en un sitio correcto 00:07:08
porque todavía hay 00:07:10
metiéndolo en un while 00:07:11
y esto funcionaría así 00:07:13
entonces jugaríamos con esto 00:07:19
metiéndolo en un while 00:07:23
entonces este while 00:07:24
¿qué iría haciendo? pues este while 00:07:26
en cada iteración 00:07:28
va colocándose en cada uno de los registros 00:07:30
¿verdad? 00:07:33
si estos son mis registros 00:07:36
en la primera vuelta del while 00:07:37
se ha colocado aquí 00:07:40
y yo ahora aquí hago lo que sea 00:07:41
en la siguiente vuelta del while 00:07:43
se ha colocado aquí y ahora ya hago lo que sea 00:07:45
en la siguiente vuelta del while 00:07:48
se ha colocado aquí y ahora ya hago lo que sea 00:07:50
así hasta que haya 00:07:52
una vuelta del while 00:07:54
que ya me ha dado false 00:07:55
porque no hay nada en donde colocarse 00:07:57
me ha dado false con lo cual este while terminaría 00:08:00
¿vale? 00:08:02
Luego este while, tal y como está puesto, solamente con esta condición aquí por ahora, va haciendo esto, va avanzando. 00:08:03
Primer registro, segundo registro, tercer registro, cuarto registro. 00:08:11
El while termina cuando ya no hay más registro. 00:08:14
Ahora nos queda la siguiente parte, que es, vale, una vez que ya está posicionado en cada registro, 00:08:17
¿cómo saca de él la información? 00:08:22
Porque es lo que queremos hacer, sacar la información. 00:08:24
Bueno, pues este result set tiene métodos para sacar los datos. 00:08:27
No, porque es un select asterisco. 00:08:35
O sea, me devuelve todos los campos. 00:08:46
Ah, este en particular 00:08:54
me va a dar o una 00:08:56
o ninguna, porque el ID podría no existir. 00:08:58
En este caso en particular. 00:09:01
Pero bueno, yo esa explicación la he dado en general. 00:09:02
Si fuera un select que te devolviera 00:09:04
más. ¿Vale? En nuestro 00:09:06
caso en particular este while o no 00:09:08
se ejecuta nunca porque directamente 00:09:10
el id no existe, luego 00:09:12
es vacío, no hay nada 00:09:14
por donde ir, o si realmente 00:09:16
existe este id, este while 00:09:18
va a entrar solo una vez, efectivamente, va a entrar 00:09:20
solo una vez, ¿vale? 00:09:22
Pero nosotros a priori 00:09:24
en una sentencia de select genérica 00:09:25
no sabemos cuántos registros 00:09:28
va a haber, por eso siempre usamos 00:09:30
esta estructura, que solo 00:09:32
se ejecuta una vez, vale, pues solo 00:09:34
se ha ejecutado una vez. ¿Que no se ha ejecutado ninguna? Pues no se ha ejecutado ninguna 00:09:36
porque no hay registros. Entonces, ahora 00:09:40
en cada iteración que estamos posicionados, en cada registro 00:09:43
¿cómo sacamos los datos? Pues mi estructura registros 00:09:48
tiene unos métodos que son get para sacar los valores de los campos 00:09:51
por ejemplo, yo aquí que quiero el campo nombre de ese registro 00:09:56
el campo nombre sé que es un barchar, un string, pues lo saco así 00:10:00
este sería el campo nombre 00:10:04
entonces yo aquí podría hacer 00:10:07
este campo nombre a quien se lo quiero poner 00:10:10
al set de la persona 00:10:12
entonces vamos a 00:10:15
entrar aquí 00:10:17
vamos a crearnos nuestra persona p 00:10:19
igual a 00:10:23
p igual a new persona 00:10:25
vale 00:10:39
y ahora el constructor 00:10:40
sin parámetros lo quité cuando puse 00:10:42
el otro 00:10:44
entonces 00:10:45
bueno, ni siquiera hace falta 00:10:47
por pura vaguería 00:10:50
registros para hacerlo 00:10:52
por partes, este sería 00:10:56
el nombre 00:10:57
de ese registro 00:10:59
¿verdad? el campo nombre de ese registro 00:11:01
vámonos por el campo id 00:11:04
el campo id 00:11:05
perdón 00:11:08
el campo id no, el campo edad 00:11:12
el campo id ya lo tengo, es por el que he buscado 00:11:14
el campo edad 00:11:16
sería get 00:11:19
como es un ínteger 00:11:20
pues será get in 00:11:21
get in edad 00:11:23
y ahora me voy a construir 00:11:25
una persona con esos valores 00:11:28
y la devuelvo con valor de retorno 00:11:30
y ahora ya 00:11:31
mi persona p 00:11:33
igual 00:11:35
construyo una persona 00:11:36
new persona 00:11:39
con 00:11:40
voy a hacer un 00:11:42
constructor con el id también 00:11:47
me construyo una persona con los 00:11:49
tres parámetros y es la que voy a devolver 00:11:57
new persona 00:11:59
el parámetro 00:12:02
No, instanciada no 00:12:03
La tengo a null 00:12:10
Para que si nunca entro aquí me devuelva el null 00:12:11
Directamente 00:12:13
Edad y n 00:12:14
Venga, voy a poner nombre 00:12:18
Y así queda más bonito 00:12:22
Vale, y esta es 00:12:24
Penopersona 00:12:29
Vale, pues con este while 00:12:31
He avanzado al primer registro 00:12:37
En mi caso el único 00:12:39
de ese primer registro he sacado 00:12:42
el campo nombre y el campo edad 00:12:44
y me he construido la persona 00:12:47
con esos tres valores 00:12:49
con el valor id que es por el que yo estaba buscando 00:12:50
con la edad que me ha devuelto 00:12:53
la select y con el nombre que ha devuelto 00:12:55
la select 00:12:57
que la id no existe 00:12:57
este while nunca se habría ejecutado 00:13:00
entonces si la id no existe este while nunca se habría 00:13:02
ejecutado con lo cual persona seguiría siendo null 00:13:05
porque ese while nunca 00:13:07
se habría ejecutado 00:13:09
Y ahora ya lo único que me falta a mí es devolver esa persona 00:13:10
Que puede ser null 00:13:13
Puede ser null si el id no existe 00:13:15
Porque entonces nunca entré aquí 00:13:17
O si el id sí existe 00:13:19
No será null 00:13:21
Será la persona que sea 00:13:23
¿Vale? 00:13:24
Entonces 00:13:29
Vamos a 00:13:30
En nuestro main 00:13:31
Añadir 00:13:34
La funcionalidad de 00:13:35
recuperar 00:13:39
persona 00:13:45
recuperar 00:13:46
persona 00:13:48
vale, sería mi caso 00:13:50
dos, dirá pues 00:13:53
dame el id 00:14:06
dame el id 00:14:07
dame el id 00:14:10
pues venga, el id 00:14:13
lo leo 00:14:16
integer 00:14:19
punto parse 00:14:22
int 00:14:24
de scan.nextline 00:14:25
no lo leo con next in para evitar todo el rollo del salto de línea 00:14:29
del buffer, etcétera, y ahora ya puedo llamar a 00:14:34
operaciones 00:14:38
operaciones. 00:14:39
operaciones. 00:14:42
no lo hice estático 00:14:46
o algo, a ver, operaciones 00:14:48
¿dónde está? gestión persona es este 00:14:52
no, no lo tengo 00:14:54
ah, está aquí 00:14:56
exacto, no lo hice static 00:14:56
vale, no lo hice static 00:15:00
ahora ya 00:15:04
ah, main aquí 00:15:06
operaciones.getpersona 00:15:10
esta me va a devolver una persona 00:15:15
me va a devolver una persona 00:15:18
venga, vamos a mostrarla directamente 00:15:19
Tú esto ya luego lo dejas bonito 00:15:21
Si es null puedes poner 00:15:37
No existe la persona 00:15:40
Vamos a ponerlo bonito 00:15:41
Si persona 00:15:45
Siendo persona P igual a 00:15:50
operaciones.getPersonaId 00:15:53
si esta persona p 00:15:57
resulta que es diferente de null 00:16:00
resulta que es diferente de null 00:16:04
entonces, ahora lo reviso 00:16:10
me falta aquí un paréntesis 00:16:16
vale 00:16:23
Persona es diferente de nul 00:16:33
Entonces si sop 00:16:46
Ahora tendré que hacer el toString 00:16:48
Y si no 00:16:50
Ahora arreglamos eso 00:16:52
Y si no pues mostramos 00:16:53
No existe nadie 00:16:56
Con ese id 00:17:01
Vale 00:17:03
Y ahora 00:17:05
Esto de aquí 00:17:06
este cierra este 00:17:08
es diferente de nul 00:17:10
pues me gustaría poder 00:17:12
pero si no me va a dejar 00:17:19
tendré que declararlo 00:17:21
fuera 00:17:23
no me digas que no, es que como en el for 00:17:24
tenemos la costumbre de quedarlo siempre dentro 00:17:29
no me deja declararlo 00:17:32
que pena 00:17:39
persona p 00:17:40
igual a nul 00:17:50
vale 00:17:52
Pues si p es diferente de null 00:17:56
Muéstrame la persona 00:17:59
Y si no, no existe nadie con ese id 00:18:00
Y ahora hombre, para que esto quede bonito 00:18:02
Vamos a poner un toString en persona 00:18:04
Vamos a poner aquí un toString 00:18:05
Generate toString 00:18:10
Con los tres valores 00:18:14
Y ya está 00:18:16
Vale, pues este es mi main 00:18:17
Vamos a probarlo 00:18:29
A ver si existe la persona con el id 1 00:18:32
Si que existe 00:18:45
Pero la persona con el id 78 00:18:47
78 pues no existe 00:18:49
vale, pues este es el CRUD 00:18:51
básico, basiquísimo 00:18:56
lo más básico del mundo 00:18:58
y sin ningún patrón de diseño, ni dado ni nada 00:19:00
para ver el funcionamiento 00:19:03
ahora 00:19:04
a partir de aquí es sobre todo cuestiones de diseño 00:19:06
vale, bueno 00:19:09
pero bueno, seguimos 00:19:10
ayer ya mencionamos 00:19:14
lo feo 00:19:17
que es esto, verdad 00:19:18
esto de romper, esto de aquí 00:19:19
lo horrible que es, ¿por qué? 00:19:22
porque el usuario puede meterte en este campo id 00:19:24
cualquier cosa 00:19:28
puede meterte cualquier cosa 00:19:29
entre ellas un propio script SQL 00:19:31
¿y qué te hace este de aquí? 00:19:33
pues va 00:19:36
y te lo coge 00:19:37
entonces imaginaos que aquí construimos 00:19:38
vamos a pensar que podríamos construir aquí 00:19:41
para alterar este SQL 00:19:43
que se convierta en otro pero válido también 00:19:45
por ejemplo 00:19:47
si yo le meto ahí 00:19:49
un número cualquiera 00:19:51
el que me dé la gana, 38 00:19:55
y luego le pongo 00:19:58
1 igual a 1 00:19:59
¿esto es con doble igual en SQL? 00:20:06
con solo 1 00:20:09
esto va a ser un true 00:20:10
con lo cual me va a devolver toda la base de datos entera 00:20:12
toda la tabla 00:20:15
claro 00:20:15
Entonces esto va a ser un true 00:20:24
Con lo cual da igual 00:20:30
Yo puedo no tener ni idea de los ids que hay 00:20:32
Pero cualquier número que ponga 00:20:35
Me va a mostrar todo el contenido 00:20:37
Si, o sea, puedes hacer cualquier cosa 00:20:39
Pero vamos a probar esta opción la más sencilla 00:20:46
Por ejemplo, yo estoy con esto aquí 00:20:48
Y bueno, aquí lo único es que 00:20:50
Me select asterisco 00:20:56
Aquí lo único es que 00:20:58
estaría pisando una persona tras otra 00:21:01
vale, me mostraría la última 00:21:03
claro, entonces 00:21:05
vamos a hacerlo para que me 00:21:08
devuelva 00:21:13
una colección 00:21:14
y así me devuelva 00:21:18
las datos enteras, bueno 00:21:19
solamente para ver cómo funciona la inyección 00:21:23
vamos a dejarlo así, pero vamos a poner aquí 00:21:24
un siso 00:21:27
que me vaya mostrando 00:21:31
las personas por las que va pasando 00:21:33
entonces 00:21:35
vamos a hacer que nos muestre así 00:21:38
suprimir, esto va a ser 00:21:43
para ver el problema de inyección, este SISO de aquí 00:21:48
para ver el problema de 00:21:51
inyección SQL 00:21:56
vamos a añadir aquí un SISO 00:22:00
Que me muestre 00:22:03
Nombre 00:22:06
Y edad 00:22:08
Vale, entonces luego además 00:22:15
Me irá construyendo 00:22:18
Una persona cada vez 00:22:19
Y me devolverá la última 00:22:22
La que me devolverá luego es la última 00:22:24
Que ha construido 00:22:26
Porque una se va pisando con todas 00:22:27
Vale, entonces 00:22:30
Aquí 00:22:31
Si yo ahora 00:22:34
Espera, vamos a comprobar aquí 00:22:36
Se le hace una comprueba a personas 00:22:42
Vamos a ver 00:22:45
Que esa sentencia está bien 00:22:46
Where id 00:22:49
Igual a 1 00:22:51
Esta es la que yo quiero construir 00:22:53
Or 1 igual a 1 00:22:55
¿Vale? Esta sentencia me devolvería 00:22:56
Todos, ¿verdad? 00:23:01
¿Es correcto SQL? 00:23:02
Vamos a comprobarlo 00:23:05
Efectivamente me los devuelve todos 00:23:06
Si yo le quito el or1 igual a 1 00:23:07
Si yo lo quito solo me va a devolver 00:23:11
El primero 00:23:15
Pero si yo aquí le pongo 00:23:16
Or1 00:23:18
Igual a 1 00:23:21
Me devuelve todos 00:23:22
Con lo cual la idea es meterle este id 00:23:25
Ah vale vale vale 00:23:27
Pero aquí en esta selet en particular 00:23:29
No podría hacer 00:23:31
Inyecciones SQL 00:23:32
Porque esto 00:23:34
es un int 00:23:36
vale, id es un int 00:23:38
entonces esto no le valdría como int 00:23:40
pero si el parámetro de entrada fuera string 00:23:42
vale, o sea si la clave 00:23:45
fuera string 00:23:47
por ejemplo, vamos a recuperar 00:23:47
vamos a hacer, y así vamos a recuperar 00:23:50
por nombre, vale, vamos a recuperar por nombre 00:23:52
y así 00:23:55
y así ya atacamos el siguiente problema 00:23:57
que, pero salir, ya ha salido 00:23:58
vale, pues vamos a hacer 00:24:03
esto lo quitamos 00:24:05
Y vamos a hacer el 00:24:07
Recuperar todas las personas 00:24:11
Que se llamen no sé qué 00:24:14
Pues venga 00:24:15
Ahora, este método 00:24:17
Es interesante 00:24:20
Porque este ahora ya me devuelve 00:24:21
Todo esto 00:24:23
Todo esto me tiene que devolver 00:24:24
Porque esto ya no es por clave primaria 00:24:26
Entonces 00:24:28
Get 00:24:30
Personas 00:24:32
By nombre 00:24:34
Vale, pues este 00:24:36
Ahora ya me tiene que devolver 00:24:50
Toda una lista 00:24:53
Pues venga 00:24:55
Esta es la lista que me va a devolver 00:24:57
Lista 00:25:00
Persona, personas 00:25:01
Igual a new 00:25:03
Pues ArrayList, por ejemplo 00:25:05
El código sería el mismo que el de arriba 00:25:07
Lo que pasa es que aquí 00:25:20
Cada persona construida 00:25:22
Cada persona construida la añado a la colección 00:25:23
¿Vale? 00:25:25
Pero el código sería el mismo que el de arriba 00:25:27
Entonces vamos a copiar 00:25:29
todo el código que tenemos aquí arriba 00:25:30
todo este código 00:25:33
nuestra select cambia 00:25:40
where nombre 00:25:45
igual a 00:25:46
como el nombre es un string 00:25:50
aquí te voy a poner una comilla simple 00:25:53
aquí concateno con nombre 00:25:55
aquí concateno otra vez con la comilla simple de cierre 00:25:59
luego la select me cambia 00:26:03
eso es lo primero que me cambia 00:26:10
devuélveme todos los campos de la tabla personas 00:26:12
donde nombre sea igual a comilla 00:26:14
el parámetro nombre que me han pasado 00:26:16
cerrando con comilla 00:26:19
vale 00:26:20
ahora este bucle, ahora ya sí que se va a ejecutar 00:26:21
un montón de veces 00:26:25
vale, pues vamos a 00:26:26
recuperar 00:26:29
todos los campos 00:26:30
el id 00:26:32
registros 00:26:34
punto get int 00:26:39
nombre 00:26:43
nom 00:26:49
Porque está repetido 00:26:54
Bueno 00:26:55
Vale, y ahora ya 00:26:59
Me hago una nueva persona 00:27:02
Con esos datos 00:27:05
Y se la añado a la lista 00:27:07
Personas.app 00:27:08
Esta persona 00:27:12
Y ahora me devuelvo aquí 00:27:13
Personas 00:27:22
Vale, ¿tenéis el método completo? 00:27:25
Esta es la colección inicial 00:27:42
Inicialmente vacía 00:27:43
Puede que no haya personas con este nombre 00:27:44
Inicialmente vacía 00:27:46
nos hacemos nuestra select 00:27:47
que ahora ha cambiado 00:27:49
nos hacemos nuestra select, ahora es por nombre 00:27:50
hay que poner esta comilla 00:27:53
y ahora 00:27:54
por cada registro, que ahora puedo tener muchos 00:27:58
me construye una persona 00:28:04
con esos datos y se la añado 00:28:05
a la colección 00:28:07
y devuelvo las personas 00:28:08
vale, vamos a comprobar primero que funciona 00:28:11
y luego ya le hacemos 00:28:13
la inyección, que a esta sí que se la podremos hacer 00:28:15
fácilmente, ah bueno que no me he hecho 00:28:17
el main con el método 00:28:24
recupera 00:28:26
personas 00:28:37
por nombre 00:28:38
vale, pues será 00:28:41
mi caso 3 00:28:46
dame nombre 00:28:52
vale, ya tengo su nombre 00:29:07
y ahora ya 00:29:22
voy a recorrer 00:29:23
las personas para mostrarla 00:29:25
para cada persona 00:29:28
en operaciones.get 00:29:30
no me digas que otra vez tampoco la he puesto 00:29:34
static 00:29:36
tampoco la he puesto static 00:29:38
vale 00:29:41
pues 00:29:46
vale, amiga, dime 00:29:47
a ver, no 00:30:02
pero esto no lo hace 00:30:17
no hace una llamada esto en cada 00:30:18
iteración 00:30:21
la hace al principio 00:30:22
vale, o sea, no es que en cada 00:30:24
iteración vuelva a sacarlas 00:30:27
todas, no, no las vuelve a sacar 00:30:29
todas, vale, pues bueno 00:30:31
esto, dame el nombre 00:30:36
y ahora ya recorro todas las personas 00:30:37
en esa colección, vamos a 00:30:39
probar primero 00:30:41
aquí no hay nada lanzado 00:30:42
sí, vamos a lanzarlo 00:30:44
primero bien, metiéndole 00:30:49
un dato bueno, no queremos romper nada 00:30:51
a ver, una que tenga 00:30:53
pues venga 00:30:58
vamos a ver que pasa con 00:30:59
Pepe, vale, pues aquí 00:31:01
están los datos de Pepe, vale 00:31:07
entonces yo ahora puedo 00:31:08
meter 00:31:11
una cosa 00:31:11
y que me salga la base de datos entera 00:31:14
¿qué cosa? pues vamos a pensarla 00:31:16
aquí 00:31:19
el string que él tiene es este 00:31:19
nombre 00:31:23
igual 00:31:25
entonces, él tiene la comilla 00:31:26
aquí el nombre que yo le dé 00:31:29
y luego me cierra con comilla otra vez 00:31:32
entonces, este es el nombre que yo le paso 00:31:37
¿qué le podemos pasar ahí para convertir este word en un true? 00:31:40
pues le podemos pasar cualquier cosa 00:31:45
lo que me dé, un nombre que yo ni conozco de la base de datos 00:31:47
pongo una comilla otra vez, 1 la cierro 00:31:51
Igual a 00:31:56
Abro la comilla y pongo el 1 00:32:00
Es decir, si yo le pongo esto 00:32:01
Ya he convertido 00:32:04
Un true, ¿no? 00:32:06
Ah, me falta 00:32:13
No, no 00:32:14
Ya, ya, ya, sé que me estáis diciendo 00:32:19
eso, pero 00:32:32
entonces 00:32:33
no, es que no 00:32:45
vale, esta sí está bien 00:32:47
vale, entonces 00:33:22
esto 00:33:24
es lo que le tengo que meter 00:33:26
¿verdad? cualquier cosa ahí 00:33:28
dime 00:33:30
a ver 00:33:33
esto es algo que es verdad 00:33:40
¿no? uno igual a uno es verdad, como si pongo 00:33:42
2 igual a 2, 3 igual a 3 00:33:44
entonces al hacer un or 00:33:46
con algo que es verdad 00:33:47
entonces me queda nombre igual a pepe 00:33:49
o verdad, entonces aunque este nombre 00:33:52
no exista, la condición 00:33:54
va a ser verdad 00:33:56
entonces yo tengo que meter algo que me construya 00:33:56
este SQL, lo que me aporta 00:34:00
esta primera comilla, ya está 00:34:01
entonces es esto lo que tengo que meter 00:34:04
¿verdad? sería esto lo que tengo que meter 00:34:06
entonces 00:34:08
por ejemplo 00:34:10
esto mismo 00:34:15
¿Vale? Cualquier cosa que le ponga 00:34:16
Yo aquí 00:34:23
Esto 00:34:23
¿Vale? Da igual lo que yo ponga ahí da lo mismo 00:34:25
Entonces 00:34:29
Yo ahora voy a decir 00:34:30
A ver, no tengo ni idea 00:34:35
Recuperar personas por nombre 00:34:38
Esto es nombre 00:34:41
Pero podría ser contraseña o la que fuera 00:34:44
Yo no tengo ni idea de lo que hay en la base de datos 00:34:45
Pero 00:34:47
Aquí me funciona 00:34:48
esto, le meto esto 00:34:50
no tengo ni idea de nombres o algo así 00:34:53
y me saca 00:34:55
toda la tabla 00:34:57
¿vale? entonces es una forma 00:34:58
sencilla de sacar todos los contenidos de una tabla 00:35:04
¿qué ocurre? 00:35:06
claro, que efectivamente 00:35:11
esto no tiene solución, es que 00:35:12
esto es así sí o sí, y probando 00:35:15
con un montón de 00:35:17
datos de formularios 00:35:19
perfectamente, rápidamente 00:35:20
vas a romper la seguridad y te va a salir 00:35:22
ahí todo lo de la tabla 00:35:25
Claro, pues precisamente por eso 00:35:26
Hay una sentencia alternativa 00:35:29
A esta de aquí 00:35:30
A esta 00:35:32
¿Vale? 00:35:36
Vale 00:35:39
Pues vamos a parar unos minutos 00:35:40
Luego completamos con esta sentencia 00:35:44
Y lo dejamos por hoy 00:35:46
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
19 de mayo de 2026 - 13:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 51″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
156.82 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid