Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 11 sur 11
  1. #1
    Nouveau Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    mars 2011
    Messages
    41
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2011
    Messages : 41
    Points : 38
    Points
    38

    Par défaut Class de stockage de connexion BDD

    Salut à tous !
    Voilà, j'ai développé une class permettant de stocker une multitude de connexion à l'intérieur pour simplifier l'utilisation des accès BDD dans PHP.
    J'aimerai savoir ce que vous en pensez, avis, remarques, critiques constructives, tout est bon à prendre !

    Voici le code
    Code :
    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
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    <?php
     
    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */
     
    /**
     * Description of DBConnect
     *
     * @author Anthony
     */
    class DBConnect {
     
        //put your code here
     
        private static $DBInfo = array(
            array()
        ); //UUID=>[Informations]
        private static $DBConnection = array(); // UUID => PDO
        private static $unvalidateActions = array(
            array(
                array()
            )
        ); //UUID => [UnvalidateActions] => Action/Valeur
     
        /**
         *
         * Connecte une base de donnée MySQL à l'aide des informations de connexion / uuid d'une connexion non linkée
         * @param type $server
         * @param type $dbname
         * @param type $user
         * @param type $password
         * @param type $uuid
         * @return type 
         */
     
        public static function connect($server=null, $dbname=null, $user=null, $password=null, $uuid=null) {
            if ($server == null && $user == null && $password == null && $dbname == null && !empty($uuid)) {
                $informations = self::getInformations($uuid);
                try {
                    if (!empty($informations['DBNAME'])) {
                        $connect = new PDO("mysql:host=" . $informations['SERVER'] . ";dbname=" . $informations['DBNAME'], $informations['USER'], $informations['PASSWORD']); //Crée un objet PDO (Connexion à la base de données)
                    } else {
                        $connect = new PDO("mysql:host=" . $informations['SERVER'], $informations['USER'], $informations['PASSWORD']); //Crée un objet PDO (Connexion à la base de données) 
                    }
                    $connect->exec('SET CHARACTER SET utf8'); //Execute la requête de formatage   
                } catch (Exception $e) {
                    return false;
                }
                self::$DBConnection[$uuid] = $connect;
            }
     
            if (!empty($server) && !empty($user) && !empty($password) && $uuid == null) {
                try {
                    if (!empty($dbname)) {
                        $connect = new PDO("mysql:host=$server;dbname=$dbname", $user, $password); //Crée un objet PDO (Connexion à la base de données)
                    } else {
                        $connect = new PDO("mysql:host=$server;", $user, $password); //Crée un objet PDO (Connexion à la base de données) 
                    }
                    $connect->exec('SET CHARACTER SET utf8'); //Execute la requête de formatage   
                } catch (Exception $e) {
                    return false;
                }
                self::setServer($server, $uuid);
                self::setPassword($password, $uuid);
                self::setUser($user, $uuid);
                if (!empty($dbname))
                    self::setDbname($dbname, $uuid);
                self::$DBConnection[$uuid] = $connect;
            }
     
            return self::getConnection($uuid);
        }
     
        /**
         * tente une connexion avec le serveur demandé
         * @param type $server
         * @param type $user
         * @param type $password
         * @param type $dbname
         * @return type 
         */
        private static function tryConnection($uuid, $server, $user, $password, $dbname = null) {
            try {
                if (!empty($dbname)) {
                    $connect = new PDO("mysql:host=$server;dbname=$dbname", $user, $password); //Crée un objet PDO (Connexion à la base de données)
                } else {
                    $connect = new PDO("mysql:host=$server;", $user, $password); //Crée un objet PDO (Connexion à la base de données) 
                }
                /* Ajout des informations sans passer par la fonction pour des raisons de performance */
                self::$DBInfo[$uuid]["SERVER"] = $server;
                self::$DBInfo[$uuid]["USER"] = $user;
                self::$DBInfo[$uuid]["DBNAME"] = $dbname;
                self::$DBInfo[$uuid]["PASSWORD"] = $password;
                self::$DBConnection[$uuid] = $connect;
     
                unset($connect);
                return true;
            } catch (Exception $e) {
                return false;
            }
        }
     
        /**
         * déconnecte un link
         * @param type $uuid 
         */
        public static function disconnect($uuid) {
            unset(self::$DBConnection[$uuid]);
        }
     
        /*
         * Ajoute une nouvelle connexion vide
         */
     
        private static function addNewEmptyConnection($uuid=null) {
            if (empty($uuid))
                self::$DBInfo[] = array();
            else
                self::$DBInfo[$uuid] = array();
        }
     
        /**
         * Ajoute une nouvelle connexion non linkée avec le serveur
         * @param type $server
         * @param type $user
         * @param type $password
         * @param type $dbname
         * @return type 
         */
        public static function addUnlinkedConnection($server, $user, $password, $dbname=null) {
     
            $uuid = self::generateUUID();
            self::addNewEmptyConnection($uuid);
            if (!self::setDbname($dbname, $uuid)) {
                return false;
            }
            if (!self::setPassword($password, $uuid)) {
                return false;
            }
            if (!self::setServer($server, $uuid)) {
                return false;
            }
            if (!self::setUser($user, $uuid)) {
                return false;
            }
            return $uuid;
        }
     
        /**
         * Génère un UUID
         * @return type 
         */
        private static function generateUUID() {
            return uniqid("DB_");
        }
     
        /**
         * Récupère la connexion à l'aide d'un UUID
         * @param type $uuid
         * @return type 
         */
        public static function getConnection($uuid) {
            return self::$DBConnection[$uuid];
        }
     
        /**
         * Définit une nouvelle connexion, ne peut pas en modifier une existante
         * @param type $uuid
         * @param PDO $connect
         * @return type 
         */
        private static function setConnection(PDO $connect, $uuid) {
            if (self::verifyData($uuid)) {
                if (!empty($connect) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                    self::$DBConnection[$uuid] = $connect;
                    return true;
                } else
                    return false;
            }else
                return false;
        }
     
        /**
         * retourne l'UUID d'une connexion
         * @param PDO $connexion
         * @return type 
         */
        public static function getUUID(PDO $connexion) {
            foreach (self::$DBConnection as $UUID => $LINK) {
                if ($LINK === $connexion)
                    return $UUID;
            }
            return false;
        }
     
        /**
         * définit le serveur d'une connexion
         * @param type $server
         * @param type $uuid
         * @return type 
         */
        public static function setServer($server, $uuid) {
            if (self::verifyData($uuid)) {
                if (!empty($server) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                    if (array_key_exists("DBNAME", self::$DBInfo[$uuid])) {// test la validité de la modification
                        self::addUnvalidateAction($uuid, "setServer", self::getServer($uuid));
                        return self::tryConnection($uuid,$server, self::getUser($uuid), self::getPassword($uuid), self::getDbname($uuid));
                    } else { // test la validité de la modification
                        self::addUnvalidateAction($uuid, "setServer", self::getServer($uuid));
                        return self::tryConnection($uuid,$server, self::getUser($uuid), self::getPassword($uuid));
                    }
                }else
                    return false;
            }else
                self::$DBInfo[$uuid]["SERVER"] = $server;
            return true;
        }
     
        /**
         * définit l'utilisateur d'une connexion
         * @param type $user
         * @param type $uuid
         * @return type 
         */
        public static function setUser($user, $uuid) {
            if (self::verifyData($uuid)) {
                if (!empty($user) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                    if (array_key_exists("DBNAME", self::$DBInfo[$uuid])) {// test la validité de la modification
                        self::addUnvalidateAction($uuid, "setUser", self::getUser($uuid));
                        return self::tryConnection($uuid,self::getServer($uuid), $user, self::getPassword($uuid), self::getDbname($uuid));
                    } else { // test la validité de la modification
                        self::addUnvalidateAction($uuid, "setUser", self::getUser($uuid));
                        return self::tryConnection($uuid,self::getServer($uuid), $user, self::getPassword($uuid));
                    }
                }else
                    return false;
            }else
                self::$DBInfo[$uuid]["USER"] = $user;
            return true;
        }
     
        /*
         * Définit le mot de passe d'une connexion
         */
     
        public static function setPassword($password, $uuid) {
            if (self::verifyData($uuid)) {
                if (!empty($password) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                    if (array_key_exists("DBNAME", self::$DBInfo[$uuid])) {// test la validité de la modification
                        self::addUnvalidateAction($uuid, "setPassword", self::getPassword($uuid));
                        return self::tryConnection($uuid,self::getServer($uuid), self::getUser($uuid), $password, self::getDbname($uuid));
                    } else { // test la validité de la modification
                        self::addUnvalidateAction($uuid, "setPassword", self::getPassword($uuid));
                        return self::tryConnection($uuid,self::getServer($uuid), self::getUser($uuid), $password);
                    }
                }else
                    return false;
            }else
                self::$DBInfo[$uuid]["PASSWORD"] = $password;
            return true;
        }
     
        /**
         * Définit la base de donnée sélectionnée pour la connexion
         * @param type $dbname
         * @param type $uuid
         * @return type 
         */
        public static function setDbname($dbname, $uuid) {
            if (self::verifyData($uuid)) {
                if (!empty($dbname) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                    self::addUnvalidateAction($uuid, "setDbname", self::getDbname($uuid));
                    return self::tryConnection($uuid,self::getServer($uuid), self::getUser($uuid), self::getPassword($uuid), $dbname);
                }else
                    return false;
            }else {
                self::$DBInfo[$uuid]["DBNAME"] = $dbname;
            }
            return true;
        }
     
        private static function addUnvalidateAction($uuid, $actionName, $lastValue) {
            $tmp = self::generateUUID();
            self::$unvalidateActions[$uuid][$tmp]["ACTION"] = $actionName;
            self::$unvalidateActions[$uuid][$tmp]["LASTVALUE"] = $lastValue;
        }
     
        /**
         * Récupère le serveur de la connexion
         * @param type $uuid
         * @return type 
         * 
         */
        public static function getServer($uuid) {
            return self::$DBInfo[$uuid]["SERVER"];
        }
     
        /**
         * Récupère l'utilisateur d'une connexion
         * @param type $uuid
         * @return type 
         */
        public static function getUser($uuid) {
            return self::$DBInfo[$uuid]["USER"];
        }
     
        /**
         * Récupère le mot de passe d'une connexion
         * @param type $uuid
         * @return type 
         */
        public static function getPassword($uuid) {
            return self::$DBInfo[$uuid]["PASSWORD"];
        }
     
        /**
         * Récupère la base de donnée sélectionnée d'une connexion
         * @param type $uuid
         * @return type 
         */
        public static function getDbname($uuid) {
            return self::$DBInfo[$uuid]["DBNAME"];
        }
     
        /**
         * Récupère toutes les informations d'une connexion
         * @param type $uuid
         * @return type 
         */
        public static function getInformations($uuid) {
            return self::$DBInfo[$uuid];
        }
     
        /**
         * Annule les dernières actions non validées.
         */
        public static function rollback($uuid) {
     
            foreach (self::$unvalidateActions as $_uuid => $listActions) {
                if ($_uuid === $uuid) {
                    foreach ($listActions as $action) {
                        self::$action['ACTION']($action['LASTVALUE'],$uuid);
                    }
                }
            }
            self::valid($uuid); 
        }
     
        public static function valid($uuid) {
            unset(self::$unvalidateActions[$uuid]);
        }
     
        private static function verifyData($uuid) {
            foreach (self::$DBInfo as $Cuuid => $info) {
                if ($Cuuid === $uuid) {
                    if (empty($info))
                        return false;
                    if(array_key_exists("DBNAME", $info) && 
                       array_key_exists("SERVER", $info) && 
                       array_key_exists("USER", $info) && 
                       array_key_exists("PASSWORD", $info)){
                        foreach($info as $data){
                            if($data == null) return false;
                        }
                    }else return false;
                }
            }
            return true;
        }
     
    }
     
    ?>
    Merci à vous.

    Cordiallement, Anthony <xetqL> BOULMIER

  2. #2
    Expert Confirmé
    Avatar de christele_r
    Femme Profil pro Christele Rubneau
    Responsable de service informatique
    Inscrit en
    novembre 2009
    Messages
    1 361
    Détails du profil
    Informations personnelles :
    Nom : Femme Christele Rubneau
    Âge : 66
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Responsable de service informatique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : novembre 2009
    Messages : 1 361
    Points : 2 577
    Points
    2 577
    Billets dans le blog
    1

    Par défaut

    Bonjour,
    Si tu veux un avis , il va me falloir étre franche

    C' est une usine a gaz pour risquer de créer des failles de sécuritées la ou la recherche va dans le sens d'une minimilisation du code.

    En premier tu t'attaques a une des premiére classe, la connection.

    Tu es bien OK que tout serveur qui se respecte interdit toute connection externe, et même toute connection sur un même serveur, entre noms de domaines.

    Tu vois déjas dans ce cas ta classe parait inutile. J'ajouterais que de plus en plus nous allons vers PDO donc tu vas te retrouver avec des classes de classes.

    A ce sujet sur la connection PDO pas de mise en route de la gestion d'erreurs ! pas de vrais TRY etc ...

    Je m'arrétes là, mais je reconnais que tu as du travailler sérieusement pour monter cela.

  3. #3
    Expert Confirmé Sénior
    Avatar de Benjamin Delespierre
    Profil pro Benjamin Delespierre
    Développeur Web
    Inscrit en
    février 2010
    Messages
    3 931
    Détails du profil
    Informations personnelles :
    Nom : Benjamin Delespierre
    Âge : 27
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : février 2010
    Messages : 3 931
    Points : 8 401
    Points
    8 401

    Par défaut

    Bonjour

    Cette classe m'a l'air pas mal du tout mais son principal défaut selon moi est qu'elle ne contraste pas vraiment avec un simple tableau d'instances PDO...

    Un défaut somme toute mineur est que la méthode "disconnect" ne provoque pas réellement de déconnexion.

    Tu devrais également la rendre plus générique en permettant d'ouvrir des connections vers d'autres SGBD.

    Une amélioration possible serait de permettre de passer des requêtes SQL directement dans cette classe qui se chargerait in-fine de trouver à quelle connexion cette requête correspond. Cela peut se faire par exemple en détectant un nom de table ou de base de données dans la chaine SQL.

    Par curiosité, pourquoi avoir créé cette classe ?

  4. #4
    Nouveau Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    mars 2011
    Messages
    41
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2011
    Messages : 41
    Points : 38
    Points
    38

    Par défaut

    @Cristele_r :
    Merci de votre commentaire !
    Tu es bien OK que tout serveur qui se respecte interdit toute connection externe, et même toute connection sur un même serveur, entre noms de domaines.
    De quel connexion externe parles-tu ? J'effectue simplement une connexion à l'aide de la classe PDO, rien de plus rien de moins.
    J'ajouterais que de plus en plus nous allons vers PDO donc tu vas te retrouver avec des classes de classes.
    Mon code utilise déjà PDO, le principe de ma classe est de simplifier la gestion et l'organisation des différents BDD/SGBD à utiliser (pour l'instant que MySQL, mais en cours de dev.)
    A ce sujet sur la connection PDO pas de mise en route de la gestion d'erreurs ! pas de vrais TRY etc ...
    Dans mon code, aucunes actions critiques ne sont effectuées. Libre à l'utilisateur de ma classe de faire des try/catch sur les actions qu'il entreprendra sur ses BDD. En l'occurence, cette classe est une classe de STOCKAGE et non de traitement, récupération et affichage (MVC)
    Cependant, il est vrai que je ne me suis pas amuser à créer mes propres exceptions pour faire plus propre mais je ne vois pas ou cela peut apporter de l'insécurité, une petit explication ? .

    @Benjamin : Merci de ton commentaire !
    Tu devrais également la rendre plus générique en permettant d'ouvrir des connections vers d'autres SGBD.
    C'est en cours de développement, mais merci de l'avoir souligné
    Par curiosité, pourquoi avoir créé cette classe ?
    J'ai eu plusieurs écho d'amis développeurs apprentis qui étaient emmerdés, par les multiples base de données à gérer pour générer un backup automatique sur une base de données distante.
    J'ai décidé de créer cette classe pour moi-même être plus tranquille avec les actions à faire sur les différentes sgbd disponible, manque plus qu'à faire les quelques modifications restantes pour que ma class soit plus ou moins comme je l'espérais.
    Cordiallement.

  5. #5
    Expert Confirmé Sénior
    Avatar de Benjamin Delespierre
    Profil pro Benjamin Delespierre
    Développeur Web
    Inscrit en
    février 2010
    Messages
    3 931
    Détails du profil
    Informations personnelles :
    Nom : Benjamin Delespierre
    Âge : 27
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : février 2010
    Messages : 3 931
    Points : 8 401
    Points
    8 401

    Par défaut

    A ce sujet sur la connection PDO pas de mise en route de la gestion d'erreurs ! pas de vrais TRY etc ...
    Dans mon code, aucunes actions critiques ne sont effectuées. Libre à l'utilisateur de ma classe de faire des try/catch sur les actions qu'il entreprendra sur ses BDD. En l'occurence, cette classe est une classe de STOCKAGE et non de traitement, récupération et affichage (MVC)
    Cependant, il est vrai que je ne me suis pas amuser à créer mes propres exceptions pour faire plus propre mais je ne vois pas ou cela peut apporter de l'insécurité, une petit explication ? .
    Il n'est pas obligatoire de mettre un try/catch ici, on peut très bien vouloir laisser remonter l'exception. Mais je pense que ce serait pas mal de mettre un paramètre optionnel supplémentaire $silent = true qui, si vrai attrape l'exception et renvoie false et si faux, laisse remonter l'exception. Quand à créer des classes personnalisées d'exception, franchement je ne vois pas ce que ça apporte...

    Tu es bien OK que tout serveur qui se respecte interdit toute connection externe, et même toute connection sur un même serveur, entre noms de domaines.
    De quel connexion externe parles-tu ? J'effectue simplement une connexion à l'aide de la classe PDO, rien de plus rien de moins.
    C'est vrai que les cas ou on est amené à utiliser plusieurs bdd distantes sont plutôt rares - surtout dans le web - mais dans le milieu industriel, ça peut se comprendre.

  6. #6
    Nouveau Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    mars 2011
    Messages
    41
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2011
    Messages : 41
    Points : 38
    Points
    38

    Par défaut

    Il est vrai que je fais pas de , c'est plus clair au niveau du message d'erreur pour l'utilisateur de la classe mais rien de plus n'est-ce pas ?
    Personnellement, j'en ai eu l'utilité il n'y a pas une semaine entre un site Magento et une bdd interne à l'entreprise pour faire des sondages / calculs etc.

  7. #7
    Expert Confirmé Sénior
    Avatar de Benjamin Delespierre
    Profil pro Benjamin Delespierre
    Développeur Web
    Inscrit en
    février 2010
    Messages
    3 931
    Détails du profil
    Informations personnelles :
    Nom : Benjamin Delespierre
    Âge : 27
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : février 2010
    Messages : 3 931
    Points : 8 401
    Points
    8 401

    Par défaut

    Non c'est complêtement différent. Renvoyer un status true/false permet de déterminer une action à effectuer si la connection n'a pas été ouverte, c'est je pense le mieux à faire. Dans ce cas c'est à toi de mettre le try / catch.

    Lever une exception, c'est normalement comme son nom l'indique exceptionnel, par exemple dans le cadre des constructeurs qui ne peuvent rien renvoyer: comment savoir alors que quelque chose s'est mal déroulé ? Lever une exception (ou la laisser remonter ce qui revient au même) provoque l'arrêt immédiat de la méthode / fonction en cours et remonte la pile des appels jusqu'au script racine. S'il n'est à aucun moment catché cela provoque une FATAL_ERROR et interrompt brutalement le script.

    Une exception doit toujours être levée en dernier recours, s'il n'y a plus rien d'autre à faire, dans ton cas renvoyer false suffit amplement.

    Note: quand une méthode / fonction lève une exception et qu'on veut la faire remonter, on a alors 2 possibilités: soit on re-throw l'exception:
    Code :
    1
    2
    3
    4
    5
    6
     
    try {
     throw new RuntimeException("une exception bidon");
    } catch (RuntimeException $e) {
     throw $e;
    }
    soit on enveloppe cette exception dans une autre:
    Code :
    1
    2
    3
    4
    5
    6
     
    try {
     throw new LogicException("erreur de logique");
    } catch (LogicException $e) {
     throw new RuntimeException("un autre message", 0, $e);
    }
    Note: on peut définir plusieurs blocs catch pour les différentes classes d'exception disponibles, sachant qu'un catch (Exception $e) les attrapera obligatoirement vu que les exception dérivent toutes de Exception.

    En espérant avoir été clair.

  8. #8
    Nouveau Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    mars 2011
    Messages
    41
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2011
    Messages : 41
    Points : 38
    Points
    38

    Par défaut

    Je connaissais déjà le principe des exceptions, vu que j'en fais moult utilisation en Java, mais j'avais simplement mal compris ton affirmation ^^

  9. #9
    Expert Confirmé
    Avatar de christele_r
    Femme Profil pro Christele Rubneau
    Responsable de service informatique
    Inscrit en
    novembre 2009
    Messages
    1 361
    Détails du profil
    Informations personnelles :
    Nom : Femme Christele Rubneau
    Âge : 66
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Responsable de service informatique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : novembre 2009
    Messages : 1 361
    Points : 2 577
    Points
    2 577
    Billets dans le blog
    1

    Par défaut

    Bref comme je te l'ais dis, tu refait un PDO de PDO et pas de
    Code :
    1
    2
     
    $bdd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    En disant si tu veux tu te le mets

  10. #10
    Nouveau Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    mars 2011
    Messages
    41
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2011
    Messages : 41
    Points : 38
    Points
    38

    Par défaut

    Ma classe n'est pas un PDO de PDO.
    Cette classe permet de STOCKER (à nouveau) plusieurs BDD à la fois !
    Non pas une seule connexion où l'on peut changer les attributs etc. mais plusieurs.
    Ma classe s'utilise comme un tableau de PDO sauf que j'en simplifie l'utilisation.
    Après, je vois pas comment être plus claire

  11. #11
    Modérateur

    Inscrit en
    septembre 2010
    Messages
    7 957
    Détails du profil
    Informations forums :
    Inscription : septembre 2010
    Messages : 7 957
    Points : 10 638
    Points
    10 638

    Par défaut

    utilise un pattern type registry ça sera plus simple, pourquoi ne par garder le systeme de DNS, j'ai pas MySQL je fais comment ?

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •