Um componente JavaBeans é um componente de software reusável escrito na linguagem de programação Java. Você escreve JavaBeans como escreve qualquer outra classe Java. Você pode também usar componentes existentes, applets ou classes Java como JavaBeans.
Esse tutorial tem dois objetivos:
- Ensinar o básico para a criação de JavaBeans.
- Explicar os conceitos básicos por trás do JavaBeans e mostrar como esses conceitos se relacionam com técnicas práticas de programação.
Para poder seguir esse tutorial, você precisa ter os seguintes itens instalados na sua máquina:
Esse tutorial não substitui a especificação do JavaBeans, mas fornece exemplos concretos e guias passo a passo para a construção e uso dos JavaBeans. Leia as seções correspondentes da especificação em conjunto com esse tutorial. Você pode também achar útil os exemplos de código fornecidos como o BDK.
Definição: O que é um Bean?
Se você já usou ferramentas como Delphi ou Visual Basic deve estar familiarizado como a noção de bean. Um JavaBean é um componente reutilizável escrito em Java. Pode ser visualmente manipulado como ferramentas de construção de software. Um JavaBeans é frequentemente referenciado simplesmente como Beans.
Componentes de software são unidades auto-suficientes e reutilizáveis. Usando uma ferramenta de contrução de aplicações visual, componentes de software podem ser compostos por applets, aplicações, servlets e componentes de composição. Você executa essa composição dentro de uma interface gráfica, e pode imediatamente ver os resultados de seu trabalho.
Componentes de software reutilizáveis
Componentes de software reutilizáveis aplicam o conceito de partes intercambiáveis ao campo da construção de software. Outras indústrias tem lucrado com o uso de componentes reutilizáveis. Por exemplo, a ferramenta abaixo mostra um componentes de calculadora que é contruída com 16 botões, um campo de texto e um painel como botões e um display de texto.
Componentes de software reutilizáveis podem ser simples, como botões, campos de textos, caixas de listagem, barra de rolagem e caixas de diálogos.
Button Beans
Slider Beans
Os componentes acima são tradicionalmente disponibilizados por terceiros. Mais recentemente, distribuidores estão disponibilizando componentes de software, como calendários e planilhas de cálculo:
Spreadsheet
Se você usar um ferramenta de montagem de componentes visual, como Visual Age, Delphi, Visual Basic, Mojo, ou mesmo PowerBuilder, você tem familiaridade como a noção de componentes de software. As Extenções do Visual Basic (VBX) foram as primeiros componentes largamente utilizados, seguidos pelos Controles Personalizados OLE (OCX). Programadores UNIX são mais familiarizados com widgets e toolkits.
Componentes reutilizáveis adicionam interfaces padrão e mecanismos de introspecção de objetos em widgets, permitindo que as ferramentas de construção acesses as propriedades e comportamentos de componentes.
Mantenha em mente, também, que os componentes de software não precisam ser visiveis em uma aplicação em execução; eles apenas precisam estar vísiveis quando a aplicação estiver sendo construída.
Por exemplo, na figura acima é mostrada um componente de calculadora que é construída com 16 botões, um campo de texto e um painel onde os botões e o display são mostrados. Por estar olhando os componentes em uma ferramenta de construção, você pode ver cinco componentes adicionais (NewCalcFlag, zeroInteger, Accumulator, EnteredString, e opcharHolder) que são normalmente invisíveis quando o componente é exibido. Esses componentes adicionais guardam valores ou strings usandos pela calculadora para cálculos intermediários, códigos de operação e strings de exibição.
Um programador pode mover, consultar ou visualmente lincar componentes enquanto estiver operando a ferramenta de construção. Frequentemente, cada componente faz seu trabalho enquanto a aplicação está sendo executada, apesar delas serem invisíveis para o usuário.
Componentes podem ser aninhados e arbitrariamente complexos. Por exemplo, uma calculadora construída a partir de componentes pode, ela mesma, ser um componente para outra aplicação. Componentes personalizados são facilmente adicionados as paletas das ferramentas de construção. Componentes mais complexos incluem gráficos de barra, diagramas gráficos e processadores de texto.
O que distingue JavaBeans de Widgets?
O JavaBeans define uma interface em tempo de desenho. Essa interface permite que a ferramenta de desenho de aplicações possa buscar componentes para determinar os tipos de propriedades que os componentes definem e os tipos de eventos que eles geram ou a quem respondem.
Em ambientes visuais de construção de aplicações, os Beans são algumas vezes referenciados como componentes de software reutilizáveis ou controles personalizados. Componentes de software como os JavaBeans são empacotados de forma diferente dos controles padrão do Windows ou widgets Motif. Eles são empacotados com informações em tempo de desenho (propriedades ne metódos) que permitem que a ferramenta de construção determine seus recursos.
Além disso, usuários finais, ou fornecedores externos, podem construir beans personalizados independetemente da plataforma ou sistema operacional. Um departamento pode distribuir esses componentes para clientes corporativos ou podem vender esses componentes para que qualquer um que utilize ferramentas para construir aplicações.
O que distingue JavaBeans de Classes Java?
Qualquer classe Java que adere a certas convenções relativa a definições de propriedades e eventos pode ser um JavaBean. Os Beans são classes Java que podem ser manipuladas por uma ferramenta de construção de aplicativos e compor novas aplicações.
Introspecção, o processo pelo qual uma dada ferramenta analiza como um Bean funciona, diferencia um Bean de um classe típica de Java. Por Beans serem codificados com padrões pré-definidos por suas assinaturas de metódos e definições de classe, as ferramentas que reconhecem esses padrões podem “olhar dentro” de um Bean e determinar suas propriedades e comportamento.
A introspecção permite que o estado do Bean seja manipulado durante o desenho da aplicação – isto é, durante o tempo que estiver sendo montado como parte de uma aplicação maior. Para que isso funcionar, as assinaturas dos metódos internos do Bean precisam seguir um padrão que as ferramentas de introspecção possam reconhecer, tanto duranto o desenho quanto durante a execução.
Dessa forma, o Bean publica seus atributos e comportamentos através de padrões de assinatura e metódos que são reconhecidos por ferramentas de construção de aplicações compativeis com Beans. Porém, essas ferramentas não são requisitos para a construção e teste de seus Beans. Esses padrões de assinatura são dacilmente reconhecidos por leitores humanos, assim como ferramentas de construção. Uma das primeiras coisas que você aprenderá quando for construir seu Bean é como reconhecer e construir metódos que sigam esses padrões.
Beans não devem ser usados indiscriminadamente. Eles são melhor ajustados para componentes de software que serão manipulados visualmente por ferramentas de construção. Algumas funcionalidades, como JDBC, são melhor fornecidas por uma interface textual ou programática, ao invés de uma interface manipulada visualmente.
Conceitos básicos relativos a Beans
Os JavBeans, sem levar em consideração suas funcionalidades, são definidos pelas seguintes características:
- Introspecção —Os Beans suportam instrospecção, que permite que uma ferramenta de construção analize como o Beans trabalha. Elas seguem regras específicas chamadas de padrão de desenho para nomear as características do Bean. Cada Bean tem uma classe de informação, que fornece propriedades, metódos e informações sobre eventos do próprio Bean. Cada classe de informação implementa uma interface BeanInfo, que explicitamente lista as características do Bean que serão expostas a ferramenta de construção.
- Propriedades —Ferramentas de contrução analiza um Bean para descobrir suas propriedades e expo-las para manipulação. Como resultado, você pode alterar uma propriedade do Bean durante o desenho da aplicação.
- Customização —As propriedades expostas de um Bean podem ser customizadas durante o desenho da aplicação. A customização permite que um usuário altere a aparência e o comportamente do Bean. Os Beans suportam customização pelo uso de um editor de propriedades ou pelo uso de um customizador de Bean sofisticado e especial.
- Eventos —Os Beans usam eventos para comunicar-se com outros Beans. Os Beans podem disparar eventos, o que significa que um Bean envia um evento a outro Bean. Quando um Bean dispara um evento ele é considerado a fonte. Um Bean pode receber um evento, nesse caso é considerado o ouvinte. Um Bean ouvinte registra seu interesse no evento com o Bean fonte. Ferramentas de construção usam instrospecção para determinar quais eventos um Bean envia e quais ele escuta.
- Persistência —Os Beans usam a serialização de objetos do Java, implementando a interface java.io.Serialization, para salvar e recuperar o estado que pode ser mudado como resultado de uma customização, assim as propriedades que foram alteradas podem ser recuperadas depois.
- Metódos —Todos os metódos do JavaBean são idênticos aos metódos de qualquer outra classe Java. Os metódos do Bean podem ser chamados por outros Beans ou via linguagens de script. Um metódo público JavaBean é exportado por padrão.
Mesmo sendo os Beans feitos para serem usados primariamente com ferramentas de construção, eles não precisam ser. Os Beans podem ser manipulados manualmente por ferramentas de texto através de interfaces programáticas. Todas das chaves da API, incluindo suporte para eventos, propriedades e persistência, são desenhadas para serem facilmente lidas e entendidas por programadores, assim como por ferramentas de construção.
Para criar nosso primeiro JavaBean, vamos olhar o BeanBox do BDK. No decorrer desse tutorial, usaremos o BeanBox para criar o JavaBean, o BeanBox é usado geralmente para testar os JavaBeans. O BeanBox é considerado um ambiente de referência. Não é apropriado para aplicações gráficas, nem feito para ter uma aparentar como outras ferramentas como Visual Age, Delphi ou Visual Basic.
Você pode criar um JavaBean e então usar o BeanBox para testa-lo. Se um JavaBeans rodas adequadamente em um BeanBox, você garante que ele funcionará com qualquer outra ferramenta comercial.
Inciando o BeanBox
Quando você incia o BeanBox, verá três janelas:
- Janela de Ferramentas (ToolBox)
- Janela de Beans (BeanBox)
- Janela de Propriedades
A Janela de Ferramentas mostra os JavaBeans que estão instalados no BeanBox, como os Beans que acompanham o demo do BeanBox. Quando o BeanBox inicia, automaticamente carrega essa janela com os Beans contidos nos arquivos JAR do diretório bean/jars. Você pode adicionar outros Beans, como os seus próprios, nessa janela. A próxima lição mostrará como adicionar seu próprio Beans nessa seção.
A Janela de Beans é exibida incialmente como uma janela vazia. Você usa essa janela vazia, algumas vezes chamada de “form” por algumas ferramentas, para construir sua aplicação.
A terceira janela, Propriedades, exibe as propriedades atuais do Bean selecionado. Se nenhum Bean estiver selecionado, como quando você inicia o BeanBox pela primeira vez ou se você clica no background da janela do BeanBox, então essa janela mostra as propriedades do BeanBox.
Usando o BeanBox do BDK
Usando o JavaBeans Demo do BDK
A forma mais fácil de entender como o BeanBox funciona é usá-lo. O BeanBox permite que você construa aplicações simples sem escrever nenhum código Java. Como primeiro exemplo, podemos construir uma aplicação chamada “Juggling Duke” onde o Duke começará ou parará de fazer malabarismo dependendo de que botão for pressionado.
Nessa lição, você aprenderá como:
- Arrastar Beans da Janela de Ferramentas do BeanBox e mudar suas propriedades usando a planilha de Propriedades e os editores apropriados.
- Ter um Bire disparando um evento e outro reagindo ao evento disparado.
Criando um Bean
Começaremos arrastando o Bean Juggler da Janela de Ferramentas para um BeanBox vazio.
- Clique no Juggler para seleciona-lo na listade Beans na janela de ferramentas
- Coloque o cursor em qualquer lugar do BeanBox, e clique no lugar com o mouse. Isso insere o Juggler na janela do BeanBox. A caixa de seleção em volta do Juggler indica que ele é o bean selecionado.
- Clique no Bean OurButton na Janela de Ferramentas, e então coloque a instância do botão no BeanBox. Selecione o botão para a as propriedades do botão sejam exibida na planilha de Propriedades.
- Edite o campo label na planilha de Propriedades do botao para que o texto mude para “start”.
- Use o menu Edit do BeanBox para selecionar uma ação para o evento a ser disparado pelo botão start. Antes de escolher o evento, certifique-se de ter selecionado o botão. Observe que uma vez que você tiver selecionado o item de menu actionPerformed, o BeanBox entra em um estado onde uma linha emana do botão e segue o mouse a medida que você se move na janela. Isso indica que o botão está selecionado como a origem do evento, e que o próximo clique do mouse deverá ser no Bean alvo do evento o que define o metódo apropriado para manipular o evento; no nosso caso clique no Bean Juggler.
- Arraste a linha do botão start e solte sobre o bean Juggler. Uma caixa de diálogo aparece listando os manipuladores de eventos disponíveis definidos para o Bean Juggler.
- Selecione o metódo startJuggling como o alvo do evento, e então pressione OK.
Observe que o cursos mudará para um reticulo.
Agora iremos adicionar um botão para controlar o Juggler. Esse botão é uma instância da classe OurButton.
Observe que o texto do botão no BeanBox mude de “press” para “start” depois que você digite o texto no campo label da planilha de propriedades.
Agora, quando você clicar no botão start o Duke começar a atirar feijões em volta de sua cabeça como um malabarista profissional.Você pode controlar a velocidade do malabarismo do Duke pela configuração manual da valor da propriedade animationRate na planilha de propriedades do Juggler. Para que a planilha adequada apareça, o Juggler deve estar selecionado no frama do BeanBox.
Completando o seu programa
Para completar o programa exemplo, vamos adicionar um botão stop. Repita os passos tomados para adiconar o botão start e conecte à ação apropriado.
- Selecione OurButton da lusta de beans disponíveis na Janela de Ferramentas, e então arraste ele para um local abaixo do botão start no BeanBox.
- Quando o novo botão estiver selecionado, o editor de propriedades apropriado irá aparecer.
- Edite o campo label na planilha de propriedades para o valor “stop”.
- Crie uma ligação de evento entre o botão stop e o metódo de manipulação de evento do Juggler stopJuggling.
- Selecione o evento actionPerformed no menu Edit/Events.
- Arraste uma linhado botão stop até o Bean Juggler. Pressione e solte o botão do mouse com a linha da conexão sobre o Juggler.
- A caixa de diálogo de metódos de manipulação de eventos definidos para o Juggler aparecerá; selecione o evento stopJuggling e clique OK.
Você será capaz agora de iniciar e parar o malabarismo apenas pressionando o botão apropriado.
Sumário
Você aprendeu aqui como selecionar o Beans na ToolBox e coloca-lo no BeanBox. Uma vez no BeanBox, você pode usar a planilha de Propriedades para alterar a aparência dele. Você pode também usar o menu de opções do BeanBox para conectar os eventos de um Bean para outro, para iniciar e controlar ações do Bean.
Mantenha em mente que o BeanBox não é uma ferramenta de construção. Seu próposito principal é testar os Beans e verificar se a instropecção e ligação entre eventos está funcionando direito.Você não deveria usar o BeanBox para desenvolver uma aplicação.
Ao invés disso, pense no BeanBox como uma ferramenta de referência. Se o seu beans executar corretamento no BeanBox e reportar corretamente os eventos disparados assim como os eventos corretos para receber eventos de outros Beans, você pode garantir que seu Bean funcionará adequadamente em qualquer ferramenta que suporte Beans.
Traduzido de http://java.sun.com