[RESOLVIDO] Ordem de 2 listeners

This message was edited 1 time. Last update was at 04/12/2008 14:52:04

Pessoal.

Estou com um problema quanto à utilização de Listeners em um componentes Swing.

Meu componente (uma tabela) já possui um ActionListener, que ás vezes faz alguns carregamentos nas linhas (buscas a banco , formatações e outras coisinhas...).

Eu precisei adicionar outro ActionListener, porque estou em outra classe e não a enxergo, então não pude colocar meu processo no meio dos métodos executados pelo outro Listener. Só que eu preciso que os processos que serão executados no novo Listener sejam executados DEPOIS daqueles que são executados pelo primeiro. Existe algum modo de eu garantir a ordem da execução?

Não sei se dá para garantir a ordem de execução à partir da ordem de inserção dos listeners.
Uma sugestão para garantir a ordem de execução é que os listeners que precisam ser executados depois sejam adicionados como listeners dos que precisam ser executados antes.
Ou seja, você adiciona seus listeners na sua tabela e os listeners que precisam ser executados depois você adiciona como listeners destes primeiros.

davidtiagoconceicao wrote:
Ou seja, você adiciona seus listeners na sua tabela e os listeners que precisam ser executados depois você adiciona como listeners destes primeiros.

Eu posso fazer isso?

Tipo... Eu tenho um ActionListener na tabela, e ele tem o método propertyChange, que é executado quando tem uma alteração na tabela (praticamente tudo, mudança de selção, exclusão... várias coisas). E eu quero esse mesmo evento para o meu segundo Listener, eu tenho como implementar isso?

Se der, eu posso fazer isso tranquilo...

Sim, é perfeitamente possível, mas dependendo da sua implementação até o momento, pode exigir algumas alterações.
Você criou duas classes que implementam os determinados listeners, certo? Para facilitar, vou chamar de classe A e classe B.
Supondo que a classe A precisa ser avisada antes da classe B, o que precisa ser feito é:
- Dentro da classe A:
- criar um atributo para armazenar um ou um conjunto de listeners que esta classe irá avisar (ArrayList, por exemplo).
- criar métodos que adicionem e removam listeners na variável anterior (add e remove).
- no determinado momento que você gostaria que estes listeners fossem acionados, você chama os métodos do listener. Por exemplo, se são listeners de ActionPerformed, você percorre a estrutura de listeners adicionados e invoda o método actionPerformed.
- Dentro da classe B:
- Implementa a interface dos listeners que serão adicionados em A.
- Em algum outro ponto do seu sistema você adiciona instância(s) de B como listeners de A chamando os métodos que você criou.

Espero ter sido claro.
Qualquer dúvida poste aí!

This message was edited 1 time. Last update was at 04/12/2008 10:37:58

Cara...

Foi mal, mas não consegui entender direito. Eu particularmente não entendo muito de eventos, nem sei o que é padrão do Java e o que tem de implementações do próprio código aqui da empresa... mas eu vou colocar as partes do códigos que eu estou usando.

É só isso que eu faço ( o primeiro código foi até o NetBeans que fez, como dá para perceber ).

O que eu quero é garantir que o meuMetodo seja executado depois do MinaTabelaPropertyChange...

Tipo... eu não criei classes diferentes pros meus Listeners... achei que não precisaria...

Tudo bem cara, está indo pelo caminho certo...

Listeners são baseados no padrão Observer. E funcionam mais ou menos assim: um objeto que permite ser observado cria métodos
para adicionar e remover listeners e têm como parâmetros objetos que implementam determinada interface. Ou seja, para observar
outro objeto, um objeto deve implementar uma determinada interface. Conforme necessário, o objeto observado percorre a estrutura
em que os listeners foram adicionados invocando um determinado método da interface.

Falando do seu caso.

Neste trecho de código o que o NB fez foi gerar um código no qual um objeto é instanciado através de uma chamada classe anônima: é instanciado um objeto que implementa a determinada interface, porém sem ser à partir de classe alguma. Para tratar o evento, o método MinhaTabelaPropertyChange é invocado.
Assim, o que você precisa fazer é criar uma classe que implementa java.beans.PropertyChangeListener, instanciar um objeto desta classe e adicionar esta instância como listener da tabela através do método addPropertyChangeListener. Isto pode ser feito no construtor da classe, por exemplo.
Dentro desta classe, crie métodos para adicionar e remover listeners conforme uma interface que você definir. Depois, dentro dos métodos percorra a lista de listeners invocando os métodos conforme necessário.

Entendi. Ao invés de adicionar

Eu adiciono um

E essa classe MeuListener também precisa ter o método addPropertyChangeListener??

Ela precisa ter um método addInterface.
Se você utilizar a interface PropertyChangeListener, então deverá ser um método addPropertyChangeListener.

Mas e como eu faço pra disparar o evento?

Tipo... o evento que o MeuListener vai pegar executará algo, e depois, como faço para que o Listener que eu tiver adicionado a ele chame o meu segundo método? Não deve ser automático...

Supondo que você tenha escolhido como interface a PropertyChangeListener, no ponto em que você deseja acionar os listeners, você faria algo mais ou menos assim:

Não entendi direito de onde veio essa List listeners...

Eu tenho meu listener agora:

aqui eu adicionei ele na minha tabela:

Agora ele chega no propertyChange do MeuListener, e chama aquele primeiro método corretamente. Mas e como faço pra executar o meuMetodo??

O atributo listeners seria a sua lista de listeners. Sua classe ficaria mais ou menos assim:

Valeu David.

Vou testar tudo aqui.

Beleza, qualquer coisa estamos aí!

Olha... fiquei com uma dúvida agora. Minha classe ficou assim:

Assim que eu conseguir fazer esses eventos em seqïencia, vai ficar barbada... =D

Notícias, artigos e o maior fórum brasileiro sobre Java