Czy możesz wyjaśnić zasadę odwracania zależności i jak jest ona stosowana w projektowaniu systemów programistycznych?

Zasada odwrócenia zależności (Dependency Inversion Principle, DIP) jest jednym z pięciu zasad SOLID, które mówią, że:

• Moduły wysokiego poziomu nie powinny zależeć od modułów niskiego poziomu. Oba powinny zależeć od abstrakcji.
• Abstrakcje nie powinny zależeć od szczegółów. Szczegóły powinny zależeć od abstrakcji.

Oznacza to, że zamiast tworzyć i używać bezpośrednio konkretnych klas lub modułów, pracujemy przez interfejsy lub klasy abstrakcyjne. To zwiększa elastyczność i ułatwia testowanie oraz utrzymanie kodu.

W projektowaniu systemów oprogramowania, zasada ta jest stosowana w następujący sposób:

• Komponenty zależą od interfejsów, a nie od konkretnych implementacji.
• Implementacje można zmieniać bez zmiany kodu, który ich używa.
• Pozwala na wstrzykiwanie zależności przez konstruktory, settery lub fabryki (Dependency Injection).

Przykład w Node.js:

// Abstrakcja
class Logger {
  log(message) {
    throw new Error('Niezaimplementowane');
  }
}

// Konkretna implementacja
class ConsoleLogger extends Logger {
  log(message) {
    console.log(message);
  }
}

// Klasa zależna od abstrakcji
class UserService {
  constructor(logger) {
    this.logger = logger;
  }

  createUser(name) {
    // logika tworzenia użytkownika
    this.logger.log(`Użytkownik ${name} utworzony`);
  }
}

const logger = new ConsoleLogger();
const userService = new UserService(logger);
userService.createUser('Alice');

Tutaj, UserService zależy od abstrakcji Logger, a nie od konkretnej klasy ConsoleLogger. To pozwala na łatwą wymianę loggera na inny, np. do zapisywania do pliku, bez modyfikacji UserService.