Šta su zavisnosti (eng. dependency)?
U programiranju, “zavisnost” predstavlja odnos između različitih komponenti u softverskom sistemu. Smatra se da kada jedna komponenta koristi ili zavisi od druge komponente, da tada postoji zavisnost između njih.
Zavisnost može biti u mnogo oblika, a osnovni tipovi zavisnosti uključuju:
- Zavisnost od Klase (Class Dependency) se odnosi na situaciju kada jedna klasa koristi drugu klasu. Na primer, ako imate klasu koja predstavlja korisnika (User), a drugu klasu koja upravlja bazom podataka (DatabaseManager), klasa korisnika može zavisiti od klase za upravljanje bazom podataka kako bi čuvala ili dobijala informacije.
- Zavisnost od Modula (Module Dependency) se javlja u većim sistemima, kada se različite komponente često se organizuju u module. Zavisnost između modula može se pojaviti kada jedan modul koristi funkcionalnosti ili usluge drugog modula.
- Zavisnost od Metode (Method Dependency) nastaje kada jedna metoda poziva ili koristi drugu metodu.
- Zavisnost od Servisa (Service Dependency) nastaje kada aplikacije koristi različite servise, kao što su servisi za upravljanje podacima, servisi za autentifikaciju ili servisi za slanje poruka. Zavisnost od servisa javlja se kada jedan deo koda (npr. klasa) koristi funkcionalnosti ili usluge nekog servisa.
Zavisnosti nisu same po sebi loše, ali je važno upravljati njima na način koji olakšava održavanje i testiranje koda. Ali preterana zavisnost i “čvrsto povezivanje” (eng. Strongly Coupled Code) između komponenti može otežati promene u kodu i testiranje jedinica koda.
Povezivanja komponenti
“Čvrsto povezivanje” (eng. Strongly Coupled Code)
U programiranju, “čvrsto povezivanje” (eng. Strongly Coupled Code) se odnosi na situaciju kada gde komponente sistema imaju jake zavisnosti jedna o drugoj tj. jedna komponenta koristi drugu komponentu ili kada jedan modul koristi drugi modul pa tada promene u jednom delu koda često zahtevaju promene u drugim delovima koji od njih zavise.
Mana ovog dizajna je što održavanje tako pisanog koda može biti teže jer promene u jednom delu koda mogu imati kaskadne efekte na druge delove. Takodje se smanjuje fleksibilnost jer zamena ili nadogradnja delova može iziskivati šire promene u celom sistemu.
Primer za “Strongly Coupled Code” je “direktno instanciranje objekata unutar jedne komponente” a koja zavise od implementacija drugih komponenti ili neposredno korišćenje konkretnih klasa umesto apstrakcija ili interfejsa za komunikaciju između komponenti.
“Slabo povezivanje” (eng.Loosely Coupled Code)
Slabo povezan kod (Loosely Coupled Code) se odnosi na dizajn gde komponente sistema imaju minimalne zavisnosti jedne o drugih, pa promene u jednom delu koda ne bi trebalo da uzrokuju značajne promene u drugim delovima.
Kod ovog dizajna komponente često komuniciraju putem interfejsa ili apstrakcija umesto da direktno zavise od implementacija drugih komponenti.
Prednost ovakog dizajna se primećuje kod održavanja jer promene u jednom delu koda neće automatski zahtevati promene u drugim delovima, te se tako povećava fleksibilnost sistema jer je moguće lakše zameniti ili nadograditi delove ne utičući na celokupan sistem.
Šta je “Dependecies injection”?
“Dependecies injection” je softverski obrazac dizajna koji se zasniva na pravilu da prosleđujemo objekate drugim komponentama kojima su potrebni (“inject”), umesto da ih same komponente kreiraju unutar sebe.
Takav pristup doprinosi smanjenju međusobne zavisnosti između komponenata (“Loosely Coupled Code”). Zavisne klase (“dependenceies”) čije se instance prosledjuju moraju imate interfejse ili same biti apstraktne. Ovaj pristup programiranju takodje olakšava jedinično testiranje jer se može lako ubacivati lažnih (mock) implementacija zavisnosti tokom testiranja.
Postoje tri glavna načina ubacivanja zavisnosti iz spolja:
-
Constructor Injection: zavisnosti se ubacuju kroz konstruktor klase
123456789public class SomeClass{private readonly IDependency dependency;public SomeClass(IDependency dependency){this.dependency = dependency;}} -
Method Injection: zavisnosti se ubacuju putem metoda
1234567public class SomeClass{public void DoSomething(IDependency dependency){// Use the dependency}} -
Property Injection: zavisnosti se ubacuju putem svojstava
1234public class SomeClass{public IDependency Dependency { get; set; }}
Primeri
U ovome primeru ćemo razmotriti dve klase medjusobno povezane, klasa “Automobil” i klasa “Motor”. Svima je jasno da klasa “Automobil” zavisi od klase “Motor” tj. da je “Motor” zavisnost (eng. dependency) klase “Automobil”. U primerima klasa “Motor” ima samo jednu metodu koja se zove “Start”, i upravo ta metoda je potrebna klasi “Automobil”.
Primer čvrstog povezivanja (“Strongly Coupled Code”)
“Motor” klasa u ovome slučaju izgleda ovako:
|
1 2 3 4 5 6 7 8 |
public class Motor { public void Start() { // Start the engine Console.WriteLine("Engine started!"); } } |
Kod “Strongly Coupled Code” dizajna se direktno instancira zavisnički objekt, te ćemo u ovome primeru direktno instancirati “Motor” objekat u sklopu konstruktora:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class Automobil { private readonly Motor motor; public Automobil() { // Primer za čvrstu zavisnost jer se instanca pravi u konstruktoru this.motor = new Motor(); } public void Start() { motor.Start(); } } |
Pa bi u glavnom programu to ovako izgledalo:
|
1 2 3 4 5 6 7 8 |
class Program { static void Main() { Automobil automobil = new Automobil(); automobil.Start(); } } |
Ovaj kod izgleda sasvim regularno i OK sve dok se ne javi potreba za proširenjem mogućnosti aplikacije, pa treba da se ubaci novi motor npr. električni. Tada se javalja problem što pored nove klase za motor moramo da pravimo izmene i u klasi Automobil tj. najverovatnije da pravimo dve posebne klase automobila svaki sa svojim motorom!
Primer slabog povezivanja “Loosely Coupled Code” sa “dependency injection”
U ovome primeru moramo dodati interfejs za metodu Start:
|
1 2 3 4 |
public interface IMotor { void Start(); } |
Pa ćemo klasu “Motor” promeniti tako da implementira ovaj interfejs:
|
1 2 3 4 5 6 7 8 |
public class Motor : IMotor { public void Start() { // Start the engine Console.WriteLine("Engine started!"); } } |
Sa dependecies injection-om lako možemo da dodajemo nove motore, dovoljno je da se samo kreira nova klasa za novi motor, npr. “MotorElektrični” koja implementira isti IMotor interfejs:
A klasa koja implementira taj interfejs:
|
1 2 3 4 5 6 7 8 |
public class MotorElektrični : IMotor { public void Start() { // Start the engine Console.WriteLine("Elektric Engine started!"); } } |
Pa će u klasa Automobil sada imati sledeći oblik:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class Automobil { private readonly IMotor motor; public Automobil(IMotor motor) { this.motor = motor; } public void Start() { motor.Start(); } } |
U glavnom programu se sada vidi da se klasi “Automobil” prosledjuje kao parametar kreirana instanca “Motor”-a:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class Program { static void Main() { // Kreiranje instance motora: IMotor motor = new Motor(); IMotor elektricniMotor = new MotorElektrični(); // Injektovanje instance u automobil kroz konstruktor: Automobil automobil = new Automobil(motor); Automobil elektricniAutomobil = new Automobil(elektricniMotor); automobil.Start(); elektricniAutomobil.Start(); } } |
ZAKLJUČAK:
U primeru sa Dependency Injection (“Loosely Coupled Code”), klasa Automobil koristi IMotor interfejs, a konkretna implementacija (Motor) se ubacuje putem konstruktora. To omogućava jednostavnu zamenu implementacije motora.
Dok u primeru bez Dependency Injection (“Strongly Coupled Code”), klasa Automobil direktno instancira Motor, čime je kod manje fleksibilan, te ako želimo promeniti tip motora, morali bismo direktno promeniti klasu Automobil.
Korišćenje Dependency Injection pruža veću fleksibilnost i olakšava testiranje i održavanje koda, čineći ga manje zavisnim od konkretnih implementacija.