Novo padrão de projeto: SDAO (Super Data Access Object)

Natal DevMedia: Assine hoje e ganhe 3 meses gr�tis

Problema:
Quero que meu c�digo interfira em todas as opera��es com o banco, para que tenha controle total do fluxo de informa��es.
No DAO convencional, a partir do Value Object a classe faz interm�dio da rela��o Usu�rio => C�digo => Banco, em outras palavras, a partir dos setters, o fluxo de informa��es que o usu�rio envia para o banco pode ser manipulado de forma centralizada antes de ser inserido.
O problema � que os getters do DAO convencional s� retornam o que o usu�rio inseriu, ou seja, C�digo <= Usu�rio, sem nenhuma rela��o com os dados que de fato est�o no banco de dados.

** Os exemplos ser�o em PHP 5.3.x **

Exemplo:

<?php
class UserVO {
    private $usuario, $senha, $nome_completo;

    public function setSenha( $senha )
    {
        $this->senha = $senha; //aqui h� uma interfer�ncia entre o que o usu�rio coloca para $senha e o que � armazenado em $this->senha
    }

    //... Outros setters ...

    public function getSenha( )
    {
        return $this->senha; // aqui retorna basicamente o que foi armazenado em $this->senha, e n�o o que foi de fato armazenado no BANCO DE DADOS
    }

    //... Outros getters ...
}
?>

Mas a� voc� me diz: Jota, tudo que eu j� vi at� hoje com o padr�o DAO/VO acabava em "[query] WHERE senha = $instancia->getSenha()", que no fim das contas torna o que foi armazenado no banco exatamente o valor de $this->senha, logo uma outra camada para lidar com esses dados seria in�til, � s� manipular o UserVO::getSenha(), n�o precisa de outra classe para isso.
A� eu at� concordo com voc�! Mas isso s� ocorre enquanto a classe UserVO estiver instanciada e a senha setada. Se em algum outro lugar eu quiser resgatar os dados do banco para mostrar ao usu�rio, n�o terei controle para manipular a rela��o Banco de Dados => Usu�rio, e � agora que entra o diferencial do SDAO: Ele transforma o Banco de Dados => Usu�rio em Banco de Dados => C�digo => Usu�rio, dessa forma o programador tem total controle para manipular, se quiser, n�o s� o fluxo de dados para setar valores e inserir no BD, mas tamb�m o fluxo de dados no resgate de valores de forma criteriosa ou n�o.
Mas voc�, insistente e ainda sem entender direito, faz uma r�plica: Mas Jota! Manipular dados resgatados do BD pode ser feito na forma procedural quando estiver aplicando as classes que criou!
Ent�o eu nem te respondo direito... No procedural, o m�nimo poss�vel. Centralize tudo. Se quiser mudar o crit�rio no resgate de dados, com SDAO voc� muda apenas os getters de uma classe, enquanto se fizesse em procedural ia ter que alterar todos os lugares em que resgatou dados.

Enfim, o SDAO � para ter total controle do fluxo de dados entre o que � mostrado e o que � inserido, e de forma persistente. Pense numa situa��o em que o usu�rio setou para um campo o valor VAR1, foi armazenado VAR2 no BD e � necess�rio resgatar VAR1 de novo quando for acessado esse valor (ou at� uma gen�rica VAR3). Para isso existe o SDAO.

Como implementar?
Para implementar o SDAO, s�o adicionadas duas finas camadas ao DAO do convencional DAO/VO. Uma para lidar com as altera��es no BD e outra para lidar com o resgate de dados.
A conven��o de nomes � DBG para a camada de resgate de informa��es (DataBase Getter) e DBS para a de altera��es (DataBase Setter).
Mas elas s�o s� subdivis�es, unidas na classe SDAO (UserSDAO, por exemplo), que serve como Factory (ver Factory Pattern) para selecionar como a classe vai trabalhar.

Exemplo:

Vamos supor que queremos que o usu�rio entre com uma senha, ela seja mascarada pelo script, inserida ainda mascarada no Banco de Dados e, na hora de resgatar, a voltamos ao est�gio natural para comparar com a senha inserida pelo usu�rio.
(Obs.: � somente um exemplo, pode-se atingir o mesmo objetivo mascarando o que o usu�rio inseriu e comparando com a do BD, mas n�o vem ao caso)

Cria-se, primeiro, uma classe Value Object (nesse caso n�o estou aproveitando o princ�pio central que ela tem da imutabilidade, mas ainda assim � muito importante):

<?php
class UserVO { // transforma $senha em $senha1 (algo diferente de $senha) nos setters e retorna, nos getters, a $senha1 (ainda mascarada)
    private $id, $usuario, $senha, $nome_completo;

    public function setSenha( $senha )
    {
        $this->senha = mascarar($senha); //aqui h� uma interfer�ncia entre o que o usu�rio coloca para $senha e o que � armazenado em $this->senha
    }

    //... Outros setters ...

    public function getSenha( )
    {
        return $this->senha; // aqui retorna basicamente o que foi armazenado em $this->senha, e n�o o que foi de fato armazenado no BANCO DE DADOS
    }

    //... Outros getters ...
}
?>

Agora criaremos a camada que intermediar� a rela��o Usu�rio => Banco de Dados, ou seja, as inser��es/altera��es/dele��es.

<?php
class UserDBS // usuario DataBaseSetter -> classe para lidar com inser��es no BD || insere $senha1 definidas nos getters de UsuarioVO
{             // para sumarizar, colocaremos aqui s� a parte de inser��o
    private $user, $dealer;

    public function __construct(UserVO $user )
    {
        $this->dealer = new Connection();
        $this->user = $user;
    }
    public function registrar()
    {
        $sql = "INSERT INTO usuarios(nome, senha, nome_completo) VALUES (:nome, :senha, :nome_completo)";
        $sth = $this->dealer->prepare( $sql );
        $sth->bindParam(":nome", $this->user->getNome(), PDO::PARAM_STR);
        $sth->bindParam(":senha", $this->user->getSenha(), PDO::PARAM_STR);
        $sth->bindParam(":nomefunc", $this->user->getNomeCompleto(), PDO::PARAM_STR);
        if ( $sth->execute() )
        {
            return true;
        } else
        {
            throw new Exception("Houve algum erro na hora de cadastrar o usu�rio.");
        }
    }
}
?>

Nesse momento, criaremos a camada que intermediar� a rela��o Banco de Dados => Usu�rio, ou seja, o DBG:

<?php
class UserDBG extends UserDBS //Usuario DataBaseGetter -> pegar dados do BD || retorna $senha1 como $senha, atrav�s dos getters
{ // estende UserDBS somente para servir de 'ponte' para que UsuarioSDAO estenda UserDBG e UsuarioDBS, pelo fato do PHP nao permitir que uma classe estenda outras duas
// essa estens�o s� � necess�ria para que a Factory UserSDAO possa utilizar o m�todo estatico UserDBG::listar()
    private $id, $nome, $nome_completo, $senha, $dealer, $user;

    public function __construct(UserVO $user)
    {
        $this->dealer = new Connection();
        $this->user = $user;
    }

    public function resgatar()
    {
        $id = (int) $this->user->getId();
        $sth = $this->dealer->prepare("SELECT * FROM `usuarios` WHERE id = :id");
        $sth->bindParam(":id", $id, PDO::PARAM_INT);
        if ( $sth->execute() )
        {
            $vals = $sth->fetchAll(PDO::FETCH_ASSOC);
            $vals = $vals[0];
            $this->id = $vals['id'];
            $this->nome = $vals['nome'];
            $this->nome_func = $vals['nome_completo'];
            $this->senha = $vals['senha'];
            return array("id" => $this->getId(), "nome" => $this->getNome(), "nome_func" => $this->getNomeFunc(), "senha" => $this->getSenha(), "nivel" => $this->getNivel());
        } else
        {
            throw new Exception("Houve um erro durante a pesquisa de usu�rios.");
        }
    }

    public static function listar() // est�tica e desvinculada da inst�ncia pelo fato de n�o utilizar nada do UserVO, pois n�o � criteriosa,
    {                // retorna todos os usu�rios sem distin��o.
        $sql = "SELECT id FROM usuarios";
        if ( !isset( self::$dealer ) )
        {
            $dealer = new Connection();
        }
        else
        {
            $dealer = &self::$dealer;
        }
        $sth = $dealer->prepare( $sql );
        if( $sth->execute() )
        {
            $res = array();
            $vals = $sth->fetchAll(PDO::FETCH_ASSOC);
            foreach( $vals as $key)
            {
                $vo = new UsuarioVO();
                $vo->setId( $key['id'] );
                $a = new UserDBG( $vo );
                $res[] = $a->resgatar();
            }
            return $res;
        }
        else
        {
            throw new Exception( "Houve um erro durante a listagem de usu�rios." );
        }
    }

    // ATEN��O!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // Os getters daqui s�o a grande diferen�a do SDAO, e s�o totalmente diferentes dos getters de UserVO. Mas por qu�?
    // Porque os getters de UserVO retornam a vari�vel do fluxo Usu�rio => Banco de Dados, me dando liberdade para manipular,
    // mas os getters de UserDBG permitem a manipula��o do fluxo Banco de Dados => Usu�rio, modificando, se for da vontade do programador, o valor         // resgatado do valor retornado.
    // No exemplo, eu n�o estou modificando, mas n�o � sobre isso que se trata. N�o se trata do fato de 'VOU FAZER' ou 'N�O VOU FAZER', e sim da
    // tranquilidade que 'POSSO FAZER SE EU QUISER' lhe proporciona.

    public function getId( )
    {
        return $this->id;
    }

    public function getNome( )
    {
        return $this->nome;
    }

    public function getSenha( )
    {
        return desmascarar($this->senha); // Como dito.s
    }

    public function getNomeCompleto( )
    {
        return $this->nome_completo;
    }

}
?>

Aqui, criamos a Factory UserSDAO:

<?php
class UserSDAO extends UserDBG // para UserSDAO poder utilizar os m�todos desvinculados da inst�ncia (static) para si mesmo
{
    public static function setModo( $mode, UserVO $vo )
    {
        $mode = strtolower( $mode ); // tornar case insensitive
        switch ( $mode )
        {
            case "getter": // caso queira interferir na cama de resgate de dados
                return new UserDBG($vo);
            break;
            case "setter": // caso queira interferir na cama de inser��o/altera��o/dele��o
                return new UserDBS($vo);
            break;
            default:
                throw new Exception( "Houve um erro durante a defini��o do modo DAO." );
            break;
        }
    }
}

// Exemplo de uso:

//Procurando algum usu�rio pelo ID:
///////////////////////////////////////////////////

$vo = new UserVO();
$vo->setId(7);
$a = UserSDAO::setModo('getter', $vo);
var_dump($a->resgatar());

///////////////////////////////////////////////////

// Listando todos os usu�rios (justificando os extends):
////////////////////////////////////////////////////////////

var_dump(UserSDAO::listar());

////////////////////////////////////////////////////////////

// Cadastrando usu�rios:
////////////////////////////////////////////////////////////

$vo = new UserVO();
$vo->setNome("Jota");
$vo->setSenha(123);
$vo->setNomeCompleto("Jota Vicente Romualdo J�nior");
$a = UserSDAO::setModo('setter', $vo);
$a->registrar();

////////////////////////////////////////////////////////////
?>

Ent�o, a� est� a pattern que eu idealizei. Espero que gostem e implementem! Qualquer d�vida ou dica, mande para jotavrj@gmail.com.

Obrigado!