Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login

Java ME - Utilizando Floggy para Persistência de dados

Utilize o poder do Floggy, um framework criado por brasileiros que veio para substituir o RMS em Java ME.

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (4)  (0)

Java ME

Utilizando Floggy para Persistência de dados

Carlos Eduardo Carvalho Dantas

Utilize o poder do Floggy, um framework criado por brasileiros que veio para substituir o RMS em Java ME

Dentro do Desenvolvimento de Aplicações em Java ME, um dos maiores problemas que encontramos atualmente é com relação à persistência dos dados. Isto porque, os sistemas operacionais dos dispositivos fornecem recursos simples para persistência de dados e os poucos bancos de dados existentes são proprietários e disponíveis somente para determinados tipos de dispositivos.

Atualmente a persistência em Java ME é feita com a API de armazenamento de dados RMS (Record Management System), que vem junto com o pacote Java ME. O RMS usa a classe RecordStore para gerenciamento de registros, aonde um objeto desta classe armazena um conjunto de registros, em que cada registro é tratado como um array de bytes com um identificador  único. Esta maneira de persistir os dados torna-se um trabalho complexo para o programador, já que cabe ao mesmo a responsabilidade de lidar com operações de banco utilizando manipulações de array, além de escolher e gerenciar caracteres separadores entre os campos da tabela, entre vários outros.

Com todos os problemas apresentados anteriormente, torna-se necessária uma ferramenta de nível mais alto para o desenvolvedor, que abstrai todos os detalhes de memória. O framework Floggy fornece exatamente isso.

 

O framework Floggy

O framework Floggy seria como uma camada de nível mais alto, acima do RMS, aonde visa abstrair os detalhes de manipulação de caracteres do programador, ficando este responsável apenas pela montagem da lógica da aplicação, ou seja, ao invés de persistir um array de dados, a persistência será feita com instâncias dos objetos das classes modelo, assim como é feito atualmente em Java EE.

 

Classes modelo são as conhecidas classes model do modelo MVC em Java EE, onde efetuando um mapeamento objeto-relacional, pode-se mapear todas as tabelas de um banco utilizando simples classes Java, facilitando o acesso à informação e a implementação das regras de negócio específicas.

Download e Instalação no NetBeans

Para fazer a instalação do Floggy, efetue o download do arquivo floggy.zip no site sourceforge.net/projects/floggy. Após descompactá-lo, verá uma série de informações, inclusive tutoriais em português, bibliotecas do framework e o código fonte, caso deseje implementar alguma funcionalidade a mais, específica para o seu negócio. O Floggy vem com o arquivo org-floggyuml-floggyumlplugin.nbm (para simplificar será chamado de arquivo .nbm) para fazer a instalação do plugin FloggyUML no NetBeans e dois arquivos importantes que fazem parte do framework que são floggy-framework-SNAPSHOT.jar (para simplificar será chamado de arquivo .jar) que é a biblioteca do Floggy e floggy-compiler-J2ME-midp2-1.0.zip (para simplificar será chamado de arquivo .zip) que é responsável pela compilação do Floggy. Lembrando que, atualmente o Floggy possui suporte tanto para Eclipse quanto NetBeans, a diferença é que, para o NetBeans, foi desenvolvido o plugin FloggyUML que é bastante útil no aspecto da criação dos diagramas de classe UML para geração das classes Java correspondentes ao negócio. Para conferir como se utiliza o Floggy no Eclipse, veja o quadro “Floggy com o Eclipse”.

Para instalar o FloggyUML no NetBeans, clique na aba Tools\UpdateCenter. Selecione Install Manually Downloaded Modules. Clique em add e adicione o arquivo .nbm já citado anteriormente. Clique em next, next, accept e o plugin será instalado. Depois basta selecionar a opção plug-in FloggyUMLPlugin e reiniciar a IDE.

Crie um novo projeto no NetBeans e vamos configurar os outros dois arquivos, o .jar e o .zip. Copie-os para o diretório raiz do projeto, acesse as propriedades do projeto, selecione a opção Libraries & Resources e clique em Add jar/zip. Escolha o arquivo .jar e clique em abrir conforme pode ser visto na Figura 1.

image002.jpg 

Figura 1. Adicionando a blblioteca floggy-framework-SNAPSHOT.jar no projeto.

Para referenciar o arquivo .zip no projeto, basta configurar o arquivo build.xml da aplicação. O arquivo build.xml foi gerado automaticamente pelo NetBeans na criação do projeto. Para acessá-lo, basta selecionar a guia Files. Abra-o e adicione o código da Listagem 1 no final do arquivo build.xml, antes do fechamento da tag project. O código é um script ant simples, aonde a tag taskdef define quem irá compilar o projeto, no caso está sendo referenciado o arquivo .zip em floggy-compiler, em seguida a tag floggy-compiler chama o compilador passando o local dos arquivos compilados (inputfile) e os arquivos de saída (outputfile).

Com isso, o projeto já está pronto para desenvolvimento da aplicação com Floggy.

image004.jpg 

Figura 2. Diagrama criado no FloggyUML

Utilização do Plug-in FloggyUML no NetBeans

Dentro do projeto, vamos criar o modelo de dados. O aplicativo é basicamente um cadastro de artigos de revistas, contendo duas classes modelo: Artigo e Revista. Revista contém apenas o campo nome enquanto Artigo contém os campos Nome, Edição e uma associação de muitos-pra-um com a classe Revista, significando que um artigo faz parte de uma revista e uma revista pode conter vários artigos.

A janela do plugin FloggyUML está em Window\Open DiagramEditor Window. Como dito anteriormente, o FloggyUML é um plugin bastante útil na geração das classes Java que servirão de modelo para as tabelas. Basta criar os diagramas com as relações entre as classes e exportar, com isso todo o modelo das tabelas está pronto. O funcionamento do FloggyUML é bastante simples e intuitivo, mas vamos seguir de modo passo a passo para ficar de fácil entendimento.

Abrindo a tela do plugin FloggyUML, vemos dois botões habilitados. Clique na opção New Diagram. Dentro desta opção, o primeiro campo é para selecionar o diretório raiz do projeto e o segundo é para especificar o nome do package aonde ficarão as classes modelo. O segundo campo é opcional. Preenchidos os campos, crie uma nova classe clicando botão Add new class e arraste até a área branca. Feito isso basta renomear a classe e clicar com o botão direito para adicionar atributos. Para criar associação entre as classes, clique no botão Add new Association, clicando logo em seguida sobre cada uma das duas classes que farão parte do relacionamento. Por default é criada uma associação de um-para-um entre duas classes. Para modificar, basta mudar o valor de alguma das associações para * (muitos). Também é possível mudar o nome da associação como desejar. As classes e a associação entre elas deverão ficar conforme a Figura 2. Com o botão Start Code Generator são gerados dois arquivos, Revista.java e Artigo.java dentro do projeto. Também é possível salvar o diagrama clicando no botão Save Diagram, caso precise alterar ou criar novas classes futuramente.

Analisando as classes criadas, vemos que a novidade fica por conta do método save(). Este método é quem de fato salva os objetos criados para a base de dados, como veremos com mais detalhes na seção “Persistindo os dados”. O código das classes Artigo e Revista podem ser conferidos nas Listagens 2 e 3 respectivamente.

image006.jpg

Figura 3. Flow Design da aplicação

Montando a Aplicação

Até aqui, já foi configurado o Floggy no projeto e também foi criado o modelo de dados. Agora precisamos desenvolver as telas no NetBeans, conforme pode ser visualizado na Figura 3. Como o foco do artigo não é ensinar a desenvolver em Java ME, presume-se que o leitor já tenha conhecimentos básicos acerca de desenvolvimento Java ME com NetBeans. Caso não, aconselho o artigo “Programação Java ME” da edição 46, aonde aborda passo a passo como desenvolver em Java ME utilizando a IDE NetBeans. Na Figura 3, podemos ver que a aplicação possui um Midlet (mobile device), três Forms, sendo que um deles é o principal, ou seja, o menu da aplicação e os outros dois Forms são para cadastro de artigo e revista. Ainda tem dois Lists para listar os dados de Artigo e Revista e um Alert para mostrar mensagens na tela. Quanto aos Commands das telas, apenas o Form principal tem Command para sair da aplicação. Os outros dois Forms possuem Command para voltar para o Form principal e Command para salvar os dados e os dois Lists possuem apenas um Command para voltar para o Form principal cada um.

Os Screen Design dos Forms de cadastro de artigo e revista podem ser visualizados nas Figuras 4 e 5, respectivamente. Em cadastro de artigo possui um TextField para Nome, um TextField para Edição e um ChoiceGroup do tipo Popup para selecionar uma revista. Já em cadastro de revista possui apenas um TextField para Nome.

image008.jpg

Figura 4. Screen Design do Form de Cadastro de Artigo

 

image010.jpg   

Figura 5. Screen Design do Form de Cadastro de Revista

Persistindo os dados

Persistir utilizando Floggy é muito mais fácil do que se imagina. Para quem utiliza a API RMS, verá que não é necessário abrir conexão, tampouco lidar com tamanho de array que será persistido, ou seja, todo esse trabalho é feito pelo Floggy. O nosso trabalho é cuidar das regras, não dos detalhes.

Vamos utilizar como exemplo a classe Revista. Esta classe possui um atributo único chamado Nome. Quando o usuário ativar o Command de Salvar, o único trabalho que teremos é de instanciar uma nova classe Revista, setar o atributo Nome com o valor preenchido pelo usuário no TextField e chamar o método save() que se encontra dentro de todas as classes modelo. O exemplo está na Listagem 4. Com certeza isto é muito mais prático que criar um array de bytes para cada registro novo com separadores entre os campos, como é usado atualmente em RMS. Implemente o código da Listagem 4 dentro da condição do Command Salvar do Form de cadastro de revista.

Para o Command Salvar do Form de cadastro de artigos, segue-se a mesma lógica, apenas com uma diferença: como o cadastro de artigos possui uma associação com a classe Revista, precisa-se de recuperar a instância de Revista selecionada no ChoiceGroup, já que o ChoiceGroup somente armazena vetor do tipo String, e não do tipo Object. Para isso, usa-se o método find() aplicando Filter conforme pode ser visto na Listagem 5.  A lógica de se utilizar o Filter será detalhada na seção “Filter e Comparator” e os métodos de buscar registros serão detalhados na seção “Listando os dados”.

 

Listando os dados

Se salvar dados utilizando o RMS já é complicado, imagina buscá-los da base. Para começar, o separador precisa ser um caractere que o usuário nunca poderá usar para preencher algum campo, caso contrário não teria como saber se o caractere em determinada posição do array de bytes seria um separador ou parte de um campo. Alguns outros problemas são: separar campo por campo de um registro, aplicar filtros, entre outros. Com o Floggy, a busca de registros é muito simples. Para listar os registros de Artigo, basta implementar o código na Listagem 6. No código, ObjectSet tem a finalidade de receber um array de dados através de find() ou findAll() sendo que find() é uma busca que pode ser filtrada, ordenada ou nenhuma das anteriores, enquanto findAll() traz todos os registros sem filtro e sem ordenação. Cada iteração do loop tratá um registro recuperado da base, que será adicionado no List de artigos para exibição no display.

A lógica do List de revistas é praticamente igual, basta mudar para a classe Revista.class dentro do findAll() e mudar os gets dos campos da classe Artigo para os gets dos campos da classe Revista dentro do loop.

 

Filter e Comparator

Filter e Comparator são duas interfaces bastante úteis no Floggy. A semelhança entre estas duas interfaces é que para utilizá-las, precisa-se criar classes separadas implementando estas interfaces. A diferença é que Filter está associado aos filtros de uma consulta enquanto que Comparator está associado à ordenação de uma consulta.

O exemplo de Filter pode ser conferido na Listagem 7. Quando o método find() é chamado, este faz um loop interno buscando os registros da tabela enviada como parâmetro, e a cada iteração entra no método matches() para conferir se o registro passa ou não pelo filtro. Repare que, quando implementa a interface Filter, a declaração do método matches() torna-se obrigatória.  Este método tem como parâmetro um objeto do tipo Persistable, que pode ser convertido para a classe enviada como parâmetro de find(), podendo filtrar os atributos desejados. O retorno é do tipo boolean, que diz se aquele objeto em específico passou ou não no filtro.

A interface Comparator segue uma idéia parecida, já que a classe que implementar Comparator precisa declarar o método compare() passando dois Persistables como parâmetro. A idéia é fazer um cast para a classe modelo desejada e depois comparar o atributo que quiser, no caso o método compareTo() compara por caracteres alfanuméricos. O código da interface Comparator pode ser conferido na Listagem 8.

Conclusão

Com o que foi apresentado, podemos concluir que apesar de ser um framework de terceiros, o Floggy é uma ótima opção para persistência em aplicações Java ME, levando para o programador uma solução de alto nível sendo prática, robusta e simples de codificar, podendo substituir perfeitamente a biblioteca padrão RMS que é utilizada atualmente para persistência na maioria das aplicações Java ME.

 

 

Floggy com o Eclipse

Apesar deste artigo focar na IDE NetBeans, o Floggy também pode ser utilizado no Eclipse. Boa parte da codificação explicada pode ser utilizada da mesma forma para o Eclipse. O principal aspecto negativo fica por conta do plugin FloggyUML ainda não possuir sua versão para o Eclipse, tendo como conseqüência a necessidade de criar as classes modelo manualmente, conforme exemplo pode ser visto nas Listagens 1 e 2.

Primeiramente, antes de configurar o Floggy no Eclipse, para que o leitor fique por dentro das diferenças, toda a configuração explicada em “Download e Instalação”, foi referenciada a IDE NetBeans, portanto para o Eclipse, a configuração é totalmente diferente, como por exemplo o script ant da Listagem 1 não se faz necessário no Eclipse, nem referenciar os arquivos .jar e .zip explicados na sessão.

A configuração do Floggy para Eclipse é bastante trabalhosa, mas a boa notícia é que os criadores do Floggy já estão trabalhando em um plugin único e definitido para o Eclipse. Mas para quem quiser usar o que temos atualmente, primeiramente entre os arquivos que podem ser baixados do artigo no site da DevMedia em www.devmedia.com.br,  copie  a pasta floggy-persistence-1.0 para o diretório raiz do projeto. Feito isso, acesse as propriedades do projeto e adicione o arquivo floggy-persistence-framework.jar que está dentro da pasta lib no classpath da aplicação e na opção de exportar, marque-o.

Em seguida, é necessário adicionar a ferramenta que irá enxergar o código de persistência, conhecida como Weaver. Para isto, selecione a opção Builders em propriedades do projeto e crie uma nova entrada clicando em New, Ant Build.

image012.jpg

Figura Q1. Exemplo preenchimento dos campos para configurar o Weaver.

Agora preencha os campos conforme a Figura Q1. Lembre-se de alterar os parâmetros para trabalhar com as suas configurações.

l        floggy.path – diretório aonde o Floggy foi instalado (descompactado);

l        wtk.home – diretório de instalação do Sun Wireless Toolkit;

l        app.input – diretório aonde os arquivos .class estão sendo gerados pelo Eclipse.

Concluindo, dentro da opção builders aparecerá o Floggy Weaver. Selecione-o e clique em Up para que ele fique entre os outros dois builders, o Java Builder e o CLDC Preverifier.

Bem, para quem esteja utilizando no Eclipse os códigos apresentados aqui, especialmente das Listagens, existem algumas ressalvas com relação ao Eclipse:

l        No Eclipse, o caminho dos pacotes dos imports é diferente, portando utilizando um simples Ctrl + space as classes que estiverem apresentando erro acharão o caminho correto;

l        No Eclipse o método findAll() simplesmente não existe! Para simulá-lo, basta utilizar find(nomedaclasse.class,null,null) que terá o mesmo resultado de findAll();

l        A classe ObjectSet ao invés de oferecer o método count(), oferece o método size().

       

Carlos Eduardo Carvalho Dantas (carlose@swb.com.br) é Bacharel em Engenharia de Computação pela FEIT-UEMG e Especialista em Desenvolvimento Java pela UNITRI. Atualmente trabalha como Analista/Desenvolvedor Java para a empresa SWB em Uberlândia – MG.[LG5] 

 

Links

floggy.org[LG6] 

Sobre o Floggy

 

 

Listagem 1. Configuração no arquivo build.xml do projeto

             

  classpath="${path.floggy.CompilerTask}" />

               

 

     classpath="${path.floggy.CompilerTask}${path.separator}${path.floggy-framework}"

     inputfile="${basedir}/build/compiled"

     outputfile="${basedir}/build/compiled" />

 

Listagem 2. Exemplo de classe-modelo gerada pelo FloggyUML Artigo.java

import net.sourceforge.floggy.*;

public class Artigo implements Persistable{

  private String Nome;

  private int Edicao;

  private Revista revista;

  public String getNome(){

    return this.Nome; }

  public void setNome(String Nome){

    this.Nome = Nome;

  }

  public int getEdicao(){

    return this.Edicao;

  }

  public void setEdicao(int Edicao){

    this.Edicao = Edicao;

  }

  public Revista getRevista(){

    return this.revista;

  }

  public void setRevista(Revista revista){

    this.revista = revista;

  }

  public void save(){

    try{

      PersistableManager.getInstance().save(this);

    } catch (FloggyException ex) {

      ex.printStackTrace();

    }

  }

}

 

Listagem 3. Exemplo de classe-modelo gerada pelo FloggyUML Revista.java

import net.sourceforge.floggy.*;

public class Revista implements Persistable{

  private String Nome;

  public String getNome(){

    return this.Nome;

  }

  public void setNome(String Nome){

    this.Nome = Nome;

  }

  public void save(){

    try{

      PersistableManager.getInstance().save(this);

    } catch (FloggyException ex) {

      ex.printStackTrace();

    }

  }

}

 

Listagem 4. Código implementado no command Salvar da tela de Cadastro de Revistas

if (command == cmCadastrarRevista) {                              

  Revista revista = new Revista();

  revista.setNome(tfNome.getString());

  revista.save();           

  getDisplay().setCurrent(get_alCadastro(), get_frmPrincipal());         

}

 

Listagem 5. Código implementado no command Salvar da tela de Cadastro de Artigos

Artigo artigo = new Artigo();

artigo.setNome(tfNomeArtigo.getString());

artigo.setEdicao(Integer.parseInt(tfEdicao.getString()));                            

ObjectSet os = null;

try {

  os = PersistableManager.getInstance().find(Revista.class,

      new FiltroRevista(cgRevistas.getString(cgRevistas.getSelectedIndex())),null);

  artigo.setRevista((Revista)os.get(0));

} catch (FloggyException ex) {

    ex.printStackTrace();

    artigo.setRevista(null);

}                                                                                                               

artigo.save();

getDisplay().setCurrent(get_alCadastro(), get_frmPrincipal());      

 

Listagem 6. Código implementado no Command Listar da tela de listar Artigos

ObjectSet os = null;

get_lsArtigos().deleteAll();

try {                               

  os = PersistableManager.getInstance().findAll(Artigo.class);                       

  for (int i = 0; i < os.count(); i++) {

    Artigo artigo = (Artigo)os.get(i);

    get_lsArtigos().append(artigo.getNome()+ " - "+ artigo.getEdicao()

        + " - " + artigo.getRevista().getNome() +  "\n", null);

    }

} catch (FloggyException ex) {

    get_lsArtigos().append("Erro: List Record", null);

}                                       

getDisplay().setCurrent(get_lsArtigos());

 

Listagem 7. Código implementado na classe FilterRevista.java

public class FiltroRevista implements Filter {

  private String nome;

  public FiltroRevista(String nome) {

    this.nome = nome;

  }

  public boolean matches(Persistable objeto) {

    Revista r = (Revista) objeto;

    return r.getNome().equals(nome);

  }  

}       

 

Listagem 8. Código implementado na classe ComparatorRevista.java

public class ComparatorRevista implements Comparator {   

  public int compare(Persistable data1, Persistable data2) {       

    Revista revista1 = (Revista)data1;

    Revista revista2 = (Revista)data2;               

    String name1 = revista1.getNome();

    String name2 = revista2.getNome();

    int result = name1.compareTo(name2);

    if (result == 0) {

      return RecordComparator.EQUIVALENT;

    } else if (result < 0) {

      return RecordComparator.PRECEDES;               

    } else return RecordComparator.FOLLOWS;                                       

  }             

}

 Máximo de 25 caracteres

 Máximo de 45 caracteres

 A introdução deve ter no máximo 30 palavras (ou 150 caracteres)

 Use notas para mostrar informações que podem ficar mais separadas do texto – e para variar um pouco o ritmo.

 Máximo de 50 palavras.

 Links sem "http" e no menor formato possível – remover "www" (se possível) e documentos padrão, como "index.html" e "index.jsp"

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Ajude-nos a evoluir: você gostou do post?  (4)  (0)
Confirmar voto
Compartilhe:
Ficou com alguma dúvida?