Discussion :

[Mika2008]

Bonjour,

voila j'ai écrit mon programme en PHP en utilisant des classe.

Pour le moment je fait des simples sorti écran pour voir ce qui se passe quand mon programme tourne.

maintenant j'aimerais loguer ces informations dans un fichier de log.

Pour ne pas reinventer la roue je vais utiliser la librairie monolog.

ça fonctionne trés bien lorsque je fait mes logs fichier :

Utilsation standard :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
<?php
 
require 'vendor/autoload.php';
use Monolog\Handler\StreamHandler;
use Monolog\Logger;
 
 
$logger = new Logger('channel-name');
$logger->pushHandler(new StreamHandler(__DIR__ . '/app.log', Logger::DEBUG));
$logger->info('This is a log! ^_^ ');
$logger->warning('This is a log warning! ^_^ ');
$logger->error('This is a log error! ^_^ ');

me premiere question c'est comment afficher à la fois les logs dans mon fichier txt de log mais aussi à l'écran quand je lance le programme ?

ma deuxiéme question, c'est comment j'intégrer ce fichier de log, sans le redéclarer à chaque fois des mes classe :

exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?php
 
require 'vendor/autoload.php';
use Monolog\Handler\StreamHandler;
use Monolog\Logger;
 
 
class voiture {
 
    public $name = "";
    public $logger ="";
 
 
    public function __construct($logger) {
        $this->logger = $logger;    
 
    }
 
    function getName () {
        return $this->name;
    }
    function setName($name){
        $this->logger->info('This is a log! ^_^ '.$name);        
        $this->name = $name;
    }
}
 
 
$logger = new Logger('channel-name');
$logger->pushHandler(new StreamHandler(__DIR__ . '/app.log', Logger::DEBUG));
$logger->info('This is a log! ^_^ ');
$logger->warning('This is a log warning! ^_^ ');
$logger->error('This is a log error! ^_^ ');
 
$voitureA = new voiture();
$voitureA->setName('Teska');

dans ce code j'ajoute dans ma classe mon objet logger.

Mais du coup je vais devoir modifier toute mes classes en ajouter cette information.

du coup n'y a t'il pas un moyen pour gérer ma classe logger de façon global et de ne pas le passer en paramétre de mon construct ?


merci

[cavo789]

Bonjour

Tu devrais créer une classe spécialisée pour les logs et rien que les logs. Je vois que tu as créé une classe voiture, fait donc de même avec Logs.

Voiture fera alors appel à la classe Logs pour que cette dernière se charge de l'écriture.

Tu demandes un output écran et une sortie log ? Dans ta nouvelle classe Logs, tu aurais alors une méthode imaginons "writeLog" qui aurait et un écho et un appel à monolog.

Note : dans ton dernier source, tu nous montres le code de la classe Voiture et au bas du source, tu as cette ligne : $voitureA = new voiture();. Ce n'est pas très correct car ton constructeur s'attends à recevoir un paramètre que tu n'as pas donné.

[Mika2008]

Bonjour,

j'ai retravaillé mon code avec une classe global de log, et ça fonctionne

par contre quand j'ai une classe qui hérite de 2 objects je fait comment ?

il faut faire une cascade d'héritage, ou il est possible d'hérité de deux classe en meme temps ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
<?php
 
require 'vendor/autoload.php';
use Monolog\Handler\StreamHandler;
use Monolog\Logger;
 
 
class loggerPerso {
 
    private $logger;
    public function __construct($path = __DIR__,$nameFiles = '/app.log',$channelName = 'default'){ 
        $this->logger = new Logger($channelName);
        $this->logger->pushHandler(new StreamHandler($path.$nameFiles, Logger::WARNING));
    }
    public function logs($message = "NNOTHING",$info = "INFO") {
 
        echo $info."  -- ".$message."\n";
 
        if($info == "ERROR"){
            $this->logger->error($message);
        } else if ($info == "WARNING"){
            $this->logger->warning($message);
        } else {
            $this->logger->info($message);
        }
 
    }
 
    public function testLog(){
        $this->logs("test log ERROR","ERROR");
        $this->logs("test log ERROR","WARNING");
        $this->logs("test log ERROR");
    }
}
 
 
class voiture extends loggerPerso {
 
    public $name = "";
    public $logger ="";
 
    public function __construct() {
 
        parent::__construct();
            $this->logs("Création d'une voiture");
    }
 
    function getName () {
        $this->logs("Affichage du nom");
        return $this->name;
    }
    function setName($name){
        $this->logs("Le nom est setter sur ".$name);
        $this->name = $name;
    }
}
 
$testLog = new loggerPerso();
$testLog->testLog();
$testLog->logs("message de log");
 
$voitureA = new voiture();
$voitureA->setName('Tesla');

merci

[cavo789]

Si je puis me permettre : prends le temps d'étudier les bases de la POO.

Une classe n'a jamais qu'un seul ancêtre et pas deux. Ensuite, ta classe voiture décrit une voiture (càd quelque chose qui roule, qui a un moteur, quatre roues, ...). Son ancêtre est peut-être un charriot mais certainement pas une classe logger. Il n'y a aucun lien logique entre tes deux classes.

Logger ne devrait pas être le parent mais, juste, une classe d'utilitaire que tu passerais p.ex. à ton constructeur voiture. Ainsi, dans le code principal, tu crées 1. une instance de la classe logger puis 2. tu crées ta classe voiture et tu lui passes ton instance logger comme dépendance (on nomme cette technique Dependency Injection). Ainsi, voiture vit sa petite vie; totalement distincte du logger que tu remplaceras comme tu le veux plus tard sans aucun impact à ta classe voiture.

[laurentSc]

Bonjour,
je lis cette discussion qui a attirée ma curiosité. Je découvre cette classe monolog. D'après ce que j'ai vu, il y a 3 méthodes : info(), warning() et error(). Je suppose que pour utiliser ça, on va utiliser une structure try/catch et que les 2 dernières méthodes ne seront appelées que dans le catch. Ca marche comme ça ?

[cavo789]

Je découvre cette classe monolog.

Pourtant je t'en ai parlé très récemment ;-)

[laurentSc]

Je m'en souvenais (malgré ma mémoire catastrophique), mais bien qu'en ayant pris note à ce moment-là, j'avais pas approfondi ; ce que je viens de faire. Peux-tu répondre à ma question ?

[cavo789]

Peux-tu répondre à ma question ?

https://seldaek.github.io/monolog/

Oui et non... $log->error("Bla bla bla") est OK. Mais oui, bien sûr, si tu veux capturer une exception, c'est en effet dans le catch avec un $log->error($exception->getMessage());C'est toi le patron, tu mets ce que tu veux comme texte.

[Mika2008]

Bonjour,

bon du coup j'essai de comprendre le framwork suivant : https://php-di.org/

mais c'est pas très claire,

avez vous des exemples d'utilisations svp ?

merci beaucoup pour vos pistes de rechercher

[cavo789]

Ouch.. Pas utile d'installer quoi que ce soit.

Reprends ton précédent code. Tu as dans ton source l'initialisation et de ton logger et de ta classe voiture où ensuite tu dis que c'est une tesla.

Quand tu créés ta variable voiture (avec le new()), donne-lui comme paramètre ta variable logger.

$voitureA = new voiture($testLog);Du coup, tu donnes à voiture ton logger et donc, bingo, tu peux l'utiliser.

Rien à installer d'autre que ce que tu as.

Je parlais de Depedency Injection car c'est la nomenclature pour cette approche ;-)

[Mika2008]

j'ai vu les videos sur le DI et ça l'air super interressant cette technique

car ça permet de faire des classes qui ne sont pas mélangé alors que la ma technique vas me faire mélanger les classes

mais ce n'est pas encore clair pour moi.

[cavo789]

Oui c'est bien plus propre, ton code pourra évoluer plus facilement et sa maintenance sera moins compliquée. Dans ton cas, l'effort à consentir est faible car tu as déjà fait le boulot de créer une classe séparée pour les logs.

[Mika2008]

Bonjour, je pense avoir trouver comment ça marche, mais ça rajoute une belle compléxité :

Déja il faut changer son fichier composer pour avoir un dossier pour les controlleurs :

composer.json

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "require": {
        "php-di/php-di": "^6.3"
    }
}

une fois fait on lance la mise à jour du composer :

composer install
et
composer dump-autoload

ensuite on créer les controlleurs :

LogPersoController.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
namespace App;
 
class LogPersoController 
{
 
 
    public function __construct()
    {
 
    }
 
 
    public function logs($string){
        echo "LOG - ".$string.".\n";
    }
 
 
}

VoitureController.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?php
namespace App;
 
class VoitureController 
{
  /**
   * @var string
   * @brief texte à afficher
   */
  private $name = "";
 
  public $id;
 
  /**
   * @var string
   * @brief information de log
   */
  private $log;
 
 
    public function __construct(LogPersoController $log)
    {
        $this->log = $log;
        $this->id = uniqid();
 
    }
 
 
    /**
     * Get the value of Name 
     * 
     * @return string
     */
    public function getName()
    {
        $this->log->logs("Affichage de la VVVV");
        return $this->name;
    }
 
 
    /** 
     * Set the value of Name 
     * 
     * @param string $name
     * 
     * @return self
     */
    public function setName($name)
    {
        $this->log->logs("Enregisterment du nouveau nom");
        $this->name = $name;
 
        return $this;
    }
 
 
 
}

ensuite dans mon index je lance :

index.php :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<?php
 
require 'vendor/autoload.php';
 
 
use DI\ContainerBuilder;
 
 
$containerBuilder = new ContainerBuilder();
$containerBuilder->useAutowiring(true);
 
 
$container = $containerBuilder->build();
//$container->get(App\LogPersoController::class)->logs("Hello World");
 
//var_dump($container->get(App\LogPersoController::class)->logs("test"));
 
//Création d'un objet
$voiture = ($container->get(App\VoitureController::class));
$voiture->setName(("Tesla"));
$voiture->getName();
 
//Attention création d'un nouvelle object et pas une copie de l'objet précédent 
$voiture = ($container->make(App\VoitureController::class));
$voiture->setName(("Tesla"));
$voiture->getName();
 
 
$voiture = new App\VoitureController($container->get(App\LogPersoController::class));
$voiture->setName("Tesla");

voila pour utiliser le DI sur des classes PHP

[cavo789]

Bonjour

Je modifie à l'arrache (=non testé; juste pour illustrer mon propos) ton code. Je t'ai souvent répondu depuis mon smartphone (compliqué d'écrire du code):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?php
class loggerPerso
{
     [...]
}
 
class voiture {
    private $logger;    // Tip: pourquoi public ?
 
    public function __construct(\loggerPerso  $logger)
    {
        parent::__construct();
 
        // Tu récupères ton objet logger (=> dependency injection)
        $this->logger = $logger;
 
        // et hop, tu peux déjà l'utiliser puisque (faisons court); tu l'as déjà initialisé
        $this->logger->logs("Création d'une voiture");
    }
    [...]
}
 
$testLog = new loggerPerso();
$testLog->testLog();
$testLog->logs("message de log");
 
// $testLog est donc supposé correctement initialisé à ce niveau
$voitureA = new voiture($testLog);

Il me semble que cela devrait fonctionner; sans avoir rien ajouté.

Maintenant, c'est hyper cool d'utiliser composer.json; c'est vraiment une énorme avancée en termes de professionnalisation de ton code. Si tu as appris Composer ces derniers jours; bravo; belle corde à ton arc.