Laura Lemay
A maior parte da popularidade atual de Java sucedeu por causa de browseres de World Wide Web permitidos por Java e o seu suporte de programas de applets-Java que correm em Páginas da Web e podem usar-se para criar Web sites dinâmicos, interativos. Applets, como observado no início deste livro, escrevem-se na língua de Java e podem examinar-se em qualquer browser que apoia Java, inclusive Navegador de Netscape e Internet Explorer de Microsoft. Aprender como criar applets é o mais provável a razão comprou este livro, então vamos desperdiçar não mais o tempo.
Na semana passada, concentrou-se em aprender sobre a própria língua de Java, e a maioria dos pequenos programas que criou foram aplicações de Java. Nesta semana, agora que tem os fundamentos abaixo, mudará a criação e utilização applets, que inclui uma discussão de muitas das classes na biblioteca de classe de Java padrão.
Hoje começará com os fundamentos:
Embora explorasse as diferenças entre aplicações de Java e Java applets no início deste livro, vamos revê-los.
Em resumo, as aplicações de Java são programas Java autônomos que podem dirigir-se usando somente o intérprete de Java, por exemplo, de uma linha de comando. A maioria tudo que usou até este ponto no livro foi uma aplicação de Java, embora um simples.
Java applets, contudo, dirige-se do interior de um browser de World Wide Web. Uma referência para um applet é introduzida em uma Página da Web usando uma etiqueta de HTML especial. Quando um leitor, usando um browser permitido por Java, carrega uma Página da Web com um applet nele, os carregamentos de browser que applet de um Servidor Web e o realiza no sistema local (aquele o browser continua). (O intérprete de Java incorpora-se no browser e dirige o arquivo de classe de Java compilado daí.)
Como Java applets corre dentro de um browser de Java, têm o acesso à estrutura que o browser fornece: uma janela existente, um contexto que trata o evento e de gráficos e a interface de usuário circundante. As aplicações de Java também podem criar esta estrutura (permitindo-lhe criar aplicações gráficas), mas não o necessitam (aprenderá como criar aplicações de Java que usam gráfica parecida a applet e características de interface de usuário (UI) no Dia 14, "Windows, Ligação em rede e Outros Petiscos").
Observe que um programa Java único pode escrever-se para funcionar como tanto uma aplicação de Java como Java applet. Enquanto usa procedimentos diferentes e regras de criar applets e aplicações, nenhum daqueles procedimentos ou regras está em conflito um com outro. As características específicas para applets ignoram-se quando o programa corre como uma aplicação, e vice-versa. Lembre-se disto como projeta o seu próprio applets e aplicações.
Uma diferença significante final entre Java applets e aplicações provavelmente a diferença mais grande - é o jogo de restrições colocadas em como applets pode funcionar em nome da segurança. Já que podem carregar de Java applets de qualquer sítio em World Wide Web e corrida no sistema de um cliente, permitido por Java browseres e limite de instrumentos o que pode fazer-se para prevenir um velhaco applet de causar dano de sistema ou violações de segurança. Sem estas restrições no lugar, Java applets pode escrever-se para conter vírus ou cavalos troianos (programas que parecem amistosos mas fazem algum tipo do dano ao sistema), ou usar-se para comprometer a segurança do sistema que os dirige. As restrições em applets incluem o seguinte:
Todas estas regras são verdade para Java applets Navegador de Netscape corrente ou Microsoft Internet Explorer. Outros browseres permitidos por Java ou os instrumentos podem permitir-lhe configurar o nível da segurança você querer por exemplo, o instrumento de appletviewer no JDK permite-lhe estabelecer uma lista de controle de acesso para que diretórios um applet pode ler ou escrever. Contudo, como um desenvolvedor applet, está seguro supor que a maioria do seu público esteja indo estar examinando o seu applets em um browser que implementa as regras mais estritas para o que um applet pode fazer. As aplicações de Java não têm nenhuma destas restrições.
| Observar |
As restrições de segurança impostas a applets chamam-se às vezes "a caixa de areia" (como em applets só se permitem jogar na caixa de areia e não podem ir além disso). O trabalho está fazendo-se pelo Sol e pela comunidade de Java para encontrar que caminhos para applets são capazes de libertar-se da caixa de areia, inclusive assinaturas digitais e encriptação. No Dia 21, "Abaixo do Capuz", aprenderá mais detalhes de Java e segurança applet. |
Além das restrições applet enumeradas, próprio Java inclui várias formas de segurança e coerência registrando-se no compilador de Java e intérprete de todos os programas Java para prevenir o uso heterodoxo da língua (aprenderá mais sobre isto no Dia 21). Esta combinação de restrições e características de segurança fá-lo mais difícil para um velhaco Java applet para fazer o dano ao sistema do cliente.
| Observar |
Estas restrições previnem todos dos modos tradicionais de causar dano ao sistema de um cliente, mas é impossível estar absolutamente seguro que um programador inteligente não pode trabalhar de qualquer maneira em volta destas restrições, violar o isolamento, use recursos de CPU, ou somente planície ser aborrecido. O sol pediu que a Rede em liberdade tente quebrar a segurança de Java e crie um applet que pode trabalhar em volta das restrições impostas a ele, e, de fato, vários problemas desenterraram-se e fixaram-se, normalmente relacionando-se com o carregamento de classes e à união a sítios não autorizados. Aprenderá sobre mais questões na segurança de Java no Dia 21. |
Em sua maioria, todos os programas Java que criou até este ponto foram Java programas simples pelas aplicações com um método de main() único que criam objetos, estabelecem variáveis de exemplo e métodos de corrida. Hoje e durante os próximos poucos dias estará criando applets exclusivamente, portanto precisará de um bom aperto de como um applet trabalha, os tipos de características que um applet tem, e onde começar quando primeiro cria o seu próprio applets.
Para criar um applet, cria uma subclasse da classe Applet. A classe de Applet, parte do pacote de java.applet, fornece a maior parte do comportamento o seu applet tem de trabalhar dentro de um browser permitido por Java. Applets também tomam a vantagem forte da Caixa de ferramentas de Windowing Abstrata de Java (awt), que provê o comportamento para criar a interface de usuário gráfico (GUI) - baseou applets e aplicações: desenho à tela; criando janelas, barras de cardápio, botões, caixas de seleção e outros elementos UI; e o usuário gerente introduziu como cliques de rato e keypresses. As classes awt são parte do pacote de java.awt.
| Novo termo |
A Caixa de ferramentas de Windowing Abstrata de Java (awt) fornece classes e comportamento para criar aplicações baseadas em GUI em Java. Applets utilizam muitas das capacidades no awt. |
Embora o seu applet possa ter tantas classes "de ajudante" adicionais como precisa, é a classe applet principal que provoca a execução do applet. Aquela classe applet inicial sempre tem uma assinatura como isto:
public class myClass extends java.applet.Applet {
...
}
Observe a palavra-chave de public. Java precisa que a sua subclasse applet se declare por public. Novamente, isto só é verdade da sua classe applet principal; qualquer classe de ajudante que cria não necessariamente precisa de ser public. public, private e outras formas do controle de acesso descrevem-se no Dia 15, "Modificadores, Controle de acesso e Desenho de Classe".
Quando um browser permitido por Java encontra o seu applet em uma Página da Web, carrega a sua classe applet inicial sobre a rede, bem como qualquer outra classe de ajudante que a primeira classe usa, e dirige o applet utilização do intérprete bytecode construído do browser. Diferentemente de com aplicações, onde Java chama o método de main() diretamente na sua classe inicial, quando o seu applet se carrega, Java cria um exemplo da classe applet, e uma série de métodos applet especiais convida-se aquele exemplo. applets diferentes que usam a mesma classe usam exemplos diferentes, portanto cada um pode comportar-se diferentemente de outro applets que corre no mesmo browser.
Para criar uma aplicação de Java básica, a sua classe tem de ter um método, main(), com uma assinatura específica. Então, quando a sua aplicação corre, main() encontra-se e realiza-se, e de main() pode fundar o comportamento que o seu programa tem de dirigir. Applets são semelhantes mas mais complicados - e, de fato, os applets não precisam de um método de main() em absoluto. Applets têm muitas atividades diferentes que correspondem a vários eventos principais no ciclo de vida do applet-por-exemplo, inicialização, pintura e eventos de rato. Cada atividade tem um método correspondente, portanto quando um evento ocorre, o browser ou outro instrumento permitido por Java chamam aqueles métodos específicos.
As implementações à revelia destes métodos de atividade não fazem nada; para fornecer o comportamento para um evento deve ignorar o método apropriado na subclasse do seu applet. Não tem de ignorar todos eles, naturalmente; o comportamento applet diferente necessita que métodos diferentes se ignorem.
Aprenderá sobre vários métodos importantes a ignorar enquanto a semana progride, mas, para um resumo geral, aqui é cinco dos métodos mais importantes na execução de um applet: inicialização, começo, paragem, destruição e pintura.
A inicialização ocorre quando o applet se carrega primeiro (ou se recarrega), de mesmo modo ao método de main() em aplicações. A inicialização de um applet poderia incluir a leitura e a análise de qualquer parâmetro ao applet, criação de qualquer objeto de ajudante do qual precisa, se estabelecer um estado inicial ou carregamento de imagens ou fontes. Para fornecer o comportamento para a inicialização do seu applet, ignore o método de init() na sua classe applet:
public void init() {
...
}
Depois que um applet inicializa-se, começa-se. O começo é diferente da inicialização porque pode acontecer muitas vezes diferentes durante a vida de um applet, ao passo que a inicialização só acontece uma vez. O começo também pode ocorrer se o applet se parou anteriormente. Por exemplo, um applet para-se se o leitor seguir uma conexão a uma página diferente, e começa-se novamente quando o leitor volta a esta página. Para fornecer o comportamento de lançamento para o seu applet, ignore o método de start():
public void start() {
...
}
A funcionalidade que instala no método de start() poderia incluir a criação e o lançamento um fio para controlar o applet, enviando as mensagens apropriadas a objetos de ajudante, ou em algum modo de dizer ao applet começar a correr. Aprenderá mais sobre o começo applets no Dia 10, "Animação simples e Fios".
A paragem e o começo vão de mãos dadas. A paragem ocorre quando o leitor deixa a página que contém uma atualmente gerência applet, ou pode parar o applet você mesmo chamando stop(). À revelia, quando o leitor deixa uma página, qualquer fio que o applet tinha começado continuará correndo. Aprenderá mais sobre fios no Dia 10. Ignorando stop(), pode suspender a execução destes fios e logo reiniciá-los se o applet se examinar novamente:
public void stop() {
...
}
Destruir sons mais violentos do que ele é. A destruição permite ao applet limpar depois de si mesmo justo antes de que se liberta ou as saídas por exemplo de browser, para parar e retirar qualquer fio de gerência, fechar qualquer conexão de rede aberta ou lançar qualquer outro objeto de gerência. Geralmente, não quererá ignorar destroy() a menos que tenha recursos específicos que têm de por exemplo lançar-se, fios que o applet criou. Para fornecer o comportamento de limpeza para o seu applet, ignore o método de destroy():
public void destroy() {
...
}
| Nota técnica |
Como destroy() é diferente de finalize(), que se descreveu no Dia 7, "mais sobre Métodos"? Em primeiro lugar, destroy() só aplica-se a applets. finalize() é um caminho mais de uso geral para um objeto único de qualquer tipo de limpar depois de si mesmo. |
A pintura é como um applet de fato desenha algo na tela, ser ela texto, uma linha, um contexto colorido ou uma imagem. A pintura pode ocorrer muitos milhares de tempos durante o ciclo de vida de um applet (por exemplo, depois que o applet se inicializa, se o browser se colocar atrás de outra janela na tela e logo se apresentar novamente, se a janela do navegador se mover para uma posição diferente quanto à tela, ou possivelmente repetidamente, em caso da animação). Ignora o método de paint() se o seu applet tiver de ter uma aparência real na tela (isto é, a maior parte do tempo). O método de paint() parece a isto:
public void paint(Graphics g) {
...
}
Observe que diferentemente de outros métodos principais nesta seção, paint() toma um argumento, um exemplo da classe Graphics. Este objeto cria-se e passa-se a paint pelo browser, portanto não tem de incomodar-se com ele. Contudo, terá de assegurar-se que a classe de Graphics (parte do pacote de java.awt) se importa para o seu código de applet, normalmente por uma afirmação de import em cima do seu arquivo de Java:
import java.awt.Graphics;
Caminho atrás no Dia 2, "A Programação orientada ao Objeto e Java", criou um applet simples chamado HelloAgainApplet (isto foi aquele com o grande Hello Again vermelho). Lá, criou e usou isto applet como um exemplo de criar uma subclasse. Vamos sobre o código para isto applet novamente, esta vez olhando para ele ligeiramente diferentemente na luz das coisas somente aprendeu sobre applets. A listagem 8.1 mostra o código para isto applet.
A listagem 8.1. Olá Novamente applet.
1: import java.awt.Graphics;
2: import java.awt.Font;
3: import java.awt.Color;
4:
5: public class HelloAgainApplet extends java.applet.Applet {
6:
7: Font f = new Font("TimesRoman", Font.BOLD, 36);
8:
9: public void paint(Graphics g) {
10: g.setFont(f);
11: g.setColor(Color.red);
12: g.drawString("Hello again!", 5, 40);
13: }
14: }
| Análise |
Este applet implementa o método de paint(), um dos métodos principais descritos na seção prévia (de fato, ignora a implementação à revelia de paint(), que não faz nada). Como o applet não faz de fato muito (tudo que faz é imprimir umas palavras de par para a tela), e não há realmente nada para inicializar, não precisa de um start(), stop(), init() ou método de destroy(). |
O método de paint é onde o verdadeiro trabalho deste applet (a que um pouco de trabalho vai) realmente ocorre. O objeto de Graphics passado no método de paint() mantém o estado de gráficos para o applet-isto-é, as características atuais da superfície de desenho, como primeiro plano e cores de fundo ou recorte de área. As linhas 10 e 11 fundam a fonte e cor deste estado de gráficos (aqui, o objeto de fonte mantido na variável de exemplo de f e um objeto de Color que representa a vermelhidão a cores).
A linha 12 desenha a cadeia "Hello Again!" usando a fonte atual e cor na posição 5, 40. Observe que o ponto de 0 de x, y se deixa em cima do applet's que desenha superfície, com y positivo descer, portanto 50 está de fato no fundo do applet. A figura 8.1 mostra como a caixa delimitadora do applet e a cadeia se desenham na página.
A figura 8.1: Desenho do applet.
Se tem seguido junto com todos os exemplos até este ponto, poderia notar que parece haver algo que falha nesta classe: um método de main(). Como mencionado na seção nas diferenças entre applets e aplicações, os applets não precisam de um método de main(). Implementando o direito applet métodos na sua classe (init(), start(), stop(), paint(), e assim por diante), o seu applet somente sem costura trabalha sem precisar de um salto explícito - do ponto.
Depois que cria uma classe ou classes que contêm o seu applet e os compilam em arquivos de classe como ia qualquer outro programa Java, tem de criar uma Página da Web que considerará que applet usando a língua de HTML. Há uma etiqueta de HTML especial da inclusão applets em Páginas da Web; os browseres permitidos por Java usam a informação contida naquela etiqueta para localizar os arquivos de classe compilados e realizar o próprio applet. Nesta seção, aprenderá sobre como pôr Java applets em uma Página da Web e como servir aqueles arquivos à Web em liberdade.
| Observar |
A seção seguinte supõe que tenha pelo menos uma compreensão de passagem da escrita de páginas de HTML. Se precisar da ajuda nesta área, pode encontrar que o livro Se ensina a Publicação na Web com o HTML durante 14 Dias úteis. Também é de Sams.net e também por Laura Lemay, autor da maior parte deste livro. |
Para incluir um applet em uma Página da Web, use a etiqueta de <APPLET>. <APPLET> é uma extensão especial ao HTML da inclusão applets em Páginas da Web. A listagem 8.2 mostra um exemplo muito simples de uma Página da Web com um applet incluído nele.
A listagem 8.2. Uma página de HTML simples.
1: <HTML> 2: <HEAD> 3: <TITLE>This page has an applet on it</TITLE> 4: </HEAD> 5: <BODY> 6: <P>My second Java applet says: 7: <BR><APPLET CODE="HelloAgainApplet.class" WIDTH=200 HEIGHT=50> 8: Hello Again! 9: </APPLET> 10: </BODY> 11: </HTML>
| Análise |
Há três coisas a observar sobre a etiqueta de <APPLET> nesta página: |
Observe que a etiqueta de <APPLET>, como a própria etiqueta de <IMG>, não é um parágrafo, portanto deve cercar-se dentro de uma etiqueta de texto mais geral, como <P> ou uma das etiquetas de título (<H1>, <H2>, e assim por diante).
Agora com um arquivo de classe e um arquivo de HTML que se refere ao seu applet, deve ser capaz de carregar aquele arquivo de HTML no seu browser permitido por Java do seu disco local (no Netscape, use o Arquivo Aberto do menu File; no Internet Explorer, use Aberto do menu File e logo selecione Pesquisam para encontrar o arquivo direito no seu disco). O browser carrega e analisa o seu arquivo de HTML, e logo carrega e realiza a sua classe applet.
Se não tiver um browser permitido por Java, muitas vezes há os instrumentos que vêm com o seu ambiente de desenvolvimento para ajudá-lo a testar applets. No JDK, a aplicação de appletviewer testará o seu applets. Não verá a Página da Web o applet continua, mas pode compreender se o applet de fato estiver dirigindo o modo ao qual o espera.
A figura 8.2 mostra o Olá Novamente applet correndo no Netscape.
A figura 8.2: Olá Novamente applet.
Depois que tem um applet e um arquivo de HTML, e verificou que tudo trabalha corretamente no seu sistema local, o passo último deve fazer isto applet disponível para World Wide Web em liberdade para que cada um com um browser permitido por Java possa examinar isto applet.
Java applets serve-se por um Servidor Web o mesmo modo que os arquivos de HTML, as imagens e outros meios de comunicação são. Não precisa do software de servidor especial para fazer Java applets disponível para a Web; não precisa de até configurar o seu servidor para tratar arquivos de Java. Se convidar um Servidor Web e gerência ou espaço em um Servidor Web disponível para você, tudo que tem de fazer é mover o seu HTML e arquivos de classe compilados àquele servidor, como ia qualquer outro arquivo.
Se não tiver um Servidor Web, tem de alugar o espaço em um ou estabelecer aquele você mesmo. (A organização de servidor Web e a administração, bem como outras facetas da Publicação na Web em geral, são do lado de fora do alcance deste livro.)
Na sua forma mais simples, usando CODE, WIDTH e HEIGHT, a etiqueta de <APPLET> simplesmente cria um espaço do tamanho apropriado e logo carrega e dirige o applet naquele espaço. A etiqueta de <APPLET>, contudo, realmente inclui vários atributos que podem ajudá-lo melhor a integrar o seu applet no desenho total da sua Página da Web.
| Observar |
Os atributos disponíveis para a etiqueta de <APPLET> são quase idênticos àqueles para o HTML a etiqueta de <IMG>. |
O atributo de ALIGN define como o applet se alinhará na página. Este atributo pode ter um de nove valores: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM ou ABSBOTTOM.
Em caso de ALIGN=LEFT e ALIGN=RIGHT, o applet coloca-se na esquerda ou margem direita da página, respectivamente, e todo o texto depois de que applet flui no espaço à direita ou deixado disto applet. O texto continuará fluindo naquele espaço até o fim do applet, ou pode usar uma etiqueta de intervalo de linha (<BR>) com o atributo de CLEAR para começar a linha esquerda do texto em baixo disto applet. O atributo de CLEAR pode ter um de três valores: CLEAR=LEFT começa o texto na seguinte margem esquerda clara, CLEAR=RIGHT faz o mesmo da margem direita, e CLEAR=ALL começa o texto na seguinte linha onde ambas as margens são claras.
| Observar |
No Navegador de Netscape do Windows, o uso do atributo de ALIGN previne o applet de carregar-se de fato (isto é um defeito; trabalha perfeito no UNIX e as versões de Macintosh do Netscape, bem como no Internet Explorer). Se usa o alinhamento extensivamente nas suas Páginas da Web com applets, poderia querer cercá-los em mesas e alinhar as próprias mesas em vez de usar ALIGN. |
Por exemplo, aqui está um fragmento do código de HTML que alinha um applet contra a margem esquerda, tem algum texto que flui ao lado dele, e logo estala no fim do parágrafo para que o seguinte bit do texto comece em baixo do applet:
<P><APPLET CODE="HelloAgainApplet.class" WIDTH=200 HEIGHT=50 ALIGN=LEFT>Hello Again!</APPLET> To the left of this paragraph is an applet. It's a simple, unassuming applet, in which a small string is printed in red type, set in 36 point Times bold. <BR CLEAR=ALL> <P>In the next part of the page, we demonstrate how under certain conditions, styrofoam peanuts can be used as a healthy snack.
A figura 8.3 mostra como este applet e o texto que rodeia poderia aparecer em um browser permitido por Java (iluminei o contexto de página à revelia portanto pode ver onde o applet começa e os fins de fundo).
A figura 8.3: Um applet aliou-se deixado.
Para mais pequeno applets, poderia querer incluir o seu applet dentro de uma linha única do texto. Para fazer isto, há sete valores de ALIGN que determinam como o applet se alinha verticalmente com o texto:
A figura 8.4 mostra várias opções de alinhamento, onde a linha é uma imagem e a flecha é um pequeno applet.
A figura 8.4: opções de alinhamento de Applet.
O HSPACE e os atributos de VSPACE usam-se para estabelecer o montante do espaço, em pixéis, entre um applet e o seu texto circundante. HSPACE controla o espaço horizontal (o espaço à esquerda e direito ao applet). VSPACE controla o espaço vertical (o espaço em cima e abaixo). Por exemplo, aqui está que o fragmento de mostra do HTML com espaço vertical de 50 e espaço horizontal de 10:
<P><APPLET CODE="HelloAgainApplet.class" WIDTH=300 HEIGHT=200 ALIGN=LEFT VSPACE=50 HSPACE=10>Hello Again!</APPLET> To the left of this paragraph is an applet. Its a simple, unassuming applet, in which a small string is printed in red type, set in 36 point Times bold. <BR CLEAR=ALL> <P>In the next part of the page, we demonstrate how under certain conditions, styrofoam peanuts can be used as a healthy snack.
O resultado em um browser de Java típico poderia parecer a isto na Figura 8.5.
A figura 8.5: espaço vertical e horizontal.
Dois atributos finais para observar em <APPLET> são CODE e CODEBASE. Diferentemente de outros atributos, nenhum destes tem algo a ver com a aparência do applet na página; estes dois enviam à posição real de Java applet o arquivo para que o browser permitido por Java possa encontrá-lo.
CODE usa-se para indicar o nome do arquivo de classe que mantém a corrente applet. Se CODE se usar sozinho na etiqueta de <APPLET>, o arquivo de classe procura-se no mesmo diretório que o arquivo de HTML que o refere. Observe que os nomes de arquivo de classe usados em CODE têm a extensão de .class; isto é diferente de no intérprete de linha de comando de Java, que não usa a extensão.
Se quiser guardar os seus arquivos de classe em um diretório diferente no seu Servidor Web do que aquele dos seus arquivos de HTML, tem de dizer o browser onde encontrar aqueles arquivos de classe. Para fazer isto, usa CODEBASE. CODE só contém o nome do arquivo de classe; CODEBASE contém um nome de caminho alternativo (de fato um URL ou nome de caminho relativo) onde as classes se contêm. Por exemplo, se guarda os seus arquivos de classe em um diretório chamado classes, que está no mesmo diretório que os seus arquivos de HTML, CODEBASE é o seguinte:
<APPLET CODE="myclass.class" CODEBASE="classes"
WIDTH=100 HEIGHT=100></APPLET>
Se guardar todas as suas classes de Java em alguma posição central, também pode usar um URL em CODEBASE:
<APPLET CODE="myclass.class" CODEBASE="http://myserver.com/javaclasses"
WIDTH=100 HEIGHT=100></APPLET>
E se os seus arquivos de classe se guardam de fato em um servidor inteiramente diferente completamente? Pode usar isto URL em CODEBASE também:
<APPLET CODE="myclass.class" CODEBASE="http://www.joesserver.com/javaclasses"
WIDTH=100 HEIGHT=100></APPLET>
Normalmente, usando o modo padrão de indicar Java applets em Páginas da Web, usa <APPLET> para apontar para a classe applet primária do seu applet. O seu browser permitido por Java então carregará e dirigirá isto applet. Isto applet pode usar outras classes ou arquivos de mídia, também carregam de todos de que do Servidor Web como são necessários.
O problema com a gerência applets deste modo consiste em que cada arquivo um applet precisa - de ser ele outra classe de ajudante, imagem, arquivo áudio, arquivo de texto ou algo mais - é uma conexão separada que o browser tem de fazer ao servidor. Como há um período de tempo justo somente tinha de fazer a própria conexão, isto pode aumentar o período de tempo que toma para carregar do seu applet e tudo do qual precisa.
A solução para este problema é um arquivo de Java. Um arquivo de Java é uma coleção de classes de Java e outros arquivos contidos em um arquivo único. Usando um arquivo de Java, o browser só faz uma conexão ao servidor, em vez de vário. Reduzindo o número de arquivos o browser tem de carregar do servidor, podem carregar do seu applet e dirigir isto muito mais rápido. Os arquivos de Java também podem comprimir-se, fazendo o tamanho de arquivo total mais pequeno e por isso mais rápido carregar também (embora possa levar um tempo no lado de browser dos arquivos a descomprimir-se antes que possam correr).
Agora mesmo só o Netscape apoia o uso de arquivos de Java, e só para arquivos de classe de Java (não para meios de comunicação). Dentro do Netscape, pode usar o atributo de ARchIVE para indicar o nome do arquivo, como isto:
<APPLET CODE="MyApplet.class" ARchIVE="appletstuff.zip" WIDTH=100 HEIGHT=100> ... </APPLET>
O próprio arquivo é um arquivo de código postal não compresso. Os arquivos de código postal padrão, que usam alguma forma da compressão para fazer o arquivo mais pequeno, não se reconhecem. Também, as classes de ajudante podem conter-se dentro e fora do arquivo de código postal; o Netscape olhará em qualquer lugar.
O atributo de ARchIVE ignora-se por browseres ou espectadores applet que podem encontrar por acaso esta Página da Web. Se realmente usar arquivos de Java para o Netscape, é uma boa ideia de guardar tanto o arquivo como os arquivos individuais no seu Servidor Web para que todos os browseres permitidos por Java quem visitam a sua Página da Web possam examinar o seu applet.
Além do esquema de arquivo simples de Netscape, Java 1.1 incluirá o suporte de arquivos de JARRO. Os arquivos de JARRO são arquivos de Java, com ou sem compressão, que pode conter tanto classes como meios de comunicação. Além disso, os arquivos de JARRO são plataforma independente, e os instrumentos para criá-los estarão disponíveis em qualquer plataforma que apoia o JDK. Os arquivos de JARRO e os seus componentes individuais também podem assinar-se digitalmente, significando que o seu criador pode identificar-se confiantemente (uma forma da segurança). Para mais informação sobre arquivos de JARRO, inclusive as especificações do formato de arquivo real, ver Preview Page JDK 1.1 em http://java.sun.com/products/JDK/1.1/designspecs/.
Com aplicações de Java, passa parâmetros à sua rotina de main() usando argumentos na linha de comando, ou, para Macintosh, na caixa de diálogo de Corredor de Java. Então pode analisar aqueles argumentos dentro do corpo da sua classe, e a aplicação atua consequentemente, baseada nos argumentos que se dá.
Applets, contudo, não têm uma linha de comando. Como passa em argumentos diferentes a um applet? Applets pode adquirir a entrada diferente do arquivo de HTML que contém a etiqueta de <APPLET> por meio do uso de parâmetros applet. Para estabelecer-se e tratar parâmetros em um applet, precisa de duas coisas:
Os parâmetros de Applet vêm para duas partes: um nome de parâmetro, que é simplesmente um nome que escolhe, e um valor, que é o valor real daquele determinado parâmetro. Deste modo, por exemplo, pode indicar a cor do texto em um applet usando um parâmetro com o nome color e o valor red. Pode determinar a velocidade de uma animação usando um parâmetro com o nome speed e o valor 5.
No arquivo de HTML que contém o applet introduzido, indica cada parâmetro usando a etiqueta de <PARAM>, que tem dois atributos para o nome e o valor, chamado (bastante surpreendentemente) NAME e VALUE. A etiqueta de <PARAM> vai dentro da abertura e encerramento de etiquetas de <APPLET>:
<APPLET CODE="MyApplet.class" WIDTH=100 HEIGHT=100> <PARAM NAME=font VALUE="TimesRoman"> <PARAM NAME=size VALUE="36"> A Java applet appears here.</APPLET>
Este determinado exemplo define dois parâmetros ao MyApplet applet: aquele cujo nome é font e cujo valor é TimesRoman e aquele cujo nome é size e cujo valor é 36.
Os parâmetros passam-se ao seu applet quando se carrega. No método de init() do seu applet, então pode vir mantêm-se daqueles parâmetros usando o método de getParameter(). getParameter() toma uma cadeia de argumento-a que representa o nome do parâmetro olha para - e devolve uma cadeia que contém o valor correspondente daquele parâmetro. (Como argumentos em aplicações de Java, todos os valores de parâmetro são cadeias.) Para adquirir o valor do parâmetro de font do arquivo de HTML, poderia ter uma linha como isto no seu método de init():
String theFontName = getParameter("font");
| Observar |
Os nomes dos parâmetros como especificado em <PARAM> e os nomes dos parâmetros em getParameter() devem combinar identicamente, inclusive ter o mesmo caso. Em outras palavras, <PARAM NAME="name"> é diferente de <PARAM NAME="Name">. Se os seus parâmetros não se estiverem propriamente passando ao seu applet, assegure-se o jogo de casos de parâmetro. |
Observe que se um parâmetro esperar não se especificou no arquivo de HTML, getParameter() devolve null. Muitas vezes, quererá testar para um parâmetro de null no seu Java codificam e fornecem a um default razoável:
if (theFontName == null)
theFontName = "Courier"
Tenha em mente que getParameter() devolve cadeias - se quiser que um parâmetro seja algum outro objeto ou tipo, tem de convertê-lo você mesmo. Para analisar o parâmetro de size daquele mesmo arquivo de HTML e destiná-lo a uma variável de número inteiro chamada theSize, poderia usar as seguintes linhas:
int theSize;
String s = getParameter("size");
if (s == null)
theSize = 12;
else theSize = Integer.parseInt(s);
Adquiri-lo? Não ainda? Vamos criar um exemplo de um applet que usa esta técnica. Modificará o Olá Novamente applet para que diga olá a um nome específico, por exemplo, "Hello Bill" ou "Hello Alice". O nome passa-se no applet por um parâmetro de HTML.
Vamos começar copiando a classe de HelloAgainApplet original e chamando-a MoreHelloAgain (ver a Listagem 8.3).
A listagem 8.3. Mais Olá Novamente applet.
1:import java.awt.Graphics;
2:import java.awt.Font;
3:import java.awt.Color;
4:
5:public class MoreHelloApplet extends java.applet.Applet {
6:
7: Font f = new Font("TimesRoman", Font.BOLD, 36);
8:
9: public void paint(Graphics g) {
10: g.setFont(f);
11: g.setColor(Color.red);
12: g.drawString("Hello Again!", 5, 40);
13: }
14:}
A primeira coisa que tem de acrescentar a esta classe é um lugar de manter o nome da pessoa que diz olá. Como precisará daquele nome em todas as partes do applet, vamos acrescentar uma variável de exemplo do nome, somente depois da variável da fonte na linha 7:
String name;
Para estabelecer um valor do nome, tem de adquirir aquele parâmetro do arquivo de HTML. O melhor lugar de tratar parâmetros com um applet é dentro de um método de init(). O método de init() define-se de mesmo modo a paint() (public, sem argumentos e um tipo de regresso de void). Assegure-se quando testa para um parâmetro que testa para um valor de null. O default, neste caso, se um nome não se indicar, deve dizer olá a "Laura". Acrescente o método de init() entre as suas definições de variável de exemplo e a definição de paint(), justo antes da linha 9:
public void init() {
name = getParameter("name");
if (name == null)
name = "Laura";
}
Agora que tem o nome dos parâmetros de HTML, precisará de modificá-lo para que seja uma cadeia completa - isto é, para pregar o word Hello com um espaço para o começo e um ponto de exclamação para o fim. Pode fazer isto no método de paint() justo antes da impressão da cadeia à tela, mas isto significaria criar uma nova cadeia cada vez quando o applet pinta-se. Seria muito mais eficiente fazê-lo somente uma vez, diretamente depois de adquirir o próprio nome, no método de init(). Acrescente esta linha ao método de init() justo antes da tira última:
name = "Hello " + name + "!";
E agora, tudo isto deixa-se deve modificar o método de paint() para usar o novo parâmetro de nome. O método de drawString() original pareceu a isto:
g.drawString("Hello Again!", 5, 40);
Para desenhar a nova cadeia guardou na variável de exemplo de name, tudo que tem de fazer é substituir por aquela variável pela cadeia literal:
g.drawString(name, 5, 40);
A listagem 8.4 mostra o resultado final da classe de MoreHelloApplet. Compile-o para que tenha um arquivo de classe pronto.
A listagem 8.4. A classe de MoreHelloApplet.
1: import java.awt.Graphics;
2: import java.awt.Font;
3: import java.awt.Color;
4:
5: public class MoreHelloApplet extends java.applet.Applet {
6:
7: Font f = new Font("TimesRoman", Font.BOLD, 36);
8: String name;
9:
10: public void init() {
11: name = getParameter("name");
12: if (name == null)
13: name = "Laura";
14:
15: name = "Hello " + name + "!";
16: }
17:
18: public void paint(Graphics g) {
19: g.setFont(f);
20: g.setColor(Color.red);
21: g.drawString(name, 5, 40);
22: }
23: }
Agora vamos criar o arquivo de HTML que contém este applet. A listagem 8.5 mostra uma nova Página da Web do MoreHelloApplet applet.
A listagem 8.5. O arquivo de HTML do MoreHelloApplet applet.
1: <HTML> 2: <HEAD> 3: <TITLE>Hello!</TITLE> 4: </HEAD> 5: <BODY> 6: <P> 7: <APPLET CODE="MoreHelloApplet.class" WIDTH=200 HEIGHT=50> 8: <PARAM NAME=name VALUE="Bonzo"> 9: Hello to whoever you are! 10: </APPLET> 11: </BODY> 12: </HTML>
| Análise |
Observe a etiqueta de <APPLET>, que aponta para o arquivo de classe do applet e tem a largura apropriada e altura (200 e 50). Somente em baixo dele (linha 8) é a etiqueta de <PARAM>, que usa para passar no valor do nome. Aqui, o parâmetro de NAME é simplesmente nome, e o VALUE é a cadeia "Bonzo". |
Carregar este arquivo de HTML no Netscape produz o resultado mostrado na Figura 8.6.
A figura 8.6: O resultado de usar MoreHelloApplet a primeira vez.
Vamos tentar um segundo exemplo. Lembre-se de que no código de MoreHelloApplet, se nenhum nome se especificar em um parâmetro, o default é o nome Laura. A listagem 8.6 cria um arquivo de HTML sem etiqueta de parâmetro de name.
A listagem 8.6. Outro arquivo de HTML do MoreHelloApplet applet.
1: <HTML> 2: <HEAD> 3: <TITLE>Hello!</TITLE> 4: </HEAD> 5: <BODY> 6: <P> 7: <APPLET CODE="MoreHelloApplet.class" WIDTH=200 HEIGHT=50> 8: Hello to whoever you are! 9: </APPLET> 10: </BODY> 11: </HTML>
Aqui, porque nenhum nome se forneceu, o applet usa o default, e o resultado é o que poderia esperar (ver a Figura 8.7).
A figura 8.7: O resultado de usar MoreHelloApplet a segunda vez.
Applets são provavelmente a maior parte de uso comum da língua de Java hoje. Applets são mais complicados do que muitas aplicações de Java porque se realizam e se desenham ligados em série dentro de Páginas da Web, mas podem acessar a gráfica, interface de usuário e estrutura de evento fornecida pelo próprio Navegador da Web. Hoje aprendeu os fundamentos de criar applets, inclusive as seguintes coisas:
| Na primeira parte da lição de hoje, diz que carregam de applets de Servidores Web casuais e corrida no sistema do cliente. O que deve parar um desenvolvedor applet de criar um applet que elimina todos os arquivos naquele sistema, ou de algum outro modo compromete a segurança do sistema? | |
| Lembre que Java applets tem várias restrições que o fazem difícil para todo do comportamento malicioso mais óbvio de realizar-se. Por exemplo, porque Java applets não pode ler ou escrever arquivos no sistema de cliente, não podem eliminar arquivos ou ler arquivos de sistema que poderiam conter a informação privada. Como não podem dirigir programas no sistema do cliente sem a sua permissão expressa, por exemplo, não podem pretender ser você e programas de sistema de corrida. Nem podem dirigir tantos programas que o seu sistema espatifa. Além disso, Java muito arquitetura faz difícil lograr estas restrições. A própria língua, o compilador de Java e o intérprete de Java todos têm cheques para assegurar-se que ninguém tentou andar furtivamente em código falso ou jogos de jogo com o próprio sistema. Aprenderá mais sobre estes cheques no fim deste livro. Naturalmente, nenhum sistema pode afirmar ser 100 por cento seguro, e o fato que Java applets se dirige no seu sistema deve fazê-lo suspeito - ver o Dia 21 para mais na segurança. | |
| Espere um minuto. Se não puder ler ou escrever arquivos ou dirigir programas no sistema o applet continua, que não significa que basicamente não posso fazer nada outro do que animação simples e gráfica flamejante? Como posso salvar o estado em um applet? Como posso criar, dizer, um processador de palavra ou uma planilha como Java applet? | |
| Para todo o mundo quem não acredita que Java é bastante seguro, há alguém que acredita que as restrições de segurança de Java são demasiado severas por somente estas razões. Sim, Java applets limita-se por causa das restrições de segurança. Mas, considerando a possibilidade do abuso, acredito que é melhor errar no lado de ser mais conservador pelo que a segurança esteja em questão. Considere-o um desafio. Tenha em mente, também, que as aplicações de Java não têm nenhuma das restrições que Java applets faz, mas porque também se compilam a bytecode, são portáteis através de plataformas. Pode ser que a coisa que quer criar faria uma aplicação muito melhor do que um applet. Se a coisa que quer criar tiver de ser um applet, a única solução que tem para salvar o estado ou implementar algo como um processador de palavra em Java applet é permitir aos seus leitores salvar o estado atrás ao seu servidor. | |
| O applets vai se parecer com isto para sempre confinado à caixa de areia e incapaz de fazer algo outro do que animação whizzy e brinquedos simples? | |
| O sol trabalha em futuros modelos da segurança applet que permitirá a applets libertar-se da caixa de areia em alguns exemplos. Uma das soluções que se discutem é para o arquivo de classe applet a assinar-se digitalmente, que é um modo de identificar sem uma dúvida onde um applet veio de (por exemplo, se um applet se assina pelo Sol, pode estar seguro que foi Sol que de fato o criou, e por isso confiança ele mais do que alguma outra necessidade de applet casual). Aprenderá mais sobre a segurança applet no Dia 21. | |
| Tenho uma mais velha versão do browser de HotJava. Segui todos os exemplos nesta seção, mas HotJava não pode ler o meu applets (parece ignorá-los). O que está acontecendo? | |
| Mais provavelmente tem uma versão alfabética de HotJava. Lembre que as mudanças significativas se fizeram a Java API e como Java applets se escreve entre a alfa e o 1,0 lançamento. O resultado destas modificações consiste em que os browseres que apoiam a alfa applets não podem ler a beta applets, e vice-versa. As etiquetas de HTML são até diferentes, portanto um mais velho browser somente omite sobre mais novo applets, e vice-versa. Em que lê isto, pode haver uma nova versão de HotJava com o suporte de 1,0. Se não, pode usar Netscape, Internet Explorer ou o appletviewer do JDK para examinar applets escrito à especificação de beta. | |
| Notei na minha documentação que a etiqueta de <APPLET> também tem um atributo de NAME. Não o discutiu aqui. | |
| NAME usa-se quando tem múltiplo applets em uma página que tem de comunicar-se um com outro. Aprenderá sobre isto no Dia 12, "Dirigindo Eventos Simples e Interatividade". | |
| Muitos exemplos applet que vi na Web têm um método de init() que não faz nada para chamar um método de resize() com os mesmos valores que na etiqueta de <APPLET> WIDTH e HEIGHT. Perguntei um amigo sobre isto e disse que tem de ter resize() em lá para assegurar-se o applet's o tamanho certo. Não menciona resize(). | |
| A chamada ao método de resize() em init() deixa-se dos primeiros dias de applets quando realmente precisou de resize() para estabelecer o tamanho inicial do applet. Nestes dias só o WIDTH e os atributos de HEIGHT fazem isto; a chamada de resize() não é necessária. | |
| Tenho um applet que toma parâmetros e um arquivo de HTML que o passa aqueles parâmetros. Mas quando o meu applet corre, tudo que adquiro são valores de null. O que está acontecendo aqui? | |
| Os nomes dos seus parâmetros (no atributo de NAME) combinam exatamente com os nomes para que testa em getParameter()? Devem ser exatos, inclusive o caso, para o jogo a fazer-se. Também assegure-se que as suas etiquetas de <PARAM> são dentro da abertura e encerramento de etiquetas de <APPLET>, e que não soletrou mal nada. | |
| Desde que os applets não têm uma linha de comando ou uma corrente de stdout, como pode fazer a produção de depuração simples como System.out.println() em um applet? | |
| Pode. Dependendo do seu browser ou outro ambiente permitido por Java, pode haver uma janela de console onde depurar produção (o resultado de System.out.println()) aparece, ou pode salvar-se a um arquivo de log (O Netscape tem um Consolo de Java de acordo com o menu Options; o Internet Explorer usa um arquivo de log de Java que deve permitir usar Opções | Promovido). Pode continuar imprimindo mensagens usando System.out.println() no seu applets - somente lembram-se de retirá-los uma vez que se faz assim não confundem os seus leitores reais! |
