1
00:00:00,270 --> 00:00:06,450
Bien, en esta clase vamos a ver cómo inyectar, pero mediante la interfaz, desacoplar completamente

2
00:00:06,570 --> 00:00:09,090
una implementación concreta como una clase.

3
00:00:09,510 --> 00:00:13,050
Acá mi servicio está muy acoplado, ya que es una clase.

4
00:00:13,590 --> 00:00:16,890
La clase por lo general podrían cambiar más adelante.

5
00:00:16,920 --> 00:00:18,450
Podríamos tener otra clase.

6
00:00:18,570 --> 00:00:20,430
Otra implementación con otro nombre.

7
00:00:20,730 --> 00:00:24,680
Por lo tanto, acá el tipo de dato podría cambiar.

8
00:00:25,110 --> 00:00:30,960
Y si lo estamos usando inyectando en varios controladores, habría que estar modificando uno por uno.

9
00:00:31,050 --> 00:00:34,410
Entonces, por eso es mejor implementar una interfaz.

10
00:00:34,530 --> 00:00:37,110
Es algo mucho más genérico, abstracto.

11
00:00:37,200 --> 00:00:44,280
Ciertas clases concreta implementan esta interfaz e inyectamos a través del tipo genérico y no la implementación

12
00:00:44,280 --> 00:00:44,760
concreta.

13
00:00:44,940 --> 00:00:51,030
Entonces podremos tener más clases que implementan la interfaz y a través de un selector que se le llama

14
00:00:51,060 --> 00:00:53,880
calificador o coali fáser, que después lo vamos a ver.

15
00:00:53,970 --> 00:01:00,090
Podemos seleccionar qué implementación concreta de esa interfaz vamos a utilizar, a inyectar en el

16
00:01:00,090 --> 00:01:00,690
controlador.

17
00:01:01,080 --> 00:01:02,490
Pero bien, vamos por partes.

18
00:01:02,850 --> 00:01:06,150
Lo primero es crear una nueva interfaz para mi servicio.

19
00:01:06,810 --> 00:01:09,220
Entonces nos vamos a servis en el package.

20
00:01:09,990 --> 00:01:13,230
Vamos a crear una interfaz New Interface.

21
00:01:14,870 --> 00:01:22,070
Le vamos a llamar I mayúscula de interfaz, servicio y servicio y de interfaz.

22
00:01:22,460 --> 00:01:28,520
Aunque también le podrían colocar el nombre que queramos, pero por convención, por estándar, los

23
00:01:28,520 --> 00:01:34,700
nombres de interfaces terminan en able o ible, ya que representan comportamientos.

24
00:01:34,730 --> 00:01:38,720
Por ejemplo, ejecutable imprimible conversable.

25
00:01:38,810 --> 00:01:40,520
En fin, hable o ible.

26
00:01:40,640 --> 00:01:47,480
Pero bueno, si tenemos una interfaz, un nombre que no pega o no calza con able oponible, como por

27
00:01:47,480 --> 00:01:54,560
ejemplo cliente servidor o cliente servicio, le podemos colocar una I mayúscula antepuesta al nombre

28
00:01:54,590 --> 00:01:55,640
tal como lo tenemos acá.

29
00:01:56,530 --> 00:02:02,270
Finalizar entonces una interfaz contiene métodos sin implementar contratos.

30
00:02:02,390 --> 00:02:07,940
Estos contratos dice qué operaciones van a implementar las clases concretas?

31
00:02:08,060 --> 00:02:10,790
En el fondo ese comportamiento lo que hacen.

32
00:02:10,940 --> 00:02:16,990
Entonces podríamos tener más de una clase concreta que implementa interfaz y todas hacen cierta tarea,

33
00:02:17,000 --> 00:02:23,840
cierto trabajo, pero de forma distinta implementada por ejemplo de alguna u otra forma diferente.

34
00:02:23,990 --> 00:02:31,100
Llevando un ejemplo en base de datos, podríamos tener una que trabaja con J de DCD con consultas nativas

35
00:02:31,160 --> 00:02:39,530
SQL, mientras que otra implementación trabaje con Internet o JPA con un o RM consultas a nivel de objetos.

36
00:02:43,070 --> 00:02:50,030
Acá tenemos el método Operación que rotonda un streak vamos a guardar, nos vamos a ir a mi servicio

37
00:02:50,840 --> 00:02:52,660
y vamos a implementar esta interfaz.

38
00:02:55,670 --> 00:02:56,300
Perfecto.

39
00:02:56,420 --> 00:02:57,830
Si se fijan, funciona bien.

40
00:02:58,080 --> 00:02:59,720
Ahora, qué pasa si quitamos este método?

41
00:02:59,870 --> 00:03:01,720
Lo vamos a quitar automáticamente.

42
00:03:01,720 --> 00:03:08,870
Te marca un error, ya que mi servicio debe implementar el método genérico o abstracto de la interfaz

43
00:03:08,930 --> 00:03:11,060
operación de que está implementando.

44
00:03:11,150 --> 00:03:17,180
Es un protocolo que debe cumplir un contrato, por lo tanto, está obligado siempre a implementar este

45
00:03:17,180 --> 00:03:17,540
método.

46
00:03:19,460 --> 00:03:26,900
Voy a volver a como lo teníamos el Loved Right, una anotación que indica que este método es una implementación

47
00:03:26,900 --> 00:03:31,040
de un padre, ya sea una interfaz o una clase que estemos heredando.

48
00:03:31,190 --> 00:03:35,270
Estamos o escribiendo o implementando este método vamos a guardar.

49
00:03:35,360 --> 00:03:40,640
Y ahora que mi servicio implementa la interfaz, podemos inyectar a través del tipo genérico.

50
00:03:41,450 --> 00:03:47,360
Nos vamos al controlador y en vez de la clase concreta usamos la interfaz.

51
00:03:48,050 --> 00:03:48,950
Importamos.

52
00:03:50,200 --> 00:03:57,600
Quitamos el import de la clase concreta y nuestro código está mucho mejor, mucho más desacoplar.

53
00:03:57,910 --> 00:04:01,600
Ahora depende de algo genérico y no de algo concreto.

54
00:04:01,810 --> 00:04:04,570
Como es genérico, la mantención es mucho más simple.

55
00:04:04,900 --> 00:04:06,840
Ahora podríamos crear otra clase.

56
00:04:06,940 --> 00:04:08,650
Mi servicio, mi servicio.

57
00:04:08,740 --> 00:04:16,150
Otro que implementa esta misma interfaz y simplemente acá vamos a estar inyectando a través de la interfaz.

58
00:04:16,480 --> 00:04:22,840
Lo que sí tendríamos que usar un calificador para indicar que implementación concreta vamos a inyectar

59
00:04:22,960 --> 00:04:27,280
a través del nombre del componente, como por ejemplo los componentes.

60
00:04:27,280 --> 00:04:30,940
Acá también le podemos dar un nombre, un identificador.

61
00:04:31,090 --> 00:04:36,790
Por ejemplo, mi servicio, mi servicio simple por poner un nombre.

62
00:04:36,970 --> 00:04:43,720
Entonces con un calificador indicamos que vamos a inyectar mis servicios simple, pero como tenemos

63
00:04:43,810 --> 00:04:49,960
una sola implementación no es necesario, va a inyectar la primera que encuentre la primera implementación

64
00:04:49,960 --> 00:04:55,210
concreta de esta interfaz, siempre cuando esté anotada con component o con servis.

65
00:04:55,330 --> 00:04:56,530
Bien, vamos a ejecutar.

66
00:05:02,610 --> 00:05:03,470
Y nos vamos a la raíz.

67
00:05:03,620 --> 00:05:10,370
Se fijan y funciona igual que entran de forma transparente, pero por detrás de escena, inyectando

68
00:05:10,490 --> 00:05:12,260
mediante la interfaz.

69
00:05:12,520 --> 00:05:12,680
Bien.

70
00:05:12,770 --> 00:05:18,290
Y antes finalizar una clase de componentes, SPRI tiene que tener ciertas características, como por

71
00:05:18,290 --> 00:05:22,280
ejemplo siempre un constructor por defecto vacío.

72
00:05:22,400 --> 00:05:28,250
En este caso, como no tenemos ningún constructor, va a tomar el constructor por defecto, sin parámetros,

73
00:05:28,370 --> 00:05:28,970
vacío.

74
00:05:29,060 --> 00:05:34,580
Pero si tenemos una clase cualquiera que es un componente spring y tiene un constructor con parámetros,

75
00:05:34,700 --> 00:05:40,760
además de ese constructor, estamos obligados a tener otro constructor sin argumento vacío, ya que

76
00:05:40,760 --> 00:05:43,430
es Brink por detrás de escena instancia.

77
00:05:43,490 --> 00:05:49,490
Estos objetos los maneja de forma automática, pero esta instancias lo hace con el constructor sin parámetros.

78
00:05:49,610 --> 00:05:55,580
Por lo tanto, si tenemos un constructor con parámetros y no implementamos un constructor por defecto

79
00:05:55,670 --> 00:06:02,540
vacío, va a lanzar error de que no encuentra un constructor por defecto sin parámetros para poder crear

80
00:06:02,600 --> 00:06:04,730
esta instancia y para poder manejarla.

81
00:06:04,910 --> 00:06:10,580
Entonces, como característica básica, todo componente spring que vamos a registrar en el contenedor

82
00:06:10,640 --> 00:06:14,630
tiene que tener un constructor por defecto sin argumento.

83
00:06:14,810 --> 00:06:18,320
En este caso es implícito de que no tenemos ningún constructor.

84
00:06:18,590 --> 00:06:26,870
Bien, entonces por eso es importante utilizar en la inyección de dependencia los tipos más genéricos

85
00:06:26,960 --> 00:06:29,360
ojalas interfaces o clases abstracta.

86
00:06:29,510 --> 00:06:35,150
De esa forma, desacople, vamos del controlador o de la clase que estemos inyectando una implementación

87
00:06:35,150 --> 00:06:35,630
concreta.

88
00:06:35,750 --> 00:06:42,770
Si no es algo genérico, que podría ser cualquier otro tipo concreto sin tener que modificar o intervenir

89
00:06:42,860 --> 00:06:43,460
el código.

90
00:06:43,580 --> 00:06:45,830
Por ahora nada más nos vemos.