PHP 단일 모드 는 어떤 phop 이 단일 모드 를 실현 하 는 방법 입 니까?

1.단일 모드 는 무엇 입 니까?
1.의미   
   대상 의 생 성 모드 로 서 단일 모드 는 하나의 인 스 턴 스 만 있 고 자체 적 으로 예화 되 어 전체 시스템 에 이 인 스 턴 스 를 제공 합 니 다.인 스 턴 스 복사 본 을 만 들 지 않 고 단일 클래스 내부 에 저 장 된 인 스 턴 스 에 인용 을 되 돌려 줍 니 다.
2.단일 사례 모델 의 세 가지 요점:
(1).클래스 를 저장 하 는 유일한 인 스 턴 스 의 정적 구성원 변수 가 필요 합 니 다.
private static $_instance;   
(2).구조 함수 와 복제 함 수 는 개인 적 인 것 으로 밝 혀 야 하 며 외부 프로그램 new 류 가 단일 모드 의 의 미 를 잃 지 않도록 해 야 합 니 다.

private function __construct()  
{  
  $this->_db = pg_connect('xxxx'); 
}  
private function __clone() 
{ 
}//  __clone()  ，     

(3).이 인 스 턴 스 에 접근 하 는 공공 정적 방법(보통 getInstance 방법)을 제공 하여 유일한 인 스 턴 스 의 인용 을 되 돌려 야 합 니 다.

public static function getInstance()  
{  
  if(! (self::$_instance instanceof self) )  
  {  
    self::$_instance = new self();  
  } 
  return self::$_instance;  
 
}  

2.왜 단일 모드 를 사용 합 니까?
1.PHP 의 단점:        
        PHP 언어 는 해석 형 스 크 립 트 언어 입 니 다.이 운영 체 제 는 모든 PHP 페이지 가 해석 되 고 실 행 된 후에 모든 관련 자원 을 회수 합 니 다.즉,PHP 는 언어 단계 에서 특정한 대상 을 메모리 에 상주 시 킬 방법 이 없다.이것 은 asp.net,자바 등 컴 파일 형 과 다르다.예 를 들 어 자바 에서 단일 사례 는 전체 응용 프로그램의 생명 주기 에 존재 하고 변 수 는 크로스 페이지 급 이 므 로 이 인 스 턴 스 가 응용 프로그램의 생명 주기 에서 유일 하 게 할 수 있다.그러나 PHP 에서 모든 변 수 는 전역 변수 든 클래스 의 정적 구성원 이 든 페이지 급 입 니 다.페이지 가 실 행 될 때마다 새로운 대상 을 다시 만 들 고 페이지 가 실 행 된 후에 비 워 집 니 다.그러면 PHP 단일 모드 는 의미 가 없 는 것 같 습 니 다.그래서 PHP 단일 모드 는 단일 페이지 급 요청 시 여러 개의 응용 장면 이 나타 나 고 같은 대상 자원 을 공유 해 야 할 때 매우 의미 가 있다 고 생각 합 니 다.
2.단일 모드 가 PHP 에서 의 응용 장소:
(1)응용 프로그램 과 데이터베이스 상호작용
  하나의 응용 프로그램 에 대량의 데이터베이스 조작 이 존재 할 것 이다.예 를 들 어 데이터베이스 핸들 을 통 해 데이터 베 이 스 를 연결 하 는 행 위 는 단일 모드 를 사용 하면 대량의 new 작업 을 피 할 수 있다.왜냐하면 매번 new 작업 은 메모리 자원 과 시스템 자원 을 소모 하기 때문이다.
(2)제어 설정 정보
 시스템 에 일부 설정 정 보 를 전역 적 으로 제어 할 수 있 는 클래스 가 필요 하 다 면 단일 모드 를 사용 하면 편리 하 게 실현 할 수 있 습 니 다.
3.어떻게 단일 모델 을 실현 합 니까?
1.일반적인 데이터베이스 접근 예:

<?php 
...... 
//           
$db = new DB(...); 
 
//       
$db->addUserInfo(...); 
 
...... 
 
//         ，       
function getUserInfo() 
{ 
  $db = new DB(...);//  new     ，         
  $db = query(....);//            
} 
 
?> 

2.단일 모드 를 사용 하여 데이터 베 이 스 를 조작 합 니 다.

<?php 
class DB  
{  
  private $_db;  
  private static $_instance;  
  
  private function __construct(...)  
  {  
    $this->_db = pg_connect(...);//postgrsql  
  }  
  
  private function __clone() {}; //  __clone()  ，      
  
  public static function getInstance()  
  {  
    if(! (self::$_instance instanceof self) ) {  
      self::$_instance = new self();  
    }  
    return self::$_instance;  
  }  
  
  public function addUserInfo(...) 
  { 
  } 
   public function getUserInfo(...) 
  {  
  } 
 
} 
 
//test  
$db = DB::getInstance();  
$db->addUserInfo(...);  
$db->getUserInfo(...);  
 
?> 

 다음 코드 는 PDO 작업 데이터베이스 클래스 의 패키지 로 단일 모드 를 사용 합 니 다.

<?php
/**
 * MyPDO
 */
class MyPDO
{
  protected static $_instance = null;
  protected $dbName = '';
  protected $dsn;
  protected $dbh;
  
  /**
   *   
   * 
   * @return MyPDO
   */
  private function __construct($dbHost, $dbUser, $dbPasswd, $dbName, $dbCharset)
  {
    try {
      $this->dsn = 'mysql:host='.$dbHost.';dbname='.$dbName;
      $this->dbh = new PDO($this->dsn, $dbUser, $dbPasswd);
      $this->dbh->exec('SET character_set_connection='.$dbCharset.', character_set_results='.$dbCharset.', character_set_client=binary');
    } catch (PDOException $e) {
      $this->outputError($e->getMessage());
    }
  }
  
  /**
   *     
   * 
   */
  private function __clone() {}
  
  /**
   * Singleton instance
   * 
   * @return Object
   */
  public static function getInstance($dbHost, $dbUser, $dbPasswd, $dbName, $dbCharset)
  {
    if (self::$_instance === null) {
      self::$_instance = new self($dbHost, $dbUser, $dbPasswd, $dbName, $dbCharset);
    }
    return self::$_instance;
  }
  
  /**
   * Query   
   *
   * @param String $strSql SQL  
   * @param String $queryMode     (All or Row)
   * @param Boolean $debug
   * @return Array
   */
  public function query($strSql, $queryMode = 'All', $debug = false)
  {
    if ($debug === true) $this->debug($strSql);
    $recordset = $this->dbh->query($strSql);
    $this->getPDOError();
    if ($recordset) {
      $recordset->setFetchMode(PDO::FETCH_ASSOC);
      if ($queryMode == 'All') {
        $result = $recordset->fetchAll();
      } elseif ($queryMode == 'Row') {
        $result = $recordset->fetch();
      }
    } else {
      $result = null;
    }
    return $result;
  }
  
  /**
   * Update   
   *
   * @param String $table   
   * @param Array $arrayDataValue     
   * @param String $where   
   * @param Boolean $debug
   * @return Int
   */
  public function update($table, $arrayDataValue, $where = '', $debug = false)
  {
    $this->checkFields($table, $arrayDataValue);
    if ($where) {
      $strSql = '';
      foreach ($arrayDataValue as $key => $value) {
        $strSql .= ", `$key`='$value'";
      }
      $strSql = substr($strSql, 1);
      $strSql = "UPDATE `$table` SET $strSql WHERE $where";
    } else {
      $strSql = "REPLACE INTO `$table` (`".implode('`,`', array_keys($arrayDataValue))."`) VALUES ('".implode("','", $arrayDataValue)."')";
    }
    if ($debug === true) $this->debug($strSql);
    $result = $this->dbh->exec($strSql);
    $this->getPDOError();
    return $result;
  }
  
  /**
   * Insert   
   *
   * @param String $table   
   * @param Array $arrayDataValue     
   * @param Boolean $debug
   * @return Int
   */
  public function insert($table, $arrayDataValue, $debug = false)
  {
    $this->checkFields($table, $arrayDataValue);
    $strSql = "INSERT INTO `$table` (`".implode('`,`', array_keys($arrayDataValue))."`) VALUES ('".implode("','", $arrayDataValue)."')";
    if ($debug === true) $this->debug($strSql);
    $result = $this->dbh->exec($strSql);
    $this->getPDOError();
    return $result;
  }
  
  /**
   * Replace       
   *
   * @param String $table   
   * @param Array $arrayDataValue     
   * @param Boolean $debug
   * @return Int
   */
  public function replace($table, $arrayDataValue, $debug = false)
  {
    $this->checkFields($table, $arrayDataValue);
    $strSql = "REPLACE INTO `$table`(`".implode('`,`', array_keys($arrayDataValue))."`) VALUES ('".implode("','", $arrayDataValue)."')";
    if ($debug === true) $this->debug($strSql);
    $result = $this->dbh->exec($strSql);
    $this->getPDOError();
    return $result;
  }
  
  /**
   * Delete   
   *
   * @param String $table   
   * @param String $where   
   * @param Boolean $debug
   * @return Int
   */
  public function delete($table, $where = '', $debug = false)
  {
    if ($where == '') {
      $this->outputError("'WHERE' is Null");
    } else {
      $strSql = "DELETE FROM `$table` WHERE $where";
      if ($debug === true) $this->debug($strSql);
      $result = $this->dbh->exec($strSql);
      $this->getPDOError();
      return $result;
    }
  }
  
  /**
   * execSql   SQL  
   *
   * @param String $strSql
   * @param Boolean $debug
   * @return Int
   */
  public function execSql($strSql, $debug = false)
  {
    if ($debug === true) $this->debug($strSql);
    $result = $this->dbh->exec($strSql);
    $this->getPDOError();
    return $result;
  }
  
  /**
   *        
   * 
   * @param string $table   
   * @param string $field_name    
   * @param string $where   
   */
  public function getMaxValue($table, $field_name, $where = '', $debug = false)
  {
    $strSql = "SELECT MAX(".$field_name.") AS MAX_VALUE FROM $table";
    if ($where != '') $strSql .= " WHERE $where";
    if ($debug === true) $this->debug($strSql);
    $arrTemp = $this->query($strSql, 'Row');
    $maxValue = $arrTemp["MAX_VALUE"];
    if ($maxValue == "" || $maxValue == null) {
      $maxValue = 0;
    }
    return $maxValue;
  }
  
  /**
   *         
   * 
   * @param string $table
   * @param string $field_name
   * @param string $where
   * @param bool $debug
   * @return int
   */
  public function getCount($table, $field_name, $where = '', $debug = false)
  {
    $strSql = "SELECT COUNT($field_name) AS NUM FROM $table";
    if ($where != '') $strSql .= " WHERE $where";
    if ($debug === true) $this->debug($strSql);
    $arrTemp = $this->query($strSql, 'Row');
    return $arrTemp['NUM'];
  }
  
  /**
   *      
   * 
   * @param String $dbName   
   * @param String $tableName   
   * @param Boolean $debug
   * @return String
   */
  public function getTableEngine($dbName, $tableName)
  {
    $strSql = "SHOW TABLE STATUS FROM $dbName WHERE Name='".$tableName."'";
    $arrayTableInfo = $this->query($strSql);
    $this->getPDOError();
    return $arrayTableInfo[0]['Engine'];
  }
  
  /**
   * beginTransaction     
   */
  private function beginTransaction()
  {
    $this->dbh->beginTransaction();
  }
  
  /**
   * commit     
   */
  private function commit()
  {
    $this->dbh->commit();
  }
  
  /**
   * rollback     
   */
  private function rollback()
  {
    $this->dbh->rollback();
  }
  
  /**
   * transaction         SQL  
   *       getTableEngine           
   *
   * @param array $arraySql
   * @return Boolean
   */
  public function execTransaction($arraySql)
  {
    $retval = 1;
    $this->beginTransaction();
    foreach ($arraySql as $strSql) {
      if ($this->execSql($strSql) == 0) $retval = 0;
    }
    if ($retval == 0) {
      $this->rollback();
      return false;
    } else {
      $this->commit();
      return true;
    }
  }
  /**
   * checkFields                  
   *
   * @param String $table
   * @param array $arrayField
   */
  private function checkFields($table, $arrayFields)
  {
    $fields = $this->getFields($table);
    foreach ($arrayFields as $key => $value) {
      if (!in_array($key, $fields)) {
        $this->outputError("Unknown column `$key` in field list.");
      }
    }
  }
  
  /**
   * getFields               
   *
   * @param String $table   
   * @return array
   */
  private function getFields($table)
  {
    $fields = array();
    $recordset = $this->dbh->query("SHOW COLUMNS FROM $table");
    $this->getPDOError();
    $recordset->setFetchMode(PDO::FETCH_ASSOC);
    $result = $recordset->fetchAll();
    foreach ($result as $rows) {
      $fields[] = $rows['Field'];
    }
    return $fields;
  }
  
  /**
   * getPDOError   PDO    
   */
  private function getPDOError()
  {
    if ($this->dbh->errorCode() != '00000') {
      $arrayError = $this->dbh->errorInfo();
      $this->outputError($arrayError[2]);
    }
  }
  
  /**
   * debug
   * 
   * @param mixed $debuginfo
   */
  private function debug($debuginfo)
  {
    var_dump($debuginfo);
    exit();
  }
  
  /**
   *       
   * 
   * @param String $strErrMsg
   */
  private function outputError($strErrMsg)
  {
    throw new Exception('MySQL Error: '.$strErrMsg);
  }
  
  /**
   * destruct        
   */
  public function destruct()
  {
    $this->dbh = null;
  }
}
?>

호출 방법:

<?php
require 'MyPDO.class.php';
$db = MyPDO::getInstance('localhost', 'root', '123456', 'test', 'utf8');
$db->query("select count(*) frome table");
$db->destruct();
?>

이상 은 본 고의 모든 내용 이 므 로 여러분 이 phop 프로 그래 밍 을 배 우 는 데 도움 이 되 기 를 바 랍 니 다.