Floggy - problema com objetos que referenciam um ao outro

Mobile
#1

Minha dúvida é a seguinte: é possível, utilizando Floggy, persistir um objeto que possui um campo contendo um objeto filho que, por sua vez, possui um campo que aponta para seu pai?

Criei uma estrutura de classes que precisam desse comportamento, mas meu programa não está funcionando quando tento salvar os objetos.

Um exemplo básico:

[code]public class Pai implements Persistable{
String nome;
Filho filho;
}

public class Filho implements Persistable {
String nome;
Pai pai;
}

public void startMIDlet() {
PersistableManager pm = PersistableManager.getInstance();

    Pai pai = new Pai();
    Filho filho = new Filho();
    
    pai.nome = "nome do pai";
    pai.filho = filho;

    filho.nome = "nome do filho";
    filho.pai = pai;

    try {
        pm.save(pai); //não executa, a execução para aqui.
        pm.save(filho);
    } catch (FloggyException ex) {
        ex.printStackTrace();
    }
  
}[/code]

Ao depurar o código, percebi que ele para no trecho pm.save(pai). Ao chegar nessa linha, o programa não faz mais nada, mas também não dá erro. Achei o comportamento bem estranho. Simplesmente não executa essa linha nem o que vier depois dela.

Se eu substituo o trecho filho.pai = pai por filho.pai = new Pai() o código funciona. Mas não é o que eu quero, como deu pra perceber.
Alguém tem alguma idéia do que está havendo?

Agradeço muito qualquer dica rápida, pois estou suspeitando de que isso possa ser algo que o Floggy não suporte e, como estou com urgência, vou acabar fazendo alguma POG (gambiarra) para resolver…

#2

Primeiramente encapsule estes atributos. [ private + get e set ]

#3

Editado - Eu uso o Floggy desta maneira tbm.

public class ConteudoBean implements Persistable{
   private String Palavra,Traducao,Audio,Imagem,Video,Frase;
   private int Tipo;

    public ConteudoBean(String palavra, String traducao, String audio, String imagem, String video, String frase, int tipo) {
        this.Palavra = palavra;
        this.Traducao = traducao;
        this.Audio = audio;
        this.Imagem = imagem;
        this.Video = video;
        this.Frase = frase;
    }

    public String getAudio() {
        return Audio;
    }

    public void setAudio(String Audio) {
        this.Audio = Audio;
    }

    public String getFrase() {
        return Frase;
    }

    public void setFrase(String Frase) {
        this.Frase = Frase;
    }

    public String getImagem() {
        return Imagem;
    }

    public void setImagem(String Imagem) {
        this.Imagem = Imagem;
    }

    public String getPalavra() {
        return Palavra;
    }

    public void setPalavra(String Palavra) {
        this.Palavra = Palavra;
    }

    public String getTraducao() {
        return Traducao;
    }

    public void setTraducao(String Traducao) {
        this.Traducao = Traducao;
    }

    public String getVideo() {
        return Video;
    }

    public void setVideo(String Video) {
        this.Video = Video;
    }

    public int getTipo() {
        return Tipo;
    }

    public void setTipo(int Tipo) {
        this.Tipo = Tipo;
    }


}

Faz uma classe de para tratar a persistência


public class RecordHistory {
    //instancia um vetor (array)
    private Vector vector;
    private MovLang midlet;
    private int index;


    //método construtor da classe
    public RecordHistory(){
    }

    //método getReserve - pega os dados de resultado (no caso ligado ao historybean e ao "result" de connectionMain)
    // e coloca em um novo vetor para armazenar como se fosse um banco de dados
    public Vector getConteudo() {
        vector = new Vector();
        //getInstance pega todas as informações,
        //cria objetos "itens" para preencher o vetor(array) size para varrer o array e preencher com elementos
        //traduzindo preenche o banco de dados com o resultado...

        
        try {
            PersistableManager pm = PersistableManager.getInstance();
            ObjectSet itens = pm.find(ConteudoBean.class, null, null);
            int size = itens.size();
            for (int i=0; i < size; i++ ){
                ConteudoBean cb = (ConteudoBean)itens.get(i);
                vector.addElement(cb);
            }
        } catch (FloggyException ex) {
            ex.printStackTrace();
        }
        return vector;
    }

    //método para salvar este "banco de dados"
    public void save(ConteudoBean cb){
        try {
           PersistableManager.getInstance().save(cb);
        } catch (FloggyException ex) {
            ex.printStackTrace();
        }
    }
  //modo excluir todos os registros de tudo
    public void excALL(){
           //PersistableManager.getInstance().delete(hb);
            try {
            PersistableManager pm = PersistableManager.getInstance();
            pm.deleteAll();
            } catch (FloggyException ex) {
            ex.printStackTrace();
            }
    }

//método que exclui todo conteúdo
    public void excTC(){            
           //PersistableManager.getInstance().delete(hb);
            try {
            PersistableManager pm = (PersistableManager) PersistableManager.getInstance();
            ObjectSet itensCont = pm.find(ConteudoBean.class, null, null);
            int size = itensCont.size();
              for (int i=0; i < size; i++ ){
                ConteudoBean cb = (ConteudoBean)itensCont.get(i);
                pm.deleteAll(ConteudoBean.class);
              }
            } catch (FloggyException ex) {
            ex.printStackTrace();
            }
    }

//método q exclui um conteúdo selecionado na LIST 

    public void excOne(MovLang midlet, int index){
        this.midlet = midlet;
        this.index = index;
        PersistableManager pm;

        if (midlet.getFmHist().getLtConteudo() != null){
            try {
            
            // Variável criada para especificar qual elemento será excluído
            Persistable excluir;
            //int ind = ltHist.getSelectedIndex();
            pm = PersistableManager.getInstance();
            ObjectSet itens = PersistableManager.getInstance().find(ConteudoBean.class, null, null);
            //define o item pelo index (posição) que o user está
            excluir = itens.get(index);
            pm.delete(excluir);
            midlet.getFmLogin().getDialogInstanceLogin("Aviso", "Conteudo deletado com sucesso").show();            
            midlet.getFmHist().repaint();
            
            
            } catch (FloggyException e) {
           // System.out.println("Erro ao iniciar Função (Excluir)");
            }
        } else{
           midlet.getFmLogin().getDialogInstanceLogin("Alerta","Nenhum conteúdo encontrado!").show();
           
           }
    }
}

Então chama o save em um método depois de tratado os dados.

ConteudoBean cb = new ConteudoBean(palavra, traducao, audio, imagem, video, frase, tipo);
       
       //chama no midlet o método de que retorna a classe RecordHistory, chama o save.
       midlet.getRecHist().save(cb);

Se quiser excluir trata os dados e chama o

Acho que vai ajudar todos que estão estudando Floggy.

Espero que ajude! Dá um retorno.

#4

Olá pessoal, agradeço a ajuda, mas continuo sem solução para o meu problema. O problema acontece independente da forma como estão organizadas as classes. O que ocorre é que não é possível salvar um objeto se esse tem um filho que o tem como pai.

No meu programa original, os atributos estão encapsulados. O exemplo que eu coloquei aqui foi só para efeito didático.
O que eu quis demonstrar é que depois que faço as seguintes atribuições:

pai.filho = filho; filho.pai = pai;
E tento salvar qualquer um dos dois objetos, o programa trava. É esse o X da questão. Parece que os objetos não podem se referenciar mutuamente…

Vingard, não considero a sua solução uma Pog. Eu já faço dessa forma e a considero uma boa prática, já que divide o projeto em camadas. De qualquer forma, também não resolve, pois na hora de chamar o método save() do Floggy, não importa quem chamou e como, se o objeto a ser salvo possuir as característica que citei (pai e filho) vai dar pau. Pelo menos é o que que está acontecendo comigo. Se alguém quiser testar esse meu código de exemplo para ver se faz funcionar, eu agradeço muito.

A gambiarra que estou pensando em fazer, caso não haja solução, é criar uma Hashtable que indique quem está associado a quem. Dessa forma, para eu saber quem seria o pai ou filho de um objeto, por exemplo, eu o procuraria na Hashtable e retornaria o objeto associado. Dessa forma, os campos “pai” e “filho” (exemlo didático) não existiriam nas classes. Só que isso é muito deselegante. Na verdade é uma POG medonha.

#5

Cara, quando vc trabalhar com uma massa de dados muito grande acessando esses atributos muitas vezes, vc vai querer deixar eles públicos, vai por mim, experiência própria.

#6

Saquei, na real foi falta de atenção minha, foi mal, comecei respondendo uma coisa, fui fazer outro lance quando voltei resolvi postar um ex. de floggy… editei ali em cima. Não tenho tempo de testar agora mas será q tratando no “Paibean” um método para retornar algo da classe filho e vice - versa?

#7

Boa noite caros,

O Floggy não permiti a referência circular dos objetos.

Um abraço

#8