1
00:00:00,000 --> 00:00:22,460
Bueno, está grabando, así que no digáis cosas raras. Vale, entonces, tenemos la base de datos. ¿Y qué tenemos? El... Silencio por ahí. Y tenemos el lenguaje Java, que es nuestra herramienta para construir aplicaciones que accedan a los datos y den resultados a los usuarios.

2
00:00:22,460 --> 00:00:24,519
Bueno, pues entonces

3
00:00:24,519 --> 00:00:26,239
Como se trata de estandarizar

4
00:00:26,239 --> 00:00:27,339
Como siempre, ya lo sabéis

5
00:00:27,339 --> 00:00:28,519
Tenemos que hacer estándares

6
00:00:28,519 --> 00:00:29,820
A los que todos nos adaptemos

7
00:00:29,820 --> 00:00:32,979
Para uniformizar las aplicaciones

8
00:00:32,979 --> 00:00:35,060
Permitir su mantenimiento, escalabilidad, etc

9
00:00:35,060 --> 00:00:37,759
Que estándar nos ofrece Java

10
00:00:37,759 --> 00:00:41,159
Para el acceso a bases de datos relacionales

11
00:00:41,159 --> 00:00:42,780
JDBC

12
00:00:42,780 --> 00:00:44,359
Java Database Connectivity

13
00:00:44,359 --> 00:00:44,759
¿Vale?

14
00:00:45,460 --> 00:00:47,299
Entonces sabemos que es JDBC

15
00:00:47,299 --> 00:00:48,640
Es una API

16
00:00:48,640 --> 00:00:52,119
Que ofrece unas clases

17
00:00:52,119 --> 00:01:05,530
Entre ellas, Driver Manager, una de las que ofrece, ¿vale? Pero ofrece más clases como Statement, Prepare Statement, Connection, dime.

18
00:01:05,530 --> 00:01:10,969
el 22

19
00:01:10,969 --> 00:01:14,469
vale, entonces

20
00:01:14,469 --> 00:01:17,150
esta API

21
00:01:17,150 --> 00:01:19,090
nos ofrece unos métodos

22
00:01:19,090 --> 00:01:20,829
a los cuales nosotros llamamos para hacer

23
00:01:20,829 --> 00:01:22,349
esencialmente tres cosas

24
00:01:22,349 --> 00:01:25,150
crear conexiones, ejecutar

25
00:01:25,150 --> 00:01:26,650
sentencias, el CRUD

26
00:01:26,650 --> 00:01:27,269
completo

27
00:01:27,269 --> 00:01:30,950
y cerrar conexiones

28
00:01:30,950 --> 00:01:32,849
entonces

29
00:01:32,849 --> 00:01:35,090
nosotros hemos visto un poco

30
00:01:35,090 --> 00:01:37,150
lo básico, porque da un poco igual

31
00:01:37,150 --> 00:01:39,150
a partir de ahí explorar el resto de métodos

32
00:01:39,150 --> 00:01:40,349
no tiene más interés

33
00:01:40,349 --> 00:01:43,430
entonces, ¿qué es? crear una conexión

34
00:01:43,430 --> 00:01:47,129
o crear un pool de conexiones

35
00:01:47,129 --> 00:01:48,530
teníamos las dos opciones, ¿verdad?

36
00:01:48,870 --> 00:01:49,829
conexión única

37
00:01:49,829 --> 00:01:52,370
creo esa conexión

38
00:01:52,370 --> 00:01:55,569
hago lo que tenga que hacer y la cierro

39
00:01:55,569 --> 00:01:57,329
o si tengo una aplicación

40
00:01:57,329 --> 00:01:59,370
multi hilo, lo ideal sería

41
00:01:59,370 --> 00:02:01,650
creo un pool de conexiones

42
00:02:01,650 --> 00:02:03,349
lo que pasa es que

43
00:02:03,349 --> 00:02:05,290
el objeto

44
00:02:05,290 --> 00:02:06,650
pool de conexiones

45
00:02:06,650 --> 00:02:09,090
no me lo ofrece la API

46
00:02:09,090 --> 00:02:10,569
JDBC, me lo ofrece

47
00:02:10,569 --> 00:02:13,169
muchos

48
00:02:13,169 --> 00:02:13,830
proveedores

49
00:02:13,830 --> 00:02:16,650
el más usado

50
00:02:16,650 --> 00:02:19,210
para javar

51
00:02:19,210 --> 00:02:20,349
era el Icari, este

52
00:02:20,349 --> 00:02:22,949
entonces, pues bien

53
00:02:22,949 --> 00:02:24,689
un pool de conexiones, una colección

54
00:02:24,689 --> 00:02:26,930
única, el pool de conexiones

55
00:02:26,930 --> 00:02:28,990
se instanciaba y sacábamos de él

56
00:02:28,990 --> 00:02:30,909
una conexión cada vez que

57
00:02:30,909 --> 00:02:32,229
quisiéramos, las dos opciones

58
00:02:32,229 --> 00:02:34,750
pues eso, crear conexión

59
00:02:34,750 --> 00:02:36,590
única o pool, hacer las sentencias

60
00:02:36,590 --> 00:02:38,509
que quisiéramos hacer para

61
00:02:38,509 --> 00:02:40,550
hacer el CRUD correspondiente a esa

62
00:02:40,550 --> 00:02:42,930
base de datos y cerrar conexiones

63
00:02:42,930 --> 00:02:44,530
o liberarlas si se trataba

64
00:02:44,530 --> 00:02:46,449
de un pool, ¿vale? liberarlas para que

65
00:02:46,449 --> 00:02:48,550
estén ahí en el pool disponibles, esencialmente es eso

66
00:02:48,550 --> 00:02:49,669
entonces nosotros

67
00:02:49,669 --> 00:02:52,969
hemos hecho, pues hacer sentencias

68
00:02:52,969 --> 00:02:54,389
tanto sin

69
00:02:54,389 --> 00:02:56,289
precompilar como precompiladas

70
00:02:56,289 --> 00:02:57,469
que era el prepare statement

71
00:02:57,469 --> 00:03:00,250
y ya está

72
00:03:00,250 --> 00:03:02,370
no hemos hecho más que eso, entonces ahí sobre todo

73
00:03:02,370 --> 00:03:04,030
la complejidad está en

74
00:03:04,030 --> 00:03:06,750
recordar el SQL y construir

75
00:03:06,750 --> 00:03:08,330
buenos SQL

76
00:03:08,330 --> 00:03:10,169
porque

77
00:03:10,169 --> 00:03:12,370
JDBC lo que hace es llamar a esos

78
00:03:12,370 --> 00:03:14,229
SQL, entonces si uno construye

79
00:03:14,229 --> 00:03:16,469
buenos SQL, pues la aplicación no será

80
00:03:16,469 --> 00:03:18,189
un joyo de botella, funcionará mejor que si no

81
00:03:18,189 --> 00:03:18,810
¿vale?

82
00:03:20,090 --> 00:03:22,530
Luego, JDBC por supuesto

83
00:03:22,530 --> 00:03:24,430
permite hacer muchas más cosas

84
00:03:24,430 --> 00:03:26,370
en las que uno se podría

85
00:03:26,370 --> 00:03:28,289
meter, pero nosotros no tenemos tiempo

86
00:03:28,289 --> 00:03:31,590
y como ya son cosas que una vez que ya estéis en el contexto

87
00:03:31,590 --> 00:03:34,629
se trata de decir, a ver, ¿cómo hago esto con JDBC?

88
00:03:34,789 --> 00:03:37,569
Pues con estos dos métodos, punto, pelota, te lo dice

89
00:03:37,569 --> 00:03:40,650
chaje, peteo, te lo dice quien sea, siempre y cuando uno ya esté

90
00:03:40,650 --> 00:03:43,849
en el contexto de lo que quiere. ¿Qué otras cosas permite hacer?

91
00:03:44,389 --> 00:03:46,770
Pues, por ejemplo, sacar información

92
00:03:46,770 --> 00:03:49,729
sobre la base de datos, pues ¿cuántas tablas tiene?

93
00:03:49,909 --> 00:03:52,849
¿Las tablas qué columnas tienen? Etcétera. Eso a través

94
00:03:52,849 --> 00:03:55,370
de el objeto database, metadata

95
00:03:55,370 --> 00:03:57,289
que también se puede sacar de aquí

96
00:03:57,289 --> 00:03:59,569
pues cuando tengo un ResultSet

97
00:03:59,569 --> 00:04:01,770
sacar información de él

98
00:04:01,770 --> 00:04:03,310
como los nombres de las columnas

99
00:04:03,310 --> 00:04:06,069
porque no los conozco, el tipo de dato porque no lo conozco

100
00:04:06,069 --> 00:04:07,509
a través de un objeto

101
00:04:07,509 --> 00:04:09,750
también de aquí que es el ResultSetMetadata

102
00:04:09,750 --> 00:04:11,629
¿qué otra cosa se puede hacer

103
00:04:11,629 --> 00:04:12,370
que no hemos hecho?

104
00:04:13,169 --> 00:04:15,930
en lugar de ejecutar sentencias sueltas

105
00:04:15,930 --> 00:04:17,029
SQL sin más

106
00:04:17,029 --> 00:04:19,750
ejecutar procedimientos o funciones

107
00:04:19,750 --> 00:04:21,110
¿no? en SQL

108
00:04:21,110 --> 00:04:23,709
se pueden hacer procedimientos

109
00:04:23,709 --> 00:04:25,350
y funciones

110
00:04:25,350 --> 00:04:27,930
¿Vale? ¿Los hicisteis el año pasado?

111
00:04:29,069 --> 00:04:30,029
Bueno, pues se pueden

112
00:04:30,029 --> 00:04:31,850
hacer como en cualquier otro lenguaje de

113
00:04:31,850 --> 00:04:33,850
programación, como en cualquier otro

114
00:04:33,850 --> 00:04:35,750
lenguaje, se pueden hacer procedimientos

115
00:04:35,750 --> 00:04:37,750
y funciones, y si uno tiene

116
00:04:37,750 --> 00:04:39,750
su gestor de, tu gestor de

117
00:04:39,750 --> 00:04:41,810
base de datos, tú, por ejemplo

118
00:04:41,810 --> 00:04:44,089
si has visto que con esa base de datos

119
00:04:44,089 --> 00:04:45,930
haces muchas veces

120
00:04:45,930 --> 00:04:47,949
no sé qué acción que implica

121
00:04:47,949 --> 00:04:50,089
hacer varias sentencias, la metes

122
00:04:50,089 --> 00:04:51,870
en un procedimiento y le das

123
00:04:51,870 --> 00:04:54,069
un nombre, y ahí se queda en la base de datos

124
00:04:54,069 --> 00:04:56,649
y luego ya en tu script SQL

125
00:04:56,649 --> 00:04:58,490
llamas ese procedimiento almacenado

126
00:04:58,490 --> 00:05:00,470
y se acabó, pues ese procedimiento

127
00:05:00,470 --> 00:05:02,649
almacenado también podría ser llamado

128
00:05:02,649 --> 00:05:04,389
desde aquí, desde la aplicación

129
00:05:04,389 --> 00:05:06,610
siempre y cuando esté

130
00:05:06,610 --> 00:05:07,990
guardado y creado

131
00:05:07,990 --> 00:05:09,470
ya en la base de datos

132
00:05:09,470 --> 00:05:12,589
entonces hay muchas cosas

133
00:05:12,589 --> 00:05:14,769
relacionadas con el acceso a la base de datos

134
00:05:14,769 --> 00:05:16,870
que se pueden hacer desde aquí

135
00:05:16,870 --> 00:05:18,490
más allá de

136
00:05:18,490 --> 00:05:20,709
crear una sentencia simple sin más

137
00:05:20,709 --> 00:05:22,430
sea de insert, update, delete

138
00:05:22,430 --> 00:05:24,350
¿vale? pero son cosas muy puntuales

139
00:05:24,350 --> 00:05:26,569
que son fáciles de averiguar como se hacen y ya está

140
00:05:26,569 --> 00:05:28,449
¿vale? no nos vamos a meter aquí en ellas

141
00:05:28,449 --> 00:05:30,410
por falta de tiempo

142
00:05:30,410 --> 00:05:32,129
por ejemplo también los

143
00:05:32,129 --> 00:05:34,209
result set, recordad que era un objeto

144
00:05:34,209 --> 00:05:36,149
result set, un objeto result set

145
00:05:36,149 --> 00:05:38,009
era un objeto de esta API

146
00:05:38,009 --> 00:05:39,750
que recogía

147
00:05:39,750 --> 00:05:42,269
todos los resultados de una consulta

148
00:05:42,269 --> 00:05:43,170
¿verdad? de una query

149
00:05:43,170 --> 00:05:46,430
pues el objeto result set lo hemos usado

150
00:05:46,430 --> 00:05:48,310
exclusivamente para recorrerlo y mirar

151
00:05:48,310 --> 00:05:50,129
lo que tenía, pero tiene

152
00:05:50,129 --> 00:05:52,209
muchas más posibilidades, pues por

153
00:05:52,209 --> 00:05:58,250
ejemplo, a través del objeto result set, podemos actualizar la base de datos sin hacer queries. Es

154
00:05:58,250 --> 00:06:06,029
decir, tú has hecho una query y tienes aquí tus registros en Java. Pues esos registros puedes

155
00:06:06,029 --> 00:06:11,029
configurar de forma muy sencilla el result set para que estén conectados a la base de datos. Y a

156
00:06:11,029 --> 00:06:17,269
través de Java, pues eliminar algunos de esos registros, insertar un registro nuevo a través

157
00:06:17,269 --> 00:06:18,910
del result set sin tener que hacer

158
00:06:18,910 --> 00:06:21,110
otra sentencia SQL

159
00:06:21,110 --> 00:06:23,230
por ejemplo, entonces eso te facilita

160
00:06:23,230 --> 00:06:23,970
un poco el trabajo

161
00:06:23,970 --> 00:06:26,689
bueno, pues cosas

162
00:06:26,689 --> 00:06:28,889
que se pueden hacer para

163
00:06:28,889 --> 00:06:31,750
hacer más

164
00:06:31,750 --> 00:06:33,209
interesantes, o sea, tenemos

165
00:06:33,209 --> 00:06:35,550
más herramientas dentro de esto

166
00:06:35,550 --> 00:06:36,829
bueno

167
00:06:36,829 --> 00:06:39,790
pues esta es la herramienta

168
00:06:39,790 --> 00:06:40,870
ah bueno, el driver manager

169
00:06:40,870 --> 00:06:42,509
el driver manager era el que

170
00:06:42,509 --> 00:06:45,410
el gestor que manejaba los drivers

171
00:06:45,410 --> 00:07:08,689
Entonces, el driver manager necesita que haya un driver lógicamente en la aplicación, driver cargado, un objeto driver instanciado. Ese objeto driver lógicamente depende de la base de datos con la que estemos. Si es MySQL será un driver para MySQL, si es Postgre pues un driver para Postgre, lo que sea.

172
00:07:08,689 --> 00:07:11,310
Entonces ese driver lógicamente

173
00:07:11,310 --> 00:07:13,269
Nosotros lo poníamos como dependencia

174
00:07:13,269 --> 00:07:14,389
De la aplicación, ¿verdad?

175
00:07:14,449 --> 00:07:15,750
Lo poníamos como dependencia

176
00:07:15,750 --> 00:07:18,689
Y entonces cuando la aplicación arranca

177
00:07:18,689 --> 00:07:21,550
Se instancia automáticamente

178
00:07:21,550 --> 00:07:24,009
Un objeto de esa clase

179
00:07:24,009 --> 00:07:25,069
No tenemos que hacerlo a mano

180
00:07:25,069 --> 00:07:26,750
Como antes, que sí que había que hacerlo a mano

181
00:07:26,750 --> 00:07:29,009
Se instancia, se queda ahí cargado

182
00:07:29,009 --> 00:07:31,029
Y el driver manager ya

183
00:07:31,029 --> 00:07:33,730
Tira de él y lo coge

184
00:07:33,730 --> 00:07:36,050
Lo coge para rellenar

185
00:07:36,050 --> 00:07:37,490
Los métodos vacíos de la API

186
00:07:37,490 --> 00:07:49,290
Porque en JDBC los métodos están semivacíos, porque se tienen que implementar con el driver concreto que se haya incorporado como dependencia en la aplicación.

187
00:07:50,310 --> 00:08:02,910
Entonces, aquí por ejemplo, vimos una pequeña situación extraña, entre comillas, y es que cuando la aplicación era de escritorio, una aplicación de escritorio de Java, estupendo,

188
00:08:02,910 --> 00:08:06,050
porque todos los objetos estaban en el mismo

189
00:08:06,050 --> 00:08:07,350
contexto de carga

190
00:08:07,350 --> 00:08:09,850
porque solo había un proceso, entre comillas

191
00:08:09,850 --> 00:08:12,430
solo había un proceso que es mi aplicación de escritorio

192
00:08:12,430 --> 00:08:14,050
entonces

193
00:08:14,050 --> 00:08:16,029
hay un único contexto de carga

194
00:08:16,029 --> 00:08:16,750
de objetos

195
00:08:16,750 --> 00:08:19,610
pero si movíamos esto

196
00:08:19,610 --> 00:08:21,769
a una arquitectura de aplicación web

197
00:08:21,769 --> 00:08:23,610
que con un ejemplito

198
00:08:23,610 --> 00:08:25,730
para incorporar pedidos o coches

199
00:08:25,730 --> 00:08:27,170
o yo que sé, rollos de ventas

200
00:08:27,170 --> 00:08:29,930
que habíamos hecho en escritorio, lo movimos

201
00:08:29,930 --> 00:08:30,550
a serle

202
00:08:30,550 --> 00:08:32,669
para que no se os olvidara

203
00:08:32,669 --> 00:08:34,389
y acabaríais de entender bien lo que era un servlet

204
00:08:34,389 --> 00:08:35,830
pues cuando lo movimos a servlet

205
00:08:35,830 --> 00:08:38,590
¿qué pasó? que aunque poníamos como

206
00:08:38,590 --> 00:08:40,490
dependencia nuestro driver

207
00:08:40,490 --> 00:08:42,470
de MySQL y ahí estaba puesto en el

208
00:08:42,470 --> 00:08:44,370
POM como dependencia, aunque lo poníamos como

209
00:08:44,370 --> 00:08:46,450
dependencia, el driver

210
00:08:46,450 --> 00:08:48,629
manager no lo encontraba y nos decía

211
00:08:48,629 --> 00:08:49,389
todo el rato

212
00:08:49,389 --> 00:08:52,269
no encuentro un driver

213
00:08:52,269 --> 00:08:54,629
no encuentro un driver, no encuentro un driver y la aplicación

214
00:08:54,629 --> 00:08:56,409
no arrancaba, ¿por qué

215
00:08:56,409 --> 00:08:58,509
ocurría eso? porque

216
00:08:58,509 --> 00:09:00,529
en una aplicación web tenemos

217
00:09:00,529 --> 00:09:02,830
dos contextos de carga de objetos

218
00:09:02,830 --> 00:09:04,909
el contexto de la propia

219
00:09:04,909 --> 00:09:06,549
aplicación y el contexto

220
00:09:06,549 --> 00:09:08,690
del servidor de aplicaciones del Tomcat

221
00:09:08,690 --> 00:09:10,450
que también está ahí ejecutándose

222
00:09:10,450 --> 00:09:12,789
porque el Tomcat es el que tiene que cargar

223
00:09:12,789 --> 00:09:14,370
el servlet para que se ejecute

224
00:09:14,370 --> 00:09:16,830
entonces teníamos dos contextos

225
00:09:16,830 --> 00:09:17,210
de carga

226
00:09:17,210 --> 00:09:20,789
entonces el driver manager

227
00:09:20,789 --> 00:09:23,009
estaba en el contexto

228
00:09:23,009 --> 00:09:24,529
de carga del Tomcat

229
00:09:24,529 --> 00:09:27,169
y sin embargo la dependencia

230
00:09:27,169 --> 00:09:28,990
el objeto driver en sí

231
00:09:28,990 --> 00:09:31,389
el objeto driver estaba en el contexto

232
00:09:31,389 --> 00:09:32,470
de carga de la aplicación

233
00:09:32,470 --> 00:09:34,889
entonces driver manager no lo podía encontrar

234
00:09:34,889 --> 00:09:36,649
pues entonces que teníamos que hacer

235
00:09:36,649 --> 00:09:39,509
forzar que se cargara

236
00:09:39,509 --> 00:09:41,230
en el contexto de carga también

237
00:09:41,230 --> 00:09:43,049
y eso forzar que se cargue

238
00:09:43,049 --> 00:09:45,269
cualquier objeto se hacía

239
00:09:45,269 --> 00:09:46,129
con estas enter

240
00:09:46,129 --> 00:09:49,450
class for name ya que poníamos el nombre

241
00:09:49,450 --> 00:09:51,330
de la clase

242
00:09:51,330 --> 00:09:52,570
vale

243
00:09:52,570 --> 00:09:54,649
entonces con esto forzábamos la carga

244
00:09:54,649 --> 00:09:56,110
entonces esto era como un detalle

245
00:09:56,110 --> 00:09:58,389
para que veamos una situación

246
00:09:58,389 --> 00:10:01,250
curiosa de alguna manera

247
00:10:01,250 --> 00:10:02,830
entonces esta sentencia

248
00:10:02,830 --> 00:10:04,330
el class formame este

249
00:10:04,330 --> 00:10:06,830
si uno mirara aplicaciones

250
00:10:06,830 --> 00:10:08,870
antiguas o legadas

251
00:10:08,870 --> 00:10:11,029
de JDBC, pues se ponía

252
00:10:11,029 --> 00:10:12,929
por sistema, porque

253
00:10:12,929 --> 00:10:14,549
antes el driver

254
00:10:14,549 --> 00:10:16,850
incluso una aplicación de escritorio cualquiera

255
00:10:16,850 --> 00:10:18,990
el driver no se cargaba

256
00:10:18,990 --> 00:10:20,649
automáticamente, en los drivers

257
00:10:20,649 --> 00:10:22,669
del 8 hacia atrás

258
00:10:22,669 --> 00:10:23,870
en MySQL en particular

259
00:10:23,870 --> 00:10:25,870
no se cargaba automáticamente

260
00:10:25,870 --> 00:10:27,669
entonces siempre se ponía esto

261
00:10:27,669 --> 00:10:29,230
Para que el driver se cargara siempre

262
00:10:29,230 --> 00:10:31,149
Entonces lo veréis en muchos sitios

263
00:10:31,149 --> 00:10:33,370
Incluso en tutoriales antiguos

264
00:10:33,370 --> 00:10:34,870
Que ya no veis tutoriales o lo que sea

265
00:10:34,870 --> 00:10:37,230
Pero desde cierta versión de los drivers

266
00:10:37,230 --> 00:10:39,850
Ya está hecha el contexto estático

267
00:10:39,850 --> 00:10:41,009
Del driver

268
00:10:41,009 --> 00:10:43,210
El contexto estático está hecho para que se caiga automáticamente

269
00:10:43,210 --> 00:10:44,690
Con lo cual ya esto no se pone

270
00:10:44,690 --> 00:10:46,669
Pero

271
00:10:46,669 --> 00:10:49,710
En la aplicación web sí tuvimos que ponerlo

272
00:10:49,710 --> 00:10:51,149
Porque se había cargado

273
00:10:51,149 --> 00:10:52,809
En un contexto y en el otro no

274
00:10:52,809 --> 00:10:54,789
Entonces tuvimos que ponerlo para que se cargara

275
00:10:54,789 --> 00:10:56,730
Bueno, todo esto

276
00:10:56,730 --> 00:10:59,850
está subido en las sucesivas aplicaciones

277
00:10:59,850 --> 00:11:01,070
que están en el aula virtual

278
00:11:01,070 --> 00:11:02,970
que están ahí todas seguidas

279
00:11:02,970 --> 00:11:04,950
y en todos los comentarios de la aplicación

280
00:11:04,950 --> 00:11:06,690
está todo el chorizo explicado todo eso

281
00:11:06,690 --> 00:11:08,870
primero teníamos subido

282
00:11:08,870 --> 00:11:10,889
una de, a ver

283
00:11:10,889 --> 00:11:13,350
vamos a abrir aquí el aula virtual

284
00:11:13,350 --> 00:11:15,289
para irnos situando porque si alguien

285
00:11:15,289 --> 00:11:17,350
decide que va a estudiar en algún momento

286
00:11:17,350 --> 00:11:17,870
de su vida

287
00:11:17,870 --> 00:11:20,129
que debería ocurrir

288
00:11:20,129 --> 00:11:25,190
bueno pues es que por eso estamos

289
00:11:25,190 --> 00:11:26,110
haciendo un poco esto

290
00:11:26,110 --> 00:11:30,049
Para reenganchar

291
00:11:30,049 --> 00:11:34,120
El que no se va a ver

292
00:11:34,120 --> 00:11:35,659
No lo he grabado

293
00:11:35,659 --> 00:11:37,440
No, ¿cómo que no lo he grabado?

294
00:11:37,519 --> 00:11:40,419
A ver, la grabación está capturando pantalla todo el rato

295
00:11:40,419 --> 00:11:44,240
Sí, por eso, está capturando el escritorio

296
00:11:44,240 --> 00:11:44,600
Entonces

297
00:11:44,600 --> 00:11:46,659
Esto no se oye mi voz

298
00:11:46,659 --> 00:11:49,139
Vale, entonces la voz se oye

299
00:11:49,139 --> 00:11:51,200
Pero a ver, que tampoco es tan interesante

300
00:11:51,200 --> 00:11:52,720
Y se oye la voz

301
00:11:52,720 --> 00:11:53,879
Lo que esté aquí

302
00:11:53,879 --> 00:11:57,779
Vale, pues a ver

303
00:11:57,779 --> 00:12:11,899
Venga, pues nos vamos a JDBC

304
00:12:11,899 --> 00:12:15,019
Vale, pues esta es

305
00:12:15,019 --> 00:12:19,059
La aplicación de escritorio básica

306
00:12:19,059 --> 00:12:21,100
De uso de JDBC sin más

307
00:12:21,100 --> 00:12:21,720
¿Vale?

308
00:12:22,879 --> 00:12:24,480
Vale, eso sí

309
00:12:24,480 --> 00:12:26,440
Eso sí, lo que sí que hicimos

310
00:12:26,440 --> 00:12:29,059
Por supuesto que eso sí que nos tenemos que acostumbrar

311
00:12:29,059 --> 00:12:33,019
Que eso sí que nos tenemos que acostumbrar

312
00:12:33,019 --> 00:12:34,539
Es que uno puede hacer

313
00:12:34,539 --> 00:12:37,039
Un main, ahí, ah, alegremente

314
00:12:37,039 --> 00:12:38,220
Y hacer la aplicación, no, hombre

315
00:12:38,220 --> 00:12:40,419
tenemos que incorporar un patrón de diseño

316
00:12:40,419 --> 00:12:42,000
más o menos organizado, cuando hacemos

317
00:12:42,000 --> 00:12:44,659
patrones de diseño hay que meter, si no te queda una aplicación

318
00:12:44,659 --> 00:12:46,139
que nadie la quiere

319
00:12:46,139 --> 00:12:48,419
vale, entonces en esta aplicación

320
00:12:48,419 --> 00:12:50,480
de escritorio, simplemente para

321
00:12:50,480 --> 00:12:52,139
ilustrar, crear conexiones

322
00:12:52,139 --> 00:12:54,159
tanto únicas como pool de conexiones

323
00:12:54,159 --> 00:12:56,519
ejecutar sentencias, tanto sin precompilar

324
00:12:56,519 --> 00:12:57,759
como precompiladas y cerradas

325
00:12:57,759 --> 00:12:59,799
pues lo hicimos lógicamente

326
00:12:59,799 --> 00:13:02,159
con un patrón dado

327
00:13:02,159 --> 00:13:04,700
metiendo también un singleton

328
00:13:04,700 --> 00:13:06,460
para asegurarnos

329
00:13:06,460 --> 00:13:08,740
de que tanto la conexión

330
00:13:08,740 --> 00:13:11,259
como el patrón de conexiones eran únicos

331
00:13:11,259 --> 00:13:12,940
¿vale? entonces programamos

332
00:13:12,940 --> 00:13:14,799
el singleton, hicimos

333
00:13:14,799 --> 00:13:16,639
el DAO que sacaba ya la

334
00:13:16,639 --> 00:13:18,820
implementación del DAO, saca la

335
00:13:18,820 --> 00:13:20,679
conexión, en el DAO

336
00:13:20,679 --> 00:13:22,639
están los métodos que hacen el CRUD

337
00:13:22,639 --> 00:13:24,919
¿vale? y luego

338
00:13:24,919 --> 00:13:26,639
ya teníamos

339
00:13:26,639 --> 00:13:27,679
el servicio

340
00:13:27,679 --> 00:13:30,019
que ya es la clase

341
00:13:30,019 --> 00:13:32,879
que tiene las funcionalidades de la aplicación

342
00:13:32,879 --> 00:13:34,759
ya más

343
00:13:34,759 --> 00:13:36,419
en lenguaje natural, pues

344
00:13:36,419 --> 00:13:38,860
recuperar coches que se les ha roto una rueda

345
00:13:38,860 --> 00:13:40,659
eso no lo metes en el DAO, eso lo metes

346
00:13:40,659 --> 00:13:42,840
en el servicio, y ese método

347
00:13:42,840 --> 00:13:44,600
del servicio, recuperar coches

348
00:13:44,600 --> 00:13:46,320
a los que se les ha roto una rueda

349
00:13:46,320 --> 00:13:48,639
ese método del servicio ya sí que tiene

350
00:13:48,639 --> 00:13:50,639
que tirar del DAO, lógicamente, porque el DAO

351
00:13:50,639 --> 00:13:52,240
es el sota, caballo y rey, el cruz

352
00:13:52,240 --> 00:13:54,779
y bueno, algunas cosas más se hacen falta, recuperar

353
00:13:54,779 --> 00:13:56,740
por IDE, find by IDE, find all, lo que sea

354
00:13:56,740 --> 00:13:58,639
entonces, hombre, el patrón sí que

355
00:13:58,639 --> 00:14:00,600
lo hicimos, pero luego

356
00:14:00,600 --> 00:14:02,639
la parte de JDBC era la que

357
00:14:02,639 --> 00:14:04,580
estaba metida en el DAO implementación

358
00:14:04,580 --> 00:14:06,539
ahí metidita, crear la sentencia, lo que fuera

359
00:14:06,539 --> 00:14:08,519
y ya está, vale, entonces luego

360
00:14:08,519 --> 00:14:10,600
pasamos

361
00:14:10,600 --> 00:14:11,960
esto a una aplicación web

362
00:14:11,960 --> 00:14:13,480
vale

363
00:14:13,480 --> 00:14:15,940
con un serle

364
00:14:15,940 --> 00:14:18,600
y aquí ya es cuando ya me comprometí

365
00:14:18,600 --> 00:14:20,480
a que ya a partir de aquí ya suponía

366
00:14:20,480 --> 00:14:21,779
que todos entendíais

367
00:14:21,779 --> 00:14:24,580
lo que eran los serles y sus particularidades

368
00:14:24,580 --> 00:14:26,539
y ya no hacíamos más aplicaciones web

369
00:14:26,539 --> 00:14:28,580
con serles, vale, sino poniéndoles

370
00:14:28,580 --> 00:14:30,500
una capa para vagos por encima

371
00:14:30,500 --> 00:14:31,720
vale

372
00:14:31,720 --> 00:14:34,580
Entonces, aquí es donde os he dicho

373
00:14:34,580 --> 00:14:36,039
En esta aplicación que vimos

374
00:14:36,039 --> 00:14:37,659
Lo de los dos contextos de carga

375
00:14:37,659 --> 00:14:39,759
Porque tuvimos que hacer el class for name, etc

376
00:14:39,759 --> 00:14:41,620
¿Vale?

377
00:14:42,259 --> 00:14:44,320
Y aquí también nos sirvió

378
00:14:44,320 --> 00:14:46,019
Esta aplicación que también está escrito

379
00:14:46,019 --> 00:14:47,519
Como comentarios en el proyecto

380
00:14:47,519 --> 00:14:48,779
Nos sirvió esta aplicación

381
00:14:48,779 --> 00:14:52,460
Pues para recordar o revisar

382
00:14:52,460 --> 00:14:54,320
Los formularios

383
00:14:55,159 --> 00:14:55,980
HTML

384
00:14:55,980 --> 00:14:58,360
La diferencia entre get y post

385
00:14:58,360 --> 00:14:59,019
¿Vale?

386
00:14:59,019 --> 00:15:01,980
post cuando se producen actualizaciones

387
00:15:01,980 --> 00:15:02,820
en el servidor

388
00:15:02,820 --> 00:15:05,980
porque esas no se cachean

389
00:15:05,980 --> 00:15:06,820
entonces

390
00:15:06,820 --> 00:15:09,919
get cuando estamos haciendo consultas

391
00:15:09,919 --> 00:15:11,200
y más, pues

392
00:15:11,200 --> 00:15:13,360
en fin

393
00:15:13,360 --> 00:15:16,019
algunos detallitos de esos aprovechamos

394
00:15:16,019 --> 00:15:17,679
para verlos aquí

395
00:15:17,679 --> 00:15:20,059
vale, entonces una vez hecho esto

396
00:15:20,059 --> 00:15:21,799
fue donde dijimos que

397
00:15:21,799 --> 00:15:24,480
¿eh?

398
00:15:27,120 --> 00:15:28,080
¿qué decido?

399
00:15:28,080 --> 00:15:34,149
Pues una vez

400
00:15:34,149 --> 00:15:37,110
Hecho esto

401
00:15:37,110 --> 00:15:38,590
Fue cuando dijimos

402
00:15:38,590 --> 00:15:41,210
A ver, desde aquí ya empezamos a ver

403
00:15:41,210 --> 00:15:42,750
Qué farragoso

404
00:15:42,750 --> 00:15:44,350
Y qué pesado y qué todo

405
00:15:44,350 --> 00:15:45,269
Es

406
00:15:45,269 --> 00:15:48,009
Cosas como

407
00:15:48,009 --> 00:15:49,629
Sobre todo

408
00:15:49,629 --> 00:15:51,110
Convertir

409
00:15:51,110 --> 00:15:54,610
De los campos de mis results

410
00:15:54,610 --> 00:15:56,710
A los objetos

411
00:15:56,710 --> 00:15:58,769
Teníamos que hacerlo lógica de toda mano

412
00:15:58,769 --> 00:16:00,129
Instanciar el objeto

413
00:16:00,129 --> 00:16:02,669
sacar los campos con el

414
00:16:02,669 --> 00:16:04,389
result set de las consultas

415
00:16:04,389 --> 00:16:06,850
con cada campo setear la propiedad

416
00:16:06,850 --> 00:16:08,789
del objeto, eso ya era un rollo

417
00:16:08,789 --> 00:16:10,190
que teníamos que hacer a mano siempre

418
00:16:10,190 --> 00:16:12,450
que es lo que se llama el mapeo

419
00:16:12,450 --> 00:16:14,850
el mapeo objeto

420
00:16:14,850 --> 00:16:16,590
relacional, el mapeo objeto

421
00:16:16,590 --> 00:16:18,889
relacional es transformar

422
00:16:18,889 --> 00:16:20,889
los resultados de los

423
00:16:20,889 --> 00:16:23,070
campos de la consulta

424
00:16:23,070 --> 00:16:24,750
en propiedades del objeto

425
00:16:24,750 --> 00:16:26,669
pues ese mapeo hay que hacerlo a mano

426
00:16:26,669 --> 00:16:28,669
lógicamente cuando uno trabaja con JDBC

427
00:16:28,669 --> 00:16:31,850
Y además había ahí un montón de try-catch

428
00:16:31,850 --> 00:16:32,950
Porque lógicamente

429
00:16:32,950 --> 00:16:35,629
Si uno usa JDBC desde la base

430
00:16:35,629 --> 00:16:37,669
Ahí hay un montón de excepciones

431
00:16:37,669 --> 00:16:39,850
En tiempo de compilación

432
00:16:39,850 --> 00:16:40,649
Que hay que capturar

433
00:16:40,649 --> 00:16:42,250
Entonces hay un montón de try-catch

434
00:16:42,250 --> 00:16:45,149
Ahí también revisamos el try con recursos, etc.

435
00:16:46,370 --> 00:16:46,769
Vale

436
00:16:46,769 --> 00:16:48,470
Pues sí, muy pesado

437
00:16:48,470 --> 00:16:50,210
De desarrollar código JDBC

438
00:16:50,210 --> 00:16:51,289
Pero lógicamente

439
00:16:51,289 --> 00:16:53,789
Es el que nos permitiría

440
00:16:53,789 --> 00:16:55,309
Si solo usáramos JDBC

441
00:16:55,309 --> 00:16:56,909
Hacer la aplicación

442
00:16:56,909 --> 00:16:58,509
Perfecto

443
00:16:58,509 --> 00:16:59,389
Pero muy pesado.

444
00:16:59,990 --> 00:17:02,549
Entonces, primera capita que pusimos por encima.

445
00:17:04,309 --> 00:17:05,569
Spring JDBC.

446
00:17:06,630 --> 00:17:08,349
Entonces, al poner Spring JDBC,

447
00:17:09,950 --> 00:17:11,710
conseguíamos algunas cosas.

448
00:17:13,109 --> 00:17:17,710
Primera, poder crear unos mapeadores básicos,

449
00:17:18,529 --> 00:17:19,710
unos mapeadores básicos,

450
00:17:20,589 --> 00:17:22,890
que nos permitían decir,

451
00:17:23,069 --> 00:17:26,710
oye, espera, vamos a abrir esta aplicación,

452
00:17:26,710 --> 00:17:28,509
Esta aplicación, ahora ya sí que la vamos a abrir.

453
00:17:30,009 --> 00:17:32,950
Esta, que está aquí.

454
00:17:33,390 --> 00:17:37,089
Debe estar en 2023-2025.

455
00:17:38,569 --> 00:17:39,390
Web Developers.

456
00:17:39,470 --> 00:17:40,309
Aquí tiene que estar.

457
00:17:44,130 --> 00:17:45,130
Ahora lo digo.

458
00:17:45,529 --> 00:17:48,450
Porque con la aplicación abierta es más fácil de...

459
00:17:48,450 --> 00:18:01,720
¿Qué pasa?

460
00:18:03,940 --> 00:18:05,160
Sí, sí, a mí también.

461
00:18:05,160 --> 00:18:15,220
Que alguien está mirando la Fórmula 1

462
00:18:15,220 --> 00:18:22,500
Vale

463
00:18:22,500 --> 00:18:25,079
Esta

464
00:18:25,079 --> 00:18:27,900
Debía ser

465
00:18:27,900 --> 00:18:32,299
Debía ser esta de aquí

466
00:18:32,299 --> 00:18:34,180
A ver

467
00:18:34,180 --> 00:18:35,420
Un momento que la localice

468
00:18:35,420 --> 00:18:37,559
Pero

469
00:18:37,559 --> 00:18:58,670
Lo único que habíamos dicho de aquí, así muy rápido, era que con Spring JDBC incorporábamos este objeto que se asocia a una conexión, bien conexión única o bien pool de conexiones, a través de esta sentencia.

470
00:18:58,670 --> 00:19:01,509
esa instancia sí asociado a una conexión la que sea

471
00:19:01,509 --> 00:19:03,630
y luego el JDBC template

472
00:19:03,630 --> 00:19:06,410
pues se usa para ejecutar la sentencia sin más

473
00:19:06,410 --> 00:19:07,849
y si son queries

474
00:19:07,849 --> 00:19:09,930
si le damos un mapper

475
00:19:09,930 --> 00:19:12,970
además te lo transforma al objeto correspondiente

476
00:19:12,970 --> 00:19:15,609
pero ese mapper lo tenemos que haber creado nosotros

477
00:19:15,609 --> 00:19:18,549
lo tenemos que haber creado como nos dé la gana crearlo

478
00:19:18,549 --> 00:19:20,569
bueno

479
00:19:20,569 --> 00:19:22,049
entonces

480
00:19:22,049 --> 00:19:23,109
la otra

481
00:19:23,109 --> 00:19:25,549
ahora ya de nuevo

482
00:19:25,549 --> 00:19:27,349
como asunto de diseño

483
00:19:27,349 --> 00:19:29,710
Cuando uno gestiona las acciones que se van a hacer

484
00:19:29,710 --> 00:19:30,630
Sobre una base de datos

485
00:19:30,630 --> 00:19:33,849
Es importante identificar cuáles van en transacción

486
00:19:33,849 --> 00:19:35,029
¿Vale?

487
00:19:35,329 --> 00:19:37,269
Y de hecho con un ORM

488
00:19:37,269 --> 00:19:39,210
Que ya veremos después

489
00:19:39,210 --> 00:19:41,230
Se trabaja siempre

490
00:19:41,230 --> 00:19:44,009
Se puede trabajar fuera de una transacción

491
00:19:44,009 --> 00:19:45,589
Pero lo recomendable es

492
00:19:45,589 --> 00:19:48,009
Trabajar siempre dentro de transacciones

493
00:19:48,009 --> 00:19:49,549
Siempre, que esa transacción

494
00:19:49,549 --> 00:19:50,910
Tiene solo una sentencia SQL

495
00:19:50,910 --> 00:19:52,970
Vale, pero es una transacción

496
00:19:52,970 --> 00:19:55,150
Recordad que una transacción es

497
00:19:55,150 --> 00:20:01,089
Bueno

498
00:20:01,089 --> 00:20:03,549
Ya, pero bueno

499
00:20:03,549 --> 00:20:05,130
Como pauta de alguna manera de diseño

500
00:20:05,130 --> 00:20:06,650
Para evitar que te confundas

501
00:20:06,650 --> 00:20:09,210
Para habilitarte siempre la opción de un rollback

502
00:20:09,210 --> 00:20:10,190
Aunque

503
00:20:10,190 --> 00:20:16,839
Bueno

504
00:20:16,839 --> 00:20:17,940
Pero

505
00:20:17,940 --> 00:20:21,660
Siempre te vas a poder poner un rollback

506
00:20:21,660 --> 00:20:23,839
Si se ha ejecutado mal

507
00:20:23,839 --> 00:20:25,880
Esa sentencia porque ha dado una excepción

508
00:20:25,880 --> 00:20:26,920
Fuera de control

509
00:20:26,920 --> 00:20:28,900
entonces pues puedes hacer un rollback

510
00:20:28,900 --> 00:20:31,279
porque se supone que si ha habido una excepción

511
00:20:31,279 --> 00:20:32,960
esa sentencia no se habrá ejecutado

512
00:20:32,960 --> 00:20:35,119
pero oye, siempre puedes poner un rollback

513
00:20:35,119 --> 00:20:36,759
por si se hubiera ejecutado en parte

514
00:20:36,759 --> 00:20:37,559
que no creo

515
00:20:37,559 --> 00:20:40,460
entonces

516
00:20:40,460 --> 00:20:43,180
una transacción, recordad que es un conjunto

517
00:20:43,180 --> 00:20:45,220
de sentencias que necesitamos que o se hagan

518
00:20:45,220 --> 00:20:46,339
todas o no se hagan ninguna

519
00:20:46,339 --> 00:20:49,160
entonces si se hace la primera, la segunda y la tercera

520
00:20:49,160 --> 00:20:51,259
falla, entonces queremos

521
00:20:51,259 --> 00:20:52,799
que la primera y la segunda se anulen

522
00:20:52,799 --> 00:20:55,480
eso es una transacción, ¿vale? y ahí viene el concepto

523
00:20:55,480 --> 00:20:56,660
de rollback y commit

524
00:20:56,660 --> 00:20:59,359
Si cuando hay una transacción

525
00:20:59,359 --> 00:21:01,700
Se van ejecutando las sentencias SQL

526
00:21:01,700 --> 00:21:02,380
Una tras otra

527
00:21:02,380 --> 00:21:04,480
Pero en la base de datos no pasa nada

528
00:21:04,480 --> 00:21:07,500
No pasará algo hasta que no hagamos el commit final

529
00:21:07,500 --> 00:21:09,579
Entonces cuando se hace el commit final

530
00:21:09,579 --> 00:21:11,740
Cuando todas las SQL hemos verificado

531
00:21:11,740 --> 00:21:13,680
Que se han ejecutado

532
00:21:13,680 --> 00:21:14,599
Sin dar excepciones

533
00:21:14,599 --> 00:21:16,720
Si en alguna ha habido una excepción

534
00:21:16,720 --> 00:21:18,279
Se hará un rollback que significa

535
00:21:18,279 --> 00:21:20,400
Vuelve al principio de todo

536
00:21:20,400 --> 00:21:23,039
Con lo cual las SQL que sí que hiciste bien

537
00:21:23,039 --> 00:21:24,180
Sin excepción

538
00:21:24,180 --> 00:21:26,259
Besarlas, nada

539
00:21:26,259 --> 00:21:28,339
Bueno, pues entonces

540
00:21:28,339 --> 00:21:30,779
Para incorporar el poder

541
00:21:30,779 --> 00:21:32,539
Hacer transacciones, que es básico

542
00:21:32,539 --> 00:21:36,059
Seguimos utilizando Spring

543
00:21:36,059 --> 00:21:38,759
¿Vale? Para eso ya volvimos

544
00:21:38,759 --> 00:21:39,420
A un

545
00:21:39,420 --> 00:21:41,980
Proyecto de escritorio

546
00:21:41,980 --> 00:21:44,099
Que era este, ¿vale?

547
00:21:44,619 --> 00:21:46,839
Entonces este mismo de coches y de no sé qué

548
00:21:46,839 --> 00:21:48,779
Pues lo hicimos

549
00:21:48,779 --> 00:21:49,619
Con

550
00:21:49,619 --> 00:21:52,500
Spring en el escritorio

551
00:21:52,500 --> 00:21:54,140
Y era este

552
00:21:54,140 --> 00:21:57,759
Sería

553
00:21:57,759 --> 00:22:02,210
Ah, no, es que aquí estoy en

554
00:22:02,210 --> 00:22:03,869
Aquí

555
00:22:03,869 --> 00:22:05,569
Sería este

556
00:22:05,569 --> 00:22:07,769
Vale

557
00:22:07,769 --> 00:22:18,250
Pues aquí ya

558
00:22:18,250 --> 00:22:19,849
Ya incorporamos

559
00:22:19,849 --> 00:22:22,490
La gestión de bins de Spring

560
00:22:22,490 --> 00:22:24,490
¿Vale?

561
00:22:25,589 --> 00:22:26,529
Aprovechamos ya

562
00:22:26,529 --> 00:22:28,769
Este proyecto, que lo podríamos haber incorporado

563
00:22:28,769 --> 00:22:30,769
Antes también, porque son cosas independientes

564
00:22:30,769 --> 00:22:32,069
La gestión de bins de Spring

565
00:22:32,069 --> 00:22:33,390
Y el Spring JDBC

566
00:22:33,390 --> 00:22:34,569
Y son cosas independientes

567
00:22:34,569 --> 00:22:36,970
Pero bueno

568
00:22:36,970 --> 00:22:39,170
ahí no lo habíamos incorporado todavía, lo incorporamos aquí

569
00:22:39,170 --> 00:22:42,579
entonces

570
00:22:42,579 --> 00:22:45,539
repito, además de en sí

571
00:22:45,539 --> 00:22:47,539
el uso de las transacciones

572
00:22:47,539 --> 00:22:48,940
que era para anotaciones y ya está

573
00:22:48,940 --> 00:22:51,259
incorporamos, ya que usábamos

574
00:22:51,259 --> 00:22:52,440
Spring y el Spring Core

575
00:22:52,440 --> 00:22:55,240
la dependencia de, o sea, la gestión

576
00:22:55,240 --> 00:22:56,000
de bins de Spring

577
00:22:56,000 --> 00:22:59,059
y la gestión de bins de Spring

578
00:22:59,059 --> 00:23:00,220
¿qué nos ahorraba?

579
00:23:01,119 --> 00:23:03,259
nos ahorraba dejar de instanciar

580
00:23:03,259 --> 00:23:05,200
cosas para inyectárselas a quien las

581
00:23:05,200 --> 00:23:05,799
necesita

582
00:23:05,799 --> 00:23:08,799
es lo que se llama

583
00:23:08,799 --> 00:23:11,380
la inversión de control

584
00:23:11,380 --> 00:23:29,359
es decir, cuando hacemos

585
00:23:29,359 --> 00:23:31,339
las aplicaciones sin la gestión

586
00:23:31,339 --> 00:23:32,440
de bins de sprint

587
00:23:32,440 --> 00:23:34,099
tenemos

588
00:23:34,099 --> 00:23:36,099
sí, tenemos

589
00:23:36,099 --> 00:23:39,200
hablando de JDBC

590
00:23:39,200 --> 00:23:41,160
o de acceso a datos

591
00:23:41,160 --> 00:23:42,200
como estamos hablando nosotros

592
00:23:42,200 --> 00:23:44,359
tenemos la conexión o el pool

593
00:23:44,359 --> 00:23:47,140
el DAO que necesita la conexión

594
00:23:47,140 --> 00:23:48,880
o el pool, el servicio

595
00:23:48,880 --> 00:23:50,500
que necesita el DAO

596
00:23:50,500 --> 00:23:53,519
la aplicación, sea la que sea

597
00:23:53,519 --> 00:23:54,740
que necesita el servicio

598
00:23:54,740 --> 00:24:10,140
O sea, tenemos ya una cadena de necesidades, unos se necesitan a otros y nosotros, si no usamos la gestión de sprint, tenemos que preocuparnos de instanciar todos los objetos de esa cadena para que la aplicación al final funcione.

599
00:24:10,140 --> 00:24:11,960
Tenemos que instanciar la conexión

600
00:24:11,960 --> 00:24:14,640
Tenemos que instanciar el DAO

601
00:24:14,640 --> 00:24:16,119
Tenemos que instanciar el servicio

602
00:24:16,119 --> 00:24:18,759
Para que recoja el DAO

603
00:24:18,759 --> 00:24:20,539
Tenemos que instanciar la aplicación

604
00:24:20,539 --> 00:24:21,980
Que recoja el servicio, en fin

605
00:24:21,980 --> 00:24:24,759
Pues eso nos desborda

606
00:24:24,759 --> 00:24:26,220
Entonces, ¿qué hacemos?

607
00:24:26,900 --> 00:24:28,880
Le cedemos el control

608
00:24:28,880 --> 00:24:31,140
De la instancia

609
00:24:31,140 --> 00:24:32,900
De la instanciación de objetos

610
00:24:32,900 --> 00:24:34,740
Le cedemos el control

611
00:24:34,740 --> 00:24:35,380
A Spring

612
00:24:35,380 --> 00:24:37,980
Y eso es lo que se llama

613
00:24:37,980 --> 00:24:40,119
hacer la inversión

614
00:24:40,119 --> 00:24:40,680
de control

615
00:24:40,680 --> 00:24:44,980
le cedemos el control

616
00:24:44,980 --> 00:24:46,000
por eso

617
00:24:46,000 --> 00:24:50,099
el corazón de sprint

618
00:24:50,099 --> 00:24:53,900
es que no sé cómo se dice esto en inglés

619
00:24:53,900 --> 00:24:55,839
es el inversor de control o algo así

620
00:24:55,839 --> 00:24:57,920
el corazón de sprint es el

621
00:24:57,920 --> 00:24:59,539
que se llama el inversor de control

622
00:24:59,539 --> 00:25:00,619
que no sé cómo se dice en inglés

623
00:25:00,619 --> 00:25:03,180
pues inversión

624
00:25:03,180 --> 00:25:04,519
que feo ¿no?

625
00:25:05,220 --> 00:25:06,460
inversión of control

626
00:25:06,460 --> 00:25:07,960
muy feo pero vale

627
00:25:07,960 --> 00:25:10,140
bueno, pues el inversor de control

628
00:25:10,140 --> 00:25:11,720
es el

629
00:25:11,720 --> 00:25:13,660
es que no sería

630
00:25:13,660 --> 00:25:15,880
control inversor o algo así, es el más bonito

631
00:25:15,880 --> 00:25:17,019
no sé, bueno, da igual

632
00:25:17,019 --> 00:25:21,339
no mandamos en eso, ¿no?

633
00:25:23,680 --> 00:25:25,079
el IOC, pues este

634
00:25:25,079 --> 00:25:29,579
entonces, este es el corazón

635
00:25:29,579 --> 00:25:31,559
de Sprint, en realidad, del que todo

636
00:25:31,559 --> 00:25:33,660
nació, luego a partir de ahí empezaron a meterse

637
00:25:33,660 --> 00:25:35,599
ahí morraya para aburrir, pero el corazón fue

638
00:25:35,599 --> 00:25:37,480
este, que es, no te

639
00:25:37,480 --> 00:25:39,200
preocupes, yo soy una clase

640
00:25:39,200 --> 00:25:41,359
maravillosa, soy una clase estupenda

641
00:25:41,359 --> 00:25:43,099
que según vea

642
00:25:43,099 --> 00:25:45,299
tú vas a instanciar

643
00:25:45,299 --> 00:25:47,380
lo último, el servicio por ejemplo

644
00:25:47,380 --> 00:25:49,740
que es el último

645
00:25:49,740 --> 00:25:51,579
tú instancias, no, más que

646
00:25:51,579 --> 00:25:53,680
instancia, tú pídeme el servicio, tú pídemelo

647
00:25:53,680 --> 00:25:55,500
a mí, y yo cuando tú

648
00:25:55,500 --> 00:25:57,779
me lo pidas, me ocuparé de instanciarlo

649
00:25:57,779 --> 00:25:59,299
que veo que el servicio te ha dado un dado

650
00:25:59,299 --> 00:26:01,420
instancia el dado, que veo que el dado te ha dado

651
00:26:01,420 --> 00:26:03,279
una conexión, instancia la conexión, o sea

652
00:26:03,279 --> 00:26:05,380
yo ya me ocuparé de instanciar

653
00:26:05,380 --> 00:26:07,460
todo lo que haga falta, tú pídeme lo que quieres

654
00:26:07,460 --> 00:26:10,599
entonces le cedemos el control a él

655
00:26:10,599 --> 00:26:12,559
al inversor de control

656
00:26:12,559 --> 00:26:14,960
vale, pero hay que configurarle

657
00:26:14,960 --> 00:26:16,920
hay que decirle cuáles son

658
00:26:16,920 --> 00:26:18,819
los beams que él va a tener

659
00:26:18,819 --> 00:26:20,759
que controlar e instanciar cuando le

660
00:26:20,759 --> 00:26:22,859
hagan falta, vamos a tener que configurarlo

661
00:26:22,859 --> 00:26:24,880
eso era lo

662
00:26:24,880 --> 00:26:26,720
que antiguamente pues se hacía con un

663
00:26:26,720 --> 00:26:28,559
xml o no sé si muy

664
00:26:28,559 --> 00:26:30,359
antiguamente, pero bueno, ya no aplica

665
00:26:30,359 --> 00:26:33,019
un fichero beams xml para marcarlo

666
00:26:33,019 --> 00:26:34,500
o

667
00:26:34,500 --> 00:26:36,700
se hace con anotaciones

668
00:26:36,700 --> 00:26:38,660
dentro del código Java que es lo habitual

669
00:26:38,660 --> 00:26:40,819
entonces

670
00:26:40,819 --> 00:26:42,700
hablo antes de Spring Boot

671
00:26:42,700 --> 00:26:43,960
bueno

672
00:26:43,960 --> 00:26:45,900
antes de Spring Boot

673
00:26:45,900 --> 00:26:47,759
había

674
00:26:47,759 --> 00:26:50,299
y puede seguir habiendo

675
00:26:50,299 --> 00:26:52,440
una clase en la cual

676
00:26:52,440 --> 00:26:54,000
tú marcas

677
00:26:54,000 --> 00:26:56,660
los objetos que Spring

678
00:26:56,660 --> 00:26:57,900
va a tener que instanciar

679
00:26:57,900 --> 00:27:00,480
y le dices como instanciarlo porque hombre

680
00:27:00,480 --> 00:27:01,380
el tan listo no va a ser

681
00:27:01,380 --> 00:27:04,480
entonces por ejemplo como aquí

682
00:27:04,480 --> 00:27:06,259
ya en esta aplicación de transacciones

683
00:27:06,259 --> 00:27:08,599
estábamos usando Spring y el inversor de control,

684
00:27:09,380 --> 00:27:12,259
pues teníamos esta clase, esta clase de aquí,

685
00:27:13,279 --> 00:27:20,700
donde yo empiezo a crear, a anotar con bin e indicar los

686
00:27:20,700 --> 00:27:25,140
objetos que Spring va a necesitar instanciar.

687
00:27:25,720 --> 00:27:31,339
Pues un data source, el pool, pues este puede que ni te

688
00:27:31,339 --> 00:27:31,960
instanciarlo.

689
00:27:32,440 --> 00:27:35,660
Si mi DAO usa el pool, si mi DAO usa el pool, pues nada,

690
00:27:35,660 --> 00:27:38,819
Yo le instancio y le digo cómo, ¿vale?

691
00:27:40,779 --> 00:27:44,619
Aquí yo estoy sacando las propiedades,

692
00:27:44,740 --> 00:27:46,400
lógicamente para la conexión,

693
00:27:46,980 --> 00:27:48,900
las estoy sacando de un archivo de propiedades.

694
00:27:50,000 --> 00:27:52,339
Aquí lo estoy haciendo a pelo, a lo bestia,

695
00:27:52,440 --> 00:27:53,599
sacándolo con el properties.

696
00:27:54,680 --> 00:27:56,779
Spring te ofrece también una posibilidad

697
00:27:56,779 --> 00:27:59,779
de sacar las propiedades de un properties más fácilmente,

698
00:27:59,880 --> 00:28:03,059
pero bueno, eso en el siguiente proyecto lo incorporamos, ¿vale?

699
00:28:03,059 --> 00:28:05,720
las anotas y él ya

700
00:28:05,720 --> 00:28:07,720
por la anotación asume que las tiene que buscar

701
00:28:07,720 --> 00:28:09,539
en el property, pero bueno, solo en commerce no necesitan

702
00:28:09,539 --> 00:28:11,440
proyectos, vale, pues entonces

703
00:28:11,440 --> 00:28:13,839
oye tú, sprint, inversor de control

704
00:28:13,839 --> 00:28:15,599
que puede que necesites instanciar

705
00:28:15,599 --> 00:28:17,539
tú en algún momento porque yo

706
00:28:17,539 --> 00:28:19,119
porque haga falta este

707
00:28:19,119 --> 00:28:21,640
cuando necesites hazlo así, vale, este era

708
00:28:21,640 --> 00:28:23,819
el pool, vale, ¿qué más?

709
00:28:24,140 --> 00:28:25,619
oye, puede que necesites instanciar un

710
00:28:25,619 --> 00:28:27,500
template, pues cuando necesites

711
00:28:27,500 --> 00:28:29,480
hazlo así, vale

712
00:28:29,480 --> 00:28:31,019
puede que necesites instanciar

713
00:28:31,019 --> 00:28:33,039
un gestor de transacciones

714
00:28:33,039 --> 00:28:35,039
porque esta aplicación tenía transacciones

715
00:28:35,039 --> 00:28:37,460
pues cuando lo tengas que instanciar

716
00:28:37,460 --> 00:28:39,059
el gestor de transacciones

717
00:28:39,059 --> 00:28:40,980
que estará siempre asociado a un data source

718
00:28:40,980 --> 00:28:42,480
lógicamente instanciarlo así

719
00:28:42,480 --> 00:28:44,299
bueno, pues estos serán

720
00:28:44,299 --> 00:28:47,000
los tres únicos bin

721
00:28:47,000 --> 00:28:48,180
que había en esta clase

722
00:28:48,180 --> 00:28:50,519
y ahora me diréis

723
00:28:50,519 --> 00:28:53,339
pero bueno, también va a necesitar

724
00:28:53,339 --> 00:28:54,960
la aplicación instanciar el DAO

725
00:28:54,960 --> 00:28:56,720
instanciar el servicio, que menos

726
00:28:56,720 --> 00:28:59,619
claro, pero es que no hace falta ponerlos aquí

727
00:28:59,619 --> 00:29:01,420
yo puedo

728
00:29:01,420 --> 00:29:03,019
como esas clases

729
00:29:03,019 --> 00:29:05,200
tanto el DAO como el servicio

730
00:29:05,200 --> 00:29:08,720
tienen una personalidad propia muy particular

731
00:29:08,720 --> 00:29:11,440
el DAO es un repositorio

732
00:29:11,440 --> 00:29:14,839
un repositorio es todo aquello que me permite

733
00:29:14,839 --> 00:29:17,180
recuperar datos o consultarlos

734
00:29:17,180 --> 00:29:21,079
y el servicio es todo aquello que me permite hacer cosas

735
00:29:21,079 --> 00:29:23,579
¿vale? pues tienen esa personalidad

736
00:29:23,579 --> 00:29:26,019
la clase servicio me permite hacer cosas

737
00:29:26,019 --> 00:29:29,339
la clase DAO me permite trabajar con datos

738
00:29:29,339 --> 00:29:32,400
tiene una propia personalidad, la clase DAO es un repositorio

739
00:29:32,400 --> 00:29:35,900
y la clase servicio es un servicio.

740
00:29:37,819 --> 00:29:41,400
Entonces, Sprint te ofrece unas anotaciones propias

741
00:29:41,400 --> 00:29:42,339
para esas clases.

742
00:29:43,339 --> 00:29:43,940
Exacto.

743
00:29:44,420 --> 00:29:46,240
Entonces, en el DAO implementación,

744
00:29:46,619 --> 00:29:47,220
este de aquí,

745
00:29:48,500 --> 00:29:50,119
le poníamos esta anotación.

746
00:29:51,180 --> 00:29:53,559
Esta anotación sustituye

747
00:29:53,559 --> 00:29:57,200
hacer el bin en la clase configuración.

748
00:29:57,880 --> 00:29:58,599
La sustituye.

749
00:29:59,099 --> 00:30:00,359
Yo podría no poner esto,

750
00:30:00,819 --> 00:30:02,140
pero entonces me tengo que hacer

751
00:30:02,140 --> 00:30:05,019
aquí en conexión

752
00:30:05,019 --> 00:30:06,079
un get

753
00:30:06,079 --> 00:30:08,670
¿vale?

754
00:30:09,710 --> 00:30:12,049
para este, con un return new

755
00:30:12,049 --> 00:30:13,150
data no sé qué

756
00:30:13,150 --> 00:30:16,369
un return new con el implementación

757
00:30:16,369 --> 00:30:18,009
en el siguiente proyecto está puesto así

758
00:30:18,009 --> 00:30:19,509
entonces

759
00:30:19,509 --> 00:30:22,410
si yo no tengo aquí un bin que me permite

760
00:30:22,410 --> 00:30:24,710
recuperar, que me permite recuperar

761
00:30:24,710 --> 00:30:26,329
así con un return new no sé qué

762
00:30:26,329 --> 00:30:28,210
que me permite recuperar el venta

763
00:30:28,210 --> 00:30:30,250
de la implementación, entonces tengo

764
00:30:30,250 --> 00:30:31,130
que anotarlo aquí

765
00:30:31,130 --> 00:30:33,170
¿vale?

766
00:30:33,710 --> 00:30:42,910
Entonces, anotándolo aquí, además, además, le hago ser repositorio, que algunas particularidades le darán.

767
00:30:44,789 --> 00:30:51,490
Bueno, pues nada, este era mi repositorio con los métodos, esto estaba, ¿vale?

768
00:30:51,490 --> 00:30:54,470
vea entrada a implementación

769
00:30:54,470 --> 00:30:55,230
y aquí

770
00:30:55,230 --> 00:30:57,109
pusimos

771
00:30:57,109 --> 00:30:59,769
como esta aplicación era

772
00:30:59,769 --> 00:31:01,230
precisamente para

773
00:31:01,230 --> 00:31:03,509
escenificar, para

774
00:31:03,509 --> 00:31:05,950
ejemplificar lo de las transacciones

775
00:31:05,950 --> 00:31:07,930
nos inventamos

776
00:31:07,930 --> 00:31:10,450
un método

777
00:31:10,450 --> 00:31:11,769
del DAO implementación

778
00:31:11,769 --> 00:31:13,970
que necesitaba hacerse en transacción

779
00:31:13,970 --> 00:31:16,190
que era cambiar en el

780
00:31:16,190 --> 00:31:17,849
escaparate un coche por otro

781
00:31:17,849 --> 00:31:19,750
entonces

782
00:31:19,750 --> 00:31:22,130
o se hacían las dos

783
00:31:22,130 --> 00:31:25,609
es decir, que era marcar

784
00:31:25,609 --> 00:31:26,650
que este coche

785
00:31:26,650 --> 00:31:28,789
no estuviera en el escaparate

786
00:31:28,789 --> 00:31:30,569
y que este ya sí lo estuviera

787
00:31:30,569 --> 00:31:32,549
o se hacían las dos o ninguna

788
00:31:32,549 --> 00:31:34,950
porque si se hace solo una de las dos

789
00:31:34,950 --> 00:31:37,690
podría ocurrir que aparezcan los dos coches en el escaparate

790
00:31:37,690 --> 00:31:39,349
que no puede ocurrir o que no aparezca ninguno

791
00:31:39,349 --> 00:31:41,529
y se quede vacío, que no puede ocurrir, siempre tiene que haber uno

792
00:31:41,529 --> 00:31:42,650
siempre tiene que haber uno

793
00:31:42,650 --> 00:31:44,329
entonces este método

794
00:31:44,329 --> 00:31:46,769
es un método que tiene que hacer el transacción

795
00:31:46,769 --> 00:31:47,690
vale

796
00:31:47,690 --> 00:31:50,329
¿Hacemos aquí algo

797
00:31:50,329 --> 00:31:53,329
Para indicar que esto es transacción?

798
00:31:53,569 --> 00:31:53,970
No

799
00:31:53,970 --> 00:31:56,869
Porque esto se marca en el servicio

800
00:31:56,869 --> 00:31:58,049
¿Vale?

801
00:31:59,269 --> 00:32:00,069
Es decir

802
00:32:00,069 --> 00:32:03,390
La implementación del DAO tiene la capa de servicio por encima

803
00:32:03,390 --> 00:32:05,009
Que es la que ya llama la aplicación

804
00:32:05,009 --> 00:32:06,730
Y ahí es donde hay que decidir

805
00:32:06,730 --> 00:32:08,069
Que es transacción y que no

806
00:32:08,069 --> 00:32:14,609
Pero no lo vas a hacer

807
00:32:14,609 --> 00:32:16,730
¿Vale?

808
00:32:17,789 --> 00:32:18,269
Entonces

809
00:32:18,269 --> 00:32:20,690
ahora ya teníamos el servicio

810
00:32:20,690 --> 00:32:23,170
el servicio que estaba por aquí abajo

811
00:32:23,170 --> 00:32:26,410
este servicio de nuevo

812
00:32:26,410 --> 00:32:28,789
anotado así, porque si no tenemos

813
00:32:28,789 --> 00:32:30,750
que hacer un bin en la configuración

814
00:32:30,750 --> 00:32:32,609
en la clase de configuración

815
00:32:32,609 --> 00:32:34,410
en esta clase de conexión que hemos hecho

816
00:32:34,410 --> 00:32:36,470
vale, pues aquí

817
00:32:36,470 --> 00:32:38,450
estaban los servicios que fueran

818
00:32:38,450 --> 00:32:40,849
en particular este que llamaba

819
00:32:40,849 --> 00:32:41,509
este de aquí

820
00:32:41,509 --> 00:32:45,170
y ahora, aquí sí que le anotábamos

821
00:32:45,170 --> 00:32:45,809
de esta manera

822
00:32:45,809 --> 00:32:47,769
entonces anotándolo

823
00:32:47,769 --> 00:32:49,869
de esta manera, esto se ejecuta

824
00:32:49,869 --> 00:32:50,829
en modo transacción

825
00:32:50,829 --> 00:32:52,450
que significa

826
00:32:52,450 --> 00:32:55,630
no abro y cierro la conexión por cada

827
00:32:55,630 --> 00:32:57,630
sentencia, que es lo que se hace

828
00:32:57,630 --> 00:32:59,509
que es lo que se haría

829
00:32:59,509 --> 00:33:00,890
si no estuviera en modo transacción

830
00:33:00,890 --> 00:33:03,230
si estuviéramos en modo transacción

831
00:33:03,230 --> 00:33:04,670
esto

832
00:33:04,670 --> 00:33:07,490
abriría conexión y la cerraría

833
00:33:07,490 --> 00:33:09,549
con lo cual se haría el cómic automático

834
00:33:09,549 --> 00:33:12,150
esto abriría conexión y la cerraría

835
00:33:12,150 --> 00:33:13,650
con lo cual se haría el cómic automático

836
00:33:13,650 --> 00:33:15,769
no, desde el momento

837
00:33:15,769 --> 00:33:17,490
en que ponemos esto

838
00:33:17,490 --> 00:33:18,890
con transactional

839
00:33:18,890 --> 00:33:22,089
la conexión permanece abierta

840
00:33:22,089 --> 00:33:24,170
todo el tiempo de vida del servicio

841
00:33:24,170 --> 00:33:25,589
todo el tiempo de vida

842
00:33:25,589 --> 00:33:27,690
que esto luego va a tener más implicaciones

843
00:33:27,690 --> 00:33:29,049
con el ORM como ya veremos

844
00:33:29,049 --> 00:33:30,569
transactional significa

845
00:33:30,569 --> 00:33:33,990
abierta la conexión

846
00:33:33,990 --> 00:33:35,869
todo el rato hasta que no termines

847
00:33:35,869 --> 00:33:37,210
todo esto no la cierres

848
00:33:37,210 --> 00:33:39,950
que nos permite eso, hacer commit o rollback

849
00:33:39,950 --> 00:33:41,069
si hace falta

850
00:33:41,069 --> 00:33:43,750
vale, pues aquí ya vamos a cambiar este aparate

851
00:33:43,750 --> 00:33:45,690
forzamos un fallo

852
00:33:45,690 --> 00:33:48,109
para ver que

853
00:33:48,109 --> 00:33:50,289
se hacía el rollback.

854
00:33:50,829 --> 00:33:50,930
¿Vale?

855
00:33:52,589 --> 00:33:54,250
Claro, si hay un fallo

856
00:33:54,250 --> 00:33:55,450
se hace el rollback automáticamente.

857
00:33:55,950 --> 00:33:58,069
Y si no, se hace el commit automáticamente

858
00:33:58,069 --> 00:33:59,210
al terminar el servicio.

859
00:33:59,990 --> 00:34:00,190
¿Vale?

860
00:34:02,390 --> 00:34:03,730
Pues entonces, de aquí

861
00:34:03,730 --> 00:34:05,289
no había nada más.

862
00:34:05,970 --> 00:34:07,690
Lo de la gestión de bins

863
00:34:07,690 --> 00:34:10,510
con el sprint normal y corriente.

864
00:34:11,750 --> 00:34:12,989
Las anotaciones

865
00:34:12,989 --> 00:34:13,869
y ya está.

866
00:34:13,869 --> 00:34:16,590
porque el modelo no tenía nada

867
00:34:16,590 --> 00:34:18,090
vale

868
00:34:18,090 --> 00:34:21,030
como veis

869
00:34:21,030 --> 00:34:22,590
esto

870
00:34:22,590 --> 00:34:24,369
ni se anota

871
00:34:24,369 --> 00:34:25,489
la clase de modelo

872
00:34:25,489 --> 00:34:28,369
ni aparece como bin en conexión

873
00:34:28,369 --> 00:34:30,429
porque los objetos

874
00:34:30,429 --> 00:34:32,449
del modelo no los gestiona

875
00:34:32,449 --> 00:34:34,670
Spring, eso lo gestiona la aplicación

876
00:34:34,670 --> 00:34:36,429
porque es la que hace las cosas con los objetos

877
00:34:36,429 --> 00:34:37,690
ahora tengo una lista de no se que

878
00:34:37,690 --> 00:34:40,489
Spring gestiona los objetos de alguna manera

879
00:34:40,489 --> 00:34:42,170
de acceso a datos

880
00:34:42,170 --> 00:34:45,469
los de trabajo con la base de datos,

881
00:34:45,590 --> 00:34:46,869
no los de negocio,

882
00:34:46,969 --> 00:34:48,190
no los de la lógica de negocio,

883
00:34:48,289 --> 00:34:49,409
esos no los gestiona Spring.

884
00:34:55,769 --> 00:34:56,690
Hombre, podrías poner,

885
00:34:56,849 --> 00:34:57,610
podrías anotarlo,

886
00:34:57,769 --> 00:35:01,030
no va a pasar nada, ¿vale?

887
00:35:01,510 --> 00:35:03,230
Entonces, en esta clase de conexión

888
00:35:03,230 --> 00:35:04,969
y ya paramos un segundito,

889
00:35:05,630 --> 00:35:07,170
pues había que decir además,

890
00:35:07,670 --> 00:35:08,469
cuidado con esto,

891
00:35:08,590 --> 00:35:09,349
bueno, primero decir

892
00:35:09,349 --> 00:35:11,530
que era una clase de configuración de Spring,

893
00:35:12,090 --> 00:35:13,210
había que decir que era una clase,

894
00:35:13,949 --> 00:35:15,449
había que decir a partir

895
00:35:15,449 --> 00:35:18,489
de qué árbol de jerarquía

896
00:35:18,489 --> 00:35:19,130
del paquete

897
00:35:19,130 --> 00:35:22,710
él tiene que buscar clases anotadas

898
00:35:22,710 --> 00:35:23,929
¿por qué?

899
00:35:24,369 --> 00:35:25,989
y de verdad que ya me callo, pero el gente

900
00:35:25,989 --> 00:35:27,230
dejarlo a medias no mola

901
00:35:27,230 --> 00:35:30,110
porque esta está anotada

902
00:35:30,110 --> 00:35:31,969
con repositorio, entonces Spring

903
00:35:31,969 --> 00:35:33,889
la tiene que detectar él solito

904
00:35:33,889 --> 00:35:34,829
la tiene que detectar

905
00:35:34,829 --> 00:35:38,110
esta está anotada, la tiene que detectar

906
00:35:38,110 --> 00:35:40,389
entonces es imprescindible

907
00:35:40,389 --> 00:35:41,849
hacer un component scan

908
00:35:41,849 --> 00:35:44,070
para decirle, oye, aparte de los bin

909
00:35:44,070 --> 00:35:45,989
que te doy yo a mano, que están todos aquí a mano

910
00:35:45,989 --> 00:35:48,090
dados, aparte de estos, busca

911
00:35:48,090 --> 00:35:50,030
tú, no vaya a ser que haya repositor

912
00:35:50,030 --> 00:35:50,829
y service

913
00:35:50,829 --> 00:35:53,769
controller, algunos otros que pueda haber por ahí

914
00:35:53,769 --> 00:35:55,809
búscalos a partir de

915
00:35:55,809 --> 00:35:57,889
esta raíz, y él se mete en todos los

916
00:35:57,889 --> 00:35:59,969
paquetes que hay ahí y los detecta

917
00:35:59,969 --> 00:36:01,489
si yo tuviera

918
00:36:01,489 --> 00:36:03,510
todos los bins

919
00:36:03,510 --> 00:36:05,550
puestos aquí, bin, bin, bin, bin, bin, bin

920
00:36:05,550 --> 00:36:07,829
el component scan no haría falta porque Spring no tiene que

921
00:36:07,829 --> 00:36:08,889
detectar nada al solito

922
00:36:08,889 --> 00:36:11,809
¿vale? y bueno, esto lo pusimos

923
00:36:11,809 --> 00:36:13,469
porque íbamos a habilitar

924
00:36:13,469 --> 00:36:16,030
el uso de esta

925
00:36:16,030 --> 00:36:17,949
transacción, de esta anotación

926
00:36:17,949 --> 00:36:18,750
transaccional

927
00:36:18,750 --> 00:36:20,090
¿vale?

928
00:36:21,469 --> 00:36:22,150
aquí

929
00:36:22,150 --> 00:36:30,619
aquí se ha hecho

930
00:36:30,619 --> 00:36:32,019
una inyección

931
00:36:32,019 --> 00:36:33,980
esto es una inyección

932
00:36:33,980 --> 00:36:35,059
lógicamente

933
00:36:35,059 --> 00:36:38,460
clavada

934
00:36:38,460 --> 00:36:40,380
¿no? que es para crear

935
00:36:40,380 --> 00:36:42,340
un objeto necesito

936
00:36:42,340 --> 00:36:44,760
otro, esto es el concepto de inyección

937
00:36:44,760 --> 00:36:46,360
para crear un objeto

938
00:36:46,360 --> 00:36:47,460
por favor dame otro

939
00:36:47,460 --> 00:36:50,000
esto es lo que Spring llama

940
00:36:50,000 --> 00:36:52,480
inyección por constructor

941
00:36:52,480 --> 00:36:56,420
que es lo que hemos hecho siempre

942
00:36:56,420 --> 00:36:58,039
que el constructor

943
00:36:58,039 --> 00:36:59,260
reciba

944
00:36:59,260 --> 00:37:02,260
el objeto

945
00:37:02,260 --> 00:37:04,119
¿vale? y ya es instable

946
00:37:04,119 --> 00:37:05,780
pero Spring todavía

947
00:37:05,780 --> 00:37:08,019
pues lo hace más, hay una anotación

948
00:37:08,019 --> 00:37:09,119
lo digo por si lo veis por aquí

949
00:37:09,119 --> 00:37:11,320
que se usa bastante habitualmente

950
00:37:11,320 --> 00:37:13,679
te quitas el constructor directamente

951
00:37:13,679 --> 00:37:16,300
y marcas esta propiedad

952
00:37:16,300 --> 00:37:18,239
con una anotación

953
00:37:18,239 --> 00:37:19,960
que es auto-wire, o sea, auto-cableada.

954
00:37:20,900 --> 00:37:21,920
Lo marcas así.

955
00:37:29,130 --> 00:37:29,610
Wired.

956
00:37:30,610 --> 00:37:30,969
¿Vale?

957
00:37:32,550 --> 00:37:33,570
Creo que era esta.

958
00:37:35,889 --> 00:37:36,789
Esta, ¿vale?

959
00:37:37,449 --> 00:37:38,010
Entonces,

960
00:37:38,610 --> 00:37:40,510
esto, cuando Spring

961
00:37:40,510 --> 00:37:41,869
ve que una propiedad está

962
00:37:41,869 --> 00:37:43,530
auto-cableada,

963
00:37:44,630 --> 00:37:46,750
cuando instancias un objeto de esto,

964
00:37:47,050 --> 00:37:48,750
¡pum!, te lo instancia

965
00:37:48,750 --> 00:37:50,469
automáticamente para meterla aquí.

966
00:37:52,150 --> 00:37:52,710
¿Vale?

967
00:37:52,730 --> 00:37:55,809
Con lo cual

968
00:37:55,809 --> 00:37:56,170
No

969
00:37:56,170 --> 00:37:59,030
Puedes llamar al constructor sin parámetros

970
00:37:59,030 --> 00:38:00,750
¿Vale?

971
00:38:01,030 --> 00:38:02,769
Puedes llamar al constructor sin parámetros

972
00:38:02,769 --> 00:38:03,530
Porque Spring

973
00:38:03,530 --> 00:38:05,530
Con las que vea que están autocableadas

974
00:38:05,530 --> 00:38:05,849
Pim

975
00:38:05,849 --> 00:38:06,750
De las instancias

976
00:38:06,750 --> 00:38:08,349
Cuando las necesita

977
00:38:08,349 --> 00:38:09,449
Y las pone ahí

978
00:38:09,449 --> 00:38:10,610
¿Vale?

979
00:38:15,130 --> 00:38:15,570
Sí

980
00:38:15,570 --> 00:38:16,550
Pero el bin

981
00:38:16,550 --> 00:38:18,929
Una cosa es que vea

982
00:38:18,929 --> 00:38:20,550
Él hace el view y dice

983
00:38:20,550 --> 00:38:20,809
Ah

984
00:38:20,809 --> 00:38:22,849
necesito aquí

985
00:38:22,849 --> 00:38:25,469
uno para meterlo, entonces te lo instancia

986
00:38:25,469 --> 00:38:27,389
al solito y lo vas inyectando por constructor

987
00:38:27,389 --> 00:38:29,670
aquí lo inyecta en otro momento

988
00:38:29,670 --> 00:38:31,289
¿vale?

989
00:38:31,309 --> 00:38:32,630
aquí instancia el objeto

990
00:38:32,630 --> 00:38:34,650
y la primera vez que lo usa

991
00:38:34,650 --> 00:38:37,110
vale, instancia

992
00:38:37,110 --> 00:38:39,289
¿vale? no sé si es exactamente así

993
00:38:39,289 --> 00:38:41,289
pero bueno, sobre todo es una cosa

994
00:38:41,289 --> 00:38:43,230
a nivel de código ¿vale?

995
00:38:45,570 --> 00:38:47,650
entonces, el inyectarlo

996
00:38:47,650 --> 00:38:49,690
por constructor te permitiría

997
00:38:49,690 --> 00:38:51,710
hacer a lo mejor aquí cosas

998
00:38:51,710 --> 00:38:53,989
o sea, tunear

999
00:38:53,989 --> 00:38:54,750
la inyección

1000
00:38:54,750 --> 00:38:57,329
tunearla, porque haces aquí más cositas

1001
00:38:57,329 --> 00:38:58,429
con el auto-wire

1002
00:38:58,429 --> 00:39:01,650
no la puedes tunear, porque lo va a instanciar

1003
00:39:01,650 --> 00:39:03,050
con el constructor de este de aquí

1004
00:39:03,050 --> 00:39:05,210
bueno, es una herramienta más para

1005
00:39:05,210 --> 00:39:07,570
jugar y esas cosas

1006
00:39:07,570 --> 00:39:13,380
cuando uno usa esto y trabaja

1007
00:39:13,380 --> 00:39:14,340
con esto, pues al final

1008
00:39:14,340 --> 00:39:17,460
sin entender muy bien

1009
00:39:17,460 --> 00:39:19,500
nunca jamás lo que realmente está haciendo

1010
00:39:19,500 --> 00:39:21,179
al final las cosas funcionan y

1011
00:39:21,179 --> 00:39:23,099
le ves en cierto sentido a todo.

1012
00:39:23,820 --> 00:39:25,400
Venga, y ahora sí que vamos a

1013
00:39:25,400 --> 00:39:27,039
parar aquí un...