मेरे उपयोगकर्ता वर्ग

Question

में डेटाबेस क्लास का उपयोग करना मेरे प्रोजेक्ट में मेरे पास एक डेटाबेस क्लास है जिसका उपयोग मैं सभी MySQL सामग्री को संभालने के लिए करता हूं। यह किसी डेटाबेस से कनेक्ट होता है, क्वेरी चलाता है, त्रुटियों को पकड़ता है और कनेक्शन बंद कर देता है।

अब मुझे अपनी साइट पर एक सदस्य क्षेत्र बनाना होगा, और मैं एक ऐसे उपयोगकर्ता वर्ग का निर्माण करने जा रहा हूं जो पंजीकरण, लॉग इन, पासवर्ड/उपयोगकर्ता नाम परिवर्तन/रीसेट और लॉग आउट आउट करेगा। इस प्रयोक्ता वर्ग में मुझे स्पष्ट कारणों से MySQL का उपयोग करने की आवश्यकता है ... जो मेरा डेटाबेस वर्ग बनाया गया था।

लेकिन मैं इस बात से उलझन में हूं कि मैं अपने उपयोगकर्ता वर्ग में अपने डेटाबेस वर्ग का उपयोग कैसे करूं। क्या मैं अपने उपयोगकर्ता वर्ग के लिए एक नया डेटाबेस ऑब्जेक्ट बनाना चाहता हूं और फिर जब भी उस वर्ग में कोई विधि समाप्त हो जाती है तो इसे बंद कर दें? या मैं किसी भी तरह से 'ग्लोबल' डेटाबेस क्लास बना सकता हूं जिसका उपयोग पूरे पूरे स्क्रिप्ट में किया जा सकता है (यदि ऐसा है तो मुझे इसके साथ मदद की ज़रूरत है, कोई विचार नहीं कि वहां क्या करना है।)

किसी भी प्रतिक्रिया के लिए धन्यवाद मुझे।

Answer 1

चूंकि आप किसी ऑब्जेक्ट के रूप में डेटाबेस का उपयोग कर रहे हैं, क्यों न केवल उस ऑब्जेक्ट में विधियों को जोड़ें जो आपके "उपयोगकर्ता क्लास" को उन चीज़ों का ख्याल रखने के लिए नियोजित कर सकते हैं जिन्हें उन्हें करने की आवश्यकता है। उपयोगकर्ता वर्ग में डेटाबेस क्लास में पॉइंटर हो सकता है। डेटाबेस क्लास आपके डेटाबेस की रक्षा करेगी, और आश्वस्त करेगी कि उपयोगकर्ता वर्ग उचित रूप से इसका उपयोग कर रहा है।

Answer 2

जैसा कि उन्होंने कहा, अपने सभी कार्यों को डेटाबेस वर्ग में रखें और डेटाबेस उपयोगकर्ता का उपयोग अपने उपयोगकर्ता वर्ग से उन कार्यों तक पहुंचने के लिए करें। यह आपके मामले में सबसे अच्छी विधि होनी चाहिए। उदाहरण के लिए:
global $database;
userclassvar = $database->doSomething();

Answer 3

मुझे क्या करना चाहते मन में Singleton pattern साथ डेटाबेस वर्ग बनाते हैं। इस तरह, यदि आपके पास पहले से डेटाबेस ऑब्जेक्ट है, तो यह केवल इसे पुनर्प्राप्त करता है, अन्यथा एक नया बनाता है। उदाहरण के लिए:

Database.class.php 

class Db 
{ 
    protected static $_link; 

    private function __construct() 
    { 
     // access your database here, establish link 
    } 

    public static function getLink() 
    { 
     if(self::_link === null) { 
      new Db(); 
     } 
     return self::_link; 
    } 

    // etc. 

} 


User.class.php 

class User 
{ 
    protected $_link; // This will be the database object 
    ... 

    public function __construct() 
    { 
     $this->_link = Db::getLink(); 
    } 

} 

और अब आप User के $_link संपत्ति $this->_link->query(...) तरह डेटाबेस कार्यों ऐसा करने के लिए, का उपयोग कर सकते हैं। यदि आपको कक्षा में डेटाबेस के साथ बातचीत करने की आवश्यकता नहीं है तो आपको कन्स्ट्रक्टर में Db::getLink() रखना आवश्यक नहीं है।

Answer 4

सरल, 3 चरण प्रक्रिया। 1/डेटाबेस ऑब्जेक्ट बनाएं। 2/इसे अपने उपयोगकर्ता वर्ग निर्माता को दें। 3/उपयोगकर्ता विधियों में इसका इस्तेमाल करें।

थोड़ा उदाहरण।

फ़ाइल Database.class.php:

<?php 
class Database{ 
    public function __construct(){ 
    // Connects to database for example. 
    } 

    public function query($sqlQuery){ 
    // Send a query to the database 
    } 
    [...] 
} 

User.class.php में:

<?php 

class User{ 
    private $_db; 
    public function __construct(Database $db){ 
    $this->_db = $db; 
    } 

    public function deleteUser(){ 
    $this->_db->query('DELETE FROM Users WHERE name = "Bobby"'); 
    } 
} 

अब, userManager.php में उदाहरण के लिए:

<?php 
$db = new Database(); 
$user = new User($db); 
// Say bye to Bobby : 
$user->deleteUser(); 

आप तो इस पुरानी तकनीक के वर्तमान ट्रेंडी नाम, गूगल "निर्भरता इंजेक्शन" चाहते हैं। PHP में सिंगलटन पैटर्न जल्द ही खत्म हो जाएगा।

Answer 5

मुझे लगता है कि बेहतर अपरिवर्तनीय डेटाबेस क्लास बनाना होगा जो डेटाबेस.एफपी पर तुरंत अपने आप को इंस्टाल कर देगा और फिर इसे user.php पर शामिल करें। फिर हर बार जब आप कोई फ़ंक्शन बनाते हैं जिसे डेटाबेस की आवश्यकता होती है, तो आप डेटाबेस ऑब्जेक्ट को वैश्वीकृत करते हैं।

इसे जांचें। databse.php

<?php 
require_once ('includes/config.php'); 

class MysqlDb{ 
public $connection; 
private $last_query; 
private $magic_quotes_active; 
private $real_escape_string_exists; 


public function __construct() { 
    $this->open_connection(); 
    $this->magic_quotes_active = get_magic_quotes_gpc(); 
$this->real_escape_string_exists = function_exists("mysql_real_escape_string"); 
} 

public function open_connection() { 
    $this->connection = mysql_connect(DBHOST,DBUSER,DBPASS); 
    if(!$this->connection){ 
     die("Could not Connect ".mysql_error()); 
    }else{ 
     $db = mysql_select_db(DB, $this->connection); 
    } 
} 

public function close_connection(){ 
    if(isset($this->connection)){ 
     mysql_close($this->connection); 
     unset($this->connection); 
    } 
} 

public function query($sql){ 
    $this->last_query = $sql; 
    $results   = mysql_query($sql, $this->connection); 
    $this->comfirm_query($results); 
    return $results; 
} 

private function comfirm_query($results){ 
    if(!$results){ 
     $output  = "Query Failed " .mysql_error()."<br />"; 
     $output .= "Last Query: " . $this->last_query; 
     die($output); 
    } 
} 

public function escape_value($value){ 

if($this->real_escape_string_exists) { 
    if($this->magic_quotes_active) { $value = stripslashes($value); } 
    $value = mysql_real_escape_string($value); 
} else { 
    if(!$this->magic_quotes_active) { $value = addslashes($value); } 
} 
return $value; 
} 

public function fetch_array($results){ 
    return mysql_fetch_array($results);   
} 

public function num_row($results){ 
    return mysql_num_rows($results); 
} 

public function insert_id(){ 
    return mysql_insert_id($this->connection); 
} 

public function affected_row(){ 
    return mysql_affected_rows(); 
} 
} 
$database = new MysqlDb(); 

?> 

यहाँ

user.php

<?php 
require_once ('includes/database.php'); 

class User { 

public $id; 
public $fName; 
public $lName; 
Public $userName; 
public $password; 
public $email; 
public $acess; 

public static function find_all(){ 
    global $database; 
    return self::find_by_sql("SELECT * FROM users");  
} 

public static function find_by_id($id=0){ 
    global $database; 
    $results_array = self::find_by_sql("SELECT * FROM users where id={$id}"); 
    return !empty($results_array)? array_shift($results_array) : false; 
} 

public static function find_by_sql($sql){ 
    global $database; 
    $results = $database -> query($sql); 
    $object_array = array(); 
    while($row = $database -> fetch_array($results)){ 
     $object_array[] = self::instantiate($row); 
    } 
    return $object_array; 
} 

public static function instantiate($row){ 
    $user = new self; 
    foreach($row as $attribute => $value){ 
     if($user -> has_attribute($attribute)){ 
      $user -> $attribute = $value; 
     } 
    } 
    return $user; 
} 

private function has_attribute($attribute){ 
    $object_vars = get_object_vars($this); 
    return array_key_exists($attribute, $object_vars); 

} 
} 

?> 

Answer 6

है यहाँ एक समाधान पीडीओ का उपयोग कर रहा है।

<?php 
    class Database { 
     private static $dbh; 

     public static function connect() { 
      $host = "mysql:dbname=YOUR_DB_NAME;host=YOUR_DB_SERVER"; 
      $username = "YOUR_USERNAME"; 
      $password = "YOUR_PASSWORD"; 
      try { 
       self::$dbh = new PDO($host, $username, $password); 
       self::$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT); 
       self::$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING); 
       self::$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
      } catch(PDOException $e){ 
       $error_message = $e->getMessage(); 
       exit(); 
      } 
      return self::$dbh; 
     } 
    } 

    class MYObject { 
     public static $dbh = null; 

     public function __construct(PDO $db = null) { 
      if($db === null){ 
       $this->dbh = Database::connect(); 
      } else { 
       $this->dbh = $db; 
      } 
     } 
    } 

    class User extends myObject { 
     public function __construct($id = null, PDO $db = null) { 
      if($db === null){ 
       parent::__construct(); 
      } else { 
       parent::__construct($db); 
      } 

      if($id !== null){ 
       return $this->select($id); 
      } 
     } 

     public function select($id) { 
      $retVal =false; 
      try { 
       $stmt = $this->dbh->prepare("SELECT..."); 
       $stmt->execute(); 

       if($stmt->rowCount()==1){ 
        $row = $stmt->fetchAll(PDO::FETCH_ASSOC); 
        $retVal =json_encode($row); 
       } 
      } catch (PDOException $e) { 
       $error_message = $e->getMessage(); 
       exit(); 
      } 
      return $retVal; 
     } 
    } 
?>