1
00:00:00,690 --> 00:00:17,570
Bueno, vamos a empezar a programar ya para recuperar información. Voy a cerrar todas estas pestañas que tenemos por aquí y voy a hacer algún programa. No sé si aquí hice algo. De momento no lo salvo. No sé lo que hice.

2
00:00:17,570 --> 00:00:24,679
vamos a hacer algún programa aparte de principal en el cual perfectamente

3
00:00:24,679 --> 00:00:29,000
podíamos trabajar e insertar algo

4
00:00:29,000 --> 00:00:32,039
voy a intentar ahora recuperar información

5
00:00:32,039 --> 00:00:35,520
voy a copiar este ficherito mismo de principal

6
00:00:35,520 --> 00:00:40,359
este ficherito mismamente, principal lo voy a copiar

7
00:00:40,359 --> 00:00:44,460
por evitarme escribir algo

8
00:00:44,460 --> 00:00:48,460
voy a poner recuperar información

9
00:00:48,460 --> 00:00:49,979
voy a llamar así

10
00:00:49,979 --> 00:00:55,179
voy a cerrar el otro

11
00:00:55,179 --> 00:00:57,140
y simplemente es por aprovechar

12
00:00:57,140 --> 00:00:59,020
la primera parte del código

13
00:00:59,020 --> 00:01:00,939
solamente el tema

14
00:01:00,939 --> 00:01:04,060
de las transacciones

15
00:01:04,060 --> 00:01:06,000
en este caso no voy a verlas porque no voy a crear

16
00:01:06,000 --> 00:01:07,060
nada, con lo cual

17
00:01:07,060 --> 00:01:10,120
todo esto lo puedo dejar así

18
00:01:10,120 --> 00:01:12,120
y

19
00:01:12,120 --> 00:01:15,140
tengo ya preparado

20
00:01:15,140 --> 00:01:17,500
una parte de mi programa

21
00:01:17,500 --> 00:01:18,120
muy bien

22
00:01:18,120 --> 00:01:20,260
¿cuál es mi idea?

23
00:01:20,260 --> 00:01:34,799
Pues mi idea principal es recuperar, por ejemplo, toda la información del departamento número 10, que sabemos que el departamento número 10 es este que tenemos aquí de antes, el departamento este que tenía varias personas por ahí, el de producción.

24
00:01:34,799 --> 00:01:40,739
¿De acuerdo? Bueno, pues una vez que yo tengo esto, voy a empezar a buscar información.

25
00:01:43,359 --> 00:01:51,780
Lo primero es cargar el departamento correspondiente a la clase al objeto cuyo identificador es el 10.

26
00:01:51,780 --> 00:02:05,519
Para ello, yo puedo crear un departamento, un departamento D, que sea un nuevo departamento.

27
00:02:07,680 --> 00:02:16,879
Y en este nuevo departamento, AD, yo le puedo asignar una sesión en la cual cargue,

28
00:02:16,879 --> 00:02:21,620
y ya vemos que aquí aparecen un montón de cabeceras posibles.

29
00:02:21,620 --> 00:02:24,719
yo lo que quiero es cargar la clase departamento

30
00:02:24,719 --> 00:02:32,689
y el argumento que le quiero pasar

31
00:02:32,689 --> 00:02:36,110
es el 10, ¿de acuerdo? Con esto cargo

32
00:02:36,110 --> 00:02:40,330
el departamento 10. Muy bien, vamos a ver

33
00:02:40,330 --> 00:02:44,189
si esto nos va dando la información que yo pretendo. Entonces voy a poner

34
00:02:44,189 --> 00:02:48,370
simplemente una salida en la cual

35
00:02:48,370 --> 00:02:52,270
me salga el nombre del departamento

36
00:02:52,270 --> 00:02:56,830
voy a poner de.getNombre

37
00:02:56,830 --> 00:03:00,250
estaría muy bien, get.getNombre

38
00:03:00,250 --> 00:03:05,229
de este departamento, voy a poner también que nos devuelva

39
00:03:05,229 --> 00:03:07,430
su identificador

40
00:03:07,430 --> 00:03:10,650
el identificador

41
00:03:10,650 --> 00:03:15,270
a ver que están saliendo cosas raras

42
00:03:15,270 --> 00:03:19,629
algo así, vale

43
00:03:19,629 --> 00:03:30,110
No voy a avanzar más, de momento voy a dejarlo ahí y después voy a obtener todos los empleados de ese departamento.

44
00:03:30,650 --> 00:03:35,229
Voy a ejecutar para ver si esto nos da algún problema o funciona correctamente.

45
00:03:36,270 --> 00:03:45,469
Bueno, pues ya vemos aquí la salida, 10 producción, o sea, perfectamente ha funcionado esto que tenemos aquí, todo el código que tenemos aquí.

46
00:03:45,469 --> 00:03:48,150
voy a abrir la consola por si hubiera algún error

47
00:03:48,150 --> 00:03:50,389
que se nos pasara, pero no, todo está en la información

48
00:03:50,389 --> 00:03:51,750
que tenemos

49
00:03:51,750 --> 00:03:53,930
de hibernate

50
00:03:53,930 --> 00:03:56,009
y después está la salida

51
00:03:56,009 --> 00:03:58,129
perfecto, una vez que sabemos que esto está

52
00:03:58,129 --> 00:03:59,909
funcionando correctamente, vamos a ver

53
00:03:59,909 --> 00:04:02,129
que empleados tiene

54
00:04:02,129 --> 00:04:03,150
este departamento

55
00:04:03,150 --> 00:04:07,659
bueno, pues vamos, sabemos

56
00:04:07,659 --> 00:04:10,039
que empleados los podemos obtener directamente

57
00:04:10,039 --> 00:04:11,819
con de punto

58
00:04:11,819 --> 00:04:13,240
get

59
00:04:13,240 --> 00:04:16,019
empleados, y que esto nos devuelve un conjunto

60
00:04:16,019 --> 00:04:42,329
Entonces, yo podría decir, for un empleado e get empleados, muéstrame, por ejemplo, el nombre del empleado y su salario.

61
00:04:42,329 --> 00:04:51,470
bueno, estoy poniendo aquí directamente unos campos que no existen

62
00:04:51,470 --> 00:04:55,430
tendría que poner llamar al subguete, estoy aquí haciéndolo muy deprisa

63
00:04:55,430 --> 00:05:00,870
y aquí el nombre claramente me está dando un error porque yo tendría que decir su nombre

64
00:05:00,870 --> 00:05:06,189
bueno, pues vamos a ver si esto nos funciona

65
00:05:06,189 --> 00:05:12,120
vamos a ejecutar, carga todo lo de hibernate

66
00:05:12,120 --> 00:05:14,699
y efectivamente, voy a ampliar la consola

67
00:05:14,699 --> 00:05:19,839
dice que en producción está Juan Velasco y María García

68
00:05:19,839 --> 00:05:22,860
y lo que gana cada uno de ellos.

69
00:05:23,600 --> 00:05:28,040
Con lo cual ya vemos que prescindiendo completamente

70
00:05:28,040 --> 00:05:30,639
de un lenguaje de interrogación a la base de datos

71
00:05:30,639 --> 00:05:34,680
obtenemos toda la información que requerimos.

72
00:05:36,420 --> 00:05:39,279
Este mismo ejemplo lo podríamos haber resuelto de otra manera

73
00:05:39,279 --> 00:05:41,759
utilizando el lenguaje HQL.

74
00:05:42,759 --> 00:05:46,360
En este caso hemos cargado directamente el departamento 10

75
00:05:46,360 --> 00:05:47,600
mediante este load.

76
00:05:47,600 --> 00:06:05,360
Bueno, nosotros podemos, voy a poner aquí el ejemplo ya hecho, realizar una sentencia de HQL que diga from departamento donde el id sea igual a 10, con lo cual creamos una query con ese HQL y devolvemos un único resultado.

77
00:06:05,360 --> 00:06:10,959
Hacemos un test-card de departamento y ya tenemos también este departamento

78
00:06:10,959 --> 00:06:15,699
Esto además nos permite que aquí podamos buscar por cualquier información

79
00:06:15,699 --> 00:06:19,560
Cuando sabemos que solamente vamos a devolver un único resultado

80
00:06:19,560 --> 00:06:21,100
Vamos a ejecutarlo

81
00:06:21,100 --> 00:06:29,079
Bueno, aquí vemos que otra vez nos sale perfectamente

82
00:06:29,079 --> 00:06:36,170
Que nos sale perfectamente la misma información que teníamos antes

83
00:06:36,170 --> 00:06:36,949
¿De acuerdo?

84
00:06:39,399 --> 00:06:43,540
¿Qué ocurre cuando la información no va a devolver múltiples elementos?

85
00:06:43,720 --> 00:06:49,500
Realmente lo que vamos a obtener es una lista de algo. Vamos a ver ese ejemplo como podría ser.

86
00:06:50,379 --> 00:07:01,500
Entonces nosotros tenemos aquí una lista, creamos un query, este query from departamento, con lo cual nos devolverá todos los departamentos,

87
00:07:02,300 --> 00:07:11,959
y a este query le aplicamos una lista. A esta lista de departamentos le aplicamos un iterador y vamos preguntando

88
00:07:11,959 --> 00:07:16,240
que mientras que haya, vamos obteniendo el siguiente y lo vamos mostrando.

89
00:07:16,519 --> 00:07:18,899
Este sería nuestro ejemplo.

90
00:07:19,720 --> 00:07:28,420
Vamos a ejecutarlo y efectivamente vemos aquí abajo que nos ha devuelto finanzas y producción,

91
00:07:28,540 --> 00:07:29,879
los dos que tenemos funcionando.

92
00:07:33,420 --> 00:07:43,079
El lenguaje HQL es muy rico y podemos ir a ver parte de sus características en la propia Ibernet,

93
00:07:43,079 --> 00:07:46,279
con lo cual podemos ver todas las características que nos ofrece.

94
00:07:46,899 --> 00:07:50,180
Y efectivamente tiene cláusulas del tipo WHERE, ORDER, GROUP, etc.

95
00:07:50,879 --> 00:07:55,160
Y, por supuesto, declaraciones para modificación de la información.

96
00:07:56,040 --> 00:08:02,680
Este, les recomiendo que se lean esto tranquilamente y vean qué cosas nos aporta el propio lenguaje.

97
00:08:05,319 --> 00:08:06,959
También podemos preparar sentencias.

98
00:08:07,199 --> 00:08:14,220
Podríamos haber dicho que no supiéramos aquí el dato y haber puesto una variable que después vamos a rellenar.

99
00:08:14,220 --> 00:08:23,220
Por lo cual, aquí, una vez que creamos nuestra sentencia query, podríamos, antes de decir que la ejecute,

100
00:08:24,040 --> 00:08:31,420
podríamos haber dicho que insertemos en ese valor de id el valor correspondiente.

101
00:08:31,540 --> 00:08:39,259
Vamos a separar esta sentencia, vamos a ir separando cosas de aquí, voy a crear la query, tal cual,

102
00:08:39,259 --> 00:08:41,679
esto después lo voy a dejar por aquí atrás

103
00:08:41,679 --> 00:08:46,419
creamos nuestra query

104
00:08:46,419 --> 00:08:52,259
Q con esta estructura

105
00:08:52,259 --> 00:08:55,259
perfecto, una vez que tenemos esa query

106
00:08:55,259 --> 00:08:59,799
podemos decirle que establezcamos un valor entero

107
00:08:59,799 --> 00:09:03,159
un tejer, en esa posición

108
00:09:03,159 --> 00:09:07,000
que hemos llamado id con el valor 10

109
00:09:07,000 --> 00:09:09,820
ya tenemos ese valor

110
00:09:09,820 --> 00:09:22,620
Y ahora ya podríamos aplicar en departamento, podríamos aplicarle el resultado de esto que tenemos aquí.

111
00:09:22,919 --> 00:09:35,629
Vamos a ver, q.uniqueResult.

112
00:09:37,210 --> 00:09:43,210
Entonces ya con esta información podríamos obtener el mismo resultado.

113
00:09:43,210 --> 00:09:47,269
vamos a ejecutar

114
00:09:47,269 --> 00:09:51,230
esto y efectivamente

115
00:09:51,230 --> 00:09:55,769
vemos que nos aparece el mismo resultado que teníamos antes

116
00:09:55,769 --> 00:09:59,149
como igual que en SQL es más seguro siempre pasar

117
00:09:59,149 --> 00:10:03,309
los parámetros de esta manera a escribirlos en la propia sentencia

118
00:10:03,309 --> 00:10:05,929
a pesar de que podamos hacerlo

119
00:10:05,929 --> 00:10:10,950
ya para ir finalizando vamos a ver la diferencia

120
00:10:10,950 --> 00:10:15,809
entre cargar un objeto

121
00:10:15,809 --> 00:10:19,629
que sabemos que existe o que no exista. Vamos a poner aquí

122
00:10:19,629 --> 00:10:23,830
un objeto que no exista. Vamos a poner el departamento 99.

123
00:10:24,570 --> 00:10:27,850
Y vamos a ejecutar. Voy a quitar todo lo que tengo

124
00:10:27,850 --> 00:10:32,940
por aquí, para que no nos incordien. Esto

125
00:10:32,940 --> 00:10:36,440
y esto. Y voy a

126
00:10:36,440 --> 00:10:43,129
ejecutar esta sentencia. Una vez que aparece

127
00:10:43,129 --> 00:10:51,009
Toda esta información vemos que lo que ha ocurrido es que aquí nos aparece una excepción,

128
00:10:51,129 --> 00:10:54,049
en la cual dice que el objeto no ha sido encontrado.

129
00:10:54,789 --> 00:10:55,129
¿De acuerdo?

130
00:10:55,509 --> 00:10:59,730
Tenemos otra manera de hacerlo, que es con el método de verde load, el método get.

131
00:11:00,889 --> 00:11:03,230
Vamos a ver con get qué nos ocurriría.

132
00:11:06,639 --> 00:11:09,139
Entonces, en este caso también va a saltar una excepción,

133
00:11:09,139 --> 00:11:16,539
pero de otro tipo que dice excepción de que nos devuelve un puntero a nulo

134
00:11:16,539 --> 00:11:22,059
la diferencia consiste en que yo en este caso me puede devolver el departamento

135
00:11:22,059 --> 00:11:27,399
o bien, si D es igual a nulo

136
00:11:27,399 --> 00:11:32,580
pues puedo mostrar aquí un mensaje en el cual tranquilamente por digo

137
00:11:32,580 --> 00:11:36,679
el departamento no existe

138
00:11:36,679 --> 00:11:42,480
y si no, pues me haces todo lo que aparece por aquí

139
00:11:42,480 --> 00:11:48,379
bueno, una vez que hago este código

140
00:11:48,379 --> 00:11:52,100
pues vamos a ver cómo quedaría

141
00:11:52,100 --> 00:11:54,279
y efectivamente vamos a obtener al final

142
00:11:54,279 --> 00:11:56,360
el departamento no existe

143
00:11:56,360 --> 00:11:58,019
lo recuperamos sin excepción

144
00:11:58,019 --> 00:11:59,580
en el caso de load

145
00:11:59,580 --> 00:12:03,580
habría que comprobar que no salte una excepción

146
00:12:03,580 --> 00:12:05,539
entonces habría que hacer un bloque try

147
00:12:05,539 --> 00:12:08,820
para realizar esta misma sentencia

148
00:12:08,820 --> 00:12:11,340
son dos instituciones similares

149
00:12:11,340 --> 00:12:13,039
pero en una hay que tratar una excepción

150
00:12:13,039 --> 00:12:15,899
y en la otra simplemente comprobar

151
00:12:15,899 --> 00:12:16,820
que nos devuelve algo

152
00:12:16,820 --> 00:12:18,639
que es el caso de null

153
00:12:18,639 --> 00:12:23,559
bueno, han sido una serie de vídeos

154
00:12:23,559 --> 00:12:25,419
simplemente de introducción

155
00:12:25,419 --> 00:12:27,539
a lo que es todo el entorno

156
00:12:27,539 --> 00:12:29,840
URM y específicamente

157
00:12:29,840 --> 00:12:31,720
el entorno de Hibernate

158
00:12:31,720 --> 00:12:34,320
y ahora ya es el momento

159
00:12:34,320 --> 00:12:35,679
de profundizar

160
00:12:35,679 --> 00:12:37,419
y ya lo dejo en sus manos

161
00:12:37,419 --> 00:12:40,059
mucha suerte y adelante

162
00:12:40,320 --> 00:12:41,539
Gracias.