1
00:00:00,370 --> 00:00:23,629
Vale. Pues habíamos visto que aparte de los métodos que te ofrece ya Spring Data JPA por el hecho de implementar una clase que herede de esta, que son los básicos del CRUD, recuperar por ID, por clave primaria, recuperar todos, borrar por clave primaria y save, o sea, persistir, que serían un poco los básicos.

2
00:00:23,629 --> 00:00:26,089
Pues aparte de los básicos uno puede construir

3
00:00:26,089 --> 00:00:27,370
Sus métodos propios

4
00:00:27,370 --> 00:00:30,250
Basados en el propio

5
00:00:30,250 --> 00:00:32,590
Nombre del método o en una consulta

6
00:00:32,590 --> 00:00:34,429
Las dos formas básicas

7
00:00:34,429 --> 00:00:36,270
Y pum, te los construye

8
00:00:36,270 --> 00:00:37,490
Automáticamente JPA

9
00:00:37,490 --> 00:00:39,469
Entonces

10
00:00:39,469 --> 00:00:42,030
Recuperar por otro

11
00:00:42,030 --> 00:00:43,170
Campo de

12
00:00:43,170 --> 00:00:45,530
De la entidad

13
00:00:45,530 --> 00:00:48,030
Find by y el campo de la entidad

14
00:00:48,030 --> 00:00:50,149
Y ya está, y JPA te lo construye entero

15
00:00:50,149 --> 00:00:51,070
No tienes que hacer nada

16
00:00:51,070 --> 00:00:53,090
Es el ejemplo más típico

17
00:00:53,090 --> 00:00:55,350
Pero vamos, se puede jugar más

18
00:00:55,350 --> 00:00:57,649
De esto, esto es como JPQL

19
00:00:57,649 --> 00:00:59,729
Que si uno se mete, pues ve que hay muchas más posibilidades

20
00:00:59,729 --> 00:01:01,229
Pero ya sabemos las posibilidades

21
00:01:01,229 --> 00:01:03,710
Y luego uno ya se puede meter a ver más cosas

22
00:01:03,710 --> 00:01:05,730
Hay más reglas

23
00:01:05,730 --> 00:01:06,709
Me refiero

24
00:01:06,709 --> 00:01:12,379
O sea, hay más cosas que uno puede

25
00:01:12,379 --> 00:01:14,840
Generar automáticamente a partir del nombre

26
00:01:14,840 --> 00:01:16,519
Que exclusivamente la consulta

27
00:01:16,519 --> 00:01:17,700
De consultar por otro campo

28
00:01:17,700 --> 00:01:20,379
Puedes consultar por campo

29
00:01:20,379 --> 00:01:22,959
Mayor o menor que no sé qué, si es numérico

30
00:01:22,959 --> 00:01:24,200
Puedes hacer más cosas

31
00:01:24,200 --> 00:01:27,159
Puedes consultarlo y además que te lo dé ordenado

32
00:01:27,159 --> 00:01:28,840
O sea, solamente

33
00:01:28,840 --> 00:01:30,840
Por el nombre, siguiendo ciertas reglas

34
00:01:30,840 --> 00:01:32,140
En lo que pones en el nombre

35
00:01:32,140 --> 00:01:34,739
Ya puedes hacer métodos

36
00:01:34,739 --> 00:01:36,959
Que genere Spring Data JPA

37
00:01:36,959 --> 00:01:37,939
Su código automáticamente

38
00:01:37,939 --> 00:01:42,980
Si, creo que es order by

39
00:01:42,980 --> 00:01:44,760
No es sort, pero vamos, sería algo así

40
00:01:44,760 --> 00:01:46,120
Si le pones hgpt

41
00:01:46,120 --> 00:01:48,480
Reglas para no sé qué, pues nos daría

42
00:01:48,480 --> 00:01:49,879
Las que tiene, supongo

43
00:01:49,879 --> 00:01:51,599
Que tiene unas cuantas

44
00:01:51,599 --> 00:01:54,620
vale, que queremos consultas

45
00:01:54,620 --> 00:01:56,659
específicas que no podemos generar

46
00:01:56,659 --> 00:01:58,500
con este protocolo que

47
00:01:58,500 --> 00:02:00,500
tiene tan chulo de a partir del

48
00:02:00,500 --> 00:02:02,719
nombre del método que me genera el código automáticamente

49
00:02:02,719 --> 00:02:03,959
pues plantamos la query

50
00:02:03,959 --> 00:02:06,079
y ya está, vale

51
00:02:06,079 --> 00:02:07,980
como aquí que hicimos esta query

52
00:02:07,980 --> 00:02:09,620
para recuperar

53
00:02:09,620 --> 00:02:12,280
un cliente no por un campo

54
00:02:12,280 --> 00:02:14,500
suyo, sino por un campo de pedido

55
00:02:14,500 --> 00:02:16,159
que tiene una lista dentro

56
00:02:16,159 --> 00:02:18,180
entonces pues aquí

57
00:02:18,180 --> 00:02:20,680
la ventaja del join en JPQL

58
00:02:20,680 --> 00:02:23,400
es que no tenemos que hacer un join

59
00:02:23,400 --> 00:02:25,439
basado en un campo de la tabla

60
00:02:25,439 --> 00:02:27,439
porque es que aquí no hace falta

61
00:02:27,439 --> 00:02:29,379
porque ya está dentro de cliente

62
00:02:29,379 --> 00:02:31,280
pedidos, entonces ya

63
00:02:31,280 --> 00:02:33,340
con poner el join lo que

64
00:02:33,340 --> 00:02:35,819
significa aquí es, oye coge el cliente

65
00:02:35,819 --> 00:02:37,520
pero coge también todos los pedidos

66
00:02:37,520 --> 00:02:38,900
que tiene, coge los todos

67
00:02:38,900 --> 00:02:41,479
aquí también está

68
00:02:41,479 --> 00:02:43,319
el inner y el left que a ti te gusta

69
00:02:43,319 --> 00:02:45,479
tanto, Daniel, también se

70
00:02:45,479 --> 00:02:47,000
podría poner inner y left

71
00:02:47,000 --> 00:02:48,500
inner join y left join

72
00:02:48,500 --> 00:02:50,780
inner join y left join, uno de los dos

73
00:02:50,780 --> 00:02:51,500
nunca sé cuál

74
00:02:51,500 --> 00:02:54,219
uno de los dos es el que

75
00:02:54,219 --> 00:02:56,699
cuando tú unes

76
00:02:56,699 --> 00:02:58,620
una tabla con otra, con uno de los dos

77
00:02:58,620 --> 00:03:01,039
te coge, aunque las

78
00:03:01,039 --> 00:03:02,919
otras sean null, te las coge

79
00:03:02,919 --> 00:03:05,020
también las originales y en el otro

80
00:03:05,020 --> 00:03:06,800
si con la que enlazas no hay

81
00:03:06,800 --> 00:03:08,780
son nulles, no te coge las originales

82
00:03:08,780 --> 00:03:10,860
pero vamos, nunca sé cuál es

83
00:03:10,860 --> 00:03:12,580
inner y cuál es left, pero bueno

84
00:03:12,580 --> 00:03:14,300
no da igual, ¿verdad?

85
00:03:14,300 --> 00:03:18,699
cuando pones el left

86
00:03:18,699 --> 00:03:21,460
no te dejaría los clientes que no tienen pedidos

87
00:03:21,460 --> 00:03:23,360
cuando pones el inner te deja clientes

88
00:03:23,360 --> 00:03:24,620
aunque no tengan pedidos también

89
00:03:24,620 --> 00:03:26,199
seguramente, no lo sé

90
00:03:26,199 --> 00:03:28,479
bueno pues entonces esta

91
00:03:28,479 --> 00:03:31,300
era una consulta que recuperábamos

92
00:03:31,300 --> 00:03:33,120
por un campo de dentro de pedidos

93
00:03:33,120 --> 00:03:35,520
luego no nos quedaba más remedio que hacer el join de pedidos

94
00:03:35,520 --> 00:03:37,479
y aquí ya poníamos la condición

95
00:03:37,479 --> 00:03:37,919
que fuera

96
00:03:37,919 --> 00:03:41,240
pues en este caso era que fuera similar

97
00:03:41,240 --> 00:03:43,699
a el patrón

98
00:03:43,699 --> 00:03:45,860
con delante y detrás lo que fuera

99
00:03:45,860 --> 00:03:47,979
pero podría ser igual, que es el primer

100
00:03:47,979 --> 00:03:49,780
caso que hicimos, entonces

101
00:03:49,780 --> 00:03:51,819
si le ponemos la query, pues le damos el nombre

102
00:03:51,819 --> 00:03:53,759
que nos dé la gana, lógicamente

103
00:03:53,759 --> 00:03:55,360
lo más explicativo posible, claro

104
00:03:55,360 --> 00:03:57,860
y si la query tiene parámetros, pues

105
00:03:57,860 --> 00:03:59,759
hay que poner un pack

106
00:03:59,759 --> 00:04:01,860
de estos, un pack de estos

107
00:04:01,860 --> 00:04:03,780
por cada parámetro, vale

108
00:04:03,780 --> 00:04:05,800
y ya está, y JPA la genera

109
00:04:05,800 --> 00:04:07,479
todo, que esto es realmente lo que es

110
00:04:07,479 --> 00:04:09,840
bonito y bueno de JPA

111
00:04:09,840 --> 00:04:11,240
que te haga los métodos solos

112
00:04:11,240 --> 00:04:13,580
esto es lo chulo

113
00:04:13,580 --> 00:04:14,979
¿Puedes poner más de un concepto ahí?

114
00:04:15,780 --> 00:04:17,259
¿Puedes poner coma y luego...?

115
00:04:17,259 --> 00:04:17,779
Sí, sí, sí.

116
00:04:17,899 --> 00:04:20,019
Pones un pack de eso separado por coma

117
00:04:20,019 --> 00:04:22,600
por cada incógnita que tuvieras en tu query,

118
00:04:22,720 --> 00:04:24,220
porque podrías tener varias incógnitas.

119
00:04:24,379 --> 00:04:26,240
Todas ellas empiezan con los dos puntos delante.

120
00:04:27,379 --> 00:04:27,620
¿Vale?

121
00:04:28,759 --> 00:04:30,139
Aquí pusimos este

122
00:04:30,139 --> 00:04:33,360
para poner un método que fuera a cargar con los pedidos

123
00:04:33,360 --> 00:04:34,399
y aquí es donde vimos

124
00:04:34,399 --> 00:04:37,500
que el cell, si no ponemos el fetch,

125
00:04:37,879 --> 00:04:40,220
en el jpql, si no lo ponemos,

126
00:04:41,899 --> 00:04:43,459
te consulta los pedidos

127
00:04:43,459 --> 00:04:45,579
para hacer lo que fuera, o sea, los tiene en cuenta

128
00:04:45,579 --> 00:04:47,620
para luego hacer la consulta, la web

129
00:04:47,620 --> 00:04:49,500
o lo que fuera, los tiene en cuenta, pero no los

130
00:04:49,500 --> 00:04:51,759
mete, no los incorpora en él

131
00:04:51,759 --> 00:04:53,120
es decir, respeta el lazy

132
00:04:53,120 --> 00:04:55,800
este join respetaría el lazy si lo hubiera

133
00:04:55,800 --> 00:04:57,379
sin embargo

134
00:04:57,379 --> 00:04:59,560
si queremos que en la consulta que

135
00:04:59,560 --> 00:05:01,879
hagamos, ese cliente devuelto

136
00:05:01,879 --> 00:05:03,879
si incorpore también sus pedidos

137
00:05:03,879 --> 00:05:05,459
aunque tengamos un lazy

138
00:05:05,459 --> 00:05:07,680
en la anotación, pues

139
00:05:07,680 --> 00:05:09,639
ponemos aquí después

140
00:05:09,639 --> 00:05:10,839
el fetch, ¿vale?

141
00:05:10,839 --> 00:05:13,579
entonces este método lo hicimos pues para recuperar

142
00:05:13,579 --> 00:05:15,459
los clientes con todos sus pedidos

143
00:05:15,459 --> 00:05:17,339
y que no nos saliera lazy bla bla bla

144
00:05:17,339 --> 00:05:19,740
¿vale? luego ya desde el servicio

145
00:05:19,740 --> 00:05:21,399
pues uno hace sus métodos y se acabó

146
00:05:21,399 --> 00:05:23,720
¿vale? aquí es donde nos quedamos el otro día

147
00:05:23,720 --> 00:05:25,300
¿vale? y bueno

148
00:05:25,300 --> 00:05:27,279
esto está muy bien pero

149
00:05:27,279 --> 00:05:29,480
estos

150
00:05:29,480 --> 00:05:31,779
tres métodos que hemos puesto de ejemplo

151
00:05:31,779 --> 00:05:33,259
que podrían ser

152
00:05:33,259 --> 00:05:34,339
300.000 más

153
00:05:34,339 --> 00:05:37,259
tienen la característica de que

154
00:05:37,259 --> 00:05:38,899
todos ellos nos devuelven un objeto

155
00:05:38,899 --> 00:05:41,060
entidad entero, el cliente entero

156
00:05:41,060 --> 00:05:42,779
que en este caso el cliente entero

157
00:05:42,779 --> 00:05:44,399
no es tan gordo, o sea, tiene

158
00:05:44,399 --> 00:05:46,459
ID, nombre y lista de pedidos

159
00:05:46,459 --> 00:05:50,589
¿vale? tiene ID, nombre

160
00:05:50,589 --> 00:05:52,550
y la lista de pedidos, tampoco tiene tanto

161
00:05:52,550 --> 00:05:55,110
pero claro, porque estamos haciendo un modelo muy sencillito

162
00:05:55,110 --> 00:05:56,430
con poquitas cosas

163
00:05:56,430 --> 00:05:58,730
pero en una situación real

164
00:05:58,730 --> 00:06:00,490
las entidades del modelo

165
00:06:00,490 --> 00:06:02,329
tienen dentro la leche

166
00:06:02,329 --> 00:06:04,009
un montón de propiedades

167
00:06:04,009 --> 00:06:06,610
de colecciones que las están ligando

168
00:06:06,610 --> 00:06:07,829
con otras, un mogollón

169
00:06:07,829 --> 00:06:28,410
Entonces, ¿realmente necesitamos que todas las consultas que vamos a poner aquí, luego en los servicios, estén basadas en retornos sobre los objetos enteritos? Seguramente la información me sobre, ¿vale? Yo no necesito tanta información.

170
00:06:28,410 --> 00:06:48,470
O sea, ese método a lo mejor está en particular solo para trabajar con el nombre y no sé qué más del cliente. Entonces, yo estoy condenada a devolver siempre objetos completos con todo lo que tienen dentro, que eso es no solo pesado, sino pues peligroso.

171
00:06:48,470 --> 00:07:04,449
O sea, estoy mandando fuera de mi servicio, estoy mandando el objeto con un montón de información, ¿vale? Es decir, estoy como si estuviera lanzando fuera, exponiendo al universo toda mi lógica de negocio entera cada vez que hago un servicio.

172
00:07:04,449 --> 00:07:06,389
Toda la lógica de negocio

173
00:07:06,389 --> 00:07:06,990
Va para afuera

174
00:07:06,990 --> 00:07:09,610
¿Vale? Entonces, bueno

175
00:07:09,610 --> 00:07:12,430
¿Realmente es necesario?

176
00:07:12,910 --> 00:07:14,089
Siempre va a ser necesario

177
00:07:14,089 --> 00:07:15,069
Hay veces que sí, ¿no?

178
00:07:15,110 --> 00:07:17,149
Si yo aquí quiero devolver

179
00:07:17,149 --> 00:07:20,029
El cliente entero con todos sus pedidos

180
00:07:20,029 --> 00:07:21,410
Con todo, pues ya está

181
00:07:21,410 --> 00:07:22,910
Pero no siempre es necesario

182
00:07:22,910 --> 00:07:25,730
¿Vale? Pues, ¿qué hacemos normalmente?

183
00:07:25,850 --> 00:07:26,709
¿Qué se hace normalmente?

184
00:07:27,490 --> 00:07:29,689
Hacer entidades que no son entidades

185
00:07:29,689 --> 00:07:32,110
Del modelo, sino que están pensadas

186
00:07:32,110 --> 00:07:33,829
Exclusivamente para recoger

187
00:07:33,829 --> 00:07:36,310
datos que tú

188
00:07:36,310 --> 00:07:37,949
quieres consultar

189
00:07:37,949 --> 00:07:39,990
y luego transmitir. O sea, son los objetos

190
00:07:39,990 --> 00:07:41,889
que sirven para almacenar

191
00:07:41,889 --> 00:07:43,629
resultados de consultas.

192
00:07:43,970 --> 00:07:45,649
¿Vale? ¿Perdón?

193
00:07:45,730 --> 00:07:46,709
Como tablas intermedias.

194
00:07:47,529 --> 00:07:49,810
Como si fuera una vista

195
00:07:49,810 --> 00:07:51,850
en el concepto de SQL, ¿vale?

196
00:07:51,889 --> 00:07:52,750
Como si fuera una vista

197
00:07:52,750 --> 00:07:55,910
que tú en una vista seleccionas

198
00:07:55,910 --> 00:07:57,610
qué datos te gustan de una tabla

199
00:07:57,610 --> 00:07:59,649
y no los tienes todos todo el rato

200
00:07:59,649 --> 00:08:01,810
porque es un mogollón. Pues es como si fuera

201
00:08:01,810 --> 00:08:03,910
una vista, entonces no es una entidad del modelo

202
00:08:03,910 --> 00:08:06,110
no forma parte de la lógica de negocio

203
00:08:06,110 --> 00:08:07,930
la lógica de negocio son mis entidades

204
00:08:07,930 --> 00:08:09,949
del modelo y ahí está toda la información

205
00:08:09,949 --> 00:08:11,870
con todas las anotaciones, con todo

206
00:08:11,870 --> 00:08:14,129
entonces yo eso lo dejo ahí protegidito

207
00:08:14,129 --> 00:08:16,170
y lo que

208
00:08:16,170 --> 00:08:18,209
expongo al exterior, lo que mando

209
00:08:18,209 --> 00:08:20,310
fuera a través de los métodos

210
00:08:20,310 --> 00:08:22,290
primero del repositorio y luego del servicio

211
00:08:22,290 --> 00:08:24,170
son estas

212
00:08:24,170 --> 00:08:25,910
vistas, entre comillas

213
00:08:25,910 --> 00:08:27,990
estas vistas que para cada consulta

214
00:08:27,990 --> 00:08:30,009
tienen los datos que le interesará

215
00:08:30,009 --> 00:08:31,730
a esa consulta, exclusivamente esos

216
00:08:31,730 --> 00:08:33,509
y esos ni tienen anotaciones

217
00:08:33,509 --> 00:08:35,330
ni tienen nada, porque no pertenecen a la modelo

218
00:08:35,330 --> 00:08:36,090
ni pertenecen a nada

219
00:08:36,090 --> 00:08:39,129
esos son los famosos DTOs

220
00:08:39,129 --> 00:08:41,809
que se llaman los Data Transfer Object

221
00:08:41,809 --> 00:08:43,950
que forman parte

222
00:08:43,950 --> 00:08:45,570
de cualquier arquitectura de estas

223
00:08:45,570 --> 00:08:47,789
y DTOs, pues de nuevo

224
00:08:47,789 --> 00:08:49,850
es otra capa más

225
00:08:49,850 --> 00:08:50,870
como le gustan a Pablo

226
00:08:50,870 --> 00:08:53,389
pues sí, lo podríamos ver como otra capa más

227
00:08:53,389 --> 00:08:55,929
en realidad no es que sea una capa

228
00:08:55,929 --> 00:08:58,429
es una capa de vistas

229
00:08:58,429 --> 00:09:05,990
es como un paquete con vistas

230
00:09:05,990 --> 00:09:07,950
es lo que yo realmente

231
00:09:07,950 --> 00:09:09,250
quiero mandar hacia afuera

232
00:09:09,250 --> 00:09:11,450
lo que yo realmente quiero mandar hacia afuera

233
00:09:11,450 --> 00:09:13,909
aquí a lo mejor no se ve

234
00:09:13,909 --> 00:09:15,090
tanto la utilidad de eso

235
00:09:15,090 --> 00:09:17,330
pero cuando tienes una arquitectura p-rest

236
00:09:17,330 --> 00:09:18,649
es básico

237
00:09:18,649 --> 00:09:20,629
como ya

238
00:09:20,629 --> 00:09:22,830
veremos la semana que viene

239
00:09:22,830 --> 00:09:25,450
porque tú cuando pides tus objetos

240
00:09:25,450 --> 00:09:28,110
haces tus consultas en una arquitectura p-rest

241
00:09:28,110 --> 00:09:29,250
aquí cuando lo haces

242
00:09:29,250 --> 00:09:31,769
el resultado está en tu propia aplicación

243
00:09:31,769 --> 00:09:33,190
tu propio main o donde sea

244
00:09:33,190 --> 00:09:35,450
y tú pues con eso

245
00:09:35,450 --> 00:09:37,789
ya haces lo que seas, traes lo que quieras

246
00:09:37,789 --> 00:09:40,049
lo pasas a no sé dónde, te metes en el objeto

247
00:09:40,049 --> 00:09:42,149
pero cuando tú haces la consulta

248
00:09:42,149 --> 00:09:43,830
desde un servicio API REST

249
00:09:43,830 --> 00:09:44,950
desde tu web

250
00:09:44,950 --> 00:09:47,870
pues lo que te devuelve es el resultado

251
00:09:47,870 --> 00:09:49,889
de esa consulta mapeado en un JSON

252
00:09:49,889 --> 00:09:52,169
entonces ¿qué necesidad tienes tú

253
00:09:52,169 --> 00:09:53,070
de mapear en un JSON?

254
00:09:53,789 --> 00:09:56,289
un objeto que tiene millones de cosas dentro

255
00:09:56,289 --> 00:09:57,250
un JSON

256
00:09:57,250 --> 00:09:58,629
manejable.

257
00:09:59,730 --> 00:10:01,669
Entonces, tú lo que te haces son

258
00:10:01,669 --> 00:10:03,350
tus data transfer object que tienen

259
00:10:03,350 --> 00:10:05,470
solo la información que necesitas y eso

260
00:10:05,470 --> 00:10:07,490
ya sí que se mapea en tu JSON ya cortito

261
00:10:07,490 --> 00:10:09,429
y manejable. Es que, de hecho,

262
00:10:09,470 --> 00:10:10,570
la locura que se monta,

263
00:10:11,330 --> 00:10:13,370
imaginaos aquí, mapear

264
00:10:13,370 --> 00:10:15,149
esto en un JSON. O sea, yo saco esto.

265
00:10:16,509 --> 00:10:17,330
Saco un cliente

266
00:10:17,330 --> 00:10:18,789
con mi método de servicio y cliente.

267
00:10:19,909 --> 00:10:21,190
Y el API REST, el pobre,

268
00:10:21,669 --> 00:10:23,389
pues, ¿qué hace? Lo que hace

269
00:10:23,389 --> 00:10:25,269
es, te lo mapea

270
00:10:25,269 --> 00:10:27,230
un JSON, porque es lo que tú vas a ver.

271
00:10:27,250 --> 00:10:28,990
Te lo mapea un JSON

272
00:10:28,990 --> 00:10:30,649
Entonces, mapear a un JSON

273
00:10:30,649 --> 00:10:31,710
ID y nombre está bien

274
00:10:31,710 --> 00:10:34,070
Pero ponte a mapear a un JSON pedidos

275
00:10:34,070 --> 00:10:36,470
Muy bien, pedido, me pongo a mapear

276
00:10:36,470 --> 00:10:37,549
En JSON pedidos

277
00:10:37,549 --> 00:10:40,610
Y ID y concepto

278
00:10:40,610 --> 00:10:42,529
Pero ahora tengo que mapear cliente

279
00:10:42,529 --> 00:10:44,850
Muy bien, me voy a poner a mapear cliente

280
00:10:44,850 --> 00:10:45,190
Tiene

281
00:10:45,190 --> 00:10:48,730
ID y nombre, pero tiene pedidos

282
00:10:48,730 --> 00:10:50,210
Con lo cual me meto en un bucle infinito

283
00:10:50,210 --> 00:10:52,450
Entonces, yo de repente hago

284
00:10:52,450 --> 00:10:53,730
Una inocente petición

285
00:10:53,730 --> 00:10:55,690
Y mi página web no para

286
00:10:55,690 --> 00:10:58,809
Claro, solo puedo ñapar

287
00:10:58,809 --> 00:11:00,529
Poniendo anotaciones

288
00:11:00,529 --> 00:11:02,009
Pues ignoran el Jason

289
00:11:02,009 --> 00:11:03,649
Pero ya es hacer una ñapa

290
00:11:03,649 --> 00:11:05,470
Ya es hacer

291
00:11:05,470 --> 00:11:07,990
Una ñapa y decirle a Jackson

292
00:11:07,990 --> 00:11:10,389
Esta propiedad no cuenta, pero claro, no cuenta para la PIRRES

293
00:11:10,389 --> 00:11:11,669
A lo mejor sí cuenta para otros

294
00:11:11,669 --> 00:11:14,210
Conclusión

295
00:11:14,210 --> 00:11:15,490
Deteos, ya está

296
00:11:15,490 --> 00:11:17,690
¿Os lo he vendido suficientemente bien?

297
00:11:17,690 --> 00:11:19,649
No, ya estáis convencidos

298
00:11:19,649 --> 00:11:21,210
¿No? Vale, pues

299
00:11:21,210 --> 00:11:23,049
Entonces

300
00:11:23,049 --> 00:11:26,529
Ya respiro

301
00:11:26,529 --> 00:11:28,710
Porque es que sois un poquito

302
00:11:28,710 --> 00:11:29,909
Exquisitos

303
00:11:29,909 --> 00:11:32,629
Estáis todo el rato, pues no lo veo

304
00:11:32,629 --> 00:11:33,789
Pues yo creo que no sé cuánto

305
00:11:33,789 --> 00:11:38,529
Es que claro, todos hacéis tambalear

306
00:11:38,529 --> 00:11:39,730
Mis cimientos que ya son

307
00:11:39,730 --> 00:11:41,529
Frágiles de por sí

308
00:11:41,529 --> 00:11:46,649
No hombre, ya lo sé

309
00:11:46,649 --> 00:11:47,990
Vale, pues entonces

310
00:11:47,990 --> 00:11:50,529
Seguro que no

311
00:11:50,529 --> 00:11:52,850
Vamos a meterlo

312
00:11:52,850 --> 00:11:54,289
En un paquetito

313
00:11:54,289 --> 00:11:58,850
Y es que realmente

314
00:11:58,850 --> 00:12:00,809
Yo sé que encima os provoco, ya lo sé

315
00:12:00,809 --> 00:12:01,850
Pero es que

316
00:12:01,850 --> 00:12:04,490
La cantidad de paquetes que llevamos

317
00:12:04,490 --> 00:12:06,870
Para solo poder hacer un main

318
00:12:06,870 --> 00:12:08,690
Que en una consulta

319
00:12:08,690 --> 00:12:09,309
JDBC

320
00:12:09,309 --> 00:12:12,470
Es un getConnection

321
00:12:12,470 --> 00:12:14,970
Se ejecute query y ya está

322
00:12:14,970 --> 00:12:16,870
Pues la cantidad de paquetes

323
00:12:16,870 --> 00:12:18,549
Que llevamos, pero claro, ¿quién escala

324
00:12:18,549 --> 00:12:20,750
Una aplicación con JDBC y quién escala esto?

325
00:12:20,830 --> 00:12:22,629
Con JDBC, pues no es trivial

326
00:12:22,629 --> 00:12:24,889
Al escalarla, con esto se supone que sí

327
00:12:24,889 --> 00:12:25,690
Ampliarla

328
00:12:25,690 --> 00:12:33,850
A ver, yo hice

329
00:12:33,850 --> 00:12:35,389
Espera, esto no lo voy a grabar

330
00:12:35,389 --> 00:12:36,490
A ver, no porque

331
00:12:36,490 --> 00:12:40,070
Ya he contado la anécdota

332
00:12:40,070 --> 00:12:41,429
De vieja cebolleta

333
00:12:41,429 --> 00:12:42,889
Seguimos

334
00:12:42,889 --> 00:12:45,830
Vale, pues vamos a hacer

335
00:12:45,830 --> 00:12:47,450
Un paso intermedio, venga

336
00:12:47,450 --> 00:12:49,730
Tenemos aquí una

337
00:12:49,730 --> 00:12:51,210
Una

338
00:12:51,210 --> 00:12:53,149
Un modelo tan pequeñito

339
00:12:53,149 --> 00:12:54,950
Que pocas cosas podemos hacer

340
00:12:54,950 --> 00:12:57,269
Pero por ejemplo, vamos a recoger

341
00:12:57,269 --> 00:12:57,690
El

342
00:12:57,690 --> 00:13:01,789
El nombre

343
00:13:01,789 --> 00:13:03,269
Porque es que en pedido repository

344
00:13:03,269 --> 00:13:05,230
Poco podemos hacer, solo tiene un cliente

345
00:13:05,230 --> 00:13:06,889
Vamos a recoger

346
00:13:06,889 --> 00:13:09,070
El id

347
00:13:09,070 --> 00:13:10,970
Y el nombre

348
00:13:10,970 --> 00:13:13,730
Y algo

349
00:13:13,730 --> 00:13:15,210
Que se salga del

350
00:13:15,210 --> 00:13:16,830
Que sea un agregado

351
00:13:16,830 --> 00:13:19,250
Pues vamos a recoger id

352
00:13:19,250 --> 00:13:19,950
Nombre

353
00:13:19,950 --> 00:13:22,629
y el primero de la lista

354
00:13:22,629 --> 00:13:24,850
ni siquiera el más caro

355
00:13:24,850 --> 00:13:25,690
es que no tenemos ni precio

356
00:13:25,690 --> 00:13:29,269
y el primer pedido de la lista

357
00:13:29,269 --> 00:13:31,269
vale

358
00:13:31,269 --> 00:13:33,169
eso lo podríamos hacer

359
00:13:33,169 --> 00:13:34,570
con un JPQL directamente

360
00:13:34,570 --> 00:13:37,169
pero si no tendríamos que hacer que en el repositorio

361
00:13:37,169 --> 00:13:39,190
nos devuelva a todos y luego en el servicio

362
00:13:39,190 --> 00:13:40,789
ya el primero de la lista

363
00:13:40,789 --> 00:13:41,970
entonces

364
00:13:41,970 --> 00:13:47,389
el cliente con su número de pedidos

365
00:13:47,389 --> 00:13:49,490
cliente y cuantos has pedido

366
00:13:49,490 --> 00:13:50,730
El cliente y cuántos has pedido

367
00:13:50,730 --> 00:13:53,090
Esa sí que es una consulta que quizá tiene más sentido

368
00:13:53,090 --> 00:13:54,830
El cliente y cuántos has pedido

369
00:13:54,830 --> 00:13:56,149
Vale, pues entonces

370
00:13:56,149 --> 00:13:59,490
Esa información se correspondería

371
00:13:59,490 --> 00:14:00,629
A una vista de esta manera

372
00:14:00,629 --> 00:14:02,450
Vale

373
00:14:02,450 --> 00:14:06,090
Primera, hay como dos posibilidades

374
00:14:06,090 --> 00:14:07,389
De DTO, de vistas

375
00:14:07,389 --> 00:14:09,629
Primera, la más

376
00:14:09,629 --> 00:14:11,769
Cliente

377
00:14:11,769 --> 00:14:13,370
En un pedidos

378
00:14:13,370 --> 00:14:18,679
La más sencilla

379
00:14:18,679 --> 00:14:20,779
Es

380
00:14:20,779 --> 00:14:22,740
Yo me hago aquí una interfaz, mi vista es una

381
00:14:22,740 --> 00:14:24,740
interfaz y me da

382
00:14:24,740 --> 00:14:26,440
los datos con el get, vale

383
00:14:26,440 --> 00:14:27,860
pues hemos dicho

384
00:14:27,860 --> 00:14:30,179
era long, verdad, el id

385
00:14:30,179 --> 00:14:32,200
long get id

386
00:14:32,200 --> 00:14:34,700
es uno de los parámetros

387
00:14:34,700 --> 00:14:36,580
el otro era nombre, string

388
00:14:36,580 --> 00:14:39,120
get

389
00:14:39,120 --> 00:14:39,940
nombre

390
00:14:39,940 --> 00:14:44,159
y el número de pedidos

391
00:14:44,159 --> 00:14:46,019
que sería un integer

392
00:14:46,019 --> 00:14:49,659
num pedidos

393
00:14:49,659 --> 00:14:53,110
del cliente

394
00:14:53,110 --> 00:14:55,370
vale, esta es una vista muy sencilla

395
00:14:55,370 --> 00:14:59,289
ahora

396
00:14:59,289 --> 00:15:05,899
entonces fijaos que

397
00:15:05,899 --> 00:15:08,200
puede haber muchos en una aplicación

398
00:15:08,200 --> 00:15:10,220
porque cada consulta es interesante

399
00:15:10,220 --> 00:15:12,139
que tenga agregados de cosas distintas

400
00:15:12,139 --> 00:15:14,240
que son transversales a las entidades en sí

401
00:15:14,240 --> 00:15:16,159
vale, ahora yo ya me voy a mi

402
00:15:16,159 --> 00:15:17,980
repositorio, pues venga

403
00:15:17,980 --> 00:15:19,779
vamos a hacer una query

404
00:15:19,779 --> 00:15:23,799
que ahora veremos

405
00:15:23,799 --> 00:15:25,000
como la hacemos

406
00:15:25,000 --> 00:15:32,639
vale, y esta query

407
00:15:32,639 --> 00:15:34,440
se va a implementar

408
00:15:34,440 --> 00:15:46,519
en el método que me devuelve una lista de esta, me devuelve cada cliente con su número

409
00:15:46,519 --> 00:16:10,389
de pedidos. Get clientes con un pedidos. Entonces no tendría parámetros porque me los tenía

410
00:16:10,389 --> 00:16:20,559
que devolver todos. Y esto pues nada. Y ahora hacemos nuestra JPQL. Vamos a lanzarnos a

411
00:16:20,559 --> 00:16:28,539
hacer lo que sea y si no pues se la pedimos son clientes ahora yo aquí no pongo esto esta es la

412
00:16:28,539 --> 00:16:36,120
historia que aquí no tiene sentido hacer esto from from cliente c vale aquí no tiene sentido

413
00:16:36,120 --> 00:16:44,000
aquí lo que yo pongo son los campos que quiero hacer exacto que serían c punto y de verdad c

414
00:16:44,000 --> 00:16:45,139
Punto nombre

415
00:16:45,139 --> 00:16:47,340
Y ahora

416
00:16:47,340 --> 00:16:49,480
La cuenta de pedidos

417
00:16:49,480 --> 00:16:52,139
Que sería count c punto

418
00:16:52,139 --> 00:16:53,460
Pedidos

419
00:16:53,460 --> 00:16:56,299
Pero claro, para que me tenga los pedidos

420
00:16:56,299 --> 00:16:58,299
En cuenta en esta jpql

421
00:16:58,860 --> 00:16:59,899
Tengo que hacer el join

422
00:16:59,899 --> 00:17:01,700
Si no, no me

423
00:17:01,700 --> 00:17:03,259
Los va a tener en cuenta

424
00:17:03,259 --> 00:17:06,299
Count c punto pedidos

425
00:17:06,299 --> 00:17:07,220
Como el alias

426
00:17:07,220 --> 00:17:10,259
Porque ya le he puesto un alias

427
00:17:10,259 --> 00:17:14,079
Perdón

428
00:17:14,079 --> 00:17:17,319
count es de SQL

429
00:17:17,319 --> 00:17:19,460
¿verdad? en SQL es count y en JPQL

430
00:17:19,460 --> 00:17:21,099
juraría que también

431
00:17:21,099 --> 00:17:25,079
bueno

432
00:17:25,079 --> 00:17:26,920
es como SQL, que da igual

433
00:17:26,920 --> 00:17:28,900
no es sensible a mayúscula, minúscula

434
00:17:28,900 --> 00:17:29,400
¿vale?

435
00:17:29,920 --> 00:17:31,259
en Android por ejemplo lo tenemos

436
00:17:31,259 --> 00:17:35,099
Manoli era sensible a mayúscula

437
00:17:35,099 --> 00:17:37,240
vale, a ver

438
00:17:37,240 --> 00:17:39,200
igual

439
00:17:39,200 --> 00:17:40,160
si os gusta más así

440
00:17:40,160 --> 00:17:43,319
para que se vea claro que esto es JPQL

441
00:17:43,319 --> 00:18:07,900
Y ahora, yo hice pedidos, pero claro, para que no me devuelva, porque la consulta así tal cual, o sea, estoy guiándome por SQL, la consulta así tal cual me devolvería el primer cliente tantas veces como pedidos tiene con su número de pedidos, porque se va a unir a pedidos.

442
00:18:07,900 --> 00:18:09,599
entonces lo tenemos que agrupar, ¿no?

443
00:18:09,599 --> 00:18:10,279
con el group by

444
00:18:10,279 --> 00:18:13,380
group by

445
00:18:13,380 --> 00:18:15,740
lo vamos a agrupar

446
00:18:15,740 --> 00:18:17,420
por c.id

447
00:18:17,420 --> 00:18:19,519
para que todo esto me lo agrupe

448
00:18:19,519 --> 00:18:22,019
los que sean iguales, todos los que tengan

449
00:18:22,019 --> 00:18:24,200
todos los resultados de la consulta

450
00:18:24,200 --> 00:18:26,059
que tengan id y nombre igualitos

451
00:18:26,059 --> 00:18:27,579
pues que lo agrupe

452
00:18:27,579 --> 00:18:29,539
porque todos van a tener el count de pedidos igual, ¿no?

453
00:18:30,859 --> 00:18:31,960
vale, entonces

454
00:18:31,960 --> 00:18:32,740
agrúpamelo

455
00:18:32,740 --> 00:18:36,500
y ya está

456
00:18:36,500 --> 00:18:41,259
yo creo que esta JPQL

457
00:18:41,259 --> 00:18:41,920
estaría bien

458
00:18:41,920 --> 00:18:45,099
vamos a lanzarnos, si no rápidamente la cambiamos

459
00:18:45,099 --> 00:18:45,559
y ya está

460
00:18:45,559 --> 00:18:49,039
porque no

461
00:18:49,039 --> 00:18:51,200
es que no voy a seleccionar el cliente

462
00:18:51,200 --> 00:18:53,259
entero, estoy seleccionando

463
00:18:53,259 --> 00:18:55,160
campos que a mí me da la gana

464
00:18:55,160 --> 00:18:57,119
elegir para formar

465
00:18:57,119 --> 00:18:58,519
esta vista

466
00:18:58,519 --> 00:19:01,200
o sea, estoy construyendo esta vista con campos

467
00:19:01,200 --> 00:19:03,240
sueltos, uno es el ID, otro es

468
00:19:03,240 --> 00:19:05,000
el nombre, pero podría a lo mejor

469
00:19:05,000 --> 00:19:07,160
Ni siquiera creer el ID, entonces no pongo ni el ID

470
00:19:07,160 --> 00:19:08,940
¿Vale? O sea, estoy seleccionando

471
00:19:08,940 --> 00:19:10,940
Campos sueltos de las tablas que estoy

472
00:19:10,940 --> 00:19:12,880
Haciendo, cliente y pedidos unidas

473
00:19:12,880 --> 00:19:17,240
Claro, en este caso

474
00:19:17,240 --> 00:19:18,440
Una lista, claro, porque

475
00:19:18,440 --> 00:19:20,900
No tengo un web, entonces

476
00:19:20,900 --> 00:19:21,259
Todos

477
00:19:21,259 --> 00:19:24,039
Bueno, pues entonces

478
00:19:24,039 --> 00:19:25,660
Esto en principio

479
00:19:25,660 --> 00:19:27,920
Creemos que estaría

480
00:19:27,920 --> 00:19:30,099
Vamos a ponerlo en el servicio, claro

481
00:19:30,099 --> 00:19:39,009
Pues venga, le ponemos

482
00:19:39,009 --> 00:19:40,809
Un método

483
00:19:40,809 --> 00:19:46,109
public list

484
00:19:46,109 --> 00:19:49,819
cliente num

485
00:19:49,819 --> 00:19:51,180
pedidos

486
00:19:51,180 --> 00:19:55,720
y este sería

487
00:19:55,720 --> 00:19:58,559
lista clientes

488
00:19:58,559 --> 00:20:00,420
con num

489
00:20:00,420 --> 00:20:01,640
pedidos

490
00:20:01,640 --> 00:20:06,410
y este te devuelve directamente

491
00:20:06,410 --> 00:20:10,210
clientes

492
00:20:10,210 --> 00:20:11,069
punto

493
00:20:11,069 --> 00:20:14,170
get clientes

494
00:20:14,170 --> 00:20:15,210
num pedidos

495
00:20:15,210 --> 00:20:22,829
ahí está, y ahora nuestro main

496
00:20:22,829 --> 00:20:26,119
que está

497
00:20:26,119 --> 00:20:27,259
Aquí

498
00:20:27,259 --> 00:20:31,789
Nuestro main que está aquí

499
00:20:31,789 --> 00:20:33,769
Todo esto ya nos había funcionado

500
00:20:33,769 --> 00:20:41,950
Y ahora vamos a hacer

501
00:20:41,950 --> 00:20:44,170
Nuestro servicio

502
00:20:44,170 --> 00:20:48,750
Los tabuladores ya ni sé cómo están

503
00:20:48,750 --> 00:20:50,450
Lista clientes

504
00:20:50,450 --> 00:20:51,690
Con numpedidos

505
00:20:51,690 --> 00:20:54,390
Punto

506
00:20:54,390 --> 00:20:56,450
Para cada cliente con numpedidos

507
00:20:56,990 --> 00:21:00,029
Este es un

508
00:21:00,029 --> 00:21:01,190
Interfaz

509
00:21:01,190 --> 00:21:04,069
No tiene un toString

510
00:21:04,069 --> 00:21:06,190
Así que vete a saber el system out cual es

511
00:21:06,190 --> 00:21:09,069
Pues para cada uno de ellos

512
00:21:09,069 --> 00:21:10,849
Vamos a mostrar directamente

513
00:21:10,849 --> 00:21:19,240
Vamos a mostrar

514
00:21:19,240 --> 00:21:23,859
X.getNombre

515
00:21:23,859 --> 00:21:27,900
Del id pasamos para

516
00:21:27,900 --> 00:21:30,779
X.

517
00:21:31,779 --> 00:21:33,859
Claro, JPA es tan listo

518
00:21:33,859 --> 00:21:36,480
Que él ya te instancia un objeto

519
00:21:36,480 --> 00:21:37,819
Que pertenezca a esa interfaz

520
00:21:37,819 --> 00:21:38,740
Cuando te hace la query

521
00:21:38,740 --> 00:21:39,599
¿Vale?

522
00:21:40,240 --> 00:21:41,720
Es decir, ¿qué hace JPA?

523
00:21:42,240 --> 00:21:43,819
JPA cuando haga este select

524
00:21:43,819 --> 00:21:47,099
Claro, le va a dar estos tres valores

525
00:21:47,099 --> 00:21:49,720
Como ve que tiene que volcarlos aquí

526
00:21:49,720 --> 00:21:51,480
Como ve que tiene que volcarlos aquí

527
00:21:51,480 --> 00:21:53,700
Pues te instancia un objeto

528
00:21:53,700 --> 00:21:54,799
Que implemente esta clase

529
00:21:54,799 --> 00:21:56,420
Y te lo mete, y ya está

530
00:21:56,420 --> 00:21:58,279
Y luego tú, ¿qué es lo único que puedes hacer?

531
00:21:58,619 --> 00:22:00,779
Sacarle los datos, no puedes hacer nada más

532
00:22:00,779 --> 00:22:02,059
Sacarle los datos

533
00:22:02,059 --> 00:22:05,140
Entonces vamos a ver si tenemos suerte

534
00:22:05,140 --> 00:22:06,000
Y nos falla

535
00:22:06,000 --> 00:22:09,599
Y podemos arreglar el fallo

536
00:22:13,819 --> 00:22:14,380
¿Qué?

537
00:22:16,000 --> 00:22:17,339
No, ojalá falle

538
00:22:17,339 --> 00:22:19,079
Porque si falle vamos a aprender algo

539
00:22:19,079 --> 00:22:19,759
Eso sin duda

540
00:22:19,759 --> 00:22:21,720
Si no falla no vamos a aprender nada

541
00:22:21,720 --> 00:22:25,920
Bueno, que esto funciona en este caso muy concreto

542
00:22:25,920 --> 00:22:28,160
Pero a lo mejor está muy próximo a un fallo

543
00:22:28,160 --> 00:22:29,160
Y si no lo pillamos

544
00:22:29,160 --> 00:22:30,880
No aprendemos

545
00:22:30,880 --> 00:22:33,119
Claro

546
00:22:33,119 --> 00:22:38,980
Qué poca resistencia

547
00:22:38,980 --> 00:22:40,720
La tolerancia a la frustración tenéis

548
00:22:40,720 --> 00:22:45,339
Qué suerte hemos tenido

549
00:22:45,339 --> 00:22:46,599
Vale

550
00:22:46,599 --> 00:22:49,480
El select me lo ha hecho

551
00:22:49,480 --> 00:22:50,940
Con lo cual la

552
00:22:50,940 --> 00:22:53,119
La sintaxis jpql está bien

553
00:22:53,119 --> 00:22:53,980
Hasta ahí hemos llegado

554
00:22:53,980 --> 00:22:55,539
Pero

555
00:22:55,539 --> 00:22:58,559
Invalid method bla bla bla

556
00:22:58,559 --> 00:23:03,180
Get client en un pedidos

557
00:23:03,180 --> 00:23:04,660
Como que no, está mal

558
00:23:04,660 --> 00:23:06,660
Ah, es que he puesto en un pedidos

559
00:23:06,660 --> 00:23:08,539
En lugar de poner get en un pedidos

560
00:23:08,539 --> 00:23:09,220
¿Verdad?

561
00:23:11,160 --> 00:23:12,019
Vale, entonces a ver

562
00:23:12,019 --> 00:23:14,319
¿Dónde está el cliente en un pedidos?

563
00:23:14,579 --> 00:23:14,799
Ah

564
00:23:14,799 --> 00:23:16,380
Vale, vale

565
00:23:16,380 --> 00:23:18,539
Espérate, es que aquí yo me he inventado

566
00:23:18,539 --> 00:23:19,299
Un nombre un poco raro

567
00:23:19,299 --> 00:23:22,500
Vale, getNumPedidos

568
00:23:22,500 --> 00:23:24,279
No he puesto la sintaxis de getter

569
00:23:24,279 --> 00:23:26,339
O sea, he hecho lo que me ha dado la gana y eso es feo

570
00:23:26,339 --> 00:23:29,059
Vale

571
00:23:29,059 --> 00:23:31,619
GetNumPedidos, vamos a ver ahora

572
00:23:31,619 --> 00:23:33,900
Que podría estar la cosa en otro lado

573
00:23:33,900 --> 00:23:44,049
Vale, null, null, null, null, null

574
00:23:44,049 --> 00:23:47,549
Null, null, null

575
00:23:47,549 --> 00:23:49,809
Va a ser que no tengo la base de datos

576
00:23:49,809 --> 00:23:50,970
Lanzada

577
00:23:50,970 --> 00:23:53,029
Va a ser eso, ¿verdad?

578
00:23:59,160 --> 00:23:59,960
¡Qué problemón!

579
00:24:05,039 --> 00:24:06,200
Vale, a ver

580
00:24:06,200 --> 00:24:07,880
Ahora está lanzada

581
00:24:07,880 --> 00:24:09,640
Si ahora falla, ya sí que

582
00:24:09,640 --> 00:24:12,119
Vamos a vernos en un problema serio

583
00:24:12,119 --> 00:24:12,880
Muy serio

584
00:24:12,880 --> 00:24:15,599
Sí, porque no vamos a tener ni idea

585
00:24:15,599 --> 00:24:16,420
Pero

586
00:24:16,420 --> 00:24:18,519
¿Nul, nul, nul?

587
00:24:19,619 --> 00:24:21,740
¿Y por qué nos aparece nul, nul, nul?

588
00:24:21,839 --> 00:24:23,400
¿Qué he hecho yo mal en la query?