Ankündigung

Einklappen
Keine Ankündigung bisher.

Applikation "verdrahten"

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Applikation "verdrahten"

    Hallo, ich habe eine Frage bzgl. Software-Design. Und zwar: Ich habe viele Komponenten (Routing, Form Validation, ...) wie bei einem professionellen Framework im Einsatz. Meine Frage zielt darauf ab, wie ich nun die Komponenten am Besten miteinander verdrahte und die Applikation als "Solches" zum Laufen bringe. Eignet sich dafür eine Art "God-Klasse" am Besten, die wie eine Fassade fungiert und alle Komponenten miteinander verdrahtet, und dann in einer Datei instanziiert wird und mit einer Methode zum Laufen gebracht wird. Ich glaube Symfony macht das so. Ich möchte einfach sauber voneinander trennen, habe aber beim "Zusammenbauen" der Applikation noch Bauchschmerzen, nachdem ich die Komponenten sauber voneinander getrennt und entsprechend abstrahiert habe. Würde mich über jeden konstruktiven Beitrag sehr freuen.

  • #2
    http://php-di.org

    Das ist im Moment wohl der Goldstandard in dieser Rubrik.

    Kommentar


    • #3
      Da hab ich mir selbst nen DI-Container geschrieben. Die Frage zielte eher darauf ab, wie das Klassentechnisch bewerkstelligt werden soll. Wird dass dann alles in "einer" Klasse gemacht, die wie eine Art Fassade fungiert?

      Kommentar


      • #4
        Zitat von engineer Beitrag anzeigen
        Da hab ich mir selbst nen DI-Container geschrieben. Die Frage zielte eher darauf ab, wie das Klassentechnisch bewerkstelligt werden soll. Wird dass dann alles in "einer" Klasse gemacht, die wie eine Art Fassade fungiert?
        Ich hoffe ich tue dir jetzt nicht Unrecht. Hast du den Unterschied zwischen einem Service-Locator und einem DI-Container verstanden?

        Bei einem DI-Container hast du eigentlich nur zwei strategische Punkte, wo du mit dieser "Fassade" in Berührung kommst: Den Bootstrap und Factories.

        Nehmen wir mal an, dass wir folgende Klassen haben (verzeih die Schreibweise; Das ist Quasi-Scala, was ich jetzt nur wegen der kompakten Schreibweise wähle):

        PHP-Code:
        class TransactionReader(string $endpointHttpClient $client) {
            public function 
        getTransactions(DateTimeInterface $startDateDateTimeInterface $endDate): XMLNode[] {
                
        $data $client->post($endpoint, ['startDate' => $startDate->format('c'), 'endDate' => $startDate->format('c')]);
                
        $xml = new XMLDoc($data);
                foreach(
        $xml \\ "Orders" as $order) yield $order
            
        }
        }

        class 
        TransactionConverter(Hydrator $hydrator) {
            public function 
        convert(XMLNode $order) = $hydrator->hydrate($orderTransaction::class);
        }

        class 
        Transactions(TransactionReader $readerTransactionConverter $converter) {
            public function 
        getTransactions(DateTimeInterface $startDateDateTimeInterface $endDate): Transaction[] {
                
        $transactions $reader->getTransactions($startDate$endDate);
                foreach(
        $transactions as $transaction) yield $converter->convert($transaction);
            }

        Drei Klassen. Wenn du hier PHP-DI verwendest, dann musst du nur für eine dieser drei Klassen in deiner DI-Config was hinterlegen, denn die anderen sind von Interfaces abhängig. PHP-DI kann diese Zuordnung automatisch anhand des Parameter-Typs machen. Das heißt Autowiring.

        Deine di-config sähe in diesem Fall ohne näheres Wissen, wei ein Hydrator oder ein HttpClient erzeugt wird so aus:

        PHP-Code:
        <?php

        return [
            
        'api.endpoint' => 'http://...',
            
            
        HttpClient::class => /* ... */,
            
        Hydrator::class => /* ... */,

            
        TransactionReader::class => object()
                ->
        constructorParameter('endpoint'link('api.endpoint'))
        ];
        Das ist der Teil, der dir wahrscheinlich noch ziemlich klar ist. Wie sieht jetzt also deine Applikation aus? Hier ein Controller:

        PHP-Code:
        class MyController(Config $configTransactions $transactions) {
            public function 
        storeNewTransactions() {
                
        $lastStartDate $config->get('last-order-start-date', new DateTime('-1 month')->format('c'));
                
        /* ... */
            
        }

        Und der Bootstrap:

        PHP-Code:
        $ctrl $container->get(MyController::class);
        $ctrl->storeNewTransactions(); 
        Das ist quasi der einzige Ort (neben einer Factory), wo ich mit dieser "Fassade" in Berührung komme. Warum? Weil die Dependencies alle ja, schon instantiiert und "verdrahtet" sind. Aber eben auch nur die, die ich wirklich brauche. Alle anderen, bleiben kalt. Ich kann so auch einen zweiten Kontainer erstellen, der eine andere Config bekommt und andere Parameter für die Objekte verwendet. So kann ich in einem größeren System Inseln erschaffen, in denen ich die Objekte anders zusammenstelle.

        Kommentar

        Lädt...
        X