1. Müqavilə kimi interfeyslər: arxitekturanın təməli
Java-da (və təkcə Java-da deyil) interfeys — bu sadəcə metodlar toplusu deyil. Bu, müqavilədir: interfeysi həyata keçirən istənilən sinfin müəyyən davranışı dəstəkləyəcəyinə dair vəd. Interfeys nəyi həyata keçirmək lazım olduğunu, necə yox, məhz nəyi müəyyən edir.
Bu nə üçün vacibdir?
- Kodu səviyyələrə bölmək. Interfeyslər sayəsində “nə edir” ilə “necə edir”i ayıra bilirik. Məsələn, əgər sizdə PaymentService interfeysi varsa, müxtəlif realizasiyalar ödənişi bank kartı, PayPal və ya kriptovalyuta ilə emal edə bilər, amma pay() çağıran kod detallarla maraqlanmır.
- Elastiklik və genişlənəbilənlik. Qalan kodu dəyişmədən interfeysin yeni realizasiyasını əlavə edə bilərsiniz. Bu, böyük komandalarda və uzunömürlü layihələrdə xüsusilə önəmlidir.
- Testlənəbilənlik. Interfeyslər sayəsində əsas koda toxunmadan realizasiyaları test (mock) variantları ilə asanlıqla əvəz etmək olur.
Nümunə: xidmət səviyyəsi və DAO
Biznes-tətbiqlərdən klassik nümunəyə baxaq. Tutaq ki, istifadəçilərlə iş üçün interfeysimiz var:
public interface UserRepository {
User findById(int id);
void save(User user);
}
Müxtəlif situasiyalarda bu interfeysi müxtəlif cür reallaşdıra bilərik:
- DatabaseUserRepository — istifadəçiləri verilənlər bazasında saxlayır.
- InMemoryUserRepository — istifadəçiləri yaddaşda saxlayır (testlər üçün əlverişlidir).
- FileUserRepository — istifadəçiləri faylda saxlayır.
İstifadəçilərlə işləyən kod yalnız interfeysdən asılıdır:
public class UserService {
private final UserRepository userRepository;
// Asılılığın konstruktor vasitəsilə yeridilməsi
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public void registerUser(User user) {
userRepository.save(user);
}
}
Artıq servisin kodunu dəyişmədən UserRepository realizasiyasını asanlıqla əvəz edə bilərik.
2. Dependency Injection (asılılıqların yeridilməsi) və interfeyslərin rolu
Dependency Injection (DI, asılılıqların yeridilməsi) — bu, asılılıqların (məsələn, interfeys realizasiyalarının) obyektə kənardan ötürülməsi üsuludur, adətən konstruktor və ya setter vasitəsilə. Bu, çevik, asan test olunan və genişlənə bilən tətbiqlər qurmağa imkan verir.
İnterfeyslər DI üçün niyə vacibdir?
Əgər realizasiyanı koda sərt şəkildə yazsaq, onu əvəzləmək çətin olar. Interfeyslər sayəsində əsas kodu dəyişmədən istənilən realizasiyanı qoşa bilərik.
Asılılığın yeridilməsi ilə nümunə
public interface NotificationSender {
void send(String message);
}
public class EmailNotificationSender implements NotificationSender {
@Override
public void send(String message) {
System.out.println("E-poçt göndərilməsi: " + message);
}
}
public class SmsNotificationSender implements NotificationSender {
@Override
public void send(String message) {
System.out.println("SMS göndərilməsi: " + message);
}
}
// NotificationSender istifadə edən sinif
public class NotificationService {
private final NotificationSender sender;
public NotificationService(NotificationSender sender) {
this.sender = sender;
}
public void notifyUser(String message) {
sender.send(message);
}
}
İndi siz NotificationService-i asanlıqla test edə bilərsiniz: məsələn, real ismarıc göndəricisi əvəzinə “stub” verərək.
3. Dizayn nümunələri və interfeyslər
Interfeyslər təkcə arxitektura haqqında deyil, həm də dizayn nümunələri haqqındadır. Bir çox nümunəni interfeyssiz reallaşdırmaq mümkün deyil. Ən populyarlarına baxaq.
Observer (Müşahidəçi)
Observer — müşahidə olunan obyektin vəziyyətindəki dəyişikliklər barədə digər obyektləri (müşahidəçiləri) xəbərdar etməyə imkan verən nümunədir.
UML diaqramı (sadələşdirilmiş):
+------------------+ +------------------------+
| Subject |<------->| Observer |
+------------------+ +------------------------+
| +addObserver() | | +update() |
| +removeObserver()| +------------------------+
| +notifyObservers()|
+------------------+
Kod nümunəsi:
import java.util.ArrayList;
import java.util.List;
// Müşahidəçi interfeysi
public interface Observer {
void update(String event);
}
// Subyekt interfeysi
public interface Subject {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(String event);
}
// Subyektin reallaşdırılması
public class NewsAgency implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void addObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String event) {
for (Observer observer : observers) {
observer.update(event);
}
}
}
// Müşahidəçinin reallaşdırılması
public class NewsReader implements Observer {
private String name;
public NewsReader(String name) {
this.name = name;
}
@Override
public void update(String event) {
System.out.println(name + " xəbər aldı: " + event);
}
}
// Nümunəni işə salmaq üçün əsas sinif
public class ObserverExample {
public static void main(String[] args) {
// "xəbər agentliyi" (subyekt) yaradırıq
NewsAgency agency = new NewsAgency();
// Müşahidəçiləri yaradırıq
Observer alice = new NewsReader("Alisa");
Observer bob = new NewsReader("Bob");
// Müşahidəçiləri xəbərlərə abunə edirik
agency.addObserver(alice);
agency.addObserver(bob);
// Xəbər göndəririk
agency.notifyObservers("Java-nın yeni versiyası çıxdı!");
// Bir müşahidəçini çıxarıb daha bir xəbər göndəririk
agency.removeObserver(bob);
agency.notifyObservers("Abunəçilər üçün növbəti xəbər");
}
}
Nəticə:
Alisa xəbər aldı: Java-nın yeni versiyası çıxdı!
Bob xəbər aldı: Java-nın yeni versiyası çıxdı!
Alisa xəbər aldı: Abunəçilər üçün növbəti xəbər
Strategy (Strategiya)
Strategy — müştəri kodunu dəyişmədən, icra zamanı davranış alqoritmini seçməyə imkan verən nümunədir.
UML diaqramı (sadələşdirilmiş):
+------------------+
| Context |
+------------------+
| -strategy: Strat.|
| +setStrategy() |
| +execute() |
+------------------+
|
v
+------------------+
| Strategy |<-------------------------+
+------------------+ |
| +execute() | |
+------------------+ |
^ |
| |
+------------------+ +------------------+ |
| ConcreteA | | ConcreteB |---+
+------------------+ +------------------+
| +execute() | | +execute() |
+------------------+ +------------------+
Kod nümunəsi:
public interface PaymentStrategy {
void pay(int amount);
}
public class CreditCardPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("Ödəniş " + amount + " rubl bank kartı ilə");
}
}
public class PaypalPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("Ödəniş " + amount + " rubl PayPal vasitəsilə");
}
}
public class OnlineStore {
private PaymentStrategy paymentStrategy;
public void setPaymentStrategy(PaymentStrategy strategy) {
this.paymentStrategy = strategy;
}
public void checkout(int amount) {
paymentStrategy.pay(amount);
}
}
// İstifadə:
OnlineStore store = new OnlineStore();
store.setPaymentStrategy(new CreditCardPayment());
store.checkout(1000);
store.setPaymentStrategy(new PaypalPayment());
store.checkout(500);
Nəticə:
Ödəniş 1000 rubl bank kartı ilə
Ödəniş 500 rubl PayPal vasitəsilə
Command (Komanda)
Command — sorğunu obyekt kimi kapsullaşdıran, hərəkətləri parametr kimi ötürməyə imkan verən nümunədir.
Kod nümunəsi:
public interface Command {
void execute();
}
public class LightOnCommand implements Command {
@Override
public void execute() {
System.out.println("İşıq yandırıldı!");
}
}
public class LightOffCommand implements Command {
@Override
public void execute() {
System.out.println("İşıq söndürüldü!");
}
}
public class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
}
}
// İstifadə:
RemoteControl remote = new RemoteControl();
remote.setCommand(new LightOnCommand());
remote.pressButton(); // İşıq yandırıldı!
remote.setCommand(new LightOffCommand());
remote.pressButton(); // İşıq söndürüldü!
4. Arxitekturada interfeyslərin istifadəsinin üstünlükləri
- Zəif əlaqəlilik (Low Coupling). Kod konkret realizasiyadan deyil, yalnız interfeysdən asılıdır. Bu, əvəzləməyi, test etməyi və genişləndirməyi asanlaşdırır.
- Testlənəbilənlik. Unit-testlər yazarkən real realizasiyanı test (mock/stub) variantı ilə asanlıqla əvəz etmək olur.
- Genişlənəbilənlik. Mövcud kodu dəyişmədən interfeysin yeni realizasiyalarını əlavə etmək mümkündür — açıqlıq/bağlılıq prinsipi (OCP).
- Paralel inkişaf. Ümumi interfeys olduqda bir neçə komanda sistemi müstəqil şəkildə reallaşdıra bilər.
- Arxitekturanın çevikliyi. Yeni nümunələri və yanaşmaları asanlıqla tətbiq etmək olur.
5. Arxitekturada interfeyslərdən istifadə zamanı tipik səhvlər
Səhv № 1: Realizasiyaya sərt bağlılıq.
Əgər hər yerdə konkret siniflərdən istifadə edirsinizsə, interfeyslərdən yox, realizasiyanın istənilən dəyişikliyi kodun bir çox yerində yenidən yazılmasını tələb edəcək. Həmişə “interfeyslər səviyyəsində” proqramlaşdırmağa çalışın.
Səhv № 2: Həddindən artıq böyük interfeyslər (God Interface).
Interfeys yığcam olmalı və bir məsuliyyət zonasına cavab verməlidir. Hər şeyi bir interfeysə yığmayın — əks halda realizasiya ağır və dolaşıq olacaq.
Səhv № 3: Testlənəbilənliyin üstünlüklərini görməzdən gəlmək.
Əgər asılılıqları testlərdə əvəzləmək üçün interfeyslərdən istifadə etmirsinizsə, testləriniz yavaş və etibarsız ola bilər, xüsusilə real verilənlər bazaları və şəbəkələrlə işləyirlərsə.
Səhv № 4: Bir neçə realizasiya var, amma DI yoxdur.
Əgər interfeys üçün bir neçə realizasiya yaratmısınızsa, lakin onlardan birini koda sərt şəkildə yazmısınızsa, arxitekturanın çevikliyini itirirsiniz. Asılılıqların yeridilməsindən (DI) istifadə edin!
GO TO FULL VERSION