Eğer MySQL sınıfının tek bir global nesne oluşturmak ve her yerde bu nesneyi kullanabilirsiniz. Sonra yapıcı yalnızca bir kez olacağını söyledi.

Yoksa her yerde MySQL sınıfının yeni nesneler oluşturabilirsiniz. Zaten bir açık varsa mysql_connect yeni bağlantıları açılmaz:

İkinci bir çağrı, aynı argümanlarla () mysql_connect yapılırsa, yeni bir bağlantı kurulacak, ancak bunun yerine, zaten açılan bağlantı bağlantı belirteci iade edilecektir.

Eğer mysql_pconnect () işlevini kullanmak eğer bu yöntemi kullanabilirsiniz, bir mysql bağlantı zaten varsa wich arayacak ve bu durumda onu bulursa, o zaman başka bir getirisi olmaz.

Eğer ne php örneklerini kullanmak düşünün alternatif olarak, sizin gibi, doğrudan php veritabanı nesnesini çağırabilir:

class DB {}

DB::connect($host, $user, $pass);

Bu yöntemi kullanırsanız, çoklu bağlantıları hakkında endişelenmenize gerek yoktur. Tabii ki bir seferde birden fazla veritabanı için çeşitli bağlantıları kullanmak gerekiyorsa, sen nesne örnekleri yararlanabilir, ya da birkaç parametre alır ve bir seferde hepsini saklayabilirsiniz böylece sınıf yapmak (çok bu bir recomemded değil)

Bence iyi yolu mysql bağlantıları işlemek ve bir tek olarak kullanmak için özel bir sınıf kullanmaktır. Kurucu özel yapmak ve varolan bir bağlantı veya yeni bir ya bir örneğini dönmek için olsun.

İşte benim örnek:

class db 
{

    public $host;
    public $user;
    public $pass;
    public $database;

    private static $instance = false;

    private function __construct() 
    {

    }

    public static function getInstance()
    {
        if (self::$instance === false)
        {
            self::$instance = new db;
        }
        return self::$instance;
    }

        public function db_connect()
        {
        }

        public function db_disconnect()
        {
        }
}

Bu şekilde, çağırdığınız: db :: getInstance () -> db_connect (), yalnızca her yerde bağlantı ONE örneği olacak orada oluyor kesin.

Evet, birden çok kez bağlantı olmamalıdır. Açılması ve bağlantı her zaman kapanış havai komut çalıştırmak göreceli küçük bir zaman boyunca onu açık tutmanın maliyeti daha büyük. Yani başında sınıfının bir örneğini oluşturmak gerekir ve bunun küresel bir değişken tutmak.

Bir egzersiz olarak, kendi sınıfları yazmak için kesinlikle kötü bir fikir değil, ama belki veritabanı bağlantı yönetimi (Zend_Db vb) için varolan çözümlerden biri içine bakmak gerekir.

Her zaman statik bir sınıf değişkeni içinde database bağlantı başvurusunu saklamak ve gerektiğinde çağırabilirsiniz. Ancak, tek başına PHP hafızasında varsa Varolan bir bağlantıyı kullanmaya çalışır.

Ben onun PHP 5 ve kullanır PDO'nun tabii, sizin için bir örnek veritabanı işleyici kodu var.

<?php
// Class providing generic data access functionality
class DatabaseHandler
{
  // Hold an instance of the PDO class
  private static $_mHandler;

  // Private constructor to prevent direct creation of object
  private function __construct()
  {
  }

  // Return an initialized database handler 
  private static function GetHandler()
  {
    // Create a database connection only if one doesn’t already exist
    if (!isset(self::$_mHandler))
    {
      // Execute code catching potential exceptions
      try
      {
        // Create a new PDO class instance
        self::$_mHandler =
          new PDO(PDO_DSN, DB_USERNAME, DB_PASSWORD);

        // Configure PDO to throw exceptions
        self::$_mHandler->setAttribute(PDO::ATTR_ERRMODE,
                                       PDO::ERRMODE_EXCEPTION);
        self::$_mHandler->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
      }
      catch (PDOException $e)
      {
        // Close the database handler and trigger an error
        self::Close();
        trigger_error($e->getMessage(), E_USER_ERROR);
      }
    }

    // Return the database handler
    return self::$_mHandler;
  }
  // Clear the PDO class instance
  public static function Close()
  {
    self::$_mHandler = null;
  }
  // Wrapper method for PDO::prepare
  private static function Prepare($queryString)
  {
    // Execute code catching potential exceptions
    try
    {
      // Get the database handler and prepare the query
      $database_handler = self::GetHandler();
      $statement_handler = $database_handler->prepare($queryString);

      // Return the prepared statement
      return $statement_handler;
    }
    catch (PDOException $e)
    {
      // Close the database handler and trigger an error
      self::Close();
      trigger_error($e->getMessage(), E_USER_ERROR);
    }
  }

  // Wrapper method for PDOStatement::execute()
  public static function Execute($sqlQuery, $params = null)
  {
    // Try to execute an SQL query or a stored procedure
    try
    {
    	$statement_handler = self::Prepare($sqlQuery);

      // Execute query
      $statement_handler->execute($params);
    }
    // Trigger an error if an exception was thrown when executing the SQL query
    catch(PDOException $e)
    {
      // Close the database handler and trigger an error
      self::Close();
      trigger_error($e->getMessage(), E_USER_ERROR);
    }
  }

  // Wrapper method for PDOStatement::fetchAll()
  public static function GetAll($sqlQuery, $params = null,
                                $fetchStyle = PDO::FETCH_ASSOC)
  {
    // Initialize the return value to null
    $result = null;

    // Try to execute an SQL query or a stored procedure
    try
    {
        $statement_handler = self::Prepare($sqlQuery);

      // Execute the query
      $statement_handler->execute($params);

      // Fetch result
      $result = $statement_handler->fetchAll($fetchStyle);
    }
    // Trigger an error if an exception was thrown when executing the SQL query
    catch(PDOException $e)
    {
      // Close the database handler and trigger an error
      self::Close();
      trigger_error($e->getMessage(), E_USER_ERROR);
    }

    // Return the query results
    return $result;
  }

  // Wrapper method for PDOStatement::fetch()
  public static function GetRow($sqlQuery, $params = null,
                                $fetchStyle = PDO::FETCH_ASSOC)
  {
    // Initialize the return value to null
    $result = null;

    // Try to execute an SQL query or a stored procedure
    try
    {

      $statement_handler = self::Prepare($sqlQuery);

      // Execute the query
      $statement_handler->execute($params);

      // Fetch result
      $result = $statement_handler->fetch($fetchStyle);
    }
    // Trigger an error if an exception was thrown when executing the SQL query
    catch(PDOException $e)
    {
      // Close the database handler and trigger an error
      self::Close();
      trigger_error($e->getMessage(), E_USER_ERROR);
    }

    // Return the query results
    return $result;
  }

  // Return the first column value from a row
  public static function GetOne($sqlQuery, $params = null)
  {
    // Initialize the return value to null    
    $result = null;

    // Try to execute an SQL query or a stored procedure
    try
    {
        $statement_handler = self::Prepare($sqlQuery);

      // Execute the query
      $statement_handler->execute($params);

      // Fetch result
      $result = $statement_handler->fetch(PDO::FETCH_NUM);

      /* Save the first value of the result set (first column of the first row)
         to $result */
      $result = $result[0];
    }
    // Trigger an error if an exception was thrown when executing the SQL query
    catch(PDOException $e)
    {
      // Close the database handler and trigger an error
      self::Close();
      trigger_error($e->getMessage(), E_USER_ERROR);
    }

    // Return the query results
    return $result;
  }
}
?>

Bir parametre olarak, ya diğerleri, ya da bir şey için bir başvuru varsa, bazı merkez nesnesinin bir özelliği olarak da, etrafında bir bağlantı nesnesi (muhtemelen PDO) geçmelidir, ve çeşitli yerlerde o kadar almak gerekir.

Birden fazla bağlantı olması yararlı olabilir, mysql_connect bir yenisini istedim olabilir varolan bir bağlantıyı seçer, deli görünüyor - ama yine de delilik. Sadece PDO kullanabilirsiniz.