Question

Supongamos que tengo una interface:

<?php

interface ActiveRecord
{
    public function save();
    public function update();
    public function delete();
    public function find($id);
    public function all();
}

Y una clase que lo implementa:

<?php

abstract class ActiveRecordImpl implements ActiveRecord
{

    public function save()
    {

    }

    public function update()
    {

    }

    public function delete()
    {

    }

    public function find($id)
    {

    }

    public function all()
    {

    }

}

Además dos clases: Customer y User (con sus get y set) que heredan de Active Record.

Bien, supongamos que el método save() de ActiveRecord necesita guardar un objeto en la BD de la siguiente manera:

<?php

public function save()
{
    $caller = REFERENCIA_AL_OBJETO_LLAMANTE;
    $callerClass = getClass($caller); // 'Customer' o 'User'

    // obtiene el servicio dinámicamente, de acuerdo al objeto llamante
    $service = ServiceFactory::create($callerClass);

    // le envía el objeto llamante al servicio Customer para que
    // lo guarde en la BD
    $service->save($caller);
}

El método save() obtiene una referencia al método que lo llamó (que puede ser un objeto tipo Customer o User), y obtiene la clase del objeto llamante para poder crear su servicio respectivo. Posteriormente, el servicio guarda el objeto por medio del método save()

La clase ServiceFactory solo crea y devuelve un servicio para el tipo de clase indicado:

<?php

public static function create($class)
{
    switch ($class) {
        case 'Customer':
            return new CustomerService();

        case 'User':
            return new UserService();
    }
}

Y los servicios de 'Customer' y 'User' hacen uso de sus DAOs respectivos:

<?php

class CustomerService
{
    public function save(Customer $customer)
    {
        new CustomerDAO()->save($customer);
    }
}

<?php

class UserService
{
    public function create(User $user)
    {
        new UserDAO()->save($user);
    }
}

Ahora, para guardar un objeto 'Customer' y 'User' se haría lo siguiente:

<?php

$customer = new Customer();
$customer->username = $username;
$customer->email = $email;
$customer->password = $password;
$customer->dni = $dni;
$customer->address = $address;

$user = new User();
$user->username = $username;
$user->email = $email;
$user->password = $password;

¿Es ésto posible? Si es es así, ¿cómo podría obtener la referencia del objeto llamante?

Answer 1

Y dónde está el "objeto llamante" o "llamador" en este código???

Para el caso:

$user = new User();
$user->username = $username;
$user->email = $email;
$user->password = $password;

asumiendo que luego harás

$user->save();

para guardarlo, el que ejecuta los métodos, ya seam propios o por herencia es $user y no otro objeto que lo llama.

bastaría con hacer:

$caller = get_class($this);

Igual, me pierdo un poco porque en tu código ni save() ni create() aparecen como métodos de ninguna clase.. incluso en create() esás esperando que la clase sea un string con el nombre, cuando podrías pasar directamente un Objeto y preguntarle de qué clase es.

Tampoco me queda claro el momento de instanciación de los servicios, es decir, quiés en el que llama a create(), cuándo lo llama, y si el factory es parte del DAO por composición o si es solo usado por un método de las clases concretas.

Si la llamada fuese a un método de otro objeto que no es parte de una composición o agregación, podrías simplemente hacer la llamada pasando al propio objeto como mensaje, porque tu código:

public function save() {
    $caller = REFERENCIA_AL_OBJETO_LLAMANTE;
    $callerClass = getClass($caller); // 'Customer' o 'User'
    // obtiene el servicio dinámicamente, de acuerdo al objeto llamante
    $service = ServiceFactory::create($callerClass);
    // le envía el objeto llamante al servicio Customer para que
    // lo guarde en la BD
    $service->save($caller);
}

lo que está enviado a save() es un string con un nombre de clase del que no podrás acceder a los atributos del objeto instanciado.

Tal vez sea el caso de que estés queriendo escribir un DAO sin haber usado antes 4 o 5... nunca es buena estrategia de programación hacer abstracciones de alto nivel sin antes haberse ensuciado mucho las manos con código concreto.

Respecto de la persistencia, un profesor de un posgrado de Ingeniería del Software que hice decía que DAO era la sigla de "Desde Ahora Olvídenlos". ;-)

Comparado con un mapeador Objeto/Relacional que haga persistencia no invasiva y por alcance, los DAO son solo un conjunto de malas prácticas y violaciones al paradigma de la POO :-( Puede que parezca que se usen mucho, como el goto para citar un ejemplo famoso de la generación anterior, pero eso no significa que haya que usarlos.

Si tenés un rato probá este ORM para PHP bajo Licencia GPL: verás que cuando escribas las Clases que soporten al Modelo, no habrá ni una línea de código que tenga que ver con la persistencia: será Modelo puro.

Saludos cordiales!