PHP: Utilizing singleton pattern correctly?

I've trying to learn PHP OOP and have made some research on how to make a global database class to use around in my project. From what I've seen the 开发者_StackOverflow中文版most appropriate pattern available is a singleton which would ensure that only one database connection are present at all times. However as this is my first time working with the Singleton pattern, I am not sure that I have made it right.

Is this a proper singleton? Will this code ensure one database connection only? Is there any way I can test this? (Learn a man to fish and he will have food for the rest of his life...)

I am using redbean as my ORM and here's how I set it up plainly:

require_once PLUGINPATH.'rb.php';
$redbean= R::setup("mysql:host=192.168.1.1;dbname=myDatabase",'username','password');

I've made the following script based upon this source, as my own singleton Database class;

class database {
    private $connection = null;

    private function __construct(){
        require_once PLUGINPATH.'rb.php';
        $this->connection = R::setup("mysql:host=192.168.1.1;dbname=myDatabase",'username','password');
    }

    public static function get() {
        static $db = null;

        if ( $db === null )
        $db = new database();

        return $db;
    }

    public function connection() {
        return $this->connection;
    }
}

Thanks!

The instance variable needs to be a static member of the class. I haven't tested this code, but it should work. Connection should probably be static too. With this code, you will have one instance of your database class, and one instance of the connection. It is possible to do this without connection being static, but making it static will ensure there is only one connection instance. I also changed the literal names of the class to php magic constants. This make your code more maintainable. If you change the name of your class down the road, you won't have to go and find all of the literal instances of the old class name in your code. This may seem like overkill now, but trust me, as you work on more and more complex projects, you will appreciate the value.

class database {
    private static $connection = null;
    private static $db;

    private function __construct(){
        require_once PLUGINPATH.'rb.php';
        self::$connection = R::setup("mysql:host=192.168.1.1;dbname=myDatabase",'username','password');
    }

    public static function get() {
        if ( !(self::$db instanceof __CLASS__) ) {
            $klass = __CLASS__; // have to set this to a var, cant use the constant with "new"
            self::$db = new $klass();
        }

        return self::$db;
        }

    public function connection() {
        return self::$connection;
    }
}

You're singleton is almost correct.

The private member (no pun intended) $connection needs to be static as well. You might go with the following too:

class database {
    private static $instance = NULL;
    protected $conn;

    private function __construct() {
        $this->conn = mysql_connect( ... );
    }

    public static function init() {
        if (NULL !== self::$instance) 
            throw new SingletonException();
        self::$instance = new database();
    }

    public static function get_handle() {
        if (NULL === self::$instance)
            ; // error handling here
        return self::$instance->conn;
    }
}