MySQLi-klassenpatroon voor verbinding, sluiten, open laten?

Ik zou het geen goede gewoonte vinden. Dat heeft vooral één reden:het probleem dat je beschrijft waarom je denkt dat je het nodig hebt:slechts één verbinding per verzoek.

U hoeft niets te coderen. mysqli heeft een leuke feature ingebouwd, de standaard verbinding. Het kiest de databaseverbindingsparameters uit de ini-instellingen (configuratie) telkens wanneer u een nieuwe instantie aanmaakt:

$db = new mysqli;

Omdat alle databaseverbindingen worden gesloten wanneer het script klaar is, is er niet veel om je zorgen over te maken. Het enige dat u hoeft te doen, is de verbinding eenmaal te instantiëren en de variabele door te geven aan alle code die mysqli nodig heeft voorwerp.

Een andere slechte gewoonte is dat je een Singleton hier, zoiets als:

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.');
    }
}

Het zou als volgt werken:

$mysqli = MysqliSingleton::getInstance();

en zou altijd die ene mysqli-instantie retourneren, wat misschien is wat u zoekt. Maar Singletons worden als schadelijk beschouwd omdat ze veel problemen kunnen veroorzaken, zie de gerelateerde vraag Wie heeft eenlingen nodig? .

Het is gemakkelijker om zelf een variabele te maken die u rondgeeft met daarin de database-instantie. U kunt bovendien een soort van lui laden inkapselen voor het geval uw toepassing niet altijd een mysqli-verbinding nodig heeft, b.v. met een heel eenvoudige contextklasse:

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;
    }
}

Wanneer uw scripts starten, hoeft u alleen maar uw context te instantiëren en deze door te geven aan elk deel van uw code waar u deze nodig heeft:

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

Deze suggestie is misschien ook een beetje kortzichtig, maar het is beter dan een eenling zonder veel ophef te veroorzaken. Het voordeel is dat u de logica hebt ingekapseld wanneer u de mysqli . moet maken object zonder de noodzaak van een singleton. Uw code is nu onafhankelijk van de globale of statische context.