Modèle de classe MySQLi pour la connexion, fermer, laisser ouvert ?

Je considérerais que ce n'est pas une bonne pratique. C'est surtout pour une raison :le problème que vous décrivez et pourquoi vous pensez en avoir besoin :une seule connexion par requête.

Vous n'avez pas besoin de coder quoi que ce soit. mysqli a une fonctionnalité intéressante intégrée, la connexion par défaut. Il sélectionne les paramètres de connexion à la base de données dans les paramètres ini (configuration) chaque fois que vous créez une nouvelle instance :

$db = new mysqli;

Comme toutes les connexions à la base de données sont fermées lorsque le script se termine, il n'y a pas grand-chose à se soucier du tout. La seule chose que vous devez faire est d'instancier la connexion une fois et de passer la variable à tout le code qui a besoin de ce mysqli objet.

Une autre mauvaise pratique est que vous introduisez un Singleton ici, quelque chose comme :

class MysqliSingleton extends mysqli
{
    private static $instance;
    /**
     * @return MysqliSingleton
     */
    public function getInstance()
    {
        if (NULL === self::$instance)
            self::$instance = new self();
        return self::$instance;
    }
    private function __construct()
    {
    }
    public function __clone()
    {
         throw new RuntimeException('Clone is not allowed.');
    }
    public function __wakeup()
    {
        throw new RuntimeException('Unserializing is not allowed.');
    }
}

Cela fonctionnerait comme ceci :

$mysqli = MysqliSingleton::getInstance();

et renverrait toujours cette instance mysqli, ce qui pourrait être ce que vous recherchez. Cependant Singletons sont considérés comme nuisibles car ils peuvent introduire de nombreux problèmes, voir la question connexe Qui a besoin de singletons ? .

Il est plus facile de créer vous-même une variable que vous transmettez contenant l'instance de base de données. Vous pouvez en outre encapsuler une sorte de chargement paresseux au cas où votre application n'aurait pas toujours besoin d'une connexion mysqli, par ex. avec une classe de contexte très simple :

interface ContextMysqli
{
    /**
     * @return mysqli
     */
    public function getMysqli();
}

class Context implements ContextMysqli
{
    private $mysqli;
    public function getMysqli()
    {
        $this->mysqli || $this->mysqli = new mysqli();
        return $this->mysqli;
    }
}

Lorsque vos scripts démarrent, instanciez simplement votre contexte et transmettez-le à chaque partie de votre code où vous en avez besoin :

$context = new Context();
...
$result = do_some_db_work($context);
...
function do_some_db_work(ContextMysqli $context)
{
    $mysqli = $context->getMysqli();
    ...
}

Cette suggestion est peut-être aussi un peu myope, mais c'est mieux qu'un singleton tout en n'introduisant pas beaucoup de bruit. L'avantage est que vous avez encapsulé la logique quand créer le mysqli objet sans besoin d'un singleton. Votre code est maintenant indépendant du contexte global ou statique.