Fala ai Radizeiro e Radizeira, tudo com você?
Seguindo a nossa série de posts aqui no nosso blog.
Hoje estarei mostrando como podemos usar tudo que foi falado no post anterior na prática, é realmente agora iremos colocar a mão na massa, quer dizer, mão no código…rsrs
Vamos lá?
O que iremos fazer primeiramente é criar uma classe de conexão, criar a camada que irá conectar ao meu banco de dados.
No nosso projeto aqui no blog, irei criar uma nova Unit, e irei salvar ela dentro do meu Model, dentro dessa nosso model irei criar uma pasta chamada Conexão, onde tudo relacionado a conexão estará aqui dentro.
Observe como ficou nossa Unit?
Seguindo os posts anteriores, onde mostro de como é a nomenclatura das nossa units, foi tudo descrito seguindo as boas práticas.
Essa nossa Unit eu criei especificamente um bloco de interfaces para cada camada do nosso projeto, por exemplo, um bloco de interfaces para o bloco de conexão, se eu tiver um outro bloco, uma outra camada, e por ai vai.
Agora vamos criar nossas interfaces, as interfaces são as assinatura que as minhas classes irão precisar ter.
iModelConexao = interface
['{23B13564-CFE2-4B96-9265-AA370634418D}']
function Connection : TCustomConnection;
end;
Observe que criei um método chamado Connection do tipo TCustomConnection, ele é a classe mais ancestral que os componentes de conexão herdam, se eu tivesse colocado TFDConnection, estaria um acoplamento ao Firedac ai não iria conseguir utilizar outra coisa que não seja Firedac, por este motivo nós tentamos abstrair isso para uma camada mais raiz.
Assim que eu criei minha conexão, eu já posso criar minha classe de conexão, que será nossa classe de conexão do Firedac, ou seja, a classe que implementa essa nossa interface.
Após seguirmos o padrão de criação de nossa classe, vamos implementá-la.
type
TModelConexaoFiredac = class (TInterfacedObject, iModelConexao)
private
FConexao : TFDConnection;
public
constructor Create;
destructor Destroy; override;
class function New : iModelConexao;
function Connection : TCustomConnection;
end;
implementation
{ TModelConexaoFiredac }
function TModelConexaoFiredac.Connection: TCustomConnection;
begin
Result := FConexao;
end;
constructor TModelConexaoFiredac.Create;
begin
FConexao := TFDConnection.Create(nil);
FConexao.Params.DriverID := 'SQLite';
FConexao.Params.Database := '..\..\Database\database.db3';
FConexao.Connected := True;
end;
destructor TModelConexaoFiredac.Destroy;
begin
FConexao.DisposeOf;
inherited;
end;
class function TModelConexaoFiredac.New: iModelConexao;
begin
Result := Self.Create
end;
Observe que a nomenclatura eu mantive como salvei anteriormente, isso é muito importante.
Tudo que é relacionado ao Firedac está dentro dessa classe, fazendo assim não deixamos nossa aplicação com acoplamento, isso só ocorre quando colocamos vários componentes na nossa aplicação.
Toda a vez que eu quiser uma conexão, não preciso ter um Datamodule, vários componentes, só com essa classe já temos uma conexão com um código mais limpo e de fácil manutenção, você pode viu que não teve necessidade de colocar um monte de componente para que nossa tela venha ter acesso as dados do banco de dados? Claro que não.
Se eu chamar minha conexão diretamente na View, não faça isso pois é apenas uma demonstração, porque desta forma você está violando o MVC.
procedure TForm2.FormCreate(Sender: TObject); begin TModelConexaoFiredac.New.Connection; end;
observe que apenas com uma linha de código já possuímos a conexão com o banco de dados, sem ter que colocar nenhum componente na tela, é mais fácil colocar um componente na tela? Sim, só que observe que iremos fazer somente uma vez só e não precisar fazer mais, já tenho minha conexão e fazer o que quiser com ela, é muito mais reutilizável.
Esse é primeiro caminho para você pegar seu projeto legado e implementar qualquer coisa nele, separa os componentes de conexão do formulário.
Dessa forma abstrairmos nossa conexão e na hora que quisermos alterar nosso componente de conexão basta simplesmente criar uma classe de conexão para o componente de conexão e ser feliz…
Neste treinamento você vai aprender a aplicar técnicas que darão maior escalabilidade em seus softwares criando uma estrutura de forma prática e dinâmica, aplicando os padrões de boas práticas e clean code, além de compreender como aplicar os padrões de persistência de dados sem a necessidade de criar scripts de banco de dados.
