Data Mapper... ORM

Para a primeira pergunta eu ACHO que da forma como fez, você misturou parte do Mapper com parte do Active Record.

Dada a complexidade do assunto e carência de bons materiais posso estar enganado, mas imagino que o correto seria algo como:

class Person {

 private $name;

 public function setName( $name ) {

 $this -> name = trim( $name );

 return $this;
 }

 public function getName() {
 return $this -> name;
 }
}

class PersonMapper {

 private $entity;

 public function __construct( $entity ) {
 $this -> entity = $entity;
 }

 public function save() {

 var_dump( $this -> entity );
 }
}

$p = new Person;

$p -> setName( 'Bruno Augusto' );

$pm = new PersonMapper( $p );

$pm -> save();

Saída:

object(Person)[1]
private 'name' => string 'Bruno Augusto' (length=13)

Eu quando implementei achei isso redundante pois tinha de repetir os métodos save() e cia em todos os Mappers, então criei um única classe que operaria qualquer tabela.

O código ficou bem mais complexo pois envolveu interfaces e classes abstratas, mas pelo menos evito tal repetição (DRY) e ainda anulo a necessidade de o Mapper conhecer o objeto mapeado (setters e getters).

Para a segunda pergunta eu diria que nesse seu código (e nem nessa adaptação minha) o Lazy Loading não se aplica porque as classes se conhecem, mesmo que não devessem.

Veja, o PersonMapper sabe que Person tem um nome que deve ser setado e que para isso ele dispõe do método Person::setName().

Já no exemplo que comentei sobre a minha implementação, como minha classe que manipula as entidades não sabe qual entidade está sendo designada para ela trabalhar, tenho um método de interface que informa quais são os campos mapeados nessa/dessa tabela.

Mais ou menos assim:

interface Table {

 public function getFields();
}

class MyTable implements Table {

 public function getFields() {

 // Do something
 }
}

class Manager {

 private $table;

 public function __construct( Table $table ) {
 $this -> table = $table;
 }

 public function update() {

 $fields = $this -> table -> getFields();
 }
}

Eu atraso a listagem dos campos ao momento em eles são realmente necessários e através da interface, eu garanto ao meu gerenciador que todas as tabelas possuem tal método.

@Bruno Augusto

Primeiramente obrigado por responder. Eu após ter escrito o post fui pesquisar um pouco mais, logo me deparei com o que você disse que eu misturei o Data Mapper com o Active Record.

Mas e ai, como o Data Mapper trabalho com as relações ( n-n, 1-n )? Pelo o que imaginei é no puro SQL, ou o PersonMapper deve conhecer o AccountMapper ( caso exista uma relação entre Person e Account ) ?

;)

Essa resposta eu vou ficar te devendo.

Justamente pela ausência de material decente, minha implementação carece do suporte à JOIN's. Todo e qualquer relacionamento é codificado na unha.

>
Essa resposta eu vou ficar te devendo.

Justamente pela ausência de material decente, minha implementação carece do suporte à JOIN's. Todo e qualquer relacionamento é codificado na unha.

:) estou pesquisando bastante sobre o assunto e achei um post bem bacana:

http://blog.tekerson.com/2008/12/17/data-mapper-pattern-in-php/

A UnitOfWork to track which objects need saving, deleting and to co-ordinate roll backs on error, or the order of persistence to satisfy foreign key constraints.

Ele fala desse pattern Unit of Work, que eu desconheço. :/

@edit

Parando para pensar aqui, a real diferença entre o Active Record e o Data Mapper é só o desacoplamento do DO. Após criar um Mapper podemos herdar de um Mapper_Base no qual faz todo tratamento de relações. Então fica bem próximo do Active Record. Mas mesmo assim o nível de complexidade não muda muito, continua sendo difícil implementar :)