PHP Singleton DOP

Question

de 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 () ; 
?> 

Mis preguntas son:

Lo que es Singleton?

¿Qué significa static/do?

¿Cuál es __callStatic public static function (utilizado para?

Y cómo lo hago, que DOP sólo se conecta a la base de datos cuando sea necesario? Tal como consulta o escapar? Así que si la clase/objeto no está en uso entonces no se conecta.

Answer 1

Un singleton es un patrón de diseño de software que restringe el inicio de una clase a una instancia. http://en.wikipedia.org/wiki/Singleton_pattern

Estático significa que algo pertenece a la clase y no a una instancia en particular. En PHP, esto también significa que se debe llamar a un método estático con :: no ->

_callStatic devuelve el enlace PDO si ya se ha establecido. De lo contrario, primero crea el enlace y luego lo devuelve.

La respuesta a su cuarta pregunta es precisamente el patrón singleton. Asegura que la conexión solo se configure una vez, cuando sea necesario.

Answer 2

Singleton significa que tiene esta clase que solo tendrá un objeto asociado. Por lo tanto, esta clase solo se instanciará una sola vez, luego de eso, llamará a un método con un nombre como getInstance() que devolverá su instancia.

Estático, significa que para acceder a ese method o property que no es necesario y la instancia de ese objeto, puede llamar a que method directamente con su clase class::myMethod()

__callStatic es la forma de acceder a los métodos estáticos. Es uno de PHPmagic-methods y es similar a __call con la diferencia que acabo de mencionar.

Para la última pregunta, esa clase solo obtiene una conexión a la base de datos. Si se agrega otro método, por ejemplo, executeSelect($sql) tendrá algo como:

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

Usted sólo tendrá que llamar así: Database::executeSelect($sql); y nunca obtendrá dos conexión a la DB simultáneamente.

Answer 3

Un singleton es un objeto que asegura que solo una instancia de sí mismo está activa a la vez. Es decir, solo puede hacer uno por programa, si sabe a qué me refiero.

Un método estático es aquel que se puede llamar como una función normal, fuera del contexto del objeto. Como SomeClass:afunc() y no solo $this->afunc().

Answer 4

Una tonelada simple es una función estática que le permite realizar un seguimiento de las instancias de sus objetos, cuando usa un singleton, crea una instancia del objeto pero las instancias siempre permanecen con el objeto asociado.

Tome este ejemplo:

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

como se puede ver que db1 y db2 son 2 nuevas instancias de base de datos, por lo tanto no la misma, ahora toma este ejemplo.

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

Y el código, por ejemplo,

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

Si se analiza el código que va por lo que no importa dónde se utiliza en toda la aplicación Instancia el objeto siempre será el mismo.

una función estática es un método dentro de una clase/objeto es un tipo de método que se puede utilizar sin que el objeto se inicialice.

Con respecto al método __callStatic, este es un Método Mágico que se ejecuta cuando un método estático no está disponible.

Por ejemplo:

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

permite probarlos.

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 

la esperanza que esto le ayuda