WEBVTT

1
00:01.520 --> 00:03.920
Abbiamo imparato a conoscere l'iniezione
di costruttori.

2
00:03.920 --> 00:07.000
Ora impareremo a conoscere l'iniezione di
campo.

3
00:07.080 --> 00:09.040
Salve amici e bentornati.

4
00:09.120 --> 00:15.960
L'iniezione di campi è una tecnica di
dependency injection in cui le dipendenze
vengono iniettate

5
00:15.960 --> 00:21.240
direttamente nelle proprietà dei campi
della classe tramite annotazioni, senza
passarle attraverso il costruttore.

6
00:21.240 --> 00:26.680
Questo viene comunemente fatto usando
l'annotazione inject in framework come
Hilt o Dagger.

7
00:26.720 --> 00:34.640
Si usa principalmente quando l'iniezione
del costruttore non è possibile o pratica,

8
00:34.640 --> 00:36.440
come nel caso di classi, attività o
frammenti del framework Android.

9
00:36.440 --> 00:43.000
Quindi, quando la classe è gestita da
un'attività del framework, da un'attività
o da

10
00:43.000 --> 00:48.920
un frammento di Android, quando non si
controlla la creazione dell'oggetto,
Android istanzia

11
00:48.920 --> 00:50.320
le attività e quando le dipendenze non
possono essere passate tramite il
costruttore.

12
00:50.480 --> 00:58.440
Questo approccio è meno comune
dell'iniezione del costruttore in Kotlin,
perché i campi sono tipicamente

13
00:58.440 --> 01:06.530
privati e Kotlin incoraggia fortemente
l'immutabilità e l'iniezione del
costruttore per la risoluzione delle
dipendenze.

14
01:06.570 --> 01:11.650
Tuttavia, se l'iniezione di campo è
necessaria per i framework o per casi
d'uso specifici.

15
01:11.690 --> 01:16.330
Dagger può aiutare a gestirlo usando
l'annotazione inject.

16
01:16.370 --> 01:20.170
Quando si parla di pugnale, si intende
l'elsa.

17
01:20.210 --> 01:20.890
Pugnale.

18
01:20.930 --> 01:22.250
Lo stesso concetto.

19
01:22.290 --> 01:25.570
Ok, solo un breve riepilogo e un breve...

20
01:25.730 --> 01:29.130
Differenza tra il costruttore e
l'iniezione di campo.

21
01:29.130 --> 01:32.810
Le dipendenze dell'iniezione del
costruttore sono passate attraverso il
costruttore.

22
01:33.050 --> 01:37.730
Mentre nell'iniezione di campo, le
dipendenze vengono iniettate direttamente
nei campi.

23
01:37.730 --> 01:41.290
L'iniezione del costruttore è preferibile
per i componenti non Android.

24
01:41.290 --> 01:46.530
Mentre l'iniezione di campo è comune nelle
classi Android come le attività e i
frammenti.

25
01:46.530 --> 01:53.010
Le dipendenze nell'iniezione del
costruttore sono valori immutabili, mentre
le dipendenze sono immutabili.

26
01:53.010 --> 02:00.790
Nell'iniezione di campo, l'iniezione del
costruttore var o late initiate var è più
facile da testare dell'iniezione di campo.

27
02:00.950 --> 02:04.590
Leggermente più difficile da testare se
non viene maneggiato con cura.

28
02:04.590 --> 02:05.110
Non preoccupatevi.

29
02:05.150 --> 02:11.070
Prendiamo un esempio di field injection e
impariamo a conoscere questo tipo di
dipendenza.

30
02:11.070 --> 02:13.270
Torniamo all'esempio precedente.

31
02:13.270 --> 02:24.110
Qui abbiamo aggiunto l'elsa e le
dipendenze e abbiamo usato anche

32
02:24.110 --> 02:24.590
il plugin Kapt e qui abbiamo aggiunto elsa
e Kapt.

33
02:24.590 --> 02:32.910
Anche nel Build.gradle che si trova a
livello di progetto, abbiamo creato le
classi engine e car.

34
02:32.950 --> 02:37.470
Ora voglio che vi concentriate con me
nella classe di motori.

35
02:37.470 --> 02:40.950
Non ci sono cambiamenti perché si tratta
di una dipendenza.

36
02:40.990 --> 02:42.670
Dobbiamo iniettarlo.

37
02:42.670 --> 02:48.310
Abbiamo quindi a che fare con la classe
del motore, che è una classe di
dipendenza.

38
02:48.310 --> 02:50.670
Nessuna modifica per la classe di
dipendenza.

39
02:50.670 --> 03:00.280
Passare all'auto all'interno della classe
dipendente, che è l'auto di cui dobbiamo
rimuovere il costruttore di iniezione.

40
03:00.280 --> 03:03.280
Qui si utilizza l'iniezione del
costruttore.

41
03:03.440 --> 03:05.760
Non abbiamo più bisogno di usarlo.

42
03:06.040 --> 03:10.760
Dobbiamo passarlo e utilizzarlo come
iniezione di campo.

43
03:11.360 --> 03:14.000
Iniziare con l'iniezione tardiva.

44
03:14.000 --> 03:16.120
Avviare il motore var.

45
03:16.280 --> 03:18.080
È di tipo motore.

46
03:18.120 --> 03:24.000
In questo caso, l'annotazione "inietta" è
posizionata sul campo del motore.

47
03:24.240 --> 03:29.760
Dagger inietterà un'istanza del motore nel
campo in fase di esecuzione.

48
03:30.080 --> 03:38.920
Quindi, invece di iniettare il motore nel
costruttore,

49
03:38.920 --> 03:39.520
lo iniettiamo come campo all'interno di
questa classe.

50
03:39.600 --> 03:41.720
Passiamo al modulo dell'applicazione.

51
03:41.760 --> 03:44.520
Qui non abbiamo bisogno di altro.

52
03:44.800 --> 03:46.280
L'autovettura in dotazione.

53
03:46.320 --> 03:49.040
Noi forniamo solo il motore.

54
03:49.280 --> 03:56.200
Poiché car utilizza l'iniezione di campo,
non ha bisogno di un costruttore o di
fornire un'annotazione per car.

55
03:56.290 --> 04:05.650
Tuttavia, il motore deve comunque
richiedere l'iniezione del costruttore o
un modulo per gli scenari più complessi.

56
04:05.930 --> 04:08.850
Il terzo passo è il componente dell'app.

57
04:09.050 --> 04:14.130
Il componente collega il modulo e le
classi che richiedono l'iniezione.

58
04:14.170 --> 04:17.890
È necessario modificare il codice.

59
04:18.090 --> 04:19.850
Rimuovere questa funzione.

60
04:19.850 --> 04:25.970
Creerò una nuova funzione inject e passerò
il parametro car.

61
04:26.290 --> 04:32.770
Questa funzione indica a dagger di
iniettare le dipendenze nei campi della
classe auto.

62
04:33.090 --> 04:38.010
Quindi questa funzione inietterà l'istanza
dell'auto.

63
04:38.050 --> 04:40.250
Passare al file principale.

64
04:40.410 --> 04:43.610
È necessario modificare il codice.

65
04:43.930 --> 04:46.290
Il componente dell'applicazione rimarrà lo
stesso.

66
04:46.570 --> 04:53.810
Dobbiamo creare un'istanza dell'auto,
creando un costruttore di auto.

67
04:53.930 --> 04:59.510
Poi dobbiamo iniettare le dipendenze nel
campo dell'auto.

68
04:59.550 --> 05:00.750
Componente dell'app.

69
05:00.790 --> 05:01.150
Punto.

70
05:01.350 --> 05:02.150
Iniettare.

71
05:02.270 --> 05:02.870
Auto.

72
05:03.110 --> 05:03.990
Usare l'auto.

73
05:04.030 --> 05:04.590
Stampa.

74
05:04.590 --> 05:04.990
Auto.

75
05:05.270 --> 05:05.830
Guida.

76
05:06.110 --> 05:09.430
Inoltre, se andiamo alla macchina si può
vedere println.

77
05:09.470 --> 05:11.950
Non è quindi necessario usare println.

78
05:12.070 --> 05:15.390
Eseguite di nuovo l'applicazione ed ecco
fatto.

79
05:15.590 --> 05:17.030
Il motore è stato avviato.

80
05:17.070 --> 05:25.510
In questo video abbiamo imparato a
conoscere l'iniezione di campo,

81
05:25.510 --> 05:27.110
sostituendo all'interno dell'auto
l'iniezione del costruttore con
l'iniezione del campo.

82
05:27.110 --> 05:32.390
Abbiamo creato una proprietà di campo
chiamata engine e annotata con inject.

83
05:32.430 --> 05:41.030
Abbiamo modificato il componente dell'app
per iniettare l'auto, iniettare i campi
della classe auto e poi

84
05:41.070 --> 05:47.710
abbiamo modificato il codice all'interno
della funzione principale, creato la
nostra istanza e poi iniettato nell'app.

85
05:48.110 --> 05:52.630
componente App, iniettiamo l'auto e poi la
chiamiamo per testare l'applicazione.