Curso de Java - Banco de Dados e Aplicações Cliente x Servidor

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
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;
Manipulação do pacote AWT através do uso de Applets
- Página 1
Curso de Java -
Professor Sérgio Furgeri
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
Manipulação do pacote AWT através do uso de Applets
- Página 2
Curso de Java -
Professor Sérgio Furgeri
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
Manipulação do pacote AWT através do uso de Applets
- Página 3
Curso de Java -
Professor Sérgio Furgeri
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>
Manipulação do pacote AWT através do uso de Applets
- Página 4
Curso de Java -
Professor Sérgio Furgeri
<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
import
import
import
java.awt.*;
java.awt.event.*;
java.applet.Applet;
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);
Manipulação do pacote AWT através do uso de Applets
- Página 5
Curso de Java -
Professor Sérgio Furgeri
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
Manipulação do pacote AWT através do uso de Applets
- Página 6
Curso de Java -
Professor Sérgio Furgeri
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
import
import
import
import
java.net.*;
java.awt.*;
java.awt.event.*;
java.applet.Applet;
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>
Manipulação do pacote AWT através do uso de Applets
- Página 7
Curso de Java -
Professor Sérgio Furgeri
</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;
Manipulação do pacote AWT através do uso de Applets
- Página 8
Curso de Java -
Professor Sérgio Furgeri
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;
Manipulação do pacote AWT através do uso de Applets
- Página 9
Curso de Java -
Professor Sérgio Furgeri
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>
Manipulação do pacote AWT através do uso de Applets
- Página 10
Curso de Java -
Professor Sérgio Furgeri
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);
Manipulação do pacote AWT através do uso de Applets
- Página 11
Curso de Java -
//
Professor Sérgio Furgeri
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)
{
}
*/
}
Manipulação do pacote AWT através do uso de Applets
- Página 12
Curso de Java -
Professor Sérgio Furgeri
<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);
Manipulação do pacote AWT através do uso de Applets
- Página 13
Curso de Java -
Professor Sérgio Furgeri
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");
Manipulação do pacote AWT através do uso de Applets
- Página 14
Curso de Java -
Professor Sérgio Furgeri
}
}
}
<html>
<TITLE>Curso de Java - Professor Sérgio Furgeri</TITLE>
Uso de Listas tipo ListBox<BR><BR>
<applet code="ex08.class" width=150 height=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()
{
Manipulação do pacote AWT através do uso de Applets
- Página 15
Curso de Java -
Professor Sérgio Furgeri
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.
Manipulação do pacote AWT através do uso de Applets
- Página 16
Curso de Java -
Professor Sérgio Furgeri
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
Manipulação do pacote AWT através do uso de Applets
- Página 17
Curso de Java -
Professor Sérgio Furgeri
\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
Manipulação do pacote AWT através do uso de Applets
- Página 18
Curso de Java -
Professor Sérgio Furgeri
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();
}
Manipulação do pacote AWT através do uso de Applets
- Página 19
Curso de Java -
Professor Sérgio Furgeri
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;
Manipulação do pacote AWT através do uso de Applets
- Página 20
Curso de Java -
Professor Sérgio Furgeri
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 SWING
MenuArquivo.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");
Manipulação do pacote AWT através do uso de Applets
- Página 21
Curso de Java -
if
if
if
if
if
Professor Sérgio Furgeri
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();
}
(e.getSource()==miAbrir)
System.out.println("Abrir");
(e.getSource()==miSalvar)
System.out.println("Salvar");
(e.getSource()==miSalvarC)
System.out.println("Salvar Como");
(e.getSource()==miSalvarT)
System.out.println("Salvar Tudo");
(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.*;
Manipulação do pacote AWT através do uso de Applets
- Página 22
Curso de Java -
Professor Sérgio Furgeri
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
Manipulação do pacote AWT através do uso de Applets
- Página 23
Curso de Java -
Professor Sérgio Furgeri
arquivo html qie carrega a applet deve ser convertido com a ferramenta HTML
Converter (Anexo A).
import
import
import
import
java.awt.*;
java.awt.event.*;
java.applet.Applet;
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();
Manipulação do pacote AWT através do uso de Applets
- Página 24
Curso de Java -
Professor Sérgio Furgeri
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
Manipulação do pacote AWT através do uso de Applets
- Página 25
Curso de Java -
Professor Sérgio Furgeri
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
gerados atravé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);
Controle de Eventos e manipulação de Arquivo Texto
- Página 26
Curso de Java -
Professor Sérgio Furgeri
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;
Controle de Eventos e manipulação de Arquivo Texto
- Página 27
Curso de Java -
Professor Sérgio Furgeri
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,
mouseExited e mouseReleased
KeyListener
keyPressed, keyReleased, keyTyped
Controle de Eventos e manipulação de Arquivo Texto
mouseEntered,
- Página 28
Curso de Java TextListener
Professor Sérgio Furgeri
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
Controle de Eventos e manipulação de Arquivo Texto
- Página 29
Curso de Java -
Professor Sérgio Furgeri
keyRelease
keyTyped
MouseListener
mousePressed
mouseClicked
mouseEntered
mouseExited
mouseRelease
2.2. Manipulação
aplicações
de
arquivos
MouseEvent
Texto
através
de
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");
Controle de Eventos e manipulação de Arquivo Texto
- Página 30
Curso de Java -
Professor Sérgio Furgeri
b1.addActionListener(this);
b2.addActionListener(this);
t1 = new TextArea();
add(l1); add(t1); add(b1); add(b2); add(b3);
}
b3.addActionListener(this);
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
Controle de Eventos e manipulação de Arquivo Texto
- Página 31
Curso de Java -
Professor Sérgio Furgeri
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()
{
Controle de Eventos e manipulação de Arquivo Texto
- Página 32
Curso de Java -
Professor Sérgio Furgeri
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);
Controle de Eventos e manipulação de Arquivo Texto
- Página 33
Curso de Java -
Professor Sérgio Furgeri
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;
Controle de Eventos e manipulação de Arquivo Texto
- Página 34
Curso de Java -
Professor Sérgio Furgeri
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
{
Controle de Eventos e manipulação de Arquivo Texto
- Página 35
Curso de Java -
Professor Sérgio Furgeri
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
Controle de Eventos e manipulação de Arquivo Texto
- Página 36
Curso de Java -
Professor Sérgio Furgeri
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
import
import
import
java.awt.*;
java.awt.event.*;
java.io.*;
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);
}
Controle de Eventos e manipulação de Arquivo Texto
- Página 37
Curso de Java -
Professor Sérgio Furgeri
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
Controle de Eventos e manipulação de Arquivo Texto
- Página 38
Curso de Java -
Professor Sérgio Furgeri
Figura 2.5 – A Applet ex19 sendo executada pelo Appletviewer
Uma vez compilado o
“política de segurança”, pois
diretamente, antes disso é
responsável em definir o que a
programa, deverá ser criado um arquivo de
uma Applet não pode manipular um arquivo
necessário existir um policy file, que será
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.
Controle de Eventos e manipulação de Arquivo Texto
- Página 39
Curso de Java -
Professor Sérgio Furgeri
É 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.
Controle de Eventos e manipulação de Arquivo Texto
- Página 40
Curso de Java -
Professor Sérgio Furgeri
SignedBy: representa um apontamento para um arquivo de assinatura
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
Controle de Eventos e manipulação de Arquivo Texto
- Página 41
Curso de Java -
Professor Sérgio Furgeri
Para manipular arquivos com o browser é necessário alterar o arquivo
que contém as propriedades de segurança do sistema. Esse arquivo encontrase 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
Controle de Eventos e manipulação de Arquivo Texto
- Página 42
Curso de Java -
Professor Sérgio Furgeri
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;
Controle de Eventos e manipulação de Arquivo Texto
- Página 43
Curso de Java -
Professor Sérgio Furgeri
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)
Acesso a banco de dados através de aplicações
- Página
44
Curso de Java -
Professor Sérgio Furgeri
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
Acesso a banco de dados através de aplicações
- Página
45
Curso de Java -
Professor Sérgio Furgeri
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
Acesso a banco de dados através de aplicações
- Página
46
Curso de Java -
Professor Sérgio Furgeri
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"));
Acesso a banco de dados através de aplicações
- Página
47
Curso de Java -
Professor Sérgio Furgeri
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çõ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".
Acesso a banco de dados através de aplicações
- Página
48
Curso de Java -
Professor Sérgio Furgeri
•
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.
Acesso a banco de dados através de aplicações
- Página
49
Curso de Java -
Professor Sérgio Furgeri
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.
Acesso a banco de dados através de aplicações
- Página
50
Curso de Java -
Professor Sérgio Furgeri
Figura 3.5 – Serviços do Java WebServer
Figura 3.6 – Opções de configuração
A seguir deve ser clicado na opção add, conforme a figura 3.7, onde a
Servlet será registrada.
Acesso a banco de dados através de aplicações
- Página
51
Curso de Java -
Professor Sérgio Furgeri
Figura 3.7 – Registro do Servlet
No campo Servlet Name deve ser digitado um nome que faça referência
ao nome físico da classe, ou seja, funciona como um apelido da classe. Em
nosso caso foi escolhido o apelido aluno. Esse é o nome colocado na Applet
para invocar a execução da Servlet (veja o exemplo 9.34). No campo Servlet
Class deve ser digitado o nome físico do arquivo, em nosso caso Servletaluno
(não é necessário digitar a extensão class). Com isso a Servlet já está
registrada. A próxima tela demonstrada na figura 3.8 possibilita: a)definir se a
Servlet será executada no momento em que o servidor entrar no ar (load at
Startap), o que normalmente não é necessário, b) carregar a Servlet nesse
momento (Loaded Now), c) definir se a Servlet é carregada remotamente
(Load Remotely), o que não é o nosso caso.
Acesso a banco de dados através de aplicações
- Página
52
Curso de Java -
Professor Sérgio Furgeri
Figura 3.8 – Configuração do Servlet
3.2.4. Realização da comunicação
Nesse ponto tudo deve estar preparado para que a aplicação Cliente possa
ser carregada e envie dados para a Servlet ex21. Para isso deve ser digitado o
seguinte endereço no browser: http://127.0.0.1:8080/ex21.html, isto fará
que o documento ex21.html, armazenado na pasta public_html do servidor,
seja carregada. Se tudo estiver funcionando corretamente, o documento deverá
ser carregado e entrar em funcionamento, conforme demonstrado na figura
3.9.
Acesso a banco de dados através de aplicações
- Página
53
Curso de Java -
Professor Sérgio Furgeri
Figura 3.9 – A aplicação sendo carregada na pasta do servidor
Ao pressionar o botão enviar, a aplicação Servidora criará uma página
HTML de resposta, demonstrando os dados recebidos e ao mesmo tempo criará
um arquivo texto (arquivo.txt) com os dados. A página HTML de retorno pode
ser visualizada na figura 3.10.
Figura 3.10 – Página de resposta da aplicação Servidora
Acesso a banco de dados através de aplicações
- Página
54
Curso de Java -
Professor Sérgio Furgeri
3.2.5. Criação de uma Applet Cliente
Da mesma forma que a comunicação foi realizada com a Servlet através
de uma página HTML, o mesmo pode ser feito com o uso de uma applet. O
exemplo seguinte mostra como isso é possível, onde a Applet ex23 se comunica
com a mesma Servlet do exemplo ex21.
import java.net .*;
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class ex23 extends Applet implements ActionListener
{
TextField t1,t2,t3;
Label l1,l2,l3;
Button b1;
public void init()
{
l1 = new Label("Nome");
t1 = new TextField(30);
l2 = new Label("Data Nasc.");
t2 = new TextField(30);
l3 = new Label("Filhos");
t3 = new TextField(30);
setLayout (new GridLayout(4,2));
b1 = new Button ("Inscrever");
b1.addActionListener(this);
add(l1); add(t1); add(l2); add(t2); add(l3); add(t3); add(b1);
}
public void actionPerformed(ActionEvent e)
{
try
{
String s1 = t1.getText();
String s2 = t2.getText();
String s3 = t3.getText();
String param = "nome="+s1+"&data="+s2+"&filhos="+s3;
URL ul = new URL("http://127.0.0.1:8080/servlet/usuario?"+param);
getAppletContext().showDocument(ul);
}
catch (Exception exc)
{ t1.setText("Ocoreu um erro"); }
}
}
Exemplo 23 – A Applet Cliente
Acesso a banco de dados através de aplicações
- Página
55
Curso de Java -
Professor Sérgio Furgeri
Tópico 4:
Acesso a Banco de Dados através de Aplicações
A tarefa de se elaborar aplicações que possam manipular banco de dados
através de aplicações é relativamente simples se comparado ao mesmo acesso
através de um browser.
Os passos necessários para a manipulação de banco de dados através de
uma aplicação são:
I – A criação do banco de dados.
II – A configuração do sistema através da criação de uma fonte de dados entre
o banco de dados criado e a linguagem Java (fonte ODBC-JDBC).
III – A criação da aplicação Java propriamente dita.
Inicialmente, será desenvolvida uma aplicação que realiza apenas a consulta a
um banco de dados. A maioria das instruções usadas na linguagem Java para a
manipulação de banco de dados é realizada através da linguagem SQL.
4.1. A criação do banco de dados
A criação do banco de dados é bem simples. Para realizar essa tarefa
será utilizado o Microsoft Access 2000 e para facilitar os procedimentos, será
definido um diretório de trabalho, onde todos os arquivos criados serão
armazenados. Crie uma pasta chamada MeuBD no drive C (C:\MeuBD) e realize
os procedimentos seguintes:
•
Abra o Microsoft Access a partir do botão iniciar de seu desktop.
•
Crie um novo banco de dados: escolha um novo banco de dados vazio.
•
Quando o novo banco de dados abrir, escolha a pasta MeuBD e crie o banco
de dados com o nome Banco.
•
Quando o Access abrir o novo banco de dados, crie uma nova tabela no
modo estrutura: dê um duplo clique em Criar tabela no modo estrutura.
•
Crie a tabela de clientes, seguindo as informações seguintes:
Nome do campo
FICODIGO
FINOME
FIGENERO
FIPRODUT
FIDATCOM
FIANOPRO
FITEMDUR
Tipo de dados
Texto
Texto
Texto
Texto
Data/Hora
Texto
Texto
Acesso a banco de dados através de aplicações
Tamanho
5
35
8
15
4
3
- Página
56
Curso de Java -
Professor Sérgio Furgeri
•
Defina o campo FICODIGO como sendo a chave primária. Para isso,
pressione o botão direito do mouse sobre esse campo e escolha chave
primária.
•
Salve a tabela com o nome Filmes.
•
Feche o Microsoft Access.
Para que seja possível consultar dados futuramente, obviamente o banco de
dados deverá ser preenchido, isto é, diversos filmes deverão ser cadastrados.
4.2. A Configuração do sistema
Para que seja possível acessar banco de dados em Java, é necessário criar
uma fonte de dados ODBC, de maneira a estabelecer uma ponte de
comunicação entre o Access e o Java. A seguir, são demonstrados os
procedimentos necessários para a criação da fonte de dados.
•
Clique no botão Iniciar, escolha configurações e Painel de Controle.
•
Dê um duplo clique sobre o item ODBC 32 bits.
•
Acesse a guia NFD (Nome das Fontes de Dados) de usuário e pressione o
botão adicionar, conforme demonstra a figura 4.1.
Fig. 4.1 – Os drivers instalados
•
Escolha Microsoft Access Driver e pressione concluir. Dessa forma aparecerá
uma janela apresentada pela figura 4.2. No campo Nome da Fonte de Dados
digite MeuBanco.
Acesso a banco de dados através de aplicações
- Página
57
Curso de Java -
Professor Sérgio Furgeri
Figura 4.2 – Criação da Fonte de dados
•
Pressione o botão Selecionar e escolha o banco de dados criado pelo Access
(Banco.mdb), localizado na pasta c:\MeuBD e clique em OK
•
Sendo assim, o nome do banco de dados que será a fonte de dados ODBC
será selecionado. Pressione OK para finalizar essa operação. A fonte de
dados criada (MeuBanco) deve aparecer entre as Fontes de dados do
usuário, conforme demonstra a figura 4.3.
Nesse ponto, o banco de dados que será consultado pelo Browser já está
corretamente criado e devidamente configurado.
Acesso a banco de dados através de aplicações
- Página
58
Curso de Java -
Professor Sérgio Furgeri
Figura 4.3 – A Fonte de dados criada
4.3. A criação da aplicação em Java
Para criar uma aplicação que realiza a manipulação de banco de dados é
necessário incluir instruções para carregar um driver da linguagem java
(jdbc:odbc) que será o responsável em realizar a ponte com a fonte de dados
ODBC do Windows.
4.3.1. A conexão com o banco de dados
O exemplo seguinte realiza apenas a conexão com um banco de dados.
Ao executar o programa será enviada uma mensagem indicando o sucesso ou
não da conexão.
import java.sql.*;
class ex24
{
public static void main(String[] args)
{
//declaração de um url que será a ponte jdbc-odbc com o banco de dados MeuBanco
String url = "jdbc:odbc:MeuBanco";
try
{
// carrega um jdbc-odbc driver
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// estabele a conexão chamada MinhaConexao com o URL definido
Acesso a banco de dados através de aplicações
- Página
59
Curso de Java -
Professor Sérgio Furgeri
// anteriormente usando um nome de usuário e uma senha
Connection
"anypswd");
MinhaConexao
=
DriverManager.getConnection(url,
"anyname",
System.out.println("Conexao realizada com sucesso");
MinhaConexao.close();
//Fecha a Conexão
}
catch(java.lang.Exception ex)
{
System.out.println("Problemas na conexao com a fonte de dados");
}
}
}
Ex24 – Conexão com o banco de dados
4.3.2. A leitura do banco de dados com o SQL
O exemplo seguinte demonstra os procedimentos necessários para a
conexão e consulta de um banco de dados através de instruções em SQL. No
exemplo, será apresentado na tela a relação de filmes que possuem código
superior a 03120 e inferior a 03140, conforme demonstra a figura 4.4.
import java.sql.*;
class ex25
{
public static void main(String[] args)
{
String url = "jdbc:odbc:MeuBanco";
try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection
"anypswd");
MinhaConexao
=
DriverManager.getConnection(url,
"anyname",
// Cria e executa uma instrução SQL
Statement MeuState = MinhaConexao.createStatement();
// Mostra o resultado da instrução SQL na tela
ResultSet rs = MeuState.executeQuery("SELECT Ficodigo, Finome FROM Filmes
WHERE Ficodigo>'03120' AND Ficodigo<'03140' ORDER BY Ficodigo");
System.out.println("Codigo
System.out.println("------
Nome");
-------------------------------------------
");
while(rs.next())
{
String codigo = rs.getString("ficodigo");
String nome = rs.getString("finome");
Acesso a banco de dados através de aplicações
- Página
60
Curso de Java System.out.println(codigo + "
Professor Sérgio Furgeri
" + nome);
}
MinhaConexao.close();
}
catch(java.lang.Exception ex)
{
System.out.println("Problemas na conexao com a fonte de dados");
}
}
}
Ex25 – leitura do banco de dados com SQL
Figura 4.4 – O Resultado da consulta em SQL
O exemplo seguinte demonstra o resultado das instruções SQL em uma
janela, através da inserção de um objeto TextArea deixando a aplicação mais
apresentável e profissional. Nesse exemplo existem instruções SQL fixas,
entretanto, nada impede que se construam aplicações mais versáteis que
permitam a inclusão direta de qualquer instrução SQL.
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
public class ex26 extends Frame implements ActionListener
{
Acesso a banco de dados através de aplicações
- Página
61
Curso de Java -
Professor Sérgio Furgeri
TextArea area=new TextArea();
Button b1 = new Button ("Filmes com cod>03400");
Button b2 = new Button ("Filmes com cod<00100");
Button b3 = new Button ("Filmes com cod>3400 ordenados por nome");
Label l1 = new Label("Instrução SQL");
TextField sql = new TextField(70);
TextField status = new TextField(50);
Connection MinhaConexao;
public static void main(String[] args)
{
ex26 Janela = new ex26();
WindowListener l = new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
};
Janela.addWindowListener(l);
Janela.show();
}
ex26()
{
setTitle("Consulta em Banco de dados");
setSize(650,300);
setBackground(new Color(180,180,140));
sql.setEditable(false);
area.setEditable(false);
status.setEditable(false);
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
setLayout(new FlowLayout());
add(l1);add(sql);
add(b1);add(b2);add(b3);
add(area);add(status);
}
public void actionPerformed(ActionEvent e)
{
if (e.getSource()==b1)
sql.setText("SELECT ficodigo,finome FROM filmes WHERE ficodigo>'03400'");
Acesso a banco de dados através de aplicações
- Página
62
Curso de Java -
Professor Sérgio Furgeri
if (e.getSource()==b2)
sql.setText("SELECT ficodigo,finome FROM filmes WHERE ficodigo<'00100'");
if (e.getSource()==b3)
sql.setText("SELECT ficodigo,finome FROM filmes WHERE ficodigo>'03400' order by
finome");
try
{
String url = "jdbc:odbc:MeuBanco";
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
MinhaConexao = DriverManager.getConnection(url, "anyname", "anypswd");
status.setText("");
area.setText("");
Statement MeuState = MinhaConexao.createStatement();
ResultSet rs = MeuState.executeQuery(sql.getText());
area.append("Codigo Nome \n");
area.append("----------------------- \n");
-----------------------------------------------
String codigo="", nome="";
while(rs.next())
{
codigo = rs.getString("ficodigo");
nome = rs.getString("finome");
area.append(codigo + "
" + nome + "\n");
}
status.setText("Instrução executada com sucesso!");
MinhaConexao.close();
}
catch(java.lang.Exception ex)
{
status.setText("Instrução nao reconhecida");
}
}
}
Ex26 – Instruções SQL em uma Janela
Acesso a banco de dados através de aplicações
- Página
63
Curso de Java -
Professor Sérgio Furgeri
Figura 4.5 – Instruções SQL fixas
4.3.3. Criação de consultas com tabelas
O exemplo seguinte demonstra a utilização do componente JTable. Com
ele é possível visualizar os dados na forma de uma grade, da mesma forma que
é usado na maioria das linguagens visuais de programação.
import
import
import
import
import
java.sql.*;
javax.swing.*;
java.awt.*;
java.awt.event.*;
java.util.*;
public class ex27 extends JFrame
{
Connection conexao;
JTable tab;
public ex27()
{
String url = "jdbc:odbc:MeuBanco";
try
{
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
conexao = DriverManager.getConnection(url, "", "" );
}
catch (ClassNotFoundException cne)
{
System.out.println("Erro ao carregar o driver JDBC/ODBC");
System.exit(0);
}
catch (SQLException sqlne )
{
System.out.println("Problemas na Conexão");
}
Acesso a banco de dados através de aplicações
- Página
64
Curso de Java -
Professor Sérgio Furgeri
buscaTabela();
setSize(600,300);
show();
}
private void buscaTabela()
{
Statement st;
ResultSet res;
try
{
String sql = "SELECT * FROM Filmes";
st = conexao.createStatement();
res = st.executeQuery(sql);
mostraTabela(res);
st.close();
}
catch (SQLException sqlex)
{
System.out.println("Instrução não reconhecida");
}
}
private void mostraTabela(ResultSet rs)
throws SQLException
{
setTitle( "Tabela de Filmes" );
Vector cabecalho = new Vector();
Vector linhas = new Vector();
try
{
// busca os cabeçalhos
ResultSetMetaData rsmd = rs.getMetaData();
for ( int i = 1; i <= rsmd.getColumnCount(); ++i )
cabecalho.addElement( rsmd.getColumnName( i ) );
// busca dados das linhas
while ( rs.next() );
linhas.addElement( proximaLinha( rs, rsmd ) );
// Mostra a tabela com cabeçalhos e registros
tab = new JTable( linhas, cabecalho );
JScrollPane scroller = new JScrollPane( tab );
add(scroller, BorderLayout.CENTER);
}
catch ( SQLException sqlex )
{
System.out.println( "Problemas na criação da tabela");
}
}
private Vector proximaLinha(ResultSet rs, ResultSetMetaData rsmd )
throws SQLException
{
Acesso a banco de dados através de aplicações
- Página
65
Curso de Java -
Professor Sérgio Furgeri
Vector LinhaAtual = new Vector();
for ( int i = 1; i <= rsmd.getColumnCount(); ++i )
switch( rsmd.getColumnType(i))
{
case Types.VARCHAR:
LinhaAtual.addElement(rs.getString(i));break;
case Types.INTEGER:
LinhaAtual.addElement(new Long(rs.getLong(i)));break;
case Types.TIMESTAMP:
LinhaAtual.addElement(rs.getDate(i));break;
default:
System.out.println( "Type was: " +
rsmd.getColumnTypeName( i )+rsmd.getColumnType( i ));
}
return LinhaAtual;
}
public void fechar()
{
try
{
conexao.close();
}
catch ( SQLException sqlex )
{
System.out.println( "Impossível Desconectar" );
}
}
public static void main( String args[] )
{
final Tabela janela = new Tabela();
janela.addWindowListener(new WindowAdapter()
{
public void windowClosing( WindowEvent e )
{
janela.fechar();
System.exit( 0 );
}
}
);
}
}
Ex27 – Uso do componente JTable
Acesso a banco de dados através de aplicações
- Página
66
Curso de Java -
Professor Sérgio Furgeri
Figura 4.6 – Consulta da tabela de filmes com o JTable
Acesso a banco de dados através de aplicações
- Página
67
Curso de Java -
Professor Sérgio Furgeri
Tópico 5:
Uso da Classe Table e Manutenção em Banco de Dados
No tópico anterior foi demonstrado um exemplo que possibilita a
utilização da classe Table para demonstrar dados de uma tabela do banco de
dados. Nesse tópico são apresentados alguns exemplos que detalham a
utilização da classe Table. O primerio exemplo (Tabela1) demonstra como
acessar dados armazenados nas células da classe Table.
5.1. Verificação do conteúdo das células da tabela
import javax.swing.JTable;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
// para tratar a largura da coluna
import javax.swing.table.TableColumn;
public class Tabela1 extends JFrame
{
public Tabela1()
{
setTitle("Mostra o conteúdo das células e como definir a largura da coluna");
Object[][] data = {
{"Monica", "Silva",
"Volei", new Integer(5), new Boolean(false)},
{"Aline", "Severo",
"Tênis", new Integer(3), new Boolean(true)},
{"katia", "Barnabé",
"Natação", new Integer(2), new Boolean(false)},
{"Marcos", "Pinheiro",
"Moto Velocidade", new Integer(20), new Boolean(true)},
{"Angela", "Lima",
"Voley", new Integer(4), new Boolean(false)}
};
String[] columnNames = {"Nome","Sobrenome","Esporte","Anos","Fumante"};
final JTable table = new JTable(data, columnNames);
//Linha abaixo é opcional
table.setPreferredScrollableViewportSize(new Dimension(500, 80));
Uso da classe Table e manutenção em banco de dados
- Página
68
Curso de Java -
Professor Sérgio Furgeri
// adiciona o evento Click do mouse
table.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
mostraDados(table);
}
});
// Controla a largura da coluna -------------------TableColumn column = null;
for (int i = 0; i < 5; i++)
{
column = table.getColumnModel().getColumn(i);
if (i == 2)
column.setPreferredWidth(100);
else
column.setPreferredWidth(50);
}
// -------------------------------------------------//Cria um painel de rolagem e adiciona a tabela nele.
JScrollPane scrollPane = new JScrollPane(table);
//adciona o painel a Janela.
getContentPane().add(scrollPane, BorderLayout.CENTER);
//trecho para frechar a Janela -------------------addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
//---------------------------------------------------}
private void mostraDados(JTable table)
{
int numLinhas = table.getRowCount();
int numColunas = table.getColumnCount();
javax.swing.table.TableModel mTab = table.getModel();
System.out.println("Conteúdo da tabela: ");
Uso da classe Table e manutenção em banco de dados
- Página
69
Curso de Java -
Professor Sérgio Furgeri
for (int i=0; i < numLinhas; i++)
{
System.out.print("
Linha " + i + ":");
for (int j=0; j < numColunas; j++)
{
System.out.print(" " + mTab.getValueAt(i, j));
}
System.out.println();
}
}
public static void main(String[] args) {
Tabela1 janela = new Tabela1();
janela.pack(); //janela do tamanho do objeto
janela.show();
}
}
Exemplo Tabela1 – Mostra conteúdo das células da tabela
A tela gerada pelo exemplo Tabela1 é demonstrada na figura 5.1
Figura 5.1 – Consulta de dados nas células da tabela
Ao clicar sobre a tabela serão demonstrados todos os dados
armazenados nas células, célula a célula. Dessa forma, torna-se possível
conhecer o conteúdo de qualquer ponto da tabela.
5.2. Posicionamento da seleção da tabela
O próximo exemplo (Tabela2) se parece com o anterior, entretanto,
demonstra como identificar a posição do cursor sobre a tabela, permitindo
conhecer a linha e coluna selecionada no momento em que o Mouse é clicado. A
Janela gerada pelo exemplo é idêntica a apresentada pela figura 5.1.
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionListener;
Uso da classe Table e manutenção em banco de dados
- Página
70
Curso de Java -
Professor Sérgio Furgeri
import javax.swing.event.ListSelectionEvent;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
public class Tabela2 extends JFrame
{
public Tabela2()
{
setTitle("Mostra a linha e coluna selecionada
");
Object[][] data = {
{"Monica", "Silva",
"Volei", new Integer(5), new Boolean(false)},
{"Aline", "Severo",
"Tênis", new Integer(3), new Boolean(true)},
{"katia", "Barnabé",
"Natação", new Integer(2), new Boolean(false)},
{"Marcos", "Pinheiro",
"Moto Velocidade", new Integer(20), new Boolean(true)},
{"Angela", "Lima",
"Voley", new Integer(4), new Boolean(false)}
};
String[] columnNames = {"Nome","Sobrenome","Esporte","Anos","Fumante"};
final JTable table = new JTable(data, columnNames);
//Linha abaixo é opcional
table.setPreferredScrollableViewportSize(new Dimension(500, 80));
// seleção de linhas
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
ListSelectionModel rowSM = table.getSelectionModel();
rowSM.addListSelectionListener(new ListSelectionListener()
{
public void valueChanged(ListSelectionEvent e)
{
//Ignore extra messages.
if (e.getValueIsAdjusting()) return;
Uso da classe Table e manutenção em banco de dados
- Página
71
Curso de Java -
Professor Sérgio Furgeri
ListSelectionModel lsm = (ListSelectionModel)e.getSource();
int selectedRow = lsm.getMinSelectionIndex();
System.out.println("Linha " + selectedRow);
}
});
//seleção de colunas
ListSelectionModel colSM =
table.getColumnModel().getSelectionModel();
colSM.addListSelectionListener(new ListSelectionListener()
{
public void valueChanged(ListSelectionEvent e)
{
//Ignore extra messages.
if (e.getValueIsAdjusting()) return;
ListSelectionModel lsm = (ListSelectionModel)e.getSource();
int selectedCol = lsm.getMinSelectionIndex();
System.out.println("Coluna " + selectedCol);
}
});
//Cria um painel de rolagem e adiciona a tabela a ele.
JScrollPane scrollPane = new JScrollPane(table);
//adciona o painel a Janela.
getContentPane().add(scrollPane, BorderLayout.CENTER);
//trecho para frechar a Janela
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String[] args) {
Tabela2 janela = new Tabela2();
janela.pack(); //janela do tamanho do objeto
janela.show();
}
Uso da classe Table e manutenção em banco de dados
- Página
72
Curso de Java -
Professor Sérgio Furgeri
}
Exemplo Tabela2 – Mostra a linha e coluna selecionada
5.3. Uso do objeto Combo dentro da tabela
O exemplo seguinte demonstra como utilizar um objeto tipo Combo
dentro de uma célula da tabela, conforme apresenta a figura 5.2.
import javax.swing.JTable;
import javax.swing.table.TableColumn;
import javax.swing.DefaultCellEditor;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.JScrollPane;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
public class Tabela3 extends JFrame
{
public Tabela3()
{
setTitle("Uso do Combo em uma célula");
final JTable table = new JTable(MinhaTabela);
//final JTable table = new JTable(data, columnNames);
//Linha abaixo é opcional
table.setPreferredScrollableViewportSize(new Dimension(500, 80));
// define a tabela e a coluna onde o combo será inserido
adicionaCombo(table, table.getColumnModel().getColumn(2));
// -------------------------------------------------//Cria um painel de rolagem e adiciona a tabela nele.
JScrollPane scrollPane = new JScrollPane(table);
//adciona o painel a Janela.
getContentPane().add(scrollPane, BorderLayout.CENTER);
Uso da classe Table e manutenção em banco de dados
- Página
73
Curso de Java -
Professor Sérgio Furgeri
//trecho para frechar a Janela -------------------addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
//---------------------------------------------------}
public static void main(String[] args) {
Tabela3 janela = new Tabela3();
janela.pack(); //janela do tamanho do objeto
janela.show();
}
public void adicionaCombo(JTable t, TableColumn espC)
{
JComboBox combo = new JComboBox();
combo.addItem("Futebol");
combo.addItem("Natação");
combo.addItem("Voley");
combo.addItem("Tênis");
combo.addItem("Basquete");
combo.addItem("Boxe");
espC.setCellEditor(new DefaultCellEditor(combo));
// Coloca hint no combo
DefaultTableCellRenderer r = new DefaultTableCellRenderer();
r.setToolTipText("Escolha um esporte");
espC.setCellRenderer(r);
}
class MinhaTabela extends AbstractTableModel
{
Object[][] data = {
{"Monica", "Silva",
"Volei", new Integer(5), new Boolean(false)},
{"Aline", "Severo",
"Tênis", new Integer(3), new Boolean(true)},
{"katia", "Barnabé",
"Natação", new Integer(2), new Boolean(false)},
Uso da classe Table e manutenção em banco de dados
- Página
74
Curso de Java -
Professor Sérgio Furgeri
{"Marcos", "Pinheiro",
"Moto Velocidade", new Integer(20), new Boolean(true)},
{"Angela", "Lima",
"Voley", new Integer(4), new Boolean(false)}
};
String[] columnNames = {"Nome","Sobrenome","Esporte","Anos","Fumante"};
}
}
Exemplo Tabela3 – Uso de Combos nas células da tabela
Figura 5.2 – Uso do Combo nas células da tabela
5.4. Uso do objeto CheckBox dentro da tabela
Semelhante ao exemplo anterior, o exemplo Tabela4, demonstra a
utilização de objetos tipo CheckBox dentro das células da tabela, conforme
apresenta a figura 5.3.
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.JScrollPane;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.JOptionPane;
import java.awt.*;
import java.awt.event.*;
public class Tabela4 extends JFrame
{
public Tabela4() {
Uso da classe Table e manutenção em banco de dados
- Página
75
Curso de Java -
Professor Sérgio Furgeri
super("Uso do CheckBox nas células");
MinhaTabela MeuModelo = new MinhaTabela();
JTable table = new JTable(MeuModelo);
table.setPreferredScrollableViewportSize(new Dimension(500, 70));
//Create the scroll pane and add the table to it.
JScrollPane scrollPane = new JScrollPane(table);
//Add the scroll pane to this window.
getContentPane().add(scrollPane, BorderLayout.CENTER);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
class MinhaTabela extends AbstractTableModel
{
Object[][] data = {
{"Monica", "Silva",
"Volei", new Integer(5), new Boolean(false)},
{"Aline", "Severo",
"Tênis", new Integer(3), new Boolean(true)},
{"katia", "Barnabé",
"Natação", new Integer(2), new Boolean(false)},
{"Marcos", "Pinheiro",
"Moto Velocidade", new Integer(20), new Boolean(true)},
{"Angela", "Lima",
"Voley", new Integer(4), new Boolean(false)}
};
String[] columnNames = {"Nome","Sobrenome","Esporte","Anos","Fumante"};
public int getColumnCount() {
return columnNames.length;
}
public int getRowCount()
{
Uso da classe Table e manutenção em banco de dados
- Página
76
Curso de Java -
Professor Sérgio Furgeri
return data.length;
}
public String getColumnName(int col)
{
return columnNames[col];
}
public Object getValueAt(int row, int col)
{
return data[row][col];
}
public Class getColumnClass(int c)
{
return getValueAt(0, c).getClass();
}
// as colunas 0 e 1 não são editáveis
public boolean isCellEditable(int row, int col)
{
if (col < 2)
return false;
else
return true;
}
//método usado para que a tabela seja editável
public void setValueAt(Object value, int row, int col)
{
data[row][col] = value;
fireTableCellUpdated(row, col);
System.out.println("Novos valores:");
mostraDados();
}
private void mostraDados()
{
int numLinhas = getRowCount();
int numColunas = getColumnCount();
for (int i=0; i < numLinhas; i++) {
System.out.print("
Linha " + i + ":");
for (int j=0; j < numColunas; j++) {
System.out.print(" " + data[i][j]);
Uso da classe Table e manutenção em banco de dados
- Página
77
Curso de Java -
Professor Sérgio Furgeri
}
System.out.println();
}
System.out.println("--------------------------");
}
}
public static void main(String[] args) {
Tabela4 frame = new Tabela4();
frame.pack();
frame.setVisible(true);
}
}
Exemplo Tabela4 – Uso de CheckBoxes nas células da tabela
Figura 5.3 – Uso do CheckBox nas células da tabela
5.5. Uma aplicação completa para manutenção em
tabelas
O exemplo seguinte se refere a uma aplicação completa para
manutenção de dados em um cadastro. Nesse exemplo são controlados os
dados referentes a tabela de Filmes, contendo as funções de Inserção,
Alteração, Exclusão e Localização, conforme pode ser observado na figura 5.4.
import java.sql.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.JOptionPane;
import javax.swing.JDialog;
import javax.swing.JFrame;
public class ex28 extends JFrame implements ActionListener
{
Uso da classe Table e manutenção em banco de dados
- Página
78
Curso de Java -
Professor Sérgio Furgeri
// ScrollingPanel fields;
Connection conexao;
JFrame frame;
JTable tab;
JLabel l1,l2,l3,l4,l5,l6,l7,l8;
JButton b1,b2,b3,b4;
static JTextField tfCodigo,tfNome,tfGenero,tfProdut,tfDatcom,tfAnopro,tfTemdur;
static JTextArea tfMen;
JPanel p1 = new JPanel();
Statement st;
String SQL="";
public ex28()
{
p1.setLayout(new FlowLayout(FlowLayout.LEFT));
l1 = new JLabel("Código ");
l2 = new JLabel("Título");
l3 = new JLabel("Gênero");
l4 = new JLabel("Produtora");
l5 = new JLabel("Data de Compra ");
l6 = new JLabel("Ano de Produção");
l7 = new JLabel("Tempo de Duração");
l8 = new JLabel(" ");
for (int i=0;i<60;i++)
l8.setText(l8.getText()+" ");
tfCodigo = new JTextField(10);
tfCodigo.addActionListener(this);
tfNome = new JTextField(35);
tfGenero = new JTextField(10);
tfProdut = new JTextField(15);
tfDatcom = new JTextField(8);
tfAnopro = new JTextField(5);
tfTemdur = new JTextField(5);
tfMen = new JTextArea(2,53);
b1=new JButton("Inserir");
b2=new JButton("Atualizar");
b3=new JButton("Excluir");
b4=new JButton("Localizar");
//b5=new JButton("Anterior");
//b6=new JButton("Próximo");
b1.setBackground(new Color(180,180,250));
b2.setBackground(new Color(180,180,250));
b3.setBackground(new Color(180,180,250));
Uso da classe Table e manutenção em banco de dados
- Página
79
Curso de Java -
Professor Sérgio Furgeri
b4.setBackground(new Color(180,180,250));
// b5.setBackground(new Color(180,180,250));
// b6.setBackground(new Color(180,180,250));
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
// b5.addActionListener(this);
// b6.addActionListener(this);
String url = "jdbc:odbc:MeuBanco";
try
{
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
conexao = DriverManager.getConnection(url, "", "" );
}
catch (ClassNotFoundException cne)
{
System.out.println("Erro ao carregar o driver JDBC/ODBC");
System.exit(0);
}
catch (SQLException sqlne )
{
System.out.println("Problemas na Conexão");
}
p1.add(l1); p1.add(tfCodigo); p1.add(l2); p1.add(tfNome);
p1.add(l3); p1.add(tfGenero); p1.add(l4); p1.add(tfProdut);
p1.add(l5); p1.add(tfDatcom); p1.add(l6); p1.add(tfAnopro);
p1.add(l7); p1.add(tfTemdur); p1.add(l8); p1.add(b1);
p1.add(b2); p1.add(b3); p1.add(b4);// p1.add(b5);p1.add(b6);
p1.add(tfMen);
getContentPane().add(p1);
setTitle("Controle de Filmes");
setSize(600,200);
setResizable(false);
show();
}
public void fechar()
{
try
{
Uso da classe Table e manutenção em banco de dados
- Página
80
Curso de Java -
Professor Sérgio Furgeri
conexao.close();
}
catch ( SQLException sqlex )
{
System.out.println( "Impossível Desconectar" );
}
}
public static void main( String args[] )
{
final ex28 janela = new ex28();
janela.addWindowListener(new WindowAdapter()
{
public void windowClosing( WindowEvent e )
{
janela.fechar();
System.exit( 0 );
}
}
);
}
public void actionPerformed(ActionEvent e)
{
tfMen.setText("");
if (e.getSource()==b1)
//inserir
{
try
{
st = conexao.createStatement();
SQL = "INSERT INTO Filmes ("+
"Ficodigo,Finome,Figenero,Fiprodut,Fidatcom,Fianopro,Fitemdur) Values ('"+
tfCodigo.getText()+"','"+
tfNome.getText()+"','"+
tfGenero.getText()+"','"+
tfProdut.getText()+"','"+
tfDatcom.getText()+"','"+
tfAnopro.getText()+"','"+
tfTemdur.getText()+"')";
st.executeUpdate(SQL);
tfMen.setText("Gravação realizada com sucesso");
limparCampos();
}
Uso da classe Table e manutenção em banco de dados
- Página
81
Curso de Java -
Professor Sérgio Furgeri
catch(SQLException ex)
{
if (ex.getMessage().equals("General error"))
tfMen.setText("Filme já Cadastrado");
else
tfMen.setText("Data Inválida");
}
}
// ------------------ Final da Inclusão ------------------if (e.getSource()==b2)
//Atualizar
{
try
{
st = conexao.createStatement();
SQL = "UPDATE Filmes SET "+
"Ficodigo='"+tfCodigo.getText()+"',"+
"Finome='"+tfNome.getText()+"',"+
"Figenero='"+tfGenero.getText()+"',"+
"Fiprodut='"+tfProdut.getText()+"',"+
"Fidatcom='"+tfDatcom.getText()+"',"+
"Fianopro='"+tfAnopro.getText()+"',"+
"Fitemdur='"+tfTemdur.getText()+"' "+
"WHERE Ficodigo = '"+tfCodigo.getText()+"'";
int r = st.executeUpdate(SQL);
if (r==1)
tfMen.setText("Atualização realizada com sucesso");
else
tfMen.setText("Esse Filme ainda não está cadastrado\n Pressione Inserir");
}
catch(SQLException ex)
{
tfMen.setText("Deu Pau");
}
}
// ------------------ Final da Atualização ------------------if (e.getSource()==b3)
// Excluir
{
try
{
st = conexao.createStatement();
SQL = "SELECT Ficodigo, Finome FROM Filmes Where Ficodigo =
'"+tfCodigo.getText()+"'";
resultSet rs = st.executeQuery(SQL);
Uso da classe Table e manutenção em banco de dados
- Página
82
Curso de Java -
Professor Sérgio Furgeri
String nome = "";
try
{
rs.next();
nome = "Deletar o Filme: "+rs.getString("finome");
}
catch(SQLException ex1)
{
JOptionPane.showMessageDialog(null,"Filme nao cadastrado!");
return;
}
Int n = JOptionPane.showConfirmDialog(frame,nome,"
",JOptionPane.YES_NO_OPTION);
if (n==JOptionPane.YES_OPTION)
{
SQL = "DELETE FROM Filmes Where Ficodigo =
'"+tfCodigo.getText()+"'";
int r = st.executeUpdate(SQL);
if (r==1)
JOptionPane.showMessageDialog(null,"Exclusão realizada com sucesso");
else
JOptionPane.showMessageDialog(null,"Não foi possível excluir o filme");
}
}
catch(SQLException ex)
{
tfMen.setText("Instrução SQL inválida");
}
limparCampos();
}
// ------------------ Final da Exclusão ------------------if (e.getSource()==b4 || e.getSource()==tfCodigo)
{
try
{
st = conexao.createStatement();
SQL = "SELECT * FROM Filmes Where Ficodigo = '"+tfCodigo.getText()+"'";
ResultSet rs = st.executeQuery(SQL);
rs.next();
tfCodigo.setText(rs.getString("Ficodigo"));
tfNome.setText(rs.getString("Finome"));
tfGenero.setText(rs.getString("Figenero"));
Uso da classe Table e manutenção em banco de dados
- Página
83
Curso de Java -
Professor Sérgio Furgeri
tfProdut.setText(rs.getString("Fiprodut"));
tfDatcom.setText(""+rs.getDate("Fidatcom"));
tfAnopro.setText(rs.getString("Fianopro"));
tfTemdur.setText(rs.getString("Fitemdur"));
}
catch(SQLException ex)
{
JOptionPane.showMessageDialog(null,"Filme nao Encontrado!");
return;
}
}
// ------------------ Final da Localização ------------------}
public static void limparCampos()
{
tfCodigo.setText("");
tfNome.setText("");
tfGenero.setText("");
tfProdut.setText("");
tfDatcom.setText("");
tfAnopro.setText("");
tfTemdur.setText("");
}
}
Exemplo Ex28 – Controle completo de cadatramento
Figura 5.4 – Manutenção da tabela de Filmes
Uso da classe Table e manutenção em banco de dados
- Página
84
Curso de Java -
Professor Sérgio Furgeri
Anexo A: Utilização do HTML Converter
Originalmente o browser não pode abrir applets dotadas de classes do pacote
Swing (java 2). Isso inclui todas as classes do Swing (iniciam-se com um J – Ex:
Jmenu, Jmessage...). Para que o browser possa realizar o carregamento dessas Applets
atuais é necessário realizar a conversão do arquivo HTML que carrega a Applet através
da ferramenta HTML Converter fornecia pela Sun.
Para instalar essa ferramenta descompacte o arquivo de instalação em um
diretório qualquer. Uma vez instalado, entre no diretório onde se encontra o arquivo
HTMLConverter.bat (...converter\classes) através do prompt do DOS. Exemplo: se a
ferramenta foi instalada no diretório c:\Conversor, então digite:
Cd\conversor\converter\classes <Enter>
Estando dentro do diretório que se encontra a ferramenta, digite as seguintes
linha no prompt do DOS:
set CLASSPATH=%CLASSPATH%;.;
java HTMLConverter
A seguir será apresentada a seguinte tela:
Você deve escolher o diretório onde o arquivo HTML a ser convertido se encontra
(All Files in Folder) e um local para Backup onde or arquivos originais ficarão guardados
(Backup Files to Folder).
Uma vez que seus arquivos HTML foram convertidos você já pode carregá-los
através do browser.
Uso da classe Table e manutenção em banco de dados
- Página
85