Home > Artigos > Engenharia de Software >

OO e padrões de projeto: Criando um novo componente GUI e adicionando a um projeto existente

Publicado por jesuino em 16/08/2009 - 2.137 visualizações

comentários: 0

Objetivo: Gerar um elemento Swing que sugira termos de busca de acordo com o que o usuário insere em um campo de texto.
Origem: Esse é mais um artigo/tutorial/exemplo que parte aqui mesmo do JavaFree! Há muitos posts, houve uma pessoa aqui no fórum querendo um elemento como o descrito acima. Eu me interessei pelo problema, por ser uma idéia legal, e fiz uma possível solução, que acabei utilizando em um projeto acadêmico! Mas na época eu era muito novo com Java! Então, recentemente nesse post, uma outra pessoa estava com a mesma dúvida. Não consegui achar o post anterior e resolvi postar novamente o código. Nosso colega do post disse que o código estava muito complicado, não era impressão dele! Estava mesmo, e muito ridículo. Assim, propomos uma nova solução, reutilizável, encaixável em qualquer projeto! Ao longo desse artigo tentaremos observar os problemas que o código anterior poderia trazer, melhorando o mesmo código para ser mais re-utilizável!

O código antigo e seus problemas:
Um explicação do código antigo (Somente a view é necessária para explicar, o restante do código se encontra no post citado acima):
package view; import java.awt.event.FocusEvent; import java.awt.event.FocusListener; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import javax.swing.JComboBox; import javax.swing.JFrame; import javax.swing.JInternalFrame; import javax.swing.JTextField; import control.Control; public class Tela extends JFrame {    private JTextField txtBusca;    private Control control;    private JInternalFrame frmSug;    private JComboBox listSug;    public Tela() {       super("Exemplo de auto complete");       setDefaultCloseOperation(EXIT_ON_CLOSE);       setSize(300, 300);       setLayout(null);       txtBusca = new JTextField();       txtBusca.setBounds(100, 10, 150, 20);       add(txtBusca);       listSug = new JComboBox();       listSug.setBounds(100, 30, 150, 20);       listSug.setMaximumRowCount(4);       listSug.setVisible(false);       add(listSug);            control = new Control();       txtBusca.addFocusListener(new FocusListener() {          @Override          public void focusGained(FocusEvent arg0) {          }          @Override          public void focusLost(FocusEvent arg0) {             // listSug.setVisible(false);          }       });       txtBusca.addKeyListener(new KeyListener() {          @Override          public void keyPressed(KeyEvent e) {          }          @Override          public void keyReleased(KeyEvent e) {             if (txtBusca.getText().equals("")) {                listSug.setVisible(false);                return;             }             String dados[] = control.buscaSug(txtBusca.getText());             listSug.removeAllItems();             listSug.setVisible(true);             if (dados[0] == null){                dados[0] = "Não encontrado!!";             }                                        for (int i = 0; i < dados.length; i++) {                listSug.addItem(dados[i]);             }          }          @Override          public void keyTyped(KeyEvent e) {          }       });             listSug.addFocusListener(new FocusListener(){          @Override          public void focusGained(FocusEvent arg0) {                     }          @Override          public void focusLost(FocusEvent arg0) {             txtBusca.setText((String)listSug.getSelectedItem());                     }});    }    public static void main(String[] args) {       Tela teste = new Tela();       teste.setVisible(true);    } }

Se estiver perdido, leia um tutorial de como criar janela Swing
Explicando essa tralha toda:
Nosso objetivo é criar um elemento que compõe dois outros elementos já existentes. Conforme vocês podem ver, o código acima resolve o problema de auto-complete. A cada tecla digitada, ele bate no banco de dados, busca e retorna as sugestões, colocando-as em um JComboBox, antes invisível. Com o usuário selecionando um valor, o programa põe esse valor como parâmetro para busca e ainda indica quando não há valores no banco de dados. Isso é feito usando os eventos nos elementos: A cada caracter digitado no campo de texto, vamos para o banco, buscamos nossos campos relacionados e jogamos no JComboBox, como o foco perdido na combobox(o usuário "des-seleciona") passamos o valor como parâmetro de busca...

Se estiver perdido, leia um tutorial de como criar janela Swing
Funcionar até que funciona...
Na verdade isso é muito fácil de implementar, e existem muitas outras formas. Com certeza, não há problemas para o funcionamento do presente frame com o meu atual control! No entanto, temos problemas quanto a flexibilidade, visibilidade de código, reutilização, entre outros. É ai que entra nosso papel de deixar esse código brilhando, sem macumba nem vudu, somente com Orientação a Objeto e Padrões de Projeto.
Vamos analisar o código. Imagine-se na seguinte situação: você tem reutilizar o componente proposto, o projeto já está compilado em arquivos .class, como você vai fazer? Você tem acesso ao Frame, mas e daí? Você quer utilizar somente o recurso de auto-complete. Para os espertinhos de plantão, é possível sim pegar o campo de texto e o combobox do frame, mas isso de nada servirá, pois a lógica de realizar a função destinada está dentro do frame... Enfim, um grande problema! Uma solução é você fuçar no código fonte de sua aplicação antiga e "sugar" a forma que foi feito, para repetir código e gerar outra solução específica. Olha, dois pecados graves: Repetir Código e Gerar uma solução específica. E outro problema maior seria sua demissão, pois até você pegar o código, reler, re-entender, aplicar novamente no seu problema atual: game over...
Onde foi que erramos???
O que gerou nosso problema foi a má idéia de não separar algumas classes da classe que utiliza. Não usamos composição e nem encapsulamento. Também fomos egoístas, fizemos uma solução para este projeto sem pensar nas consequências e nem nos projetos de nossos amigos... Nosso primeiro objetivo é separar o que nos interessa desse frame, que deveria ser feito no primeiro momento, mas não foi!
Muitos podem pensar: "Ninguém deixa um códígo dentro do outro assim, esse é só um exemplo". Sim, nesse exemplo é verdade que está explícita a necessidade de separação, mas podemos achar outros pontos que não são tão visíveis para serem separados, pois podem ser usados futuramente.

Me liberte do seu Control
Temos que libertar a busca de dados para preencher o componente do nosso atual controller. Ou seja: o auto complete não deve conhecer um controller especificamente, mas uma forma genérica de controller.
É bobeira para o nosso componentes conhecer o controller, sendo que ele simplesmente quer os dados. A classe control pode ter diversos métodos, mas você precisa só de um. Você tem que identificar o que é necessário para o seu componente... No nosso caso, por mais que a classe conheça o controller inteiramente você só quer o método que retorna os dados para sugestão de auto preenchimento!

Vamos usar uma interface!!!!!!!!!!!!!!!!!!!!!!!!!!

Assim o autocomplete compõe a interface e não o control, e ele passa a implementar a interface! Observe a simplicidade de nossa interface:
public interface IFonteDados {       /*     * Esse método deverá retornar as sugestões para a GUI     * */    public String[] buscaDados(String pusca); }

Retomando: Queríamos tirar o autocomplete de nossa telinha de teste para usar em outros projeto, mas ele estava muito ligado ao nosso control. Analisando o código, descobrimos que simplesmente um método é necessário. Assim fizemos uma interface.

Separação fisíca do auto complete
A separação fisíca é mais estética. Optamos por colocar nosso componente em um JPanel simples... Também fizemos métodos de acesso aos dois componentes do painel(O campo de texto e o comboBox). Olhe como ficou:
/* * Painel para realizar auto complete com JavaSwing * * by William Antônio Siqueira * * Um JComboBox fica escondido embaixo de uma campo de texto. * Quando o usuário começa a digitar, vamos ao banco de dados * e buscamos as palavras que têm as letras como iniciais ou * que que contenham as letras digitadas. * Mostramos o comboBox com as sugestões, com um listener no combo, * podemos usar as sugestões do usuário. * Para que as sugestões apareçam em tempo real, um listener é adicionado * ao campo de texto Alvo * Você deve enviar para esse painel, uma classe que implemente a interface * IFonteDados * */ import interfaces.IFonteDados; import java.awt.GridLayout; import java.awt.event.FocusEvent; import java.awt.event.FocusListener; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import javax.swing.JComboBox; import javax.swing.JPanel; import javax.swing.JTextField; public class PainelAutoComplete extends JPanel {    private static final long serialVersionUID = 1L;    private JTextField txtBusca;    private IFonteDados fonteDados;    private JComboBox listSug;    public PainelAutoComplete(IFonteDados fonte) {       super(new GridLayout(2,1));       this.fonteDados = fonte;            setSize(300, 300);                   txtBusca = new JTextField();            add(txtBusca);             listSug = new JComboBox();            listSug.setMaximumRowCount(4);       listSug.setVisible(false);       add(listSug);       txtBusca.addKeyListener(new KeyListener() {          @Override          public void keyPressed(KeyEvent e) {          }          @Override          public void keyReleased(KeyEvent e) {             if (txtBusca.getText().equals("")) {                listSug.setVisible(false);                return;             }             /*              * Aqui é onde usamos o estratégia para buscar os dados A fonte,              * desde que implemente nossa interface IFonteDados, pode ser um              * banco de dados, arquivo de texto e outros, sendo que a busca              * de dados é encapsulada pelo padrão estratégia              */             String dados[] = fonteDados.buscaDados(txtBusca.getText());             listSug.removeAllItems();             listSug.setVisible(true);             if (dados[0] == null) {                dados[0] = "Não encontrado!!";             }             for (int i = 0; i < dados.length; i++) {                listSug.addItem(dados[i]);             }          }          @Override          public void keyTyped(KeyEvent e) {          }       });       listSug.addFocusListener(new FocusListener() {          @Override          public void focusGained(FocusEvent arg0) {          }          @Override          public void focusLost(FocusEvent arg0) {             txtBusca.setText((String) listSug.getSelectedItem());          }       });    }    public JTextField getTxtBusca() {       return txtBusca;    }    public void setTxtBusca(JTextField txtBusca) {       this.txtBusca = txtBusca;    }    public JComboBox getListSug() {       return listSug;    }    public void setListSug(JComboBox listSug) {       this.listSug = listSug;    }     }

Para usar esse painel é simples, você somente precisa fazer o control implementar o método!
package control; import interfaces.IFonteDados; import java.sql.ResultSet; import java.sql.SQLException; import dao.DaoNome; public class Control implements IFonteDados{    private DaoNome daoNome;       String dados[];    public Control() {       daoNome = new DaoNome();    }    @Override    public String[] buscaDados(String texto) {       ResultSet rs = daoNome.buscaDadosPessoais(texto);       int i = 0;       // Vamos limitar a 10 sugestões ;)       dados = new String[10];       try {          for (i = 0; rs.next() && i < dados.length; i++) {             dados[i] = rs.getString("nome");             System.out.println(i + " - " + dados[i]);          }       } catch (SQLException e) {          e.printStackTrace();       }                 return dados;          } }

Terminamos, olhe uma classe de teste, que linda que ficou:
import javax.swing.JFrame; import paineis.PainelAutoComplete; import control.Control; public class Tela extends JFrame {    private static final long serialVersionUID = 1L;    //O controle implementa IFonteDados    private Control control;        //O painel de autoComplete    private PainelAutoComplete pnlAutoComplete;        public Tela() {       super("Exemplo de auto complete");       setDefaultCloseOperation(EXIT_ON_CLOSE);       setSize(300, 300);       setLayout(null);             control = new Control();             pnlAutoComplete = new PainelAutoComplete(control);       pnlAutoComplete.setBounds(5,5, 200,50);       add(pnlAutoComplete);                }    public static void main(String[] args) {       Tela teste = new Tela();       teste.setVisible(true);    } }
Agora vamos usar em um outro projeto comprovando a flexibilidade!

Errrrr.... não tenho o código dos controllers, eles já estão compilados em bytecodes...

E agora??

O desenvolvedor derrotado, que não leu a teoria dos padrões:
Nossa... Trabalho perdido para projetos já existentes...

Você! A partir de hoje:
Eu tenho uma solução para isso.

Sim, há uma solução! Você pode utilizar uma classe intermediária que implementa a interface (então nosso componente vai "aceitar" a classe) e conhece o controle. Assim você não mexe no seu projeto existente e nem no componente que propomos. O nome desse padrão é Adapter. Ele permite que você conecte dois elementos adaptando interfaces, sendo que os componentes envolvidos não precisam se conhecer! Exatamente a solução para nosso caso. No nosso caso, temos a interface mostrada acima e o nosso controller que precisamos adaptar para a interface sem mexer no código existente. Nossa interface é uma variação desse padrão, olhe como ficou:
package view; import interfaces.IFonteDados; import control.Control; public class ControlAdapter extends Control implements IFonteDados {    @Override    public String[] buscaDados(String texto) {            return super.buscaSug(texto);    } }

Usando o Adapter, finalizamos com um exemplo:
package view; import javax.swing.JFrame; import paineis.PainelAutoComplete; public class Tela extends JFrame {    private static final long serialVersionUID = 1L;    //Um adaptador para não mexer no nosso controle    private ControlAdapter control;        //O painel de autoComplete    private PainelAutoComplete pnlAutoComplete;        public Tela() {       super("Exemplo de auto complete");       setDefaultCloseOperation(EXIT_ON_CLOSE);       setSize(300, 300);       setLayout(null);              control = new ControlAdapter();              pnlAutoComplete = new PainelAutoComplete(control);       pnlAutoComplete.setBounds(5,5, 200,50);       add(pnlAutoComplete);    }    public static void main(String[] args) {       Tela teste = new Tela();       teste.setVisible(true);    } }
Perceba que instanciamos o ControlAdapter na view, sem mexer sequee uma linha no controller, e temos o projeto funcionando de forma visível, com código limpo!

FAQ's:

->Tem coisas a melhorar???
Muitas!

->Esse modelo pode não ser o mais flexível???
Sim, com certeza existem formas de melhorar esse modelo adotado!

Estamos aguardando sugestões, críticas, comentários no fórum!

Um pequeno desafio:
Desafiamos você a tentar usar esse componente em algum projeto existente e comentar no fórum as necessidades e problemas enfrentados!

Tópicos Relacionados


• HashSet  
• Delphi + Java  
• JScrollPane ????? Duvida  
• GUI...componentes...  
• JTable em JScrollPane  
• Livro para iniciante em Java  
• JComboBox não exibe  
• Mensagens que não tinham tópicos  
• Existe alguma classe/Componente GUI onde eu possa formatar  
• Interfaces  
• JFileChooser - ordem de exibição dos "FileFilters"  
• como faço isso  
• O PHP É BEM MAIS RÁPIDO EM ACESSO A BANCO DO QUE O JSP!  
• Parte complexa em O.O  
• Ler um arquivo txt no J2ME  

Home Sobre Empregos Blogs Anuncie

O JavaFree.org é uma comunidade java formada pela coolaboração dos desenvolvedores da tecnologia java. A publicação de artigos além de ajudar a comunidade java, ajuda a dar maior visibilidade para o autor. Contribua conosco.

© Copyright JavaFree.org - Java
Design: Luka Cvrk  |  Desenvolvimento: Dalton Camargo  |