1
00:00:00,000 --> 00:00:18,000
Entonces, aquí en particular, esto a lo que se refiere es, si quitamos un elemento de la colección, que hasta ahí llegábamos, entonces quitar un elemento de la colección no significa que el elemento desaparezca.

2
00:00:18,000 --> 00:00:20,079
aparezca, ¿no? porque cuando hacemos

3
00:00:20,079 --> 00:00:21,320
un remove, de hecho

4
00:00:21,320 --> 00:00:24,059
el elemento me lo devuelve con ahorro de retorno

5
00:00:24,059 --> 00:00:26,420
recordáis que cuando uno hace un remove en una colección

6
00:00:26,420 --> 00:00:28,260
el elemento te lo devuelve con ahorro de retorno

7
00:00:28,260 --> 00:00:30,300
por eso cuando queríamos borrar

8
00:00:30,300 --> 00:00:32,280
todos los que eran igual a algo

9
00:00:32,280 --> 00:00:33,679
en una lista hacemos un while remove

10
00:00:33,679 --> 00:00:35,359
while remove diferente de null

11
00:00:35,359 --> 00:00:36,320
entonces

12
00:00:36,320 --> 00:00:40,700
si quitamos un elemento de la colección

13
00:00:40,700 --> 00:00:42,259
de pedidos, ese pedido

14
00:00:42,259 --> 00:00:44,259
ese pedido en principio

15
00:00:44,259 --> 00:00:46,200
no tendría por qué desaparecer

16
00:00:46,200 --> 00:00:47,539
¿vale?

17
00:00:48,000 --> 00:00:50,079
Entonces, el Orphan Removal True es

18
00:00:50,079 --> 00:00:52,020
si ese pedido,

19
00:00:52,079 --> 00:00:53,520
elimínalo. Ya está, automáticamente.

20
00:00:54,039 --> 00:00:54,920
¿Vale? Que deje de molestar.

21
00:00:55,240 --> 00:00:56,359
Que deje de molestarlo, elimina.

22
00:00:56,899 --> 00:00:59,259
Vale. Lo que más o menos incluyamos.

23
00:00:59,700 --> 00:01:01,020
¿Vale? Eso por un lado.

24
00:01:01,219 --> 00:01:03,820
Que se quedó ahí huérfano el matizarlo un poquito.

25
00:01:04,400 --> 00:01:05,879
Y la otra cosa que se quedó

26
00:01:05,879 --> 00:01:06,500
extraña

27
00:01:06,500 --> 00:01:09,680
era, ¿por qué aquí

28
00:01:09,680 --> 00:01:12,180
en los modelos

29
00:01:12,180 --> 00:01:13,799
que hace ChatGPT pone siempre

30
00:01:13,799 --> 00:01:14,500
Protected?

31
00:01:15,799 --> 00:01:17,859
Cuando yo directamente aquí, normalmente

32
00:01:17,859 --> 00:01:21,700
no pongo nada, ¿vale? Y él pone

33
00:01:21,700 --> 00:01:25,680
protected, ¿vale? Porque yo normalmente aquí en este no pongo nada, o de poner

34
00:01:25,680 --> 00:01:29,840
pongo público, una de las dos cosas, ¿vale? ¿Sabéis qué significa no poner

35
00:01:29,840 --> 00:01:33,120
nada? ¿Sabéis qué significa? Que puedes instanciar

36
00:01:33,120 --> 00:01:37,780
desde el propio paquete, pero no desde fuera, ¿vale? Entonces

37
00:01:37,780 --> 00:01:41,959
normalmente en el constructor sin parámetros, cuando estás en un

38
00:01:41,959 --> 00:01:45,780
modelo JPA, el constructor sin parámetros

39
00:01:45,780 --> 00:01:47,900
normalmente puede estar pensado

40
00:01:47,900 --> 00:01:49,340
quieres tú tenerlo protegido

41
00:01:49,340 --> 00:01:51,980
para que solo lo use hibernate, hibernate lo tiene que usar

42
00:01:51,980 --> 00:01:54,099
porque ya sabemos de memoria que hibernate

43
00:01:54,099 --> 00:01:55,640
que es lo que implementa dentro JPA

44
00:01:55,640 --> 00:01:57,819
usa el constructor sin parámetros

45
00:01:57,819 --> 00:01:58,939
para instanciar los objetos

46
00:01:58,939 --> 00:02:02,040
porque si no lo hacemos, de hecho siempre nos dice

47
00:02:02,040 --> 00:02:03,540
te faltan constructores sin parámetros

48
00:02:03,540 --> 00:02:06,140
entonces tiene que estar, eso ya lo sabemos

49
00:02:06,140 --> 00:02:06,819
que tiene que estar

50
00:02:06,819 --> 00:02:10,000
pero podemos decidir que no lo use

51
00:02:10,000 --> 00:02:11,599
nadie más que hibernate

52
00:02:11,599 --> 00:02:13,379
pues entonces si le quitamos este, ya está

53
00:02:13,379 --> 00:02:15,060
solo lo usa hibernate y se acabó

54
00:02:15,060 --> 00:02:16,900
No podríamos poner private, lógica

55
00:02:16,900 --> 00:02:18,680
Si ponemos private ya no lo puede usar ni Dios

56
00:02:18,680 --> 00:02:21,599
Si ponemos public lo puede usar cualquiera

57
00:02:21,599 --> 00:02:22,659
Entonces decidimos

58
00:02:22,659 --> 00:02:27,460
Hombre, tú puedes poner un constructor

59
00:02:27,460 --> 00:02:28,900
Privado, el problema es que entonces

60
00:02:28,900 --> 00:02:31,180
Solamente lo puedes usar desde otro método

61
00:02:31,180 --> 00:02:33,199
De la clase, a ver, tendría sentido

62
00:02:33,199 --> 00:02:34,819
Si lo quieres usar desde otro

63
00:02:34,819 --> 00:02:36,580
Método, yo qué sé

64
00:02:36,580 --> 00:02:37,319
¿Vale?

65
00:02:39,439 --> 00:02:39,960
Entonces

66
00:02:39,960 --> 00:02:42,800
¿Por qué pone protected?

67
00:02:43,280 --> 00:02:43,960
Chat GPT

68
00:02:43,960 --> 00:02:46,819
Pues por nada en particular, o sea la respuesta

69
00:02:46,819 --> 00:02:47,900
que me ha venido a dar es

70
00:02:47,900 --> 00:02:50,240
pues porque la palabra

71
00:02:50,240 --> 00:02:52,120
porque protected sabemos lo que significa

72
00:02:52,120 --> 00:02:54,460
significa que además

73
00:02:54,460 --> 00:02:56,819
de las clases del paquete te puede instanciar

74
00:02:56,819 --> 00:02:58,500
cualquier subclase, esté de donde esté

75
00:02:58,500 --> 00:03:00,560
eso lo vimos ya el año pasado, es decir

76
00:03:00,560 --> 00:03:02,120
protected es un

77
00:03:02,120 --> 00:03:04,000
public añadido

78
00:03:04,000 --> 00:03:05,960
perdón, un public no, un package

79
00:03:05,960 --> 00:03:08,780
con el añadido de las subclases del resto del

80
00:03:08,780 --> 00:03:10,680
universo, ¿por qué te lo pone?

81
00:03:11,219 --> 00:03:12,620
lo que me ha venido a decir o me ha parecido

82
00:03:12,620 --> 00:03:14,520
entenderle es, bueno porque

83
00:03:14,520 --> 00:03:43,819
Porque protected aporta un significado, o sea, no por el significado sintáctico, no, sino porque si tú pones protected, al ver ahí la palabra protected, pues de repente se te enciende la lucecita, ah, que este constructor es especial porque lo va a usar hibernate, que no tiene nada que ver con que esté protected, como que es informativo porque la palabra protected significa protegido, significa protegido a nivel lingüístico, no a nivel nuestro de Java.

84
00:03:44,520 --> 00:04:05,039
Bueno, pues por eso lo pone, ¿vale? Y si lo pone es porque lo ha visto en muchos proyectos, entonces debe ser que por ahí está en proyectos, digo yo, si no, no lo pondría. Entonces, si lo veis por ahí en algún sitio, pues no tiene más significado que ese, ¿vale? Pues yo qué sé, por hábito, por costumbre, porque sea informativo, pero ya sabemos lo que aporta.

85
00:04:05,039 --> 00:04:07,500
que alguna subclase tuya fuera

86
00:04:07,500 --> 00:04:08,659
te puede instanciar.

87
00:04:09,360 --> 00:04:11,259
Pero vamos, pones public

88
00:04:11,259 --> 00:04:13,680
si no te importa que te instancien

89
00:04:13,680 --> 00:04:15,300
sin parámetros y también, depende,

90
00:04:15,400 --> 00:04:16,519
es que todo depende del contexto.

91
00:04:18,180 --> 00:04:19,699
Vale, pues eran las dos cosas

92
00:04:19,699 --> 00:04:21,259
que se quedaron aquí

93
00:04:21,259 --> 00:04:22,819
pendientes de este modelo.

94
00:04:23,720 --> 00:04:25,639
De lo demás ya habíamos completado el modelo,

95
00:04:25,839 --> 00:04:27,100
ya habíamos entendido todo,

96
00:04:27,720 --> 00:04:28,540
etcétera, etcétera.

97
00:04:30,600 --> 00:04:31,079
Ahora,

98
00:04:32,439 --> 00:04:33,620
esto lo íbamos a hacer ya con

99
00:04:33,620 --> 00:04:35,639
Sprint, poniendo esa capita adicional

100
00:04:35,639 --> 00:04:36,860
De Sprint, vale

101
00:04:36,860 --> 00:04:41,360
A ver

102
00:04:41,360 --> 00:04:43,279
No estaba subido

103
00:04:43,279 --> 00:04:45,980
Porque se supone que lo hicimos el otro día

104
00:04:45,980 --> 00:04:47,839
Y está todavía sin hacer

105
00:04:47,839 --> 00:04:49,600
Pero al final

106
00:04:49,600 --> 00:04:51,660
Lo he subido a una carpeta temporal

107
00:04:51,660 --> 00:04:53,519
A un este temporal temp

108
00:04:53,519 --> 00:04:57,279
Que está aquí, vale

109
00:04:57,279 --> 00:04:59,800
Pero vamos, si viniste el otro día

110
00:04:59,800 --> 00:05:01,740
Tienes que tener escrito el otro día, pues solo hicimos eso

111
00:05:01,740 --> 00:05:03,579
Vale, solo hicimos eso

112
00:05:03,579 --> 00:05:06,439
vale, entonces ahora es cuando estamos

113
00:05:06,439 --> 00:05:08,459
cubriendo la capa de sprint, que se supone

114
00:05:08,459 --> 00:05:09,540
que nos va a oficiar las cosas

115
00:05:09,540 --> 00:05:12,480
y si es verdad, nos va a oficiar

116
00:05:12,480 --> 00:05:14,500
las cosas, bueno, ¿qué sería lo siguiente

117
00:05:14,500 --> 00:05:15,920
que haríamos si

118
00:05:15,920 --> 00:05:18,480
¿qué sería lo siguiente que haríamos

119
00:05:18,480 --> 00:05:20,480
si no tuviéramos sprint? hacer nuestros

120
00:05:20,480 --> 00:05:22,519
DAOs, ¿verdad? hacer nuestros DAOs

121
00:05:22,519 --> 00:05:24,519
vale, pues

122
00:05:24,519 --> 00:05:26,360
con sprint en lugar de nuestros DAOs

123
00:05:26,360 --> 00:05:28,240
lo que vamos a hacer son

124
00:05:28,240 --> 00:05:29,540
repositorios

125
00:05:29,540 --> 00:05:32,279
que ahí venía el debate del otro día

126
00:05:32,279 --> 00:05:34,680
qué es un repositorio

127
00:05:34,680 --> 00:05:36,459
y qué es un DAO. Un repositorio

128
00:05:36,459 --> 00:05:38,420
esencialmente es un DAO. Es una clase

129
00:05:38,420 --> 00:05:40,240
que tiene métodos para acceder a la base de datos.

130
00:05:40,720 --> 00:05:42,000
Pero el repositorio

131
00:05:42,000 --> 00:05:43,480
no lo hacemos nosotros.

132
00:05:44,300 --> 00:05:45,439
Al menos no al completo.

133
00:05:46,019 --> 00:05:48,420
El repositorio, su versión inicial,

134
00:05:48,639 --> 00:05:50,160
su versión básica, la tiene hecha

135
00:05:50,160 --> 00:05:51,439
a Spring. Ya está.

136
00:05:52,139 --> 00:05:53,879
Entonces, la tiene hecha a Spring,

137
00:05:54,040 --> 00:05:55,220
construida por dentro,

138
00:05:56,399 --> 00:05:58,139
ya con sus propios DAOs o como

139
00:05:58,139 --> 00:05:59,819
la construya. Entonces, es cierto

140
00:05:59,819 --> 00:06:01,740
que el repositorio

141
00:06:01,740 --> 00:06:04,899
Tiene métodos como más pegados al modelo

142
00:06:04,899 --> 00:06:06,240
No está en el DAO

143
00:06:06,240 --> 00:06:08,699
Es como muy de meterse en la tierra

144
00:06:08,699 --> 00:06:11,139
El CREATE, el GET, el DELETE

145
00:06:11,139 --> 00:06:11,819
Y el no sé qué

146
00:06:11,819 --> 00:06:12,920
Está un poco pensado para eso

147
00:06:12,920 --> 00:06:14,759
Aunque luego en el DAO uno al final

148
00:06:14,759 --> 00:06:16,079
Acaba poniendo muchos métodos

149
00:06:16,079 --> 00:06:19,160
El repositorio, pues el debate era

150
00:06:19,160 --> 00:06:21,420
Que quizá está como un poquito

151
00:06:21,420 --> 00:06:22,879
Más pegado al modelo

152
00:06:22,879 --> 00:06:26,459
Ves métodos más amplios

153
00:06:26,459 --> 00:06:28,339
Más generales, más parecidos a servicios

154
00:06:28,339 --> 00:06:29,000
A lo mejor

155
00:06:29,000 --> 00:06:32,100
entonces sería

156
00:06:32,100 --> 00:06:34,399
pues como si hubiera un DAO que nosotros

157
00:06:34,399 --> 00:06:36,600
ni vemos, ni accedemos, ni construimos

158
00:06:36,600 --> 00:06:38,240
el repositorio

159
00:06:38,240 --> 00:06:40,379
que también lo hace Spring, aunque ese

160
00:06:40,379 --> 00:06:42,379
ya sí que lo vemos, porque lo

161
00:06:42,379 --> 00:06:44,279
tenemos que escribir nosotros, aunque luego

162
00:06:44,279 --> 00:06:45,899
Spring lo implemente

163
00:06:45,899 --> 00:06:48,459
y luego ya por encima del repositorio, como siempre

164
00:06:48,459 --> 00:06:49,680
los servicios, como siempre

165
00:06:49,680 --> 00:06:52,300
entonces, como ahora estamos con

166
00:06:52,300 --> 00:06:54,199
Spring, nuestra siguiente capa entonces sería

167
00:06:54,199 --> 00:06:56,180
hacer ya el repositorio, porque

168
00:06:56,180 --> 00:06:58,240
el repositorio sí es el bin, el objeto

169
00:06:58,240 --> 00:07:00,420
que Spring maneja.

170
00:07:01,160 --> 00:07:02,139
Instancia maneja

171
00:07:02,139 --> 00:07:04,199
como todos los BIMs que es capaz

172
00:07:04,199 --> 00:07:06,300
de manejar. Vale, pues entonces

173
00:07:06,300 --> 00:07:08,199
lo metemos en un

174
00:07:08,199 --> 00:07:10,139
paquete de repositorio, en lugar

175
00:07:10,139 --> 00:07:12,300
de un paquete de DAO, pues en un paquete de repositorio

176
00:07:12,300 --> 00:07:13,720
y lo natural

177
00:07:13,720 --> 00:07:16,019
es hacer un

178
00:07:16,019 --> 00:07:17,519
repositorio por entidad.

179
00:07:18,939 --> 00:07:19,779
Aunque de nuevo

180
00:07:19,779 --> 00:07:22,060
esto es un poco más

181
00:07:22,060 --> 00:07:23,899
flexible realmente, porque al estar

182
00:07:23,899 --> 00:07:26,079
un poquito más pegado al

183
00:07:26,079 --> 00:07:28,139
modelo que a la propia base de datos

184
00:07:28,139 --> 00:07:30,180
no es como el DAO, el DAO está más pegado

185
00:07:30,180 --> 00:07:31,959
a la base de datos, entonces tengo tabla

186
00:07:31,959 --> 00:07:33,899
o entidad, tengo DAO, tengo tabla, entidad

187
00:07:33,899 --> 00:07:36,139
tengo DAO, el repositorio

188
00:07:36,139 --> 00:07:38,100
al estar más pegado al modelo porque

189
00:07:38,100 --> 00:07:39,860
tiene métodos

190
00:07:39,860 --> 00:07:41,800
a lo mejor que mezclan más cosas, más

191
00:07:41,800 --> 00:07:43,779
de servicio, pues

192
00:07:43,779 --> 00:07:46,160
no es tan, tan, tan, tan

193
00:07:46,160 --> 00:07:48,120
por cada entidad o repositorio, en general

194
00:07:48,120 --> 00:07:49,939
sí, en general sí, ¿vale?

195
00:07:50,040 --> 00:07:50,500
más o menos

196
00:07:50,500 --> 00:07:54,379
es que no hay normal

197
00:07:54,379 --> 00:07:56,360
a ver, es que

198
00:07:56,360 --> 00:07:57,939
el de normal es que no existe

199
00:07:57,939 --> 00:08:26,720
O sea, depende del proyecto en sí, pero en general una entidad me ofrece su persistencia, me ofrece su acceso a datos a través de un repositorio, ¿vale? Lo que pasa es que ese repositorio me puede ofrecer a lo mejor cosas relacionadas con otras entidades porque habrá métodos que mezclen varias cosas, que hay un poco mezcla y de nuevo depende de los servicios que tengas que hacer, de la aplicación que tengas y del modelo que tengas, depende de muchas cosas.

200
00:08:26,720 --> 00:08:39,720
O sea, no hay el de normal, es un poco, pues bueno, entender la arquitectura y ya está. Vale, en este caso son dos tablas, corrientes y molientes. Vale, pues entonces un cliente repositorio, un pedido repositorio.

201
00:08:39,720 --> 00:08:57,360
Y ahora, pues nuestro cliente repositorio, como no la vamos a implementar nosotros, porque eso es la magia de Spring, que la implementa ella, pues que sea una interfaz, porque no la vamos a implementar nosotros.

202
00:08:57,360 --> 00:09:00,279
Esta es la parte interesante

203
00:09:00,279 --> 00:09:02,220
De Spring Data

204
00:09:02,220 --> 00:09:04,419
La parte interesante es

205
00:09:04,419 --> 00:09:06,460
Que la implementa ella

206
00:09:06,460 --> 00:09:07,639
¿Vale?

207
00:09:07,679 --> 00:09:09,220
Nosotros los DAOs los tenemos que hacer

208
00:09:09,220 --> 00:09:11,080
Tampoco es que nos cueste horrores hacerlos

209
00:09:11,080 --> 00:09:13,779
Y gracias a hacerlos

210
00:09:13,779 --> 00:09:15,179
Tenemos más control realmente

211
00:09:15,179 --> 00:09:16,980
Luego de los servicios que están haciendo

212
00:09:16,980 --> 00:09:18,960
Así aquí no tenemos mucho

213
00:09:18,960 --> 00:09:20,279
Pero bueno

214
00:09:20,279 --> 00:09:22,639
Claro

215
00:09:22,639 --> 00:09:25,340
Manejas tú donde está el Entity Manager

216
00:09:25,340 --> 00:09:27,500
Sabes exactamente en qué momento se está instanciando

217
00:09:27,500 --> 00:09:28,500
Cuando lo cierras

218
00:09:28,500 --> 00:09:29,799
Tienes un poco más de control

219
00:09:29,799 --> 00:09:31,899
Aquí ya empiezas a perderlo

220
00:09:31,899 --> 00:09:32,759
Pero bueno

221
00:09:32,759 --> 00:09:37,139
Pero bueno, es más mágico

222
00:09:37,139 --> 00:09:39,320
Vale, entonces para que esto realmente

223
00:09:39,320 --> 00:09:41,320
Sea algo

224
00:09:41,320 --> 00:09:42,620
Implementable por Spring

225
00:09:42,620 --> 00:09:44,419
Pues tiene que heredar

226
00:09:44,419 --> 00:09:46,259
De JPA Repository

227
00:09:46,259 --> 00:09:47,820
Tiene que heredar de ahí, sí o sí

228
00:09:47,820 --> 00:09:50,919
Para que Spring diga, uy que lo tengo que implementar

229
00:09:50,919 --> 00:09:52,919
Según tu modelo

230
00:09:52,919 --> 00:09:53,860
Vale

231
00:09:53,860 --> 00:09:57,500
Entonces, jprepositorio es una clase genérica

232
00:09:57,500 --> 00:09:58,159
Que depende

233
00:09:58,159 --> 00:10:00,600
De la entidad en concreto

234
00:10:00,600 --> 00:10:02,500
Y del tipo de dato de la clave

235
00:10:02,500 --> 00:10:04,639
Porque la clave es básica, lógicamente

236
00:10:04,639 --> 00:10:05,759
Para el acceso a datos

237
00:10:05,759 --> 00:10:09,100
Pues el tipo de dato de la clase es cliente

238
00:10:09,100 --> 00:10:11,039
Y la clave en nuestro caso

239
00:10:11,039 --> 00:10:12,320
De cliente era long

240
00:10:12,320 --> 00:10:13,940
La clave era long

241
00:10:13,940 --> 00:10:16,860
Pues ya está

242
00:10:16,860 --> 00:10:19,879
Se acabó el repositorio

243
00:10:19,879 --> 00:10:21,220
Se acabó el DAO

244
00:10:21,220 --> 00:10:22,659
Si queremos

245
00:10:22,659 --> 00:10:24,460
¿Vale? Si queremos

246
00:10:24,460 --> 00:10:25,519
Se puede quedar así

247
00:10:25,519 --> 00:10:28,659
Y ya tenemos un DAO que hace unas cuantas cosas

248
00:10:28,659 --> 00:10:29,919
Vamos a verlo

249
00:10:29,919 --> 00:10:30,899
Ya está

250
00:10:30,899 --> 00:10:35,419
Si lo sabes

251
00:10:35,419 --> 00:10:38,299
Ahora lo sabremos

252
00:10:38,299 --> 00:10:39,919
Al fin y al cabo son 4, 5, 6

253
00:10:39,919 --> 00:10:40,820
¿Vale?

254
00:10:42,120 --> 00:10:43,139
Entonces ya está

255
00:10:43,139 --> 00:10:45,659
Están en JPA Repositorio esos métodos

256
00:10:45,659 --> 00:10:46,580
Pero luego pues podemos

257
00:10:46,580 --> 00:10:50,100
Gracias al entorno de desarrollo rápidamente nos ofrece

258
00:10:50,100 --> 00:10:52,299
Gracias a la documentación que integra el entorno

259
00:10:52,299 --> 00:10:53,840
pues nos ofrece los que hay

260
00:10:53,840 --> 00:10:56,100
ya no hay más que hacer, se acabó

261
00:10:56,100 --> 00:10:57,159
¿vale?

262
00:10:58,240 --> 00:10:59,759
esto ya

263
00:10:59,759 --> 00:11:02,299
va a ser un objeto

264
00:11:02,299 --> 00:11:04,419
de los manejados por Sprint

265
00:11:04,419 --> 00:11:06,019
recordad que Sprint

266
00:11:06,019 --> 00:11:08,440
entre otras cosas

267
00:11:08,440 --> 00:11:09,860
su origen sobre todo

268
00:11:09,860 --> 00:11:12,460
venía por

269
00:11:12,460 --> 00:11:14,600
instanciar los objetos que hicieran

270
00:11:14,600 --> 00:11:16,580
falta e inyectarlos a través de los

271
00:11:16,580 --> 00:11:17,980
constructores o de donde fuera

272
00:11:17,980 --> 00:11:20,659
a donde hicieran falta y nos olvidamos

273
00:11:20,659 --> 00:11:22,759
de ellos, que para yo crearte

274
00:11:22,759 --> 00:11:24,940
a Tinnit un datasource, saco el datasource

275
00:11:24,940 --> 00:11:27,100
y lo meto, que para crear el datasource

276
00:11:27,100 --> 00:11:28,360
necesito un no sé qué

277
00:11:28,360 --> 00:11:30,720
me lo invento, lo instancio y lo meto

278
00:11:30,720 --> 00:11:32,240
o sea, todo eso, ¿no? Spring es

279
00:11:32,240 --> 00:11:33,879
crea objetos según hagan falta y ya está

280
00:11:33,879 --> 00:11:36,700
bueno, pues este es uno

281
00:11:36,700 --> 00:11:38,679
de los que Spring tendrá que

282
00:11:38,679 --> 00:11:40,519
crear solo cuando vea que

283
00:11:40,519 --> 00:11:41,600
a alguien le hace falta

284
00:11:41,600 --> 00:11:45,019
¿a quién le va a hacer falta un repositorio? pues al servicio

285
00:11:45,019 --> 00:11:46,700
¿vale? pues este es

286
00:11:46,700 --> 00:11:48,179
uno de los que Spring creará solo

287
00:11:48,179 --> 00:11:51,059
entonces, oficialmente

288
00:11:51,059 --> 00:11:53,179
teóricamente habría que marcarlo

289
00:11:53,179 --> 00:11:54,820
¿vale? porque mediante

290
00:11:54,820 --> 00:11:56,980
anotaciones es como le decimos a Spring las cosas

291
00:11:56,980 --> 00:11:58,700
¿vale?

292
00:11:59,559 --> 00:12:00,559
entonces, estos

293
00:12:00,559 --> 00:12:02,600
nos hemos despreocupado de eso

294
00:12:02,600 --> 00:12:04,919
porque estos no son los objetos del

295
00:12:04,919 --> 00:12:06,860
modelo, no son objetos pensados

296
00:12:06,860 --> 00:12:08,799
para que Spring los instancie cuando le

297
00:12:08,799 --> 00:12:10,799
hagan falta, no, los objetos del

298
00:12:10,799 --> 00:12:12,840
modelo forman parte de nuestra aplicación

299
00:12:12,840 --> 00:12:14,860
los clientes que tengamos, no sé qué, que nos irán

300
00:12:14,860 --> 00:12:16,720
llegando, pues los vamos instanciando según nos van

301
00:12:16,720 --> 00:12:18,860
llegando lo que sea, eso ya se hace en nuestra aplicación

302
00:12:18,860 --> 00:12:20,639
Spring esencialmente

303
00:12:20,639 --> 00:12:22,639
se dedica a gestionar todos los bins relacionados

304
00:12:22,639 --> 00:12:24,860
con la configuración de alguna manera

305
00:12:24,860 --> 00:12:26,480
los objetos del modelo no

306
00:12:26,480 --> 00:12:28,659
son los objetos que yo decido cuando

307
00:12:28,659 --> 00:12:30,139
aparecen y cuando no, porque son mis datos

308
00:12:30,139 --> 00:12:32,559
son los datos de mi aplicación, estos son datos

309
00:12:32,559 --> 00:12:33,940
de mi aplicación, el resto son

310
00:12:33,940 --> 00:12:36,600
pues los esclavos, esclavos que

311
00:12:36,600 --> 00:12:38,519
están todos al servicio de que mis datos

312
00:12:38,519 --> 00:12:40,580
entren y salgan en la base de datos

313
00:12:40,580 --> 00:12:42,620
que es lo que hace cualquier aplicación, coger datos

314
00:12:42,620 --> 00:12:43,960
y llevarlos de un lado a otro

315
00:12:43,960 --> 00:12:46,659
pues esos datos son responsabilidad mía

316
00:12:46,659 --> 00:12:49,139
los clientes y los pedidos son responsabilidad mía

317
00:12:49,139 --> 00:12:51,000
y el resto son los esclavos

318
00:12:51,000 --> 00:12:52,960
para que esos tránsitos de datos funcionen

319
00:12:52,960 --> 00:12:54,879
y los esclavos sí que son los que

320
00:12:54,879 --> 00:12:56,320
Spring tiene que gestionar

321
00:12:56,320 --> 00:12:58,899
pues cliente repository será un objeto

322
00:12:58,899 --> 00:13:00,960
esclavo necesario para que

323
00:13:00,960 --> 00:13:02,960
todos estos datos puedan ir de un lado para otro

324
00:13:02,960 --> 00:13:04,899
entonces yo lo tendría que marcar de alguna

325
00:13:04,899 --> 00:13:06,139
manera para que Spring diga

326
00:13:06,139 --> 00:13:08,919
este es un... en general

327
00:13:08,919 --> 00:13:11,000
los objetos que maneja

328
00:13:11,000 --> 00:13:12,799
Spring son componentes

329
00:13:12,799 --> 00:13:14,559
se anotarían como componentes, pero bueno

330
00:13:14,559 --> 00:13:16,200
ya no hace falta porque está Spring Boot

331
00:13:16,200 --> 00:13:18,019
Etcétera, etcétera, hay muchas cosas

332
00:13:18,019 --> 00:13:20,419
Dentro de los objetos component

333
00:13:20,419 --> 00:13:22,360
Que son los objetos en general que Spring

334
00:13:22,360 --> 00:13:24,740
Puede manejar solito, instanciar solito

335
00:13:24,740 --> 00:13:26,600
Hay algunos

336
00:13:26,600 --> 00:13:28,259
Con características especiales

337
00:13:28,259 --> 00:13:30,460
Pues como el controller, si os suena

338
00:13:30,460 --> 00:13:32,779
De la primera vez que ya volveremos a él

339
00:13:32,779 --> 00:13:34,059
Pues como el servicio

340
00:13:34,059 --> 00:13:36,039
O como el repositorio

341
00:13:36,039 --> 00:13:38,379
Entonces yo, pues teóricamente

342
00:13:38,379 --> 00:13:40,779
Debería decir, oye que tú eres un component

343
00:13:40,779 --> 00:13:42,240
Un objeto component, ¿vale?

344
00:13:42,299 --> 00:13:43,659
Podría poner aquí incluso

345
00:13:43,659 --> 00:13:45,519
Component

346
00:13:45,519 --> 00:13:46,980
vale

347
00:13:46,980 --> 00:13:48,539
pero

348
00:13:48,539 --> 00:13:52,320
sería todavía más preciso

349
00:13:52,320 --> 00:13:54,019
si dijera eres un component

350
00:13:54,019 --> 00:13:55,580
vale, o sea un objeto de sprint

351
00:13:55,580 --> 00:13:57,980
pero es que además eres un repositorio

352
00:13:57,980 --> 00:13:59,960
pues sería mucho más

353
00:13:59,960 --> 00:14:02,059
precisa

354
00:14:02,059 --> 00:14:03,980
todavía si pusiera aquí esto

355
00:14:03,980 --> 00:14:05,100
y no pasa nada

356
00:14:05,100 --> 00:14:08,059
y puedo ponerle, pero en este

357
00:14:08,059 --> 00:14:09,659
caso en particular no es necesario

358
00:14:09,659 --> 00:14:12,139
porque al heredar de jpa

359
00:14:12,139 --> 00:14:14,120
repository, al heredar

360
00:14:14,120 --> 00:14:16,379
Ya Spring infiere

361
00:14:16,379 --> 00:14:18,480
Que esto es un component para él

362
00:14:18,480 --> 00:14:19,759
Y ya está

363
00:14:19,759 --> 00:14:21,980
Entonces no es necesaria anotación

364
00:14:21,980 --> 00:14:23,519
¿Pasa algo porque la ponga?

365
00:14:23,820 --> 00:14:25,600
No pasa nada, de hecho

366
00:14:25,600 --> 00:14:28,399
Muchas anotaciones, muchas veces son meramente

367
00:14:28,399 --> 00:14:30,320
Aclaratorias, para que uno

368
00:14:30,320 --> 00:14:31,340
Entienda las cosas

369
00:14:31,340 --> 00:14:34,120
Esta en particular, pues no hace falta

370
00:14:34,120 --> 00:14:35,899
¿Cómo ponen las dos?

371
00:14:36,379 --> 00:14:36,899
¿Cómo?

372
00:14:37,960 --> 00:14:38,740
¿Qué dos?

373
00:14:40,179 --> 00:14:41,879
¿Componen? No, hombre, no, las dos no

374
00:14:41,879 --> 00:14:55,720
Claro, porque una sería una subclase de la otra de alguna manera, ¿vale? Entonces, en este caso, la anotación es opcional. Pero la pongamos o no la pongamos, esto es un objeto que va a ser gestionado por Spring, eso está claro.

375
00:14:55,720 --> 00:15:20,879
Vale, entonces pedido repository, vale, pues pedido repository lo mismo, extiende de jpeg a repository parametrizado a los dos datos, el tipo de entidad y el tipo de la clave primaria, integer, long, string, la que sea.

376
00:15:24,320 --> 00:15:25,259
Y ya tengo el dado.

377
00:15:25,899 --> 00:15:28,460
¿Es la clave primaria compuesta igual que la última que has pasado?

378
00:15:28,460 --> 00:15:53,259
Sí, el tipo de la clave primaria, claro. Entonces, aquí, ahora ya el siguiente paso sería hacer los servicios, ¿vale? Por ejemplo, aquí cliente service, ¿vale? Ahora mismo está vacío, podéis escribirlo vosotros si no lo tenéis escrito, ¿vale? Este sería nuestro servicio, por ejemplo, de los clientes.

379
00:15:53,259 --> 00:16:10,480
Aunque recordad que el servicio todavía es más flexible. En principio, pues bueno, una clase para los servicios de cliente, una clase para los servicios de pedido, pero claro, los servicios son los casos de uso ya, las funcionalidades. Y las funcionalidades ya sí que están muy mezcladas, mezclan mucho.

380
00:16:10,480 --> 00:16:13,000
clientes cuyos pedidos no sé qué

381
00:16:13,000 --> 00:16:14,980
entonces bueno, en principio

382
00:16:14,980 --> 00:16:16,419
una clase de servicio

383
00:16:16,419 --> 00:16:18,460
por entidad

384
00:16:18,460 --> 00:16:20,980
pero no es tan rígido, puede haber una clase de servicio

385
00:16:20,980 --> 00:16:22,980
sin más o otro tipo

386
00:16:22,980 --> 00:16:23,759
de agrupaciones

387
00:16:23,759 --> 00:16:26,639
¿Puedes poner pedido de repositorio?

388
00:16:27,039 --> 00:16:28,940
Sí, es como

389
00:16:28,940 --> 00:16:30,620
la otra, solo cambia

390
00:16:30,620 --> 00:16:31,879
esto y esto

391
00:16:31,879 --> 00:16:33,820
¿Vale?

392
00:16:34,820 --> 00:16:36,960
Vale, ¿dónde

393
00:16:36,960 --> 00:16:37,720
estábamos? Aquí

394
00:16:37,720 --> 00:16:41,019
bueno, pues lo siguiente que haríamos sería nuestro servicio

395
00:16:41,019 --> 00:16:42,120
nuestro servicio

396
00:16:42,120 --> 00:16:44,740
con el constructor

397
00:16:44,740 --> 00:16:46,419
y el

398
00:16:46,419 --> 00:16:49,139
repositor, la clase de servicios

399
00:16:49,139 --> 00:16:50,659
va a necesitar este

400
00:16:50,659 --> 00:16:52,899
repositorio casi seguro, y puede que también el otro

401
00:16:52,899 --> 00:16:53,779
puede que también

402
00:16:53,779 --> 00:16:56,220
esto no es rígido, no es que

403
00:16:56,220 --> 00:16:58,700
la clase donde están los servicios del cliente

404
00:16:58,700 --> 00:17:00,399
solo tenga que usar este, pues no

405
00:17:00,399 --> 00:17:02,419
igual tiene que usar el resto de repositorios

406
00:17:02,419 --> 00:17:04,759
pues si tiene que usar el resto de repositorios lo pongo, no pasa nada

407
00:17:04,759 --> 00:17:05,900
claro

408
00:17:05,900 --> 00:17:08,339
claro, es un servicio

409
00:17:08,339 --> 00:17:09,519
que usará lo que haga falta

410
00:17:09,519 --> 00:17:10,119
vale

411
00:17:10,119 --> 00:17:14,119
pero bueno, este se supone

412
00:17:14,119 --> 00:17:16,099
casi seguro que lo va a usar, porque si son servicios

413
00:17:16,099 --> 00:17:16,700
de clientes

414
00:17:16,700 --> 00:17:19,559
entonces, aquí

415
00:17:19,559 --> 00:17:22,180
de nuevo, aquí es donde

416
00:17:22,180 --> 00:17:23,640
Spring va a aparecer

417
00:17:23,640 --> 00:17:26,460
porque cuando nosotros instanciemos el servicio

418
00:17:26,460 --> 00:17:28,579
porque ya desde mi aplicación

419
00:17:28,579 --> 00:17:30,019
sea un controller

420
00:17:30,019 --> 00:17:32,460
sea un main, sea lo que sea

421
00:17:32,460 --> 00:17:33,700
ya desde mi aplicación

422
00:17:33,700 --> 00:17:35,339
lo que yo necesito es el objeto

423
00:17:35,339 --> 00:17:37,200
servicio, para llamar a sus métodos

424
00:17:37,200 --> 00:17:38,240
es lo que yo instancio

425
00:17:38,240 --> 00:17:41,500
vale, pues desde el momento en que yo lo instancie

426
00:17:41,500 --> 00:17:43,200
yo o Spring o quien sea

427
00:17:43,200 --> 00:17:45,220
en el momento en que este servicio aparezca

428
00:17:45,220 --> 00:17:46,940
que es el que tiene que aparecer en mi main

429
00:17:46,940 --> 00:17:48,839
porque es el que tiene las funcionalidades

430
00:17:48,839 --> 00:17:50,440
en el momento en el que aparezca

431
00:17:50,440 --> 00:17:53,119
Spring se va a dar cuenta de que, uy, necesita

432
00:17:53,119 --> 00:17:54,920
un repository, pues ya está

433
00:17:54,920 --> 00:17:57,200
lo crea y punto, pero tal

434
00:17:57,200 --> 00:17:58,920
lo crea y se lo inyecta al

435
00:17:58,920 --> 00:18:02,109
este porque no va

436
00:18:02,109 --> 00:18:05,089
porque estás con el

437
00:18:05,089 --> 00:18:08,950
No, si se la va a pasar a edificar.

438
00:18:10,490 --> 00:18:11,910
Porque creo que está con lo de pintar, claro.

439
00:18:12,670 --> 00:18:13,710
¿Cómo quito esto ahora?

440
00:18:14,430 --> 00:18:16,009
El último botón.

441
00:18:16,029 --> 00:18:17,829
Dale al cuadrado de abajo de ahí.

442
00:18:19,690 --> 00:18:20,869
Ah, vale, para aquí.

443
00:18:20,990 --> 00:18:22,910
Ah, y lo que no sé es cómo lo he abierto.

444
00:18:23,190 --> 00:18:24,309
Ah, lo he abierto aquí, ¿verdad?

445
00:18:24,650 --> 00:18:25,549
No, no, lo he abierto aquí.

446
00:18:26,150 --> 00:18:26,970
Bueno, pues nada.

447
00:18:27,609 --> 00:18:29,569
A ver, ahora cómo vuelvo yo, no tengo que volver.

448
00:18:31,410 --> 00:18:32,089
Ahí nos va.

449
00:18:32,089 --> 00:18:32,990
¿Dónde la pintarás vos?

450
00:18:32,990 --> 00:18:38,420
vale, pues entonces

451
00:18:38,420 --> 00:18:40,440
Spring ya pum, lo hará aparecer

452
00:18:40,440 --> 00:18:41,000
y ya está

453
00:18:41,000 --> 00:18:44,480
vale, en su momento mencionamos

454
00:18:44,480 --> 00:18:45,799
que lo he puesto aquí para que no se me

455
00:18:45,799 --> 00:18:46,819
olvide

456
00:18:46,819 --> 00:18:48,220
que

457
00:18:48,220 --> 00:18:52,259
Spring sabe

458
00:18:52,259 --> 00:18:53,680
que tiene que hacer aparecer

459
00:18:53,680 --> 00:18:55,559
lo que este necesite

460
00:18:55,559 --> 00:18:57,380
entonces

461
00:18:57,380 --> 00:19:00,819
hay dos maneras de decírselo

462
00:19:00,819 --> 00:19:02,299
una pues que

463
00:19:02,299 --> 00:19:04,460
decirle, oye, inyectalo en el constructor

464
00:19:04,460 --> 00:19:09,240
y otra, ponerle aquí una anotación

465
00:19:09,240 --> 00:19:12,319
que es esta de aquí, que la mencionamos también un día

466
00:19:12,319 --> 00:19:16,039
autowire, que es, si tú pones en cualquier

467
00:19:16,039 --> 00:19:20,859
propiedad el autowire, pues lo que hace sprint es

468
00:19:20,859 --> 00:19:24,960
la hace aparecer tal cual, la hace aparecer dentro

469
00:19:24,960 --> 00:19:28,660
de cliente service, no la hace pasar a través del constructor

470
00:19:28,660 --> 00:19:31,759
su matiz, entonces

471
00:19:31,759 --> 00:19:51,119
Entonces, aquí yo entiendo que hay diferentes criterios, ¿vale? Si el que haya un constructor, a mí me parece buena idea porque te independizas de Spring, tú siempre vas a poder instanciar clientes service con el repositor y no vas a vivir tan agobiado por la existencia de Spring.

472
00:19:51,119 --> 00:19:53,759
si pones aquí autowire y quitas el constructor

473
00:19:53,759 --> 00:19:55,960
pues simplemente has deshabilitado

474
00:19:55,960 --> 00:19:57,680
ese constructor, entonces bueno

475
00:19:57,680 --> 00:19:58,779
pues

476
00:19:58,779 --> 00:20:01,700
no lo sé, lo de mala idea es

477
00:20:01,700 --> 00:20:03,660
intuición

478
00:20:03,660 --> 00:20:05,599
bien, pero vamos, vale

479
00:20:05,599 --> 00:20:06,119
no lo sé

480
00:20:06,119 --> 00:20:09,440
no lo sé cómo estará más por ahí, dime

481
00:20:09,440 --> 00:20:11,000
se recomienda que

482
00:20:11,000 --> 00:20:13,480
en el 95% de los casos lo hagas por

483
00:20:13,480 --> 00:20:15,420
constructor y quites el celular del

484
00:20:15,420 --> 00:20:16,819
autowire por atributo

485
00:20:16,819 --> 00:20:18,539
¿y qué razón da?

486
00:20:18,539 --> 00:20:30,079
Pero vamos, no te dice por qué

487
00:20:30,079 --> 00:20:30,680
Porque

488
00:20:30,680 --> 00:20:32,599
Pero bueno

489
00:20:32,599 --> 00:20:36,359
Claro, sí, lo que pasa es que

490
00:20:36,359 --> 00:20:37,640
Esas son las cosas que a mí me

491
00:20:37,640 --> 00:20:39,920
Me desconciertan de este mundo

492
00:20:39,920 --> 00:20:41,799
Te recomiendo que lo hagas así

493
00:20:41,799 --> 00:20:43,640
Vale, yo lo hago así, pero ¿por qué?

494
00:20:43,680 --> 00:20:44,980
Porque funciona distinto

495
00:20:44,980 --> 00:20:46,960
No debería, porque

496
00:20:46,960 --> 00:20:48,839
Pero bueno, que es que así

497
00:20:48,839 --> 00:20:50,940
Trabajar con un framework es así

498
00:20:50,940 --> 00:20:53,480
Tú al final sigues sus recomendaciones y ya está

499
00:20:53,480 --> 00:20:54,519
Pero bueno

500
00:20:54,519 --> 00:20:57,519
Y si haces un segundo constructor, como si haces un constructor vacío

501
00:20:57,519 --> 00:20:58,640
Ya tienes que meter el autowire

502
00:20:58,640 --> 00:21:00,900
Pones autowire en el que quieres el print

503
00:21:00,900 --> 00:21:01,819
Para distanciar

504
00:21:01,819 --> 00:21:06,099
Vale, aquí

505
00:21:06,099 --> 00:21:09,059
Si pones autowire sin más y no hay ninguno

506
00:21:09,059 --> 00:21:11,200
Lógicamente te va a salir sin parámetro, que es el que tiene

507
00:21:11,200 --> 00:21:13,460
Vale, pues nada

508
00:21:13,460 --> 00:21:17,660
Bla, bla, bla

509
00:21:17,660 --> 00:21:18,859
Aquí tenemos el servicio

510
00:21:18,859 --> 00:21:21,140
Y ahora, aquí viene la magia estupenda

511
00:21:21,140 --> 00:21:22,980
¿Vale? Por ejemplo

512
00:21:22,980 --> 00:21:25,500
¿Qué puedo querer hacer yo con un cliente?

513
00:21:26,240 --> 00:21:27,579
Pues recuperar un cliente

514
00:21:27,579 --> 00:21:29,480
Dado su ID, dame este cliente

515
00:21:29,480 --> 00:21:31,259
Por ejemplo, ¿no? Pues entonces yo me podría hacer

516
00:21:31,259 --> 00:21:32,079
Aquí un servicio

517
00:21:32,079 --> 00:21:42,799
Recupera cliente

518
00:21:42,799 --> 00:21:45,440
A través de su clave

519
00:21:45,440 --> 00:21:46,259
Que era long

520
00:21:46,259 --> 00:21:47,900
Vale

521
00:21:47,900 --> 00:21:51,799
Bueno, pues vamos a necesitar el repositorio

522
00:21:51,799 --> 00:21:53,519
Que el repositorio es el que me hace las cosas

523
00:21:53,519 --> 00:21:54,380
¿Vale?

524
00:21:55,480 --> 00:21:56,740
Y aquí es donde

525
00:21:56,740 --> 00:21:59,740
Veo todo lo que Spring ha hecho por mí

526
00:21:59,740 --> 00:22:02,359
Todos estos métodos están implementados

527
00:22:02,359 --> 00:22:03,759
No los tengo que hacer yo

528
00:22:03,759 --> 00:22:06,019
Se acabó

529
00:22:06,019 --> 00:22:07,660
¿Cómo están implementados?

530
00:22:07,759 --> 00:22:09,339
No sé, pero bueno

531
00:22:09,339 --> 00:22:12,640
Podría importarnos

532
00:22:12,640 --> 00:22:13,740
Pero

533
00:22:13,740 --> 00:22:18,279
No, no, no

534
00:22:18,279 --> 00:22:19,319
Vamos a verlo

535
00:22:19,319 --> 00:22:21,700
No vamos a verlo, no tenemos ganas

536
00:22:21,700 --> 00:22:24,259
Bueno, podemos tener ganas

537
00:22:24,259 --> 00:22:24,960
Pero no tiempo

538
00:22:24,960 --> 00:22:26,400
El repositorio como se llama

539
00:22:26,400 --> 00:22:29,339
Cliente repo, vale

540
00:22:29,339 --> 00:22:34,420
Porque la lupa, porque los de atrás

541
00:22:34,420 --> 00:22:38,420
Ah, que se llama clientes

542
00:22:38,420 --> 00:22:39,599
Vale, es que ya se llamaba clientes

543
00:22:39,599 --> 00:22:41,519
Todos veis incluso pequeñito

544
00:22:41,519 --> 00:22:44,240
Pero todo eso también lo veíais

545
00:22:44,240 --> 00:22:46,180
Por favor

546
00:22:46,180 --> 00:22:47,380
Que vista tenéis

547
00:22:47,380 --> 00:22:50,119
Vamos, que la lupa no gusta nada

548
00:22:50,119 --> 00:22:56,880
Bueno, pues nada, no lo veo ni yo

549
00:22:56,880 --> 00:22:57,740
Pero si vosotros lo veis

550
00:22:57,740 --> 00:23:01,299
Vale, pues tenemos el crud básico

551
00:23:01,299 --> 00:23:03,619
En realidad, el crud básico y alguna otra cosa

552
00:23:03,619 --> 00:23:04,559
Tenemos

553
00:23:04,559 --> 00:23:06,619
Vale

554
00:23:06,619 --> 00:23:08,880
Tenemos borrar

555
00:23:08,880 --> 00:23:10,980
Eliminar el objeto

556
00:23:10,980 --> 00:23:12,759
Eliminarlos todos

557
00:23:12,759 --> 00:23:14,099
Los clientes

558
00:23:14,099 --> 00:23:16,160
Eliminar por ID

559
00:23:16,160 --> 00:23:18,940
Eliminar

560
00:23:18,940 --> 00:23:20,839
Por ID a mogollón

561
00:23:20,839 --> 00:23:21,700
Un montón

562
00:23:21,700 --> 00:23:25,559
O sea, le pasas un montón de claves

563
00:23:25,559 --> 00:23:27,019
Y te elimina

564
00:23:27,019 --> 00:23:29,640
En un proceso batch

565
00:23:29,640 --> 00:23:30,559
¿Vale?

566
00:23:34,059 --> 00:23:35,559
Borrar uno por ID

567
00:23:35,559 --> 00:23:38,200
Si existe o no existe

568
00:23:38,200 --> 00:23:41,220
Recuperar todos los clientes

569
00:23:41,220 --> 00:23:44,140
Recuperar por ID

570
00:23:44,140 --> 00:23:47,539
¿Vale?

571
00:23:48,099 --> 00:23:49,059
Y guardar

572
00:23:49,059 --> 00:23:50,619
Uno que no sea persistente

573
00:23:50,619 --> 00:23:51,740
Todavía hacerlo persistente

574
00:23:51,740 --> 00:23:52,900
Entonces tiene el CRUD básico

575
00:23:52,900 --> 00:23:54,579
Insertar

576
00:23:54,579 --> 00:23:56,720
Recuperar por id

577
00:23:56,720 --> 00:23:59,940
Recuperar todos, eliminar

578
00:23:59,940 --> 00:24:00,680
Y

579
00:24:00,680 --> 00:24:03,619
Y bueno, modificar

580
00:24:03,619 --> 00:24:04,980
Pero modificar es que es un

581
00:24:04,980 --> 00:24:06,619
Se hace automáticamente

582
00:24:06,619 --> 00:24:10,039
Ah, perdón

583
00:24:10,039 --> 00:24:10,559
Vale, vale

584
00:24:10,559 --> 00:24:13,640
Vale, pues entonces

585
00:24:13,640 --> 00:24:15,940
En este caso es que sería tan sencillo

586
00:24:15,940 --> 00:24:16,339
Como

587
00:24:16,339 --> 00:24:27,289
By id y le pasamos id

588
00:24:27,289 --> 00:24:32,339
Vale, y este me devuelve

589
00:24:32,339 --> 00:24:34,339
el

590
00:24:34,339 --> 00:24:35,920
que no lo he sacado, ¿verdad?

591
00:24:40,380 --> 00:24:41,900
id, me lo devuelve el optional

592
00:24:41,900 --> 00:24:45,359
y aquí pues bueno

593
00:24:45,359 --> 00:24:47,099
ya os sacamos el optional

594
00:24:47,099 --> 00:24:48,359
lo bestia, lo de siempre

595
00:24:48,359 --> 00:24:51,240
o si yo no quiero evitar null

596
00:24:51,240 --> 00:24:53,220
pues yo que sé, doy un cliente vacío

597
00:24:53,220 --> 00:24:54,680
aquí lo que cada uno quiera

598
00:24:54,680 --> 00:24:57,079
¿vale? si somos un poco burros

599
00:24:57,079 --> 00:24:58,819
no hay manera de comentar

600
00:24:58,819 --> 00:25:00,619
no hay manera de comentar

601
00:25:00,619 --> 00:25:03,359
claro, es que esto no es como se hacen las cosas

602
00:25:03,359 --> 00:25:05,099
ojalá, ojalá esto fuera

603
00:25:05,099 --> 00:25:07,440
un recetario, pero esto no es un recetario

604
00:25:07,440 --> 00:25:08,759
porque

605
00:25:08,759 --> 00:25:11,039
igual dentro de un año lo que estás haciendo es

606
00:25:11,039 --> 00:25:12,960
completamente distinto a lo que hacemos aquí

607
00:25:12,960 --> 00:25:15,059
y no pasará nada

608
00:25:15,059 --> 00:25:16,720
será lo que hacen allí

609
00:25:16,720 --> 00:25:17,740
entonces

610
00:25:17,740 --> 00:25:21,740
no, no te lo enseñarán

611
00:25:21,740 --> 00:25:23,119
lo tendrás que aprender tú y sacar

612
00:25:23,119 --> 00:25:24,759
tus propias conclusiones y todo

613
00:25:24,759 --> 00:25:26,640
es que este mundo es muy distinto a

614
00:25:26,640 --> 00:25:29,039
voy a aprender a hacer cosas y ahora que ya he aprendido

615
00:25:29,039 --> 00:25:30,759
voy a hacerlas, es que no tiene nada que ver con eso

616
00:25:30,759 --> 00:25:32,480
nada que ver, voy a

617
00:25:32,480 --> 00:25:34,960
educarme un poco en ciertas maneras

618
00:25:34,960 --> 00:25:36,700
de pensar y luego voy a tratar

619
00:25:36,700 --> 00:25:38,460
de aplicarlas para aprender cosas

620
00:25:38,460 --> 00:25:39,920
completamente distintas

621
00:25:39,920 --> 00:25:40,980
se trata de eso

622
00:25:40,980 --> 00:25:46,519
pues sobrevivimos como podemos

623
00:25:46,519 --> 00:25:48,680
¿cómo quieres que evaluemos?

624
00:25:54,299 --> 00:25:55,480
vale, pues entonces

625
00:25:55,480 --> 00:25:57,279
se admite cualquier tipo de sugerencia

626
00:25:57,279 --> 00:25:58,640
sobre cómo evaluar

627
00:25:58,640 --> 00:26:00,140
en una situación así

628
00:26:00,140 --> 00:26:01,339
porque no es tan sencillo

629
00:26:01,339 --> 00:26:02,839
ojalá tuviéramos la solución

630
00:26:02,839 --> 00:26:04,380
ojalá tuviéramos

631
00:26:04,380 --> 00:26:09,740
Bueno, pero esa se la tendréis que decir a Estefano

632
00:26:09,740 --> 00:26:11,019
¿Vale?

633
00:26:15,599 --> 00:26:17,000
Pero efectivamente

634
00:26:17,000 --> 00:26:19,519
¿Cómo se evalúa de algo tan amplio como eso?

635
00:26:19,819 --> 00:26:20,500
¿Cómo se hace?

636
00:26:22,640 --> 00:26:24,480
Entonces en mi caso mi opción es

637
00:26:24,480 --> 00:26:28,200
Planteo cosas al menos fáciles

638
00:26:28,200 --> 00:26:30,299
Pues que no impliquen memoria

639
00:26:30,299 --> 00:26:32,680
para no, y ya está

640
00:26:32,680 --> 00:26:34,779
para que ciertas destrezas básicas al menos

641
00:26:34,779 --> 00:26:36,259
no

642
00:26:36,259 --> 00:26:38,700
¿qué hago? ¿os encierro aquí

643
00:26:38,700 --> 00:26:39,420
tres días?

644
00:26:42,829 --> 00:26:45,170
vale, pues entonces, en relación a lo que decías

645
00:26:45,170 --> 00:26:46,710
tú, ¿cuál es la recomendada?

646
00:26:47,369 --> 00:26:48,990
no hay recomendada, pero siempre

647
00:26:48,990 --> 00:26:50,549
hay pautas, a ver

648
00:26:50,549 --> 00:26:53,109
hay muchas pautas que más o menos siempre

649
00:26:53,109 --> 00:26:54,670
con las que siempre trabajamos, que es

650
00:26:54,670 --> 00:26:56,990
cuidado con los null, por ejemplo

651
00:26:56,990 --> 00:26:59,029
no te repitas, hay muchas cosas

652
00:26:59,029 --> 00:27:01,329
esta por ejemplo, es muy fea

653
00:27:01,329 --> 00:27:03,369
porque este es un null pointer excepción

654
00:27:03,369 --> 00:27:05,049
claro, pero eso ya

655
00:27:05,049 --> 00:27:06,670
eso ya es un tema que bueno

656
00:27:06,670 --> 00:27:09,390
que ya sabe, es transversal

657
00:27:09,390 --> 00:27:11,170
a esto, esto es un tema

658
00:27:11,170 --> 00:27:13,329
recurrente que ya sabéis, ya sabéis que en real se evitan

659
00:27:13,329 --> 00:27:15,369
los null, yo este get lo he puesto

660
00:27:15,369 --> 00:27:17,369
por comodidad, claro, pero este get

661
00:27:17,369 --> 00:27:19,049
ya sabéis y es transversal a esto

662
00:27:19,049 --> 00:27:21,190
no lo tenemos que decir todo el rato, que este get

663
00:27:21,190 --> 00:27:23,009
si saco del optional o bestia

664
00:27:23,009 --> 00:27:25,230
pues al optional no estoy usando

665
00:27:25,230 --> 00:27:26,930
todas sus posibilidades, estoy

666
00:27:26,930 --> 00:27:29,250
empeñándome en devolver el null

667
00:27:29,250 --> 00:27:31,269
vale, me empeño en devolver el null

668
00:27:31,269 --> 00:27:32,490
¿por qué ahora? por comodidad

669
00:27:32,490 --> 00:27:35,750
que no quiero devolver el null para asegurarme

670
00:27:35,750 --> 00:27:37,329
o para facilitar que el otro

671
00:27:37,329 --> 00:27:39,230
no tenga un null pointer exception, pues pondría aquí

672
00:27:39,230 --> 00:27:41,349
un or else y pondría

673
00:27:41,349 --> 00:27:43,230
aquí un new cliente, por ejemplo, o pondría

674
00:27:43,230 --> 00:27:44,710
otra cosa, ¿vale?

675
00:27:46,809 --> 00:27:47,170
depende

676
00:27:47,170 --> 00:27:49,630
es que depende del resto de la aplicación

677
00:27:49,630 --> 00:27:51,230
¿cómo se vaya a usar ese caso de uso?

678
00:27:55,230 --> 00:27:57,089
ya, pero claro, todo esto

679
00:27:57,089 --> 00:27:59,029
se basa en que luego tú lo documentas todo

680
00:27:59,029 --> 00:28:00,710
tú te haces aquí tu javadoc

681
00:28:00,710 --> 00:28:03,069
Y el otro, el que te va a usar

682
00:28:03,069 --> 00:28:04,650
Pues tienes ayuda

683
00:28:04,650 --> 00:28:06,869
¿Vale? Esto pues es

684
00:28:06,869 --> 00:28:08,789
Comodidad, pues hacer un optional para sacarlo

685
00:28:08,789 --> 00:28:10,630
Con el get, pues hombre, es

686
00:28:10,630 --> 00:28:12,509
Irte para volver

687
00:28:12,509 --> 00:28:14,829
Pero bueno, ahora como no estamos ahora mismo

688
00:28:14,829 --> 00:28:16,269
Centrados en eso

689
00:28:16,269 --> 00:28:18,710
Vale, pues entonces, pues estupendo

690
00:28:18,710 --> 00:28:20,750
Ya estás, es que no tendría más que hacer

691
00:28:20,750 --> 00:28:22,670
Se acabó, no tendría más que hacer

692
00:28:22,670 --> 00:28:25,109
Si lo que quiero es hacer un CRUD básico de consultas

693
00:28:25,109 --> 00:28:26,950
Entonces, ¿esto va a funcionar? Pues sí

694
00:28:26,950 --> 00:28:28,289
Y fijaos

695
00:28:28,289 --> 00:28:49,930
Aquí, ni entity manager, ni transacción, ni nada de nada, ¿vale? Nada de nada, yo no he visto nada, ¿vale? Vale, aquí, ¿qué me falta en este servicio? Este servicio también tiene que ser un componente, un bin gestionado por Spring, ¿vale?

696
00:28:49,930 --> 00:28:51,970
Pues vamos a anotarlo

697
00:28:51,970 --> 00:28:54,049
¿Vale? Este no se anota solo

698
00:28:54,049 --> 00:28:56,289
Porque este no hereda de nadie

699
00:28:56,289 --> 00:28:57,990
Este es una cosa que estoy haciendo yo

700
00:28:57,990 --> 00:29:00,769
¿Vale? Entonces vamos a anotarlo

701
00:29:00,769 --> 00:29:01,509
Component

702
00:29:01,509 --> 00:29:03,130
Idealmente service

703
00:29:03,130 --> 00:29:04,730
Porque es un servicio

704
00:29:04,730 --> 00:29:07,910
Aunque sea más informativo que otra cosa

705
00:29:07,910 --> 00:29:15,190
Vale, entonces yo aquí repito

706
00:29:15,190 --> 00:29:17,069
Ni me he preocupado

707
00:29:17,069 --> 00:29:18,910
De meterle al service

708
00:29:18,910 --> 00:29:20,049
El entity manager

709
00:29:20,049 --> 00:29:22,490
Para que el service se lo dé al

710
00:29:22,490 --> 00:29:24,690
al DAO, me he olvidado

711
00:29:24,690 --> 00:29:26,490
del contexto de persistencia, Spring

712
00:29:26,490 --> 00:29:28,490
instancia el contexto de persistencia, instancia

713
00:29:28,490 --> 00:29:30,490
todo, me he olvidado del begin

714
00:29:30,490 --> 00:29:32,650
del commit, me olvido de muchas cosas

715
00:29:32,650 --> 00:29:34,609
pero sé

716
00:29:34,609 --> 00:29:35,930
que existen por debajo

717
00:29:35,930 --> 00:29:38,789
sé que existen por debajo porque el saber que existen

718
00:29:38,789 --> 00:29:40,309
por debajo y cómo funciona

719
00:29:40,309 --> 00:29:42,750
puede hacer que en una aplicación muchísimo

720
00:29:42,750 --> 00:29:44,589
más grande, lógicamente en un asuntito

721
00:29:44,589 --> 00:29:46,329
como este, pues tomar

722
00:29:46,329 --> 00:29:48,569
hacerme a mí tomar decisiones sobre por qué

723
00:29:48,569 --> 00:29:50,029
me están fallando las cosas, por qué no

724
00:29:50,029 --> 00:30:12,170
En relación a las transacciones, por ejemplo, recordáis que las transacciones eran un concepto a nivel de servicio, no de DAO, ¿vale? Los DAOs hacían cosas muy atómicas y yo luego en el servicio decidía cuántas de ellas entraban a formar parte de una transacción, ¿vale? ¿Cuántas de ellas entraban a formar parte de una transacción?

725
00:30:12,170 --> 00:30:14,549
Aquí eso no ha cambiado

726
00:30:14,549 --> 00:30:16,890
Aquí la transacción es a nivel de servicio

727
00:30:16,890 --> 00:30:17,569
¿Vale?

728
00:30:18,289 --> 00:30:20,029
Entonces, los métodos

729
00:30:20,029 --> 00:30:22,589
Yo antes en los métodos

730
00:30:22,589 --> 00:30:24,609
Pues me preocupaba de poner el

731
00:30:24,609 --> 00:30:26,150
BeginTransaction, commit

732
00:30:26,150 --> 00:30:28,910
Cuando yo quería agrupar unas

733
00:30:28,910 --> 00:30:30,450
Sentencias en transacción

734
00:30:30,450 --> 00:30:31,769
Aquí

735
00:30:31,769 --> 00:30:33,210
Si yo quiero

736
00:30:33,210 --> 00:30:35,849
Si yo quiero

737
00:30:35,849 --> 00:30:37,049
Que un método

738
00:30:37,049 --> 00:30:40,210
Sea todo el entero, una transacción

739
00:30:40,210 --> 00:30:41,490
De principio a fin

740
00:30:41,490 --> 00:30:43,230
lo tengo que anotar

741
00:30:43,230 --> 00:30:45,650
lo tengo que anotar con transaccional

742
00:30:45,650 --> 00:30:46,809
en este sería una tontería

743
00:30:46,809 --> 00:30:48,849
transaccional

744
00:30:48,849 --> 00:30:51,170
en este sería una tontería

745
00:30:51,170 --> 00:30:53,089
porque es que además solo tengo una sentencia

746
00:30:53,089 --> 00:30:54,710
en este sería una tontería

747
00:30:54,710 --> 00:30:57,369
pero en otros

748
00:30:57,369 --> 00:30:59,410
métodos, como luego podemos ver

749
00:30:59,410 --> 00:31:01,630
en un ejemplo, de tener transaccional

750
00:31:01,630 --> 00:31:03,630
o no tenerlo, la trascendencia

751
00:31:03,630 --> 00:31:05,569
es muy grande, porque si no tengo transaccional

752
00:31:05,569 --> 00:31:07,789
el contexto

753
00:31:07,789 --> 00:31:09,869
de persistencia no va a estar abierto

754
00:31:09,869 --> 00:31:11,890
todo el tiempo de vida del método

755
00:31:11,890 --> 00:31:14,049
cada sentencia va a ir

756
00:31:14,049 --> 00:31:15,890
por libre, entonces me van a salir ahí unos

757
00:31:15,890 --> 00:31:16,869
lazy y unas

758
00:31:16,869 --> 00:31:19,789
excepto y unas cosas muy caras

759
00:31:19,789 --> 00:31:20,049
¿vale?

760
00:31:21,650 --> 00:31:23,650
¿transaccionar hacia que si fallase

761
00:31:23,650 --> 00:31:25,569
empezaba como que no tomaba en cuenta

762
00:31:25,569 --> 00:31:26,269
todo lo que había hecho?

763
00:31:28,970 --> 00:31:30,049
claro, si ha fallado

764
00:31:30,049 --> 00:31:31,509
ahora un rollback, ¿vale?

765
00:31:31,569 --> 00:31:33,029
porque trabaja en modo transacción

766
00:31:33,029 --> 00:31:35,309
entonces, bueno

767
00:31:35,309 --> 00:31:37,769
en general, pues la mayoría de los

768
00:31:37,769 --> 00:31:39,809
métodos de servicio, pues queremos

769
00:31:39,809 --> 00:31:41,609
que sean transacciones, la gran mayoría.

770
00:31:42,910 --> 00:31:43,849
Vale, pues si quisiéramos

771
00:31:43,849 --> 00:31:45,829
probar esto, ahora

772
00:31:45,829 --> 00:31:47,509
aquí nos falta

773
00:31:47,509 --> 00:31:49,329
que es que no hemos configurado nada.

774
00:31:50,089 --> 00:31:51,910
¿Vale? En nuestro proyecto sin sprint

775
00:31:51,910 --> 00:31:53,789
teníamos nuestro persistence

776
00:31:53,789 --> 00:31:55,750
xml y ese

777
00:31:55,750 --> 00:31:57,430
persistence tenía el origen de datos,

778
00:31:57,569 --> 00:31:58,950
lógicamente, y un montón de cosas.

779
00:31:59,650 --> 00:32:00,750
Aquí no está en ningún sitio.

780
00:32:01,730 --> 00:32:03,430
¿Vale? Aquí

781
00:32:03,430 --> 00:32:05,450
lo que ocurre es que el

782
00:32:05,450 --> 00:32:06,349
repositorio

783
00:32:06,349 --> 00:32:09,470
de forma oculta, cuando

784
00:32:09,470 --> 00:32:11,750
instancie tendrá que recibir

785
00:32:11,750 --> 00:32:13,730
todos esos datos a través de otros

786
00:32:13,730 --> 00:32:15,609
bins como data source

787
00:32:15,609 --> 00:32:17,269
bins que tiene que crear

788
00:32:17,269 --> 00:32:20,150
sprint y gestionar

789
00:32:20,150 --> 00:32:21,170
vale

790
00:32:21,170 --> 00:32:23,849
pues no estamos con

791
00:32:23,849 --> 00:32:25,670
sprint boot todavía, estamos con sprint

792
00:32:25,670 --> 00:32:27,930
normal, pues habrá que decirle

793
00:32:27,930 --> 00:32:29,829
que bins son, habrá que configurarlo

794
00:32:29,829 --> 00:32:32,170
de alguna manera, habrá que configurar

795
00:32:32,170 --> 00:32:33,789
esa parte de la fuente de datos

796
00:32:33,789 --> 00:32:35,730
de la base de datos, habrá que

797
00:32:35,730 --> 00:32:37,809
configurarla, vale pues para

798
00:32:37,809 --> 00:32:39,970
eso necesitamos una clase de configuración

799
00:32:39,970 --> 00:32:41,910
que es esta que está subida

800
00:32:41,910 --> 00:32:43,910
al aula virtual, para que la descarguéis

801
00:32:43,910 --> 00:32:45,109
directamente, es esta de aquí

802
00:32:45,109 --> 00:32:47,910
bueno, cambia con tus

803
00:32:47,910 --> 00:32:49,170
a ver, siempre la misma

804
00:32:49,170 --> 00:32:51,509
en cuanto a la parte de configuración, sí

805
00:32:51,509 --> 00:32:53,849
lo que pasa es que normalmente no se usa porque se usa

806
00:32:53,849 --> 00:32:55,829
con Spring Boot, ¿vale? que sería el siguiente

807
00:32:55,829 --> 00:32:57,769
de salto, pero Spring Boot

808
00:32:57,769 --> 00:33:00,009
lo que hace es usar eso que está ahí dentro, o generarlo

809
00:33:00,009 --> 00:33:01,710
vale, entonces si

810
00:33:01,710 --> 00:33:03,690
descargáis esta clase de aquí

811
00:33:03,690 --> 00:33:06,009
si descargáis esta clase

812
00:33:06,009 --> 00:33:07,690
de aquí y la ponéis

813
00:33:07,690 --> 00:33:09,650
en otro paquete aparte,

814
00:33:09,650 --> 00:33:11,569
¿vale? Pues es esta.

815
00:33:46,970 --> 00:33:48,710
Pues esta en su momento, también la usamos,

816
00:33:49,230 --> 00:33:49,970
es una clase

817
00:33:49,970 --> 00:33:51,849
en la que yo

818
00:33:51,849 --> 00:33:54,769
explico, declaro, doy instrucciones

819
00:33:54,769 --> 00:33:56,650
para construir bins

820
00:33:56,650 --> 00:33:58,069
que Spring va a necesitar

821
00:33:58,069 --> 00:34:00,230
inyectarles a otros, ¿vale?

822
00:34:00,829 --> 00:34:02,789
Estos en particular los va a necesitar

823
00:34:02,789 --> 00:34:04,309
para el JPA repository,

824
00:34:04,490 --> 00:34:06,109
los va a necesitar para él. Entonces yo le doy

825
00:34:06,109 --> 00:34:08,409
indicaciones sobre cómo construir. ¿Qué va a

826
00:34:08,409 --> 00:34:10,429
necesitar? Va a necesitar

827
00:34:10,429 --> 00:34:11,670
mi fuente de datos,

828
00:34:11,670 --> 00:34:13,630
la va a necesitar el data source

829
00:34:13,630 --> 00:34:15,789
el jpa repositorio la necesita

830
00:34:15,789 --> 00:34:18,550
pues yo le doy instrucciones de como la construye

831
00:34:18,550 --> 00:34:20,250
vale, le doy aquí

832
00:34:20,250 --> 00:34:21,809
pues el driver que necesita

833
00:34:21,809 --> 00:34:24,210
la dirección

834
00:34:24,210 --> 00:34:26,110
de la base de datos, en fin

835
00:34:26,110 --> 00:34:28,010
esto, lo que teníamos en el persistence

836
00:34:28,010 --> 00:34:31,610
¿qué más va a necesitar

837
00:34:31,610 --> 00:34:33,269
el repositorio?

838
00:34:34,269 --> 00:34:35,769
va a necesitar el entity manager

839
00:34:35,769 --> 00:34:37,550
el contexto de persistencia, sí o sí

840
00:34:37,550 --> 00:34:39,829
¿veis? se anota con bin para decirle a Spring

841
00:34:39,829 --> 00:34:41,530
oye que este es un bin que cuando haga falta

842
00:34:41,530 --> 00:34:43,650
Créalo y mételo a quien haga falta

843
00:34:43,650 --> 00:34:46,070
Vale, pues el entity manager también

844
00:34:46,070 --> 00:34:47,190
Vale

845
00:34:47,190 --> 00:34:49,230
Vale, pues aquí

846
00:34:49,230 --> 00:34:51,789
Aquí tenemos el entity manager factory

847
00:34:51,789 --> 00:34:53,530
Que es el que él va a instanciar

848
00:34:53,530 --> 00:34:55,889
Para luego llamar al método que me crea el entity manager en sí

849
00:34:55,889 --> 00:34:57,309
Vale, pues aquí

850
00:34:57,309 --> 00:34:58,750
Este, que este sí

851
00:34:58,750 --> 00:35:01,670
Yo lo he copiado y pegado del primer sitio

852
00:35:01,670 --> 00:35:03,510
Donde he visto

853
00:35:03,510 --> 00:35:04,610
Pero vamos

854
00:35:04,610 --> 00:35:07,989
Estas son las propiedades

855
00:35:07,989 --> 00:35:08,849
Que estaban en el persistence

856
00:35:08,849 --> 00:35:11,929
O sea, lo mismo que estaba en el persistence

857
00:35:11,929 --> 00:35:14,309
Lo tenemos puesto aquí, pero en bins

858
00:35:14,309 --> 00:35:15,050
¿Vale?

859
00:35:15,730 --> 00:35:17,349
Entonces aquí pues ponemos

860
00:35:17,349 --> 00:35:19,469
Esto de aquí

861
00:35:19,469 --> 00:35:25,090
Con esto veis que crea un fichero

862
00:35:25,090 --> 00:35:27,349
De propiedades, crea un fichero de propiedades

863
00:35:27,349 --> 00:35:28,489
Que lo podíamos haber hecho nosotros

864
00:35:28,489 --> 00:35:31,590
Pero es que así ni siquiera

865
00:35:31,590 --> 00:35:33,429
Ni siquiera metemos más

866
00:35:33,429 --> 00:35:35,789
Basura, crea un fichero de propiedades

867
00:35:35,789 --> 00:35:37,289
Y le fija ese fichero

868
00:35:37,289 --> 00:35:38,710
De propiedades al factory

869
00:35:38,710 --> 00:35:40,309
¿Vale?

870
00:35:40,309 --> 00:35:42,630
Se podría hacer de otra manera

871
00:35:42,630 --> 00:35:45,050
Podríamos hacer nuestro propio fichero de propiedades

872
00:35:45,050 --> 00:35:46,510
Aquí cargarlo

873
00:35:46,510 --> 00:35:48,130
Y fijárselo al factory

874
00:35:48,130 --> 00:35:50,170
¿Esto crea un fichero de propiedades?

875
00:35:50,190 --> 00:35:52,010
Sí, recordad la clase properties

876
00:35:52,010 --> 00:35:53,110
Pero es temporal, ¿no?

877
00:35:53,489 --> 00:35:56,010
No, perdón, no crea un fichero, crea un objeto properties

878
00:35:56,010 --> 00:35:57,809
Que luego tú podrías llevar a un fichero

879
00:35:57,809 --> 00:36:00,809
Claro, entonces este objeto properties

880
00:36:00,809 --> 00:36:03,469
Podríamos tener esto ya en un fichero

881
00:36:03,469 --> 00:36:04,530
Estas propiedades

882
00:36:04,530 --> 00:36:07,230
Entonces, el properties lo podríamos hacer

883
00:36:07,230 --> 00:36:08,309
Leyendo del fichero

884
00:36:08,309 --> 00:36:10,909
así tendríamos el properties

885
00:36:10,909 --> 00:36:11,849
y fijándoselo

886
00:36:11,849 --> 00:36:15,190
pero si nos queremos ahorrar ese fichero

887
00:36:15,190 --> 00:36:17,289
creamos nuestro properties directamente

888
00:36:17,289 --> 00:36:19,030
no leyéndolo del fichero

889
00:36:19,030 --> 00:36:20,929
sino creamos y lo fijamos

890
00:36:20,929 --> 00:36:23,090
¿vale? pero que se podría hacer de otra manera

891
00:36:23,090 --> 00:36:25,150
en cualquier caso este método

892
00:36:25,150 --> 00:36:26,849
en realidad lo único que nos importa es para

893
00:36:26,849 --> 00:36:28,650
ver que

894
00:36:28,650 --> 00:36:30,849
efectivamente el JPA repository

895
00:36:30,849 --> 00:36:32,329
va a necesitar

896
00:36:32,329 --> 00:36:34,030
un entity manager también

897
00:36:34,030 --> 00:36:36,829
que se va a crear a partir del

898
00:36:36,829 --> 00:36:37,349
factory

899
00:36:37,349 --> 00:36:39,449
Él teniendo un factory

900
00:36:39,449 --> 00:36:40,750
Podría ya llamar al

901
00:36:40,750 --> 00:36:42,050
Creativity Manager

902
00:36:42,050 --> 00:36:44,309
Hola

903
00:36:44,309 --> 00:36:50,469
Bueno, estas son las que vimos en el persistence

904
00:36:50,469 --> 00:36:52,050
Que significaban

905
00:36:52,050 --> 00:36:53,869
Esta era que hacer

906
00:36:53,869 --> 00:36:55,829
Si la base de datos no existe

907
00:36:55,829 --> 00:36:58,670
Te la crea, la ignora

908
00:36:58,670 --> 00:37:02,190
Ah, el nombre sí

909
00:37:02,190 --> 00:37:04,289
Se tienen que llamar así porque

910
00:37:04,289 --> 00:37:05,590
Estas son para hibernate

911
00:37:05,590 --> 00:37:08,949
Y Bernat, recordad que es el que está abajo del todo

912
00:37:08,949 --> 00:37:10,630
Bueno, no, el que está abajo del todo es JDBC

913
00:37:10,630 --> 00:37:12,449
Que sigue ahí abajo, aunque ya no lo veamos

914
00:37:12,449 --> 00:37:15,050
JDBC es el último

915
00:37:15,050 --> 00:37:16,309
O sea, todo esto que estamos haciendo

916
00:37:16,309 --> 00:37:18,530
Genera un chorizo

917
00:37:18,530 --> 00:37:20,590
De sentencia JDBC

918
00:37:20,590 --> 00:37:21,909
Es lo que genera, nada más

919
00:37:21,909 --> 00:37:23,829
En última instancia es eso

920
00:37:23,829 --> 00:37:25,989
Todo JDBC, lo que hay debajo

921
00:37:25,989 --> 00:37:26,989
¿Vale?

922
00:37:27,530 --> 00:37:28,389
¿La anotación BIN?

923
00:37:29,969 --> 00:37:31,670
La anotación BIN significa

924
00:37:31,670 --> 00:37:33,070
Oye tú, Sprint

925
00:37:33,070 --> 00:37:35,710
cuando alguien necesite

926
00:37:35,710 --> 00:37:37,650
un entity manager factory

927
00:37:37,650 --> 00:37:39,989
créalo de esta manera

928
00:37:39,989 --> 00:37:41,429
¿quién lo va a necesitar?

929
00:37:42,230 --> 00:37:43,690
el servicio

930
00:37:43,690 --> 00:37:46,269
y el repositorio porque necesita un entity manager

931
00:37:46,269 --> 00:37:47,769
un contexto de persistencia, sí o sí

932
00:37:47,769 --> 00:37:49,889
lo necesita, eso significa

933
00:37:49,889 --> 00:37:51,949
cuando alguien necesite esto

934
00:37:51,949 --> 00:37:54,030
créalo de esta manera y se lo das

935
00:37:54,030 --> 00:37:56,130
no lo tienes que hacer

936
00:37:56,130 --> 00:37:57,929
tú por programa, el pasárselo

937
00:37:57,929 --> 00:37:59,309
en el constructo, el no sé no

938
00:37:59,309 --> 00:38:03,869
y aparte de

939
00:38:03,869 --> 00:38:05,309
el entity manager

940
00:38:05,309 --> 00:38:07,969
y el objeto de datos

941
00:38:07,969 --> 00:38:09,250
la fuente de datos

942
00:38:09,250 --> 00:38:11,789
si vamos a usar transacciones

943
00:38:11,789 --> 00:38:13,849
pues tenemos que crear

944
00:38:13,849 --> 00:38:15,829
también un manejador de transacciones

945
00:38:15,829 --> 00:38:18,010
que siempre usamos transacciones

946
00:38:18,010 --> 00:38:19,090
un manejador de transacciones

947
00:38:19,090 --> 00:38:21,849
¿vale? estos serían los 3 bins

948
00:38:21,849 --> 00:38:23,909
que va a manejar Spring cuando los necesite

949
00:38:23,909 --> 00:38:25,050
en nuestro proyecto concreto

950
00:38:25,050 --> 00:38:27,949
aparte de el repositorio

951
00:38:27,949 --> 00:38:29,670
y el service, que esos es que están

952
00:38:29,670 --> 00:38:30,510
anotados por libre

953
00:38:30,510 --> 00:38:33,769
están anotados por libre, los podríamos poner aquí como

954
00:38:33,769 --> 00:38:35,570
bin, pero

955
00:38:35,570 --> 00:38:37,949
lo liamos

956
00:38:37,949 --> 00:38:39,809
más que nada, como ya tenemos una clase para

957
00:38:39,809 --> 00:38:42,110
ellos hecha, lo anotamos ahí en su clase y se acabó

958
00:38:42,110 --> 00:38:43,829
¿vale? bueno, vamos a parar

959
00:38:43,829 --> 00:38:44,710
un segundín