¿Cuál es la manera OO de refactorizar estas dos clases muy similares en PHP?

Question

tengo una clase como la siguiente:

class DreamsImagesStore 
{ 
    public $table = 'dreams_images'; 

    public function insertNewDreamImage($dream_id, $pid) 
    { 
    try { 
     $values = array($dream_id, $pid); 
     $sth = $this->dbh->prepare("INSERT INTO {$this->table} 
           (dream_id, pid) 
           VALUES (?, ?)"); 
     if($sth->execute($values)) { 
     return true; 
     } 
    } catch(PDOException $e) { 
     $this->errorLogger($e); 
    } 
    } 
... 
} 

Voy a ser la implementación de una nueva clase llamada InterestsImagesStore en el que las únicas diferencias entre estas clases será el valor de $table, $dream_id será $interest_id y dream_id en SQL será interest_id.

Sé que hay una mejor manera de hacer esto, y estaré implementando clases similares en el futuro que tengan tan pequeñas diferencias.

¿Cuál es la mejor forma orientada a objetos para refactorizar mi código para evitar la duplicación y aumentar el mantenimiento?

Answer 1

crear una clase ImagesStore de base:

class ImagesStore 
{ 
    // See comments about accessors below. 
    private $table; 
    private $id_column; 

    public function insertImage($id, $pid) { 
    try { 
     $values = array($id, $pid); 
     $table = $this->getTable(); 
     $id_column = $this->getIdColumn(); 
     $sth = $this->dbh->prepare("INSERT INTO {$table} ($id_column, pid) VALUES (?, ?)"); 
     if ($sth->execute($values)) { 
     return true; 
     } 
    } 
    catch (PDOException $e) { 
     $this->errorLogger($e); 
    } 
    } 

    protected function __construct($table, $id_column) { 
    $this->table = $table; 
    $this->id_column = $id_column; 
    } 

    // These accessors are only required if derived classes need access 
    // to $table and $id_column. Declaring the fields "private" and providing 
    // "protected" getters like this prevents the derived classes from 
    // modifying these values which might be a desirable property of these 
    // fields. 
    protected function getTable() {return $this->table;} 
    protected function getIdColumn() {return $this->id_column;} 

    // More implementation here... 
    // Initialize $dbh to something etc. 
    // Provide "errorLogger" method etc. 
} 

y crear DreamsImagesStore y InterestsImagesStore especializaciones:

class DreamsImagesStore extends ImagesStore { 
    public function __construct() { 
    parent::__construct('dreams_images', 'dream_id'); 
    } 
} 

class InterestsImagesStore extends ImagesStore { 
    public function __construct() { 
    parent::__construct('interests_images', 'interest_id'); 
    } 
} 

el método original insertNewDreamImage puede cambiar el nombre a insertImage ya que es realmente más general que el original nombre sugiere

Tenga en cuenta que ImagesStore también se puede declarar abstract si desea evitar la instanciación directa de la misma.

Un enfoque alternativo que puede ser adoptada es la de no molestar a las clases derivadas de ImagesStore en absoluto y sólo una instancia directamente, haciendo que el __construct método public y decir que es como sigue:

$dreamsImagesStore = new ImagesStore("dreams_images", "dream_id"); 

Otro enfoque también podría ser para implementar un método de fábrica estático en ImagesStore.

Answer 2

utilizando la clase ImagesStore creado por Richard Cook, esto también podría ocurrir:

function FactoryLoadImageStore($imageStoreType) 
{ 
    switch($imageStoreType) 
    { 
     case "Interests": 
      return new ImageStore('interests_images', 'interest_id'); 
     case "Dreams": 
      return new ImageStore('dreams_images', 'dreams_id'); 
     default: 
      throw new Exception("ImageStore type $imageStoreType not found") 
; } 

} 

o incluso se podría conseguir más elegante y hacer algo como

function FactoryLoadImageStore($imageStoreType) 
{ 
    $tableName = $imageStoreType . 's_images'; 
    $idColumnName = $imageStoreType . 's_id'; 
    $tableExists = false; 
    $sql= "Show tables like '$tableName' "; 
    foreach ($this->dbh->query($sql) as $row) 
    { 
     if ($row['tableName'] == $tableName) 
     { 
      $tableExists = true; 
      break; 
     } 
    } 
    if(!$tableExists) 
    { 
     throw new Exception ("No matching table exists for the requested image store $imageStoreType"); 
    } 

    return new ImageStore($tableName, $idColumnName); 
} 

llamada de la siguiente manera

$dreamImageStore = ImageStore::FactoryLoadImageStore('dream');