PSR-11 ist eine PHP-Standard-Empfehlung (PHP Standard Recommendation), die sich mit der Container-Interface-Definition beschäftigt. Sie beschreibt ein einheitliches Interface für Dependency Injection Container, das in PHP-Projekten verwendet werden kann. Dependency Injection Container sind Werkzeuge, die Klassen und ihre Abhängigkeiten verwalten und auflösen.
PSR-11 wurde eingeführt, um sicherzustellen, dass verschiedene Frameworks, Bibliotheken und Tools interoperabel mit Dependency Injection Containern arbeiten können. Durch die Einhaltung dieses Standards wird es möglich, verschiedene Container in einem Projekt zu verwenden, ohne den Code ändern zu müssen.
PSR-11 definiert zwei Interfaces:
ContainerInterface
namespace Psr\Container;
interface ContainerInterface {
public function get(string $id);
public function has(string $id): bool;
}get(string $id): Gibt die Instanz (oder den Service) zurück, die im Container unter einer bestimmten ID registriert ist.has(string $id): Prüft, ob der Container eine Instanz mit der angegebenen ID enthält.2. NotFoundExceptionInterface
namespace Psr\Container;
interface NotFoundExceptionInterface extends ContainerExceptionInterface {
}3. ContainerExceptionInterface
PSR-11 wird häufig in Frameworks wie Symfony, Laravel, oder Zend Framework (jetzt Laminas) verwendet, die Dependency Injection Container bereitstellen. Auch Tools wie PHP-DI oder Pimple unterstützen PSR-11.
Ein einfaches Beispiel für den Einsatz von PSR-11:
use Psr\Container\ContainerInterface;
class MyService {
public function __construct(private string $message) {}
public function greet(): string {
return $this->message;
}
}
$container = new SomePSR11CompliantContainer();
$container->set('greeting_service', function() {
return new MyService('Hello, PSR-11!');
});
if ($container->has('greeting_service')) {
$service = $container->get('greeting_service');
echo $service->greet(); // Ausgabe: Hello, PSR-11!
}PSR-11 ist eine wichtige Schnittstelle für modernes PHP-Entwickeln, da sie Abhängigkeiten und deren Auflösung standardisiert. Dies führt zu flexibleren und besser wartbaren Anwendungen.
Deptrac ist ein statisches Analysewerkzeug für PHP-Anwendungen, das dabei hilft, architektonische Regeln in einem Codebase durchzusetzen. Es analysiert die Abhängigkeiten eines Projekts und überprüft, ob diese den festgelegten architektonischen Vorgaben entsprechen. Das Hauptziel von Deptrac ist es, zu verhindern, dass verschiedene Komponenten zu eng miteinander gekoppelt werden, und somit eine klare, wartbare Struktur zu gewährleisten, besonders in größeren oder wachsenden Projekten.
Deptrac ist besonders nützlich, um Entkopplung und Modularität sicherzustellen, was in skalierenden und umgestaltenden Projekten entscheidend ist. Durch das frühzeitige Erkennen architektonischer Verstöße trägt es dazu bei, technische Schulden zu vermeiden.
Dependency Injection (DI) ist ein Entwurfsmuster in der Softwareentwicklung, das darauf abzielt, die Abhängigkeiten zwischen verschiedenen Komponenten eines Systems zu verwalten und zu entkoppeln. Es handelt sich um eine Form der Inversion of Control (IoC), bei der die Steuerung über die Instanziierung und Lebensdauer von Objekten von der Anwendung selbst an einen externen Container oder ein Framework übergeben wird.
Das Hauptziel von Dependency Injection ist es, lose Kopplung und hohe Testbarkeit in Softwareprojekten zu fördern. Indem die Abhängigkeiten einer Komponente explizit von außen bereitgestellt werden, kann der Code einfacher getestet, gewartet und erweitert werden.
Es gibt drei Hauptarten von Dependency Injection:
1. Constructor Injection: Abhängigkeiten werden über den Konstruktor einer Klasse bereitgestellt.
public class Car {
private Engine engine;
// Dependency wird durch den Konstruktor injiziert
public Car(Engine engine) {
this.engine = engine;
}
}2. Setter Injection: Abhängigkeiten werden über Setter-Methoden bereitgestellt.
public class Car {
private Engine engine;
// Dependency wird durch eine Setter-Methode injiziert
public void setEngine(Engine engine) {
this.engine = engine;
}
}3. Interface Injection: Abhängigkeiten werden durch ein Interface bereitgestellt, das die Klasse implementiert.
public interface EngineInjector {
void injectEngine(Car car);
}
public class Car implements EngineInjector {
private Engine engine;
@Override
public void injectEngine(Car car) {
car.setEngine(new Engine());
}
}Um das Konzept besser zu veranschaulichen, schauen wir uns ein konkretes Beispiel in Java an.
public class Car {
private Engine engine;
public Car() {
this.engine = new PetrolEngine(); // Feste Kopplung an PetrolEngine
}
public void start() {
engine.start();
}
}In diesem Fall ist die Car-Klasse fest an eine bestimmte Implementierung (PetrolEngine) gebunden. Wenn wir den Motor ändern möchten, müssen wir den Code der Car-Klasse anpassen.
public class Car {
private Engine engine;
// Constructor Injection
public Car(Engine engine) {
this.engine = engine;
}
public void start() {
engine.start();
}
}
public interface Engine {
void start();
}
public class PetrolEngine implements Engine {
@Override
public void start() {
System.out.println("Petrol Engine Started");
}
}
public class ElectricEngine implements Engine {
@Override
public void start() {
System.out.println("Electric Engine Started");
}
}Jetzt können wir die Abhängigkeit von Engine zur Laufzeit bereitstellen, was bedeutet, dass wir problemlos zwischen verschiedenen Motorimplementierungen wechseln können:
public class Main {
public static void main(String[] args) {
Engine petrolEngine = new PetrolEngine();
Car carWithPetrolEngine = new Car(petrolEngine);
carWithPetrolEngine.start(); // Output: Petrol Engine Started
Engine electricEngine = new ElectricEngine();
Car carWithElectricEngine = new Car(electricEngine);
carWithElectricEngine.start(); // Output: Electric Engine Started
}
}Es gibt viele Frameworks und Bibliotheken, die Dependency Injection unterstützen und vereinfachen, wie:
Dependency Injection ist nicht auf eine bestimmte Programmiersprache beschränkt und kann in vielen Sprachen implementiert werden. Hier sind einige Beispiele:
public interface IEngine {
void Start();
}
public class PetrolEngine : IEngine {
public void Start() {
Console.WriteLine("Petrol Engine Started");
}
}
public class ElectricEngine : IEngine {
public void Start() {
Console.WriteLine("Electric Engine Started");
}
}
public class Car {
private IEngine _engine;
// Constructor Injection
public Car(IEngine engine) {
_engine = engine;
}
public void Start() {
_engine.Start();
}
}
// Verwendung
IEngine petrolEngine = new PetrolEngine();
Car carWithPetrolEngine = new Car(petrolEngine);
carWithPetrolEngine.Start(); // Output: Petrol Engine Started
IEngine electricEngine = new ElectricEngine();
Car carWithElectricEngine = new Car(electricEngine);
carWithElectricEngine.Start(); // Output: Electric Engine StartedIn Python ist Dependency Injection ebenfalls möglich, obwohl es aufgrund der dynamischen Natur der Sprache oft einfacher ist:
class Engine:
def start(self):
raise NotImplementedError("Start method must be implemented.")
class PetrolEngine(Engine):
def start(self):
print("Petrol Engine Started")
class ElectricEngine(Engine):
def start(self):
print("Electric Engine Started")
class Car:
def __init__(self, engine: Engine):
self._engine = engine
def start(self):
self._engine.start()
# Verwendung
petrol_engine = PetrolEngine()
car_with_petrol_engine = Car(petrol_engine)
car_with_petrol_engine.start() # Output: Petrol Engine Started
electric_engine = ElectricEngine()
car_with_electric_engine = Car(electric_engine)
car_with_electric_engine.start() # Output: Electric Engine StartedDependency Injection ist ein mächtiges Entwurfsmuster, das Entwickler dabei unterstützt, flexible, testbare und wartbare Software zu erstellen. Durch die Entkopplung von Komponenten und die Verlagerung der Steuerung über Abhängigkeiten auf ein DI-Framework oder einen DI-Container, wird der Code leichter erweiterbar und verständlich. Es ist ein zentrales Konzept in der modernen Softwareentwicklung und ein wichtiges Werkzeug für jeden Entwickler.
TortoiseGit
