Fala radizeiro e Radizeira, tudo bem com vocês?

Nos post anteriores tenho falado muito sobre a organização e desacoplamento dos códigos.

Espero que hoje você possa já aplicar as técnicas de desacoplamento dos seus projetos.

Quero que você possa se livrar desses problemas de manutenção constante, de não conseguir sair do que está legado para as novas features do Delphi.

E com o nosso exemplo ainda aberto iremos começar a refatorar, para que possamos ter maior flexibilidade na hora de atualizar.

Irei primeiro renomear esse formulário seguindo os padrões do clean code na nomenclatura.

Onde eu defini a minha camada View.

Mas não irei entrar a fundo sobre essa questão do MVC, mas irei deixar cada classe nomeada seguindo suas respectivas regras na estrutura.

Logo de cara eu irei precisar de um unit que irá ser preparada a conexão.

Eu tenho a nomenclatura que é muito importante para definir o que é cada coisa no seu devido lugar.

Nessa classe de conexão irei utilizar o meu “Code Template”, visto em post anteriores.

type
TMyClass = class(TInterfacedObject, iMyInterface)
private
public
constructor Create;
destructor Destroy; override;
class function New : iMyInterface;
end;
implementation
constructor TMyClass.Create;
begin
end;
destructor TMyClass.Destroy;
begin
inherited;
end;
class function TMyClass.New : iMyInterface;
begin
Result := Self.Create;
end;
end.

Observe que tenho minha classe montada e que estende de uma interface, e nesse caso irei precisar criar essa interface.

interface
type
iConexao = interface
end;
implementation
end.

Nessa interface iremos ter os métodos que iremos trabalhar.

A princípio eu não sei quais são esses métodos.

Vamos a nossa classe de conexão estender essa interface.

unit Model.Customers.Conexao.Firedac;
interface
uses
Model.Customers.Conexao.Interfaces;
type
TModelConexaoFiredac = class(TInterfacedObject, iConexao)
private
public
constructor Create;
destructor Destroy; override;
class function New : iConexao;
end;
implementation
constructor TModelConexaoFiredac.Create;
begin;
destructor TModelConexaoFiredac.Destroy;
begin
inherited;
end;
class function TModelConexaoFiredac.New : iConexao;
begin
Result := Self.Create;
end;
end.

Agora que temos nossa classe de conexão do firedac, não é mais necessário o uso do componente de conexão do firedac na view, nesse caso irei importar tudo que é de dependência do firedac para essa classe.

Você irá perceber que nas uses do formulário reduzimos significativamente o acoplamento do Firedac.

uses
Winapi.Windows,
Winapi.Messages,
System.SysUtils,
System.Variants,
System.Classes,
Vcl.Graphics,
Vcl.Controls,
Vcl.Forms,
Vcl.Dialogs,
Data.DB,
Vcl.Grids,
Vcl.DBGrids;
...

Esse acoplamento estava intimamente ligado ao formulário, e isso não é uma boa prática.

E as dependências do firedac foram adicionadas na classe que é específica para a conexão do firedac.

Desta forma estamos tirando todo o acoplamento do formulário e passando para a classe para essa responsabilidade.

E o que vou fazer agora é instanciar essa conexão do firedac na sua respectiva classe, para que ao instanciar essa classe em qualquer lugar, já tenhamos a instância ativa do componente de conexão do firedac.

constructor TModelConexaoFiredac.Create;
begin
FConexao := TFDConnection.Create(nil);
end;

Agora irei precisar exportar ele, mas para isso não irei utilizar o TFDConnection, mas uma classe mais ancestral, para que não fiquemos agarrado numa chamada fixa do firedac, dando maior portabilidade dessa nossa classe.

Como a maioria dos componentes de conexão compartilham da mesma classe, TCustomConnection, iremos expor um método na nossa interface que possa trabalhar com essas conexões.

interface
type
iConexao = interface
function Connection : TCustomConnection : iConexao;
end;
implementation
end.

Agora essa nossa classe de conexão irá precisar desse método, onde esse método simplesmente irá retornar nossa interface de conexão.

type
TModelConexaoFiredac = class(TInterfacedObject, iConexao)
private
public
constructor Create;
destructor Destroy; override;
class function New : iConexao;
function Connection : TCustomConnection : iConexao;
end;
...
function TModelConexaoFiredac.Connection : iConexao;
begin
Result := FConexao;
end;

Observe que ele já recebe como retorno do método a nossa variável de conexão que recebe a instância da conexão do firedac logo ao ser criada essa classe.

Todas as vezes que alguém precisar de uma conexão com o Firedac, ele irá instanciar essa classe, acessando o método Connection.

Desta forma ele já terá o objeto já instanciado.

Muito legal, não é pessoal?

Desta forma já temos uma classe de conexão e já podemos pegar e começar a trabalhar com ela.

E caso você tem interesse de conhecer mais sobre Boas Práticas para conexão de dados acesse o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI.

Você não terá só conteúdos relacionados ao Boas Práticas para conexão de dados, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.

CLIQUE AQUI E SAIBA MAIS SOBRE O CLUBE DOS PROGRAMADORES DELPHI