PHP 单例 PDO

Question

来自 http://www.php.net/manual/en/class.pdo。 php

###### config.ini ######
db_driver=mysql
db_user=root
db_password=924892xp

[dsn]
host=localhost
port=3306
dbname=localhost

[db_options]
PDO::MYSQL_ATTR_INIT_COMMAND=set names utf8

[db_attributes]
ATTR_ERRMODE=ERRMODE_EXCEPTION
############

<?php class Database {
    private static $link = null ;

    private static function getLink ( ) {
        if ( self :: $link ) {
            return self :: $link ;
        }

        $ini = _BASE_DIR . "config.ini" ;
        $parse = parse_ini_file ( $ini , true ) ;

        $driver = $parse [ "db_driver" ] ;
        $dsn = "${driver}:" ;
        $user = $parse [ "db_user" ] ;
        $password = $parse [ "db_password" ] ;
        $options = $parse [ "db_options" ] ;
        $attributes = $parse [ "db_attributes" ] ;

        foreach ( $parse [ "dsn" ] as $k => $v ) {
            $dsn .= "${k}=${v};" ;
        }

        self :: $link = new PDO ( $dsn, $user, $password, $options ) ;

        foreach ( $attributes as $k => $v ) {
            self :: $link -> setAttribute ( constant ( "PDO::{$k}" )
                , constant ( "PDO::{$v}" ) ) ;
        }

        return self :: $link ;
    }

    public static function __callStatic ( $name, $args ) {
        $callback = array ( self :: getLink ( ), $name ) ;
        return call_user_func_array ( $callback , $args ) ;
    }
} ?>

<?php // examples
$stmt = Database :: prepare ( "SELECT 'something' ;" ) ;
$stmt -> execute ( ) ;
var_dump ( $stmt -> fetchAll ( ) ) ;
$stmt -> closeCursor ( ) ;
?>

我的问题是：

什么是单例？

静态是什么意思/做什么？

public static function __callStatic ( 用于做什么？

如何才能使 PDO 仅在需要时连接到数据库？例如查询或转义？因此，如果类/对象未使用，则它不会连接。

Answer 1

单例是一种软件设计模式，它将类的启动限制为一个实例。 http://en.wikipedia.org/wiki/Singleton_pattern

静态表示某物属于类而不是特定实例。在 PHP 中，这也意味着需要使用 :: 调用静态方法，而不是 ->

_callStatic 返回 PDO 链接（如果已经建立）。否则，它首先创建链接，然后返回它。

第四个问题的答案正是单例模式。它确保仅在需要时建立连接一次。

Answer 2

单例是一个静态函数，它允许您跟踪对象实例，当您使用单例时，您创建了对象的实例，但实例始终与关联的对象保持在一起。

举个例子：

$db1 = new Database();
$db2 = new Database();

正如您所看到的，db1 和 db2 是数据库的 2 个新实例，因此不一样，现在以这个例子为例。

$db1 = Database::Instance();
$db2 = Database::Instance();

以及 Instance 的代码

class Database
{
    private static $_instance;

    public static Instance()
    {
        if(self::$_instance !== null)
        {
            //We have already stored the object locally so just return it.
            //This is how the object always stays the same
            return self::$_instance;
        }
        return self::$_instance = new Database(); //Set the instance.
    }
}

如果您分析代码，您将发现无论您在应用程序中的哪个位置使用 Instance，您的对象都将始终相同。

静态函数是类/对象中的方法，是一种无需初始化对象即可使用的方法类型。

对于 __callStatic 方法，这是一个在静态方法不可用时执行的魔术方法。

例如：

class Database
{

    public static function first()
    {
        echo 'I actually exists and I am first';
    }

    public function __callStatic($name,$args)
    {
        echo 'I am '. $name .' and I was called with ' . count($args) . ' args';
    }
}

让我们测试一下它们。

Database::first(); //Output: I actually exists and I am first

Database::second(); //Output: I am second and I was called with 0 args

Database::StackOverflow(true,false); //Output: I am StackOverflow and I was called with 2 args

希望这对您有帮助

Answer 3

单例是一种确保一次只有一个自身实例处于活动状态的对象。也就是说，每个程序只能创建一个，如果您明白我的意思的话。

静态方法是一种可以像普通函数一样在对象上下文之外调用的方法。就像 SomeClass:afunc() 而不仅仅是 $this->afunc()。

Answer 4

Singleton 意味着，您的此类只有一个与之关联的对象。因此，此类只会实例化一次，之后您将调用一个名为 getInstance() 的方法来返回您的实例。

静态，意味着要访问您不需要的方法或属性以及该对象的实例，您可以直接使用其调用该方法 class class::myMethod()

__callStatic 是访问这些静态方法的方式。是 PHP magic-methods 之一，与 __call 类似，但有我刚才提到的区别。

对于最后一个问题，该类仅获得一个与数据库的连接。如果您添加另一个方法，例如，executeSelect($sql)，您将得到如下内容：

public static function executeSelect($sql)
{
  if (self::$link)
  {
          self::getLink()
  } 
      // execute your query here...
  return null;
}

您只需要像这样调用它：Database::executeSelect($sql); 并且它永远不会同时获得两个到DB的连接。

Answer 5

<?php 
class DB {
protected static $instance;
protected function __construct() {
if(empty(self::$instance)) {
        try {
            self::$instance = new PDO("mysql:host=localhost;dbname=techprojects", 'root', '');
            self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
        } catch(PDOException $error) {
            echo $error->getMessage();
        }
    }

}
public static function getInstance() {
    if(empty(self::$instance)) {
        try {
            new DB();
            //var_dump(self::$instance);
        } catch(PDOException $error) {
            echo $error->getMessage();
        }
    }
    //var_dump(self::$instance);
    return self::$instance;
}

private function __clone() {
    // Stopping Clonning of Object
}

private function __wakeup() {
    // Stopping unserialize of object
}
}
?>
<?php
try {
$db = DB::getInstance();
$db1 = DB::getInstance();
$sqlExample = 'SELECT * FROM keywords';
$stm = $db->prepare($sqlExample);
$stm->execute();
$result = $stm->fetchAll(PDO::FETCH_ASSOC);

var_dump($db);
var_dump($db1);
echo "<pre>";
print_r($result);
echo "</pre>";

} catch (Exception $e) {
print $e->getMessage();

}
 ?>