O que é um listener ? Como fazer um ?

Olá amigos do Preciso Estudar Sempre, meu nome é João Paulo e minha paixão é estudar. O tema de hoje é de nível intermediário e para falar sobre ele precisamos entender o básico de programação e de Java Swing. Caso você não possua esses conhecimentos, recomendo que você volte aqui um pouco mais tarde.

Vamos aprender aqui o que são listeners e como construir um nosso. Se você já sabe o que é um listener, pule essa parte da explicação mas, se você não sabe, aperte seu cinto pois, a viagem está preste a começar.

Um listener é um ouvinte. Nesse momento, você pergunta: "Como assim um ouvinte?" Bem, vamos melhorar essa definição !

Um listener é uma estrutura programada que ouve eventos os quais, foram registrados para ele. Ainda não entendeu ? Quando eu digo ouvir, não quer dizer que uma orelha magicamente irá aparecer na sua tela. Quero dizer que uma parte de seu programa será acionada assim que um evento for realizado. Por evento, podemos imaginar clicks, focus em campos, retirada de focus em campos, parar o mouse em cima de algo, tirar o mouse de algo, mover o mouse, mudar um valor, entre outros. Vamos para um exemplo ?

Imagine a seguinte tela:

Figura 1 - Tela

Quando clicamos no botão "Confirmar", os dados da tela devem ser gravadas no banco de dados mas, como o botão consegue acionar o método que realiza a gravação no banco ? A resposta é: precisamos adicionar um listener de click àquele botão. Após adicionado, o listener conseguirá ouvir todos os eventos de click daquele ou de vários botões e realizará o processamento programado.

No Java Swing isso é feito da seguinte forma:

1 - Classe da tela.

 //construtor da tela  
 public Tela(){  
      initComponents();  
      MeuClickListener meuClickListener = new MeuClickListener();  
      jButton1.addActionListener(meuClickListener);  
 }  

2 - Classe que trata os eventos de click

 public class MeuClickListener implements ActionListener{  
      @Override  
      public void actionPerformed(ActionEvent e){  
      }  
 }  

Independente de estarmos na web, desktop, mobile ou na programação distribuída, os conceitos continuam o mesmo. Acima temos, o evento, o listener e a associação, respectivamente, o click, a classe MeuClickListener e a associação feita através da linha jButton1.addActionListener(meuClickListener);  

Espero que o conceito base de listener tenha ficado bastante claro na sua mente pois, agora iremos construir o nosso.

Siga os seguintes passos:

1 - Crie um projeto Java em sua IDE.

2 - Crie a interface Listener.

 public interface Listener {  
      public void receivedEvent(Event event);  
 }  

A interface Listener representa um listener geral, o qual trata um evento qualquer. Se quisermos listeners mais específicos, como por exemplo: ActionListener, WindowListener, podemos criar nossas próprias interfaces, com nossos próprios métodos.

3 - Crie a classe ListenerClick.

 public class ListenerClick implements Listener {  
      @Override  
      public void receivedEvent(Event event) {  
           System.out.println("Eu trato os eventos de click desse sistema.");  
           System.out.println("Dados do evento recebido: ");  
           System.out.println("Nome: " + event.getName());  
           System.out.println("Hash code do objeto que gerou o meu evento: " + event.getHashCodeOrigem());  
      }  
 }  

Precisamos criar uma implementação para o nosso listener porque é aqui que trataremos de fato os eventos (MeuClickListener).

4 - Crie a classe Event.

 public class Event {  
   private String name;  
   private int hashCodeOrigem;  
   public Event(String name) {  
     super();  
     this.name = name;  
   }  
   public String getName() {  
     return name;  
   }  
   public void setName(String name) {  
     this.name = name;  
   }  
      public int getHashCodeOrigem() {  
           return hashCodeOrigem;  
      }  
      public void setHashCodeOrigem(int hashCodeOrigem) {  
           this.hashCodeOrigem = hashCodeOrigem;  
      }  
 }  

Essa classe representa o evento mas, podemos criar nossas próprias classes de eventos, com atributos e métodos próprios.

5 - Crie a classe Dispatcher.

 import java.util.HashSet;  
 import java.util.Iterator;  
 import java.util.Set;  
 public class Dispatcher {  
   private static Dispatcher instance;  
   private Set<Listener> listeners;  
   private Dispatcher() {  
     this.listeners = new HashSet<Listener>();  
   }  
   public static Dispatcher getInstance() {  
     if (instance == null) {  
       instance = new Dispatcher();  
     }  
     return instance;  
   }  
   public void addListener(Listener listener) {  
     this.listeners.add(listener);  
   }  
   public void removeListener(Listener listener) {  
     this.listeners.remove(listener);  
   }  
   public void dispatchEvent(Event event) {  
     Iterator<Listener> iterator = listeners.iterator();  
     while (iterator.hasNext()) {  
       Listener listener = (Listener) iterator.next();  
       listener.receivedEvent(event);  
     }  
   }  
 }  

A classe Dispatcher é uma das classes mais importante porque é nela onde os listeners serão adicionados ou removidos. Os listeners adicionados são mantidos em uma lista para que sejam disparados mais tarde os métodos de tratamento de eventos.

6 - Crie a classe Main.

 public class Main {  
      private ListenerClick listenerClick = new ListenerClick();  
      public Main() {  
           Dispatcher.getInstance().addListener(listenerClick);  
      }  
      public static void main(String[] args) {  
           Main main = new Main();  
           Event eventoOnClick = new Event("represento um onClick");  
           eventoOnClick.setHashCodeOrigem(main.hashCode());  
           Dispatcher.getInstance().dispatchEvent(eventoOnClick);  
      }  
 }  

A classe Main é uma classe de exemplo, é onde botamos nosso listener para funcionar. Nessa classe instanciamos um listener de clicks, adicionamos esse listener no dispatcher e logo em seguida, disparamos um evento para todos os listeners registrados.

Notou que os mesmos passos que realizamos no Swing são os mesmos no nosso próprio sistema ? Instanciamos um listener, criamos um evento e adicionamos o listener. A única diferença do nosso sistema para o Java Swing, o qual está sendo usado como exemplo, é que o dispatch é feita pela própria classe do JButton e no nosso sistema precisamos realizar essa dispatch manualmente.

Sinta-se à vontade para modificar esse projeto a vontade, o objetivo desse post é passar a idéia básica dos listeners. A partir daí, você pode evoluir o quanto quiser a idéia.

Para baixar o projeto pronto, clique aqui.

Dúvidas !? Sugestões ?! Críticas ou elogios ?!

Deixe aí nos comentários ou na nossa página do facebook.

Facebook: https://www.facebook.com/precisoestudarsempre/

Referências:
Listener em Java - http://www.mews.com.br/dev/java/criando-listener-em-java/