1 00:00:00,000 --> 00:00:18,699 Bueno, pues entonces, así rápidamente, recordad que las herramientas ORM que nos facilitan el acceso a las bases de datos porque nos ocultan el SQL y nos permiten trabajar directamente con los objetos, siempre y cuando sean persistentes, 2 00:00:18,699 --> 00:00:36,380 Que esas herramientas necesitaban una configuración, lógicamente, en el modelo de datos para que pudieran hacer un mapeo con las tablas. Eso lo habíamos hecho aquí, a través de las anotaciones, ¿vale? Que esto todo lo habréis repasado y lo tendréis más o menos claro, ¿vale? 3 00:00:36,380 --> 00:00:51,700 Entonces, ahora ya que teníamos el modelo de datos con las anotaciones que especificaban exactamente la correspondencia entre tablas y clases, a partir de ahí ya podemos trabajar directamente con los objetos, una vez que los hayamos hecho persistentes, ¿vale? 4 00:00:51,700 --> 00:01:21,120 Entonces, para eso, pues probamos hacerlo mediante un main así a lo bestia, ¿vale? Mediante un main así a lo bestia, pues probamos a hacerlo directamente con JPA, que exigía crear un contexto de persistencia, que es este, que se crea a través de un factory, como casi todas las cosas, y una vez creado el contexto de persistencia, ya podíamos trabajar en transacción o no. 5 00:01:21,700 --> 00:01:26,739 En transacción obligatorio siempre y cuando quisiéramos hacer modificaciones en la base de datos. 6 00:01:27,180 --> 00:01:30,099 Si no hay modificaciones en la base de datos, no obligatorio en transacción. 7 00:01:30,780 --> 00:01:30,980 ¿Vale? 8 00:01:31,480 --> 00:01:34,079 Entonces, si estamos trabajando en transacción, se empieza así. 9 00:01:34,079 --> 00:01:46,719 Y ahora ya, nuestros objetos de nuestro modelo, si son persistentes, cualquier cambio que hagamos en ellos, cualquier modificación, se va a reflejar en la base de datos según hacemos commit. 10 00:01:47,719 --> 00:01:47,900 ¿Vale? 11 00:01:47,900 --> 00:01:50,640 entonces, ¿cómo hacemos 12 00:01:50,640 --> 00:01:52,239 que los objetos sean persistentes? 13 00:01:52,359 --> 00:01:54,900 ¿cómo lo hacemos? pues esencialmente 14 00:01:54,900 --> 00:01:55,579 de dos maneras 15 00:01:55,579 --> 00:01:58,040 si el dato ya existe 16 00:01:58,040 --> 00:02:00,340 el dato, lo podemos recuperar 17 00:02:00,340 --> 00:02:02,319 de la base de datos con find y ya está 18 00:02:02,319 --> 00:02:04,260 este objeto se convierte en persistente 19 00:02:04,260 --> 00:02:05,719 y cualquier cambio que hagamos en él 20 00:02:05,719 --> 00:02:08,500 para nuestra aplicación ya se va a quedar reflejado 21 00:02:08,500 --> 00:02:10,000 en la base de datos 22 00:02:10,000 --> 00:02:11,659 según hagamos con mi 23 00:02:11,659 --> 00:02:14,219 esta es una manera de hacerlo persistente 24 00:02:14,219 --> 00:02:15,520 y la otra 25 00:02:15,520 --> 00:02:24,650 si mi dato todavía no existe 26 00:02:24,650 --> 00:02:26,349 yo tengo el objeto 27 00:02:26,349 --> 00:02:28,629 ese objeto es transitorio 28 00:02:28,629 --> 00:02:30,870 y el dato no está en la base de datos todavía 29 00:02:30,870 --> 00:02:33,330 yo haciendo esto 30 00:02:33,330 --> 00:02:36,210 no solo lo convierto en persistente 31 00:02:36,210 --> 00:02:37,770 sino que ya lo dejo marcado 32 00:02:37,770 --> 00:02:39,530 para que se guarde en base de datos 33 00:02:39,530 --> 00:02:41,270 cuando se haga el commit 34 00:02:41,270 --> 00:02:43,050 ya cuando se haga el commit 35 00:02:43,050 --> 00:02:46,189 todos los cambios se dejarán en la base de datos 36 00:02:46,189 --> 00:02:49,030 entonces, cuando tenemos objetos persistentes 37 00:02:49,030 --> 00:02:51,129 bien por el find, bien por el persist 38 00:02:51,129 --> 00:02:52,990 la base de datos 39 00:02:52,990 --> 00:02:53,409 perdón 40 00:02:53,409 --> 00:02:56,770 el ORM, que en nuestro caso es 41 00:02:56,770 --> 00:02:58,770 hibernate, claro, es el que implementa JPA 42 00:02:58,770 --> 00:03:00,770 el ORM ya, según vayamos haciendo 43 00:03:00,770 --> 00:03:03,009 cambios, la aplicación pues va trabajando con los objetos 44 00:03:03,009 --> 00:03:04,689 pero es que además hibernate los va dejando 45 00:03:04,689 --> 00:03:06,930 marcaditos, para que cuando llegue el commit 46 00:03:06,930 --> 00:03:08,650 decir, uy, que estos se modificaron 47 00:03:08,650 --> 00:03:10,490 desde su estado inicial de la base de datos 48 00:03:10,490 --> 00:03:12,870 que no se me olvide, dejarlos tal y como 49 00:03:12,870 --> 00:03:14,110 los ha dejado este humano 50 00:03:14,110 --> 00:03:16,889 en su toqueteo, ¿vale? 51 00:03:17,650 --> 00:03:18,849 Esencialmente esa era la idea. 52 00:03:19,610 --> 00:03:23,909 Entonces, teníamos persist, find para recuperar, remove 53 00:03:23,909 --> 00:03:26,469 si queremos marcar un objeto para que sea borrado, 54 00:03:27,490 --> 00:03:31,930 métodos por si queremos sacarlos también del estado persistente a transitorio, 55 00:03:32,650 --> 00:03:39,810 porque los objetos de mi aplicación pueden estar manejados por hibernate 56 00:03:39,810 --> 00:03:41,389 o no manejados por hibernate. 57 00:03:41,509 --> 00:03:43,650 Si están manejados por hibernate, son persistentes 58 00:03:43,650 --> 00:03:47,469 y todos los cambios se sincronizarán con la base de datos en el commit 59 00:03:47,469 --> 00:03:54,129 y si no son persistentes y por tanto son transitorios, 60 00:03:54,710 --> 00:04:00,629 la aplicación trabaja con ellos y en ningún momento se va a sincronizar 61 00:04:00,629 --> 00:04:03,349 su estado con la base de datos, porque son transitorios, van por libre. 62 00:04:05,250 --> 00:04:08,569 Entonces, pues teníamos métodos para si están en estado persistente 63 00:04:08,569 --> 00:04:11,669 en un momento dado, queremos que dejen de estar sincronizados 64 00:04:11,669 --> 00:04:13,629 una base de datos y por libre, pues ponerlos 65 00:04:13,629 --> 00:04:15,449 al estado separado, que se llamaba 66 00:04:15,449 --> 00:04:17,990 y luego además tenemos un lenguaje 67 00:04:17,990 --> 00:04:20,310 de consultas que era el JPQL 68 00:04:20,310 --> 00:04:21,990 para hacer consultas 69 00:04:22,610 --> 00:04:23,310 de 70 00:04:23,310 --> 00:04:26,029 cualquier tipo, igual que 71 00:04:26,029 --> 00:04:27,629 las que hacemos con SQL, pues igual 72 00:04:27,629 --> 00:04:30,029 recuperar por otros campos que no fueran la clave 73 00:04:30,029 --> 00:04:32,129 porque recuperar por la clave era este, sí o sí 74 00:04:32,129 --> 00:04:34,089 pues hacer 75 00:04:34,089 --> 00:04:35,930 cualquier cosa que hacemos con SQL, pues la 76 00:04:35,930 --> 00:04:37,670 podemos hacer con JPQL que era 77 00:04:37,670 --> 00:04:39,110 que es parecido 78 00:04:39,110 --> 00:04:46,329 Entonces, JPQL, las pautas básicas es que su sintaxis es similar a SQL 79 00:04:46,329 --> 00:04:51,410 Pero no trabaja con nombres de tablas, sino con nombres de clases 80 00:04:51,410 --> 00:04:53,569 Porque recordad que tabla es clase 81 00:04:53,569 --> 00:04:57,470 Y campo de tabla es propiedad de clase 82 00:04:57,470 --> 00:05:03,310 Entonces, en el JPQL jamás va a aparecer ningún identificador de la base de datos 83 00:05:03,310 --> 00:05:07,129 Nunca, no va a aparecer nunca ni un nombre de tabla, ni un nombre de campo, nada 84 00:05:07,129 --> 00:05:30,889 En JPQL solamente van a aparecer nombres de clases y nombres de propiedades de la clase, porque JPQL trabaja ahí, entonces aquí seleccionábamos de todos los empleados cuyo nombre fuera este parámetro de aquí, entonces fijábamos el parámetro y escogíamos el resultado, este es un ejemplo. 85 00:05:30,889 --> 00:05:32,990 Luego JPQL 86 00:05:32,990 --> 00:05:34,870 Si no quiere hacer algo específico 87 00:05:34,870 --> 00:05:37,550 O bien se ha hecho un cursito de JPQL 88 00:05:37,550 --> 00:05:38,569 Y se lo sabe todo 89 00:05:38,569 --> 00:05:40,990 O si no, consulta específicamente 90 00:05:40,990 --> 00:05:43,269 Oye, ¿cómo puedo hacer una consulta JPQL 91 00:05:43,269 --> 00:05:44,069 Para que haga esto? 92 00:05:44,670 --> 00:05:46,629 Pues ya está, si te la dicen bien 93 00:05:46,629 --> 00:05:48,470 Estupendo, si te la dicen mal 94 00:05:48,470 --> 00:05:49,810 Pues como tú sabes y controlas 95 00:05:49,810 --> 00:05:51,610 Pues la cambias un poquito y ya está 96 00:05:51,610 --> 00:05:54,449 ¿Vale? Recordad que aquí el parámetro 97 00:05:54,449 --> 00:05:56,089 No es como el prepare de statement 98 00:05:56,089 --> 00:05:57,569 Que era con una interrogación 99 00:05:57,569 --> 00:05:59,649 El parámetro es dos puntos 100 00:05:59,649 --> 00:06:01,689 Y un nombre, el que a ti te dé la gana 101 00:06:01,689 --> 00:06:03,389 Porque luego lo fijas 102 00:06:03,389 --> 00:06:05,889 A través de ese nombre que tú hayas puesto ahí 103 00:06:05,889 --> 00:06:07,370 Lo fijas a través de ese nombre 104 00:06:07,370 --> 00:06:08,870 ¿Es como la? 105 00:06:10,089 --> 00:06:11,410 No, la es un alias 106 00:06:11,410 --> 00:06:13,790 Porque en JPQL es obligatorio 107 00:06:13,790 --> 00:06:15,189 Poner un alias 108 00:06:15,189 --> 00:06:18,149 En este caso a la clase 109 00:06:18,149 --> 00:06:18,829 No a la tabla 110 00:06:18,829 --> 00:06:22,149 Es un alias para luego tú aquí referirte 111 00:06:22,149 --> 00:06:22,810 A esto 112 00:06:22,810 --> 00:06:27,509 Vale, JPQL es como 113 00:06:27,509 --> 00:06:28,129 Una 114 00:06:28,129 --> 00:06:30,170 Bueno, nada 115 00:06:30,170 --> 00:06:33,329 vale, pues 116 00:06:33,329 --> 00:06:35,430 para qué mencionar nombres para nada 117 00:06:35,430 --> 00:06:37,170 para liar, vale 118 00:06:37,170 --> 00:06:39,689 ya está, entonces 119 00:06:39,689 --> 00:06:41,569 este es el uso del 120 00:06:41,569 --> 00:06:43,930 JPA puro, de cómo funciona 121 00:06:43,930 --> 00:06:45,089 JPA 122 00:06:45,089 --> 00:06:47,569 pero nosotros lo que hicimos fue 123 00:06:47,569 --> 00:06:49,550 vamos a meterlo en un patrón 124 00:06:49,550 --> 00:06:51,550 de diseño un poco mejor, no vamos a poner esta mierda 125 00:06:51,550 --> 00:06:53,029 de un main donde hacemos ahí todo 126 00:06:53,029 --> 00:06:55,490 vale, entonces el patrón de diseño 127 00:06:55,490 --> 00:06:57,470 de acceso a datos siempre es 128 00:06:57,470 --> 00:06:58,790 el patrón DAO 129 00:06:59,730 --> 00:07:02,649 Entonces, por cada entidad hacíamos una clase DAO 130 00:07:02,649 --> 00:07:05,769 con las operaciones atómicas, en realidad. 131 00:07:06,050 --> 00:07:09,470 Ahí, digamos que a los DAOs no les importan nada 132 00:07:09,470 --> 00:07:11,449 los casos de uso de la aplicación. 133 00:07:11,589 --> 00:07:13,370 Es decir, ¿para qué sirve mi aplicación? 134 00:07:13,790 --> 00:07:16,009 Los casos de uso, los requisitos, como lo queráis llamar. 135 00:07:16,529 --> 00:07:17,829 A los DAOs no les importan. 136 00:07:18,370 --> 00:07:20,389 Los DAOs hacen el CRUD. 137 00:07:21,509 --> 00:07:24,470 Y luego ya mi aplicación tendrá unos casos de uso, 138 00:07:24,470 --> 00:07:25,509 unos requisitos. 139 00:07:25,509 --> 00:07:42,529 Pues el servicio, la clase servicio, es la que los mete. Y ya la clase servicio llamará a los métodos DAO que necesite, a varios de ellos seguidos, a uno, a dos, según necesite para construir su caso de uso o su requisito. 140 00:07:42,529 --> 00:07:45,689 Y ahí las transacciones, claro 141 00:07:45,689 --> 00:07:48,310 Claro, porque un caso de uso 142 00:07:48,310 --> 00:07:49,310 A lo mejor necesita 143 00:07:49,310 --> 00:07:51,589 Llamar a varios DAO en transacción 144 00:07:51,589 --> 00:07:52,949 Para que se haga todo o ninguno 145 00:07:52,949 --> 00:07:55,029 Pues el sitio para manejarlo es ahí 146 00:07:55,029 --> 00:07:57,410 Lo cual nos lleva 147 00:07:57,410 --> 00:08:00,110 Ahora ya a nuestro DAO 148 00:08:00,110 --> 00:08:01,490 Que 149 00:08:01,490 --> 00:08:03,649 Era este 150 00:08:03,649 --> 00:08:05,550 Y dijimos, hombre 151 00:08:05,550 --> 00:08:07,029 Pues si se trata de un 152 00:08:07,029 --> 00:08:08,930 CRUB básico 153 00:08:08,930 --> 00:08:11,410 Pues vamos a jugar 154 00:08:11,410 --> 00:08:13,709 un poco, vamos a hacerlo 155 00:08:13,709 --> 00:08:14,310 genérico 156 00:08:14,310 --> 00:08:17,689 porque este CRUD me vale para cualquier 157 00:08:17,689 --> 00:08:19,569 entidad, me vale para 158 00:08:19,569 --> 00:08:21,850 empleado, para departamento, para cualquiera 159 00:08:21,850 --> 00:08:22,870 pues esa entidad 160 00:08:22,870 --> 00:08:25,310 pero si la mayoría de casos de datos 161 00:08:25,310 --> 00:08:26,389 se hacen en el periódico 162 00:08:26,389 --> 00:08:28,589 el DAO solo se hace en el CRUD 163 00:08:28,589 --> 00:08:31,509 normalmente, a ver, no es que haya una 164 00:08:31,509 --> 00:08:33,549 rigidez en esto, pues hay una flexibilidad 165 00:08:33,549 --> 00:08:35,429 en el DAO puede haber otros métodos 166 00:08:35,429 --> 00:08:37,610 que no sean exclusivamente estos cuatro, porque el CRUD 167 00:08:37,610 --> 00:08:39,370 es esto, vale, entonces 168 00:08:39,370 --> 00:08:41,750 hombre, pues podéis ver dados con algunas otras cositas 169 00:08:41,750 --> 00:08:42,629 porque 170 00:08:42,629 --> 00:08:45,230 ese modelo de datos en particular 171 00:08:45,230 --> 00:08:47,269 pues tiene una operación, que se hace mucho 172 00:08:47,269 --> 00:08:49,289 lo que sea, pero la idea es que sean cosas 173 00:08:49,289 --> 00:08:51,429 lo más atómicas posible 174 00:08:51,429 --> 00:08:57,669 Sí, es la idea 175 00:08:57,669 --> 00:08:59,590 pero todo esto son ideas generales 176 00:08:59,590 --> 00:09:01,889 más o menos, pautas generales de diseño 177 00:09:01,889 --> 00:09:03,389 luego ya pues podéis 178 00:09:03,389 --> 00:09:04,549 encontrar muchas cosas 179 00:09:04,549 --> 00:09:07,330 son como pautas generales y este sería 180 00:09:07,330 --> 00:09:08,730 el club más puro del mundo 181 00:09:08,730 --> 00:09:27,320 Claro, normalmente, efectivamente 182 00:09:27,320 --> 00:09:29,919 Hacemos capas, pero además capas 183 00:09:29,919 --> 00:09:33,740 En diferentes contextos semánticos 184 00:09:33,740 --> 00:09:37,539 En el acceso a datos en particular 185 00:09:37,539 --> 00:09:40,019 Pues sí, tú tienes tu modelo 186 00:09:40,019 --> 00:09:42,879 El modelo que es independiente de cualquier acceso a datos 187 00:09:42,879 --> 00:10:03,240 Ahora, resulta que ese modelo tiene una correspondencia con una base de datos y tú quieres, por tanto, poder hacer inserciones, pues bueno, lo haces, metes todo eso relacionado con el CRUD, todo eso lo metes en otra capa, que es la capa DAO, en esa capa DAO metes lo relacionado con el CRUD de ese modelo. 188 00:10:03,240 --> 00:10:05,659 Ahora, normalmente tu aplicación 189 00:10:05,659 --> 00:10:07,940 No hace insert, get, delete 190 00:10:07,940 --> 00:10:08,919 Tu aplicación hará 191 00:10:08,919 --> 00:10:10,779 Recuperar todos los empleados 192 00:10:10,779 --> 00:10:12,519 A los que le falta un ojo 193 00:10:12,519 --> 00:10:13,759 Pues yo que sé, hará esas cosas 194 00:10:13,759 --> 00:10:15,460 Esas cosas no las metes aquí 195 00:10:15,460 --> 00:10:17,279 Entonces, luego ya pones una clase 196 00:10:17,279 --> 00:10:18,740 En la que pones todos esos casos de uso 197 00:10:18,740 --> 00:10:20,240 Que es lo que hace tu aplicación 198 00:10:20,240 --> 00:10:21,399 No son los casos de uso 199 00:10:21,399 --> 00:10:22,259 La capa de servicio 200 00:10:22,259 --> 00:10:25,399 También va asociada a un DAO 201 00:10:25,399 --> 00:10:27,440 La capa de servicio 202 00:10:27,440 --> 00:10:28,879 Usa objetos DAO 203 00:10:28,879 --> 00:10:32,159 Los que necesite 204 00:10:32,159 --> 00:10:33,700 Los que necesite 205 00:10:33,700 --> 00:10:35,200 O los DAOs de una base 206 00:10:35,200 --> 00:10:38,200 Usa los DAOs de la aplicación 207 00:10:38,200 --> 00:10:39,100 Los que necesite 208 00:10:39,100 --> 00:10:41,039 ¿Vale? 209 00:10:43,120 --> 00:10:44,139 Sí, lo que no sabía yo 210 00:10:44,139 --> 00:10:45,320 Sí, claro, hombre 211 00:10:45,320 --> 00:10:46,120 Lo que no sabía yo 212 00:10:46,120 --> 00:10:46,960 Si teníamos la clase de servicios 213 00:10:46,960 --> 00:10:48,120 Por cada DAO que necesitase 214 00:10:48,120 --> 00:10:49,659 No necesariamente 215 00:10:49,659 --> 00:10:51,340 No, eso no es tan rígido 216 00:10:51,340 --> 00:10:52,019 La clase de servicios 217 00:10:52,019 --> 00:10:52,919 Es como más abierta 218 00:10:52,919 --> 00:10:54,779 El DAO es como más rígido 219 00:10:54,779 --> 00:10:55,220 Que es 220 00:10:55,220 --> 00:10:56,000 Tú tienes ahí 221 00:10:56,000 --> 00:10:56,799 Normalmente 222 00:10:56,799 --> 00:10:57,879 Normalmente 223 00:10:57,879 --> 00:10:58,960 Un DAO 224 00:10:58,960 --> 00:10:59,779 Por entidad 225 00:10:59,779 --> 00:11:01,179 Con el CRUD 226 00:11:01,179 --> 00:11:03,139 normalmente, pero son pautas 227 00:11:03,139 --> 00:11:03,860 todo, ideas 228 00:11:03,860 --> 00:11:07,179 y luego el servicio es como más abierto porque ya el servicio 229 00:11:07,179 --> 00:11:08,779 sí que depende de la aplicación 230 00:11:08,779 --> 00:11:10,279 y la aplicación hay mil 231 00:11:10,279 --> 00:11:11,360 ¿vale? 232 00:11:13,120 --> 00:11:14,659 bueno, pues entonces, aquí 233 00:11:14,659 --> 00:11:18,779 hay muy preguntones hoy 234 00:11:18,779 --> 00:11:26,460 no me lo creo, seguro que el DAO se ha quedado claro 235 00:11:26,460 --> 00:11:26,980 eso seguro 236 00:11:26,980 --> 00:11:32,000 ¿perdón? 237 00:11:37,480 --> 00:11:43,720 A ver, el DAO 238 00:11:43,720 --> 00:11:46,360 en cada aplicación se supone 239 00:11:46,360 --> 00:11:48,279 que hay un DAO para su modelo de datos 240 00:11:48,279 --> 00:11:50,500 y cada aplicación tendrá su modelo 241 00:11:50,500 --> 00:11:50,960 de datos 242 00:11:50,960 --> 00:11:54,179 entonces cada aplicación 243 00:11:54,179 --> 00:11:56,259 con su modelo de datos y con modelo de datos 244 00:11:56,259 --> 00:11:58,559 me refiero a las clases que definen 245 00:11:58,559 --> 00:11:59,860 las entidades 246 00:11:59,860 --> 00:12:02,080 con las que trabaja, empleados 247 00:12:02,080 --> 00:12:04,059 facturas, pues cada aplicación 248 00:12:04,059 --> 00:12:05,539 tiene su modelo de datos y su DAO 249 00:12:05,539 --> 00:12:08,580 Y ya está, tú no coges DAOs de otra aplicación 250 00:12:08,580 --> 00:12:10,240 Hombre, a ver, puedes hacer un copy y pega 251 00:12:10,240 --> 00:12:11,340 Si tienes varias, pero 252 00:12:11,340 --> 00:12:16,139 A ver, cuando digo DAO 253 00:12:16,139 --> 00:12:18,840 Digo patrón DAO en general, que serán varias clases DAO 254 00:12:18,840 --> 00:12:19,799 ¿Vale? 255 00:12:21,259 --> 00:12:22,500 En general, sí 256 00:12:22,500 --> 00:12:24,500 Lo normal es una clase DAO 257 00:12:24,500 --> 00:12:26,240 Por entidad, ¿vale? 258 00:12:26,580 --> 00:12:27,559 Es lo habitual 259 00:12:27,559 --> 00:12:28,779 Es la idea 260 00:12:28,779 --> 00:12:32,740 ¿Vale? Es la idea, porque luego además hay otras clases 261 00:12:32,740 --> 00:12:34,179 Luego están, puedes hacer 262 00:12:34,179 --> 00:12:36,240 incluso otra cosa intermedia que es 263 00:12:36,240 --> 00:12:37,460 el DTO que se llama 264 00:12:37,460 --> 00:12:40,279 que es una clase en la que metes un objeto 265 00:12:40,279 --> 00:12:41,360 que vas a 266 00:12:41,360 --> 00:12:44,580 llevarlo a la base 267 00:12:44,580 --> 00:12:46,259 de datos pero todavía no 268 00:12:46,259 --> 00:12:47,860 está en el DAO, pero bueno 269 00:12:47,860 --> 00:12:50,000 nos olvidamos de esas cosas 270 00:12:50,000 --> 00:12:52,279 porque si lo veis alguna vez pues veréis que es muy fácil 271 00:12:52,279 --> 00:12:54,259 de entender, o sea que se pueden poner 272 00:12:54,259 --> 00:12:56,519 todavía más capas intermedias me refiero 273 00:12:56,519 --> 00:12:58,360 en el diseño, pero esto 274 00:12:58,360 --> 00:12:59,799 es más que suficiente y lo habitual 275 00:12:59,799 --> 00:13:02,720 modelo, DAO y el servicio 276 00:13:02,720 --> 00:13:05,759 Encima que el servicio ya depende de la aplicación 277 00:13:05,759 --> 00:13:07,480 Con lo cual el servicio ya es más abierto 278 00:13:07,480 --> 00:13:09,379 ¿Vale? Pero como pauta 279 00:13:09,379 --> 00:13:09,580 ¿Eh? 280 00:13:13,210 --> 00:13:15,129 Pero vamos que DTO es nada, es otro 281 00:13:15,129 --> 00:13:17,509 DTO es otra clase, una 282 00:13:17,509 --> 00:13:19,210 Por entidad 283 00:13:19,210 --> 00:13:21,610 También, ¿vale? Es un objeto 284 00:13:21,610 --> 00:13:23,409 De transmisión de datos, el objeto 285 00:13:23,409 --> 00:13:25,450 En donde tú metes los datos que vas a transmitir 286 00:13:25,450 --> 00:13:26,429 ¿Vale? 287 00:13:28,570 --> 00:13:28,970 Vale 288 00:13:28,970 --> 00:13:31,269 Justo 289 00:13:31,269 --> 00:13:33,529 Bueno, creo, vamos, yo siempre digo 290 00:13:33,529 --> 00:13:35,470 DTO y nunca de para pensar, pero asumo 291 00:13:35,470 --> 00:13:37,309 por lo que hace que son data transmission 292 00:13:37,309 --> 00:13:40,029 vale, pero nos olvidemos 293 00:13:40,029 --> 00:13:41,809 de eso, porque eso son detallitos 294 00:13:41,809 --> 00:13:43,669 luego veis una aplicación que tiene un DTO 295 00:13:43,669 --> 00:13:45,590 y veréis que, bueno, vale, pues ya está 296 00:13:45,590 --> 00:13:47,850 esto es trivial, no tiene más rollo 297 00:13:47,850 --> 00:13:50,090 entendiendo un poco la filosofía 298 00:13:50,090 --> 00:13:51,370 de diseño de las aplicaciones 299 00:13:51,370 --> 00:13:53,350 que es desacoplar 300 00:13:53,350 --> 00:13:55,730 vamos a desacoplar, vamos a hacer 301 00:13:55,730 --> 00:13:57,509 todo en cosas separadas 302 00:13:57,509 --> 00:13:59,629 aquí modelo, el modelo que no sepa nada 303 00:13:59,629 --> 00:14:00,929 de cómo se hace el acceso a datos 304 00:14:00,929 --> 00:14:03,889 El servicio que no sepa nada de cómo se hace 305 00:14:03,889 --> 00:14:05,190 Tampoco el acceso a datos 306 00:14:05,190 --> 00:14:08,289 Pero unas se llaman a otras porque se tienen que encargar las tareas 307 00:14:08,289 --> 00:14:10,470 Bueno, pues dicho esto 308 00:14:10,470 --> 00:14:11,570 Para 309 00:14:11,570 --> 00:14:13,990 Pues jugar un poco 310 00:14:13,990 --> 00:14:15,110 Y abrirnos la mente 311 00:14:15,110 --> 00:14:17,129 Y que no os olvidéis de programar, sobre todo 312 00:14:17,129 --> 00:14:19,970 Porque es lo que esencialmente todavía vais a hacer 313 00:14:19,970 --> 00:14:20,470 Esperamos 314 00:14:20,470 --> 00:14:24,250 Este es un DAO 315 00:14:24,250 --> 00:14:26,149 Puro y duro 316 00:14:26,149 --> 00:14:27,730 ¿Vale? Un DAO puro y duro 317 00:14:27,730 --> 00:14:29,509 Porque tiene el CRUD tal cual 318 00:14:29,509 --> 00:14:31,769 Entonces para hacer dos DAOs 319 00:14:31,769 --> 00:14:33,850 Idénticos en departamento y empleado 320 00:14:33,850 --> 00:14:35,549 Pues hacemos uno genérico 321 00:14:35,549 --> 00:14:36,190 Y ya está 322 00:14:36,190 --> 00:14:40,090 Entonces T puede ser departamento o empleado 323 00:14:40,090 --> 00:14:42,110 ¿Y por qué habíamos puesto 324 00:14:42,110 --> 00:14:43,830 Otro tipo genérico? 325 00:14:44,570 --> 00:14:45,169 Porque 326 00:14:45,169 --> 00:14:46,230 Algunos 327 00:14:46,230 --> 00:14:49,009 Porque algunos 328 00:14:49,009 --> 00:14:52,230 De estos métodos tiran de la clave 329 00:14:52,230 --> 00:14:52,870 Como el GET 330 00:14:52,870 --> 00:14:56,169 Entonces la clave, pues tampoco sabemos cuál es 331 00:14:56,169 --> 00:14:57,350 El tipo de datos de la clave 332 00:14:57,350 --> 00:14:59,149 Dependerá de la entidad que estemos 333 00:14:59,149 --> 00:15:03,330 pues entonces esta es el DAO genérico 334 00:15:03,330 --> 00:15:05,529 y además la interfaz sin más 335 00:15:05,529 --> 00:15:08,529 entonces ahora vamos a implementarla 336 00:15:08,529 --> 00:15:11,769 la implementación la podemos seguir dejando genérica 337 00:15:11,769 --> 00:15:12,929 que era la que teníamos aquí 338 00:15:12,929 --> 00:15:16,309 la implementación la podemos seguir dejando genérica 339 00:15:16,309 --> 00:15:21,070 y ahora ya, si nos íbamos directamente 340 00:15:21,070 --> 00:15:22,750 al método 341 00:15:22,750 --> 00:15:25,009 crear, vale 342 00:15:25,009 --> 00:15:28,009 crear 343 00:15:28,009 --> 00:15:30,710 si yo tengo el objeto 344 00:15:30,710 --> 00:15:33,409 Que quiero meter en la base de datos 345 00:15:33,409 --> 00:15:34,509 Quiero hacer persistente 346 00:15:34,509 --> 00:15:37,029 Insert 347 00:15:37,029 --> 00:15:38,950 Quizá queda mejor 348 00:15:38,950 --> 00:15:39,490 Lo que pasa es que 349 00:15:39,490 --> 00:15:42,549 Vale, pues ya está 350 00:15:42,549 --> 00:15:44,070 Haces el objeto persistente 351 00:15:44,070 --> 00:15:45,850 Vale 352 00:15:45,850 --> 00:15:48,629 Y se acabó, ahora volvemos aquí 353 00:15:48,629 --> 00:15:50,289 El recuperar 354 00:15:50,289 --> 00:15:52,490 El recuperar se hace por find 355 00:15:52,490 --> 00:15:53,970 Pero recordad que aquí 356 00:15:53,970 --> 00:15:56,450 Había que poner el objeto 357 00:15:56,450 --> 00:15:58,009 Que describe la clase 358 00:15:58,009 --> 00:16:00,549 ¿Recordáis el rollo del punto class? 359 00:16:00,549 --> 00:16:01,230 Del otro día 360 00:16:01,230 --> 00:16:04,470 Vale, pues entonces 361 00:16:04,470 --> 00:16:06,809 ¿Qué ocurre? Que el objeto que describe la clase 362 00:16:06,809 --> 00:16:07,990 Depende 363 00:16:07,990 --> 00:16:10,149 Será o departamento.class 364 00:16:10,149 --> 00:16:11,690 O empleado.class 365 00:16:11,690 --> 00:16:14,169 O alumno.class, no lo sé 366 00:16:14,169 --> 00:16:16,710 ¿Cuál es? Porque depende de T 367 00:16:16,710 --> 00:16:18,169 Y T.class no puede ser 368 00:16:18,169 --> 00:16:20,009 Por eso se lo pasábamos por parámetro 369 00:16:20,009 --> 00:16:23,610 Claro, si tú ya das 370 00:16:23,610 --> 00:16:25,769 Si este fuera departamento.dao 371 00:16:25,769 --> 00:16:27,309 Tú aquí pondrías 372 00:16:27,309 --> 00:16:29,029 Departamento.class 373 00:16:29,029 --> 00:16:35,509 Claro, vale, pero como es T y T.class no se puede hacer 374 00:16:35,509 --> 00:16:37,710 ¿Vale? Porque T es genérico 375 00:16:37,710 --> 00:16:41,029 Entonces T.class no se puede hacer 376 00:16:41,029 --> 00:16:42,769 Pues si lo pasamos por parámetro 377 00:16:42,769 --> 00:16:47,049 Diciéndole, oye, esto cuando esté instanciado 378 00:16:47,049 --> 00:16:50,129 Va a ser un objeto de esta clase 379 00:16:50,129 --> 00:16:52,870 Que aquí sí que podemos poner el T 380 00:16:52,870 --> 00:16:54,929 Porque aquí no estamos todavía instanciando 381 00:16:54,929 --> 00:16:55,889 Estamos declarando 382 00:16:55,889 --> 00:16:57,830 Sin embargo, ahí abajo 383 00:16:57,830 --> 00:17:00,029 Sí que ya es el objeto creado 384 00:17:00,029 --> 00:17:02,289 Luego aquí no se puede poner t.class 385 00:17:02,289 --> 00:17:07,359 Porque t.class 386 00:17:07,359 --> 00:17:08,640 No es nada 387 00:17:08,640 --> 00:17:09,720 ¿Vale? 388 00:17:10,980 --> 00:17:13,119 Entonces, aquí ponemos 389 00:17:13,119 --> 00:17:14,160 Esto, ¿vale? 390 00:17:15,299 --> 00:17:15,980 Entonces, entonces 391 00:17:15,980 --> 00:17:18,259 Perdona, ese que es solo el tener 392 00:17:18,259 --> 00:17:20,140 No hace falta el commit 393 00:17:20,140 --> 00:17:22,299 No, aquí no 394 00:17:22,299 --> 00:17:23,799 ¿Vale? Entonces 395 00:17:23,799 --> 00:17:26,480 Como le pasamos estos dos 396 00:17:26,480 --> 00:17:28,299 Por parámetro al dao 397 00:17:28,299 --> 00:17:30,420 El contexto de persistencia 398 00:17:30,420 --> 00:17:31,319 Y 399 00:17:31,319 --> 00:17:34,859 Y el tipo 400 00:17:34,859 --> 00:17:36,680 Pues hacíamos un constructor así 401 00:17:36,680 --> 00:17:37,779 ¿Vale? 402 00:17:38,700 --> 00:17:41,359 Le pasábamos el contexto de persistencia 403 00:17:41,359 --> 00:17:43,000 Porque claro, podríamos hacer 404 00:17:43,000 --> 00:17:45,319 Que se creara el contexto de persistencia 405 00:17:45,319 --> 00:17:45,819 Cada vez 406 00:17:45,819 --> 00:17:48,059 Pero entonces le complicamos 407 00:17:48,059 --> 00:17:50,759 Al servicio, manejar transacciones 408 00:17:50,759 --> 00:17:51,539 Y todo eso 409 00:17:51,539 --> 00:17:57,380 Es que aunque los creara 410 00:17:57,380 --> 00:17:58,720 Luego aquí se va a crear otro 411 00:17:58,720 --> 00:18:01,299 Entonces no podemos hacerlo tan atómico 412 00:18:01,299 --> 00:18:02,740 ¿Vale? Entonces 413 00:18:02,740 --> 00:18:05,259 Y además teníamos 414 00:18:05,259 --> 00:18:07,039 El problema del lazy y el eager 415 00:18:07,039 --> 00:18:09,099 Que no sé si os acordáis, pero bueno, ahora volverá a salir 416 00:18:09,099 --> 00:18:10,259 Vale 417 00:18:10,259 --> 00:18:12,940 Pues nada, remove lo mismo 418 00:18:12,940 --> 00:18:15,640 Y actualizar 419 00:18:15,640 --> 00:18:17,299 En realidad actualizar 420 00:18:17,299 --> 00:18:17,700 Aquí 421 00:18:17,700 --> 00:18:21,200 No habría nada que hacer 422 00:18:21,200 --> 00:18:23,539 Porque cuando se cambie el objeto 423 00:18:23,539 --> 00:18:24,359 En el servicio 424 00:18:24,359 --> 00:18:26,339 ¿Vale? 425 00:18:26,339 --> 00:18:27,839 Pero bueno, este es el método 426 00:18:27,839 --> 00:18:30,299 Que se suele poner 427 00:18:30,299 --> 00:18:32,180 Para forzar una actualización 428 00:18:32,180 --> 00:18:33,660 Entonces lo vais a encontrar mucho 429 00:18:33,660 --> 00:18:35,900 Aunque en realidad 430 00:18:35,900 --> 00:18:37,380 No es la base de datos en un NET 431 00:18:37,380 --> 00:18:39,599 Aunque no le de un COM 432 00:18:39,599 --> 00:18:41,680 No, no, no 433 00:18:41,680 --> 00:18:42,900 Tienes que hacer el COM 434 00:18:42,900 --> 00:18:45,420 Pero es el método que se asocia 435 00:18:45,420 --> 00:18:47,019 Normalmente a actualizar 436 00:18:47,019 --> 00:18:49,299 Cuando tienes que, pues lo sacas 437 00:18:49,299 --> 00:18:51,180 A otro método aparte o lo que sea 438 00:18:51,180 --> 00:18:53,980 Más que nada porque es que si no el UPDATE se quedaría vacío 439 00:18:53,980 --> 00:18:54,940 No sería necesario 440 00:18:54,940 --> 00:18:55,740 Porque tú 441 00:18:55,740 --> 00:18:58,640 Desde la aplicación 442 00:18:58,640 --> 00:19:01,039 Si tú cambias el objeto cuando ya se haga commit 443 00:19:01,039 --> 00:19:01,700 ¿Vale? 444 00:19:03,160 --> 00:19:04,740 Bueno, entonces 445 00:19:04,740 --> 00:19:06,539 Aquí, realmente aquí 446 00:19:06,539 --> 00:19:07,680 Deberíais haberme dicho 447 00:19:07,680 --> 00:19:10,619 Esto que hay aquí es contradictorio 448 00:19:10,619 --> 00:19:11,500 Con lo que has dicho antes 449 00:19:11,500 --> 00:19:14,059 Claro, hay una cosa aquí horrorosamente contradictoria 450 00:19:14,059 --> 00:19:15,200 En este código 451 00:19:15,200 --> 00:19:17,599 En serio 452 00:19:17,599 --> 00:19:24,799 A ver, lo que es contradictorio 453 00:19:24,799 --> 00:19:26,019 Es que estoy diciendo todo el rato 454 00:19:26,019 --> 00:19:28,539 que démosle al servicio 455 00:19:28,539 --> 00:19:30,619 la potestad de gestionar 456 00:19:30,619 --> 00:19:32,599 qué operaciones se hacen en transacción 457 00:19:32,599 --> 00:19:33,380 y cuáles no 458 00:19:33,380 --> 00:19:36,000 y yo he clavado aquí 459 00:19:36,000 --> 00:19:37,799 entonces 460 00:19:37,799 --> 00:19:40,339 es imposible que luego el servicio 461 00:19:40,339 --> 00:19:41,740 pueda meter 462 00:19:41,740 --> 00:19:44,440 este create, lo pueda meter 463 00:19:44,440 --> 00:19:46,380 en una transacción para forzar a que 464 00:19:46,380 --> 00:19:48,259 solo se haga si se hace otra cosa después 465 00:19:48,259 --> 00:19:50,640 es imposible porque lo acabo de meter en una transacción 466 00:19:50,640 --> 00:19:52,619 aquí, con lo cual create se va a hacer 467 00:19:52,619 --> 00:19:54,579 sí o sí, independientemente 468 00:19:54,579 --> 00:19:56,859 de si se hace en el resto de operaciones del servicio 469 00:19:56,859 --> 00:19:59,819 es que no hay 470 00:19:59,819 --> 00:20:02,819 transacciones dentro de transacciones no existen 471 00:20:02,819 --> 00:20:04,599 entonces, conclusión 472 00:20:04,599 --> 00:20:05,440 que lo primero que vamos a hacer 473 00:20:05,440 --> 00:20:08,299 que feo esto, quitarlo 474 00:20:08,299 --> 00:20:10,619 pero lo pongo 475 00:20:10,619 --> 00:20:11,599 y lo dejo en comentarios 476 00:20:11,599 --> 00:20:14,380 para que quede claro 477 00:20:14,380 --> 00:20:15,259 entonces 478 00:20:15,259 --> 00:20:23,660 aquí no ponemos 479 00:20:23,660 --> 00:20:26,180 la transacción 480 00:20:26,180 --> 00:20:29,200 porque 481 00:20:29,200 --> 00:20:31,839 Es el servicio 482 00:20:31,839 --> 00:20:34,420 El que decide que se mete en transacción 483 00:20:34,420 --> 00:20:34,900 Y que no 484 00:20:34,900 --> 00:20:40,900 No es la idea 485 00:20:40,900 --> 00:20:42,539 No es la idea 486 00:20:42,539 --> 00:20:52,279 Vale, pero esto 487 00:20:52,279 --> 00:20:53,059 Lleva una tilde 488 00:20:53,059 --> 00:21:00,119 Vale, pues esto mismo que he quitado 489 00:21:00,119 --> 00:21:01,799 Aquí, por tanto 490 00:21:01,799 --> 00:21:03,720 Lo quito de aquí 491 00:21:03,720 --> 00:21:07,920 También, y lo quito 492 00:21:07,920 --> 00:21:13,539 De aquí también, vale 493 00:21:13,539 --> 00:21:15,599 Y el dado se queda así, tan ancho 494 00:21:15,599 --> 00:21:17,640 Vale, ahora ya vamos a hacer 495 00:21:17,640 --> 00:21:19,279 el servicio, vale 496 00:21:19,279 --> 00:21:19,900 a ver 497 00:21:19,900 --> 00:21:22,839 no, este ya está 498 00:21:22,839 --> 00:21:27,660 bueno, luego, pero eso ya es servicio 499 00:21:27,660 --> 00:21:28,480 vale 500 00:21:28,480 --> 00:21:31,720 entonces, vale, vamos a ver 501 00:21:31,720 --> 00:21:33,119 pues venga, un paquete 502 00:21:33,119 --> 00:21:33,640 ¿qué? 503 00:21:33,640 --> 00:21:33,700 ¿qué? 504 00:21:36,740 --> 00:21:38,680 todo lo que veas sencillo 505 00:21:38,680 --> 00:21:40,940 preocúpate, porque 506 00:21:40,940 --> 00:21:43,519 que no, hombre, es sencillo porque no 507 00:21:43,519 --> 00:21:45,839 no, no, no 508 00:21:45,839 --> 00:21:49,420 en absoluto 509 00:21:49,420 --> 00:22:15,559 A ver, vale, pues este ya en lugar de hacer una clase servicio por empleado, departamento, 510 00:22:15,559 --> 00:22:24,460 pues una clase servicio para la aplicación, con los casos de uso que se hayan derivado del análisis de la aplicación, ¿vale? 511 00:22:24,460 --> 00:22:30,450 Y ahora aquí, pues por ejemplo 512 00:22:30,450 --> 00:22:33,329 A ver, que voy a mirar aquí para no perderme 513 00:22:33,329 --> 00:22:39,289 Lo vamos a hacer 514 00:22:39,289 --> 00:22:41,269 Departamento por ID 515 00:22:41,269 --> 00:22:46,259 Vale, pues entonces 516 00:22:46,259 --> 00:22:50,079 Recuperar un departamento 517 00:22:50,079 --> 00:22:51,920 Eso es lo más natural del mundo 518 00:22:51,920 --> 00:22:53,099 Que quiera hacer un servicio 519 00:22:53,099 --> 00:22:55,660 Pues venga, podríamos hacer 520 00:22:55,660 --> 00:22:56,980 Departamento 521 00:22:56,980 --> 00:22:58,900 Y ahora aquí 522 00:22:58,900 --> 00:23:03,539 Aquí podemos ponerlo 523 00:23:03,539 --> 00:23:06,099 Lo de inglés 524 00:23:06,099 --> 00:23:08,640 Esto es que ya es mucho más abierto 525 00:23:08,640 --> 00:23:09,680 Esto ya es la aplicación 526 00:23:09,680 --> 00:23:11,859 Entonces aquí 527 00:23:11,859 --> 00:23:13,299 Depende 528 00:23:13,299 --> 00:23:17,059 Porque el DAO está como más estandarizado 529 00:23:17,059 --> 00:23:18,519 Más estandarizado 530 00:23:18,519 --> 00:23:20,799 Y para que todos lo entendamos 531 00:23:20,799 --> 00:23:22,059 Pues lo mejor es que esté en inglés 532 00:23:22,059 --> 00:23:23,220 Porque así lo entendemos todos 533 00:23:23,220 --> 00:23:26,259 Pero el servicio ya es propio de la aplicación 534 00:23:26,259 --> 00:23:27,240 No es tan estandarizado 535 00:23:27,240 --> 00:23:30,059 Entonces aquí uno lo pone como le salga 536 00:23:30,059 --> 00:23:33,019 De cualquier lado que tenga 537 00:23:33,019 --> 00:23:37,240 Recuperar, hemos dicho, departamento 538 00:23:37,240 --> 00:23:38,779 Por id, porque aquí vamos a ver 539 00:23:38,779 --> 00:23:40,960 Lo de lazy y el eager 540 00:23:40,960 --> 00:23:42,859 Y la madre que lo trajo 541 00:23:42,859 --> 00:23:59,160 Vale 542 00:23:59,160 --> 00:24:02,640 Sí, porque departamento 543 00:24:02,640 --> 00:24:03,940 Su clave es íntegro 544 00:24:03,940 --> 00:24:06,359 Vale, entonces aquí lo tenemos tan fácil 545 00:24:06,359 --> 00:24:09,039 Como, ¿qué daos necesitamos? 546 00:24:09,259 --> 00:24:10,359 El del departamento 547 00:24:10,359 --> 00:24:12,160 Porque es un get, punto pelota 548 00:24:12,160 --> 00:24:13,859 Pues entonces 549 00:24:13,859 --> 00:24:16,359 Nos vamos a hacer una implementación 550 00:24:16,940 --> 00:24:17,779 Dao 551 00:24:17,779 --> 00:24:21,099 de que 552 00:24:21,099 --> 00:24:24,059 de departamento 553 00:24:24,059 --> 00:24:26,200 ínteger 554 00:24:26,200 --> 00:24:29,579 este es el dado que vamos a necesitar 555 00:24:29,579 --> 00:24:30,480 para este método 556 00:24:30,480 --> 00:24:33,339 y este va a ser 557 00:24:33,339 --> 00:24:34,220 new 558 00:24:34,220 --> 00:24:40,529 y ahora aquí 559 00:24:40,529 --> 00:24:46,940 hay que pasarle los parámetros 560 00:24:46,940 --> 00:24:48,980 que necesita el dado 561 00:24:48,980 --> 00:24:51,359 ¿qué parámetros necesita el dado? 562 00:24:51,539 --> 00:24:52,920 necesita la clase de la que 563 00:24:52,920 --> 00:24:53,720 estamos hablando 564 00:24:53,720 --> 00:24:56,240 perdón, el constructor 565 00:24:56,240 --> 00:24:58,880 el constructor necesita 566 00:24:58,880 --> 00:25:01,019 el objeto 567 00:25:01,019 --> 00:25:02,839 de class 568 00:25:02,839 --> 00:25:04,900 departamento y el entity 569 00:25:04,900 --> 00:25:06,599 manager, entonces este lo tenemos 570 00:25:06,599 --> 00:25:08,299 facilísimo, porque es 571 00:25:08,299 --> 00:25:10,640 departamento 572 00:25:10,640 --> 00:25:12,920 punto class, este lo tenemos 573 00:25:12,920 --> 00:25:15,099 muy fácil, y el otro 574 00:25:15,099 --> 00:25:17,000 es el entity manager 575 00:25:17,000 --> 00:25:18,500 entonces 576 00:25:18,500 --> 00:25:20,839 podríamos crearlo aquí, entity manager 577 00:25:20,839 --> 00:25:22,720 y ya está, pero vamos a sacarlo 578 00:25:22,720 --> 00:25:24,960 a un método, porque es lo típico 579 00:25:24,960 --> 00:25:26,960 tener el, tanto cuando usas 580 00:25:26,960 --> 00:25:28,440 el hibernate puro como el JPA 581 00:25:28,440 --> 00:25:30,440 un método que te devuelve el entity manager 582 00:25:30,440 --> 00:25:31,700 y tú lo llamas y ya está 583 00:25:31,700 --> 00:25:34,660 entonces, eso 584 00:25:34,660 --> 00:25:37,539 aquí 585 00:25:37,539 --> 00:25:49,579 a ver, aquí hay muy pocos paquetes 586 00:25:49,579 --> 00:25:51,220 lo normal cuando tú abres una aplicación 587 00:25:51,220 --> 00:25:52,500 es ver 588 00:25:52,500 --> 00:25:55,559 30 paquetes 589 00:25:55,559 --> 00:25:57,259 para luego 590 00:25:57,259 --> 00:25:59,500 esa aplicación igual hace 5 cosas 591 00:25:59,500 --> 00:26:01,299 pero tiene 30 paquetes 592 00:26:01,299 --> 00:26:03,180 para que sea escalable 593 00:26:03,180 --> 00:26:05,799 perdón, la he llamado 594 00:26:05,799 --> 00:26:07,299 como me ha... 595 00:26:07,299 --> 00:26:08,200 perdón 596 00:26:08,200 --> 00:26:09,700 ¿eh? 597 00:26:09,700 --> 00:26:13,779 ¿por pijería? 598 00:26:17,579 --> 00:26:18,140 efectivamente 599 00:26:18,140 --> 00:26:19,660 una aplicación organizada 600 00:26:19,660 --> 00:26:21,140 en muchos paquetes distintos 601 00:26:21,140 --> 00:26:23,099 aunque cada paquete tenga nada 602 00:26:23,099 --> 00:26:25,660 si efectivamente la tienes que escalar o lo que es lo mismo 603 00:26:25,660 --> 00:26:27,920 la tienes que ampliar con alguna funcionalidad 604 00:26:27,920 --> 00:26:29,839 es infinitamente más fácil 605 00:26:29,839 --> 00:26:31,940 ampliarlo con una funcionalidad y que siga 606 00:26:31,940 --> 00:26:34,039 siendo clara, porque cualquier aplicación 607 00:26:34,039 --> 00:26:35,900 es escalable, es decir, cualquier aplicación 608 00:26:35,900 --> 00:26:37,920 es ampliable, pero el problema es que 609 00:26:37,920 --> 00:26:39,759 si la aplicación no está bien diseñada 610 00:26:39,759 --> 00:26:41,900 desde el principio con todos los paquetitos por separado 611 00:26:41,900 --> 00:26:43,859 según esa aplicación va recibiendo 612 00:26:43,859 --> 00:26:45,960 los parches, cada vez se va 613 00:26:45,960 --> 00:26:47,720 convirtiendo en un 614 00:26:47,720 --> 00:26:49,380 magma horroroso 615 00:26:49,380 --> 00:26:51,599 entonces si está muy bien diseñada desde el principio 616 00:26:51,599 --> 00:26:53,779 cualquier ampliación la sigue dejando clarita 617 00:26:53,779 --> 00:26:56,039 clarita, clarita, los paquetes pueden ir engordando 618 00:26:56,039 --> 00:26:57,039 pero va quedando todo claro 619 00:26:57,039 --> 00:26:59,359 Entonces tendrá un tiempo de vida mucho más largo 620 00:26:59,359 --> 00:27:01,440 Porque cuando tomas tú la decisión 621 00:27:01,440 --> 00:27:03,619 De esta aplicación a la basura, que no puedo más con ella 622 00:27:03,619 --> 00:27:05,359 Pues si la tienes organizada desde el principio 623 00:27:05,359 --> 00:27:07,339 Tomas esa decisión mucho más tarde 624 00:27:07,339 --> 00:27:09,579 Vale 625 00:27:09,579 --> 00:27:11,440 Entonces esto a cuento de que venía 626 00:27:11,440 --> 00:27:13,500 De que estábamos refactorizando esto 627 00:27:13,500 --> 00:27:14,519 Que lo había llamado mal 628 00:27:14,519 --> 00:27:17,940 Bueno porque 629 00:27:17,940 --> 00:27:20,279 Yo que sé, dime otro nombre 630 00:27:20,279 --> 00:27:21,539 ¿Cómo quieres que la llame? 631 00:27:22,539 --> 00:27:24,140 Es para el entity manager 632 00:27:24,140 --> 00:27:25,059 ¿Eh? 633 00:27:27,359 --> 00:27:27,799 Vale 634 00:27:27,799 --> 00:27:32,099 Venga, Persistence 635 00:27:32,099 --> 00:27:33,160 Muy listos sois 636 00:27:33,160 --> 00:27:34,640 Está muy bien elegido 637 00:27:34,640 --> 00:27:36,779 Mejor que, vale, porque conexión 638 00:27:36,779 --> 00:27:39,680 Hace referencia más al barro 639 00:27:39,680 --> 00:27:41,259 Y aquí no nos estamos manchando 640 00:27:41,259 --> 00:27:43,819 Muy bien, vale, muy bien 641 00:27:43,819 --> 00:27:45,700 ¿Veis como sois muy espabilados 642 00:27:45,700 --> 00:27:46,460 Y muy listos? 643 00:27:47,819 --> 00:27:49,180 Vale, entonces estas clases 644 00:27:49,180 --> 00:27:51,779 Estas clases se suelen llamar 645 00:27:51,779 --> 00:27:53,359 Con el apellido útil 646 00:27:53,359 --> 00:27:56,119 De hecho está el famoso hibernate útil 647 00:27:56,119 --> 00:27:57,299 Si ponéis en internet 648 00:27:57,299 --> 00:27:59,619 De hibernate útil os salen mil pipipi. 649 00:28:00,539 --> 00:28:02,500 Entonces, esta vamos a llamarla JPA útil 650 00:28:02,500 --> 00:28:06,240 porque estamos sacando el contexto de persistencia de JPA, 651 00:28:06,380 --> 00:28:07,960 no del hibernate directamente. 652 00:28:08,960 --> 00:28:10,660 Entonces, ¿yo qué estaba haciendo aquí? 653 00:28:10,779 --> 00:28:16,930 Una nueva clase JPA útil. 654 00:28:18,690 --> 00:28:25,009 Entonces, aquí vamos a dar un método, ¿vale? 655 00:28:28,730 --> 00:28:31,430 Click static que me devuelva el entity manager. 656 00:28:31,430 --> 00:28:37,779 Y entonces 657 00:28:37,779 --> 00:28:43,130 Public static entity manager 658 00:28:43,130 --> 00:28:44,670 Entity manager 659 00:28:44,670 --> 00:28:46,609 Vale 660 00:28:46,609 --> 00:28:48,529 Y ahora, este método 661 00:28:48,529 --> 00:28:50,309 Esto se hacía 662 00:28:50,309 --> 00:28:52,230 Lo tenemos aquí en este main 663 00:28:52,230 --> 00:28:54,150 Lo tenéis en el main de la propia aplicación 664 00:28:54,150 --> 00:28:55,670 Esto 665 00:28:55,670 --> 00:28:57,430 Se hacía así 666 00:28:57,430 --> 00:28:59,710 Y ya está 667 00:28:59,710 --> 00:29:02,069 Vale 668 00:29:02,069 --> 00:29:10,529 Y aquí tendríamos que retornar 669 00:29:10,529 --> 00:29:11,130 El m 670 00:29:11,130 --> 00:29:17,160 Esto no es un singleton 671 00:29:17,160 --> 00:29:19,859 Y no es un singleton 672 00:29:19,859 --> 00:29:20,880 Ni queremos que lo sea 673 00:29:20,880 --> 00:29:23,019 Porque el EM 674 00:29:23,019 --> 00:29:25,279 Se instancia uno nuevo cada vez 675 00:29:25,279 --> 00:29:26,640 Que luego cerraremos 676 00:29:26,640 --> 00:29:28,180 ¿Vale? 677 00:29:28,400 --> 00:29:30,539 No queremos un entity manager vivo 678 00:29:30,539 --> 00:29:32,900 Para toda la aplicación para siempre 679 00:29:32,900 --> 00:29:34,180 El mismo objeto, no 680 00:29:34,180 --> 00:29:37,339 Porque eso podría tener muchos efectos colaterales secundarios 681 00:29:37,339 --> 00:29:39,059 Cada vez que el servicio 682 00:29:39,059 --> 00:29:40,799 Quiera un contexto de persistencia 683 00:29:40,799 --> 00:29:42,059 Para su caso de uso 684 00:29:42,059 --> 00:29:44,319 Su entity manager que luego cierra 685 00:29:44,319 --> 00:29:47,380 luego tiene quizá más sentido 686 00:29:47,380 --> 00:29:48,759 de nuevo no es una regla 687 00:29:48,759 --> 00:29:51,299 estricta, tiene quizá más sentido 688 00:29:51,299 --> 00:29:53,440 un contexto de persistencia por caso 689 00:29:53,440 --> 00:29:55,539 de uso, con lo cual el caso de uso 690 00:29:55,539 --> 00:29:57,359 lo llama y luego ya lo va a cerrar 691 00:29:57,359 --> 00:29:59,420 ¿vale? con el em close 692 00:29:59,420 --> 00:30:01,500 entonces esto no es un singleton 693 00:30:01,500 --> 00:30:03,440 em no queremos que haya una única 694 00:30:03,440 --> 00:30:05,460 instancia, pero a lo mejor lo que 695 00:30:05,460 --> 00:30:07,019 si podemos hacer para aprovechar un poco 696 00:30:07,019 --> 00:30:09,400 las cosas, el factory 697 00:30:09,400 --> 00:30:11,539 ese si que podría ser uno y único 698 00:30:11,539 --> 00:30:13,180 por aplicación 699 00:30:13,180 --> 00:30:15,259 El factory es el creador de EntityManager 700 00:30:15,259 --> 00:30:17,700 Entonces, ¿para qué obligar a 701 00:30:17,700 --> 00:30:18,720 Instanciar uno? 702 00:30:20,700 --> 00:30:22,000 Claro, instanciarlo 703 00:30:22,000 --> 00:30:22,519 Para que luego 704 00:30:22,519 --> 00:30:26,259 Como variable local se pierda el recolector de basura 705 00:30:26,259 --> 00:30:27,660 Pues los va periódicamente 706 00:30:27,660 --> 00:30:28,859 Pues para qué, ¿no? 707 00:30:28,859 --> 00:30:30,279 Entonces vamos a ponerlo aquí ya 708 00:30:30,279 --> 00:30:31,140 Este sí que sí 709 00:30:31,140 --> 00:30:45,359 Como este factory 710 00:30:45,359 --> 00:30:47,039 Es static y ahora ya 711 00:30:47,039 --> 00:30:51,220 Este se limita 712 00:30:51,220 --> 00:30:52,380 A devolver esto 713 00:30:52,380 --> 00:30:54,359 Entonces vamos a poner esto aquí 714 00:30:54,359 --> 00:31:07,339 vale, entonces este 715 00:31:07,339 --> 00:31:09,420 sí que va a ser ya un único 716 00:31:09,420 --> 00:31:10,759 en toda la aplicación y bien 717 00:31:10,759 --> 00:31:12,980 y ya está 718 00:31:12,980 --> 00:31:15,380 y te devuelve uno cada vez que el caso de uso 719 00:31:15,380 --> 00:31:16,059 lo necesite 720 00:31:16,059 --> 00:31:18,200 vale 721 00:31:18,200 --> 00:31:20,960 bueno, una posibilidad que tiene sentido 722 00:31:20,960 --> 00:31:23,480 vale, ahora ya 723 00:31:23,480 --> 00:31:25,180 en el servicio nos vamos 724 00:31:25,180 --> 00:31:26,119 aquí otra vez 725 00:31:26,119 --> 00:31:28,660 y ahora ya este 726 00:31:28,660 --> 00:31:30,599 el caso de uso, este de aquí 727 00:31:30,599 --> 00:31:33,220 sí que saca el 728 00:31:33,220 --> 00:31:36,000 LM y se lo pasa a este 729 00:31:36,000 --> 00:31:38,720 JPA 730 00:31:38,720 --> 00:31:41,660 Bueno, como luego lo tenemos que cerrar 731 00:31:41,660 --> 00:31:43,119 Necesitamos una referencia para él 732 00:31:43,119 --> 00:31:45,920 Porque luego hay que hacerle el en.close 733 00:31:45,920 --> 00:31:47,440 Entonces, vamos 734 00:31:47,440 --> 00:31:48,640 Tenemos que hacerlo aquí fuera 735 00:31:48,640 --> 00:31:51,180 Para luego poder cerrarlo 736 00:31:51,180 --> 00:31:55,250 . 737 00:31:55,250 --> 00:31:56,349 . 738 00:31:56,349 --> 00:31:59,069 . 739 00:31:59,069 --> 00:32:01,109 M 740 00:32:01,109 --> 00:32:05,569 Y ahora ya a este constructor se lo pasamos 741 00:32:05,569 --> 00:32:10,869 volver a donde 742 00:32:10,869 --> 00:32:12,089 al útil este 743 00:32:12,089 --> 00:32:14,990 es simplemente 744 00:32:14,990 --> 00:32:16,269 para crear un entity manager 745 00:32:16,269 --> 00:32:21,539 vale y ahora ya 746 00:32:21,539 --> 00:32:23,720 recuperar departamento 747 00:32:23,720 --> 00:32:25,279 por id pues el dao me puede 748 00:32:25,279 --> 00:32:25,779 ayudar 749 00:32:25,779 --> 00:32:28,799 ah bueno tenemos que abrir la transacción 750 00:32:28,799 --> 00:32:31,140 vale ahora nosotros aquí decidimos 751 00:32:31,140 --> 00:32:32,779 si esto va en transacción o no 752 00:32:32,779 --> 00:32:34,720 como implica modificar va en transacción 753 00:32:34,720 --> 00:32:36,920 y en este caso solo tiene 754 00:32:36,920 --> 00:32:38,859 un método pero bueno 755 00:32:38,859 --> 00:32:40,099 Aún así es obligatorio 756 00:32:40,099 --> 00:32:53,660 Es obligatorio porque modifica la base de datos 757 00:32:53,660 --> 00:32:55,759 Y JPA funciona así, esencialmente 758 00:32:55,759 --> 00:32:57,140 Vale 759 00:32:57,140 --> 00:33:00,859 Entonces, getTransaction 760 00:33:00,859 --> 00:33:01,859 Ahora ya sí 761 00:33:01,859 --> 00:33:04,859 Dao.find 762 00:33:04,859 --> 00:33:09,880 find 763 00:33:09,880 --> 00:33:17,210 departamento 764 00:33:17,210 --> 00:33:20,910 de igual a 765 00:33:20,910 --> 00:33:23,029 dado punto find nos llamaba get 766 00:33:23,029 --> 00:33:25,390 ¿verdad? get y de 767 00:33:25,390 --> 00:33:29,309 y ahora podríamos devolver de 768 00:33:29,309 --> 00:33:33,650 y ya está, ya estaría hasta caso de uso 769 00:33:33,650 --> 00:33:36,970 pero a ver, tampoco pasa nada porque 770 00:33:36,970 --> 00:33:39,529 perdón, sí, sí, sí 771 00:33:39,529 --> 00:33:41,390 Sí. Está muy bien 772 00:33:41,390 --> 00:33:42,450 que estéis despiertos. 773 00:33:45,150 --> 00:33:47,329 Sí, porque estoy... ¡Ay, no, jolines! 774 00:33:47,390 --> 00:33:49,289 Que estoy recuperando. No me hace falta. Es que estoy 775 00:33:49,289 --> 00:33:50,829 obsesionada con que estaba insertando. 776 00:33:51,450 --> 00:33:52,190 No me hace falta. 777 00:33:53,210 --> 00:33:55,150 Mira, estabas dormido hace un rato, pero te has despertado 778 00:33:55,150 --> 00:33:55,710 muy rápido. 779 00:34:00,809 --> 00:34:03,789 Pues no te he entendido. 780 00:34:05,309 --> 00:34:07,250 Vale, creía que te referías a que como hay 781 00:34:07,250 --> 00:34:09,610 solo una sentencia, aunque fuera de insertar 782 00:34:09,610 --> 00:34:11,230 hacer una transacción para 783 00:34:11,230 --> 00:34:13,269 una sentencia, pero creía que te 784 00:34:13,269 --> 00:34:15,329 referías a eso. Vale, pues 785 00:34:15,329 --> 00:34:17,150 efectivamente aquí no haría 786 00:34:17,150 --> 00:34:19,289 falta hacer esto en transacción, ¿vale? 787 00:34:20,130 --> 00:34:20,989 Entonces ahora ya sí. 788 00:34:21,750 --> 00:34:23,150 Vale, lo que pasa es que bueno 789 00:34:23,150 --> 00:34:25,170 también lo que podemos es acostumbrarnos 790 00:34:25,170 --> 00:34:26,989 en cuanto a la lista esa enorme 791 00:34:26,989 --> 00:34:28,489 de buenas prácticas 792 00:34:28,489 --> 00:34:31,329 una buena práctica de programación 793 00:34:31,329 --> 00:34:32,949 sería no 794 00:34:32,949 --> 00:34:35,030 pongas en peligro a los demás 795 00:34:35,030 --> 00:34:36,690 y 796 00:34:36,690 --> 00:34:38,949 aquí que puede ocurrir 797 00:34:38,949 --> 00:34:40,469 que esto me puede devolver un null 798 00:34:40,469 --> 00:34:42,510 perfectamente, porque si el find 799 00:34:42,510 --> 00:34:45,070 dentro del 800 00:34:45,070 --> 00:34:46,909 DAO, el find 801 00:34:46,909 --> 00:34:49,250 como funciona, pues el find que está aquí 802 00:34:49,250 --> 00:34:50,949 claro 803 00:34:50,949 --> 00:34:52,769 este find 804 00:34:52,769 --> 00:34:55,030 si miramos en la documentación 805 00:34:55,030 --> 00:34:57,309 de find, pues te devuelve 806 00:34:57,309 --> 00:34:58,989 null, lo dirá ahí 807 00:34:58,989 --> 00:34:59,389 abajo 808 00:34:59,389 --> 00:35:06,969 ves, or null, aquí 809 00:35:06,969 --> 00:35:09,429 entonces uno mira estas cosas, uy cuidado 810 00:35:09,429 --> 00:35:10,989 porque podría ser que no devolviera null 811 00:35:10,989 --> 00:35:11,929 Que devolvía yo que sé 812 00:35:11,929 --> 00:35:14,869 Un departamento vacío, que sería muy raro 813 00:35:14,869 --> 00:35:16,010 Pero bueno, te devuelve null 814 00:35:16,010 --> 00:35:19,130 Entonces, no pongamos en peligro a los demás 815 00:35:19,130 --> 00:35:20,829 Dándoles un null 816 00:35:20,829 --> 00:35:23,070 Porque ya sabemos que es un null pointer exception 817 00:35:23,070 --> 00:35:25,309 Entonces, ¿por qué no 818 00:35:25,309 --> 00:35:27,130 Se lo envolvemos en un optional? 819 00:35:28,929 --> 00:35:31,130 Vamos a envolvérselo en un optional 820 00:35:31,130 --> 00:35:32,250 ¿Vale? 821 00:35:34,130 --> 00:35:35,210 Envolvérselo en un optional 822 00:35:35,210 --> 00:35:41,599 No, no, no 823 00:35:41,599 --> 00:35:42,420 Esto, ¿vale? 824 00:35:42,539 --> 00:35:43,940 Se lo envolvemos en un optional 825 00:35:43,940 --> 00:35:45,239 Que 826 00:35:45,239 --> 00:35:47,920 Ya está 827 00:35:47,920 --> 00:35:48,599 Off 828 00:35:48,599 --> 00:35:51,679 La diferencia entre los dos 829 00:35:51,679 --> 00:35:57,420 Vale, un optional con el valor 830 00:35:57,420 --> 00:36:00,820 Si no es 831 00:36:00,820 --> 00:36:02,480 Y si no, un optional vacío 832 00:36:02,480 --> 00:36:02,960 Si es null 833 00:36:02,960 --> 00:36:04,659 Y la diferencia con el off de arriba 834 00:36:04,659 --> 00:36:09,730 Vale 835 00:36:09,730 --> 00:36:10,829 El de arriba 836 00:36:10,829 --> 00:36:12,389 No, si null 837 00:36:12,389 --> 00:36:13,989 Si el valor que metes 838 00:36:13,989 --> 00:36:15,289 Es null 839 00:36:15,289 --> 00:36:17,409 te da un null pointer exception, entonces no gusta 840 00:36:17,409 --> 00:36:19,650 este más, no, porque el de abajo 841 00:36:19,650 --> 00:36:21,570 no te da un null pointer exception, te devuelve 842 00:36:21,570 --> 00:36:22,650 un, ah, sí 843 00:36:22,650 --> 00:36:25,449 no, simplemente que te frena 844 00:36:25,449 --> 00:36:27,409 ahí ya, te frena ahí ya 845 00:36:27,409 --> 00:36:28,570 al que tú puedas devolver un null 846 00:36:28,570 --> 00:36:31,190 te pone ahí un corte antes 847 00:36:31,190 --> 00:36:33,210 venga, a mí me ha gustado este 848 00:36:33,210 --> 00:36:35,369 si vosotros queréis hacerlo de otra manera 849 00:36:35,369 --> 00:36:37,570 vale, entonces aquí 850 00:36:37,570 --> 00:36:39,369 ponemos de, y ya está 851 00:36:39,369 --> 00:36:41,889 con lo cual ahora aquí devolvemos 852 00:36:41,889 --> 00:36:42,969 un optional 853 00:36:42,969 --> 00:36:46,989 de departamento 854 00:36:46,989 --> 00:36:49,699 vale 855 00:36:49,699 --> 00:36:52,179 y así hombre, casi que queda más bonito 856 00:36:52,179 --> 00:36:54,559 porque este método 857 00:36:54,559 --> 00:36:56,599 no va a devolver null nunca jamás 858 00:36:56,599 --> 00:36:57,300 de los jamases 859 00:36:57,300 --> 00:36:59,840 entonces un null pointer exception no hay 860 00:36:59,840 --> 00:37:00,739 entonces el de arte 861 00:37:00,739 --> 00:37:04,880 ya, pero la persona que lo saca 862 00:37:04,880 --> 00:37:06,099 ya 863 00:37:06,099 --> 00:37:08,559 para empezar ya tiene que hacer 864 00:37:08,559 --> 00:37:10,360 un get, con lo cual ya 865 00:37:10,360 --> 00:37:12,300 tiene que por código 866 00:37:12,300 --> 00:37:14,039 operar para sacarlo de ahí 867 00:37:14,039 --> 00:37:15,639 y ya a través de su get 868 00:37:15,639 --> 00:37:17,760 puede ya decidir qué hace si es null 869 00:37:17,760 --> 00:37:19,940 o sea, es una protección, está claro 870 00:37:19,940 --> 00:37:21,099 un null no devuelves 871 00:37:21,099 --> 00:37:24,239 el que te llama jamás va a tener un null 872 00:37:24,239 --> 00:37:25,460 pues eso ya es algo 873 00:37:25,460 --> 00:37:27,679 es decir, le das 874 00:37:27,679 --> 00:37:30,139 no le das la bomba 875 00:37:30,139 --> 00:37:32,340 tú le das la bomba en una caja 876 00:37:32,340 --> 00:37:33,420 entonces 877 00:37:33,420 --> 00:37:35,780 la bomba no le va a explotar jamás 878 00:37:35,780 --> 00:37:37,820 a menos que él diga, mira, la caja 879 00:37:37,820 --> 00:37:39,519 la basura y cojo la bomba con la mano 880 00:37:39,519 --> 00:37:42,019 pero mi línea de pensamiento es la misma 881 00:37:42,019 --> 00:37:43,579 o sea, tú le podías dar el null ahí 882 00:37:43,579 --> 00:37:46,320 y él también sabe que puede requerir una bomba 883 00:37:46,320 --> 00:37:46,960 lo que pasa es que 884 00:37:46,960 --> 00:37:50,099 pero es más fácil 885 00:37:50,099 --> 00:37:52,179 cometer errores, porque tú haces un 886 00:37:52,179 --> 00:37:54,239 recuperar departamento por ID 887 00:37:54,239 --> 00:37:56,079 punto no sé cuántos 888 00:37:56,079 --> 00:37:58,480 recuperar departamento por ID, punto no sé cuántos 889 00:37:58,480 --> 00:38:00,139 ¿vale? y le vas a ir 890 00:38:00,139 --> 00:38:01,019 a un puente de excepción 891 00:38:01,019 --> 00:38:04,280 si tú lo haces así, él cuando escriba 892 00:38:04,280 --> 00:38:05,599 recuperar departamento por ID, punto, va a decir 893 00:38:05,599 --> 00:38:07,940 no, no puedes hacer eso, y ya por código 894 00:38:07,940 --> 00:38:10,360 te va a obligar a sacarlo 895 00:38:10,360 --> 00:38:12,260 antes de la caja, entonces tú ya 896 00:38:12,260 --> 00:38:14,239 estás de alguna manera como más avisado, si no 897 00:38:14,239 --> 00:38:16,619 tú pones regularmente el punto, no sé cuántos 898 00:38:16,619 --> 00:38:18,400 y ahí te cajas el muy fuerte de esencia 899 00:38:18,400 --> 00:38:22,659 hombre, más rápido 900 00:38:22,659 --> 00:38:38,460 o que si te dan la caja 901 00:38:38,460 --> 00:38:40,360 con la bomba, la caja 902 00:38:40,360 --> 00:38:42,460 te la puedes quedar ahí tranquila 903 00:38:42,460 --> 00:38:44,019 no, vamos a ver, el ejemplo 904 00:38:44,019 --> 00:38:46,119 te dan una bomba 905 00:38:46,119 --> 00:38:46,840 y cuando tú 906 00:38:46,840 --> 00:38:49,260 no, a ver 907 00:38:49,260 --> 00:38:52,159 el ejemplo, lo que queda 908 00:38:52,159 --> 00:38:54,199 más claro es, ahí te dan una 909 00:38:54,199 --> 00:38:56,079 bomba, tú la coges con la mano 910 00:38:56,079 --> 00:38:57,880 y tal cual la coges con la mano 911 00:38:57,880 --> 00:38:59,860 te explota porque es manosensible 912 00:38:59,860 --> 00:39:02,179 con lo cual te dan con la bomba y tú la coges 913 00:39:02,179 --> 00:39:03,880 con la mano, te ha explotado 914 00:39:03,880 --> 00:39:05,960 pero si te dan una bomba en una caja, tú coges 915 00:39:05,960 --> 00:39:08,300 la caja con la mano y no explota 916 00:39:08,300 --> 00:39:09,739 y luego tú ya 917 00:39:09,739 --> 00:39:11,900 y luego tú ya si eres tonto 918 00:39:11,900 --> 00:39:14,340 pues dices, y ahora voy a meter la mano 919 00:39:14,340 --> 00:39:15,619 y la cojo, entonces te explota 920 00:39:15,619 --> 00:39:16,840 pero al menos 921 00:39:16,840 --> 00:39:22,380 hombre, pero con el 922 00:39:22,380 --> 00:39:24,420 opcional tú puedes ya, si es nula 923 00:39:24,420 --> 00:39:25,360 hacer lo que sea 924 00:39:25,360 --> 00:39:28,219 pero puedes abrir la tapa de arriba y cogerla con la caja 925 00:39:28,219 --> 00:39:28,940 y ya ver lo que 926 00:39:28,940 --> 00:39:32,619 bueno 927 00:39:32,619 --> 00:39:35,420 pero a ver, yo creo que sí que 928 00:39:35,420 --> 00:39:38,079 es, o sea, sí que se ve 929 00:39:38,079 --> 00:39:40,139 que es más fácil a nivel de código 930 00:39:40,139 --> 00:39:42,099 generar null pointer exception 931 00:39:42,099 --> 00:39:44,460 sino porque con el optional 932 00:39:44,460 --> 00:39:46,780 ya le impides usar el método tal cual 933 00:39:46,780 --> 00:39:47,880 se lo impides usar 934 00:39:47,880 --> 00:39:50,900 claro, pues es suficiente 935 00:39:50,900 --> 00:39:51,880 se lo impides usar 936 00:39:51,880 --> 00:39:54,179 le obligas por lo menos a mirar dentro 937 00:39:54,179 --> 00:39:58,360 pero a ver, que se supone 938 00:39:58,360 --> 00:40:00,460 que estamos hablando de programadores expertos 939 00:40:00,460 --> 00:40:01,219 como vosotros 940 00:40:01,219 --> 00:40:04,139 yo quiero que me exploten la cara 941 00:40:04,139 --> 00:40:08,219 bueno, dígame 942 00:40:08,219 --> 00:40:18,199 El optional lo que te da 943 00:40:18,199 --> 00:40:20,480 es la posibilidad de envolver 944 00:40:20,480 --> 00:40:21,619 un objeto 945 00:40:21,619 --> 00:40:23,460 en otro. 946 00:40:24,199 --> 00:40:26,179 Entonces, la ventaja 947 00:40:26,179 --> 00:40:28,159 del optional es que también puedes envolver 948 00:40:28,159 --> 00:40:30,059 null. Entonces, el optional 949 00:40:30,059 --> 00:40:32,159 es un objeto. Es decir, esto que yo 950 00:40:32,159 --> 00:40:33,900 devuelvo, esto es un objeto. 951 00:40:34,840 --> 00:40:35,840 Y ese objeto 952 00:40:35,840 --> 00:40:37,639 nunca va a ser null. 953 00:40:38,219 --> 00:40:40,340 Pero lo que tiene dentro podría serlo. 954 00:40:40,579 --> 00:40:42,019 Entonces, aquí tengo dos posibilidades. 955 00:40:42,539 --> 00:40:43,699 Devolver el de sin más. 956 00:40:44,440 --> 00:40:45,980 Entonces, puedo devolver null. 957 00:40:46,599 --> 00:40:46,900 ¿Vale? 958 00:40:47,000 --> 00:40:47,320 Ya está. 959 00:40:47,400 --> 00:40:48,480 ¿Qué pasa si devuelvo null? 960 00:40:48,860 --> 00:40:51,800 Que si alguien llama a recuperar departamento id 1 961 00:40:51,800 --> 00:40:54,360 y tal cual escribe todo seguido, punto, 962 00:40:55,099 --> 00:40:56,280 get no sé cuántos, 963 00:40:56,280 --> 00:40:57,480 si ese objeto es null, 964 00:40:57,800 --> 00:40:59,300 null pointer es de. 965 00:40:59,579 --> 00:40:59,800 Vale. 966 00:41:00,539 --> 00:41:01,280 Posibilidad b. 967 00:41:02,420 --> 00:41:03,480 Creo otro objeto, 968 00:41:03,739 --> 00:41:05,280 que es un objeto de tipo optional departamento. 969 00:41:05,940 --> 00:41:06,699 ¿Pensado para qué? 970 00:41:06,699 --> 00:41:08,840 para meter objetos departamento dentro 971 00:41:08,840 --> 00:41:10,719 pues eso es lo que estoy haciendo 972 00:41:10,719 --> 00:41:12,480 con esto, crear un objeto 973 00:41:12,480 --> 00:41:14,420 optional en el que estoy guardando 974 00:41:14,420 --> 00:41:16,639 mi D, y ese es el que devuelvo 975 00:41:16,639 --> 00:41:18,199 ese nunca jamás va a ser neutral 976 00:41:18,199 --> 00:41:20,280 nunca, entonces 977 00:41:20,280 --> 00:41:24,400 vale, sí 978 00:41:24,400 --> 00:41:26,639 pero, ¿cuál es la ventaja 979 00:41:26,639 --> 00:41:28,460 más inmediata? entonces, yo he devuelto un 980 00:41:28,460 --> 00:41:30,500 optional, entonces al que me escribe el código por 981 00:41:30,500 --> 00:41:32,320 arriba, cuando 982 00:41:32,320 --> 00:41:33,320 esté escribiendo 983 00:41:33,320 --> 00:41:36,239 recuperar 984 00:41:36,239 --> 00:41:39,780 departamento 985 00:41:39,780 --> 00:41:41,860 id1 986 00:41:41,860 --> 00:41:43,800 y haga, quiera poner 987 00:41:43,800 --> 00:41:46,059 aquí, .getNombre 988 00:41:46,059 --> 00:41:47,539 pues no puede poner 989 00:41:47,539 --> 00:41:49,519 getNombre, porque este es un optional 990 00:41:49,519 --> 00:41:51,219 luego no admite el método getNombre 991 00:41:51,219 --> 00:41:53,500 entonces él ya ve, ah, tengo que sacarlo 992 00:41:53,500 --> 00:41:55,659 primero de la caja, entonces sí, puede ser 993 00:41:55,659 --> 00:41:56,940 bestia por segunda vez 994 00:41:56,940 --> 00:41:59,539 sacarlo de la caja, get 995 00:41:59,539 --> 00:42:01,099 y luego aliviar el getOf 996 00:42:01,099 --> 00:42:03,440 pero hombre, la idea es ir poniendo 997 00:42:03,440 --> 00:42:05,079 de alguna manera, pues 998 00:42:05,079 --> 00:42:07,320 avisos, protecciones 999 00:42:07,320 --> 00:42:08,619 para eso son las excepciones 1000 00:42:08,619 --> 00:42:11,380 cuando algo lanza una excepción, el otro puede decir 1001 00:42:11,380 --> 00:42:12,659 a mí me la suda 1002 00:42:12,659 --> 00:42:14,679 o puede decir, la capturo 1003 00:42:14,679 --> 00:42:17,579 para eso pones un throw en el otro método 1004 00:42:17,579 --> 00:42:18,659 y 1005 00:42:18,659 --> 00:42:20,219 ya ves que no te duele 1006 00:42:20,219 --> 00:42:24,559 bueno, vale, pones un throw pero estás propagando la 1007 00:42:24,559 --> 00:42:25,960 bueno 1008 00:42:25,960 --> 00:42:31,360 no lo estás propagando, lo estás entregando 1009 00:42:31,360 --> 00:42:32,840 en un objeto 1010 00:42:32,840 --> 00:42:34,860 que nunca te va a generar un pointer exception 1011 00:42:34,860 --> 00:42:36,539 si luego tú perseveras 1012 00:42:36,539 --> 00:42:38,739 en que no, que yo quiero mi null pointer 1013 00:42:38,739 --> 00:42:41,179 excepción, pues ya, chico, tú verás. 1014 00:42:41,780 --> 00:42:42,099 ¿Vale? 1015 00:42:42,380 --> 00:42:46,059 Pero, hombre. 1016 00:42:50,360 --> 00:42:51,119 Bueno, venga. 1017 00:42:53,159 --> 00:42:53,559 Déjala. 1018 00:43:00,579 --> 00:43:02,780 A ver, tu problema no va a ser en ningún caso 1019 00:43:02,780 --> 00:43:04,519 aunque devuelvas tu null, tampoco lo va a ser. 1020 00:43:05,159 --> 00:43:05,579 Pero, bueno. 1021 00:43:06,539 --> 00:43:13,760 Vale, pues ya está. Entonces, vamos ahora a nuestro main para probar esto. 1022 00:43:14,860 --> 00:43:15,179 Venga. 1023 00:43:16,960 --> 00:43:19,739 ¿Alguien necesita una paradinha? 1024 00:43:20,719 --> 00:43:21,940 De tres mesecitos o por ahí. 1025 00:43:23,639 --> 00:43:25,880 William, ¿es una pregunta o necesitas una parada? 1026 00:43:26,699 --> 00:43:28,159 Venga, pon una parada rápida.