Desenvolvendo aplicações 22 para a Web Uma aplicação Java pode ser executada sem modificação em qualquer plataforma que tenha a máquina virtual Java instalada. Esta característica faz com que as aplicações Java possam ser transferidas através da Internet para serem executadas nas diferentes máquinas que compõem a rede mundial de computadores. Este capítulo mostra como criar applets, que são programas Java que podem ser executados a partir de navegadores web. 22.1 Applets Os applets são painéis que podem ser embutidos em páginas web e cujo código é executado sob o controle dos navegadores web usados para exibí-las. 22.1.1 O modo de execução de um applet A execução de um applet é controlada a partir dos métodos init, start, stop e destroy, que são chamados pelo navegador web em resposta a eventos específicos. public void init(). Este método é chamado um única vez para inicializar o applet. Isto ocorre, por exemplo quando a página é carregada pelo navegador pela primeira vez. public void start(). Este método é chamado logo após a execução do método init e, após isso, sempre que a página contendo o applet é visitada (isto ocorre, por exemplo, quando o usuário retorna à página do applet após ter visitado outras páginas). public void stop(). Este método é chamado sempre que o usuário deixa a página que contém o applet.
2 Desenvolvendo aplicações para a Internet Figura 22.1. O ciclo de vida de um applet O usuário deixa a página do applet O usuário visita a página do applet pela primeira vez init() start() Mozilla stop() Mozilla O usuário visita a página do applet start() O usuário termina a execução do navegador destroy() destroy() Mozilla O usuário termina a execução do navegador public void destroy(). execução. Este método é chamado quando o navegador termina sua Os métodos acima são públicos. A própria classe que especifica o applet deve ser definida como pública. A Figura 22.1 mostra a seqüência das chamadas aos métodos init, start, stop e destroy. Esta seqüência é conhecida como ciclo de vida de um applet. Embora concebido para ser executado apenas uma vez, quando o applet é iniciado, a chamada ao método init (bem como as chamadas aos demais métodos do seu ciclo de vida) depende do ambiente de execução. Assim, é possível que certos navegadores em certas situações executem o método init mais de uma vez. 22.1.2 Construindo applets Todo applet deve ser especificado como uma subclasse de Applet que, por sua vez, é uma subclasse de Panel. Se o applet contém componentes swing, então deve ser especificado como subclasse de JApplet, que é uma subclasse de Applet. A figura 22.2 mostra a hierarquia dessas classes. Ao conceber um applet devemos codificar no método init todas as ações que queremos executar ao iniciar a aplicação. O método start deve conter as ações que queremos executar sempre que o usuário visitar a página do applet, enquanto o método stop deve conter as ações que serão executadas sempre que o usuário deixar a página do applet. O método destroy deve conter as ações que finalizam a aplicação.
22.2 Executando applets 3 Figura 22.2. Hierarquia das classes relacionadas a applets Object Component Container Panel Applet JApplet Exemplo 22.1. O programa abaixo cria um applet que consiste de um campo de texto editável. A classe que implementa o applet deve ser pública e declarada como subclasse de Applet (linha 3); a declaração import na linha 1 torna possível esta referência. 1 import java.applet.applet; 2 import java.awt.*; 3 public class C22Exemplo1 extends Applet { 4 public void init() { 5 TextField texto = new TextField("Exemplo de Applet"); 6 this.add(texto); 7 } 8 } Neste applet temos apenas o método init no qual um objeto da classe TextField é criado (linha 5) e adicionado ao applet (linha 6). Observe que na linha 6 poderíamos ter usado apenas a chamada add(texto), sem o referente this. Isto porque o método init é sempre executado pelo objeto que implementa o applet que, sendo da classe Container, pode fazer referência direta a add. O gerente de leiaute padrão de um applet da classe Applet é o FlowLayout. Se necessário devemos definir um outro tipo de gerente de leiaute. 22.2 Executando applets O applet do Exemplo 22.1 deve ser executado através de um navegador, como parte de uma página web. Uma alternativa cômoda para testar um applet sem nos preocuparmos com a página na qual ele será inserido é usar o aplicativo appletviewer.
4 Desenvolvendo aplicações para a Internet Figura 22.3. appletviewer exibindo o applet do Exemplo 21.1 22.2.1 Usando o appletviewer O aplicativo appletviewer faz parte do ambiente padrão Java. Para usá-lo basta digitar o comando: appletviewer ArquivoTag onde ArquivoTag é um arquivo texto contendo um par de tags html identificando o código que implementa o applet. A forma mais simples destas tags é a seguinte: <applet code=" IdentCodApplet " width=" LarguraApplet " height=" AlturaApplet "> </applet> As aspas são obrigatórias, IdentCodApplet identifica o arquivo contendo o código do applet, e LarguraApplet e AlturaApplet definem, em quantidade de pixels, a largura e altura da área que o applet deve ocupar na página web. Qualquer arquivo texto fornecido como parâmetro para o aplicativo appletviewer será processado e sempre que uma tag identificando um applet for encontrada, o applet correspondente será exibido, como se estivesse sendo carregado a partir de uma página web. Geralmente, quando queremos testar um applet que estamos construindo, colocamos em seu próprio código fonte um comentário contendo as tags que permitem a execução do applet através do appletviewer. Exemplo 22.2. Se colocarmos a seguinte linha de comentário no código fonte do programa do Exemplo 22.1: //<applet code="c22exemplo1.class" width="200" height="50"></applet> ao digitarmos o comando appletviewer C22Exemplo1.java o applet implementado pelo código C22Exemplo1.class será carregado e terá seus métodos init e start executados pelo visualizador. A janela de exibição terá 200 pixels de largura e 50 de altura, como a mostrada na Figura 22.3.
22.2 Executando applets 5 O botão Applet na janela do appletviewer exibe um menu que permite carregar e reiniciar a execução do applet, bem como executar seus métodos start e stop. Isso permite simular o comportamento que o applet terá quando executado através de um navegador web. 22.2.2 Usando um navegador web Os applets quando inseridos em uma página web são executados pelo navegador usado para exibí-la. As páginas web são codificadas através da linguagem de marcação de texto html, que permite tanto a especificação do texto quanto a especificação dos demais elementos que compõem uma página web como, por exemplo, arquivos de imagens, sons, conexão com outras páginas web, etc. Este capítulo não apresenta detalhes da linguagem html. Para testar nossas aplicações basta saber que grande parte dos comandos html são definidos através de pares de tags que iniciam com um rótulo da forma: <rotulo demais elementos da tag > e terminam com um rótulo da forma </rotulo>. Observe que o par que identifica um applet possui esse formato. Por sua vez, a tag <html> define o início de uma página cujo fim é especificado por </html>. Para inserir um applet em uma página web basta colocar as tags que o identificam no corpo de uma página. Exemplo 22.3. O texto a seguir define a página web mais simples que podemos especificar contendo as tags que identificam o applet do Exemplo 22.1. <html> <applet code="c22exemplo1.class" width="200" height="50"></applet> </html> Se salvarmos esse texto em um arquivo texto de nome PagTeste.html, por exemplo, e o carregarmos usando um navegador web, teremos o início da execução do applet conforme explicado na Seção 22.1.1. A página do exemplo acima, embora funcional, não possui a estrutura esperada para uma página web, que deve ter seu cabeçalho especificado pelas tags <head> e </head>, e seu corpo especificado pelas tags <body> e </body>. Normalmente as páginas web são construídas usando-se editores html que facilitam a especificação dos seus vários elementos, incluindo as tags que identificam os applets.
6 Desenvolvendo aplicações para a Internet Figura 22.4. appletviewer exibindo o applet do Exemplo 22.4 22.3 Outros modos de construir applets Applets tanto podem ser construídos para usar componentes do pacote awt quanto componentes do pacote swing. Podemos também desenhar nossos próprios componentes através das primitivas do contexto gráfico usado pelo método paint. 22.3.1 Usando o método paint Um applet pode não conter explicitamente o código dos método init, start, stop e destroy. Neste caso, o ambiente executará as ações padrões para carregar, interromper e reiniciar o applet. Exemplo 22.4. O programa a seguir implementa o applet mostrado na Figura 22.4. 1 // <applet code="c22exemplo4.class" width="150" height="60"> </applet> 2 import java.applet.*; 3 import java.awt.*; 4 public class C22Exemplo4 extends Applet { 5 public void paint(graphics g) { 6 g.drawrect(0, 0, getsize().width - 1, getsize().height - 1); 7 g.setcolor(color.red); 8 g.drawstring("josefa branca e rosa", 15, 30); 9 } 10 } Este applet possui apenas o método paint, que é chamado pelo ambiente sempre que o applet deve ser mostrado. Isto ocorre, por exemplo, quando o applet é carregado (ao iniciar sua execução e sempre que o usuário retornar à página que o contém) e também ao ser tornado visível após deixar de ser encoberto por alguma outra janela. Na chamada ao método paint o ambiente de execução fornece como argumento o contexto gráfico usado para determinar as características gráficas do componente. Neste caso a área de desenho terá a dimensão especificada para o applet (150 pixels de largura e 60 de altura). O comentário da linha 1 permite a execução deste applet pelo appletviewer. O método getsize é executado pelo objeto que implementa o applet. Logo, a referência
22.3 Outros modos de construir applets 7 Figura 22.5. appletviewer exibindo o applet do Exemplo 22.5 getsize().width produz o valor 150 e a referência getsize().height, o valor 60. Assim, o método drawrect da linha 6 desenha um retângulo cujo vértice superior esquerdo está posicionado na coordenada (0,0), tendo uma largura de 149 e uma altura de 59 pixels. Na linha 8 a cadeia de caracteres Josefa branca e rosa é desenhada a partir da coordenada (15,30). Esta cadeia é desenhada com a cor vermelha, que é a cor corrente após a execução do método setcolor da linha 7. 22.3.2 Usando a classe JApplet Se quisermos usar componentes swing para construir applets devemos especificá-los como uma subclasse de JApplet que, por sua vez, é uma subclasse de JFrame. Assim, da mesma forma que ocorre com aplicações swing convencionais, em um applet que estende JApplet o gerente de leiaute e os componentes devem ser adicionados através do componente de conteúdo do applet (e não ao applet diretamente). O gerente de leiaute padrão de um applet swing é o BorderLayout. Exemplo 22.5. O programa a seguir implementa o applet mostrado na Figura 22.5, que exibe uma lista de números idêntica à lista da Tabela 21.2. 1 //<applet code="c22exemplo5.class" width="160" height="100"> </applet> 2 import javax.swing.*; 3 import java.awt.*; 4 public class C22Exemplo5 extends JApplet { 5 String[] numeros = {"10","13","22","9","102"}; 6 public void init() { 7 Container conteudo = this.getcontentpane(); 8 conteudo.add(new JList(numeros)); 9 } 10 } O vetor com a lista de números é especificado, na linha 5, como um atributo do objeto que implementa o applet. O componente de conteúdo é obtido na linha 7 e, através dele, na linha 8, é adicionado o componente da classe JList.
8 Desenvolvendo aplicações para a Internet Figura 22.6. appletviewer exibindo o applet do Exemplo 22.6 22.4 Tratando eventos Os eventos são tratados da mesma forma que nas aplicações Java convencionais. Devemos especificar as classes capazes de monitorá-los, criar os monitores e associá-los aos componentes da interface que serão as fontes dos eventos que queremos tratar. Exemplo 22.6. O programa abaixo especifica um applet que calcula a prestação inicial de um financiamento segundo a tabela price 1. Este applet, mostrado na Figura 22.6, possui três campos de texto para o usuário informar o valor do financiamento, os juros anuais e a quantidade de meses, além de um botão de cálculo usado para calcular o valor da prestação inicial. Dois tipos de eventos são tratados. Primeiro, o clique do mouse. Sempre que o usuário clicar o mouse sobre o botão de cálculo o valor da primeira prestação será atualizado segundo a fórmula: prestação = financiamento juros (1 + juros)período (1 + juros) período 1 Este tipo de evento é tratado implementando-se a classe abstrata MouseAdapter (linhas 33 a 43). O segundo tipo de evento é a obtenção do foco do teclado. Sempre que o usuário clicar ou iniciar a digitação em um dos campos que definem o valor do financiamento, os juros ou a quantidade de meses, o valor da prestação é apagado. Este evento é tratado usando-se o próprio applet para implementar a interface FocusListener. 1 //<applet code="c22exemplo6.class" width="250" height="80"> </applet> 2 import java.awt.*; 3 import javax.swing.*; 4 import java.awt.event.*; 5 public class C22Exemplo6 extends JApplet implements FocusListener { 6 JTextField c_valor = new JTextField(""); 1 Também chamado de Sistema Francês de Amortização, foi concebido pelo matemático Richard Price e tem como característica uma amortização dos juros maior que a do principal durante boa parte do período de financiamento.
22.4 Tratando eventos 9 7 JTextField c_juros = new JTextField(""); 8 JTextField c_meses = new JTextField(""); 9 JLabel c_prest = new JLabel(""); 10 JButton b_calcula = new JButton("Prestacao 1:"); 11 public void init() { 12 Container conteudo = getcontentpane(); 13 conteudo.setlayout(new GridLayout(4,2)); 14 conteudo.add(new JLabel("Valor:")); 15 conteudo.add(c_valor); 16 conteudo.add(new JLabel("Juros (aa):")); 17 conteudo.add(c_juros); 18 conteudo.add(new JLabel("Meses:")); 19 conteudo.add(c_meses); 20 conteudo.add(b_calcula); 21 conteudo.add(c_prest); 22 MonitoraMouse monitoraclique = new MonitoraMouse(); 23 b_calcula.addmouselistener(monitoraclique); 24 c_valor.addfocuslistener(this); 25 c_juros.addfocuslistener(this); 26 c_meses.addfocuslistener(this); 27 } 28 public void focusgained(focusevent e) { 29 c_prest.settext(""); 30 } 31 public void focuslost(focusevent e) { 32 } 33 class MonitoraMouse extends MouseAdapter { 34 public void mouseclicked(mouseevent e) { 35 double v = Double.parseDouble(c_valor.getText()); 36 int n = Integer.parseInt(c_meses.getText()); 37 double i = Float.parseFloat(c_juros.getText())/100; 38 i = Math.pow(1 + i,1./12) - 1; 39 double fator = Math.pow(1 + i,n); 40 double prest = (v * i * fator)/(fator - 1); 41 c_prest.settext(double.tostring(prest)); 42 } 43 } 44 } Nas linhas 6 a 10 os componentes da interface são especificados como atributos do applet. O método init define o gerente de leiaute na linha 13, adiciona ao applet os objetos que compõem sua interface (linhas 14 a 21) e define os tratadores de eventos nas linhas 22 a 26. O objeto capaz de tratar os cliques do mouse é criado na linha 22 e associado ao botão de cálculo na linha 23. O objeto capaz de tratar os eventos da classe FocusEvent é o próprio applet, que é adicionado através do referente this aos três campos de texto nas
10 Desenvolvendo aplicações para a Internet linhas 24 a 26. Este applet deve implementar todos os métodos definidos na interface FocusListener, mesmo que o corpo de alguns seja vazio (como é o caso do método focuslost nas linhas 31 e 32). A expressão da linha 38 transforma os juros anuais em juros mensais. 22.5 Convertendo aplicações em applets Para converter uma aplicação Java em um applet devemos remover seu método main e inserir os métodos próprios de um applet, além de mudar a forma como as janelas e o seu conteúdo são construídos. Como regra geral temos que: A janela principal da aplicação em vez de estender a classe JFrame passa a estender a classe JApplet. A construção da janela principal e as ações do método main passam a ser executadas pelo método init. Não é necessário criar uma instância da janela principal já que a criação do applet fica a cargo do navegador web. Exemplo 22.7. O programa abaixo especifica um applet construído a partir do programa do Exemplo 21.11. 1 //<applet code="c22exemplo7.class" width="150" height="100"> </applet> 2 import java.awt.*; 3 import javax.swing.*; 4 class Velocimetro { 5 protected int valor = 100; 6 void incrvel() { 7 valor++; 8 } 9 void decrvel() { 10 valor--; 11 } 12 int obtemvel() { 13 return valor; 14 } 15 } 16 public class C22Exemplo7 extends JApplet { 17 Velocimetro v = new Velocimetro(); 18 JButton btincr = new JButton("+"); 19 JButton btdecr = new JButton("-"); 20 JLabel rotvalor = new JLabel("100"); 21 public void init() { 22 setbounds(10,10,150,100);
22.6 Limitações dos applets 11 23 Container conteudo = getcontentpane(); 24 conteudo.setlayout(new GridLayout(3,2)); 25 conteudo.add(new JLabel("controle")); 26 conteudo.add(new JLabel(" ")); 27 conteudo.add(btincr); 28 conteudo.add(new JLabel("velocidade")); 29 conteudo.add(btdecr); 30 conteudo.add(rotvalor); 31 rotvalor.sethorizontalalignment(swingconstants.right); 32 } 33 } No exemplo 21.11 o método main apenas criava um objeto Velocimetro e construía uma instância da classe JanelaPrincipal. Aqui, transformamos a classe JanelaPrincipal na classe C22Exemplo7 que implementa o applet, estendendo JApplet (linhas 16 a 32). O método construtor da classe JanelaPrincipal foi transformado no método init do applet. Este applet apenas mostra os componentes da interface; o tratamento de eventos pode ser feito de modo semelhante ao mostrado no Exemplo 21.13. 22.6 Limitações dos applets A execução de applets possui restrições desenvolvidas para permitir que um navegador web possa executar um applet carregado a partir de outras máquinas e ambientes sem comprometer a segurança do sistema no qual está sendo executado. Os applets não podem usar bibliotecas ou invocar métodos que estejam em classes residentes fora dos pacotes padrões da linguagem. O acesso a bibliotecas e pacotes é determinado pela política de segurança de cada visualizador, que geralmente permite acesso apenas aos pacotes java.*. Os applets não podem ler ou gravar arquivos na máquina em que estão sendo executados. Novamente, esta restrição depende da política adotada pelo visualizador. O appletviewer do ambiente Java permite algumas exceções a essa regra. Os applets não podem fazer conexões através da rede, exceto para a máquina na qual eles residem. Os applets não podem executar nenhum programa na máquina em que estão sendo executados. Os applets não podem ler certas propriedades do sistema (especificadas através de objetos da classe Properties). Não podem, por exemplo, identificar o diretório corrente nem os dados que compõem o caminho padrão (CLASSPATH). Podem, entretanto, obter o caractere usado para separar os itens na identificação de arquivos.
12 Desenvolvendo aplicações para a Internet Existem modos de contornar algumas limitações. Por exemplo, quanto à gravação de arquivos, um applet pode enviar informações para programas na máquina onde ele reside. Estes programas então gravariam os arquivos necessários. Os applets podem ler arquivos identificados através de URLs, em vez de nomes de arquivos. As janelas que contém applets são identificadas de modo diferenciado, geralmente contém na base o texto Java Applet Window. 22.7 Especificando e usando parâmetros Os applets podem ser parametrizados, com a declaração dos parâmetros e a definição do valor inicial feita através de tags da forma: <param name=" NomeParam " value=" ValorParam "> onde NomeParam e ValorParam são o nome e o valor atribuído ao parâmetro. Essas tags são inseridas entre a tags que identificam o applet. Exemplo 22.8. A declaração abaixo define três parâmetros para o applet identificado por C22Exemplo6.class: <applet code="c22exemplo6.class" width="250" height="80"> <param name="p_fin" value="130000"> <param name="p_juros" value="9"> <param name="p_meses" value="180"> </applet> Sempre que este applet for carregado os valores 130000, 9 e 180 serão atribuídos aos parâmetros p fin, p juros e p meses, respectivamente. Um applet pode a qualquer tempo obter o valor atribuído a um parâmetro através do método: public String getparameter(string nomeparam). Este método retorna o valor atribuído ao parâmetro de nome nomeparam. O valor é fornecido como uma cadeia de caracteres e deve ser convertido em um tipo apropriado, se necessário. O método retorna o valor null se não existir um parâmetro com o nome nomeparam. Exemplo 22.9. O método abaixo inicializa as variáveis c valor, c juros e c meses com os valores atribuídos aos parâmetros p fin, p juros e p meses ou com os valores 100000, 12 e 240, caso estes parâmetros não tenham sido declarados.
22.7 Especificando e usando parâmetros 13 public void inicializacampos() { String val = getparameter("p_fin"); if (val == null) c_valor = new JTextField("100000"); else c_valor = new JTextField(val); val = getparameter("p_juros"); if (val == null) c_juros = new JTextField("12"); else c_juros = new JTextField(val); val = getparameter("p_meses"); if (val == null) c_meses = new JTextField("240"); else c_meses = new JTextField(val); } Este método pode fazer parte do applet do Exemplo 22.6. Deste modo, cada página que o referencie pode adotar os valores nele definidos ou especificar, através dos parâmetros p fin, p juros e p meses, seus próprios valores iniciais. 22.7.1 Especificando diretórios Os visualizadores procuram pelo código de um applet no mesmo diretório em que está a página sendo visualizada (a página que possui a tag do applet). Para carregar um applet armazenado em um outro diretório devemos especificar sua localização através do parâmetro codebase=" LocalApplet ". A identificação do applet será aposta à localização LocalApplet, podendo ser um endereço absoluto, um subdiretório do diretório onde está a página ou um endereço da Internet (especificado através de uma URL). Não pode entretanto conter caracteres de endereçamento relativo (. ou..) Exemplo 22.10. Considere uma página web armazenada no diretório \user\pessoa. Nesta situação a tag <applet code="aplt.class" width="100" height="20"> <\applet> faz com que o applet seja procurado no diretório \user\pessoa. A tag <applet code="aplt.class" codebase="exem" width="100" height="20"> <\applet> faz com que o applet seja procurado no diretório \user\pessoa\exem. A tag
14 Desenvolvendo aplicações para a Internet <applet code="aplt.class" codebase="\progs\teste" width="100" height="20"> <\applet> faz com que o applet seja procurado no diretório \progs\teste. A tag <applet code="aplt.class" codebase="http://wwww.cic.unb.br/progs" width="100" height="20"> <\applet> faz com que o applet seja procurado no diretório \progs do servidor identificado pelo endereço www.cic.unb.br. Já a tag <applet code="aplt.class" codebase="../exem" width="100" height="20"> <\applet> é inválida porque usa a referência relativa através dos dois pontos.