Descrição
O objetivo dessa
atividade é desenvolver um JavaBean gráfico, ou seja, um componente baseado
na tecnologia Java SE. Esse componente será uma caixa de texto que
apresentará a funcionalidade de validar o seu conteúdo, permitindo que o
usuário digite uma seqüência de caracteres ou dígitos e verificando se o
conteúdo satisfaz algum critério de validação. O componente poderá ser
utilizado para validar qualquer tipo de entrada, como CEP, CPF, número de
telefone, endereço de e-mail, etc.
O componente deverá
indicar de alguma forma se o conteúdo digitado é válido ou não. O componente
pode, por exemplo, modificar a cor do contorno da caixa de texto, ou exibir
um ícone ou uma mensagem de erro (ver a figura abaixo).
O componente deverá
ser testado na aplicação desenvolvida na Atividade
1, para facilitar o registro de participantes da promoção do shopping e a
localização de participantes já registrados, através da validação do número
de CPF, do CEP e do telefone do participante.
Implementação
do Componente Gráfico
Para
iniciar a construção do componente, primeiro crie um novo projeto no NetBeans
do tipo ‘Aplicativo Java’. Em seguida, clique no menu ‘Arquivo à Novo Arquivo’ e
crie um 'Objeto JavaBean' do tipo ‘Personalizador’.
Será
criado um painel no qual podem ser adicionados os componentes gráficos
necessários para executar o comportamento descrito.
Definição de Propriedades e Métodos do Componente
Você
deve definir as propriedades e os métodos que serão necessárias para
implementar a funcionalidade do componente.
Propriedades
podem ser geradas clicando com o botão da direita do mouse em qualquer ponto
do código-fonte da classe do componente, selecionando ‘Inserir Código’ e em
seguida clicando em ‘Adicionar propriedade’:
 
Na
janela ‘Adicionar propriedade’, especifique o nome, valor inicial e o tipo da
propriedade, e os métodos de acesso que devem ser gerados.
Em
alguns casos pode ser necessário adicionar código aos métodos de acesso
gerados automaticamente, para que seja executado o comportamento adequado. Se
preferir, você pode criar a propriedade manualmente, adicionando ao
código-fonte a declaração do atributo e os métodos de acesso, respeitando as
convenções de nomeação.
Defina
propriedades que permitam que o usuário customize o visual e o comportamento
do componente, para que ele possa ser usado em diversas aplicações. Exemplos
de propriedades que podem ser criadas são:
· conteudo: armazena a string digitada na caixa
de texto;
· iconeValido e iconeInvalido, ou corValido e
corInvalido, ou mensagemValido e mensagemInvalido: usados para modificar a
aparência do componente quando o conteúdo for válido ou não;
· valido: propriedade somente-leitura (que
contém apenas um getter) do tipo booleano para indicar se o conteúdo é
válido.
Também
deve ser criada uma propriedade chamada validador que irá receber um
objeto que implementará a interface Validador, mostrada abaixo, que
será responsável por efetuar a validação do texto digitado no componente.
public interface Validador
{
public
boolean validar(String conteudo);
}
Caso
julgue adequado, implemente outros métodos que possam ser necessários para
interação com o componente.
Tratamento de Eventos
Os
eventos gerados pelo bean devem ser tratados, para que ele apresente o
comportamento esperado. Sempre que ocorrer o evento Focus à focusLost
no componente deve ser efetuada a validação e, em seguida, devem ser
atualizadas características visuais do componente para indicar se o conteúdo
é ou não válido. Isso deve ser feito alterando o valor de propriedades e/ou
efetuando chamadas a métodos que ativem esse comportamento.
A
validação do conteúdo deve ser realizada executando o método validar(String
conteudo) do objeto indicado na propriedade validador do
componente, que implementa a interface Validador.
Quando
ocorrer uma alteração no estado do componente, essa alteração deve ser
indicada difundindo um evento. O evento deve indicar se o conteúdo digitado
pelo usuário é válido ou inválido. Para isso, devem ser definidas a interface
que será implementada pelos listeners do evento e a classe que
representa o evento.
import
java.util.EventListener;
public interface
ValidadorEventListener extends EventListener {
public
void conteudoOK(ValidadorEvent evt);
public
void conteudoInvalido(ValidadorEvent evt);
}
import
java.util.EventObject;
import
java.util.Date;
public class
ValidadorEvent extends EventObject {
private String conteudo;
private boolean valido;
public ValidadorEvent(Object source, String conteudo, boolean valido) {
super(source);
this.conteudo = conteudo;
this.valido = valido;
}
public void
setConteudo(String conteudo) { this.conteudo = conteudo; }
public
String getConteudo() { return this.conteudo; }
public
void setValido(boolean valido) { this.valido = valido; }
public boolean
isValido() { return this.valido; }
}
Os métodos para
adicionar e remover listeners de uma lista de tratadores do evento e
para disparar o evento são mostrados abaixo.
// Lista na qual são
armazenados os Listeners do evento ValidadorEvent
protected
javax.swing.event.EventListenerList validadorListenerList =
new javax.swing.event.EventListenerList();
// Método que registra os
Listeners para ValidadorEvent
public void
addValidadorEventListener(ValidadorEventListener listener) {
validadorListenerList.add(ValidadorEventListener.class, listener);
}
// Método que remove
Listeners de ValidadorEvent
public void
removeValidadorEventListener(ValidadorEventListener listener) {
validadorListenerList.remove(ValidadorEventListener.class, listener);
}
// Método que dispara
ValidadorEvent; chamado quando a validação é executada
void
fireValidadorEvent(boolean valido) {
Object[] list = validadorListenerList.getListenerList();
ValidadorEvent evt = new ValidadorEvent(this,conteudo,valido);
// Cada
listener ocupa 2 posições da lista: nome da classe e a instância
for (int i = 0;
i < list.length; i += 2) {
if (list[i] == ValidadorEventListener.class) {
if (valido == true) {
((ValidadorEventListener)list[i+1]).conteudoOK(evt);
} else {
((ValidadorEventListener)list[i+1]).conteudoInvalido(evt);
}
}
}
}
Descritor do Componente
Depois de
criado o componente, crie também uma classe do tipo BeanInfo, que fornecerá
informações sobre o componente. A classe BeanInfo pode ser criada através do
menu ‘Arquivo à Novo Arquivo’, na
categoria ‘Objetos JavaBeans’, e deve ser dado a ela um nome igual ao nome do
componente, acrescido de ‘BeanInfo’. Crie um construtor para o BeanInfo e
defina os valores dos seguintes atributos, que serão úteis para que o
componente seja exibido adequadamente no NetBeans:
·
iconNameC16:
arquivo com um ícone de 16x16 pixels colorido que represente o
componente;
·
iconNameC32:
arquivo com um ícone de 32x32 pixels colorido que represente o
componente;
·
iconNameM16:
arquivo com um ícone de 16x16 pixels monocromático que represente o
componente;
·
iconNameM32:
arquivo com um ícone de 32x32 pixels monocromático que represente o
componente;
·
beanDescriptor:
objeto da classe BeanDescriptor que contém o nome e uma descrição do
componente.
Edite também o arquivo ‘manifest.mf’,
localizado na pasta raiz do projeto, que pode ser acessado na janela
‘Arquivos’.
Especifique
o nome completo da classe e indique que se trata de um JavaBean.
Manifest-Version:
1.0
Name: /pacote/NomeDaClasse.class
Java-Bean: True
Por
fim, compile o projeto para que seja criado o arquivo de distribuição (JAR)
do componente.
Testando o Componente
Durante
seu desenvolvimento, o componente pode ser testado individualmente, criando
um método main() para teste na classe do componente.
public static
void main(String[] args) {
javax.swing.JFrame frame = new javax.swing.JFrame(); //
Cria frame
ValidadorBean bean = new ValidadorBean(); // Instancia o bean
// Alterar as propriedades que julgar necessárias aqui!
frame.add(bean); // Adiciona bean ao frame
frame.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
frame.setVisible(true); // Exibe o frame
}
Após
concluídos os testes, adicione o bean na paleta de componentes do
NetBeans, abrindo o ‘Gerenciador de Paleta’ - clique na paleta com o botão da
direita do mouse e escolha a opção ‘Gerenciador de Paleta’. Em seguida,
clique no botão ‘Adicionar JAR’, selecione o arquivo JAR do bean
(contido na pasta ‘dist’ do projeto) e o adicione à categoria ‘Beans’.
Para
finalizar a atividade, teste o componente na aplicação gráfica desenvolvida
na Atividade 1. Insira o componente na aplicação para digitação de CEP, CPF e
telefone. Configure as propriedades do componente e efetue as alterações
necessárias no código da aplicação. Implemente validadores para CEP e
telefone, e utilize essa classe para validar o
CPF. Trate os eventos enviados pelo componente, e exiba um JOptionPane
com uma mensagem de erro sempre que um conteúdo inválido for digitado. Quando
um CPF válido for digitado, verifique se o CPF já foi cadastrado e, em caso
positivo, busque os dados do participante e os exiba na tela.
Avaliação
A atividade deve ser desenvolvida em
duplas. A apresentação deve ser realizada até o dia 27/04. Os dois
integrantes do grupo devem estar presentes no momento da apresentação. Será
verificado o funcionamento do programa e em seguida os alunos devem responder
oralmente a questões formuladas pelo professor sobre o código fonte do
programa. Podem ser atribuídas notas diferentes aos integrantes de um grupo,
dependendo das respostas às perguntas sobre o código do programa efetuadas
pelo professor. Caso um dos alunos não esteja presente ou demonstre não
conhecer o código do programa, este ficará com nota zero na atividade. Em
caso de cópia do código de outro grupo, ambos terão nota igual a zero.
Referências
Dúvidas
Material
para Consulta
·
Help e
página do NetBeans.
·
Documentação
da API do Java.
Atendimento
aos Alunos
- Horário: Terças-feiras das 16:20 às
18:00.
- Local: Prédio do INE - Sala 305.
E-Mail
f r a n k @ i n f . u f s c . b
r
l a u . l u n g @ i n f . u f s
c . b r
Mantida por Frank
Siqueira. Atualizada em 15/04/2011.
|