PHP类-如何连接到数据库只有一次

既然每个人都把他们的OOP扔进了环(注意:我要做PDO，因为我更了解它，但原理是一样的，只是替换连接):

<?php
class DatabaseConnection
    {
        # Create a singleton to store the connection for reuse
        private static $singleton,
                       $con;
        # save connection to singleton and return itself (the full object)
        public function __construct()
           {
                # If your singleton is not set
                if(!isset(self::$singleton))
                    # assign it this class
                    self::$singleton = $this;
                # return this class
                return self::$singleton;
           }
        # This is a connection method because your __construct
        # is not able to return the $pdo connection
        public function connection($host='hostname',$username='username',$password='password',$database='database')
            {
                # In the connection, you can assign the PDO to a static
                # variable to send it back if it's already set
                if(self::$con instanceof 'PDO)
                    return self::$con;
                # If not already a PDO connection, try and make one
                try {
                        # PDO settings you can apply at connection time
                        $opts = array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,PDO::ATTR_EMULATE_PREPARES => false);
                        # Assign your PDO Conneciton here.
                        self::$con =  new PDO("mysql:host={$host};dbname={$database}",$username,$password,$opts);
                        # Return the connection
                        return self::$con;
                    }
                catch (PDOException $e){
                        exit('Database error');
                    }   
            }
    }

你可以在任何地方使用它，在你的函数，类，你的名字之外。它每次都会返回相同的连接。如果您使用带有自动加载功能的spl_autoload_register()，您将全部设置好，甚至不必每次都显式地使用require_once() !

<?php
require_once('class.DatabaseConnection.php');
// Instantiate connection class
$pdo = new DatabaseConnection();
// Assign the connection to $con (or whatever variable you like)
$con = $pdo->connection();

需要注意的是，singleton模式通常很少使用。通常最好使用new Objects()，而不给它分配singleton。不过，我个人更喜欢singleton。

简单演示-考虑以下场景:

<?php
// Here is an example of the singlton with an echo
// which shows that the class is returning itself
// like a global
class DatabaseConnection
    {
        private static $singleton;
        public function __construct()
           {
                // If your singleton is not set
                if(!isset(self::$singleton)) {
                        echo 'NEW Object'.PHP_EOL;
                        // assign it this class
                        self::$singleton = $this;
                    }
                else
                    echo 'SAME Object'.PHP_EOL;
                // return this class
                return self::$singleton;
           }
    }
function ReturnConnection()
    {
        return new DatabaseConnection();
    }
class TestClass
    {
        public  function __construct()
            {
                new DatabaseConnection();
            }
    }
function query($sql=false)
    {
        return ReturnConnection();
    }
// The connection class wrapped in a function 
$a = ReturnConnection();
// The function nested inside a class
$b = new TestClass();
// The function nested inside another function
$c = query();

上述singleton的使用将产生:

NEW Object
SAME Object
SAME Object

首先，您根本不应该使用mysql_*函数。它们已被弃用，使用起来很危险。但是，假设您可以使用全局变量。

定义函数外部的连接(在全局作用域中)，然后使用global给函数访问它的权限。现在你所要做的就是在所有需要它的函数中包含这一行"global"。

$link = mysql_connect('127.0.0.1','XXXX','XXXXXX');
function __classDBREAD($table, $where, $value, $back)
{
    global $link;
    mysql_select_db('XXXX', $link);
    mysql_set_charset('utf8');
    $sql = "SELECT * FROM $table WHERE $where = '$value' LIMIT 1";
    $result = mysql_query($sql, $link) or die(mysql_error());
    $row = mysql_fetch_assoc($result);
    return $row[$back];
    mysqli_close($link);
}

编辑…

我没有仔细读这篇文章。我看到你正在处理一个类，所以全局变量不是最好的选择。考虑这个. .

class mydbclassthing {
    private $conn;
    public function __construct(){
        $this->conn = mysql_connect('127.0.0.1','XXXX','XXXXXX');
    }
    function __classDBREAD($table, $where, $value, $back)
    {
        $link = $this->con;
        mysql_select_db('XXXX', $link);
        mysql_set_charset('utf8');
        $sql = "SELECT * FROM $table WHERE $where = '$value' LIMIT 1";
        $result = mysql_query($sql, $link) or die(mysql_error());
        $row = mysql_fetch_assoc($result);
        return $row[$back];
        mysql_close($link);
    }
}

PHP文档中关于持久数据库连接的说明(http://php.net/manual/en/features.persistent-connections.php):

为每个PHP解释器创建和销毁一个实例页面请求(PHP页面)到您的web服务器。因为它是在每次请求之后销毁，它获得的任何资源(例如(到SQL数据库服务器的链接)在它被销毁时关闭。在在这种情况下，您不会从尝试使用持久化中获得任何好处连接——它们根本不存在。

如果你想更有效地重用代码，使用面向对象的方式是关键。

我以后可能会考虑一个更好的解决方案，但我要做的是使用类成员来存储到SQL的链接，所以它们不必每次都创建:

class MySQL {
    protected $mysql_link;
    protected $server = '127.0.0.1'; //and so on...
    public function __construct() {
       $this->link = mysql_connect($this->server,$this->user,$this->password);
       mysql_select_db($this->selected_db, $this->link);
       mysql_set_charset('utf8');
    }
    public function link() {
        return $this->link;
    }
    public function close() {
        return mysql_close($this->link);
    }
}

现在，在应用程序的其余部分使用OOP(类似于依赖注入)将是非常棒的，但如果没有，无论如何，您始终可以实例化您正在创建的类，甚至将该对象存储在$_SESSION变量中。

使用$object->link()将始终返回该实例的链接，而不是每次需要执行任何查询时创建新的链接，