Interface para Regras de Negócios em Multi-Banco

Transcrição

1 1 Interface para Regras de Negócios em Multi-Banco MARCELO JALOTO é graduado no curso superior Projetos e Gestão de Redes de Computadores e formado no curso Técnico em Processamento de Dados. Formação Developer Delphi 2006 (Official Borland). Analista Desenvolvedor de Sistemas na Softplan/Poligraph Muitas empresas desenvolvem seu primeiro sistema pensando em seu primeiro cliente e acabam esquecendo que com crescimento do produto, futuros novos clientes com diferentes necessidades poderão surgir a cada momento. Um dos principais vilões na composição do valor final de um software é o banco de dados. Hoje em dia temos diversas opções, tais como: Firebird, Oracle, SQL Server, PostGreeSQL, MySQL e uma série de outros BD s. Alguns sob licença comercial e outros gratuitos. Então o ideal seria projetar um sistema que oferecesse uma aplicação com suporte a múltiplos bancos, ficando independente do BD, o que possibilitaria comercializar o aplicativo utilizando Firebird que é gratuito e tem bons recursos e ideal para empresas de pequeno porte. Oracle, com sua licença absurdamente alta, mas com excelentes recursos e ótima velocidade; muito bom para empresas de grande porte. E ainda poderíamos ter a praticidade de usar qualquer outro BD caso fosse a necessidade do cliente. Então como percebemos existem diversas situações e para algumas empresas de software, o ideal é vender a aplicação e não o banco de dados. O objetivo do artigo visa atender somente uma etapa da uma aplicação multi-banco, que será a criação de um protocolo que definirá as regras de negócios. As regras serão implementadas por uma classe para cada banco de dados suportado pela aplicação. Em nosso exemplo vamos definir apenas algumas regras básicas, pois o objetivo principal é mostrar apenas as definições dessas regras de negócios utilizando Interface para uma aplicação que suporte a multi-banco. Entendendo o funcionamento O ideal antes de começarmos seria uma explicação detalhada sobre Interface, mas isso daria um artigo imenso, então quem não conhece e deseja saber mais a fundo, sugiro que busque uma fonte de pesquisa mais completa ou tente consultar o help do Delphi. Para o nosso exemplo basta entender que Interface é um protocolo que define métodos que deverão ser obrigatoriamente implementados pelas classes que a utilizarem, ou seja, caso deixar de implementar um método, o compilador do Delphi irá gerar um erro, o que nos garantirá que todas classes que utilizarem a Interface terão todos os métodos definidos por ela. Bom, então agora vamos ao que interessa, e descobrir como definir essas regras utilizando Interface. Desenvolvendo a Interface Nós utilizaremos o Delphi 7 em nosso exemplo, entretanto nada o impede de fazer em uma versão superior, caso tenha um conhecimento básico da mesma. Então inicie uma nova aplicação em File New>Application, e em seguida crie uma nova Unit em File New Unit e salve-a como uinterfaceregrasbd.pas e escreva o código conforme a Listagem 1. Na Listagem 1, segue a criação da Interface com algumas regras básicas que poderiam ter em uma aplicação multi-banco baseada nos componentes dbexpress. Logo de inicio definimos um tipo ( Type ) enumerado para identificar os bancos de dados que podem ser utilizados em nossa aplicação. Nosso tipo enumerado vai de 0 à 4, sendo respectivamente bdfirebird à bdmysql.

2 Logo após a declaração da Interface foi adicionada uma especificação de um identificador global único ou GUID, que pode ser criado com as teclas Ctrl + Shift + G. O mais importante aqui foram as definições de alguns métodos básicos que deverão ser obrigatoriamente implementados nas classes de banco de dados suportadas e também as propriedades que poderão ser utilizadas a partir da nossa Interface. 2 Listagem 1. Implentação da Interface unit uinterfaceregrasbd; interface type { Definição dos bancos de dados que poderam ser utilizados na aplicação. } TTipoBD = (bdfirebird, bdoracle, bdsqlserver, bdpostgreesql, bdmysql); IRegrasBD = interface ['{DBEA73DB-3FF6-4AA7-A781-06B11546CA8D}'] function GetDriverName: string; function GetVendorLib: string; function GetLibraryName: string; function GetUsuario: string; function GetSenha: string; procedure SetUsuario(const Value: string); procedure SetSenha(const Value: string); property DriverName: string read GetDriverName; property LibraryName: string read GetLibraryName; property VendorLib: string read GetVendorLib; property Usuario: string read GetUsuario write SetUsuario; property Senha: string read GetSenha write SetSenha; implementation end. Criando as classes Vamos primeiramente criar a classe referente ao banco Firebird. Crie uma nova Unit utilizando o mesmo método empregado na criação de nossa Interface. Salve-a como uclassefirebird.pas e escreva os códigos conforme a Listagem 2. Toda classe em Delphi deve ser criada herdando-a de um objeto. Como estamos trabalhando com interfaces, devemos herdar de TInterfacedObject e também de IRegrasBD, nossa interface. TIntefacedObject faz algumas implementações obrigatórias de interfaces que descende da ancestral mais básica que é a IInterface. Na sessão protected são declarados todos os métodos exigidos pela interface IRegrasBD. Caso alguém esteja se perguntando, porque não usar uma classe abstrata, basta deixar de implementar qualquer um dos métodos da interface e tentar compilar. O Delphi irá gerar uma mensagem de erro de compilação obrigando a implementação da classe, recurso que fará ter certeza que todas as classes que utilizam a interface terão todos os seus métodos requeridos sendo implementados. Então quando for utilizar uma classe abstrata, pense bem e analise conforme sua necessidade, pois esta deixaria de compilar e geraria um erro de execução, fato não muito agradável em algumas situações. Outra vantagem de usar interface é que se podem unir várias interfaces em uma única classe gerando a polêmica multi herança do Delphi, o que não é correto de se dizer, mais sim um excelente recurso do paradigma da orientação a objetos, no qual contém as assinaturas de métodos que deverão ser implementados nas classes que a suportam.

3 3 Listagem 2. Classe para implementação das regras para Firebird unit uclassefirebird; interface uses uinterfaceregrasbd; type TRegrasFirebird = class(tinterfacedobject, IRegrasBD) private FUsuario: string; FSenha: string; protected {Métodos Obrigatórios da Interface das RegrasBD} function GetDriverName: string; function GetLibraryName: string; function GetVendorLib: string; function GetUsuario: string; function GetSenha: string; procedure SetUsuario(const Value: string); procedure SetSenha(const Value: string); {Fim dos Métodos da Interface RegrasBD} public constructor Create; destructor Destroy; override; property DriverName: string read GetDriverName; property LibraryName: string read GetLibraryName; property VendorLib: string read GetVendorLib; property Usuario: string read GetUsuario write SetUsuario; property Senha: string read GetSenha write SetSenha; implementation uses SysUtils; { TRegrasFirebird } constructor TRegrasFirebird.Create; SetUsuario(''); SetSenha(''); destructor TRegrasFirebird.Destroy; inherited; function TRegrasFirebird.GetDriverName: string; Result := 'Interbase'; function TRegrasFirebird.GetLibraryName: string; Result := 'dbxint30.dll'; function TRegrasFirebird.GetSenha: string; Result := FSenha; function TRegrasFirebird.GetUsuario: string;

4 4 Result := FUsuario; function TRegrasFirebird.GetVendorLib: string; Result := 'fbclient.dll'; procedure TRegrasFirebird.SetSenha(const Value: string); FSenha := 'masterkey' FSenha := Value; procedure TRegrasFirebird.SetUsuario(const Value: string); FUsuario := 'SYSDBA' FUsuario := Value; end. Todas as function s criadas são bem simples. As funções GetDriverName, GetLibraryName, GetVendorLib, GetUsuario e GetSenha, como os próprios nomes dizem, retornam driver, Bibliotecas (dll) de acesso ao banco, usuário e senha, respectivamente. Já SetUsuario e SetSenha são procedimentos usados para informar as credenciais de acesso ao banco. Note que para o Firebird fazemos uma pequena verificação com podemos ver a seguir: FSenha := 'masterkey' FSenha := Value; Se o parâmetro Value não for preenchido assumimos que a senha do banco é masterkey, padrão do Firebird. Para a classe Oracle o processo é o mesmo, porém nesse caso as funções GetDriveName, GetLibraryName, GetVendorLib, SetSenha e SetUsuario são alteradas de acordo com os requisitos do banco de dados. Então para criar uma nova Unit repita o procedimento indo em File New>Unit, salve-a como uclasseoracle.pas e escreva o código como a Listagem 3. Na Listagem 3 foi criada a classe que contém as regras do Oracle. Repare as idênticas assinaturas entre as duas classes TRegrasFirebird e TRegrasOracle, basicamente o que muda em nosso exemplo é a implementação de cada classe, mais nada impede de uma das classes ter um método a mais que a outra, desde que não exista na interface. O constructor e o destructor não fazem nada, mas foram colocados em nosso exemplo, apenas para demonstrar que é possível instanciar a classe diretamente sem ser referenciada pela interface. Listagem 3. Classe de negócios para o Oracle unit uclasseoracle; interface uses uinterfaceregrasbd; type TRegrasOracle = class(tinterfacedobject, IRegrasBD) private FUsuario: string; FSenha: string;

5 5 protected { Métodos Obrigatórios da Interface das RegrasBD } function GetDriverName: string; function GetLibraryName: string; function GetVendorLib: string; function GetUsuario: string; function GetSenha: string; procedure SetUsuario(const Value: string); procedure SetSenha(const Value: string); {Fim dos Métodos da Interface RegrasBD} public constructor Create; destructor Destroy; override; property DriverName: string read GetDriverName; property LibraryName: string read GetLibraryName; property VendorLib: string read GetVendorLib; property Usuario: string read GetUsuario write SetUsuario; property Senha: string read GetSenha write SetSenha; implementation uses SysUtils; { TRegrasOracle } constructor TRegrasOracle.Create; SetUsuario(''); SetSenha(''); destructor TRegrasOracle.Destroy; inherited; function TRegrasOracle.GetDriverName: string; Result := 'Oracle'; function TRegrasOracle.GetLibraryName: string; Result := 'dbxora30.dll'; function TRegrasOracle.GetSenha: string; Result := FSenha; function TRegrasOracle.GetUsuario: string; Result := FUsuario; function TRegrasOracle.GetVendorLib: string; Result := 'oci.dll' procedure TRegrasOracle.SetSenha(const Value: string);

6 6 FSenha := 'system' FSenha := Value; procedure TRegrasOracle.SetUsuario(const Value: string); FUsuario := 'manager' FUsuario := Value; end. Criando um exemplo básico Voltando ao formulário principal Form1 da nossa aplicação vamos criar um programa simples para listar as regras definidas de cada banco de dados suportado, apenas para demonstrar como será instanciada a interface em nosso exemplo. Na Figura 1 segue o layout e os componentes necessários que serão utilizados em nosso exemplo e na Listagem 4, a implementação do botão Listar Regras. Dê um duplo clique no botão e escreva o código conforme a Listagem 4, para exemplificarmos a criação de nossas classes de acesso a banco de dados. Para o nosso exemplo são passadas na seção Implementation as Unit s uinterfaceregrasbd, uclassefirebird e uclasseoracle, as quais criamos nas listagens 1, 2 e 3. A principal ação aqui nesse exemplo é a declaração da variável vregrasbd do tipo IRegrasBD, que será instanciada em uma das classes de acesso que criamos. Na Unit de nossa interface, foi definido um tipo enumerado, bdfirebird = 0, bdoracle = 1... bdmysql = 4, sabendo-se disto, então foi colocado na mesma ordem no RadioGroup para que tenham o mesmo índice, então, o valor do índice selecionado do RadioGroup corresponderá a classe que será instanciada. Com a verificação se a interface foi referenciada será retornado no ListBox1, o valor de cada propriedade das regras que foram definidas. No final, repare que somente é passado nil a interface, isto se deve porque na classe TInterfacedObject, é implementada uma contagem por referência que libera automaticamente a instância quando não mais existir uma referência. Repare a diferença das classes TClasseFirebird e TClasseOracle, respectivamente nas Figuras 1 e 2 e na Figura 3 veja a mensagem que será disparada caso a tenha algum banco de dados que não foi implementado. Figura 1. Exemplo da listagem da classe Firebird.

7 7 Figura 2. Exemplo da listagem da classe Oracle. Figura 3. Mensagem de erro da classe PostGreeSQL que não foi implementada. Listagem 4. Código do programa usando as classes implementation uses uinterfaceregrasbd, uclassefirebird, uclasseoracle; {$R *.dfm} procedure TForm1.Button1Click(Sender: TObject); var vregrasbd: IRegrasBD; { Limpa todos os itens do ListBox caso possua algo. } ListBox1.Items.Clear; try { Criação das regras conforme o tipo do banco de dados especificado no parâmetro. } case TTipoBD(RadioGroup1.ItemIndex) of bdfirebird: vregrasbd := TRegrasFirebird.Create; bdoracle: vregrasbd := TRegrasOracle.Create; bdsqlserver: raise Exception.Create('Banco de dados SQL Server ainda não suportado.'); bdpostgreesql: raise Exception.Create('Banco de dados PostGreeSQL ainda não suportado.'); bdmysql: raise Exception.Create('Banco de dados MySQL ainda não suportado.');

8 8 if Assigned(vRegrasBD) then ListBox1.Items.Add('DriveName: ' + vregrasbd.drivername); ListBox1.Items.Add('LibraryName: ' + vregrasbd.libraryname); ListBox1.Items.Add('VendorLib: ' + vregrasbd.vendorlib); ListBox1.Items.Add('Usuario: ' + vregrasbd.usuario); ListBox1.Items.Add('Senha: ' + vregrasbd.senha); finally vregrasbd := nil; end. Conclusão Vimos nesse simples exemplo como utilizar os conceitos de interface para definir regras de uma aplicação multi-banco, com o objetivo de abrir uma porta para um mundo de novas possibilidades que agora você poderá utilizar em suas aplicações. E aqueles que nesse momento estão cheios de novas idéias, vale apena terminar o exemplo e implementar as classes TRegrasSQLServer, TRegrasPostGreeSQL e TRegrasMySQL. Muito obrigado e até a próxima.