Introdução à plataforma GNU de desenvolvimento



Autor: Renato Merli <merli.renato at gmail.com>
Data: 26/02/2010

Introdução

Para desenvolver aplicativos normalmente fazemos uso de uma grande quantidade de ferramentas de programação, muitas vezes dispostas em kits, frameworks ou plataformas de desenvolvimento.
Como exemplo de plataformas de desenvolvimento temos o .NET e a linguagem JAVA combinada com uma das muitas ferramentas de edição de interface e de código disponíveis.
Para o desenvolvimento de software para as plataformas Windows, Linux, BSD, Mac OS e Unix temos a plataforma de desenvolvimento GNU, que é constituída de uma coleção de projetos de software livre mantidos pela Free Software Foundation e desenvolvedores que colaboram através da internet. Os principais componentes dessa plataforma estão referenciados em http://library.gnome.org/devel/references.
A plataforma GNU não esta associada a nenhuma linguagem de programação em particular: as ferramentas de programação são desenvolvidas em linguagem C e têm ligações para a maioria das linguagens, incluindo C# (mono), C++, Java, PHP, Perl, Python, Ruby e várias outras.
Ela reúne todos os recursos que um conjunto de ferramentas deve conter para ser chamado de plataforma de desenvolvimento: editor de código, editor gráfico de interfaces, compilador, depurador etc, além de um conjunto de bibliotecas facilitadoras para as necessidades de desenvolvimento mais comuns.
Atualmente a plataforma GNU é completa, estável, rica em recursos, mas nitidamente ainda é pouco utilizada para desenvolvimento de aplicativos de acesso a banco de dados, mesmo entre os desenvolvedores de software livre: uma pesquisa no Google pela palavra chave “GDAMM”, o nome de umas ferramentas da plataforma de desenvolvimento, em janeiro de 2009, antes da publicação deste artigo, não retornava nenhuma ocorrência em língua portuguesa e muito poucas em língua inglesa.
Isso não deve, entretanto, perdurar por muito tempo. Os projetos que compõem o ambiente GNU estão sendo melhorados continuamente e, como acontece com as plataformas e aplicativos livres, sua popularidade deve continuar a crescer nos próximos anos. É provável que dentro de algum tempo a plataforma GNU venha a ter alguma representatividade entre os ambientes de desenvolvimento populares.
Considero que para todos os ambientes de desenvolvimento deve haver compiladores ou interpretadores, depuradores, editores etc. Por isso, entre todos os componentes que compõem uma plataforma de desenvolvimento, estamos interessados em especial no conjunto de bibliotecas para programação que o ambiente oferece, o resto é “bobagem”.
As funcionalidades presentes no ambiente GNU são muitas, incluindo bibliotecas thread-safe e multiplataforma para algoritmos genéricos, threads, XML, unicode, arquivos e outras utilidades (GLIB); tratamento de imagens gráficas (CAIRO), criação de interfaces gráficas (GTK+), acesso a banco de dados (GDA), comunicação interprocesso (D-BUS e BONOBO) e web services (LIBSOUP).
Nas próximas seções vamos conhecer os componentes do ambiente GNU essenciais para a criação de aplicativos e, para tanto, vamos estudar a aplicação genérica de cada uma das funcionalidades necessárias para construir aplicativos de acesso a banco de dados.
Utilizaremos do ambiente GNU: um aplicativo chamado GLADE para desenhar a interface; o toolkit GTKMM para programá-la; os componentes da biblioteca GNOME-DB para integração com o SGBD; o compilador GCC para compilar e linkar; o editor de código Anjuta para escrever o código.
Foram utilizadas as seguintes versões:

  • GLIB 2.22.0, GLIBMM 2.22.0, GTK+ 2.16.5, GTKMM 2.12.8,
  • GDA 3.1.2, GDAMM 3.0.0, GNOME-DB 3.1.2, GNOMEDBMM 2.9.5

Não foi utilizada a biblioteca GDA na versão 4 porque, ao tempo da redação deste, a ligação em C++, GDAMM, estava incompleta e sem uso possível para as funcionalidades utilizadas aqui. Deve ser lembrado, entretanto, que a versão de referência para novos projetos deve ser a versão 4, se possível.
O conhecimento da linguagem C++ e da arquitetura MVC é pré-requisito para o estudo deste documento.

Criação de interfaces: desenho

Interfaces gráficas podem ser criadas programaticamente, caso em que o programador cria e arranja os componentes um por um, ou criadas através de um criador de interfaces (interface builder), caso em que é utilizado um aplicativo gráfico que permite “desenhar” as interfaces arrastando e soltando componentes.
Na plataforma GNU, mais especificamente no toolkit GTK+, somos livres para utilizar ou não um construtor de interfaces. Em nosso exemplo usaremos um criador de interfaces, o GLADE, em conjunto com o toolkit GKT+, embora a técnica que recomendo para boa parte dos casos seja a criação de interfaces de maneira programática.
O GLADE pode ser utilizado de duas formas: pode gerar o código fonte que cria a interface desenhada, ou pode gerar uma descrição em XML da interface que é posteriormente usada por uma biblioteca (libglade) para reconstruir a interface em tempo de execução.
Utilizaremos a segunda técnica, ou seja, criaremos uma interface utilizando o software construtor de interfaces GLADE para gerar o arquivo XML que será utilizado para reconstruir a interface com a biblioteca libglade quando o aplicativo estiver “rodando”.
Como qualquer criador gráfico de interfaces gráficas, o GLADE é operado basicamente de maneira intuitiva. Alguns minutos de experimentação são suficientes para aprender a operá-lo e começar a conhecer os componentes gráficos disponíveis para criar interfaces.
O GLADE tem a seguinte aparência:

Linux: Introdução à plataforma GNU de desenvolvimento

No lado esquerdo está a barra de componentes, de onde são selecionados os componentes para inclusão na interface, ao centro há uma janela sendo criada, enquanto que no lado diretório está o editor de propriedades, onde são editadas as propriedades dos componentes.
Para nosso exemplo, utilizando o GLADE criamos uma janela principal e dois formulários, um para inserção de títulos:

Linux: Introdução à plataforma GNU de desenvolvimento

E um para pesquisa:

Linux: Introdução à plataforma GNU de desenvolvimento

Alguns componentes são propositalmente omitidos, pois serão criados programaticamente e, na fase em que estamos, apenas reservamos espaço para eles.
Tendo “desenhado” a interface, vamos programar seu comportamento.

Criação de interfaces: programação

A programação das interfaces gráficas, na plataforma GNU, é realizada utilizando o toolkit GTK+, em nosso caso através da ligação GTKMM para linguagem C++.
No GTK+, como em outros toolkits, é necessário inicializar o toolkit gráfico para então carregar explicitamente as interfaces que foram criadas através do construtor de interfaces, de modo que a programação de aplicativos deve seguir os seguintes passos:
1) inicialização do toolkit gráfico
2) construção das interfaces e associação de eventos
3) execução do mainloop, uma função que nunca retorna pois é responsável por “chamar” os tratadores de eventos quando um evento acontece.
Esses procedimentos podem não ser necessários em algumas plataformas de desenvolvimento, mas fazê-los explicitamente como o faremos obviamente tem muitas vantagens.
Então, para a criação de aplicativos no ambiente GNU podemos ter uma construção como a seguinte, em linguagem C ou C++:

Linux: Introdução à plataforma GNU de desenvolvimento

Na linha 5 inicializamos o toolkit GTK+ e na linha 9 iniciamos o mainloop: é entre uma e outra dessas chamadas que devem ser criadas as interfaces e associados os tratadores de eventos.
Em nosso caso, porque usamos um construtor de interfaces, precisamos apenas seguir os passos necessários para reconstruir a interface, o que é muito simples, conforme será demonstrado.
A utilização de um construtor de interfaces, se feita de maneira como fizemos, cria um efeito colateral, porque ao contrário do que acontece quando criamos a interface programaticamente, quando utilizamos um construtor de interfaces não temos referências aos objetos da interface, já que os mesmos são criados pela biblioteca que reconstrói a interface, em nosso caso libglade++, e não por nós mesmos.
Por esse motivo existe em libglade um mecanismo que permite recuperar a referência aos objetos componentes de uma interface construída por libglade, utilizando-se para isso o nome dado ao componente quando de sua criação com o construtor de interfaces.
A recuperação da interface criada a partir do arquivo XML gerado pelo construtor de interfaces pode ser feira assim:

Linux: Introdução à plataforma GNU de desenvolvimento

Na linha 11 criamos um smartpoiner para o tipo Xml do namespace Glade, mas não vamos nos ater a definição de smartpointer, se você não sabe o que é, faz de conta que é um ponteiro comum. :)
Na linha seguinte fazemos a leitura do arquivo que criamos previamente com o construtor de interfaces GLADE, que chamamos de arquivo.glade.
Na linha 15 criamos um ponteiro para um botão, que irá guarda a referência que iremos recuperar usando libglade.
A linha 16 demonstra como pode ser feita a recuperação das referências aos objetos dentro de uma interface criada com o GLADE, utilizando o nome dado ao widget no momento da criação da interface para referenciá-lo. No exemplo, o método get_widget é usado para recuperar a referência ao componente chamado em GLADE de “bt_add_item” e atribuí-la ao ponteiro Botao1.
Após recuperar a interface e a referência aos componentes necessários, podemos atribuir tratadores aos sinais.
Na plataforma GNU utilizamos as bibliotecas libsig e libsig++ para implementar o sistema de sinais e slots que da suporte ao sistema de eventos do ambiente de desenvolvimento.
A beleza de libsig++ está no fato de ela ser uma biblioteca de sinais e slots muito versátil, thread-safe e type-safe, mas ela não é totalmente simples. São utilizados functors que permitem que métodos de classes possam ser chamados como se fossem funções e, por isso, utilizando a plataforma GNU podemos atribuir aos eventos tanto funções como métodos de classes.
No exemplo anterior, na linha 17, realizamos a associação a uma função chamada “funcao_x”.
Já sabemos como construir uma interface com um construtor de interfaces, como recuperar a interface criada em tempo de execução e como associar tratadores aos eventos. Podemos agora tratar do acesso ao banco de dados.

Banco de dados

As funcionalidades de banco de dados na plataforma GNU são implementadas através de um projeto chamado GDA, de Gnome Data Access.
GDA é independente de SGBD, ou seja, permite operar com servidores diferentes através de uma mesma API, permitindo trocar o servidor de banco de dados sem alterar o aplicativo. Para permitir isso, GDA provê um elevado nível de abstração dos tipos de dados operados por cada tipo de SGBD em particular.
Como outras ferramentas para acesso a SGBDs, GDA oferece os seguintes componentes básicos:
1) um componente para conexão com o banco de dados
2) um componente facilitador para a criação de querys;
3) Modelos de dados que guardam o resultado das consultas
4) Componentes para exibição dos dados contidos nos modelos de dados na forma de tabelas e listas.
Uma consulta é feita usando o componente de conexão (1) e opcionalmente o componente facilitador para construção de querys (2), que retorna os dados em um modelo de dados (3), que é então associado aos componentes de exibição, chamados visões (4). Esse procedimento é bastante similar em diversas ferramentas de programação, que normalmente implementam variações em torno desse modelo básico.
Para a versão de GDA utilizada nesse exemplo, a versão 3, apenas o componente de conexão e os modelos de dados estão na biblioteca GDA, enquanto que os objetos gráficos estão em um projeto chamado libgnomedb.
Vamos ver como inicializar libgnomedb++, a ligação em C++ para a biblioteca libgnomedb, e criar uma conexão com o SGBD:

Linux: Introdução à plataforma GNU de desenvolvimento

Inicializamos a biblioteca, na linha 5, para em seguida criarmos um objeto Client, na linha 7, que entre outras coisas, manipula um conjunto de conexões. É através desses objetos que mantemos uma ou, segundo os manuais, varias conexões simultâneas com SGBDs.
Utilizamos apenas uma conexão, com servidor SQLite, como pode ser observado pelos parâmetros da conexão, nas linhas 10 e 11, que incluem também o nome de usuário(login) e a senha para conexão com o servidor de banco de dados.
Se temos um objeto de conexão, temos também acesso aos dados, já que é através do objeto de conexão que são feitas consultas e operações no banco.
No próximo exemplo vamos realizar uma consulta e então associar os dados retornados a dois dos componentes gráficos de interface (visões) disponíveis, um form e um grid.

Linux: Introdução à plataforma GNU de desenvolvimento

Até a linha 11 são realizados os procedimentos que já conhecemos, realmente nos interessam as linhas 13, 14 e 16.
Na linha 13 é criado um modelo de dados, que guarda os dados da consulta ao servidor de banco de dados.
Na linha 14, usando o objeto de conexão, executamos a instrução “SELECT * FROM titulos” no servidor de banco de dados, armazenando o resultado da consulta no modelo de dados “model” que havíamos criado na linha 13.
Para a visualização dos resultados das consultas ao banco, a maioria das ferramentas de programação oferece componentes para exibição dos resultados no formato de tabelas, que podem receber nomes como datagrid, dbgrid, dbview etc. Na plataforma GNU nós os chamamos simplesmente de grids: criamos um deles na linha 16.
Além dos bem conhecidos grids, GDA conta também com um componente para visualização de dados na forma de formulário, chamado form, que criamos na linha 17.
Os forms representam uma ferramenta eficiente para acelerar o desenvolvimento de aplicativos de acesso a banco de dados. Eles têm a seguinte aparência:

Linux: Introdução à plataforma GNU de desenvolvimento

Enquanto que os grids são assim:

Linux: Introdução à plataforma GNU de desenvolvimento

Como você deve ter percebido pelos ícones na parte inferior, em GNOME-DB os grids e os forms podem ser usados para realizar inclusão, alteração e deleção de registros. Para isso basta programar as querys correspondentes, o que é muito simples, mas não será demonstrado aqui.

Colocando tudo junto: programação do aplicativo

Até aqui ilustramos, através de exemplos genéricos, os passos essenciais para a construção de um aplicativo de acesso a banco de dados utilizando a plataforma GNU. É fundamental, entretanto, para a experimentação do leitor, um experimento prático.
Para tanto será disponibilizado o código fonte compilável de um exemplo de aplicativo utilizando as ferramentas citadas aqui. Ele estará disponível em:

Entretanto, para além do que já foi apresentado, a programação do aplicativo não está diretamente relacionada com a plataforma de desenvolvimento, de modo que não cabem maiores esclarecimentos.

Considerações finais

Espero ter demonstrado os passos básicos e mais importantes para criação de aplicativos de acesso a banco de dados na plataforma GNU, ou, mais especificamente, como começar a desenvolver um aplicativo de forma simples utilizando essa plataforma.
A plataforma GNU de desenvolvimento certamente tem suas limitações, seus pontos fortes e indicações de seu uso, mas qualquer comparação baseada unicamente nos recursos e funcionalidades apresentados aqui é invalida, porque será baseada em conhecimento apenas superficial do objeto comparado.
Procurei não fazer comparações aqui porque considero que qualquer comparação que leve em conta o conceito de plataforma é de utilidade questionável, já que não precisamos viver confinados aos recursos de um ambiente de desenvolvimento, e fazê-lo seria tolice.
Os programadores de software livre, na verdade, sequer reconhecem o conceito de plataforma de desenvolvimento, já que seu kit básico de programação já é composto de um grande número de projetos independentes integrados. Normalmente esses programadores consideram como parte de sua plataforma qualquer ferramenta de programação encontrada nos repositórios de software livre.
É certo que é possível escrever aplicativos utilizando apenas software GNU, como o fizemos, mas isso não é uma necessidade, já que as ferramentas GNU normalmente estão integradas aos ambientes de desenvolvimento populares.
Se você se interessou em utilizar as ferramentas citadas aqui, seja bem vindo a nossa pequena comunidade.
Eu mostrei como começar a desenvolver um aplicativo, daqui para frente é com você!

 

Leia mais em: http://www.vivaolinux.com.br/artigo/Introducao-a-plataforma-GNU-de-desenvolvimento

Anúncios

Publicado em 15 de julho de 2011, em Vivaolinux. Adicione o link aos favoritos. Deixe um comentário.

Um comentário começa grandes debates!

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: