Object Oriented en la cruda realidad

[jahepi]

Hola drieran !

Aparte del ejemplo de Ronruby te pongo otro ejemplo de implementación de como puedes separar tu capa de acceso a datos con la capa de dominio.

Primero en tu capa de acceso a datos haremos una clase persona que se encargue de consultar la información de algún manejador de base de datos, llamaremos a esta clase "PersonaPersistencia":

Código php:

class PersonaPersistencia
{
    private $_db;
    
    public function __construct() {
        $this->_db = new DB();
    }
    
    public function obtenerPorId($id) {
        return $this->_db->ejecutarSQL("SELECT * FROM personas WHERE id = $id");
    }
    
    public function obtenerTodos() {
        return $this->_db->ejecutarSQL("SELECT * FROM personas");
    }
    
    public function insertar($nombre) {
        return $this->_db->ejecutarSQL("INSERT...");
    }
    
    public function actualizar($id, $nombre) {
        return $this->_db->ejecutarSQL("UPDATE...");
    }
}
 

Como puedes ver tiene un atributo privado "db", que es un objeto de la clase DB que se encargaría de abstraer el acceso a los diferentes manejadores de base de datos, por ejemplo la clase DB podría hacer uso de PDO para conectarte a MySql, SQL Server, entre otros.
También puedes observar cada unos de los métodos públicos para consultar, insertar y actualizar la información con la ayuda de la instancia db.

La implementación de la clase DB no la he puesto para no complicarnos más de la cuenta, pero estoy seguro que captarás la idea.

Ahora si pasemos a ver la clase Persona, que contendrá cada uno de los atributos como id, nombre y edad, esta hará uso de la clase de persistencia para consultar, insertar y actualizar los datos necesarios.

Código php:

class Persona {
    
    private $_id;
    private $_nombre;
    
    private static $_persistencia = new PersonaPersistencia();
    
    public function __construct() {
    }
    
    public static function obtener($id) {
        $dato = self::$_persistencia->obtenerPorId($id);
        $persona = new Persona();
        $persona->_id = $datos['id'];
        $persona->_nombre = $datos['nombre'];
        return $persona;
    }
    
    public static function obtenerTodos() {
        $personas = array()
        $datos = self::$_persistencia->obtenerTodos();
        foreach($datos as $dato) {
            $persona = new Persona();
            $persona->_id = $datos['id'];
            $persona->_nombre = $datos['nombre'];
            $personas[] = $persona;
        }
        return $personas;
    }
    
    public function guardar() {
        if($this->_id == 0) {
            $this->_id = self::$_persistencia->insertar($this->_nombre);
        } else {
            self::$_persistencia->actualizar($this->_id, $this->_nombre);
        }
    }
    
    public function setNombre($nombre) {
        $this->_nombre = $nombre;
    }
    
    public function getNombre() {
        return $this->_nombre;
    }
    
    public function getId() {
        return $this->_id;
    }
}
 

Hemos agregado 2 atributos privados, lo que es el id y el nombre, y otro atributo estático que es la instancia de persistencia que es responsable de consultar los datos, el porque es estático este atributo es debido a que se usará tanto en los métodos de instancia como en los métodos de clase y también para evitar que se cree una nueva instancia de persistencia cada ves creemos una persona, veamos el porque:

Tenemos 2 métodos estáticos que son obtener y obtenerTodos que hacen uso de la instancia de persistencia tanto para crear una instancia de una persona de acuerdo al id pasado como parámetro como otro para obtener un arreglo con todas la personas existentes.
Son estáticos porque no es necesario crear una instancia de persona para poder hacer uso de ellos.

Por ejemplo podriamos hacer esto para obtener una persona o el listado completo:

Código php:

// Obtenemos la persona con id 1
$persona = Persona::obtener(1);
 
// Obtenemos todo el listado de personas
$personas = Persona::obtenerTodos();
 

Ahora los métodos de instancia como guardar, se encargaría de mandar la orden ya sea de actualizar o insertar la persona con la ayuda de la persistencia, verificaremos si el id es 0, quiere decir que es nuevo y lo insertaremos, actualizando el atributo id de persona al finalizar la inserción o actualizar si el id está definido.

También tenemos los métodos accesores como setNombre y getNombre para poder modificar y consultar los atributos de persona.

Ahora por ejemplo podriamos crear una instancia de persona de esta forma y guardarla en la base de datos:

Código php:

$persona = new Persona();
$persona->setNombre("Juan");
$persona->guardar();
 

O podriamos obtener alguna persona y modificar su nombre:

Código php:

$persona = Persona::obtener(1);
$persona->setNombre("Juan");
$persona->guardar();
 

No sé si el código tenga errores, no lo pude probar, pero a grandes rasgos me parece una implementación bastante clara.

Espero que te sea de ayuda.

Un saludo y suerte !