Introdução ao Java Applets

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (5)  (0)

Veja neste artigo como usar o recurso de Applets em Java, um poderoso recurso muito usado quando há a necessidade de processamentos mais complexos que exigem recursos extras do Java.

Neste artigo veremos uma introdução ao uso de Applets em Java, que é um recurso muito interessante quando há a necessidade de processamentos mais complexos que exigem recursos extras do Java. Você pode ver exemplos de Applet's funcionando principalmente nos sites de bancos onde você precisar digitar sua senha através de um teclado digital, ou seja, aquilo é um “Applet”.

Antes de qualquer coisa é preciso entender o que é o Applet, o seu conceito. O Applet nada mais é do que uma aplicação em Java (similar ao Java Desktop) que pode ser executado no browser juntamente com sua aplicação web. Vamos entender como isso funciona de forma mais didática.

Imagine que você tenha uma aplicação Web educativa, que ensina alunos de Medicina a montar um esqueleto em todos os seus detalhes. Sua aplicação verifica se determinada estrutura óssea está corretamente montada, dentre outras funcionalidades. Sua aplicação atualmente funciona em JSF, então você obviamente terá suas páginas XHTML e suas classes em Java, certo?

Porém você entra em um impasse: Como fazer essa simulação esquelética usando XHTML, JavaScript, Primefaces e etc, isso é possível? Impossível não é, mas é impraticável e foge as regras das boas práticas de programação, pois caso você consiga realizar tal feito apenas com os recursos Web, então você provavelmente terá uma página poluída e de difícil manutenção.

Se você estivesse trabalhando com Java Desktop seria bem mais simples, pois você teria em mãos todo recurso da programação gráfica utilizando Java 2D ou 3D, mas em XHTML você não terá tal recurso, e fazer isso “na unha” não é uma boa alternativa. A saída então é dentro da sua aplicação Web (dentro do seu XHTML) simular uma aplicação Desktop (que faça uso do Swing, por exemplo), e para isso serve o Applet.

Dentro da sua classe Applet você desenvolve abstraindo toda interface Web, trabalhando como se fosse um ambiente Desktop, e depois você apenas encapsula sua “pequena” aplicação dentro da sua aplicação maior (Web).

Exemplos de Applets

Nada melhor do que exemplos para entender a teoria. Vamos alterar um pouco a ordem do artigo, começando pelo mais complexo até chegarmos ao mais fácil, ou seja, mostraremos primeiro um exemplo completo de um Applet com uma lógica mais completa e por último mostraremos o “Hello World”.

Listagem 1. Desenvolvendo um Applet

  import java.applet.Applet;
  import java.awt.*;          
  // Imports Button, Canvas, TextArea, TextField
  import java.awt.event.*;    
  // Imports ActionEvent, ActionListener
    
  public class Viagem extends Applet
  {  
     // Nossos Componentes do Applet
     TextField distanciaText = new TextField(10);
     TextField aceleracaoText = new TextField(10);
     Button    iniciarButton = new Button("INICIAR!");
     TextArea  respostas = new TextArea(
         "Sucesso !!",
          8,
          60,
          TextArea.SCROLLBARS_NONE
     );
     /*
      * No applet não existe o método main assim como em uma classe Java
      * comum, mas temos aqui o init() que é muito similar ao main, 
      * pois este é executado na criação do mesmo
      * */
     public void init( )
     {      
        addHorizontalLine(Color.red);
        addNewLine( );
         
      
        add(distanciaText);
        add(new Label("Distancia da Viagem em Ano-luz"));
        addNewLine( );
        add(aceleracaoText);
        add(new Label("Aceleração do foguete em g's"));
        addNewLine( );
        add(iniciarButton);
        addNewLine( );
        
        respostas.setEditable(false);
        add(respostas);
        addNewLine( );
        addHorizontalLine(Color.red);
        
        // Tell the button what it should do when clicked:
        iniciarButton.addActionListener(new IniciarListener( ));
     }
   
     class IniciarListener implements ActionListener
     {
        public void actionPerformed(ActionEvent event)
        {
           double distance;     // Distance of the trip in light years.
           double acceleration; // Acceleration of the trip in g's.
           
           distance = atod(distanciaText.getText( ));
           if (Double.isNaN(distance) || distance < 0)
           {
              respostas.setText("A distância não pode ser negativa.");
              distanciaText.requestFocus( );
              distanciaText.selectAll( );
              return;
           }
   
           acceleration = atod(aceleracaoText.getText( ));
           if (acceleration == Double.NaN || acceleration <= 0)
           {
              respostas.setText("A aceleração não pode ser negativa.");
              aceleracaoText.requestFocus( );
              aceleracaoText.selectAll( );
              return;
           }
           
           makeTrip(distance, acceleration);
        }                   
     }
    
     // The inverse hyperbolic sine function:
     double asinh(double x)
     {
        return Math.log(x + Math.sqrt(x*x + 1));
     }
     
     double atod(String s)
     {
        double answer;
        Double d;
        
        try
        {
           d = new Double(s);
           answer = d.doubleValue( );
        }
        catch (NumberFormatException e)
        {
           answer = Double.NaN;
        }
        return answer;
     }
     
     // http://www.desy.de/user/projects/Physics/rocket.html
     void makeTrip(double distance, double acceleration)
     {
        final double LIGHT_YEAR   = 9.47e15; 
        // meters per light year
        final double c                  = 3.00e8;  
        // speed of light in meters/sec
        final double g                  = 9.81;    
         // gravity in meters/sec^2
        final double SECONDS_PER_YEAR = 60.0 * 60.0 * 24.0 * 365.25;
        
        double d;                 
         // Half of trip in meters
        double a;                 
        // Acceleration in meters/sec^2
        double time_earth;   
         // Time for trip as viewed from Earth (seconds)
        double time_ship;    
         // Time for trip as viewed from rocket(seconds)
        double years_earth;  
         // Time for trip as viewed from Earth (years)
        double years_ship;   
         // Time for trip as viewed from rocket(years)
        
        // Computations:
        d = LIGHT_YEAR * distance / 2;
        a = g * acceleration;
        time_earth = 2*Math.sqrt( (d*d)/(c*c) + 2*d/a );
        time_ship = 2*(c/a) * asinh(a*time_earth/c);
        years_earth = time_earth / SECONDS_PER_YEAR;
        years_ship = time_ship / SECONDS_PER_YEAR;
        
        // Mostra as respostas
        respostas.setText("");
        respostas.append("Distância da Viagem:   ");
        respostas.append((new Double(distance))
          .toString( ) + " Ano-Luz.\n");
        respostas.append("Aceleração:  ");
        respostas.append((new Double(acceleration))
          .toString( ) + " g.\n");
        respostas.append("Tempo na Terra: ");
        respostas.append((new Double(years_earth))
          .toString( ) + " anos.\n");
     }
   
     private void addHorizontalLine(Color c)
     {  
        
        Canvas line = new Canvas( );
        line.setSize(10000,1);
        line.setBackground(c);
        add(line);
     }
     
     private void addNewLine( )
     {  
        addHorizontalLine(getBackground( ));
     }
        
  }
  

Você pode se perguntar por que um exemplo complexo para mostrar simplesmente o funcionamento de um Applet simples? Pois o nosso objetivo é mostrar além de um simples “Hello World” e deixar você leitor com o cargo de estudar o código acima e entender o funcionamento mais detalhado do Applet. Com base na Listagem 1 você já pode desenvolver suas próprias lógicas, tendo em mente a forma com que deve-se trabalhar ao utilizar um Applet.

Baseado no Applet acima, como faremos agora para acoplar à nossa página HTML? Veja a Listagem 2 para tal explicação.

Listagem 2. Encapsulando um Applet no HTML

  <HTML>
    <HEAD>
      <TITLE> Calculador de Viagem Espacial </TITLE>
    </HEAD>
    <BODY>
   
      Veja nosso applet funcionando abaixo:
      <APPLET CODE=”Viagem.class" WIDTH=150 HEIGHT=25>
      </APPLET>
    </BODY>
  </HTML>

Veja como o código é bem simples e sem nenhuma poluição visual, pois toda a lógica fica dentro do nosso Applet, e o usuário jamais verá “milhares” de tags HTML desnecessárias. É óbvio que em nosso exemplo da Listagem 1 poderíamos usar nossas próprias classes como ManagedBean ou BO (Business Object) juntamente com o JSF para realizar nossos cálculos (sem necessidade de um Applet), pois apesar de parecer complexo, o exemplo da Listagem 1 é simples.

Mas para aqueles usuários que ainda preferem um simples “Hello World”, colocaremos na Listagem 3 uma demonstração pura e simples de um Applet sem nada, apenas com um uma mensagem na tela.

Listagem 3. Hello World Applet

  import java.applet.Applet;
  import java.awt.Graphics;
   
  public class HelloWorld extends Applet {
      public void paint(Graphics g) {
          g.drawString("Hello world!", 50, 25);
      }
  }

Veja que nosso Applet está pronto e funcionando, a única função dele é mostrar a mensagem “Hello World” na tela. É interessante ter os dois lados da “moeda”, um exemplo simples e outro mais trabalhado, pois assim você poderá aprofundar-se mais neste assunto seguindo exemplos com mais detalhes, métodos, atributos e lógicas avançadas. E como fica nosso Applet Hello Worlds no HTML? Veja na Listagem 4.

Listagem 4. Applet Hello World no HTML

  <HTML>
    <HEAD>
      <TITLE> Hello World Applet </TITLE>
    </HEAD>
    <BODY>
   
      <APPLET CODE="HelloWorld.class" WIDTH=150 HEIGHT=25>
      </APPLET>
    </BODY>
  </HTML>

Com isso, neste artigo mostramos que Applets são poderosas ferramentas para que você possa ter toda a praticidade de trabalhar em um ambiente Web e ao mesmo tempo não deixar de utilizar quaisquer recursos disponíveis na plataforma Java. Como alternativa ao Applet exige ainda o JWS que também “simula” um ambiente desktop em conjunto com um Web, obviamente com algumas diferenças que devem ser estudadas por você leitor. Vale a pena realizar a comparação de qual se adapta melhor a sua realidade, e as suas regras de negócio, podemos garantir que ambos os mecanismo são de extrema importância e muito úteis nas situações em que são necessários.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?