Saltar navegación

20251211 BDR-SPRING-TRANSACCIONES - 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 11 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, que era Spring en origen 00:00:00
una aplicación al final acaba siendo 00:00:04
objetos que necesitan 00:00:07
de la existencia de otros 00:00:10
para inyectarse en su constructor, lógicamente 00:00:12
ahora a su vez este objeto 00:00:16
se va a inyectar en el constructor del otro para que el otro aparezca 00:00:18
con lo cual al final una aplicación es un montón 00:00:22
de objetos que se van creando para meterse en constructores 00:00:25
de otros para subir, construir otros 00:00:29
es decir, objetos que se van apoyando unos en otros 00:00:31
¿verdad? 00:00:33
el pool 00:00:35
el data source pool 00:00:36
se apoya en el de la conexión 00:00:38
el de la conexión se apoya en no sé qué 00:00:40
al final una aplicación tiene una parte 00:00:43
muy grande que es de objetos 00:00:45
que para existir necesitan 00:00:47
que existan otros porque necesitan para su construcción 00:00:49
y a su vez yo 00:00:51
otro me va a necesitar para construir 00:00:53
bueno, no sé lo que os dije 00:00:54
pero da igual 00:01:01
como si no os hubiera dicho nada 00:01:02
vale 00:01:05
entonces, lo que importa es lo que os digo 00:01:06
ahora, vale 00:01:09
entonces, una aplicación 00:01:10
tiene una parte muy grande que es eso 00:01:12
entonces, si yo me tengo que 00:01:15
preocupar 00:01:17
de que todos los objetos necesarios 00:01:18
estén creados 00:01:20
pues bueno, eso es una tarea dificultosa 00:01:22
el preocuparme de que todos los objetos estén creados 00:01:25
pues Spring 00:01:28
en origen, lo que es su core 00:01:30
su núcleo en origen 00:01:32
esencialmente era 00:01:34
no te preocupes, yo me 00:01:36
preocupo de instanciar 00:01:38
todos los objetos que hagan falta 00:01:39
y meterlos para construir 00:01:41
el gordote 00:01:44
tú saca el gordote 00:01:44
tú saca el objeto gordote 00:01:46
A ver, que soy de igualdad de género 00:01:50
No vayáis de machirulos ahora 00:01:56
Porque os tengo que bajar la nota 00:01:58
Ah, ¿por qué? 00:01:59
Por ser hombre bajas la nota 00:02:04
Efectivamente 00:02:05
Para discriminación positiva, lo siento 00:02:07
Ah, bueno, entonces si es positiva 00:02:10
Si es positiva, entonces 00:02:11
Si es positiva, se acepta 00:02:13
Vale, pues entonces 00:02:14
¿Qué me decía Spring? 00:02:18
tú creas el objeto grandote. 00:02:20
Y yo ya me preocupo de ir instanciando todos los que hacen 00:02:22
falta hasta construir la pirámide de objetos, ¿vale? 00:02:25
Eso es lo que objeto llama bin, un bin. 00:02:30
Entonces, en origen, pues, tú configurabas un XML enorme 00:02:32
donde decías, necesito este y necesito este y este y este y 00:02:37
este y se iban inyectando en el gordo que tú ya creabas en la 00:02:40
aplicación, ¿vale? 00:02:44
Entonces, a su vez 00:02:46
Eso te facilitaba la idea del singleton 00:02:48
Es decir, asegurar 00:02:51
Que los objetos eran únicos 00:02:52
Porque ya Spring 00:02:54
Una vez que había creado un objeto 00:02:56
Para meterlo en el otro que hiciera falta 00:02:58
Ese objeto era único, se hacía falta en otro momento 00:03:00
Pues en origen era eso 00:03:02
Y eso sigue estando en la base 00:03:04
De cualquier 00:03:06
Ya subherramienta que uses con Spring 00:03:07
¿Vale? 00:03:11
Que usas Spring Data JPA 00:03:12
el core que es la gestión 00:03:14
de Bing sigue estando 00:03:16
que usas el Spring MVC 00:03:17
el core que es la gestión de Bing 00:03:19
sigue estando, o sea, eso ya está 00:03:21
en cualquier parte 00:03:23
que ya uses específica de Spring 00:03:26
¿vale? lo que pasa es que ahora 00:03:27
pues no se 00:03:30
configura normalmente con XML 00:03:31
sino con anotaciones 00:03:34
pero es lo mismo, entonces cuando 00:03:35
se pone el famoso repository para el JPA 00:03:38
uy, he puesto repository y me han aparecido un montón 00:03:40
de métodos, ¿qué es repository? 00:03:42
es una anotación que te dice 00:03:43
oye, este objeto es único 00:03:47
Spring, por favor, detectalo 00:03:48
hazlo aparecer cuando haga falta 00:03:50
todo eso significa 00:03:52
y como eso, pues mil cosas 00:03:54
¿vale? pues entonces a lo que vamos 00:03:56
para esto de las transacciones 00:03:58
vamos a usar el Spring Core también 00:04:03
porque ya sí que necesitamos más objetos 00:04:05
que se van a inyectar unos en otros 00:04:07
entonces vamos a usar anotaciones 00:04:08
para identificar los objetos como 00:04:10
oye, ojo, Spring, este es un bin 00:04:12
que créalo cuando te haga falta y mételo 00:04:14
donde te haga falta, ¿vale? Esa es la idea 00:04:16
de fondo, pues que uno no se pierda 00:04:18
en, o no debería perderse en 00:04:20
pongo anotaciones porque 00:04:22
funciona y ya está, no 00:04:24
la gran mayoría de ellas 00:04:26
aunque se llamen diferentes, service, 00:04:29
repository, no sé qué, la gran mayoría 00:04:30
de ellas sirven para decir 00:04:33
Spring, porfis, instánciame 00:04:34
esto cuando te haga falta y mételo 00:04:37
donde quieras, ¿vale? 00:04:39
pues venga, vamos a hacernos ahora 00:04:40
un proyecto de escritorio sencillísimo 00:04:42
para gestionar una transacción 00:04:45
entonces yo le he llamado 00:04:47
llamadlo como queráis, vamos a copiar 00:04:48
y pegar los modelos y demás 00:04:51
del otro, entonces no vais a tener 00:04:52
que escribir mucho 00:04:54
pues ejemplo trans 00:04:55
se llama para mí 00:04:58
claro, es que este 00:04:59
lo hice cuando todavía no era coordinadora 00:05:02
de igualdad de género, si hubiera sido no lo habría llamado 00:05:04
así, pero ahora ya 00:05:06
no lo voy a cambiar de nombre 00:05:08
no, pero que 00:05:10
no es algo que hubiera hecho 00:05:16
porque implica que de alguna manera 00:05:18
no normalizas, no sé si me estoy explicando 00:05:22
pero da igual, lo acabo de improvisar así que 00:05:24
no, no, no, no, no, no 00:05:26
me refiero 00:05:30
no normalizarlo 00:05:31
sería dejarlo patente 00:05:35
como si tuviera algún tipo de significado 00:05:36
no sé si me estoy explicando 00:05:38
normalizarlo sería asumirlo dentro de cualquier otra 00:05:39
casuística de las que tú asumes 00:05:42
de partida 00:05:44
¿no has entendido nada? 00:05:45
vaya por Dios 00:05:47
sí, en definitiva 00:05:48
un proyecto nuevo, de Maven 00:05:52
no, no, no 00:05:53
el proyecto, no, no lo he copiado 00:05:55
porque voy a quitar mucho 00:05:57
ahora las vamos a ir copiando 00:05:59
una a una vosotros, no os preocupéis 00:06:01
haced uno nuevo de Maven 00:06:03
y ahora 00:06:04
en este proyecto va a usar el mismo 00:06:06
modelo y el mismo servicio 00:06:09
que el otro, que ahora lo vamos a ir copiando 00:06:11
pero que es el método que se me ha ocurrido 00:06:13
a mí, el primero que se me ocurrió sobre la marcha 00:06:15
con este modelo de coches tan 00:06:17
chorra que me pusisteis, pues lo único que se me 00:06:19
ocurrió sobre la marcha para hacer 00:06:21
algo que me, que necesitará 00:06:23
como transacción es 00:06:25
pues que cuando tú tienes un único 00:06:27
coche en el escaparate 00:06:29
entonces cuando quitas un coche 00:06:30
del escaparate 00:06:33
y pones otro, eso lo tienes que hacer 00:06:34
los dos a la vez, porque no pueden existir 00:06:37
dos coches en el escaparate 00:06:39
luego, para simular 00:06:40
esa transacción sencillita 00:06:43
añadid 00:06:45
en vuestra base de datos 00:06:46
añadid un campo nuevo 00:06:48
para poder simular esa transacción 00:06:51
¿cómo añadís 00:06:53
desde el Workbench? 00:06:54
¿cómo alteráis una tabla? 00:06:57
pues si seleccionáis la tabla 00:06:59
seleccionáis la tabla y le dais a la llave inglesa 00:07:00
se os abre el menú 00:07:03
para iniciar, ponéis ahí una columna 00:07:06
como SQL no admite 00:07:08
boolean para decir si está en escaparate 00:07:12
no está en escaparate 00:07:14
pues él te lo pone directamente como 00:07:15
timing, si marcáis boolean 00:07:18
te lo va a poner en entero pequeñito 00:07:20
¿verdad? pues bueno 00:07:22
añadís una columna con entero 00:07:24
o entero pequeño, me da igual 00:07:26
cuando ya la tengáis pues apply 00:07:28
abajo 00:07:32
y ya está 00:07:32
y os aparecerá 00:07:35
os aparecerá 00:07:38
esta nueva columna 00:07:43
¿vale? 00:07:45
tinyint 00:07:48
o ponint, da lo mismo, tinyint es porque 00:07:49
ocupe menos, es un número entero pequeñito 00:07:51
¿vale? 00:07:52
¿esto? 00:07:57
¿cómo se añade? ¿te refieres? 00:07:59
en la tabla 00:08:01
ventas, si tú la seleccionas aquí 00:08:02
te aparece una llave inglesa 00:08:04
que es para configurarla 00:08:06
entonces si pulsas en la llave inglesa 00:08:08
te aparece ya este menú 00:08:10
para hacer los cambios que quieras en esa tabla 00:08:12
pues entre ellas, añades aquí abajo una columna nueva 00:08:14
con el tipo de dato que sea 00:08:17
apply y ya está 00:08:19
¿vale? 00:08:20
¿correcto? 00:08:23
nada 00:08:32
No pongáis nada 00:08:33
A ver, poned 00:08:35
Marcadlo como Boolean 00:08:39
Y al darlo a Apply 00:08:40
Él os lo va a transformar automáticamente al TinyInt 00:08:41
Hay un tipo Boolean por ahí abajo 00:08:45
En el desplegable, si marcáis ese 00:08:48
Cuando ya se haga el SQL 00:08:50
Él ya lo mueve al TinyInt y ya está 00:08:52
Porque como el Boolean no existe 00:08:55
Mi columna es esta 00:08:56
que veis que 00:09:01
tiene ahí un boolean 00:09:05
poned el boolean y ya está 00:09:07
y él lo pone como tiny 00:09:08
vale, pues entonces 00:09:09
¿qué quiero con esta 00:09:23
con este 00:09:27
campo de aquí? 00:09:30
la única idea que he querido reflejar 00:09:31
para explicar las transacciones es 00:09:33
solamente puede haber un coche 00:09:34
en el escaparate, el que tenga 00:09:37
esto a cero no está expuesto 00:09:39
y el que tenga 00:09:41
esto a uno sí está expuesto 00:09:43
entonces, ahora 00:09:45
en el servicio vamos a hacer un método 00:09:47
que sea 00:09:49
modificar el escaparate, entonces 00:09:50
modificar el escaparate va a necesitar 00:09:53
dos 00:09:55
updates 00:09:57
pasar este de cero a uno y pasar este 00:09:58
de uno a cero 00:10:01
vamos a necesitar que se hagan, ¿los dos o ninguno? 00:10:02
porque en el escaparate tiene que haber siempre uno solo 00:10:06
no puede haber dos o cero 00:10:09
entonces pues bueno 00:10:10
esta es la única idea sobre esta tabla 00:10:12
que se me ha ocurrido para simular 00:10:14
algo que tenemos que manejar 00:10:16
como transacción o todo o nada 00:10:18
vale, la tabla ya está con este campo añadido 00:10:20
pues vamos 00:10:22
al proyecto que tenéis vacío 00:10:24
entonces, del proyecto que tenéis vacío 00:10:26
podéis copiar ya mucho 00:10:28
del otro día 00:10:30
por ejemplo, os hacéis el paquete modelo 00:10:32
para hacer la clase venta. 00:10:34
En la clase venta 00:10:36
la copiáis, o sea, la copiáis del otro. 00:10:38
En el eclipse de escritorio del otro día 00:10:41
tenéis el ejemplo de JDBC que hicimos, 00:10:43
que es este. 00:10:46
Tenemos este ejemplo que hicimos 00:10:47
que está completito. 00:10:49
Claro, por eso digo que lo tenéis que añadir, 00:10:54
el íntegro, ¿vale? 00:10:57
Entonces, copiáis el paquete modelo 00:10:58
y en la venta, 00:11:00
cuando os ha añadido una columna nueva, 00:11:02
añadís un campo íntegro. 00:11:04
¿Vale? Añadís el campo íntegro, el escaparate 00:11:08
y ponéis su get y su set. 00:11:10
Su get y su set 00:11:13
y generad 00:11:14
el constructor con todos los parámetros 00:11:17
porque luego lo vamos a usar para el JDBCTemplate. 00:11:19
Entonces, el paquete modelo 00:11:21
se queda tal cual 00:11:23
añadiendo este campo. 00:11:24
Solamente, añadiendo este campo. 00:11:27
¿Vale? Get y set, 00:11:29
claro, añadidlo 00:11:33
y poned un constructor, 00:11:34
repito, con todos los parámetros porque luego 00:11:37
el JDBCTemplate lo va a facilitar. 00:11:39
No, no le he dado longitud. 00:11:41
Si tú, si te da error, 00:11:48
selecciona el tipo de datos Boolean y él ya 00:11:50
te lo va a modificar al TinyIn sin valores 00:11:51
y no te va a dar error. 00:11:54
Lo he hecho limpio. 00:11:57
Sí, y lo que estamos es, 00:12:00
a ver, podríais copiarse 00:12:02
una copia de este, pero había que borrar más 00:12:04
cosas que las que tenemos que añadir al proyecto 00:12:05
limpio. Entonces, haced uno limpio, 00:12:07
entonces, copiáis el modelo 00:12:10
Añadiendo esa clase 00:12:12
¿Vale? 00:12:13
El del otro día 00:12:18
Que es el que está en la virtual 00:12:19
Vale 00:12:20
Ahora ya tenemos 00:12:21
Venta con el escaparate 00:12:22
Siguiente clase 00:12:23
¿Qué hacemos? 00:12:24
La DAO 00:12:25
Pues copiaos el paquete DAO 00:12:25
Si queréis 00:12:28
Pero 00:12:29
El único 00:12:30
O mejor haceros lo limpio 00:12:31
Porque lo que hemos hecho 00:12:33
Es que vamos a hacer uno limpio 00:12:33
Sin la basura del de arriba 00:12:34
Entonces 00:12:35
Hacer un DAO limpio 00:12:36
Porque el único método 00:12:38
Que me va a interesar 00:12:39
Es este 00:12:40
Porque es el que quiero gestionar 00:12:40
Como transacción 00:12:41
¿Vale? 00:12:42
Este proyecto es solo para verlo de transacciones 00:12:44
Bueno, pues hacéis un DAO limpito 00:12:48
Con el único método 00:12:50
Que queremos que tenga ese DAO 00:12:52
Que es cambiar el escaparate 00:12:53
El coche con el ID1 00:12:56
Va a salir del escaparate 00:12:58
Y se va a ir al escaparate 00:13:01
El coche con el ID2 00:13:02
¿Vale? 00:13:03
Lo cambiamos 00:13:04
Ahora 00:13:05
Tenemos el modelo y el DAO 00:13:14
Ya está 00:13:25
¿Vale? 00:13:26
Esto es, ahora nosotros esto lo vamos a ejecutar desde un main. 00:13:32
El main va a ser el que cambie el escaparate, un main. 00:13:35
No desde un server, que nos daría igual, pero desde un main. 00:13:37
Y así se queda más limpio y más sencillo. 00:13:40
Vale, pues ahora este DAO habrá que implementarlo. 00:13:42
Venga, pues el paquete de implementación con el venta de 00:13:46
implementación. 00:13:49
¿Vale? 00:13:52
De esta anotación de aquí, por ahora os olvidáis. 00:13:55
Vamos a implementarlo. 00:13:58
Vamos a implementarlo. 00:14:00
¿Cómo sabemos implementarlo? 00:14:02
Esto es lo que ya hemos hecho en el otro proyecto. 00:14:04
Lo único es que hay que añadir el otro parámetro. 00:14:13
Hay que añadir otro parámetro. 00:14:17
Esto es tal cual. 00:14:18
El jdbc template. 00:14:21
El mapper. 00:14:25
Cuidado, añadiendo la propiedad. 00:14:27
Sí, sí. 00:14:31
Entonces, si copiáis el POM 00:14:34
Tal cual 00:14:41
Del proyecto que acabamos de hacer ahora 00:14:42
Pues ya lo tenéis todo 00:14:45
Para tener estas dependencias 00:14:46
Pues nada, esto es nuestro 00:14:49
JDBC template 00:14:53
El mapper 00:14:54
El constructor 00:14:56
Este 00:14:59
Va a necesitar 00:15:01
para instanciarse 00:15:04
va a necesitar que alguien le meta 00:15:05
un JDBC template 00:15:08
¿vale? 00:15:09
entonces 00:15:14
este ya va a empezar a ser 00:15:14
este ya 00:15:17
va a ser necesario que lo gestione Spring 00:15:19
porque se le inyecta 00:15:21
una dependencia 00:15:24
y vamos a dar ese salto 00:15:25
vamos a dar el salto de ahorrarnos 00:15:28
nosotros la inyección 00:15:30
de las dependencias 00:15:32
vamos a ahorrar ese salto 00:15:33
vale, pues entonces 00:15:35
para ahorrarnos el salto de la inyección 00:15:38
de la dependencia 00:15:40
de alguna manera hay que decirle al core 00:15:41
de sprint, que tendremos que poder 00:15:44
también en las dependencias 00:15:46
del POM, de alguna manera habrá que 00:15:48
decirle, ¡eh! este es un BIN 00:15:50
del que te encargas tú 00:15:52
este es un BIN del que te encargas tú 00:15:53
fijaos que venta 00:15:56
no necesita a nadie 00:15:58
no necesita 00:16:03
a nadie 00:16:05
no se le inyecta nada 00:16:05
se le inyectan valores 00:16:08
string, integer, que es que no son 00:16:09
objetos que se tengan que instanciar, son cosas 00:16:12
que yo le doy, entonces este 00:16:14
bin 00:16:16
spring puede pasar de él, yo no necesito 00:16:16
decirle a spring gestiónalo 00:16:20
porque este bin es muy simple, no se 00:16:21
le inyecta nada, vale 00:16:24
entonces yo aquí ni he puesto anotación ni he puesto 00:16:25
nada, pero este 00:16:27
este ya 00:16:30
empieza a necesitar 00:16:32
ya empieza 00:16:34
necesitar que le pasen otros 00:16:36
entonces aquí ya empieza 00:16:38
el caos de 00:16:40
de Spring, que es 00:16:42
uy, un bin 00:16:44
un objeto que necesita de otro 00:16:46
ocúpate tú 00:16:48
ocúpate tú Spring, ocúpate 00:16:49
vale, pues para que Spring se ocupe 00:16:52
tenemos que anotarlo 00:16:54
tenemos que anotarlo 00:16:56
vale 00:16:57
y ahora, ¿qué anotación ponemos? 00:16:58
la anotación general 00:17:03
que se le dice a Spring para decir 00:17:04
esto es un bin del que tú te ocupas 00:17:07
es la anotación component. 00:17:08
Esa es muy genérica. 00:17:11
Bin del que tú te ocupas, component. 00:17:14
Pero luego cada bin normalmente 00:17:16
tiene un significado específico. 00:17:18
Sirve para una cosa en concreto. 00:17:20
Lo cual le da como más fuerza. 00:17:21
Entonces repository 00:17:24
es un caso concreto de bin 00:17:25
que se ocupa de acceso a datos. 00:17:27
Yo podría anotarlo como component 00:17:30
y decir 00:17:32
ocúpate tu 00:17:33
sprint de él porque es un bin 00:17:36
tuyo 00:17:38
pero sería genérico, no pasa nada 00:17:40
me va a funcionar igual porque yo en esta aplicación 00:17:42
no estoy haciendo nada específico que necesite 00:17:44
ser repositorio, no estoy haciendo nada 00:17:46
pero bueno, como es 00:17:48
una clase que se ocupa de acceso a datos 00:17:50
y que va a hablar con la base de datos 00:17:52
pues le puedo anotar como un caso 00:17:54
concreto de component, que es el repositorio 00:17:56
y lo dejo ya anotadito 00:17:59
ya caracterizado 00:18:01
el hecho de que sea repositorio o no 00:18:01
en esta aplicación 00:18:04
concreta pequeña de aquí, no me está aportando nada 00:18:06
podría poner component, pero en el futuro 00:18:08
pues si nos aportará, si queremos que haga cosas 00:18:10
vale, pues entonces 00:18:12
este proyecto como lo tengo yo, lo voy a subir 00:18:14
así que como vendrá con todos los comentarios 00:18:16
pues más o menos lo tenéis explicado todo 00:18:18
vale, aquí 00:18:20
esto significa 00:18:22
lo que acabo de decir, vale 00:18:23
ah, entonces 00:18:25
ahora 00:18:28
Ahora ya necesitamos el core de Spring 00:18:28
Necesitamos el core de Spring 00:18:32
No solo el Spring JDBC 00:18:34
Y entonces ahora ya en el POM 00:18:35
O cogéis el Spring Core 00:18:38
Del 00:18:42
Repositorio 00:18:43
Copiáis esto 00:18:46
Lo que os sea más cómodo 00:18:48
La de abajo ya la tenéis 00:18:51
Que es la de Spring JDBC 00:18:57
Esto es para que el jefe 00:19:17
Ya, bueno 00:19:21
A ver 00:19:24
Calmaos 00:19:27
Aquí tenéis 00:19:28
Lo tenéis 00:19:30
Lo tengo dos veces 00:19:32
El SpringJD lo tengo dos veces 00:19:35
Vale 00:19:37
Este es el context 00:19:39
Primero copian este 00:19:41
Este es 00:19:44
Este es como el jefe 00:19:45
este es como el jefe, es una aplicación Spring 00:19:47
arranca siempre 00:19:55
desde un objeto enorme, gordote 00:19:57
que es el contexto 00:19:59
y el contexto ya es el que 00:20:01
lo hace todo, instancia los bins 00:20:03
todo lo que haga falta 00:20:05
¿vale? vais a odiar Spring, tanto que me lo pedíais 00:20:06
pues ahora lo vais a odiar 00:20:12
vale 00:20:13
odiar una cosa no implica que no odiemos más otra 00:20:17
bueno, o lo odiáis todo 00:20:20
no, en realidad 00:20:22
en realidad lo estáis disfrutando 00:20:23
Aunque no lo reconozcáis. 00:20:25
¿A quién no le está gustando el módulo? 00:20:27
Sed sinceros. 00:20:30
¿A quién no le está gustando el módulo? 00:20:33
A mí no me está gustando porque no soy capaz de entenderlo. 00:20:35
Claro, pero es que hemos dado un salto conceptual muy grande. 00:20:39
Ya, no le tocamos un salto tan grande en 20 segundos. 00:20:42
Es como saltamos el vacío. 00:20:45
¿Y qué hacemos? 00:20:49
A ver, que yo podría quedarme con los contenidos del módulo 00:20:50
y quedarme así bajito y ya. 00:20:53
pero 00:20:55
vosotros lo que tenéis es que 00:20:56
llegar a una empresa 00:21:00
y la empresa tiene que flipar con vosotros 00:21:01
y el resto que van de otros institutos 00:21:04
se van a caer 00:21:06
se van a caer porque no van a saber 00:21:07
ni la mitad de lo que hay vosotros 00:21:10
lo que hay que hacer es que en el primer curso 00:21:11
uno se dé tantas cosas random 00:21:14
y se dé más cosas de estas 00:21:16
en el primer curso tres meses 00:21:17
con el primitivo 00:21:20
vale, y cómo hacemos para que 00:21:21
Vale, entonces, si a mí me dejan que aprueben dos personas, encantada. 00:21:24
Pero no me dejan, pues ya está. 00:21:31
Ya, pero es verdad que a mí sí siempre me ha faltado curso y también. 00:21:34
Ya, ya, ya. 00:21:38
Pues el año que vamos a repetir. 00:21:40
No, no, no vais a repetir. 00:21:42
Que no, que no, que no. 00:21:44
Venga, vais a coger unas... 00:21:45
Si luego yo cuando se examino, se examina a un nivel más bajito. 00:21:47
Lo que pasa es que si que quiero, pues que todo lo que podamos, 00:21:50
Pues más o menos ver, conocer, saber, ver de qué va 00:21:52
Pues que lo sepamos 00:21:54
Dentro de lo que se usa ahora, claro 00:21:56
Venga, ¿esta la habéis copiado? 00:21:58
Se siente cada clase como 00:22:01
El garrote de 00:22:04
Pero a ver, lo que sí que tenéis que hacer es 00:22:05
Luego mirarlo en casa 00:22:14
Porque es que si no, es verdad que uno se 00:22:15
Desconcierta, tenéis que mirarlo 00:22:18
En casa, ¿vale? 00:22:20
Venga, pues a ver 00:22:22
Esta ya la tenemos 00:22:28
Y esta es para transacciones 00:22:31
Con lo cual, esta la vamos a poner 00:22:36
Porque vamos a hacer algo de transacciones 00:22:39
Si no usáramos transacciones 00:22:41
Pues del repositorio de Maven la puedes sacar 00:22:43
O le dices a HGPT 00:22:47
Dame la dependencia para si quieres usar transacciones de free 00:22:48
Y te da esto 00:22:51
si tú le pides a él cosas concretitas 00:22:52
sabiendo lo que le pides 00:22:56
te suele dar cosas con sentido 00:22:57
como le pidas algo así muy general 00:22:59
bueno, pero 00:23:00
claro, pídeselo más afinado 00:23:09
y si no, luego tú lo retocas 00:23:11
pero bueno, esta versión sí está bien 00:23:14
yo creo que sí 00:23:17
pero puede que, por si acaso 00:23:25
yo he puesto las específicas para en este proyecto 00:23:26
tampoco 00:23:28
liar mucho, pero 00:23:29
yo creo que el core, esta 00:23:32
las de arriba las tiene fijo, claro 00:23:34
y esta entiendo que también 00:23:36
pero bueno, las he buscado 00:23:38
por separado 00:23:40
pues estará, pero bueno 00:23:41
no hay una biblioteca 00:23:45
que se encargue ya de importarte 00:23:48
el resto de bibliotecas 00:23:50
vamos a 00:23:51
no cedamos el control 00:23:54
no cedas nunca el control, como cedas el control 00:23:55
de tu vida y de tus cosas, 00:23:58
uf, jamás le des el control 00:24:00
a nadie. 00:24:02
Vivo tranquilo. 00:24:03
No, no, no. 00:24:04
Tampoco quiero mucho. 00:24:05
¿Eh? 00:24:07
¿Qué? 00:24:09
Por ejemplo. 00:24:11
Vale, pues entonces. 00:24:13
Ahora ya sí que sí. 00:24:16
Con estas dependencias puestas, 00:24:17
Repositori 00:24:20
ya la tenemos. 00:24:21
¿Vale? O con la del core 00:24:24
o con la que sea. 00:24:26
esto es lo de la otra clase 00:24:28
y esto es 00:24:31
ahora ya vamos a implementar 00:24:34
mi método escaparate 00:24:36
se ha quedado así, muy sencillito 00:24:37
como veis, lo voy a bajar aquí para que se vea mejor el string 00:24:39
vale, este es mi método 00:24:42
cambiar escaparate 00:24:54
son dos subdates 00:24:55
que quiero que se hagan 00:24:58
o los dos o ninguno 00:25:00
por eso es una transacción 00:25:02
esto igual 00:25:04
lo podría haber hecho con 00:25:07
jdbc puro 00:25:09
con jdbc pues haciendo 00:25:11
la sentencia 00:25:13
y ya está 00:25:14
vale, pues si lo hago con jdbc puro 00:25:17
entonces me tengo que preocupar de 00:25:21
poner arriba 00:25:23
de la conexión 00:25:24
jdbc set autocommit false 00:25:27
porque si no por defecto 00:25:29
te hace un commit por cada 00:25:31
sentencia. Y cuando ya he terminado 00:25:33
poner conexión.com 00:25:36
¿Vale? 00:25:38
Pero claro, lo tengo que ir poniendo yo a mano 00:25:40
me tengo que ir preocupando, el código sigue 00:25:42
haciéndose gordo y gordo y gordo, etc. 00:25:43
¿Vale? 00:25:46
Exacto. 00:25:49
Justo. 00:25:51
Cuando él dice, consolida lo que has hecho 00:25:51
si todo ha ido bien. Consolida 00:25:53
lo que has hecho si has llegado hasta aquí, claro. 00:25:55
Pues si no has llegado hasta aquí, te has ido por un catch 00:25:58
entonces habrá hecho un rollback. 00:25:59
Vale, pues esta es 00:26:01
el método, y ya está, no tiene más esta implementación 00:26:03
entonces 00:26:06
¿qué? 00:26:06
¿qué? 00:26:08
quedan 19 00:26:14
en 19 minutos nos da tiempo 00:26:20
luego ya 00:26:30
lo consolidáis en casa 00:26:31
y el próximo día 00:26:34
pues volvemos sobre ello 00:26:36
y seguimos 00:26:37
volvemos sobre ello 00:26:38
el próximo día 00:26:40
para hacer una revisión general 00:26:40
vale 00:26:42
bueno 00:26:43
¿está el método? 00:26:44
algunos escriben muy lento 00:26:50
y otros escriben muy rápido 00:26:51
córtate la cabeza 00:26:52
pero aunque te tumbes 00:26:55
en la cabeza es suficiente 00:26:57
El próximo día nos va a funcionar a todos 00:26:58
Bueno, vale, pues ya está 00:27:13
Entonces 00:27:18
Esto 00:27:19
Esto tiene que ser una transacción 00:27:21
Pero 00:27:23
La transacción 00:27:25
no se marca aquí. 00:27:27
No es aquí donde hay que decirle 00:27:29
al gestor de transacciones de Sprint 00:27:32
que esto es una transacción. 00:27:34
¿Dónde hay que hacerlo? 00:27:36
En el servicio. 00:27:38
Porque el servicio realmente es el señor 00:27:40
que hace las cosas. 00:27:42
Es el que hace las cosas. 00:27:45
El servicio llama a este 00:27:46
y a otros si hacen falta. 00:27:48
Pero él es el que hace las cosas. 00:27:50
Pues en el servicio es donde hay que marcar. 00:27:52
Oye, esto que te he encargado es una transacción. 00:27:54
Vale, pues vámonos a implementar el servicio 00:27:55
Venga, el de implementación ya está 00:27:58
Porque le he metido el enter 00:28:01
Para que quepa en la misma línea 00:28:14
Para que quepa en la pantalla 00:28:15
Es que si no esto se iba a ir muy lejos 00:28:16
Bueno, le he dado el enter y me lo ha metido solo 00:28:18
Me lo ha puesto el solo 00:28:24
me lo ha puesto el solito 00:28:27
y queda bonito así 00:28:31
vale, pues ahora 00:28:32
os hacéis el paquete servicio 00:28:34
con dando 00:28:37
service 00:28:38
y vamos a hacer el servicio 00:28:39
el servicio 00:28:42
pues ventaservice 00:28:46
que necesita su venta 00:28:48
dado 00:28:52
una instancia de venta dado, claro 00:28:53
y ahora ya 00:28:56
el método 00:28:59
¿vale? 00:29:04
el método cambiar escaparate 00:29:07
será simplemente, llamo yo a mi 00:29:09
venta DAO, cambiar escaparate 00:29:11
de uno por y de dos 00:29:14
ese será mi método cambiar escaparate 00:29:15
¿verdad? 00:29:17
cambiar escaparate con transacción 00:29:19
lo he llamado para que 00:29:21
pero bueno 00:29:23
le pasan los dos id 00:29:24
y él llama al DAO, cambia la etapa, ¿eh? 00:29:27
Vale. 00:29:30
Ya está, este sería el método. 00:29:32
Vale, esto lo he puesto aquí 00:29:35
para forzar que falle 00:29:36
y así veamos qué hace el rollback. 00:29:38
Pero bueno, ahora mismo olvidaros de esto. 00:29:40
Vale, entonces, ahora este método 00:29:43
es el que queremos 00:29:45
que Spring trate como una transacción. 00:29:46
O hace todo y lo termina de principio a fin 00:29:51
o si no lo terminas de principio a fin 00:29:54
sin excepciones, 00:29:56
No hagas nada, como si nada hubiera pasado. Ahí es donde se hacen las transacciones, en los servicios, y así es como tenemos que diseñar la aplicación. Servicios que hacen las cosas, si yo quiero que algo se haga como una transacción, es un servicio, y ese servicio ahora lo anoto como transaccional. 00:29:57
si no lo anoto 00:30:14
como transaccional 00:30:16
esto no es una transacción 00:30:17
luego que se hace parte 00:30:20
de lo que hay aquí dentro, esa parte se queda 00:30:21
en la base de datos, que sale la excepción 00:30:24
después, esa parte no porque ha salido 00:30:27
excepción, pero en ningún momento se va a hacer 00:30:28
un rollback, si yo lo anoto 00:30:30
como transaccional 00:30:32
o se hace todo enterito 00:30:34
o si falla cualquier punto 00:30:36
pum, para atrás, rollback 00:30:38
¿vale? transaccional lo podéis importar 00:30:40
para dependencias que hayáis puesto y ya está 00:30:43
Ahora volvemos arriba otra vez un poquito 00:30:44
Para esta anotación 00:30:47
De nuevo, este tío 00:30:49
Necesita de otros 00:30:51
Luego, uff 00:30:53
Perdona, sprint 00:30:55
Ocúpate tú de las inyecciones 00:30:57
De objetos 00:31:00
Cuando ventas el B&T 1 00:31:01
El singleton que esté por ahí 00:31:03
Te coges el venta dado que esté por ahí 00:31:05
Implementación y lo metes aquí dentro 00:31:08
Ocúpate tú, no voy a seguir yo 00:31:09
El rastro de que objetos 00:31:12
he instanciado para 00:31:14
irlos enchufando. Yo no voy a seguir el rastro. 00:31:16
Te anoto. ¿Vale? 00:31:18
Anotación genérica para 00:31:20
bin que tiene que registrar 00:31:21
sprint. Component, 00:31:23
otra vez. Pero claro, hay 00:31:26
una subclase de component 00:31:28
que son los que son servicios. 00:31:29
Los que son servicios 00:31:32
son una clase de 00:31:33
bins especiales que ganan 00:31:36
funcionalidad específica. 00:31:38
Pues la anotación service dice, tú eres un 00:31:40
bin de sprint, te va a gestionar sprint, 00:31:42
a la hora de inyectarte 00:31:43
pero además eres un servicio 00:31:44
con lo cual ganas 00:31:46
esa fuerza que tienen los servicios 00:31:48
como tener cosas transaccionales dentro, etc 00:31:50
¿vale? y ya está 00:31:52
y nuestro service ya está 00:31:55
¿vale? entonces 00:31:56
este throw si queréis ponerlo ya 00:32:02
esto es que yo he forzado 00:32:04
que salga mal el método 00:32:08
porque ¿cómo lo voy a forzar 00:32:10
si lo único que hago es un nubdate? 00:32:12
no voy a romper la base de datos 00:32:13
es muy complicado 00:32:14
entonces he forzado lanzando una excepción 00:32:15
que una run time 00:32:18
acordaos, porque si no es run time me va a obligar 00:32:21
a hacer un try catch y un throw 00:32:24
entonces, que sea run time 00:32:25
porque si no, no hago nada 00:32:28
he forzado que algo salga mal 00:32:30
entonces 00:32:32
este método, al ser transactional 00:32:33
y como se va a estropear 00:32:35
no me va a cambiar el escaparate 00:32:37
no me lo va a cambiar, sin embargo 00:32:39
si yo quitar a transactional 00:32:41
aunque 00:32:43
me dé aquí un error 00:32:44
me va a cambiar el escaparate 00:32:47
luego la diferencia entre poner transactional y no ponerlo 00:32:48
es enorme, es muy grandota 00:32:51
de cambiar el escaparate 00:32:53
correctamente a no cambiarlo 00:32:55
porque se ha roto el método con lo cual 00:32:57
el transactional me ha hecho un rollback 00:32:59
vale, pues ahora ya vamos a hacernos 00:33:00
bueno, cogeos el 00:33:03
objeto este de conexión 00:33:05
lógicamente para 00:33:07
para generar el JDF template 00:33:08
vale, no lo copié 00:33:12
vamos a hacerlo limpio 00:33:15
¿Por qué ahora qué? 00:33:16
Un segundito 00:33:18
Porque ahora el JDBC template 00:33:18
Es un objeto 00:33:21
Que necesita ser inyectado 00:33:23
Para el 00:33:25
Para el de la implementación 00:33:26
Con lo cual 00:33:29
Ahora yo no me hago los singleton a mano 00:33:31
Como me los he hecho antes 00:33:33
No me hago mi get JDBC template 00:33:34
No me hago ni get connection 00:33:36
Para eso tengo a Spring 00:33:37
Pero claro, para eso 00:33:39
Tengo que 00:33:43
crearme 00:33:44
esta clase, mi clase conexión a la cambia 00:33:46
vale 00:33:49
entonces 00:33:50
ahora, no, no, no, esta no la vais a copiar 00:33:52
porque es una locura 00:33:55
esta os la voy a subir ahora mismo y la descargáis 00:33:56
y ahora la entendemos porque aquí es donde os dije 00:33:59
no queréis sprint, pues ahora vais a entender 00:34:01
todas y cada una 00:34:03
de las anotaciones que ha sido necesario poner 00:34:04
un segundito 00:34:06
si, se lo voy a subir luego, pero es que 00:34:08
ahora quiero que vosotros lo ejecutéis y lo probéis 00:34:16
antes de irnos. Entonces, lo necesitáis. 00:34:17
El proyecto le voy a subir ahora 00:34:22
todo. No, no hay problema. 00:34:24
Sí, está todo grabando. 00:34:31
Vale, a ver, vamos a 00:34:35
hacer una cosa. Como va a ser mi cuarto enseguida, 00:34:36
vamos a explicarlo 00:34:39
y como luego voy a subir el proyecto, 00:34:40
pues ya tenéis el proyecto 00:34:42
y todo eso. Y ya revisamos el próximo día 00:34:44
todo lo que se haya 00:34:46
quedado ahí. Vale. 00:34:48
Bueno, pues ahora, mi 00:34:50
singleton que me creaba el JDBC template 00:34:52
a mano y todo eso, ese singleton ha 00:34:54
desaparecido. Ahora tenemos esta clase. 00:34:55
Esta clase 00:34:59
sustituye 00:34:59
al antiguo XML que me dice 00:35:01
necesito esto y todo esto y todo esto. 00:35:03
¿Vale? Que es lo que yo he hecho con mi singleton. 00:35:06
Te doy un get para sacar esto, 00:35:08
te doy un get para sacar esto, te doy un get para sacar esto. 00:35:09
Pues ahora, eso, con sprint 00:35:12
tú le dices a Spring, esto es lo que necesito 00:35:13
antes en un XML 00:35:15
ahora no, ahora 00:35:17
te haces una clase 00:35:19
y puedes anotar los bin 00:35:22
que te hacen falta 00:35:23
un bin 00:35:24
es un objeto, cualquiera 00:35:27
el significado 00:35:29
más básico de bin 00:35:32
es un objeto normal y corriente 00:35:34
que anda por ahí 00:35:35
vale 00:35:36
con el término NetBeans en general 00:35:36
no sé de dónde, NetBeans, no sé de dónde 00:35:48
sacó NetBeans 00:35:50
para llamarlo Beans, no lo sé 00:35:52
no lo he buscado nunca 00:35:54
vale, pues entonces 00:35:55
necesitamos 00:35:57
el objeto DataSource 00:36:00
porque este 00:36:02
el DataSource es el pool 00:36:04
o podría ser la conexión normal que hemos usado en el otro 00:36:05
proyecto, que era el DriverManagerDataSource. 00:36:08
Por si os acordáis, en otro proyecto 00:36:11
hemos usado un DataSource con 00:36:12
conexión única para JDBC 00:36:14
que era DriverManagerDataSource. 00:36:16
Me da igual. Aquí tengo un pool. 00:36:19
Ambos son DataSources igual. 00:36:20
¿Vale? Que son los que necesita el 00:36:22
JDBC Template. El JDBC 00:36:24
Template es DataSource. Me da igual que sea un pool 00:36:26
como aquí, que 00:36:28
sea un DriverManagerDataSource 00:36:30
como en el proyecto que hemos visto antes. Me da igual. 00:36:32
Bueno, pues entonces 00:36:35
aquí tengo 00:36:36
este método 00:36:37
que me devuelve el datasource 00:36:42
que me lo devuelve 00:36:45
me lo devuelve así 00:36:47
y yo le anoto como bin 00:36:48
con esto le digo a Spring 00:36:50
oye, este tú lo instancias 00:36:52
cuando haga falta 00:36:55
consérvalo como único 00:36:56
no lo multipliques 00:36:58
consérvalo como único 00:37:00
no tengo que hacer el diferente de null 00:37:02
consérvalo como único 00:37:04
y méteselo a quien lo necesite. 00:37:06
Vale, el data source nos hace falta para el JDBC template. 00:37:08
Vale, ¿qué más nos hace falta? 00:37:11
El JDBC template que me irá el data source de arriba. 00:37:14
Pues ya está, el JDBC template me devuelve el JDBC template. 00:37:18
Trátalo como bin. 00:37:22
Aquí no tenemos el problema este que decías tú, Daniel, antes. 00:37:24
Porque aquí yo devuelvo el objeto y con la anotación bin, 00:37:30
al manejarlo Spring como bin 00:37:34
él ya se preocupa de que sea único 00:37:36
de no multiplicarlo de todo 00:37:38
no tengo yo que programarlo específicamente 00:37:39
vale, ¿y qué más objetos 00:37:42
nos hacen falta para esta aplicación? 00:37:44
el gestor de transacciones 00:37:48
porque vamos a usar transactional 00:37:49
con transacción, que es este objeto 00:37:50
que usa el data source 00:37:52
también 00:37:54
también es 3 00:37:55
y aparte está usando la anotación de la anterior 00:37:57
claro, entonces 00:38:00
Spring va a manejar, aparte de lo que yo he 00:38:02
anotado con repositor y service. 00:38:04
El de implementación y el servicio. 00:38:06
Aparte de esos, Spring va a 00:38:08
manejar estos para instanciarlos 00:38:10
cuando haga falta. ¿Por qué? Porque los 00:38:12
necesito. Los necesitan mis clases. 00:38:14
Necesitan el data source 00:38:17
porque el data source del JDF template 00:38:18
y tal esto. Entonces, los necesito. 00:38:20
Pues los tengo que declarar 00:38:23
en algún sitio. ¿En un XML? 00:38:24
Bueno, es una posibilidad. 00:38:27
¿En una clase aparte anotándolos con 00:38:28
BIM? Vale. Los declaro porque 00:38:30
los necesito. Anoto con bin, 00:38:32
tú los gestionas cuando hagan falta. 00:38:34
¿Vale? Aquí están. 00:38:36
En esta clase. ¿Vale? 00:38:38
Luego esta clase sustituye 00:38:40
a mi 00:38:42
singleton de antes. 00:38:43
Y ahora, le tengo 00:38:46
que poner anotaciones para que Sprint sepa 00:38:48
de qué va esto. 00:38:50
La anotación configuration 00:38:52
es para decirle, oye, 00:38:53
lo que te voy a meter aquí son bins para ti 00:38:56
para gestionar. Te estoy configurando. 00:38:58
Te estoy configurando. 00:39:01
Esta es una clase de configuración. 00:39:03
Estoy configurando lo que van a ser bins. 00:39:05
Ahora, siguiente anotación. 00:39:09
Paquete base a partir del cual vas a usar tú 00:39:12
para buscar esos bins que yo te doy. 00:39:16
Me he puesto con NANDOS porque es mi raíz. 00:39:18
Si yo anotara aquí un bin que no cuelga de aquí, 00:39:21
no lo va a encontrar. 00:39:25
Entonces, aquí pongo la base donde él va a hacer su escaneo. 00:39:27
Y ahora esto es simplemente 00:39:31
Para que Spring 00:39:37
Habilite la gestión de transacciones 00:39:39
Y por tanto pues 00:39:41
Mire esto, si está 00:39:42
Lo mire, para que lo tengan en cuenta 00:39:45
Esto solamente ahora es nuestro proyecto 00:39:46
Específico porque vamos a usar transacciones 00:39:49
Esto es por específico nuestro 00:39:51
De transacciones, pero esto es 00:39:53
Básico de Spring 00:39:55
Aquí le dices clase de configuración 00:39:55
Te digo cuáles son los bins que vas a 00:39:58
necesitar inyectar automáticamente 00:40:00
a partir de qué paquete 00:40:02
base de este, a partir de ahí, bla, bla, bla. 00:40:04
Y ya está. Y aquí pones 00:40:07
los bins que hacen falta. Todo 00:40:08
lo que no esté anotado con 00:40:10
bin aquí o en 00:40:13
su sitio correspondiente 00:40:14
con la anotación 00:40:16
que sea, component, repository, 00:40:19
service, Spring 00:40:21
no lo gestiona. Te tienes que encargar tú de 00:40:22
instanciarlo e inyectárselo a quien haga falta. 00:40:24
¿Vale? Bueno, pues 00:40:27
ya está. Ahora ya lo único que tenemos es un 00:40:28
main. Un main y hacer 00:40:30
nuestra llamada. 00:40:32
¿Vale? 00:40:35
Pues ya está. Ahora 00:40:36
nuestro main. 00:40:38
Nuestro main. 00:40:43
Una aplicación con Spring 00:40:44
necesita un momento 00:40:46
que ya está que no, que nos falta el main, 00:40:48
que nos faltan cuatro minutos. 00:40:50
Juan, ¿por qué te levantas? 00:40:53
Pues no puedes enchufar después. 00:40:56
A ver, el main. 00:40:58
Sí, sí, sí, sí. 00:41:03
Que sí. 00:41:05
Sí, sí, de tener grabación está grabando. 00:41:08
Porque se han hecho pequeñitos los estos. 00:41:12
Vale, entonces, la aplicación Spring necesita el jefe, 00:41:16
el jefe de todos, que es el contexto. 00:41:20
El jefe saca el BIM principal, el único que vas a usar tú. 00:41:24
vamos a usar service, ya está 00:41:27
pues saco el service 00:41:29
y con este get bin 00:41:30
sacas el service y ya sprint 00:41:33
se encarga de hacer service, meterle todo 00:41:35
instanciar la implementación, instanciar 00:41:37
todo lo que haga falta, yo tengo mi service 00:41:39
que es lo único que voy a usar 00:41:41
y ya sprint saca todo lo que haga falta 00:41:42
¿vale? y ahora ya 00:41:45
llamo al método, cambiar 00:41:47
escaparate 00:41:49
ahora 00:41:50
esto lo podemos ejecutar 00:41:52
lo vamos a ejecutar por sinergia a la cafetería 00:41:55
veríamos en la base de datos 00:41:57
que no me lo va a hacer 00:42:00
porque hay un error, luego no se va a hacer 00:42:02
pero si quitamos la anotación transaccional 00:42:04
¿vale? 00:42:06
por ejemplo, venga, voy a hacer rápido 00:42:08
voy a cambiar el 5 por el 6 00:42:10
entonces 00:42:13
esto sería 00:42:14
bueno, pero esto no tiene 00:42:15
la restricción esta 00:42:24
Aquí no lo estás validando 00:42:25
Vale, pues 00:42:31
Finish 00:42:33
Vale, entonces yo ejecuto 00:42:35
Este main 00:42:37
Vale, esto todo lo de sprint 00:42:38
Que te cuenta aquí la hostia en bote 00:42:48
Vale 00:42:50
Lo hace sprint, son los logs de sprint 00:42:52
Vale, y me ha hecho un rollback 00:42:56
Porque el método dio error 00:42:58
Con lo cual no me ha cambiado el escaparate 00:42:59
No me lo ha cambiado 00:43:01
sin embargo, si yo aquí quitara 00:43:02
la transactional 00:43:06
la quitara aquí del service 00:43:08
la quitara 00:43:09
aquí sale el error, pero es que esto ya lo ha hecho 00:43:13
eso ya lo ha hecho porque no está trabajando 00:43:18
como transacciones, entonces aquí 00:43:20
si es que como no sé 00:43:22
en qué orden cambio uno de otro, pues no sé 00:43:24
aquí 00:43:26
vale 00:43:30
¿veis? me lo ha cambiado 00:43:32
no ha funcionado como 00:43:35
transacción porque la transacción vale bueno pues no queréis sprint pues 00:43:36
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:
11 de diciembre de 2025 - 17:28
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 42″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
177.88 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid