Modèle de conception de journalisation dans une application Zend-cadre

Parfois, je dois même vous connecter à 2 tables, la majeure partie du code de journalisation est donc doublée et que les fonctions commencent à être compliquées et longues. P>

Ce sera long. Si votre code fait beaucoup de journalisation, il sera em> em> sera long, car il sera à enregistrer, et chaque action de ligne qu'elle enregistre, signifie qu'il y a une ligne dans votre code. Cependant, cela ne devrait pas être compliqué dans tous les cas car la journalisation est l'une des choses les plus simples que vous puissiez faire. Ce qui m'inquiète, c'est que vous mentionnez «Parfois, je dois même vous connecter à 2 tables». Dans mon livre, une, deux, cinq, soixante ou mille tables est effectuée par une ligne em>. Le code n'est pas doublé pour chaque enregistreur. Si vous copiez une ligne et changeez $ journal code> à $ log2 code>, vous le faites clairement mal (TM). P>

Certaines personnes ont suggéré une programmation orientée forme (AOP), mais malheureusement, un AOP pour PHP n'est pas acceptable pour mon costumateur, je recherche donc une solution orientée objet ou une meilleure pratique. P> BlockQuote>

C'est bien, AOP. Cela a cependant des effectifs; Comme pour l'approche debug_backTrace, il y a une forte performance frappée. Cela, plus le code devient de plus en plus "magique" en ce sens que cela ne constitue pas clair lorsque vous regardez le code lui-même. Cela augmente le temps que vous avez débogué votre application. P>

My $ 0.02? Tout d'abord, ne vous répétez pas: une entrée de journal par action devrait suffire. Utilisez des enregistreurs flexibles pouvant être attachés à certaines classes au moment de l'exécution. Décidez si réellement em> enregistre le message dans l'enregistreur, en fonction de la "gravité" ou du "type". Dans l'ensemble, implémentez simplement le modèle d'observateur: P>

<?php

namespace Foo;

class MailService {
    public function attach( Observes $observer ) {
        $this->observers[] = $observer;
    }

    public function notify( $message, $type = 'notice' ) {
        foreach( $this->observers as $observer ) {
            $observer->notify( $message, $type );
        }
    }

    public function sendMail( ) {
        $this->notify( 'Started sending mails', 'debug' );
        $mails = array( );
        foreach( $mails as $mail ) {
            try {
                $this->notify( 'Trying to send', 'debug' );
                $mail->send( );
                $this->notify( 'Mail sent succesfully', 'debug' );
            }
            catch( Exception $e ) {
                $this->notify( 'Failed to send mail', 'notice' );
            }
        }
        $this->notify( 'Finished sending mail', 'debug' );
    }
}

interface Observes {
    public function notify( $message, $type = 'notice' );
}

abstract class Logger implements Observes {
    protected $types = array(
        'debug' => 0,
        'notice' => 1,
        'warning' => 2,
        'error' => 3
    );

    protected function code( $type ) {
        return isset( $this->types[$type] ) ? $this->types[$type] : 0;
    }
}

class FileLogger extends Logger implements Observes {

    public function __construct( $filename ) {
        $this->filename = $filename;
    }

    /**
     * @todo replace the method body with a call to, say, file_put_contents.
     */
    public function notify( $message, $type = 'notice' ) {
        if( $this->code( $type ) > $this->code( 'notice' ) ) { // only for warning and error.
            echo $message . "\n";
        }
    }


}

class DebugLogger extends Logger implements Observes {
    public function notify( $message, $type = 'notice' ) {
        if( $this->code( $type ) === $this->code( 'debug' ) ) { // only show "debug" notices.
            echo $message . "\n";
        }
    }
}


$service = new MailService( );
$service->attach( new FileLogger( 'yourlog.txt' ) );
$service->attach( new DebugLogger( ) );
$service->sendMail( );