07_curso_de_java_banco_de_dados_e_aplicacoes_cliente_servidor

Prévia do material em texto

Professor Sérgio Furgeri 
 
IPEP – 2001 
 
Indice Analítico 
 
1.0. Componentes do Pacote AWT e criação de Applets ............................... 01 
1.1. Ciclo de vida de uma Applet.................................................................01 
1.2. Uso de Botões...................................................................................... 03 
1.3. Uso do campo texto............................................................................. 04 
1.4. Uso de Caixas de Entrada e de Diálogo.............................................. 05 
1.5. Controlando o Acesso através de senhas........................................... 07 
1.6. Uso de Botões Tipo CheckBox............................................................ 08 
1.7. Uso de Botões de Rádio...................................................................... 09 
1.8. Uso de Listas Tipo Combo...................................................................11 
1.9. Uso de Listas Tipo ListBox...................................................................13 
1.10. Uso da Barra de Rolagem.................................................................. 15 
1.11. Uso do Text Area................................................................................16 
1.12. Geração de Menus............................................................................. 18 
 
2.0. Controle de Eventos e Manipulação de Arquivo Texto.............................26 
2.1. Controle de eventos............................................................................. 26 
2.2. Manipulação de arquivos Texto através de aplicações........................30 
2.3. Manipulação de arquivos Texto através de Applets.............................37 
2.3.1 Restrições das Applets............................................................ 39 
2.3.2 Criação do Policy File.............................................................. 39 
2.4. Manipulação de arquivos Texto através do Browser........................... 41 
 
3.0. Passagem de Parâmetros e Aplicações Cliente Servidor........................ 43 
3.1. Passagem de parâmetros para Applets............................................... 43 
3.2. Utilização de Servlets........................................................................... 45 
3.2.1. A criação da aplicação Cliente............................................... 46 
3.2.2. A criação da aplicação Servidora........................................... 47 
3.2.3. A configuração do JavaWebServer 2.0.................................. 48 
3.2.4. Realização da comunicação................................................... 52 
3.2.5. Criação de uma Applet Cliente............................................... 54 
 
4.0. Acesso a Banco de Dados através de Aplicações.................................... 55 
4.1. A criação do banco de dados............................................................... 55 
4.2. A Configuração do sistema.................................................................. 56 
4.3. A criação da aplicação em Java...........................................................58 
4.3.1. A conexão com o banco de dados.........................................58 
4.3.2. A leitura do banco de dados com o SQL................................ 58 
4.3.3. Criação de consultas com tabelas..........................................62 
 
5.0. Uso da Classe Table e Manutenção em Banco de Dados.........................66 
5.1. Verificação do conteúdo das células da tabela.................................... 66 
5.2. Posicionamento da seleção da tabela..................................................68 
5.3. Uso do objeto Combo dentro da tabela................................................71 
5.4. Uso do objeto CheckBox dentro da tabela........................................... 73 
5.5. Uma aplicação completa para manutenção em tabelas...................... 76 
 
Anexo A: Utilização do HTML Converter........................................................... 83 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 1 
Componentes do Pacote AWT e criação de Applets 
 
Essa aula aborda o nível intermediário da linguagem Java através da 
utilização de classes já disponíveis, apropriadas para a criação de aplicações 
gráficas (conhecidas como pacote awt — ABSTRACT WINDOW TOOLKIT). Ao 
desenvolver uma aplicação gráfica é necessário definir quais componentes 
serão utilizados e qual a disposição que eles terão na janela. O pacote de 
classes da AWT, possui diversos componentes utilizados para a criação de 
Janelas (Frames). Serão abordados os componentes mais utilizados. 
 
1.1. Ciclo de vida de uma Applet 
 
Uma Applet possui diversos estágios durante seu período de 
processamento. A união desses períodos é chamada de Ciclo de vida de uma 
Applet. O ciclo de vida é composto por 6 fases: 
 
1 – Instanciação: Ocorre no momento que a Applet é criada. 
Ex. public class Applet01 extends Applet 
 
2 – Inicialização: é o método invocado após a criação da Applet, utilizado 
pelos navegadores para iniciar a execução da Applet. Geralmente é o método 
utilizado para a adição dos componentes da AWT para a criação dos Frames. 
Esse método é executado apenas uma vez, quando a applet é inicializada. 
Nome do método: public void init() { } 
 
3 – Inicio: esse método é chamado toda vez que a Applet se torna visível na 
tela do browser. 
Nome do método: public void start() { } 
 
4 – Parada: esse método é chamado toda vez que a Applet se torna invisível. 
Nome do método: public void stop() { } 
 
5 – Execução: esse método é chamado toda vez que a Applet necessita 
atualizar sua exibição na tela (janela redimensionada, minimizada...). 
Nome do método: public void paint() { } 
 
6 – Finalização: esse método é chamado quando a Applet está sendo 
descarregada da página para que seja realizada a liberação final de todos os 
recursos utilizados durante sua execução. 
Nome do método: public void destroy() { } 
 
O exemplo seguinte demonstra o funcionamento do ciclo de vida 
completo de uma Applet. Para que sua funcionalidade seja observada 
corretamente, o applet deve ser execuado através do Appletviewer presente no 
kit de desenvolvimento da Sun. Sendo assim, depois de compilado e criado o 
arquivo HTML, digite: appletviewer ex00.html 
 
import java.applet.Applet; 
import java.awt.Graphics; 
import java.awt.Color; 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 2 
public class ex00 extends Applet 
{ 
 String text = "Estudo da Applet"; 
 int cont = 0; 
 
 public void init() 
 { 
 text = "Estudo da Applet..."; 
 setBackground(Color.cyan); 
 } 
 
 public void start() 
 { 
 System.out.println("Iniciando..."); 
 } 
 
 public void stop() 
 { 
 System.out.println("Parando..."); 
 } 
 
 public void destroy() 
 { 
 System.out.println("Preparando para descarregar..."); 
 } 
 
 public void paint(Graphics g) 
 { 
 text = "Atualizou "+cont++; 
 g.setColor(Color.blue); 
 g.drawRect(0, 0, 
 getSize().width -1, 
 getSize().height -1); 
 g.setColor(Color.red); 
 g.drawString(text, 15, 25); 
 } 
} 
Exemplo do ciclo de vida da Applet 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Estudo do ciclo de vida da Applet<BR><BR> 
<applet code="ex00.class" width=250 height=180> 
</applet> 
</html> 
Arquivo ex00.html 
 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 3 
 
Figura 1.1 – A classe ex00 sendo executada 
 
1.2. Uso de Botões 
O exemplo seguinte mostra como utilizar um botão em uma Applet,reconhecendo o click do usuário. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex01 extends Applet implements ActionListener 
{ 
 Button b1 = new Button("OK"); 
 
 public void init() 
 { 
 b1.addActionListener(this); 
 add(b1); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { // metodo implementado pelo ActionListener 
 System.out.println("Botao pressionado"); 
 } 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso do Botão<BR><BR> 
<applet code="ex01.class" width=340 height=80> 
</applet> 
</html> 
Exemplo 1 – Uso do Componente Button 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 4 
 
Figura 1.2 – A classe ex01 sendo executada 
 
1.3. Uso do campo texto 
O exemplo seguinte mostra como utilizar uma caixa de texto em uma 
Applet, trocando caracteres no caso da digitação de uma senha. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex02 extends Applet implements ActionListener 
 { 
 TextField t1 = new TextField(10); 
 TextField t2 = new TextField(10); 
 Button b1 = new Button("Entrar"); 
 
 public void init() 
 { 
 b1.addActionListener(this); 
 t1.setEchoChar('*'); 
 add(b1); 
 add(t1); 
 add(t2); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 t2.setText(t1.getText()); 
 } 
 
 } 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso do TextField<BR><BR> 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 5 
<applet code="ex02.class" width=340 height=80> 
</applet> 
</html> 
Exemplo 2 – Uso do Componente TextField 
 
 
Figura 1.3 – A classe ex02 sendo executada 
 
 
1.4. Uso de Caixas de Entrada e de Diálogo 
 
O exemplo seguinte mostra como utilizar uma caixa de entrada para 
receber o nome de um usuário. Após receber o nome, a Applet verifica se o 
usuário é reconhecido e envia uma mensagem através de uma caixa de diálogo. 
Obs. Essa Applet não roda originalmente no I.E, sendo necessário utilizar o 
Appletviewer. Para tal, consulte o anexo A. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
import javax.swing.JOptionPane; 
 
//Entrada de dados com JOptionPane 
//Não funciona no IE 
public class ex03 extends Applet implements ActionListener 
 { 
 TextField t1 = new TextField(20); 
 String Men=""; 
 
 public void init() 
 { 
 Button b1 = new Button("Entrar"); 
 b1.addActionListener(this); 
// t1.setEditable(false); 
 add(t1); 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 6 
 add(b1); 
 Men = ""; 
 while (Men.equals("")) 
 { 
 Men = JOptionPane.showInputDialog("Entre com seu nome"); 
 if (Men==null) break; //Quando é pressionado o botão cancel, Men recebe null 
 } 
 t1.setText(Men); 
 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 if (!t1.getText().equals("IPEP")) 
 { 
 JOptionPane.showMessageDialog(null,"Usuario\n nao\n reconhecido!"); 
 } 
 } 
 
 } 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso de caixas de mensagens<BR><BR> 
<applet code="ex03.class" width=340 height=80> 
</applet> 
</html> 
Exemplo 3 – Uso da Caixa de Entrada e de Mensagem 
 
Figura 1.4 – A classe ex03 sendo executada 
 
 
 
 
 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 7 
 
 
1.5. Controlando o Acesso através de senhas 
O exemplo seguinte mostra como controlar o acesso de um usuário em 
uma página por meio de senha. 
 
 
import java.net.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
import java.applet.AppletContext; 
 
public class ex04 extends Applet implements ActionListener 
{ 
 String Men=""; 
 Label l1 = new Label("Senha: "); 
 TextField t1 = new TextField(10); 
 Button b1 = new Button("Entrar"); 
 
 public void init() 
 { 
 t1.setEchoChar('*'); 
 b1.addActionListener(this); 
 add(l1);add(t1);add(b1); 
 } 
 
 
 public void actionPerformed(ActionEvent e) 
 { 
 try 
 { 
 if (t1.getText().equals("IPEP")) 
 { 
 getAppletContext().showDocument(new URL ("http://planeta.terra.com.br/educa 
cao/profsergio/frame.html"),"_blank") ; 
 } 
 else 
 getAppletContext().showDocument(new URL ("http://planeta.terra.com.br/educa 
cao/profsergio/naousuario.html"),"_blank") ; 
 } 
 catch(Exception ex) 
 { 
 getAppletContext().showStatus("Erro ao carregar o URL") ; 
 } 
 } 
} 
 
<html> 
<TITLE>Página do Professor Sérgio Furgeri</TITLE> 
O acesso a essa página é restrito!<BR><BR> 
<applet code="ex04.class" width=340 height=80> 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 8 
</applet> 
</html> 
Exemplo 4 – Controlando o Acesso 
Figura 1.5 – A classe ex04 sendo executada 
 
1.6. Uso de Botões Tipo CheckBox 
O exemplo seguinte mostra como utilizar os botões do tipo CheckBox 
para controlar a formatação de um determinado texto de acordo com a escolha 
do usuário. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex05 extends Applet implements ItemListener 
{ 
 Label l1; 
 Checkbox c1,c2; 
 
 public void init() 
 { 
 setBackground(new Color(180,180,180)); 
 setLayout(new FlowLayout(FlowLayout.CENTER)); 
 l1 = new Label("Java"); 
 l1.setFont(new Font("Arial",Font.PLAIN,20)); 
 c1 = new Checkbox("Negrito",false); 
 c2 = new Checkbox("Itálico",false); 
 c1.addItemListener(this); 
 c2.addItemListener(this); 
 add(l1); add(c1); add(c2); 
 } 
 
public void itemStateChanged(ItemEvent e) 
 { 
 int negrito=0,italico=0; 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 9 
 if (c1.getState()) { negrito = Font.BOLD; } //negrito=1 
 else { negrito = Font.PLAIN;} //negrito=0 
 if (c2.getState()) { italico = Font.ITALIC; } //italico=2 
 else { italico = Font.PLAIN; } //italico=0 
 
 l1.setFont(new Font("Arial",negrito+italico,20)); 
 
 } 
 
} 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso de Botões tipo CheckBox<BR><BR> 
<applet code="ex05.class" width=340 height=80> 
</applet> 
</html> 
Exemplo 5 –Uso de Botões Tipo CheckBox 
Figura 1.6 – A classe ex05 sendo executada 
 
1.7. Uso de Botões de Rádio 
O exemplo seguinte mostra como utilizar os Botões de Rádio para efetuar 
um cálculo de acordo com a escolha do usuário. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex06 extends Applet implements ItemListener 
{ 
 Label L1,L2; 
 float N1=0,result=0; 
 TextField T1, T2; 
 Panel P1,P2; 
 Checkbox radio1, radio2, radio3; 
 CheckboxGroup radiogroup; 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 10 
 public void init() 
 { 
 setLayout(new FlowLayout(FlowLayout.CENTER)); 
 setBackground(new Color(230,230,230)); 
 L1 = new Label("Digite um valor"); 
 L2 = new Label("% do Valor :"); 
 T1 = new TextField(5); T2 = new TextField(); 
 P1 = new Panel(); P2 = new Panel(); 
 T2.setEditable(false);radiogroup = new CheckboxGroup(); 
 radio1 = new Checkbox("10% do valor",radiogroup,false); 
 radio2 = new Checkbox("20% do valor",radiogroup,false); 
 radio3 = new Checkbox("30% do valor",radiogroup,false); 
 radio1.addItemListener(this); 
 radio2.addItemListener(this); 
 radio3.addItemListener(this); 
 P1.setLayout(new FlowLayout(FlowLayout.CENTER)); 
 P1.setBackground(new Color(200,200,200)); 
 P2.setLayout(new GridLayout(2,3,5,10)); 
 P2.setBackground(new Color(190,190,190)); 
 P1.add(L1); P1.add(T1); 
 P2.add(radio1); P2.add(radio2); P2.add(radio3); 
 P2.add(L2); P2.add(T2); 
 add(P1); add(P2); 
 } 
 
 public void itemStateChanged(ItemEvent e) 
 { 
 if (T1.getText().length()==0) return; 
 try 
 { 
 N1 = Float.valueOf(T1.getText()).floatValue(); 
 if (radio1.getState()) 
 result = (N1 * 10)/100; 
 if (radio2.getState()) 
 result = (N1 * 20)/100; 
 if(radio3.getState()) 
 result = (N1 * 30)/100; 
 } 
 catch(NumberFormatException erro) 
 { 
 T2.setText("Erro"); return; 
 } 
 T2.setText(""+result); 
 } 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso de Botões de Rádio<BR><BR> 
<applet code="ex06.class" width=400 height=120> 
</applet> 
</html> 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 11 
Exemplo 6 –Uso de Botões de Rádio 
 
 
 
 
 
 
 
 
 
 
 
Figura 1.7 – A classe ex06 sendo executada 
 
1.8. Uso de Listas Tipo Combo 
O exemplo seguinte mostra como utilizar as Listas Tipo Combo 
(ComboBox), onde será mostrado como adicionar, remover, selecionar e 
mostrar a quantidade de itens 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex07 extends Applet implements ActionListener 
{ 
 Label l1; 
 TextField t1,t2,t3; 
 Choice combo; 
 Button b1,b2,b3,b4,b5,b6,b7,b8; 
 
 public void init() 
 { 
 setBackground(new Color(0,128,128)); 
 l1 = new Label("Conteudo"); 
 l1.setBackground(SystemColor.control); 
 l1.setFont(new Font("Symbol", Font.BOLD, 25)); 
 b1 = new Button("Mostra Texto"); b1.addActionListener(this); 
 b2 = new Button("Mostra Indice"); b2.addActionListener(this); 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 12 
 b3 = new Button("Adiciona Item"); b3.addActionListener(this); 
 b4 = new Button("Remove Item"); b4.addActionListener(this); 
 b5 = new Button("Remove Todos"); b5.addActionListener(this); 
 b6 = new Button("Seleciona Indice"); b6.addActionListener(this); 
 b7 = new Button("Quant. Itens"); b7.addActionListener(this); 
 t1 = new TextField(); t2 = new TextField(); t3 = new TextField(); 
 combo = new Choice(); 
 combo.add("Branco"); 
 combo.add("Vermelho"); 
 combo.add("Azul"); 
 combo.add("Verde"); 
// combo.addItemListener(this); 
 setLayout (new GridLayout(6,2)); 
 add(l1);add(combo); 
 add(b1);add(b2); 
 add(b3);add(t1); 
 add(b4);add(b5); 
 add(b6);add(t2); 
 add(b7);add(t3); 
 } 
 
 
public void actionPerformed(ActionEvent e) 
 { 
 if (e.getSource()==b1) 
 l1.setText("Texto: "+combo.getSelectedItem()); 
 if (e.getSource()==b2) 
 l1.setText("Indice: "+combo.getSelectedIndex()); 
 if (e.getSource()==b3) 
 if (t1.getText().length()!=0) 
 { 
 combo.add(t1.getText()); 
 t1.setText(""); 
 } 
 if (e.getSource()==b4) 
 combo.remove(combo.getSelectedIndex()); 
 if (e.getSource()==b5) 
 combo.removeAll(); 
 if (e.getSource()==b6) 
 combo.select(Integer.parseInt(t2.getText())); 
 if (e.getSource()==b7) 
 t3.setText(""+combo.getItemCount()); 
 } 
/* 
Esse método é executado toda vez que a opção do combo é alterada 
Exige que seja utilizado implements ItemListener no topo da classe 
 
public void itemStateChanged(ItemEvent e) 
 { 
 
 } 
 */ 
} 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 13 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso de Listas tipo Combo<BR><BR> 
<applet code="ex07.class" width=400 height=180> 
</applet> 
</html> 
Exemplo 7 – Uso de Listas Tipo Combo 
 
Figura 1.8 – A classe ex07 sendo executada 
 
1.9. Uso de Listas Tipo ListBox 
O exemplo seguinte mostra como utilizar as Listas do Tipo ListBox 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex08 extends Applet implements ActionListener, ItemListener 
 // Manipulador de eventos 
{ 
 Label l1; 
 TextField t1; 
 List lista; 
 Button bclear, bquant; 
 
 
 public void init() 
 { 
 setBackground(new Color(0,128,128)); 
 t1 = new TextField(20); 
 t1.addActionListener(this); 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 14 
 l1 = new Label("Sem selecao"); 
 l1.setBackground(SystemColor.control); 
 bclear = new Button("Limpa"); 
 bclear.addActionListener(this); 
 bquant = new Button("Itens "); 
 bquant.addActionListener(this); 
 lista = new List(6); 
 lista.addActionListener(this); 
 lista.addItemListener(this); 
 add(l1, BorderLayout.NORTH); //topo do frame 
 add(lista, BorderLayout.CENTER); //centro do frame 
 add(t1, BorderLayout.SOUTH); //botton do frame 
 add(bclear, BorderLayout.EAST); //direita do frame 
 add(bquant, BorderLayout.WEST); //esquerda do frame 
 } 
 
public void actionPerformed(ActionEvent e) 
 { 
 if (e.getSource()==t1) 
 { 
 lista.add(t1.getText()); //adiciona itens a lista 
 t1.setText(""); 
 } 
 else 
 if (e.getSource()==lista) //ativa quando duplo click 
 { 
 t1.setText("Removido :"+lista.getSelectedItem()); //Item-retorna o texto 
 lista.remove(lista.getSelectedIndex()); //Index-retorna o indice selecionado 
 l1.setText("Sem selecao"); //o primeiro ‚ o incice 0 
 } 
 else 
 if (e.getSource()==bclear) 
 { 
 l1.setText("Sem selecao"); 
 t1.setText(""); 
 lista.removeAll(); 
 } 
 else 
 if (e.getSource()==bquant) 
 { 
 t1.setText("Quantidade: "+lista.getItemCount()); 
 } 
 
 
 } 
 
public void itemStateChanged(ItemEvent e) 
 { 
 if (e.getSource()==lista) 
 { 
 if(lista.getSelectedIndex()>-1) 
 l1.setText(""+lista.getSelectedItem()); 
 else 
 l1.setText("Sem selecao"); 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 15 
 } 
 } 
 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso de Listas tipo ListBox<BR><BR> 
<applet code="ex08.class" width=150height=180> 
</applet> 
</html> 
Exemplo 8 – Uso de Listas Tipo ListBox 
 
Figura 1.9 – A classe ex08 sendo executada 
 
1.10. Uso da Barra de Rolagem 
O exemplo seguinte mostra como utilizar uma Barra de Rolagem. Nesse 
exemplo, na medida em que o usuário movimenta a barra, seu valor 
correspondente é inserido no campo texto. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex09 extends Applet 
{ 
 Scrollbar sb; 
 TextField t1; 
 
 public void init() 
 { 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 16 
 sb = new Scrollbar(Scrollbar.HORIZONTAL,0,5,-100,105); 
 t1 = new TextField(5); 
 // initial value is 0 
 // 5 width of slider 
 // range -100 to 100 
 add(sb);add(t1); 
 } 
 
public boolean handleEvent (Event e) 
 { 
 if (e.target instanceof Scrollbar) 
 { 
 t1.setText(""+sb.getValue()); 
 return(true); 
 } 
 return(false); 
 } 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso da barra de rolagem<BR><BR> 
<applet code="ex09.class" width=340 height=50> 
</applet> 
</html> 
Exemplo 9 – Uso da Barra de Rolagem 
 
Figura 1.10 – A classe ex09 sendo executada 
 
1.11. Uso do Text Area 
O exemplo seguinte utiliza um TextArea onde são demonstrados os 
principais procedimentos necessários a manipulação desse componente, tais 
como: a inserção de texto, a leitura linha a linha de seu conteúdo, a cópia do 
texto selecionado, etc. 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 17 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex10 extends Applet implements ActionListener 
{ 
 TextArea ta1,ta2; 
 TextField t1; 
 Button b1,b2; 
 
 public void init() 
 { 
 t1 = new TextField(30); 
 t1.addActionListener(this); 
 b1 = new Button("Mostra Linhas"); 
 b1.addActionListener(this); 
 b2 = new Button("Copia Selecao"); 
 b2.addActionListener(this); 
 ta1 = new TextArea("Editor de texto:\n",5,40); 
 ta2 = new TextArea(5,40); 
 add(ta1);add(t1);add(b1);add(b2);add(ta2); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 if (e.getSource()==t1) 
 { 
// para inserir no final do texto: 
// ta1.append(t1.getText()); 
 ta1.setText(ta1.getText()+t1.getText()+"\n"); 
 t1.setText(""); 
 return; 
 } 
 
 if (e.getSource()==b1) 
 { 
 String s = ta1.getText(); 
 // Para descobrir quando muda de linha deve ser usado 
 // if (s.charAt(i)=='\n') 
 
 for (int i=0;i<=s.length()-1;i++) 
 System.out.print(s.charAt(i)); 
 } 
 if (e.getSource()==b2) 
 ta2.setText(ta1.getSelectedText()); 
 
 } 
} 
 
 
/* 
Sinais de Escape: 
\b retrocesso 
\n novalinha 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 18 
\t tabulação 
\r retorno do carro 
\f avanço do formulário 
\\ barra invertida 
\' apóstrofo 
\" aspas 
*/ 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uso do TextArea<BR><BR> 
<applet code="ex10.class" width=280 height=260> 
</applet> 
</html> 
Exemplo 10 – Uso do TextArea 
 
 
Figura 1.11 – A classe ex10 sendo executada 
 
 
1.12. Geração de Menus 
 
A maneira mais simples de utilizar um menu é através da construção de 
aplicações. Para que um menu seja executado por uma Applet é necessário utilizar-se 
as classes do pacote swing (Java 2). 
 
A seguir serão demonstrados diversos exemplos usando menus, em aplicações e 
em Applets. O primeiro exemplo mostra um simples menu sendo inserido em uma 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 19 
aplicação. Através desse exemplo é possível verificar como criar um menu e abrir uma 
nova janela (Frame) a partir dele. É demonstrado também como realizar o fechamento 
dessa nova janela criada, através da inserção de duas classes em um só arquivo. Um 
arquivo em java pode conter diversas classes, entretanto apenas uma pode ser 
declarada como public. 
 
import java.awt.*; 
import java.awt.event.*; 
 
public class Menudemo extends Frame implements ActionListener 
 { 
 MenuBar m1; 
 Menu MenuArquivo; 
 MenuItem miNovo,miAbrir,miSair; 
 
 public static void main(String args[]) 
 { 
 Menudemo Janela=new Menudemo(); 
 Janela.addWindowListener (new fechajanela()); 
 Janela.show(); 
 } 
 
 public Menudemo() 
 { 
 setTitle("Uso de Menus"); 
 setSize(250,150); 
 setLocation(50,50); 
 setBackground(new Color(0,128,128)); 
 m1 = new MenuBar(); 
 MenuArquivo = new Menu("Arquivo"); 
 miNovo = new MenuItem ("Novo"); 
 miNovo.addActionListener(this); 
 miAbrir = new MenuItem ("Abrir"); 
 miAbrir.addActionListener(this); 
 miSair = new MenuItem ("Sair"); 
 miSair.addActionListener(this); 
 MenuArquivo.add(miNovo); 
 MenuArquivo.add(miAbrir); 
 MenuArquivo.add(miSair); 
 m1.add(MenuArquivo); 
 setMenuBar(m1); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 if (e.getSource()==miNovo) 
 { 
 System.out.println("Novo"); 
 FechaFrame f = new FechaFrame(); 
 f.setSize(200,100); 
 f.setBackground(Color.blue); 
 f.show(); 
 } 
 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 20 
 if (e.getSource()==miAbrir) 
 System.out.println("Abrir"); 
 
 if (e.getSource()==miSair) 
 { 
 System.out.println("Sair"); 
 System.exit(0); 
 } 
 } 
 
class FechaFrame extends Frame 
{ 
 public boolean handleEvent (Event evt) 
 { 
 if (evt.id == Event.WINDOW_DESTROY) 
 dispose(); 
 
 return super.handleEvent(evt); 
 } 
} 
} 
Exemplo 11 – Uso de Menus 
 
 
Figura 1.12 – A classe ex11 sendo executada 
 
O próximo exemplo demonstra uma aplicação que utiliza submenus e teclas de 
atalho. Esse exemplo será usado pelo próximo exemplo, uma applet que chama essa 
aplicação. Um ponto importante nesse exemplo é código do botão sair: 
 try 
 { System.exit(0); } 
 catch(Exception ex) 
 { dispose(); } 
Esse trecho tenta encerrar a aplicação, caso ocorra um erro, no caso dela estar 
sendo executada por uma Applet, é chamado o método dispose(). 
 
import java.awt.*; 
import java.awt.event.*; 
 
public class ex12 extends Frame implements ActionListener 
 
 { 
 MenuBar m1; 
 Menu MenuArquivo, MenuSave; 
 MenuItem miNovo,miAbrir,miSair,miSalvar,miSalvarC,miSalvarT; 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 21 
 
 public static void main(String args[]) 
 { 
 ex12 Janela=new ex12(); 
 Janela.addWindowListener (new fechajanela()); 
 Janela.show(); 
 } 
 
 public ex12() 
 { 
 setTitle("Uso de Menus"); 
 setSize(250,100); 
 setLocation(50,50); 
 setBackground(new Color(0,128,128)); 
 
 m1 = new MenuBar(); 
 MenuArquivo = new Menu("Arquivo"); 
// MenuArquivo.setMnemonic( 'A' ); SOMENTE NO SWINGMenuArquivo.addActionListener(this); 
 MenuSave = new Menu("Save"); 
 miNovo = new MenuItem ("Novo"); 
 miNovo.addActionListener(this); 
 miNovo.setShortcut(new MenuShortcut(KeyEvent.VK_N)); 
 miAbrir = new MenuItem ("Abrir"); 
 miAbrir.addActionListener(this); 
 miAbrir.setShortcut(new MenuShortcut(KeyEvent.VK_A)); 
 miSair = new MenuItem ("Sair"); 
 miSair.addActionListener(this); 
 miSair.setShortcut(new MenuShortcut(KeyEvent.VK_X)); 
 miSalvar = new MenuItem ("Salvar"); 
 miSalvar.addActionListener(this); 
 miSalvar.setShortcut(new MenuShortcut(KeyEvent.VK_S)); 
 miSalvarC = new MenuItem ("Salvar Como"); 
 miSalvarC.setShortcut(new MenuShortcut(KeyEvent.VK_C)); 
 miSalvarC.addActionListener(this); 
 miSalvarT = new MenuItem ("Salvar Tudo"); 
 miSalvarT.addActionListener(this); 
 miSalvarT.setShortcut(new MenuShortcut(KeyEvent.VK_T)); 
 MenuSave.add(miSalvar); 
 MenuSave.add(miSalvarC); 
 MenuSave.add(miSalvarT); 
 MenuArquivo.add(miNovo); 
 MenuArquivo.add(miAbrir); 
 MenuArquivo.add(MenuSave); 
 MenuArquivo.add(miSair); 
 m1.add(MenuArquivo); 
 setMenuBar(m1); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 if (e.getSource()==miNovo) 
 { 
 System.out.println("Novo"); 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 22 
 FechaFrame f = new FechaFrame(); 
 f.setSize(250,100); 
 f.setLocation(70,70); 
 f.setTitle("Nova Janela"); 
 f.setBackground(Color.gray); 
 f.add(new Label("Janela 2",Label.CENTER)); 
 f.show(); 
 } 
 if (e.getSource()==miAbrir) 
 System.out.println("Abrir"); 
 if (e.getSource()==miSalvar) 
 System.out.println("Salvar"); 
 if (e.getSource()==miSalvarC) 
 System.out.println("Salvar Como"); 
 if (e.getSource()==miSalvarT) 
 System.out.println("Salvar Tudo"); 
 if (e.getSource()==miSair) 
 { 
 System.out.println("Sair"); 
 try 
 { System.exit(0); } 
 catch(Exception ex) 
 { dispose(); } 
 } 
 } 
 
class FechaFrame extends Frame 
{ 
 public boolean handleEvent (Event evt) 
 { 
 if (evt.id == Event.WINDOW_DESTROY) 
 dispose(); 
 return super.handleEvent(evt); 
 } 
} 
} 
Exemplo 12 – Uso de com teclas de atalho 
 
 
Figura 1.13 – A classe ex12 sendo executada 
 
O próximo exemplo demonstra uma applet que no momento em que é 
executada chama a aplicação do exemplo anterior. Essa applet pode ser carregada 
através do browser, conforme demonstra a figura seguinte. 
 
import java.awt.*; 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 23 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex13 extends Applet 
 { 
 ex12 d; 
 public void init() 
 { 
 d = new ex12(); 
 d.setSize(300,200); 
 d.show(); 
 } 
 } 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uma applet que chama uma aplicação<BR><BR> 
<applet code="ex13.class" width=280 height=260> 
</applet> 
</html> 
Exemplo 13 – Carregamento de uma aplicação através de uma Applet 
 
 
 
 
 
Figura 1.14 – A classe ex13 sendo executada 
 
O próximo exemplo demonstra uma applet criada com as classes do pacote 
Swing executada através do appletviewer. Para carregar a applet pelo browser, o 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 24 
arquivo html qie carrega a applet deve ser convertido com a ferramenta HTML 
Converter (Anexo A). 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
import javax.swing.*; 
 
public class ex14 extends JApplet implements ActionListener 
 { 
 JMenuBar m1; 
 JMenu MenuArquivo; 
 JMenuItem miNovo,miAbrir; 
 
 public void init() 
 { 
 setBackground(new Color(0,128,128)); 
 m1 = new JMenuBar(); 
 MenuArquivo = new JMenu("Arquivo"); 
 MenuArquivo.setMnemonic( 'A' ); 
 MenuArquivo.addActionListener(this); 
 miNovo = new JMenuItem ("Novo"); 
 miNovo.addActionListener(this); 
 miAbrir = new JMenuItem ("Abrir"); 
 miAbrir.addActionListener(this); 
 MenuArquivo.add(miNovo); 
 MenuArquivo.add(miAbrir); 
 m1.add(MenuArquivo); 
 setJMenuBar(m1); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 if (e.getSource()==miNovo) 
 { 
 System.out.println("Novo"); 
 FechaFrame f = new FechaFrame(); 
 f.setSize(250,100); 
 f.setLocation(70,70); 
 f.setTitle("Nova Janela"); 
 f.setBackground(Color.gray); 
 f.add(new Label("Janela 2",Label.CENTER)); 
 f.show(); 
 } 
 if (e.getSource()==miAbrir) 
 System.out.println("Abrir"); 
 } 
class FechaFrame extends Frame 
{ 
 
 public boolean handleEvent (Event evt) 
 { 
 if (evt.id == Event.WINDOW_DESTROY) 
 dispose(); 
Curso de Java - Professor Sérgio Furgeri 
Manipulação do pacote AWT através do uso de Applets - Página 25 
 
 return super.handleEvent(evt); 
 } 
} 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uma applet usando as classes do pacote Swing<BR><BR> 
<applet code="ex14.class" width=280 height=260> 
</applet> 
</html> 
Exemplo 14 – Uso de menus em Applets com as classes Swing 
 
 
Figura 1.15 – A classe ex14 sendo executada no appletviewer 
 
 
 
 
 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 26 
 
Tópico 2: 
Controle de Eventos e Manipulação de Arquivo Texto 
 
Essa aula aborda os principais eventos controlados pela linguagem Java, 
gerados a partir de frames. Um exemplo típico desses procedimentos se refere 
ao controle do foco sobre um objeto. Quando o usuário pressionar a tecla Enter 
o controle de foco pode ser passado a outro objeto. Essa aula também aborda a 
identificação do teclado e a manipulação de arquivos texto através de 
aplicações, demonstrando o que é necessário para realizar a leitura e gravação 
de arquivos. Serão estudadas as técnicas mais utilizadas que envolvem o 
tratamento desses itens. 
 
2.1. Controle de eventos 
 
Em uma aplicação é importante prever certas condições como: não 
permitir a digitação de texto em campos numéricos, possibilitar a mudança de 
foco quando a tecla Enter é pressionada. Existem várias características cuja 
importância depende do tipo de aplicação. 
Cada componente do pacote awt gera uma certa quantidade de eventos 
que podem ser tratados na aplicação. Para manipular os eventos de um 
componente, três aspectos são essenciais e devem ser utilizados em uma 
aplicação: 
• A interface ou adaptador utilizada (Ex. ActionListener) 
• O método (ou métodos) para controlar o evento (Ex. actionPerformed) 
• O tipo de evento em si (Ex. ActionEvent) 
 
O exemplo seguinte demonstra a utilização de vários eventos que são 
geradosatravés do mouse e do teclado. Para o mouse são demonstrados 4 
eventos diferentes: quando o mouse entra e sai da área do botão, quando o 
mouse é pressionado e solto do botão. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex15 extends Applet implements MouseListener, KeyListener, TextListener 
{ 
 Button B1; Label L1; TextField T1,T2; 
 static int E=2,T=2; 
 
 public void init() 
 { 
 setBackground(new Color(150,150,150)); 
 setLayout(new GridLayout(4,1)); 
 L1 = new Label(""); B1 = new Button ("Click"); 
 T1 = new TextField(); T2 = new TextField(); 
 B1.addMouseListener(this); T1.addKeyListener(this); 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 27 
 T2.addTextListener(this); T2.addKeyListener(this); 
 add(B1); add(L1); add(T1); add(T2); 
 } 
 
 public void mousePressed(MouseEvent e) 
 { L1.setText("O botão do Mouse foi pressionado"); } 
 
 public void mouseClicked(MouseEvent e) 
 { L1.setText("O botão do Mouse foi solto");} 
 
 public void mouseEntered(MouseEvent e) 
 { L1.setText("O ponteiro do Mouse entrou na área do botão");} 
 
 public void mouseExited(MouseEvent e) 
 { L1.setText("O ponteiro do Mouse saiu da área do botão");} 
 
 public void mouseReleased(MouseEvent e) 
 { L1.setText("O botão do Mouse foi solto fora da área do botão");} 
 
 // método acionado quando uma tecla é pressionada 
 public void keyPressed(KeyEvent e) 
 { 
 if (e.getSource()==T1) 
 { 
 if(e.getKeyCode()==10 || e.getKeyCode()==9) 
 { e.setKeyCode(9); return; } 
 if(e.getKeyCode()<96 || e.getKeyCode()>105) 
 { e.setKeyCode(8); return; } 
 } 
 if (e.getSource()==T2) 
 { 
 if(e.getKeyCode()==38) { setLocation(E,T--); } 
 if(e.getKeyCode()==40) { setLocation(E,T++); } 
 if(e.getKeyCode()==37) { setLocation(E--,T); } 
 if(e.getKeyCode()==39) { setLocation(E++,T); } 
 } 
 } 
 
 // método acionado no momento em que a tecla é solta 
 public void keyReleased(KeyEvent e) { } 
 
 // método acionado no momento em que a tecla é pressionada 
 public void keyTyped(KeyEvent e) {} 
 
 // método acionado quando o texto do campo é mudado 
 public void textValueChanged(TextEvent e) 
 { 
 int n; 
 try 
 { 
 n = Integer.parseInt(T2.getText()); 
 switch(n) 
 { 
 case 0: L1.setText("Zero");break; 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 28 
 case 1: L1.setText("Um");break; 
 case 2: L1.setText("Dois");break; 
 default: L1.setText("Não reconhecido");break; 
 } 
 } 
 catch(NumberFormatException erro) 
 { return; } 
 } 
 } 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uma applet mostrando a manipulação de eventos<BR><BR> 
<applet code="ex15.class" width=280 height=100> 
</applet> 
</html> 
Exemplo 15 – Controle de eventos 
 
 
Figura 2.1 – A classe ex15 sendo executada 
 
Os aspectos mais importantes desse exemplo são: 
• MouseListener, KeyListener e TextListener são as interfaces utilizadas 
para a manipulação dos eventos do mouse, do teclado e da mudança de 
conteúdo da caixa de texto. Cada uma dessas interfaces exige a declaração 
de métodos para realizar a manipulação dos eventos. A tabela a seguir 
demonstra as interfaces utilizadas e os métodos exigidos. 
 
Interface Métodos 
MouseListener mousePressed, mouseClicked, mouseEntered, 
mouseExited e mouseReleased 
KeyListener keyPressed, keyReleased, keyTyped 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 29 
TextListener TextValueChanged 
 
• Linha static int L1=2,C=2 ?declaração das variáveis globais L e C para 
controle do posicionamento da janela em relação a tela. 
• Linhas addMouseListener, addKeyListener, addTextListener e 
addKeyListener ? adiciona os eventos relativos a cada objeto. 
• Os métodos relativos a interface MouseListener alteram o conteúdo do 
Label L1 na medida em que os eventos do mouse sobre o botão são 
gerados. 
• Os métodos relativos a interface KeyListener são invocados toda a vez que 
uma tecla é pressionada. 
• O método textValueChanged é invocado somente quando o conteúdo da 
caixa de texto (no caso T2) é alterado. 
• Método keyPressed ? esse método é acionado quando uma tecla é 
pressionada sobre as caixas de texto T1 e T2. Por isso, toda vez que o 
método é invocado torna-se necessário verificar qual objeto gerou o evento. 
Isso é verificado através das linhas if(e.getSource). 
Caso o objeto que gerou o evento seja o T1, ocorrerá o seguinte: 
• Se for pressionado a tecla Enter ou a tecla Tab, será gerado o código da 
tecla Tab. Desta forma tanto faz ao usuário pressionar Enter (if 
(e.getKeyCode==10)) ou Tab (if(e.getKeyCode==9)) que o próximo objeto 
(no caso o T2) receberá o foco. 
• Se for pressionado uma letra ou qualquer outra tecla diferente do teclado 
numérico (if(e.getKeyCode() < 96 || e.getKeyCode() > 105)) será gerado o 
código da tecla BackSpace (e.setKeyCode(8)) para cancelar a tecla 
pressionada. Dessa forma a caixa de texto T2 aceitará apenas a digitação de 
caracteres numéricos. Nesse exemplo as teclas numéricas localizadas abaixo 
das teclas de função não serão aceitas por possuirem códigos diferentes. 
Caso o objeto que gerou o evento seja o T2, ocorrerá o seguinte: 
• Se for pressinada a tecla ? (if(e.getKeyCode==38)) a distância da janela 
em relação ao topo da tela irá diminuir e a janela se movimentará para 
cima. Essa movimentação também é realizada pelo acionamento das teclas 
?(40), ? (37) e ? (39), cada uma movimentando a janela no sentido 
correspondente. 
• O método textValueChanged é invocado quando o conteúdo do texto 
presente em T2 é alterado. Se o conteúdo de T2 estiver com “0”, “1” ou “2”, 
o valor correspondente em extenso será colocado no Label L1. Caso um 
outro valor for fornecido será executada a instrução default do switch. 
A tabela a seguir demonstra um resumo das interfaces, métodos e 
eventos usados nesse capítulo. A lista completa pode ser encontrada no site da 
Sun (http://java.sun.com). 
 
Interface Métodos obrigatórios Evento 
ActionListener actionPerformed ActionEvent 
ItemListener itemStateChanged ItemEvent 
KeyListener keyPressed KeyEvent 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 30 
keyRelease 
keyTyped 
MouseListener mousePressed 
mouseClicked 
mouseEntered 
mouseExited 
mouseRelease 
MouseEvent 
 
 
2.2. Manipulação de arquivos Texto através de 
aplicações 
 
Será demonstrado inicialmente como realizar a manipulação de arquivo 
texto através de aplicações. Uma vez consolidados esses conceitos, será 
demonstrado como criar applets que manipulam esses arquivos através do 
browser. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
 
class ex16 extends Frame implements ActionListener 
 { 
 Label l1; 
 Button b1,b2,b3; 
 TextArea t1; 
 
public static void main(String[] args) //Fechar Janela 
 { 
 ex16 Janela = new ex16(); 
 WindowListener l = new WindowAdapter() 
 { 
 public void windowClosing(WindowEvent e) 
 { 
 System.exit(0); 
 } 
 }; 
 Janela.addWindowListener(l); 
 Janela.setVisible(true); 
 } 
 
 ex16() 
 { 
 setTitle("Uso de arquivo Texto"); 
 setSize (500,280);setBackground (new Color (150,150,0)); 
 setLayout (new FlowLayout()); 
 l1 = new Label("Texto a ser gravado:"); 
 b1 = new Button("Gravar"); 
 b2 = new Button("Ler"); 
 b3 = new Button("Limpar"); 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 31 
 b1.addActionListener(this); b2.addActionListener(this); b3.addActionListener(this); 
 t1 = new TextArea(); 
 add(l1); add(t1); add(b1); add(b2); add(b3); 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 // Sring nome_do_arquivo=System.getProperty("user.home")+File.separatorChar +"arq.txt"; 
 String nome_do_arquivo = "c:/arq.txt"; 
 if (e.getSource() == b3) //limpar 
 t1.setText(""); 
 if (e.getSource() == b1) //gravar 
 { 
 try 
 { 
 String S = t1.getText(); 
 byte b[] = S.getBytes(); 
 FileOutputStream out = new FileOutputStream(nome_do_arquivo); 
 out.write(b); 
 out.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 System.out.println("Erro ao gravar no arquivo"); 
 } 
 } 
 
 if (e.getSource() == b2) //ler 
 { 
 try 
 { 
 FileInputStream in = new FileInputStream(nome_do_arquivo); 
 byte bt[] = new byte[10024]; //(int)entrada.length()); 
 in.read(bt); 
 String S = new String(bt); 
 t1.setText(S); 
 in.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 System.out.println("Erro ao ler o arquivo"); 
 } 
 } 
 
 } 
} 
Exemplo 16 – Abertura e gravação de arquivo texto 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 32 
 
Figura 2.2 – A classe ex16 sendo executada 
 
O exemplo seguinte é uma versão melhorada do exemplo anterior, onde 
é possível escolher o arquivo que será aberto através da digitação de seu 
caminho e nome em uma caixa de texto. O exemplo também adiciona uma 
caixa de texto que demonstra possíveis erros gerados ao abrir ou gravar o 
arquivo. 
 
 
import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
 
class ex17 extends Frame implements ActionListener 
 { 
 Label l1,l2,l3; 
 Button b1,b2,b3; 
 TextArea ta1; 
 TextField t1,t2; 
 Panel p1; 
 
 public static void main(String[] args) 
 { 
 ex17 Janela = new ex17(); 
 WindowListener l = new WindowAdapter() 
 { 
 public void windowClosing(WindowEvent e) 
 { 
 System.exit(0); 
 } 
 }; 
 Janela.addWindowListener(l); 
 Janela.setVisible(true); 
 } 
 
 ex17() 
 { 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 33 
 setTitle("Uso de arquivo Texto"); 
 setSize (500,330); 
 setResizable(false); 
 setBackground (new Color (150,150,0)); 
 setLayout (new FlowLayout()); 
 l1 = new Label("Digite Caminho/nome do arquivo:"); 
 l2 = new Label("Texto a ser gravado:"); 
 l3 = new Label("Status:"); 
 b1 = new Button("Gravar"); 
 b2 = new Button("Ler"); 
 b3 = new Button("Limpar"); 
 b1.addActionListener(this); 
 b2.addActionListener(this); 
 b3.addActionListener(this); 
 p1 = new Panel(); 
 t1 = new TextField(25); 
 t1.setForeground(Color.blue); 
 t2 = new TextField(40); 
 t2.setForeground(Color.red); 
 t2.setEditable(false); 
 ta1 = new TextArea(); 
 p1.setLayout (new FlowLayout()); 
 p1.add(l3); p1.add(t2); 
 add(l1); add(t1); add(l2); add(ta1); 
 add(b1); add(b2); add(b3); add(p1); 
 
 } 
 
 public void actionPerformed(ActionEvent e) 
 { 
 String nome_do_arquivo = t1.getText(); 
 if (e.getSource() == b3) //limpar 
 { ta1.setText(""); t1.setText(""); t2.setText(""); } 
 if (e.getSource() == b1) //gravar 
 { 
 try 
 { 
 String S = ta1.getText(); 
 byte b[] = S.getBytes(); 
 FileOutputStream out = new FileOutputStream(nome_do_arquivo); 
 out.write(b); 
 out.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 t2.setText("Erro ao gravar no arquivo"); 
 } 
 } 
 
 if (e.getSource() == b2) //ler 
 { 
 try 
 { 
 FileInputStream in = new FileInputStream(nome_do_arquivo); 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 34 
 byte bt[] = new byte[10024]; 
 in.read(bt); 
 String S = new String(bt); 
 ta1.setText(S); 
 in.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 t2.setText("Erro ao ler o arquivo"); 
 } 
 } 
 
 } 
} 
Exemplo 17 – Abertura e gravação de arquivo texto 
 
 
Figura 2.3 – A classe ex17 sendo executada 
 
O exemplo seguinte é uma versão melhorada do exemplo anterior, onde 
é possível escolher o arquivo que será aberto através de uma caixa de diálogo. 
O mesmo ocorre no momento de Salvar o arquivo. Isso é possível através da 
utilização da classe FileDialog da linguagem Java. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
 
class ex18 extends Frame implements ActionListener 
 { 
 Label l2,l3; 
 Button b1,b2,b3; 
 TextArea ta1; 
 TextField t1,t2; 
 Panel p1; 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 35 
 FileDialog Fabrir,Fsalvar; 
 
 public static void main(String[] args) 
 { 
 ex18 Janela = new ex18(); 
 WindowListener l = new WindowAdapter() 
 { 
 public void windowClosing(WindowEvent e) 
 { 
 System.exit(0); 
 } 
 }; 
 Janela.addWindowListener(l); 
 Janela.setVisible(true); 
 } 
 
 ex18() 
 { 
 setTitle("Uso de arquivo Texto com caixa de diálogo"); 
 setSize (500,300); 
 setResizable(false); 
 setBackground (new Color (150,150,0)); 
 setLayout (new FlowLayout()); 
 l2 = new Label("Texto a ser gravado:"); 
 l3 = new Label("Status:"); 
 b1 = new Button("Salvar"); 
 b2 = new Button(" Abrir "); 
 b3 = new Button("Limpar"); 
 b1.addActionListener(this); 
 b2.addActionListener(this); 
 b3.addActionListener(this); 
 p1 = new Panel(); 
 t1 = new TextField(25); 
 t1.setForeground(Color.blue); 
 t2 = new TextField(40); 
 t2.setForeground(Color.red); 
 t2.setEditable(false); 
 ta1 = new TextArea(); 
 p1.setLayout (new FlowLayout()); 
 Fabrir = new FileDialog(this,"Abrir arquivo",FileDialog.LOAD); 
 Fsalvar = new FileDialog(this,"Salvar arquivo",FileDialog.SAVE); 
 p1.add(l3); p1.add(t2); 
 add(l2); add(ta1); 
 add(b2); add(b1); add(b3); add(p1); 
 } 
 public void actionPerformed(ActionEvent e) 
 { 
 String nome_do_arquivo = t1.getText(); 
 if (e.getSource() == b3) //limpar 
 { ta1.setText(""); t1.setText(""); t2.setText(""); } 
 if (e.getSource() == b1) //gravar 
 { 
 try 
 { 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 36 
 Fsalvar.show(); 
 if (Fsalvar.getFile()==null) return; 
 nome_do_arquivo = Fsalvar.getDirectory()+Fsalvar.getFile(); 
 String S = ta1.getText(); 
 byte b[] = S.getBytes();FileOutputStream out = new FileOutputStream(nome_do_arquivo); 
 out.write(b); 
 out.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 t2.setText("Erro ao gravar no arquivo"); 
 } 
 } 
 if (e.getSource() == b2) //ler 
 { 
 try 
 { 
 Fabrir.show(); 
 if (Fabrir.getFile()==null) return; 
 nome_do_arquivo = Fabrir.getDirectory()+Fabrir.getFile(); 
 FileInputStream in = new FileInputStream(nome_do_arquivo); 
 byte bt[] = new byte[10024]; 
 in.read(bt); 
 String S = new String(bt); 
 ta1.setText(S); 
 in.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 t2.setText("Erro ao ler o arquivo"); 
 } 
 } 
 } 
} 
Exemplo 18 – Abertura e gravação de arquivo texto com FileDialog 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 37 
 
Figura 2.4 – A classe ex18 sendo executada 
 
2.3. Manipulação de arquivos Texto através de Applets 
Para a manipulação de arquivos texto através do browser algumas 
modificações e procedimentos são necessários. Em primeiro lugar, é necessário 
realizar a conversão da aplicação em Applet. Para simplificar as alterações será 
criada uma Applet sobre o exemplo ex16. A Applet com o código já convertido é 
demonstrado a seguir no exemplo ex19. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
import java.applet.Applet; 
 
public class ex19 extends Applet implements ActionListener 
 { 
 Label l1; 
 Button b1,b2,b3; 
 TextArea t1; 
 
 public void init() 
 { 
 setBackground (new Color (150,150,0)); 
 setLayout (new FlowLayout()); 
 l1 = new Label("Texto a ser gravado:"); 
 b1 = new Button("Gravar"); 
 b2 = new Button("Ler"); 
 b3 = new Button("Limpar"); 
 b1.addActionListener(this); 
 b2.addActionListener(this); 
 b3.addActionListener(this); 
 t1 = new TextArea(); 
 add(l1); add(t1); add(b1); add(b2); add(b3); 
 } 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 38 
 public void actionPerformed(ActionEvent e) 
 { 
 String nome_do_arquivo = "c:/arq.txt"; 
 if (e.getSource() == b3) //limpar 
 t1.setText(""); 
 if (e.getSource() == b1) //gravar 
 { 
 try 
 { 
 String S = t1.getText(); 
 byte b[] = S.getBytes(); 
 FileOutputStream out = new FileOutputStream(nome_do_arquivo); 
 out.write(b); 
 out.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 System.out.println("Erro ao gravar no arquivo"); 
 } 
 } 
 if (e.getSource() == b2) //ler 
 { 
 try 
 { 
 FileInputStream in = new FileInputStream(nome_do_arquivo); 
 byte bt[] = new byte[10024]; //(int)entrada.length()); 
 in.read(bt); 
 String S = new String(bt); 
 t1.setText(S); 
 in.close(); 
 } 
 catch(java.io.IOException exc) 
 { 
 System.out.println("Erro ao ler o arquivo"); 
 } 
 } 
 } 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uma applet mostrando a manipulação de eventos<BR><BR> 
<applet code = "ex19.class" width=450 height=250> 
</applet> 
</html> 
Exemplo 19 – Manipulação de arquivo texto com uma Applet 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 39 
 
Figura 2.5 – A Applet ex19 sendo executada pelo Appletviewer 
 
Uma vez compilado o programa, deverá ser criado um arquivo de 
“política de segurança”, pois uma Applet não pode manipular um arquivo 
diretamente, antes disso é necessário existir um policy file, que será 
responsável em definir o que a Applet pode ou não fazer com um arquivo, etc. 
 
A seguir são passadas algumas informações sobre as restrições das 
Applets. 
 
2.3.1 Restrições das Applets 
 
As applets foram planejadas para serem carregadas de um site remoto e 
então serem executadas localmente. Desta forma, para evitar que applets 
criadas por pessoas sem ética danifiquem o sistema local onde estão sendo 
executadas, isto é, atuem como um vírus, acessando informações sigilosas, 
alterando ou ainda apagando dados armazenados no sistema, foram impostas 
algumas restrições a seu funcionamento. 
 
As applets são executadas pelo browser e monitoradas por um 
gerenciador de segurança (applet security manager) que lança uma 
interrupção do tipo SecurityException caso a applet viole alguma das regras 
de segurança impostas. Pelo motivo da applet ser monitorada durante sua 
execução, é comum dizer que as applets operam dentro de uma caixa de areia, 
algo que impossibilita que elas saiam de seu raio de atuação. Esse modelo é 
conhecido por the sandbox model. 
 
As tarefas que as applets podem realizar são: exibir imagens, executar 
sons, processar o acionamento do teclado e mouse e se comunicar com o host 
de onde foram carregadas. Por outro lado, as applets estão sujeitas as 
seguintes restrições: não podem executar programas localmente instalados, 
não podem se comunicar com outros hosts exceto de onde a applet foi 
carregada, não podem ler e escrever no sistema de arquivos local e não podem 
obter informações do sistema onde operam exceto sobre a JVM onde operam. 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 40 
 
É bastante nítido o aumento de restrições de applets executadas através 
de download quando comparadas com a execução de programas comuns 
escritos em Java. Em algumas situações tal nível de restrição se mostra 
demasiadamente severo para uma applet, assim é possível “assinar” o código, 
isto é, anexar um certificado de segurança que ateste a origem da applet 
tornando-a uma signed applet e permitindo sua execução num nível de 
restrição semelhante ao de programas comuns. 
 
Para retirar essas restrições pode ser criado um arquivo de política 
(policy file) o qual será demonstrado a seguir. 
 
2.3.2 Criação do Policy File 
 
Antes de iniciar a manipulação da PolicyTool, vamos definir um diretório 
padrão de trabalho para simplificar nossos processos. Crie um diretório 
chamado MeuApplet no drive C e copie nele os arquivos ex19.java, 
ex19.class e ex19.html. 
 
Para a criação do arquivo que controla o acesso das Applets pode ser 
usado qualquer editor de textos comum, entretanto para que o aprendizado da 
sintaxe não seja necessário, a Sun criou uma ferramenta para a criação desses 
arquivos. Trata-se da PolicyTool, executada diretamente na linha de comando 
do DOS. 
 
Ao executar a ferramenta aparecerá a tela demonstrada pela figura 2.6. 
 
 
Figura 2.6 – Tela de abertura da ferramenta Policytool 
 
Ao iniciar a ferramenta, provavelmente ela enviará uma mensagem 
alertando não ter encontrado o arquivo policy default, que normalmente fica 
armazenado na pasta do Windows. Isso não representa nenhum problema para 
nós. Para criar um novo arquivo de policy clique no botão Add Policy Entry. 
Aparecerá uma outra tela contendo os campos: 
 
CodeBase: representa o diretório onde o arquivo de policy está 
armazenado. Digite ? file:/c:/MeuApplet. 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 41 
SignedBy: representa um apontamento para um arquivo deassinatura 
que pode ser usado como chave para criptografia. Essa opção não será utilizada 
em nosso curso. 
 
Para prosseguir pressione o botão Add Permission. Aparecerá a tela 
demonstrada na figura 2.7, onde deverão ser feitas as configurações 
apontadas: 
 
Em Permission escolha: File Permission 
Em TargetName digite no campo ao lado: c:/arq.txt 
(deve ser a mesma pasta apontada no programa fonte java) 
Em Action escolha: read, write, delete, execute. 
 
 
Figura 2.7 – Configuração do arquivo de policy 
 
A seguir pressione o botão OK e na tela que surge Done. Nesse ponto o 
arquivo de policy está completo, só falta ser salvo. No menu File escolha Save 
As, localize o diretório C:\MeuApplet, coloque o nome meu_policy no nome 
do arquivo e pressione o botão Salvar. Uma mensagem apontando o sucesso 
da gravação deverá aparecer. 
 
Com isso foi criado um arquivo de policy com as seguintes informações: O 
Applet localizado no diretório C:\MeuApplet (poderia ser um site), pode 
permissão para ler, gravar, deletar e executar um arquivo chamado arq.txt 
localizado na mesma pasta. O código gerado pela policytool para nosso arquivo 
criado, é mostrado a seguir. 
 
/* AUTOMATICALLY GENERATED ON Tue Sep 25 10:56:19 BRT 2001*/ 
/* DO NOT EDIT */ 
 
grant codeBase "file:/c:/MeuApplet" { 
 permission java.io.FilePermission "c:/arq.txt", "read, write, delete, execute"; 
}; 
 
Nesse ponto já é possível executar a Applet através do appletviewer, 
digitando a seguinte linha de comando que contém um apontamento para o 
policy file criado. 
Appletviewer –J-Djava.security.policy=meu_policy ex19.html 
 
2.4. Manipulação de arquivos Texto através do Browser 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 42 
Para manipular arquivos com o browser é necessário alterar o arquivo 
que contém as propriedades de segurança do sistema. Esse arquivo encontra-
se no diretório JAVA_HOME (de acordo com o que está definido no 
autoexec.bat) e seu nome é java.security. Ele está armazenado em uma pasta 
chamada security dentro do diretório JAVA_HOME. Um endereço típico pode 
ser: C:\Arquivos de programas\JavaSoft\JRE\1.3.1\lib\security\java.security. 
 
Localize o arquivo java.security em sua máquina e o abra com o Edit do DOS. 
Encontre a linha policy.url.2=file:${user.home}/.java.policy). Depois dessa 
linha acrescente a linha policy.url.3=file:/C:/MeuApplet/meu_policy. 
Nesse ponto o sistema já está configurado corretamente para permitir que o 
browser manipule o arquivo texto, entretanto, ainda é necessário converter o 
arquivo ex19.html com a ferramenta HTMLConverter. Só assim será possível 
executar a Applet ex19.class com o browser. 
 
 
Figura 2.8 – A Applet ex19 sendo executada pelo browser 
 
 
 
 
 
 
 
 
 
Curso de Java - Professor Sérgio Furgeri 
Controle de Eventos e manipulação de Arquivo Texto - Página 43 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tópico 3: 
Passagem de Parâmetros e Aplicações Cliente Servidor 
 
Essa aula aborda os principais conceitos envolvidos pela linguagem Java 
para a passagem de dados entre aplicações Cliente Servidor. Conforme será 
demonstrado, a passagem de parâmetros pode ocorrer em diversas formas. A 
forma mais simples se refere à passagem de parâmetros através de uma 
página HTML, cujos dados são enviados para Applets. Uma Applet pode receber 
esses valores e criar uma página em HTML a partir desses dados, entretanto 
esse procedimento não é muito utilizado, uma vez que existem outras técnicas 
mais eficiêntes através do uso de Servlets. Essa comunicação bidirecional 
também é possível entre uma página HTML e uma Servlet (aplicação 
Servidora), assim como entre uma Applet e uma Servlet. Os itens seguintes 
tratarão de demostrar essas diversas variações. 
 
3.1. Passagem de parâmetros para Applets 
 
O exemplo seguinte demonstra uma Applet que recebe quatro 
parâmetros de uma página em HTML: a cor de fundo que a Applet terá ao ser 
carregada, a cor dos botões, a cor do texto do botão e a cor dos rótulos da 
janela. Conforme apresentado pelo exemplo, pode ser observado que cada 
parâmetro (param) passado deve conter um nome (name) e um valor (value). 
Para a Applet receber o parâmetro da página HTML é utilizado o método 
getParameter. 
 
import java.awt.*; 
import java.awt.event.*; 
import java.applet.Applet; 
 
public class ex20 extends Applet implements MouseListener 
 { 
 Label l1,l2,l3,l4; 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
44 
 Button b1,b2; 
 TextField t1,t2,t3,t4; 
 String p1,p2,p3,p4; 
 
 public void init() 
 { 
 p1 = getParameter("CorDeFundo"); 
 p2 = getParameter("CorDoBotao"); 
 p3 = getParameter("TextoDoBotao"); 
 p4 = getParameter("CorDoLabel"); 
 l1 = new Label("Cor de Fundo:"); 
 l2 = new Label("Cor do Botão:"); 
 l3 = new Label("Cor do Texto do Botão:"); 
 l4 = new Label("Cor dos Labels:"); 
 setBackground (new Color (150,150,0)); 
 setLayout (new GridLayout(5,2)); 
 b1 = new Button("Botão 1"); 
 b2 = new Button("Botão 2"); 
 b1.addMouseListener(this); 
 b2.addMouseListener(this); 
 t1 = new TextField(); 
 t2 = new TextField(); 
 t3 = new TextField(); 
 t4 = new TextField(); 
 t1.setText(p1); 
 t2.setText(p2); 
 t3.setText(p3); 
 t4.setText(p4); 
 setBackground(new Color(Integer.parseInt(p1,16))); 
 b1.setBackground(new Color(Integer.parseInt(p2,16))); 
 b2.setBackground(new Color(Integer.parseInt(p2,16))); 
 b1.setForeground(new Color(Integer.parseInt(p3,16))); 
 b2.setForeground(new Color(Integer.parseInt(p3,16))); 
 l1.setForeground(new Color(Integer.parseInt(p4,16))); 
 l2.setForeground(new Color(Integer.parseInt(p4,16))); 
 l3.setForeground(new Color(Integer.parseInt(p4,16))); 
 l4.setForeground(new Color(Integer.parseInt(p4,16))); 
 add(l1); add(t1); add(l2); add(t2); add(l3); 
 add(t3); add(l4); add(t4); add(b1); add(b2); 
 } 
 public void mouseExited(MouseEvent e) 
 { 
 if (e.getSource()==b1) 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
45 
 b1.setBackground(new Color(Integer.parseInt(p2,16))); 
 if (e.getSource()==b2) 
 b2.setBackground(new Color(Integer.parseInt(p2,16))); 
 } 
 public void mouseEntered(MouseEvent e) 
 { 
 if (e.getSource()==b1) 
 b1.setBackground(new Color(Integer.parseInt(p1,16))); 
 if (e.getSource()==b2) 
 b2.setBackground(new Color(Integer.parseInt(p1,16))); 
 } 
 public void mousePressed(MouseEvent e) {} 
 public void mouseClicked(MouseEvent e) {} 
 public void mouseReleased(MouseEvent e){} 
} 
 
<html> 
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE> 
Uma applet que recebe parâmetros<BR><BR> 
<applet code="ex20.class" width=280 height=100> 
<param name="CorDeFundo" value="587792"> 
<param name="CorDoBotao" value="ABABAB"> 
<param name="TextoDoBotao" value="FFFF00"> 
<param name="CorDoLabel" value="00FF00"> 
</applet> 
</html> 
Exemplo 20 – Controle de eventos 
 
 
Figura 3.1 – A classe ex20 sendo executada 
 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
46 
3.2. Utilização de Servlets 
As Servlets são aplicações servidoras que são executadas a partir de um 
servidor Java, são módulos de software compilados (objetos), que ficam 
armazenados num servidor Java. Um Servlet pode, por exemplo, ser 
responsável em receber informações(parâmetros) vindas de um formulário em 
HTML e atualizar um banco de dados, ou criar uma página HTML de resposta. 
As Servlets são para os servidores o que as Applets são para os browsers. 
As Servlets estão substituindo os CGI (common gateway interfaces) 
scripts. Isso porque possibilitam a geração de documentos HTML dinâmicos, 
sendo fáceis de escrever e mais rápidas no momento da execução, tendo como 
vantagens principais à independência de plataforma, alta performance, 
facilidade de uso e programação, entre outros. 
Para rodar uma Servlet é necessário possuir o servidor Java instalado, o 
qual para fins didáticos poderá residir na mesma máquina da aplicação cliente. 
 
 
 
 
3.2.1. A criação da aplicação Cliente 
Inicialmente, será demonstrada a comunicação entre uma página HTML 
(aplicação cliente) e uma Servlet (aplicação servidora). 
A seguir é demonstrada a aplicação cliente, isto é, o código em HTML 
necessário para enviar informações para a Servlet. Essa página possui um 
formulário onde o usuário poderá cadastrar seu nome, data de nascimento e a 
quantidade de filhos que ele possui. Ao receber esses dados, a Servlet criará 
uma página HTML de resposta. 
 
<html> 
<Title>Passagem de valores a aplicação servidora</title> 
<body bgcolor="#9c9c9c"> 
<form action="http://127.0.0.1:8080/servlet/usuario?"> 
<b>Entre com seu nome:</b><br> 
<input type=text size=30 name="nome"><br> 
<b>Entre com a data de seu Nascimento:</b><br> 
<input type=text size=8 name="data"><br> 
<b>Entre com a quantidade de filhos:</b><br> 
<input type=radio name="filhos" value=0>0 
<input type=radio name="filhos" value=1>1 
<input type=radio name="filhos" value=2 checked>2 
<input type=radio name="filhos" value=3>3 
<input type=radio name="filhos" value=4>4<br><br> 
<input type=submit value="Enviar"> 
<input type=reset value="Limpar"> 
</form> 
</body> 
</html> 
Exemplo 21 – A aplicação Cliente 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
47 
A aplicação Ex21.html deve ser salva na pasta Public_html, conforme 
demonstra a figura 3.2. 
 
Figura 3.2 – A aplicação Cliente sendo executada 
 
 
3.2.2. A criação da aplicação Servidora 
A aplicação servidora é uma Servlet que recebe os dados da aplicação 
cliente e executa duas tarefas: cria uma página de retorno para o usuário, 
demonstrando os dados enviados, e grava essas informações em um arquivo 
texto chamado Arquivo.txt a partir da raiz do drive C. O código da aplicação é 
mostrado a seguir. Essa aplicação deve ser gravada e compilada na pasta 
Servlets do Servidor. Para executá-la será necessário registrá-la no servidor, 
conforme demonstra o próximo item. 
import java.io.*; 
import java.util.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
 
public class ex22 extends HttpServlet 
{ 
 public void doGet (HttpServletRequest req, HttpServletResponse res) 
 { 
 String nome = req.getParameter("nome"); // recebe os parâmetros 
 String data = req.getParameter("data"); 
 String filhos = req.getParameter("filhos"); 
 try 
 { // grava o arquivo txt 
 PrintWriter out = new PrintWriter(new FileWriter("c:/Arquivo.txt")); 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
48 
 out.println(nome); 
 out.println(data); 
 out.println(filhos); 
 out.close(); 
 // cria a página HTML de retorno 
 PrintStream tela = new PrintStream(res.getOutputStream()); 
 tela.println("<HTML><BODY>"); 
 tela.println("Obrigado, suas informa&ccedil;&otilde;es foram gravadas com sucesso"); 
 tela.println("<BR><P>"); 
 tela.println("<B> Nome : </B>"+nome+"<BR>"); 
 tela.println("<B> Data Nasc. : </B>"+data+"<BR>"); 
 tela.println("<B> Qtde Filhos: </B>"+filhos+"<BR>"); 
 tela.println("</BODY></HTML>"); 
 } 
 catch (IOException exc) 
 { 
 System.out.println("Erro de IO"); 
 exc.printStackTrace(); 
 } 
 } 
} 
Exemplo 22 – A aplicação Servidora 
 
3.2.3. A configuração do JavaWebServer 2.0 
 Nesse ponto, é considerado que o software servidor já está instalado. 
Será demonstrado como configurar corretamente o servidor para que uma 
Servlet possa ser reconhecida e executada. Esse item demonstrará os 
procedimentos necessários para colocar o servidor no ar e registrar a Servlet 
ex21 para que a comunicação possa ser executada. Evidentemente existem 
muitas configurações que podem ser realizadas, porém será enfocado apenas o 
registro da Servlet, item essencial a nossos objetivos. 
Quando o Java WebServer é instalado corretamente, várias pastas são 
criadas dentro da pasta principal (normalmente essa pasta se chama 
JavaWebServer2.0 que é o default). Destre essas pastas, as mais importantes 
para nossos objetivos são: 
• A pasta public_HTML ? essa pasta é utilizada para armazenar documentos 
HTML ou Applets que são carregadas pelo browser. No caso das Applets 
serem carregadas apenas localmente elas podem ser armazenadas em 
qualquer pasta, porém, quando um usuário precisa carregar a Applet a 
partir de um computador remoto, ela deve estar contida nesta pasta 
public_HTML. Não esqueça que os arquivos em HTML que chamam as 
Applets também devem ser armazenados no mesmo local. Em breve será 
demonstrado como configurar e colocar o servidor no "ar". 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
49 
• A pasta Servlets ? todas as Servlets criadas devem ser armazenadas nesta 
pasta para que o Java WebServer possa encontrá-las no momento da 
execução. 
A seguir são apresentados os itens necessários para registrar a Servlet 
ex21. 
 
Para inicializar o servidor: 
1 – Entre no prompt de comando 
2 - Entre na pasta bin do servidor: cd\javaweserver2.0\bin 
3 – Digite o comando httpd seguido de Enter 
4 – Isso deverá inicializar o servidor 
5 – Abra o browser e digite o endereço: http://127.0.0.1:8080 
6 – A tela principal do Java WebServer deverá aparecer, conforme demonstrado 
na figura 3.3. Se a página de abertura aparecer significa que o servidor está 
“no ar” e rodando normalmente. 
 
Observação: Dependendo da versão da ferramenta de desenvolvimento da Sun instalada na máquina 
e do comando set JAVA_HOME presente no arquivo autoexec.bat, podem ocorrer conflitos durante 
o processo de inicialização do servidor. Geralmente aparece uma informação dizendo: ocorreu um 
conflito entre o valor da variável de ambiente set JAVA_HOME e a ferramenta de desenvolvimento. 
Se isso ocorrer, o servidor deve ser inicializado com o comando: jserv –nojre. 
 
 
Figura 3.3 – Tela de abertura do servidor Java WebServer 
 
Com o servidor inicializado deve-se partir para o registro da Servletaluno. 
Esse procedimento é necessário para todas as Servlets que forem executadas 
pelo servidor. 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações - Página 
50 
Para realizar o registro da Servlet deve-se entrar na página do 
administrador do Java WebServer. Para isso digite no browser o endereço 
http://127.0.0.1:9090. Aparecerá a tela demonstrada na figura 3.4. 
Figura 3.4 – Tela de login do servidor 
 
Ao entrar na tela de login deve ser digitada a palavra admin tanto no 
campo User Name quanto no campo Password, conforme apresentado pela 
figura 3.4. Ao ser pressionado o botão Log In será apresentado a tela da figura 
3.5. Nessa tela deve ser pressionado o botão Manage e na nova tela (figura 
3.6) o botão Servlets. 
 
Curso de Java - Professor Sérgio Furgeri 
Acesso a banco de dados através de aplicações