Floggy é um framework para persistência de objetos em aplicações Java Micro Edition (JME). Seu principal objetivo é abstrair os detalhes da persistência de dados, reduzindo o esforço de desenvolvimento e manutenção de suas aplicações. Quem já trabalhou com persistência de dados em JME com RMS sabe o trabalho árduo que tínhamos em encapsular um objeto com as informações imputadas e então para grava-lo era preciso desencapsular este objeto para gravar seus atributos. Também era muito trabalhoso filtrar dados, ordena-los, etc. Mas isso é passado. Agora você não precisa mais escrever linhas e mais linhas de código para persistência, Floggy vai fazer o trabalho sujo para você!

Floggy está licenciado sob a licença Apache 2.0. Isso significa que você pode usar Floggy em projetos comerciais e open source.

Neste post vou mostrar como fazer a persistência de um objeto complexo com o framework Floggy. Vou implementar as operações de CRUD do objeto “Veiculo” como apresentado no diagrama abaixo, Figura 1.

floggy001

Figura 1

A classe “Veiculo” possui em um de seus atributos um tipo de dado complexo, a classe “Fabricante”. Floggy é experto o suficiente para gravar uma referência do objeto “Fabricante” em um registro de “Veiculo”, e quando um veículo for carregado temos a opção de carregar ou não o objeto fabricante com suas informações já encapsuladas.

Primeiramente vou apresentar as classes “Veiculo” e “Fabricante” para a implementação dos métodos para o CRUD em uma classe que chamei de “VeiculoDAO”.

Então, mão na massa.

Classe “Veiculo”:

import net.sourceforge.floggy.persistence.IDable;
import net.sourceforge.floggy.persistence.Persistable;

/**
 * Classe com informações sobre um veículo.
 * @author Ednei Parmigiani Júnior
 */
public class Veiculo implements Persistable, IDable {
	private int id;
	private Fabricante fabricante;
	private String placa;
	private String nome;
	private String modelo;

	/**
	 * construtor padrão
	 */
	public Veiculo() {
		super();
	}

// Getters e Setters...
}

Classe “Fabricante”:

import net.sourceforge.floggy.persistence.IDable;
import net.sourceforge.floggy.persistence.Persistable;

/**
 * Classe com informações de fabricante de veículos.
 * @author Ednei Parmigiani Júnior
 */
public class Fabricante implements Persistable, IDable {
	private int id;
	private String nome;

	/**
	 * Construtor padrão
	 */
	public Fabricante() {
		super();
	}

// Getters e Setters...
}

Observe que ambas as classes implementam as interfaces “Persistable” e “IDable” de floggy.

  • Persistable: Indica para o framework que uma classe é persistente, ou seja, é uma classe cuja suas instancias (objetos) serão gravados. Uma classe que implementa ou estende essa interface é considerada persistente. Por padrão, todos os atributos de uma classe persistente será mantido, exceto aqueles declarados como “transient” ou “static”.
  • IDable: Possui somente um atributo com o nome “id” que é do tipo “int” e um método (“setId”) para atribuição de valor para o atributo. É este atributo que o framework utiliza para atribuir um valor único (identificador RMS) para o objeto gravado. Caso necessite obter este identificador, basta implementar um método que retorne o valor da propriedade “id”. O método “setId” não tem efeito se for chamado pelo desenvolvedor, pois Floggy usa seu valor internamente para persistir os objetos.

Então, a classe para a persistência dos objetos:

import java.util.Vector;

import net.sourceforge.floggy.persistence.Comparator;
import net.sourceforge.floggy.persistence.Filter;
import net.sourceforge.floggy.persistence.FloggyException;
import net.sourceforge.floggy.persistence.ObjectSet;
import net.sourceforge.floggy.persistence.PersistableManager;

/**
 * Classe responsável pelo gerenciamento de veículos.
 * @author Ednei Parmigiani Júnior
 */
public class VeiculoDAO {
	private PersistableManager pm = PersistableManager.getInstance();

	/**
	 * Cria ou atualiza um registro de veículo.
	 * @param v Objeto do tipo {@link Veiculo}  com os dados a serem salvos.
	 */
	public void salvar(Veiculo v) {
		boolean isNovo = v.getId() == 0;
		Veiculo vu = new Veiculo();

		try {
			if (!isNovo) {
				pm.load(vu, v.getId(), false);

				vu.setFabricante(v.getFabricante());
				vu.setNome(v.getNome());
				vu.setModelo(v.getModelo());
				vu.setPlaca(v.getPlaca());
			} else {
				vu = v;
			}

			pm.save(vu);
		} catch (FloggyException e) {
			String op = isNovo ? "salvar" : "alterar";
			System.err.println("erro ao " +op+ " veiculo, erro: " + e);
		}
	}

	/**
	 * Exclui um registro de veículo.
	 * @param v Objeto do tipo {@link Veiculo} que será excluido.
	 * @return {@link String} Mesagem do ocorrido na operação sucesso ou erro de exclusão.
	 */
	public String excluir(Veiculo v) {
		boolean ex = false;

		try {
			pm.delete(v);
		} catch (FloggyException e) {
			ex = true;
			System.err.println("erro ao excluir veiculo, erro: " + e);
		}
		return ex ? "Erro ao excluir registro" : "Registro excluído com sucesso.";
	}

	/**
	 * Carrega uma relação de veículos de acordo com o filtro informado.
	 * @see VeiculoDAO#obterLista(Filter filter, Comparator comparator)
	 * @param filter Objeto do tipo {@link Filter} com a definição dos filtros.
	 * @return {@link Vector}
	 */
	public Vector obterLista(Filter filter) {
		return obterLista(filter, null);
	}

	/**
	 * Carrega uma relação de veículos ordenados de acordo com o comparator informado.
	 * @see VeiculoDAO#obterLista(Filter filter, Comparator comparator)
	 * @param comparator Objeto do tip {@link Comparator} com a definição da ordenação.
	 * @return {@link Vector}
	 */
	public Vector obterLista(Comparator comparator) {
		return obterLista(null, comparator);
	}

	/**
	 * Carrega uma relação de veículos.
	 * @see VeiculoDAO#obterLista(Filter filter, Comparator comparator)
	 * @return {@link Vector}
	 */
	public Vector obterLista() {
		return obterLista(null, null);
	}

	/**
	 * Carrega uma relação de veículos de acordo com os critérios informados.
	 * @param filter Objeto do tipo {@link Filter} com a definição dos filtros.
	 * @param comparator Objeto do tip {@link Comparator} com a definição da ordenação.
	 * @return {@link Vector}
	 */
	public Vector obterLista(Filter filter, Comparator comparator) {
		Vector veiculos = new Vector();

		try {
			ObjectSet os = pm.find(Veiculo.class, filter, comparator, false);
			for (int i = 0; i < os.size(); i++) {
				veiculos.addElement((Veiculo) os.get(i));
			}
		} catch (FloggyException e) {
			System.err.println("erro ao carregar veiculos, erro: " + e);
		}
		return veiculos;
	}
}
  • Linha 14, obtenho uma instância da classe “PersistableManager”. Esta classe fornece os métodos para as operações de CRUD.
  • Linha 21, verifico se atributo “id” do objeto passado como parâmetro possui um valor igual a zero. Casso possua, significa que é um novo veículo.
  • Linha 26, se a verificação da linha 25 for verdadeira, carrego o objeto veículo referente ao identificador do objeto passado como parâmetro e atualizo os valores das propriedades para que a alteração do objeto seja feita posteriormente.
  • Linha 33, se a verificação da linha 22 não for verdadeira, obtêm somente uma referencia do novo objeto informado para sua gravação em seguida. (Novo objeto na base a ser criado na base de dados).
  • Linha 36, se for um novo objeto, este será incluído na base de dados, caso contrário somente seus valores serão alterados.
  • Linha 52, deleta o registro referente ao objeto passado como parâmetro.
  • Linhas 66, 76 e 85 são métodos de conveniência para o método da linha 95 que obtém os objetos pertencentes à classe “Veiculo” cadastrados.

Em um próximo post, explico a utilização do objeto “Filter”(utilizado para filtrar registros) esperados nos métodos das linhas 66 e 95 e do objeto “Comparator”(para ordenação de registros) esperados nos métodos das linhas 76 e 95. E também os parâmetros esperados pelo método “find”, linha 99.

Para configurar o framework floggy em sua IDE de desenvolvimento e obter outras informações sobre o framework, acesse o site de floggy.

Por enquanto é isso, até o próximo post.

2 comentários para “Persistência de dados em JME com Floggy

  1. Pingback: Ordenar registros em JME com Floggy

  2. Pingback: Filtrar registros em JME com Floggy

Deixe um comentário

Campos obrigatórios são marcados *

Post Navigation