Interfaces x Generics – Que tal um ORM Básico? Parte 9

Já conseguimos utilizar os métodos de inclusão, alteração e exclusão da classe TDaoUib, conforme pôde ser visto no último artigo.

Porém, você deve ter notado a dependência excessiva (forte acoplamento) existente para efetuar tais operações. Outro ponto importante a ser destacado é que, apesar de não ter sido notado tão claramente devido a utilização de apenas uma tabela, se em determinado momento decidirmos trocar de componente, ou seja, em vez do Uib optarmos pelo IBX, tudo que for relativo a TDaoUib teria que ser modificado para que fosse possível utilizar o novo componente.

Temos que mudar esse quadro o quanto antes, senão ficaremos engessados! E o que queremos é justamente o oposto, não é mesmo? 😉

Ajustes necessários em TDaoUib

Queremos abstrair (simplificar) o uso dos componentes de acesso de tal forma que lá na ponta, o usuário final (desenvolvedor que utilizará este código) terá o trabalho facilitado, bastando informar alguns dados básicos para que o código esteja pronto para uso. Para isso, devemos:

• Alterar o nome da variável FTransacao para FTransaction (como definimos o nome do database em inglês, vamos manter o padrão).
• Alterar a declaração do construtor para passar apenas o nome e local onde se encontra o banco de dados.
• Os objetos, FDatabase e FTransaction, serão criados no construtor, bem como suas configurações iniciais.

Segue código completo de DaoUib.pas:

[sourcecode language=”delphi”]
unit DaoUib;

interface

uses Base, Rtti, Atributos, uib, system.SysUtils, System.Classes;

type
TDaoUib = class(TInterfacedObject, IDaoBase)
private
// conexao com o banco de dados
FDatabase: TUIBDataBase;
FTransaction: TUIBTransaction;

// Este método configura os parâmetros da AQuery.
procedure ConfigParametro(AQuery: TuibQuery; AProp: TRttiProperty; ACampo: string; ATabela: TTabela);
procedure FechaQuery;

function ExecutaQuery: Integer;
public
//query para execução dos comandos crud
Qry : TUIBQuery;

constructor Create(ADatabaseName: string);

function Inserir(ATabela: TTabela): Integer;
function Salvar(ATabela: TTabela): Integer;
function Excluir(ATabela: TTabela): Integer;

function InTransaction: Boolean;
procedure StartTransaction;
procedure Commit;
procedure RollBack;
end;

implementation

{ TDaoUib }

uses Vcl.forms, dialogs, System.TypInfo;

constructor TDaoUib.Create(ADatabaseName: string);
begin
inherited Create;

FDatabase := TUIBDataBase.Create(Application);
//configurações iniciais da conexão
with FDatabase do
begin
DatabaseName := ADatabaseName;
Params.Add(‘sql_dialect=3’);
Params.Add(‘lc_ctype=ISO8859_1’);
Connected := True;
end;

FTransaction := TUIBTransaction.Create(Application);
//configurações iniciais da transacao
with FTransaction do
begin
Database := FDatabase;
DefaultAction := etmCommit;
end;

Qry := TUIBQuery.Create(Application);
Qry.DataBase := FDatabase;
Qry.Transaction := FTransaction;
end;

function TDaoUib.InTransaction: Boolean;
begin
Result := FTransaction.InTransaction;
end;

procedure TDaoUib.StartTransaction;
begin
FTransaction.StartTransaction;
end;

procedure TDaoUib.RollBack;
begin
FTransaction.RollBack;
end;

procedure TDaoUib.Commit;
begin
FTransaction.Commit;
end;

procedure TDaoUib.ConfigParametro(AQuery: TUIBQuery; AProp: TRttiProperty;
ACampo: string; ATabela: TTabela);
begin
with AQuery do
begin
case AProp.PropertyType.TypeKind of
tkInt64,
tkInteger:
begin
Params.ByNameAsInteger[ACampo] := AProp.GetValue(ATabela).AsInteger;
end;
tkChar,
tkString,
tkUString:
begin
Params.ByNameAsString[ACampo] := AProp.GetValue(ATabela).AsString;
end;
tkFloat:
begin
if CompareText(AProp.PropertyType.Name, ‘TDateTime’) = 0 then
Params.ByNameAsDateTime[ACampo] := AProp.GetValue(ATabela).AsType<TDateTime>
else
Params.ByNameAsCurrency[ACampo] := AProp.GetValue(ATabela).AsCurrency;
end;
tkVariant:
begin
Params.ByNameAsVariant[ACampo] := AProp.GetValue(ATabela).AsVariant;
end;
else
raise Exception.Create(‘Tipo de campo não conhecido: ‘ + AProp.PropertyType.ToString);
end;
end;
end;

procedure TDaoUib.FechaQuery;
begin
Qry.Close;
Qry.SQL.Clear;
end;

function TDaoUib.ExecutaQuery: Integer;
begin
with Qry do
begin
Prepare();
ExecSQL;
Result := RowsAffected;
end;
end;

function TDaoUib.Excluir(ATabela: TTabela): Integer;
var
Comando: TFuncReflexao;
begin
//crio uma variável do tipo TFuncReflexao – um método anônimo
Comando := function(ACampos: TCamposAnoni): Integer
var
Campo: string;
PropRtti: TRttiProperty;
begin
FechaQuery;
with Qry do
begin
sql.Add(‘Delete from ‘ + ACampos.NomeTabela);
sql.Add(‘Where’);

//percorrer todos os campos da chave primária
ACampos.Sep := ”;
for Campo in ACampos.PKs do
begin
sql.Add(ACampos.Sep+ Campo + ‘= :’ + Campo);
ACampos.Sep := ‘ and ‘;
// setando os parâmetros
for PropRtti in ACampos.TipoRtti.GetProperties do
if CompareText(PropRtti.Name, Campo) = 0 then
begin
ConfigParametro(Qry, PropRtti, Campo, ATabela);
end;
end;
end;
Result := ExecutaQuery;
end;

//reflection da tabela e execução da query preparada acima.
Result := ReflexaoSQL(ATabela, Comando);
end;

function TDaoUib.Inserir(ATabela: TTabela): Integer;
var
Comando: TFuncReflexao;
begin
Comando := function(ACampos: TCamposAnoni): Integer
var
Campo: string;
PropRtti: TRttiProperty;
begin
FechaQuery;
with Qry do
begin
sql.Add(‘Insert into ‘ + ACampos.NomeTabela);
sql.Add(‘(‘);

//campos da tabela
ACampos.Sep := ”;
for PropRtti in ACampos.TipoRtti.GetProperties do
begin
SQL.Add(ACampos.Sep + PropRtti.Name);
ACampos.Sep := ‘,’;
end;
sql.Add(‘)’);

//parâmetros
sql.Add(‘Values (‘);
ACampos.Sep := ”;
for PropRtti in ACampos.TipoRtti.GetProperties do
begin
SQL.Add(ACampos.Sep + ‘:’ + PropRtti.Name);
ACampos.Sep := ‘,’;
end;
sql.Add(‘)’);

//valor dos parâmetros
for PropRtti in ACampos.TipoRtti.GetProperties do
begin
Campo := PropRtti.Name;
ConfigParametro(Qry, PropRtti, Campo, ATabela);
end;
end;
Result := ExecutaQuery;
end;

//reflection da tabela e execução da query preparada acima.
Result := ReflexaoSQL(ATabela, Comando);
end;

function TDaoUib.Salvar(ATabela: TTabela): Integer;
var
Comando: TFuncReflexao;
begin
Comando := function(ACampos: TCamposAnoni): Integer
var
Campo: string;
PropRtti: TRttiProperty;
begin
FechaQuery;
with Qry do
begin
sql.Add(‘Update ‘ + ACampos.NomeTabela);
sql.Add(‘set’);

//campos da tabela
ACampos.Sep := ”;
for PropRtti in ACampos.TipoRtti.GetProperties do
begin
SQL.Add(ACampos.Sep + PropRtti.Name + ‘=:’+PropRtti.Name);
ACampos.Sep := ‘,’;
end;
sql.Add(‘where’);

//parâmetros da cláusula where
ACampos.Sep := ”;
for Campo in ACampos.PKs do
begin
sql.Add(ACampos.Sep+ Campo + ‘= :’ + Campo);
ACampos.Sep := ‘ and ‘;
end;

//valor dos parâmetros
for PropRtti in ACampos.TipoRtti.GetProperties do
begin
Campo := PropRtti.Name;
ConfigParametro(Qry, PropRtti, Campo, ATabela);
end;
end;
Result := ExecutaQuery;
end;

//reflection da tabela e execução da query preparada acima.
Result := ReflexaoSQL(ATabela, Comando);
end;

end.
[/sourcecode]Como a nossa classe já tem um objeto para conexão e um para a transação, não precisamos mais dos componentes UIB instanciados em nosso formulário principal, o frmMain:

Exclua UIBDatabase1 e UIBTransaction1.

Eu quero Generics, Eu quero Interfaces…

Eu irei propor dois modelos para você, caro leitor, ambos com um objetivo em comum: resolver o problema do forte acoplamento existente. O primeiro será baseado em Generics e o segundo em Interface + Singleton (Design Pattern). No final deste artigo irei pedir a sua opinião a respeito dos modelos apresentados. Portanto, continue lendo…

Modelo 1: Classe TDaoGenerico

Abra a unidade Base.pas e abaixo da interface IDaoBase, coloque:

[sourcecode language=”delphi”]
…
IDaoBase = interface
[‘{D06AAE8D-D5F7-47E7-BF11-E26687C11900}’]

function Inserir(ATabela: TTabela): Integer;
function Salvar(ATabela: TTabela): Integer;
function Excluir(ATabela: TTabela): Integer;

function InTransaction: Boolean;
procedure StartTransaction;
procedure Commit;
procedure RollBack;

end;

//DAO genérico
TDaoGenerico<T: IDaoBase> = class
private
FCon: T; //classe de conexao uib, ibx, …
procedure SetCon(const Value: T);
public
property Con: T read FCon write SetCon;
end;
…
[/sourcecode]Dê Ctrl+Sift+C para gerar o SetCon, que ficará com o seguinte código:

[sourcecode language=”delphi”]
procedure TDaoGenerico<T>.SetCon(const Value: T);
begin
FCon := Value;
end;
[/sourcecode]Pronto! Simples assim!

Agora, iremos inserir um datamodule em nosso projeto. Assim, tudo que for relativo a banco de dados faremos neste local.

Salve como udmPrin (Ctrl+S). No nome, coloque dmPrin:

Por fim, configure o auto-create forms (Ctrl+Shift+11) da seguinte forma:

O datamodule deve ser o primeiro.

Em public de dmPrin, crie uma variável do tipo IDaoBase e uma variável da nossa classe genérica:

[sourcecode language=”delphi”]
unit udmPrin;

interface

uses
System.SysUtils, System.Classes, uib, Base, DaoUib;

type
TdmPrin = class(TDataModule)
private
{ Private declarations }
public
{ Public declarations }
Conexao: IDaoBase;
Dao: TDaoGenerico<TDaoUib>;
end;
…
[/sourcecode]
No OnCreate, faça:

[sourcecode language=”delphi”]
procedure TdmPrin.DataModuleCreate(Sender: TObject);
begin
// configuração da nossa conexão – utilizando DaoUib
Conexao:= TDaoUib.Create(‘C:\Users\Luiz\Documents\RAD Studio\Projects\Persistencia\Bd\BANCOTESTE.FDB’);

// DAO genérico
Dao := TDaoGenerico<TDaoUib>.Create;
Dao.Con:= TDaoUib(Conexao);
end;
[/sourcecode]Analisando o código:

• Linha 4, o tipo de conexão é criado, que neste caso é da classe TDaoUib. Note que agora estou passando o caminho e nome do banco de dados no Create desta classe.
• Linha 7, criamos o nosso DAO genérico. Como estamos passando T como sendo TDaoUib, somente objetos derivados desta classe serão aceitos.
• Linha 8, setamos a propriedade Con com o objeto criado na Linha 4.

Com isso, evitaremos a dependência de algumas unidades durante o CRUD (Ah! Eu não esqueci do único método que está faltando:R – de Read. Veremos como recuperar[consultar] dados nos próximos artigos). Precisaremos apenas adicionar o datamodule e a classe que representa a tabela que estamos alterando. É bom lembrar que, por enquanto, temos apenas uma tabela chamada Teste. Nossa classe genérica recebe T do tipo IDaoBase e a propriedade Con será desse tipo. Vê-lo funcionando irá facilitar o entendimento.

Preparando o Teste

Vamos começar pelo formulário frmTesteAtributos: Como já testamos o botão Nome Tabela e Chave Primária, não há mais necessidade de tê-los neste formulário. Portanto, vamos excluí-los (exclua também os códigos destes botões):

Tire a unidade Atributos da cláusula uses deste formulário. Ficaremos apenas com os botões de inclusão, alteração e exclusão, conforme acima. Abaixo, vemos o código do botão inserir:

[sourcecode language=”delphi”]
procedure TfrmTesteAtributos.btnInserirClick(Sender: TObject);
var
ATab: TTeste;
Dao: IDaoBase;
Registros: Integer;
begin
ATab := TTeste.Create;
try
Dao := TDaoUib.Create(dmPrin.UIBDataBase1, dmPrin.UIBTransaction1);
with ATab do
begin
id := 1;
Estado := ‘MA’;
Descricao := ‘MARANHÃO’;
Habitantes := 6569683;
RendaPerCapta := 319;
end;
Registros := Dao.Inserir(ATab);
Memo1.Lines.Add(Format(‘Registro inserido: %d’, [Registros]));
Memo1.Lines.Add(Format(‘id: %d, nome: %s’,[ATab.Id, atab.Descricao]));
finally
ATab.Free;
end;
end;
[/sourcecode]Não precisamos mais do objeto Dao (linhas 4 e 9). Consequentemente, também não será mais necessário a unidade Base e nem tão pouco da unidade DaoUib na cláusula uses. Como resultado teremos uma menor dependência (acoplamento fraco). Teremos então, na cláusula uses (abaixo de implementation) apenas as unidades:

[sourcecode language=”delphi”]
implementation

{$R *.dfm}

uses
Teste, udmPrin;
[/sourcecode]Abaixo, código dos três botões. Note que já implementa o controle de transações.

[sourcecode language=”delphi”]
procedure TfrmTesteAtributos.btnInserirClick(Sender: TObject);
var
ATab: TTeste;
Registros: Integer;
begin
ATab := TTeste.Create;
try
with ATab do
begin
id := 1;
Estado := ‘MA’;
Descricao := ‘MARANHÃO’;
Habitantes := 6569683;
RendaPerCapta := 319;
end;
dmPrin.Dao.Con.StartTransaction;
try
Registros := dmPrin.Dao.Con.Inserir(ATab);

dmPrin.Dao.Con.Commit;

Memo1.Lines.Add(Format(‘Registro inserido: %d’, [Registros]));
Memo1.Lines.Add(Format(‘id: %d, nome: %s’,[ATab.Id, atab.Descricao]));
except
on E: Exception do
begin
dmPrin.Dao.Con.RollBack;
ShowMessage(‘Ocorreu um problema ao executar operação: ‘ + e.Message);
end;
end;
finally
ATab.Free;
end;
end;

procedure TfrmTesteAtributos.btnSalvarClick(Sender: TObject);
var
ATab: TTeste;
Registros: Integer;
begin
ATab := TTeste.Create;
try
with ATab do
begin
id := 1;
Estado := ‘MA’;
Data := Now;
Descricao := ‘MARANHÃO (ALTERADO)’;
Habitantes := 6569683;
RendaPerCapta := 319;
end;
dmPrin.Dao.Con.StartTransaction;
try
Registros := dmPrin.Dao.Con.Salvar(ATab);

dmPrin.Dao.Con.Commit;

Memo1.Lines.Add(Format(‘Registro inserido: %d’, [Registros]));
Memo1.Lines.Add(Format(‘id: %d, nome: %s’,[ATab.Id, atab.Descricao]));
except
on E: Exception do
begin
dmPrin.Dao.Con.RollBack;
ShowMessage(‘Ocorreu um problema ao executar operação: ‘ + e.Message);
end;
end;
finally
ATab.Free;
end;
end;

procedure TfrmTesteAtributos.btnExcluirClick(Sender: TObject);
var
ATab: TTeste;
Registros: Integer;
begin
ATab := TTeste.Create;
try
ATab.Id := 1;
dmPrin.Dao.Con.StartTransaction;
try
Registros := dmPrin.Dao.Con.Excluir(ATab);

dmPrin.Dao.Con.Commit;

Memo1.Lines.Add(Format(‘Registro excluido: %d’, [Registros]));
except
on E: Exception do
begin
dmPrin.Dao.Con.RollBack;
ShowMessage(‘Ocorreu um problema ao executar operação: ‘ + e.Message);
end;
end;
finally
ATab.Free;
end;
end;
[/sourcecode]Faça o teste: inclua, altere e exclua. Você percebeu que não é necessário fechar o programa para ver os dados no BD? Sim, os dados já estão sendo persistidos após efetuarmos o Commit no banco.

Modelo 2: Classe TDaoSingleton

Para ficar claro, e assim visualizar melhor as diferenças existentes entre o modelo 1 e o 2, façamos o seguinte:

• Crie uma pasta chamada “Persistencia”;
• Feche o Delphi e mova a pasta do nosso projeto para dentro da pasta criada;
• Renomeie a pasta do projeto para “Generico”;
• Copie a pasta “Generico” (Ctrl+C) e cole (Ctrl+V) dentro de “Persistencia”. Irá criar uma cópia;
• Renomeie a nova pasta (a “cópia”) para Interface.

Desta forma teremos 2 projetos: um para o modelo 1 (Generico) e o outro para o modelo 2 (Interface). Espero ter conseguido deixar claro esta parte. No Delphi, abra o projeto que está na pasta “Interface”. Feito isso, abra a unidade Base.pas. Iremos remover a classe TDaoGenerico e no seu lugar colocaremos uma interface e uma classe, a TDaoSingleton. Ela irá utilizar o Padrão Singleton (teremos uma implementação simples do padrão, mas é bom olhar o comentário que fiz no post Design Pattern: Singleton). Então, vamos lá:

[sourcecode language=”delphi”]
unit Base;

interface

uses DB, SysUtils, Classes, System.Generics.Collections;

type
IBaseDados = interface
[‘{9B0F9364-AB16-4C12-B4B7-4E2287840232}’]
end;

ITransacao = interface
[‘{2F1DCA7A-E7F4-4EC3-BDB2-22B99C8CA7DB}’]
end;

TTabela = class(TObject)
end;

IDaoBase = interface
[‘{D06AAE8D-D5F7-47E7-BF11-E26687C11900}’]

function Inserir(ATabela: TTabela): Integer;
function Salvar(ATabela: TTabela): Integer;
function Excluir(ATabela: TTabela): Integer;

function InTransaction: Boolean;
procedure StartTransaction;
procedure Commit;
procedure RollBack;
end;

IDaoSingleton = interface
[‘{0E2A5F26-3BBB-4022-8C2F-9BD88AD7CA89}’]
end;

TDaoSingleton = class(TInterfacedObject, IDaoSingleton)
private
FCon: IDaoBase;
class var FInstancia: IDaoSingleton;
procedure SetCon(const Value: IDaoBase);
public
class function Get: TDaoSingleton; static;
property Con: IDaoBase read FCon write SetCon;
end;

implementation

{ TDaoSing }

class function TDaoSingleton.Get: TDaoSingleton;
begin
If not Assigned(FInstancia) Then
FInstancia := TDaoSingleton.Create;

Result := FInstancia as TDaoSingleton;
end;

procedure TDaoSingleton.SetCon(const Value: IDaoBase);
begin
FCon := Value;
end;

end.
[/sourcecode]Muito parecido com a classe genérica, porém com esta não precisaremos nos preocupar com instanciação e destruição. Abra o dmPrin e faça as seguintes alterações:

[sourcecode language=”delphi”]
unit udmPrin;

interface

uses
System.SysUtils, System.Classes, uib, Base, DaoUib;

type
TdmPrin = class(TDataModule)
procedure DataModuleCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
Conexao: IDaoBase;
end;

var
dmPrin: TdmPrin;

implementation

{%CLASSGROUP ‘System.Classes.TPersistent’}

{$R *.dfm}

procedure TdmPrin.DataModuleCreate(Sender: TObject);
begin
// configuração da conexão – utilizando DaoUib
Conexao := TDaoUib.Create(‘C:\Users\Luiz\Documents\RAD Studio\Projects\Persistencia\Bd\BANCOTESTE.FDB’);

// dao genérico
TDaoSingleton.Get.Con := Conexao;
end;

end.
[/sourcecode]

• Observe que não precisamos mais do objeto chamado Dao.
• Na linha 33, setamos a propriedade Con com o objeto Conexao (TDaoUib).

No formulário frmTesteAtributos, passamos a utilizar TDaoSingleton em vez de TDaoGenerico:

[sourcecode language=”delphi”]
implementation

{$R *.dfm}

uses
Teste, Base;

procedure TfrmTesteAtributos.btnInserirClick(Sender: TObject);
var
ATab: TTeste;
Registros: Integer;
begin
ATab := TTeste.Create;
try
with ATab do
begin
id := 1;
Estado := ‘MA’;
Descricao := ‘MARANHÃO’;
Habitantes := 6569683;
RendaPerCapta := 319;
end;
TDaoSingleton.Get.Con.StartTransaction;
try
Registros := TDaoSingleton.Get.Con.Inserir(ATab);

TDaoSingleton.Get.Con.Commit;

Memo1.Lines.Add(Format(‘Registro inserido: %d’, [Registros]));
Memo1.Lines.Add(Format(‘id: %d, nome: %s’,[ATab.Id, atab.Descricao]));
except
on E: Exception do
begin
TDaoSingleton.Get.Con.RollBack;
ShowMessage(‘Ocorreu um problema ao executar a operação: ‘ + e.Message);
end;
end;
finally
ATab.Free;
end;
end;

procedure TfrmTesteAtributos.btnSalvarClick(Sender: TObject);
var
ATab: TTeste;
Registros: Integer;
begin
ATab := TTeste.Create;
try
with ATab do
begin
id := 1;
Estado := ‘MA’;
Data := Now;
Descricao := ‘MARANHÃO (ALTERADO SINGLETON)’;
Habitantes := 6569683;
RendaPerCapta := 319;
end;
TDaoSingleton.Get.Con.StartTransaction;
try
Registros := TDaoSingleton.Get.Con.Salvar(ATab);

TDaoSingleton.Get.Con.Commit;

Memo1.Lines.Add(Format(‘Registro inserido: %d’, [Registros]));
Memo1.Lines.Add(Format(‘id: %d, nome: %s’,[ATab.Id, atab.Descricao]));
except
on E: Exception do
begin
TDaoSingleton.Get.Con.RollBack;
ShowMessage(‘Ocorreu um problema ao executar a operação: ‘ + e.Message);
end;
end;
finally
ATab.Free;
end;
end;

procedure TfrmTesteAtributos.btnExcluirClick(Sender: TObject);
var
ATab: TTeste;
Registros: Integer;
begin
ATab := TTeste.Create;
try
ATab.Id := 1;
TDaoSingleton.Get.Con.StartTransaction;
try
Registros := TDaoSingleton.Get.Con.Excluir(ATab);

TDaoSingleton.Get.Con.Commit;

Memo1.Lines.Add(Format(‘Registro excluido: %d’, [Registros]));
except
on E: Exception do
begin
TDaoSingleton.Get.Con.RollBack;
ShowMessage(‘Ocorreu um problema ao executar a operação: ‘ + e.Message);
end;
end;
finally
ATab.Free;
end;
end;
[/sourcecode]Além de trocar a classe TDaoGenerico pela classe TDaoSingleton, no uses deixamos de utilizar a unidade udmPrin e em seu lugar, utilizamos a unidade Base.

Teste novamente…

Passando a bola

Agora é com você! Quero que analise os dois modelos atentamente e depois me diga:

• Qual dos 2 gostou mais?
• Pontos positivos e negativos de cada um?
• Tem alguma sugestão para melhorar o que foi feito?
• Gostaria de continuar a utilizar os componentes TUIBDatabase e TUIBTRansaction diretamente, instanciando o componente no datamodule e passando eles por parâmetro, como era feito anteriormente?

Vou aguardar o seu comentário! Depois continuaremos o ORM básico com o modelo mais aceito.

Obrigado e até o próximo artigo!

[poll id=”2″]