MySQLi Singleton - php

Question

Is this enought to make singleton in php?
public static function getInstance() {
if (!isset(self::$intance)) {
self::$instance = new mysqli(DB_HOST, DB_USER, DB_PWD, DB_NAME);
}
return self::$instance;
}
I found it easiest way, more easy than anything I saw here. Can there be any problems with that?

Answer 1

You can't make the original mysqli class be a singleton - which is actually a good thing because singletons are evil (and I will go into details about this if needed).
What you did is technically called a static factory method that will only return the first ever created instance of the database object. This is in fact very much better than using a singleton because you might also delete that instance for testing to create another one, and another one ...
But from my experience, you are usually happy to have a way to use more than exactly one database connection in your code. Simply think about using two user accounts, one for admin stuff, and the other one for regular usage. This alone would qualify as two database connections, and if your code can only handle "the only one instance" without a choice of login credentials, this would be really a bad thing. I'd recommend against it.

Answer 2

This is singleton class:
class DataBase
{
private static $mysqli;
final private function __construct() {}
public static function getInstance()
{
if (!is_object(self::$mysqli)) self::$mysqli = new mysqli($H,$U,$P,$B);
return self::$mysqli;
}
private function __destruct()
{
if (self::$mysqli) self::$mysqli->close();
}
private function __clone() {}
}
It's important that:
variable (storing db connection) is static
constructor function is private (cannot be called) (final that cannot be overridden)
function returning object is static as well (usually function getInstance as here)
cloning of singleton classes is not allowed so __clone() function must be empty
destructor function __destruct is called by garbage collector and should finalize state
so this database connection is called from other classes as:
$db=DataBase::getInstance();
not as
$db=new DataBase();

Answer 3

Consolidating the changes in the comments, with one of my own. Rather than relying on constants, pass the variables into the getInstance/constructor so that you can store your credentials any way you would like, and feed them into the class, without having the class be reliant on the data being stored a certain way. Adds a bit of flexibility.
You can also swap that out with code to read them from a config file, or to pick up the data from a service locator type pattern.
Class MysqlConnection {
private static $instance = null;
private function __construct() {
self::$instance = new mysqli(DB_HOST,DB_USER,DB_PASS,DB_DATABASE);
}
public static function getInstance() {
if (!isset(self::$instance)) {
$credentials = self::getCredentials();
self::$instance = new MysqlConnection();
}
return self::$instance;
}
}
function __clone() {
//Throw exception/custom exception type here.
}
}
Edit Comment: The idea is not to outline an entirely 100% use as is class here, but to represent my position and approach to this. The credentials bit is not 100% necessary, its just how I feel about making it a little more flexible, rather than hard coding it to use only CONSTANTS, etc. That might distract from the initial point, which is what does a singleton look like. I apologize for the confusion.