Usando una clase de base de datos en mi clase de usuario

Question

En mi proyecto tengo una clase de base de datos que utilizo para manejar todas las cosas de MySQL. Se conecta a una base de datos, ejecuta consultas, detecta errores y cierra la conexión.

Ahora necesito crear un área de miembros en mi sitio, y yo iba a crear una clase de usuarios que manejaría el registro, el inicio de sesión, la contraseña/cambios de nombre de usuario/restablecimientos y el cierre de sesión. En esta clase de usuarios necesito usar MySQL por razones obvias ... para lo que fue creada mi clase de base de datos.

Pero estoy confundido en cuanto a cómo usaría mi clase de base de datos en mi clase de usuarios. ¿Me gustaría crear un nuevo objeto de base de datos para mi clase de usuario y luego cerrarlo cada vez que se complete un método en esa clase? O de alguna manera hago una clase de base de datos 'global' que se puede usar en todo el script (si es el caso, necesito ayuda con eso, no tengo idea de qué hacer allí).

Gracias por cualquier comentario que pueda dar. yo.

Answer 1

Dado que está utilizando la base de datos como un objeto, ¿por qué no simplemente agrega métodos al objeto que su "clase de usuarios" puede emplear para encargarse de lo que necesita hacer? La clase de usuarios puede contener un puntero a la clase de la base de datos. La clase de base de datos protegerá su base de datos y garantizará que la clase de usuarios la esté utilizando adecuadamente.

Answer 2

Como dijo, ponga todas sus funciones en la clase de la base de datos y use el objeto de la base de datos para acceder a esas funciones desde su clase de usuario. Este debería ser el mejor método en su caso. Ej:
global $database;
userclassvar = $database->doSomething();

Answer 3

Lo que me gusta hacer es la clase base de datos con la Singleton pattern en mente. De esta forma, si ya tiene un objeto de base de datos, simplemente lo recupera, de lo contrario crea uno nuevo. Por ejemplo:

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(); 
    } 

} 

Y ahora se puede utilizar $_link propiedad User 's para hacer las funciones de base de datos, como $this->_link->query(...). No necesariamente tiene que poner el Db::getLink() en el constructor si su clase no tiene que interactuar mucho con la base de datos.

Answer 4

Proceso simple de 3 pasos. 1/Cree un objeto de base de datos. 2/Déle a su constructor de clase de usuario. 3/Úselo en los métodos de usuario.

Pequeño ejemplo.

Archivo Database.class.php:

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

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

En 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"'); 
    } 
} 

Ahora, en userManager.php por ejemplo:

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

Si quiere el actual nombre de moda de esta antigua técnica, google "Dependency Injection". El patrón de Singleton en php se desvanecerá pronto.

Answer 5

Creo que el mejor enfoque sería crear la clase de base de datos que se instale inmediatamente por sí misma en una base de datos.php y luego incluirla en user.php. luego, cada vez que creas una función que necesita una base de datos, globalizas el objeto de la base de datos.

Mira esto. 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(); 

?> 

aquí es la 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

Aquí es una solución con DOP.

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