Você está na página 1de 84

COMPETÊNCIAS E HABILIDADES:

- Conhecer os conceitos das principais linguagens de programação para web.

- Conhecer as ferramentas de programação web mais utilizadas no mercado.

- Capacitar à seleção de Linguagens e ferramentas para serem utilizadas em um


projeto web.

- Conhecer a linguagem de programação Java.

- Configurar um ambiente de programação Java.

- Conhecer a IDE Eclipse para desenvolver aplicações web em Java.

- Acessar banco de dados através da API JDBC.

- Manipular JSP e Servers.

-Desenvolver uma aplicação Web em Java utilizando banco de dados.

Conteúdo Programático:

UNIDADE I:
o Conhecendo a família Java
o Apresentação da IDE Eclipse para desenvolvimento Java
o Lingugem Java – Apresentação da linguagem e orientação objeto
básica (Classe, Objeto, atributos de acesso e ArrayList ).
o Classe e Objetos e atributos de acesso
o ArrayList
o Polimorfismo e herança.
o Controle de Erro

UNIDADE II:
o JDBC - java.sql - acesso a banco de dados (MYSQL)
o Conceitos básicos sobre Java EE
o Servlet Containers e o Apache Tomcat
o Configurando o Eclipse Europa para desenvolvimento WEB
o Principais TAGs HTML
o JSP – Java Server Pages
o Padrão DAO – Data Access Object
o Construindo um projeto web passo a passo utilizando JSP, DAO
e MYSQL
o Conhecendo alguns frameworks – Hibernate e JFS.
o Apresentação de outras linguagens de programação para web –
DotNet, PHP, Ruby.

Bibliografia Básica:

1. Kurniawan, Bubi. Java para Web com Servlest, JSP e EJB. Ciência Moderna, 2002.
2. Basha, Jeelani. Professional Java Web services. Wrox Press, 2002.
3. Deitel. Java TM : como programar. 6º Ed. Pearson Prentice Hall, 2007.

Bibliografia complementar:

4. Shepherd, George. Microsoft ASP.NET 2.0: passo a passo. Bookman, 2007.


5. Marcondes, Christian. HTML 4.0 fundamental: a base da programação para web.
Érica, 2005.
UNIDADE I:

Nessa unidade iremos conhecer um pouco sobre a família Java, suas funções e
áreas de atuação de um desenvolvedor. Vamos estudar a linguagem de programação
Java, nos aperfeiçoando no paradigma Orientação Objeto – Classes, objetos, atributos
de acesso e ArrayList (vetores de objetos), e manipular uma IDE de programação
muito utilizada no mercado, que é o Eclipse.
Ao finalizar essa unidade, vamos conhecer as áreas de programação da família
Java, estando aptos para discutir sobre qual caminho devemos seguir nessa
tecnologia. De igual forma, poderemos desenvolver pequenas aplicações utilizando a
linguagem Java e a IDE Eclipse.

1. Conhecendo a família Java

Java é uma linguagem de programação orientada a objeto desenvolvida e


mantida pela Sun (HTTP://www.sun.com); é uma linguagem free, multiplataforma e
uma das linguagens mais utilizadas no Brasil e no mundo. Por este motivo, existem
várias comunidades brasileiras que compartilham materiais, discutem temas e
dúvidas sobre Java em fóruns - os mais acessados são: http://www.Guj.com.br,
http://www.javafree.org/.
Sempre que possível, vamos acessar esses fóruns, pois neles encontramos
soluções para problemas que acabam acontecendo com freqüência, quando estamos
estudando um novo paradigma.
Com Java, podemos desenvolver para diversas áreas, como para: Desktop
(sistemas que são executados na máquina local), WEB e sistemas que acessam
aplicativos móveis, p.ex. celular, palm, pocket.
Para desenvolvimento Desktop no Java, temos o J2SE – Java Standard
Edition, que é onde existem todas as bibliotecas necessárias para o
desenvolvimento e execução dos códigos Java. Normalmente, quando
desenvolvemos para Desktop em Java, utilizamos Swing (Tollkit), o qual utiliza uma
interface (lembra um pouco a guia do Dephi) com alguns componentes que
interagem com o usuário.
Para desenvolvimento em multi-camadas e servidores, utilizamos o J2EE –
Java Enterprise Edition, que possui todas as funcionalidades do J2SE e mais
outras bibliotecas para desenvolvimento com banco de dados e sistemas
distribuídos. Será nessa parte da família Java que desenvolveremos nossas
aplicações WEB com JSP.
Para desenvolvimento em dispositivos móveis, utilizamos o J2ME – Java
Micro editional, que possui uma arquitetura especial com uma série de APIs -
Application Programming Interface, a qual possui funções acessíveis somente para
programação do Java.

Figura 1.1 Ilustra a família Java

1.1. Máquina Virtual - JVM

Diferente do Pascal e outras linguagens cujo código fonte é compilado para


um determinado sistema Operacional, o Java possui uma JVM – Java Virtual
Machine, que é uma camada existente entre o sistema operacional e a aplicação,
responsável pelo gerenciamento dos aplicativos e conversão dos bytecodes - código
gerado pelo compilador Java – em código executável de máquina.
Em virtude dessa máquina virtual, os programas escritos em Java podem ser
executados em qualquer plataforma que possua uma versão da JVM; por isso os
códigos Java são independentes de plataforma.
1.2. Instalando Java

Antes de começarmos a estudar sobre a instalação do Java é importante


destacar que é comum errar algum passo da instalação do Java. Por isso, sempre que
isso acontecer ou se não entender algo, nunca deixe de entrar em contato com o seu
professor.
Para desenvolvermos em Java, é preciso ter o compilador, sua Máquina
virtual e bibliotecas. Para isso, devemos instalar o JDK- Java Development Kit, em
que o compilador e as bibliotecas Java são encontrados.
Encontramos o JDK no site da Sun, onde deve ser feito o download da
versão 1.6, que é a mais atual no momento, também conhecida como Java SE 6.0.
Para download, acesse o seguinte Link:
http://java.sun.com/javase/downloads/index.jsp. Ao acessar o endereço, clique em
Get the JDK download; depois, na caixa de checagem (checkBox) Accept e faça a
escolha da plataforma Windows.
Feito o download, é só executar o arquivo baixado e instalá-lo.
Depois de instalado e devidamente configurado, vamos testar para saber se as
configurações foram concluídas com sucesso. Para efetuar o teste, devemos abrir o
Prompt de comando do Windows (Iniciar-Programas – Acessórios – Prompt de
comando), digitar Java –version e clicar na tecla enter (nesse processo, irá
aparecer, no console, qual a versão do Java que está instalado em sua máquina).
Figura 1.2 Ilustra a versão do Java

2. Apresentação da IDE Eclipse para desenvolvimento Java

Existem várias IDE´s de programação Java: JBuilder, NetBeans, JDEV,


Eclipse e outros. Nesse curso, iremos abordar o Eclipse, que além de gratuita, é IDE
líder no mercado.
O eclipse foi desenvolvido pela IBM e depois liberada para as comunidades,
as quais fazem melhoras na ferramenta e constroem plugins que auxiliam no nosso
desenvolvimento. Podemos encontrar essa ferramenta no endereço
www.eclipse.org. Para fazer o download da versão do Windows, escolha o link
download e a versão Eclipse for J2EE ou a versão mais completa do eclipse, que, na
atualidade, é a 3.3.3.1.
Para usar o eclipse, basta descompactá-lo em um diretório desejado e
executar o arquivo eclipse.exe.
Ao iniciar o eclipse, podemos escolher onde ficará nosso workspace
(diretório de todos nossos projetos).
Figura 2.1 Ilustra o workspace do eclipse

Quando acessamos o eclipse, aparece uma tela de bem vindo, que é chamada
de view Welcome. Quando fechamos essa tela, estamos no WorkBench, que é a
interface onde vamos criar nossos projetos Java no eclipse.
O eclipse é dividido em várias partes: Barra de título, ferramentas,
perspectiva, menu, status, painel do editor e views.
• Barra de título: Exibe a perspectiva atual.
• Barra de Ferramenta: É a barra onde encontraremos vários plugins e
funcionalidades do eclipse.
• Barra de perspectiva: Exibirá qual ambiente o usuário está no
momento.
• Barra de menu: Barra geral do Eclipse, em que podemos encontrar
todas as tarefas do eclipse.
• Barra de status: Exibe informações do item que estiver selecionado
no momento.
• Painel do editor: Ambiente onde podemos editar e construir nossos
códigos fontes.
• Views: Exibe os grupos de objetos selecionados e existentes nos
nossos projetos.
Para certificar que o Eclipse esteja funcionado de maneira correta, vamos
criar um projeto chamado “HelloWorld”, seguido os passos a seguir:
• Clique em File – New – Project – JavaProject
• Crie o projeto Java, o mesmo ficará no diretório do workspace criado
anteriormente.
• Clique em Finish
• O projeto deve ficar igual à imagem abaixo
• Clique com o botão direto do mouse e escolha a opção new – class

• Coloque o nome da classe “HelloWorld” e clique na caixa de


checagem public static void main (String[] args), já que nossa
classe será principal. Esse assunto será melhor explicado mais
adiante.
• Clique em finish e coloque o código abaixo.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Olá Mundo");
}
}

• Para executar, é só clicar com o botão direto em cima da classe e


escolher a opção Run as – Java Application.

• Aparecerá no console a mensagem:


No decorrer do curso, vamos aprender mais algumas funcionalidades do
eclipse.

3. Lingugem Java – Apresentação da linguagem e orientação objeto básica (Classe,


Objeto, atributos de acesso e ArrayList ).
Nesse tópico, iremos aprender a sintaxe básica do Java:
• Informações básicas do Java
• Declaração e controle de varáveis
• Operadores
• Controles condicionais
• Instruções de Laços

3.1. Informações básicas do Java

Quando estamos desenvolvendo para desktop, os códigos devem começar no


método main, que é, e sempre será, o primeiro método a ser executado.
Esse método tem um padrão a ser seguido:

public static void main (String[] args) {

Entre as chaves que iremos iniciar com os códigos Java, a primeira ({) indica
o início do método e a segunda (}) o fim.
Depois da maioria das instruções Java, deve ser colocado ponto-e-vírgula
para informar a finalização de uma linha de código.

System.out.println(“Hello World”);
Também pode ser feito comentário em Java através das formas:

// Comentário em Java
/* Comentário em Java 1
Comentário em Java 2
Comentário em Java 3 */

3.2. Declaração e controle de varáveis

As variáveis em Java podem ser declaradas a qualquer momento do código


fonte. Toda variável tem um tipo que não pode ser mudado uma vez declarado. A
sintaxe para declaração de variáveis é a seguinte:

TipoDaVaríavel NomeDaVariável;

As variáveis mais conhecidas são int, Double, char, boolean. Seguem


alguns códigos desses tipos de variáveis:

public class ExemploJava {

public static void main(String[] args) {


int num;
num = 5;
num = 5 + 4;
System.out.println(num);
}

Lembrar que Java é uma linguagem Case Sensitive, isto é, a variável deverá
ser chamada exatamente da mesma forma que foi escrita. Caso seja declarada uma
variável com letra maiúscula, essa variável deverá ser chamada com letra maiúscula.

3.3. Operadores

Em Java, há um conjunto de tipos de operadores aritméticos, relacionais e


lógicos.
Operadores Significado
+ Soma
- Subtração
* Multiplicação
/ Divisão
++ Incrementa uma variável
-- Decrementa uma variável
Tabela 3.1 – Ilustra os operadores aritméticos

Public class ExemploJava {

public static void main(String[] args) {


int num;
num = 5 + 5;
num ++;
System.out.println(num);
}

Operadores Significado
== Igualdade
!= Diferente
> Maior que
>= Maior ou igual
< Menor
<= Menor ou igual
Tabela 3.2 – Ilustra os operadores relacionais

public class ExemploJava {


public static void main(String[] args) {
int num;
num = 5;
if (num >= 5){
System.out.println("num é maior ou igual a cinco");
}
}
}

Operadores Significado
&& E lógico (and)
! Não (negação)
|| Ou Lógico (or)
Tabela 3.3 – Ilustra os operadores Lógicos

public class ExemploJava {


public static void main(String[] args) {
int num;
num = 5;
if ((num >= 5) && (num < 10)) {
//Concatenação de strings, devido a quebra de linha
System.out.println("num é maior ou igual a cinco e "+
"menor que dez");
}
}
}

3.4.Controles condicionais

As estruturas de controle funcionam como a maioria das linguagens de


programação, mas com algumas modificações na sua sintaxe.
Nesse tipo de estrutura, podemos utilizar alguns operadores e sua sintaxe é a
que segue:

if (condição){
código
}

Podemos também utilizar a clausula else:

public class ExemploJava {


public static void main(String[] args) {
int num;
num = 11;
if ((num >= 5) && (num < 10)) {
//Concatenação de strings, devido a quebra de linha
System.out.println("num é maior ou igual a cinco e "+
"menor que dez");
}else{
System.out.println("num não está entre dez e cinco");
}
}
}

public class ExemploJava {


public static void main(String[] args) {
int num;
num = 11;
boolean ok = true;
if (!ok) {
System.out.println("Variável boleana é false");
} else if ((ok) || (num > 10)) {
System.out
.println("Variável boleana é true ou num é maior que dez");
}
}
}

Existe a estrutura switch, que é também conhecida como case. É muito utilizada
em seqüências de testes:

switch (key) {
case value:

break;

default:
break;
}

public class ExemploJava {


public static void main(String[] args) {
int num;
num = 111;

switch (num) {
case 5:
System.out.println("Num é igual a cinco");
break;
case 1:
System.out.println("Num é igual a um");
break;
case 100:
System.out.println("Num é igual a cem");
break;
case 11:
System.out.println("Num é igual a onze");
break;
default:
System.out.println("Num é diferente de todos " +
"valores anteriores");
break;
}
}
}

3.5.Instruções de Laços
Os Laços mais utilizados em Java são o For e While, sendo que o
funcionamento é o mesmo das outras linguagens que conhecemos, a sintaxe,
contudo, muda um pouco:
No caso do For.
for (inicialização;condição;incremento) {
código
}

public class ExemploJava {


public static void main(String[] args) {

for (int i = 0; i < 10; i++) {


System.out.println(i);
}

}
}

No caso do While.
while (condição) {
código
}

public class ExemploJava {


public static void main(String[] args) {
int num = 0;
while (num < 10) {
System.out.println(num);
num++;
}
}
}

3.6. Método

Métodos em Java são similares a funções e procedimentos em Pascal. Crie


uma classe chamada ExemplosMetodos e adicione o método principal.

public class ExemplosMetodos {

void primeiroMetodo() {
System.out.println("Método sem parâmetro e sem retorno");
}

String segundoMetodo() {
System.out.println("Método sem parâmetro e com retorno");
return "fabio";
}

String terceitoMetodo(String nome, String sobreNome) {


System.out.println("Método com parâmetro e com retorno");
return nome + " " + sobreNome;
}

public static void main(String[] args) {


//Instanciando a classe
ExemplosMetodos exMet = new ExemplosMetodos();
//Fazendo chamada dos métodos
exMet.primeiroMetodo();
System.out.println(exMet.segundoMetodo());
System.out.println(exMet.terceitoMetodo("Fábio",
"Coriolano"));
}
}

3.7. TypeCast

Em Java, existe conversão de valores; por enquanto, serão exibidos


exemplos mais simples, mas, no decorrer do curso, veremos exemplos mais
complexos.
• String para int -> Integer.parseInt(String s)
• String para float -> Float.parseFloat(String s)
• int ou float para String -> String.valueOf(int i) ou
String.valueOf(float f)

public class typeCast{

public static void main(String[] args) {


String num = "1";
String num2 = "2";
//Concatenando strings
System.out.println(num + num2);
//Convertendo de string para inteiro (Soma)
System.out.println(Integer.parseInt(num) +
Integer.parseInt(num2));

int x = 523;
//Transformando de inteiro para String
String y = String.valueOf(x);
}

Exercícios de fixação
• Escreva um programa que leia dois números e calcule a soma e o produto
entre eles, a subtração e a divisão do primeiro valor com o segundo.

• Sobre o salário bruto de um funcionário são descontados 8% de INSS, 10%


de IR (imposto de renda) e sobre o restante, 0,5% referente à filiação
sindical. Escreva um programa que retorne o salário líquido do funcionário.

• Faça um programa que calcule o valor de um número Fatorial (Exemplo: 5!


= 5x4x3x2x1 = 120)

• Faça um programa que imprima no console todos os números múltiplos de


três e cinco que seja menor que duzentos e maior que cem.

• Desenvolva os seguintes métodos e faça chamada:

o float soma (float num1,float num2) {}


o float subtração (float num1,float num2) {}
o float divisão (float num1,float num2){}
o float multiplicação (float num1,float num2) {}
Obs.: Para fazer chamada dos métodos dentro do método principal a classe
tem que ser instanciada. (Verifique o item 3.6 do nosso material - Método)

4. Classe e Objetos e atributos de acesso (Orientação Objeto Básica)

Programação orientada a objeto tem por finalidade definir os objetos


dentro de certo domínio, junto com sua finalidade e seu comportamento. As
características destes objetos vão determinar os procedimentos que se aplicarão a
eles durante a execução do programa OO, por essa razão uma classe é chamada de
“fôrma”, e através dela, iremos criar vários objetos com atributos iguais, mas de
características diferentes.
Objetos são conjuntos de dados genéricos com funções bem definidas; essas
funções e dados são encapsulados pelo objeto de maneira a expor somente o que
for necessário a outros objetos.
Uma classe é uma fôrma que descreve de forma genérica grupos de objetos
com características similares.
Uma instância de classe é um objeto real. A classe representa a descrição
genérica de um objeto, enquanto uma instância é uma representação concreta deste
objeto.
Carro instancia objetos

Marca
Cor
Ano
KM
Carro do Carro do Carro da
Fábio Joao Maria

Marca: Marca: Marca:


Ferrari Corsa Fusca objetos
classe Cor: Preto Cor: Azul Cor: branco
Ano: 2005 Ano: 2000 Ano: 1989
KM: 3000 KM: 50000 KM:
500000

Imagem 4.1 Ilustra várias instancias de uma classe

Uma classe possui atributos e métodos (procedimento e funções). Os


atributos descrevem as características dos objetos que serão criados e são
identificados por um nome e um tipo. Os métodos definem as funcionalidades do
objeto.
Existem também os modificados de visibilidade que podem ser usados tanto
nos atributos, como nos métodos. Os mais conhecidos são:
• Public: Pode ser acessado por qualquer outro objeto.
• Private: Não pode ser acessado por nenhum outro objeto.
• Protected: Poderá ser acessado somente por objetos que forem
herdados pela mesma classe.
Vamos desenvolver nossa classe Java seguindo os passos abaixo:
• Crie um projeto no eclipse com os nome de PrjCarro.
• Crie uma classe principal chamada de appCarro.
ƒ Clique com o botão direito do mouse em cima do
projeto e depois escolha a opção new - class. (lembrar
de clicar na caixa de checagem public static void
main (String[] args))
• Crie uma classe com o nome Carro e adicione os atributos: modelo,
cor e motorLigado.

public class carro {


String modelo;
String cor;
boolean motorLigado;
}

• Ainda na classe carro, será criado um método que se chama


mostraAtributos, que serve para exibir no console o valor de cada
atributo. Esse método será criado com void, pois não possui retorno
(serio o procedimento do pascal).

public class carro {


String modelo;
String cor;
boolean motorLigado;

public void mostreAtributos(){


System.out.println("O dono do carro é: "+ dono);
System.out.println("O modelo do carro é: "+ modelo);
System.out.println("A cor do carro é: "+ cor);
if (motorLigado){
System.out.println("O motor do carro está ligado");
}else{
System.out.println("O motor do carro está "+
"desligado");
}
System.out.println("---------------------------------");
}
}

• Na classe principal, vamos criar instâncias de vários carros com a


mesma forma. Para desenvolvermos com mais eficiência, vamos
utilizar a combinação do teclado “Ctrl + Space”, para obtermos a
lista de possíveis códigos.
public class appCarro {

public static void main(String[] args) {


//Criando uma instancia de um carro
Carro carFabio = new Carro();
//setando os atributos
carFabio.dono = "Fábio";
carFabio.modelo = "Ferrari";
carFabio.cor = "preto";
carFabio.motorLigado = false;
Carro carJoao = new Carro();
carJoao.dono = "João";
carJoao.modelo = "corsa";
carJoao.cor = "azul";
carJoao.motorLigado = false;

Carro carMaria = new Carro();


carMaria.dono = "Maria";
carMaria.modelo = "fusca";
carMaria.cor = "branco";
carMaria.motorLigado = true;

carJoao.mostreAtributos();
carMaria.mostreAtributos();
carFabio.mostreAtributos();
}
}

Na programação orientada a objeto, no intuito de organizar os atributos, são


criados métodos de acesso, que são os gets e sets. Utilizaremos o exemplo anterior e
colocaremos os atributos como private (só a classe que o atributo pertence tem
acesso ao ele) e adicionaremos os gets e sets para cada atributo.
Para criar os gets e sets no eclipse basta clicar no botão direto do mouse
dentro do código da classe desejada e clicar na opção Source – Generate Getters
and Setters. Depois é só selecionar os atributos desejados e clicar em OK.
Imagem 4.1 Ilustra como adicionar os gets e sets de forma automática.

Na classe carro, serão feitas as seguintes alterações.

public class Carro {

private String dono;


private String modelo;
private String cor;
private boolean motorLigado;

public void mostreAtributos(){


System.out.println("O dono do carro é: "+ dono);
System.out.println("O modelo do carro é: "+ modelo);
System.out.println("A cor do carro é: "+ cor);
if (motorLigado){
System.out.println("O motor do carro está ligado");
}else{
System.out.println("O motor do carro está " +
"desligado");
}
System.out.println("-------------------------------");
}

public String getDono() {


return dono;
}
public void setDono(String dono) {
this.dono = dono;
}

public String getModelo() {


return modelo;
}

public void setModelo(String modelo) {


this.modelo = modelo;
}

public String getCor() {


return cor;
}

public void setCor(String cor) {


this.cor = cor;
}

public boolean isMotorLigado() {


return motorLigado;
}

public void setMotorLigado(boolean motorLigado) {


this.motorLigado = motorLigado;
}
}

Na classe appCarro, os atributos dos objetos do tipo Carro só serão


acessados através dos gets e sets.

public class appCarro {

public static void main(String[] args) {


//Criando uma instancia de um carro
Carro carFabio = new Carro();
//setando os atributos

carFabio.setDono("Fábio");
carFabio.setModelo("fiesta") ;
carFabio.setCor("preto");
carFabio.setMotorLigado(false);

Carro carJoao = new Carro();


carJoao.setDono("João");
carJoao.setModelo("corsa");
carJoao.setCor("azul");
carJoao.setMotorLigado(false);
Carro carMaria = new Carro();
carMaria.setDono("Maria");
carMaria.setModelo("fusca");
carMaria.setCor("branco");
carMaria.setMotorLigado(true);

//Fazendo chamada dos métodos mostra Atributos


carJoao.mostreAtributos();
carMaria.mostreAtributos();
carFabio.mostreAtributos();
}
}

Exercício de fixação
• Crie uma classe chamada Aluno como ilustra a tabela.
Atributos Métodos
Nome Todos os gets e stes
Sexo mostreAtributos()
Idade
Curso
Numero da Matícula
• Crie uma classe com o método principal, instancie três alunos e faça
chamado do seu método mostreAtributos().

4.1. Ler do Teclado

Ler uma determinada instrução do teclado em Java pode ser realizado de


várias maneiras. Aqui iremos utilizar o jOptionPane.showInputDialog.
Para utilizar essa função, basta colocar uma mensagem para o usuário (o
parâmetro da função) e a função dará um retorno, que é a mensagem digitada.
Quando utilizarmos o método JOptionPane, é necessário fazer o import do código
javax.swing.JOptionPane , pois é através dele que o Java irá encontrar a função.
Caso não consiga fazer o import dessa função, acione a tecla “Ctrl + O” (irá
importar todas as funções da classe) ou utilize “Ctrl + Space” em cima do código
que deseja ser importado.

import javax.swing.JOptionPane;

public class LerDoTeclado {


public static void main(String[] args) {
String nome;
nome = JOptionPane
.showInputDialog("Entre com o nome");
System.out.println(nome);

}
}

5. Herança.

Herança é uma estrutura que permite que características comuns entre


classes sejam compartilhadas a partir de uma superclasse (Classe Pai). Através de
uma classe base, outras subclasses irão herdar suas características (atributos e
métodos).

Classe A

Classe B

Classe C Classe D Classe E


Imagem 5.1 Ilustra uma herança de classes.

A imagem 5.1 ilustra o seguinte mecanismo:


• Classe A é super-classe de B
• Classe B é subclasse de A
• Classe B é super-classe de C, D, e E
• Classes C, D, e E são subclasses de B
Para entendermos melhor a herança, vamos desenvolver o exemplo a seguir:
Veículo

Motorizado N_Motorizado

Moto Carro Bicicleta Patins

• Crie um novo Projeto no eclipse chamado PrjVeiculo.


• Crie uma classe chamada veículo com os atributos:
String tipoDoVeiculo; String modelo; String cor.
• Gere seus gets e sets.
• Crie o método void mostreAtributos(). Esse método imprime no
console o valor de todos os atributos da classe.

public class Veiculo {


private String tipoDoVeiculo;
private String modelo;
private String cor;

public String getTipoDoVeiculo() {


return tipoDoVeiculo;
}

public void setTipoDoVeiculo(String tipoDoVeiculo) {


this.tipoDoVeiculo = tipoDoVeiculo;
}

public String getModelo() {


return modelo;
}

public void setModelo(String modelo) {


this.modelo = modelo;
}

public String getCor() {


return cor;
}

public void setCor(String cor) {


this.cor = cor;
}
public void mostreAtributos() {
System.out.println("O veiculo " + tipoDoVeiculo + " é do "+
"modelo " + modelo + " e é da cor " + cor);
}
}

• Crie uma classe chamada Motorizado, que herda de veiculo.


Sintaxe para herança: class Motorizado extends Veiculo{....}
• Crie o atributo MotorLigado do tipo boolean e gere seus get e set.
• Crie o método mostreAtributos(), que exibe todas as características
do Objeto do tipo motorizado (inclusive sua herança). Se o motor
estiver ligado, deverá aparecer no console “motor ligado”, se não,
“motor desligado”.

public class motorizado extends Veiculo {

private boolean motorLigado;

public boolean isMotorLigado() {


return motorLigado;
}

public void setMotorLigado(boolean motorLigado) {


this.motorLigado = motorLigado;
}

/**
* Exibe todas as características do veiculo motorizado
*/
public void mostreAtributos() {
//Faz chamada do método mostreAtributos da classe Pai
super.mostreAtributos();
if (motorLigado) {
System.out.println("Seu motor está ligado");
} else {
System.out.println("Seu motor está desligado");
}
}
}

Obs.: A classe motorizado é uma extensão de veículo. Ela é um veículo com mais uma
característica, que é o motorLigado. Como motorizado herda de veículo, a classe
motorizado pode acessar todos os métodos públicos de veículo.
• Crie uma classe carro que herda de motorizado
• Utilize o atributo reEngatada do tipo boolean e gere seu get e set
• Crie uma método mostreAtributos, que exibe todas as características
do Objeto do tipo carro(inclusive sua herança). Se a ré estiver
engatada deverá aparecer no console “ré engatada”, se não, “normal”.
public class Carro extends motorizado {
private boolean reEngatada;

public boolean isReEngatada() {


return reEngatada;
}

public void setReEngatada(boolean reEngatada) {


this.reEngatada = reEngatada;
}

public void mostreAtributos(){


super.mostreAtributos();
if (isReEngatada()){
System.out.println("Sua ré está engatada");
}else{
System.out.println("Sua ré está Normal");
}
}
}

• Crie uma classe chamada AppVeiculo com o método principal e crie


uma instância de carro.
6.ArrayList

O ArrayList é uma coleção que permite inserir objetos em determinada


ordem (normalmente os elementos são encontrados em ordem de inserção). O
ArrayList é membro do List, que é uma classe que guarda dados os quais podem ser
acessados através de índices.
Para criar um ArrayList basta chamar o construtor:
ArrayList<Tipo do Objeto> nome da Lista = new ArrayList();
É sempre possível abstrair a lista através da Interface (Define um tipo que
descreve o comportamento visível de uma classe, através de assinaturas das suas
operações) List:
List mesmaLista = lista;
O ArrayList possui dois métodos add, um que recebe o objeto a ser inserido
e o coloca no final da lista e o outro que permite adicionar o elemento em qualquer
posição da mesma.
O método get(int) retorna o elemento na posição especificada como
parâmetro, iniciando na posição zero, assim como trabalha uma array comum.
Através dele e do método size (retorna o tamanho da array), fica fácil percorrer uma
ArrayList.
No eclipse, vamos criar um projeto com método principal e fazer um
exemplo utilizando ArrayList.

import java.util.ArrayList;

public class Listas {


public static void main(String[] args) {
// Instanciando uma ArrayList
ArrayList<String> lista = new ArrayList();
// Adicionando Objetos na lista
lista.add("Brasil");
lista.add("Japão");
lista.add("Argentina");
/* Intanciando Listas para poder utilizar o método
ListaArray*/
Listas l = new Listas();
// Chamada do método
l.listaArray(lista);
// Removendo um objeto da lista
lista.remove(1);
System.out.println("------------");
// Listando todos objetos da array
l.listaArray(lista);
// Limpando a lista
lista.clear();
System.out.println("------------");
// Listando todos objetos da array
l.listaArray(lista);
}
/**
* Lista todos objetos de uma ArrayList
* @param arg: ArrayList passado por parâmetro
*/
public void listaArray(ArrayList<String> arg){
//Listando todos objetos da lista
for (int i = 0; i < arg.size(); i++) {
//Retorna o objeto da posição "i"
System.out.println(arg.get(i));
}
}
}

Exercício de aprendizado
• Vamos seguir os passos para desenvolvermos um mini-sistema utilizando
ArrayList.
• Defina uma superclasse pessoa, que herdam dela duas subclasses: aluno,
professor. Siga os atributos e operações a seguir e construa suas classes com seus
respectivos métodos.
Pessoa
Atributos Operações
Nome Listar
Sexo
Idade
Estado Civil
Número da matrícula

Aluno (Pessoa)
Atributos Operações
Ano de Entrada Listar
Ano previsto para saída
Bolsista (percentual da bolsa)

Professor (Pessoa)
Atributos Operações
Quantidade de horas de trabalho na Listar - Mostrar no console o salário do
instituição professor
Quanto ganha por hora aula

Aplicação – AppPessoa
Atributos Operações
Alunos (ArrayList) Cadastrar “N” alunos. (usar ArrayList).

Professores (ArrayList) Cadastrar “N” professores. (usar


ArrayList).

Fazer edição dos Alunos (1º faz a pesquisa


de um determinado aluno e depois edita o
mesmo)
Fazer edição dos Professores (1º faz a
pesquisa de um determinado professor e
depois edita o mesmo)
Listar todos os alunos
Listar todos os alunos do sexo Feminino
Listar aluno bolsista e o percentual da
bolsa
Exibir o professor que tem o maior salário
• 1º Passo – Construa a classe Pessoa.
• 2º Passo – Adicione todos os atributos e seus gets e sets.
• 3º Passo – Construa a classe Aluno que herda de Pessoa. (Lembre de utilizar
extends)
• 4º Passo – Adicione todos os atributos e seus gets e sets.
• 5º Passo – Construa o método listar. (Semelhante ao MostaAtributos feito em
exercícios anteriores)
• 6º Passo – Construa a classe Professor que herda de Pessoa. (Lembre de utilizar
extends)
• 7º Passo – Adicione todos os atributos e seus gets e sets.
• 8º Passo – Construa o método listar. (Semelhante ao MostaAtributos feito em
exercícios anteriores)
• 8º Passo – Construa a classe AppPessoa e adicione o método main.
• 9º Passo – Para cada operação da classe AppPessoa desenvolva um método
como segue no exemplo.
import java.util.ArrayList;
import javax.swing.JOptionPane;

public class AppPessoa {

public ArrayList<Aluno> alunos;

public ArrayList<Professor> professores;

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
AppPessoa pessoa = new AppPessoa();
pessoa.alunos = new ArrayList();
pessoa.professores = new ArrayList();
String op = JOptionPane
.showInputDialog("Deseja cadastrar outro aluno s/n");
/*
* Comprar String utilize o método equals. Se for igual
* retorna true senão flase
*/
while (op.equals("s")) {
/*
* Faz chamada do método que retorna um Objeto aluno
* e o adiciona no ArrayList
*/
pessoa.alunos.add(pessoa.cadastrarAluno());
/* Pergunta se o usúario deseja cadastrar outro aluno */
op = JOptionPane
.showInputDialog("Deseja cadastrar "+
"outro aluno s/n");
}

op = JOptionPane.showInputDialog("Deseja editar algum "+


"aluno s/n");
while (op.equals("s")) {
/* Faz chamada do método que edita um aluno do
ArrayList */
pessoa.editarAluno();
/* Pergunta se o usúario deseja editar outro aluno */
op = JOptionPane.showInputDialog("Deseja editar "+
"outro aluno s/n");
}

pessoa.listarAluno();

/**
* Lista todos os alunos do ArrayList
*/
private void listarAluno() {
for (int i = 0; i < alunos.size(); i++) {
/*
* O método get retorna um objeto aluno na posição
* "i", com isso chamamos o método listar desse
* objeto /
alunos.get(i).listar();
}
}

/**
* Fazer edição dos Alunos (1º faz a pesquisa de um determinado
* aluno e depois edita o mesmo)
*
*/
private void editarAluno() {

int mat = Integer.parseInt(JOptionPane


.showInputDialog("Entre com a matrícula do "+
"aluno"));
/* Cria objeto aluno */
Aluno aluno = new Aluno();
for (int i = 0; i < alunos.size(); i++) {
/* Aluno recebe o aluno do indici "i" da ArrayList */
aluno = alunos.get(i);
/*
* Se a matricula entrada pelo usuário for igual ao
* do aluno da ArrayList e feita a edição
*/
if (mat == aluno.getNum_mat()) {
/*
* O segundo parâmetro é para exibir o valor do
* atributo corrente na caixa de texto
*/

aluno.setAnoDeEntrada(JOptionPane.showInputDialog(
"Entre com o ano de entrada",
aluno.getAnoDeEntrada()));

aluno.setNome(JOptionPane.showInputDialog("Entre com o nome",


aluno.getNome()));

aluno.setAnoSaida(JOptionPane.showInputDialog("Ano Saida",
aluno.getAnoSaida()));

aluno.setBolsista(Double.parseDouble(JOptionPane
.showInputDialog("Bolsista",
aluno.getBolsista())));

aluno.setEstadoCivil(JOptionPane.showInputDialog(
"Entre com o Estado Civil",
aluno.getEstadoCivil()));
/* Necesário fazer o typeCast, pois o atributo
é do tipo inteiro */

aluno.setIdade(Integer.parseInt(JOptionPane.showInputDialog(
"Entre com a idade",
aluno.getIdade())));

aluno.setNum_mat(Integer.parseInt(JOptionPane.showInputDialog(
"Entre com a matrícula",
aluno.getNum_mat())));
}
}
}

/**
* Cadastrar um aluno
*
* @return Retorna um aluno
*/
private Aluno cadastrarAluno() {
Aluno aluno = null;
// Instancia o aluno
aluno = new Aluno();
// Setar seus Atributos
aluno.setAnoDeEntrada(JOptionPane
.showInputDialog("Entre com o ano de "+
"entrada"));
aluno.setNome(JOptionPane.showInputDialog("Entre com o "+
"nome"));
aluno.setAnoSaida(JOptionPane.showInputDialog("Ano "+
"Saida"));
aluno.setBolsista(Double.parseDouble(JOptionPane
.showInputDialog("Bolsista")));
aluno.setEstadoCivil(JOptionPane
.showInputDialog("Entre com o Estado Civil"));
/* Necessário fazer o typeCast, pois o atributo é do tipo
inteiro*/
aluno.setIdade(Integer.parseInt(JOptionPane
.showInputDialog("Entre com a idade")));
aluno.setNum_mat(Integer.parseInt(JOptionPane
.showInputDialog("Entre com a matrícula")));
return aluno;
}
}

7. Controle de Erro

Em Java, é possível controlar erro através das exceções. Podemos proteger


o código que está dentro da estrutura Try e caso ocorra alguma exceção, ele é
automaticamente desviado para cláusula catch.
import java.util.ArrayList;

public class AppExcecao {


public static void main(String[] args) {
try {
ArrayList<String> lista = new ArrayList();
lista.get(3);
} catch (Exception e) {
/* Ocorre quando é acessado um elemento inexistente */
System.out.println("Erro de "+
"ArrayIndexOutOfBoundsException");
}
}
}

Exercício sugerido para atividade extra


1. Nessa questão, iremos desenvolver um mini-sistema de compras. Para isso,
definiremos uma superclasse pessoa que herda dela duas subclasses: cliente,
funcionário. Construiremos também as classes: Produto, que conterá as características
dos produtos da loja; Compra que definirá o produto vendido, o cliente que comprou o
produto e o funcionário que efetuou a compra.
Siga os atributos e operações a seguir e construa as classes com seus respectivos
métodos. (Utilize Get e Set para todos os atributos das classes)

Pessoa
Atributos Operações
String nome Listar
String sexo
Int Codigo
*Cada pessoa deverá possuir um único código.

Cliente (Pessoa)
Atributos Operações
String Profissao Listar
Float Descontos
String tipoPessoa
* O cliente só terá desconto caso o tipoPessoa for “Jurídica”

Funcionário (Pessoa)
Atributos Operações
String cargo Listar
float salario

Produto
Atributos Operações
Integer codigo showProduto(exibe os valores dos
atributos da classe)
float preço
String descricao
String Marca
*Descrição: o nome do produto. Por Exemplo: descrição: = ‘Televisão’;
*Cada produto deverá possuir um único código.

Compra
Atributos Operações
Funcionário funcionário; showCompa (exibe o funcionário que
efetuou a compra, o cliente que comprou o
produto, os produtos que foram vendidos
e o preço total da compra com desconto)
Cliente cliente;
ArrayList<Produto> Produtos;
*Caso o cliente tenha algum desconto, exibir no showCompra o preço total com
desconto.
*Produtos: conterá todos os produtos que forem vendidos por um determinado
funcionário e comprados por um determinado cliente.

Aplicação
Atributos Operações
ArrayList <Funcionario> funcionarios = Cadastrar “N” funcionário
new ArrayList ()
ArrayList <Cliente> Cadastrar “N” Cliente
clientes = new ArrayList
ArrayList <Produto> Cadastrar “N” Compra
produtos = new ArrayList ()
ArrayList <Compra> Cadastre “N” Produtos
compras= new ArrayList()
Listar o funcionário que possua mais
venda (fazer busca pelo código)
Listar todos os produtos que foram
vendidos por um determinado funcionário
e essa venda tenha sido efetuada com
desconto.
Listar todos os produtos de uma
determinada marca.

*Só poderão ser cadastrados os produtos que estiverem na lista de produto


OBS. 1. Faz parte da questão a forma correta de definição de atributos e métodos nas
classes, e o melhor uso possível do paradigma Orientação Objeto.
2. Não se preocupem com a organização das telas.
3. Utilizem arrays para cadastros.

Dica:
• Ao cadastrar uma compra faça pesquisa na lista de funcionários (funcionário
que irá fazer a venda) pelo código e a mesma coisa para o cliente.
• Ao cadastrar os produtos de um cliente siga os seguintes passos:
1. Crie um método “escolheProduto” que retorne uma lista de produtos;
2. Dentro do método busque o produto que o cliente deseja pelo seu
código;
3. Lembre que só poderão ser cadastrados os produtos que estiverem na
lista de produtos.
• Lembre que será inserido o objeto Cliente, Funcionário e uma lista de objetos
do tipo produto na classe Compra.

UNIDADE II:

Nessa unidade iremos estudar uma parte importante do Java Enterprise


Edition, que é o Java Server Pages - JSP. Nessa tecnologia podemos desenvolver
páginas web com o uso de servidores e banco de dados.
No fim dessa unidade serão apresentados conceitos de framework, um
pouco mais sobre a J2EE e outras linguagens de desenvolvimento web, também,
muito utilizadas no mercado.

8. Conceitos básicos sobre Java Enterprise Edition

O J2EE é uma tecnologia que foi criada no fim dos anos noventa (com o
lançamento do JDK 1.2) e tem finalidade de desenvolver aplicações Web integradas
corporativamente.
Essa parte da família Java traz um conjunto de APIs e serviços para facilitar
o desenvolvimento dessas aplicações. As APIs a seguir são disponibilizadas pelo
Java Enterprise Edition através de sua especificação:
• Javax.transaction: controle de transação para qualquer recurso;
• Javax.activation: gerência do uso de recursos e de memória;
• Javax.sql: mecanismos de persistência de objetos;
• Javax.rmi: conexão para sistemas distribuídos;
• Javax.ejb: componentes de negócios distribuídos;
• Javax.security: implementação de segurança e controle de acesso de
usuários;
• Javax.servlet.jsp: desenvolvimento de componentes de controle para
aplicações Web;
• Javax.mail: desenvolvimento para acesso de e-mails;
• Javax.xml: desenvolvimento para controle de arquivos XML (Padrão
para criação de documentos com dados organizados de forma
hierárquica);
9. Servlet Containers e o Apache Tomcat

Para que as aplicações Web funcionem, é necessário um Servlet


Containers. O Container é o componente responsável para dar suporte para as
API`s de servlet e jsp (assunto será estudado mais na frente). Atualmente existem
diversos no mercado como: Tomcat, JBoss, IBM WebShere e outros.
As principais funções de um container são compilar os jsps em tempo de
execução e servir de servidor para aplicações web.
Neste Curso iremos utilizar a versão seis do Tomcat. O download deste
Container encontra-se no site http://tomcat.apache.org/. Vamos fazer o download
da versão seis na seção downloads.
Para instalar o Tomcat, basta descompactá-lo e escolher o diretório de
destino.
No Eclipse deve ser setado o caminho de origem do Tomcat como os passos
abaixo.
• Clique em Windows – Preferences;

• Clique em Server - Installed Runtimes;


• Clique em ADD;
• Escolha Apache Tomcat v6.0 e clique em Next;
• Sete o caminho do Tomcat em sua máquina e clique em Finish;
10. Criando a primeira aplicação web no Eclipse Europa

Nesse item vamos testar se as configurações do eclipse foram concluídas


com êxito. Para isso será criada uma aplicação “Hello World”:
• Clique em File – New – Project;
• Escolha a opção Web - Dynamic web project e clique em Next;

• Entre com o nome do projeto na caixa de texto Project Name;


• Escolha as opções Apache Tomcat v6.0 em Target Runtimes e
configurations e clique em finish;
• O projeto deverá ficar da seguinte maneira

• Clique em WebContent – New – File;


• Entre com o nome da página Web helloWorld.jsp na caixa de texto File
name e clique em finish;

• No arquivo helloWorld.jsp entre com o código;


<html>
<head>
<title>Olá Mundo...</title>
</head>
<body>
Olá Mundo!!!
</body>
</html>

• Para executar, aperte o botão direito do mouse em cima do arquivo


helloWorld.jsp e clique em Run As – Run on Server.

• Caso dê algum erro, procure a guia Servers, apague todos os servidores,


crie um novo, clicando com o botão direito do mouse e depois clique em
New – Server; (Além da guia Servers todo projeto tem uma pasta
Servers no Project Explorer)

11. Principais TAGs HTML (HyperText Markup Language)


Para desenvolver para Web, é necessário que o programador conheça
algumas Tags HTML, no intuito de a página poder interagir com o usuário. Através
de Tags é que inserimos caixas de texto, caixa de checagem, fontes, quebra de linha,
tabelas, formulários, botões e outras marcações HTML nas páginas Web.
Essas marcações consistem do sinal menor ‘<’ seguido pelo nome da
marcação e do sinal menor ‘>’.
Uma estrutura básica de um HTML seria a que segue.

<html>

<head>
<title>título do documento</title>
</head>

<body>
Corpo da mensagem (imagens, textos, links,..)
</body>

</html>

• Head - Contém informações sobre o documento e também a tag <title/>.


• Body - Tudo que estiver dentro dessa Tag será exibido na janela
principal do documento.
• Quebra de linha – Utiliza a tag <br/>.
• Parágrafo – Utilize a tag <p/>.
• Texto em Negrito – Utilize a tag <strong/>.
• Texto em Itálico – Utilize a tag <em/>.
• Links – Utilize a tag anchor <a/>.

<a href = "nome_da_pagina.jsp"> Utilizando Link<a/>

• Tabelas – Servem para organizar as informações na página. Utilize a tag


<table/> para criar a tabela e <tr/> para criar linha <td/> para coluna e
<th/> para cabeçalho.
<table border="1">
<tr>
<th> Cabeçalho Célula 1 </th>
<th> Cabeçalho Célula 2</th>
</tr>
<tr>
<td> Célula 1 </td>
<td> Célula 2 </td>
</tr>
</table>

• Formulários – São estruturas que permitem que o usuário submeta


dados. Utilizamos a tag <form/>, a qual contém também alguns atributos.
o Method: envia dados através de Get e Post. O primeiro Passa os
valores pela URL, ou seja, podemos ver as variáveis passadas na
Url da página destino definida no campo action. O segundo Passa
as variáveis de maneira transparente para o usuário. É o método
mais aconselhável.
o Action: Local onde os dados serão submetidos.
• Elementos do form:
• Input: Tem um atributo type, que pode receber seis tipos diferentes na
entrada de dados. Alguns exemplos.
<form action="teste.jsp" method="post">
Input text: <input type="text" name="texto1" value="texto"
size="10" />
Senha: <input type="password" name="texto2" size="10"
maxlength="10" />
<input type="hidden" name="oculto" value="escondido 1" /> <br>
Nome do arquivo: <input type="file" name="parquivo"
id="parquivo" />
</form>

• CheckBox (caixas de checagem): Como o nome já diz, caixa de


checagem com inúmeras opções.
<form action="teste.jsp" method="post">
<input type="checkbox" name="check1"/> opção 1 <br/>
<input type="checkbox" name="check2"/> opção 2 <br/>
<input type="checkbox" name="check3"/> opção 3 <br/>
</form>

• CompoBox: Lista de opções em uma caixa de texto.


<form action="teste.jsp" method="post">
<select name="lista" size="1">
<option value="">-- escolha --</option>
<option value="1">Um</option>
<option value="2">Dois</option>
</select>
</form>
• Image: Adicionar uma imagem no documento.
<form action="teste.jsp" method="post">
<input type="image" name="imagem"
src="img/icone.gif"/> Imagem
</form>
• input type="submit|reset|button": Submit, envia dados ao servidor.
Reset, limpar o formulário. Button, usados para fazer chamadas de
scripts.
<form action="teste.jsp" method="post">
<input type="submit" name="botao1" value="Input Enviar"/>
<input type="reset" value="Input Limpar"/>
<input type="button" value="Input Cliente"/>
</form>

12. JSP – Java Server Pages

JSP é uma página html comum que contém código Java e possui extensão
jsp.
Vamos criar um jsp. Com a declaração de uma variável do tipo String.

<html>
<body>
<%
String mensagem = "Bem vindo!";
%>
</body>
</html>

Para escrever código Java nas páginas, basta escrever entre as tags: <% e
%>. Esse código é chamado de scriptlet.
Para escrever algo na tela, podemos fazer de duas formas diferentes:
<html>
<body>
<%
String mensagem = "Bem vindo!";
%>
Duas formas diferente na hora de imprimir:<br>
<%
out.println(mensagem);
%><br>
<%=mensagem %><br>
<%
System.out.println("Tudo foi executado!");
%>

</body>
</html>

Para facilitar o desenvolvimento WEB, a tecnologia JSP disponibiliza


conjunto de objetos que podem ser usados dentro de um JSP sem a necessidade de
declaração:
• Session: Define uma referência do objeto do tipo
javax.servelet.http.HttpSession, que representa a sessão do usuário, onde,
programaticamente, podemos armazenar conteúdos de dados somente
visíveis para um usuário.
• Request: Define uma referência de objeto do tipo
javax.servelet.http.httpServeletRequest que representa a requisição do
usuário, de que, programaticamente, podemos recuperar dados enviados pelo
usuário.
• Response: Define uma referência de objeto do tipo
javax.servelet.http.HttpServeletResponse, que representa a resposta ao
usuário, em que, programaticamente, podemos inserir conteúdos de texto
como resultado do processamento.
• Application: Define uma referência de objeto do tipo
javax.servelet.Servelet.Context, que representa o contexto da aplicação, em
que, programaticamente, podemos armazenar conteúdos de dados que serão
compartilhados e visíveis a todas as sessões da aplicação.
• Exception: Define uma referência de objeto do tipo java.lang.throwable, que
representa uma exceção e está presente nas páginas de erro.
• Out: Define uma referência de objeto do tipo javax.servelet.jsp.JspWriter,
que representa a saída do conteúdo de texto do objeto de resposta(response).
• Config: Define uma referência de objeto do tipo
javax.servelet.ServeletConfig, que representa o objeto de configuração do
Servelet gerado pelo JSP e pode ser configurado pelo descritor de publicação
(deploy) web.xml.
• pageContext: Define uma referência de objeto do tipo
javax.servelet.jsp.PageContext, que encapsula os objetos existentes durante
uma única requisição.

Para entendermos melhor os objetos intrínsecos do JSP, vamos analisar o


exemplo abaixo de sessão. (Para os exemplos a seguir crie um novo projeto no
eclipse e teste cada JSP)

session.jsp (Mais a frente veremos exemplos mais complexas de sessão).

<%@ page info="session" buffer="2kb" session="true" %>


<html>
<head>
<title>
Teste dos objetos intrínsecos do JSP
</title>
</head>
<body>
<% if (session.isNew()){ %>
Nova sessão do usuário <%= session.getId() %><br>
<% } else { %>
Mesma Sessão <%= session.getId() %> <br>
<% } %>
Info do Server <%= application.getServerInfo() %>
</body>
</html>

As diretivas de compilação (<% page ...%>) definem informações que


interferem no funcionamento do JSP dentro do WEB Container. Os principais
elementos são:
• Import: Define um conjunto de classes ou pacotes. EX.: <%@ page
import="java.util.List"%>
• Session: Este valor define que o JSP tem acesso a um objeto de sessão. O
valor pode ser true (default) ou false
• Buffer: Define o tamanho do buffer que será usado para devolver o conteúdo
gerado ao cliente. O valor pode ser none ou nkb e o padrão é 8 kb. Ex.:
buffer=“8kb”
• Info: Define uma informação textual para o JSP, geralmente, uma descrição.
• erroPage: Este atributo indica um outro JSP que será responsável por exibir
as exceções de Runtime deste JSP. Ex.: erroPage=“erro.jsp” ou
erroPage=“error/formErrors.jsp”
• IsErroPage: Define que o JSP é uma página que exibe exceções. O valor
padrão é false, porém, quando está em true, significa que o objeto intrínseco
exception será preenchido com uma exceção, se ela acontecer.
• pageEncoding: Define a página de código dos caracteres usados na saída de
dados. O padrão é ISSO-8859-1.

Para entendermos melhor as diretivas de compilação do JSP, vamos analisar


os exemplos.
Criaremos um index com cabeçalho, banner e rodapé, de forma que seja
desenvolvido um cabeçalho.jsp, que servirá de cabeçalho para index.jsp, o
banner.jsp, que servirá de redirecionamento de mensagens e o rodapé.jsp, que será
o rodapé do index.jsp.
index.jsp
<%@ page info="index" session="false" buffer="1kb" %>
<html>
<jsp:include page="cabecalho.jsp" />
<body>
<br>
<jsp:include page="banner.jsp">
<jsp:param name="mensagem" value="Bem vindo ao meu WEB Site"
/>
</jsp:include>
<br>
<br>
<jsp:include page="rodape.jsp" />
</body>
</html>

cabecalho.jsp
<%@ page session="false" buffer="1kb" %>
<head>
<title>
Meu Web Site
</title>
</head>

banner.jsp
<%@ page session="false" buffer="1kb"%>
<h1> <%= request.getParameter("mensagem") %> </h1>

rodape.jsp
<%@ page session="false" buffer="1kb" %>
<%@ page import="java.util.Date" %>
Hora atual : <%= new Date().toString() %><br>
<h6> Tecnologia JSP </h6>

Os JSP’s podem redirecionar uma requisição para outro componente.


Fornecendo mecanismos de navegação através de ação.
<jsp:forward page=“page.jsp”/>)
Também podemos adicionar parâmetros no objeto Request.
<jsp:param name=“parametro” value=“valor”/>.

Segue exemplo de redirecionamento de requisição e trabalho com


navegação, que é um menu no qual faz passagem de parâmetro para um JSP de
controle.
menu.jsp
<%@ page info="menu" session="false" buffer="1kb" %>
<html>
<head>
<title>
Menu
</title>
</head>
<body>
<A href="controle.jsp?pagina=cadastro"> Cadastro </A> <br>
<A href="controle.jsp?pagina=consulta"> Consulta </A> <br>
</body>
</html>

controle.jsp
<%@ page info="controle" session="false" buffer="1kb" %>
<% String acao = request.getParameter("pagina");
if (acao.equalsIgnoreCase("cadastro")){ %>
<jsp:forward page="cadastro.jsp" />
<% } else if(acao.equalsIgnoreCase("consulta")){ %>
<jsp:forward page="consulta.jsp" />
<% } else { %>
<jsp:forward page="menu.jsp" />
<% } %>

cadastro.jsp
<%@ page info="menu" session="false" buffer="1kb" %>
<html>
<head>
<title>
Cadastro
</title>
</head>
<body>
CADASTRO DO MEU SITE
<br><br>
<A href="menu.jsp"> Menu </A> <br>
</body>
</html>

consulta.jsp
<%@ page info="menu" session="false" buffer="1kb" %>
<html>
<head>
<title>
Consulta
</title>
</head>
<body>
Consulta DO MEU SITE
<br><br>
<A href="menu.jsp"> Menu </A> <br>
</body>
</html>
No JSP podemos recuperar um parâmetro enviado por formulários ou URLs.
Esse objeto é o request.
<% string valor = request.getParameter(“parametro”) %>

Segue exemplo de conversão de valores em JSP que recupera dados de um


formulário.

conversor.jsp
<%@ page info="menu" session="false" buffer="2kb" errorPage="erro.jsp"
%>
<html>
<head>
<title>
Conversor de moedas Utilizando Scriplet
</title>
</head>
<body>
<%
double calculo = 0 ;
if(request.getParameter("calcular") != null){
String valor = request.getParameter("valor");
String taxa = request.getParameter("taxa");
if (valor != null && taxa != null){
out.println("Valor: "+valor);
out.println("<br>Taxa: "+taxa);
double val = Double.parseDouble(valor);
double tax = Double.parseDouble(taxa);
calculo = val * tax;
out.println("<br> Valor Convertido: "+calculo);
}
}
%>
<form name = "CALCULADORA" ACTION="conversor.jsp"
METHOD="POST">
valor: <input type="TEXT" name="valor"><br>
Taxa: <input type="TEXT" name="taxa"><br>
<input type="Submit" name="calcular" value="Calcular">
</form>
</body>
</html>

13. JDBC - java.sql - acesso a banco de dados (MYSQL)

JDBC é uma API utilizada para acessar qualquer Sistema Gerenciador de


Banco de Dados (SGBD). Com o JDBC, é possível enviar instruções SQL para
qualquer SGBD, permitindo que as aplicações sejam independentes de banco de
dados.
Aplicação

JDBC

Driver Driver Driver


PostgreSQL SQL Server MySql

PostgreSQL SQL Server MySql

Imagem 13.1 Ilustra o esquema de uma arquitetura de uma aplicação


utilizando JDBC.

Nesse material utilizaremos o MySql como SGBD para nossas aplicações


JSP, porque é free e referência no mercado. Os passos a seguir exibem como
encontrar e instalar o MySql e ambiente para modelagem de dados.
• Faça o download da versão no-install do mysql no site
www.mysql.com.
• Essa versão não precisa instalar.
• Para iniciar o MySql, é só rodar o arquivo “mysqld-nt”, que se
encontra na pasta BIN da versão “no-install”.
• Para criar um Diagrama de entidade relacionamento e testar se o
MySql está funcionando, devemos fazer o download do DBDesigner
no site http://fabforce.net/downloads.php.
• Instale o DBDesigner e abra o arquivo DBDesigner4.exe.
• Crie uma conexão no DBDesigner, click em “new Database
Connection”.
• No campo “Connection Name” entre com o nome da conexão; Drive:
MySql; HostName: localhost; DataBase Name: test(default do
mySql); username: root e password fica vazio.

• Clique em NewTable para criar uma tabela na base de dados e entre


com os seguintes dados:
• Depois de criada a tabela, clique em DataBase synchronisation para
que seja concectada com o MySql, a qual é adicionada na base de
dados.

Para uma aplicação acessar algum SGBD, é necessário que o programador


obtenha a API JDBC implementada para determinado SGBD.
Para realizar uma conexão, é necessário 4 parâmetros:
• Driver Æ classe, que representa o driver do banco;
• URL Æ url, que define a localização do banco, como também o
database a ser acessado (semelhante à URL de Internet);
• Usuário Æ usuário para autenticação;
• Senha Æ senha para reconhecimento do usuário.

No caso do MySql utilizaremos os seguintes parâmetros:


• Driver = com.mysql.jdbc.Driver;
• URL= jdbc:mysql://localhost/test;
• Usuário =root;
• Senha =;
• Importe o Driver do banco (MySQL Connector) no projeto que
encontraremos para download no próprio site do MySql -
http://dev.mysql.com/downloads/;
• Para importar o Driver: Clique com o botão direito do mouse em
cima do projeto, depois properties – Java Build Path e, por fim, Add
JARS;

• Escolha a opção mysql-connector-java-5.0.3-bin.jar e clique OK;


Segue código Java para conectar com o MySql; para testar os códigos, crie
um novo projeto no eclipse, utilizando Console, copie e cole o driver do MySql
(mysql-connector-java-5.0.3-bin) na pasta do projeto Java e dê uma refresh no
projeto do eclipse.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class jdbc {


public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost/test", "root",
"");
System.out.println("Conectado!");
con.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

Existem duas classes que podem ser utilizadas para realizar consultas:
– Java.sql.Statement
• Sentenças simples que não possuem parâmetros;
• Ex: select * from usuario;
– Java.sql.PreparedStatement
• São sentenças que permitem passagem de parâmetros para o
comando sql;
• Permite agilizar o processo de execução através de um recurso que
deixa o comando sql pré-compilado.

Após a execução do comando de consulta, o resultado é acessado em uma


outra classe chamada java.sql.ResultSet. O ResultSet possui métodos para obter o
dado da consulta de acordo com o seu tipo.

Ex: ResultSet rs;


rs.getString(“Nome_Coluna”);
rs.getInt(“Nome_coluna”);
rs.getDate(“Nome_coluna”);

Segue exemplo de consulta utilizando Statement; cuidado com os imports,


pois devemos importar java.sql e não java.MySql.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class jdbc {


public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost/test",
"root", "");
System.out.println("Conectado!");

// criando a sentença de execução SQL


Statement stmt = con.createStatement();
// Comando sql
String sql = "select * from usuario order by nome";
// Executando o comando de consulta
ResultSet rs = stmt.executeQuery(sql);
if (rs.next()) {
System.out.println("Possui resultado!");
} else {
System.out.println("Não possui resultado!");
}
con.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}

}
}

Exemplo de consulta utilizando PreparedStatement.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class jdbc {


public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost/test",
"root", "");
System.out.println("Conectado!");
// Comando sql
String sql = "select * from usuario where codigo=?";
// criando a sentença de execução SQL
PreparedStatement ps= con.prepareStatement(sql);
// passando o parâmetro para o comando sql. O valor 1
é a posição da ‘?’ e o 10 o valor que deve ser colocado no lugar;
ps.setInt(1, 10);
// Executando o comando de consulta
ResultSet rs = ps.executeQuery();
if (rs.next()) {
System.out.println("Possui resultado!");
} else {
System.out.println("Não possui resultado!");
}
con.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}

}
}
Para exibir os dados, a consulta pode retornar várias linhas, logo, é suficiente
trocar o if pelo while, que exibirá as informações de todas as linhas.

Ex:
ResultSet rs = ps.executeQuery();
while (rs.next()) {
System.out.println(rs.getString("nome"));
}

A inserção de dados é semelhante à consulta, sendo preciso apenas a


modificação do comando sql e o método que deve ser chamado. Para inserir na base:

Insert into TABELA (campo1, campo2, ...) values (valor1, valor2, ...)

O método que deve ser executado é:

executeUpdate();

Segue exemplo de inserção.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class jdbc {


public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost/test",
"root", "");
System.out.println("Conectado!");
/* Comando sql. O campo código é auto incremento, não
necessitando ser informado no comando de insert */
String sql = "insert into usuario (nome, login,
senha) values (?, ?, ?)";
// criando a sentença de execução SQL
PreparedStatement ps= con.prepareStatement(sql);
// passando o parâmetro
ps.setString(1, "Fábio Coriolano");
ps.setString(2, "FCoriolano");
ps.setString(3, "1234");
/* Executando o comando de inserção e retorna o
número de linhas afetadas pelo comando */
int valor = ps.executeUpdate ();
con.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}

}
}

A exclusão é semelhante à inserção, sendo necessária apenas a modificação


do comando sql.
• Para excluir algo da base:

Delete from TABELA [ where campo1=valor1 and campo2=valor2]

• Igualmente ao insert, o método que deve ser executado é :

executeUpdate();

Segue exemplo para excluir uma informação do banco de dados.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class jdbc {


public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost/test",
"root", "");
System.out.println("Conectado!");

// Comando sql de exclusão.


String sql = "delete from usuario where codigo=?";
// criando a sentença de execução SQL
PreparedStatement ps= con.prepareStatement(sql);
/* passando o parâmetro. Primeiro parâmetro equivale
a primeira interrogação e o segundo ao valor que será substituído */
ps.setInt(1, 1);
/* Executando o comando de exclusão e retorna o
número de linhas afetadas pelo comando */
int valor = ps.executeUpdate ();

con.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}

}
}

A alteração de uma informação é semelhante à exclusão, sendo necessária


apenas a modificação do comando SQL.
• Para alterar algo da base de dados:

update TABELA set campo1=valor1, campo2=valor2, ... where


campo3=valor3
• Para o update, o método que deve ser executado é:

executeUpdate();

Segue código para alterar uma determinada informação.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class jdbc {


public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost/jdbc", "root",
"");
System.out.println("Conectado!");

// Comando sql de alteração.


String sql = "update usuario set nome=?, login=?
where codigo=?";
// criando a sentença de execução SQL
PreparedStatement ps = con.prepareStatement(sql);
// passando o parâmetro
ps.setString(1, "Fábio Sobreira Coriolano");
ps.setString(2, "Fcori");
/* Primeiro parâmetro equivale a terceira
interrogação e o segundo o
valor que será subistituido pela interrogação*/
ps.setInt(3, 1);
/* Executando o comando de alteração e retorna o
número de linhas
afetadas pelo comando */
int valor = ps.executeUpdate();

con.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}

}
}

14. Padrão DAO – Data Access Object

O DAO é um padrão para persistência e consulta de informações nos bancos


de dados e serve para retirar o código SQL das páginas JSP, deixando, assim, os
códigos mais organizados e com fácil acesso.
Os desenvolvedores utilizam bastante esse padrão, que inclui tipicamente
métodos para inserir, selecionar, atualizar e excluir. É necessário que se construa um
DAO para cada classe de objeto da aplicação.
Para facilitar a conexão com banco de dados, construiremos uma classe
connectionFactory, que servirá para fazer conexão com banco de dados.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionFactory {


private static final String URL = "jdbc:mysql://localhost/test";

private static final String DRIVER = "com.mysql.jdbc.Driver";

private static final String USUARIO = "root";

private static final String SENHA = "";

public static Connection getConnection() throws SQLException {


try {
Class.forName(DRIVER);
System.out.println("Conectando ao banco");
return DriverManager.getConnection(URL, USUARIO,
SENHA);
} catch (ClassNotFoundException e) {
throw new SQLException(e.getMessage());
}
}
}
15. Construindo um projeto web passo-a-passo utilizando JSP, DAO e MYSQL
Nesse tópico desenvolveremos um projeto WEB passo-a-passo, utilizando
JSP, DAO e MYSQL.
1. Faça o download do eclipse MySql versão “no-install”, DBDesigner, mysql-
connector-java-5.0.3-bin (drive do mysql).
2. Setar o caminho do TOMCAT no eclipse
2.1 Clique em Window preferences
2.2 Clique em Server
2.2.1 Clique em Installed Runtimes
2.3 Clique em ADD
2.4 Escolha Apache Tomcat v6.0 e clique em Next
2.5 Sete o caminho do Tomcat em sua máquina e clique em Finish
3. Instale o DBDesigner.
4. Inicie o Mysql – Para iniciar o MySql é só rodar o arquivo “mysqld-nt”, que se
encontra na pasta BIN da versão “no-install”.
5. Abra o eclipse e crie um projeto web.
5.1 File – Project – Web – Dynamic Web Project
6. Todo código Java deverá ser criado dentro do src.
7. Copie e cole o arquivo “mysql-connector-java-5.0.3-bin”, que é o driver do
mysql, na pasta lib que está dentro da pasta webContent – Web –INF.
8. Atualize o Projeto do eclipse
9. Sua aplicação deverá estar conforme a Ilustração:
10. Dentro de src crie uma package chamada br.com.NomeDoProjeto.JDBC.
Package é uma pasta que contém classes; para criá-la, é só clicar com o botão
direito do mouse em cima de src e escolher a opção new – package.
11. Insira a classe chamada ConnectionFactorynessa Package.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionFactory {


private static final String URL =
"jdbc:mysql://localhost/test";

private static final String DRIVER =


"com.mysql.jdbc.Driver";

private static final String USUARIO = "root";

private static final String SENHA = "";

public static Connection getConnection() throws


SQLException {
try {
Class.forName(DRIVER);
System.out.println("Conectando ao banco");
return DriverManager.getConnection(URL,
USUARIO, SENHA);
} catch (ClassNotFoundException e) {
throw new SQLException(e.getMessage());
}
}
}

12. Abra o DBDesigner.


13. Clique em DataBase – Connect To DataBase
14. Escolha MySQL – Localhost e clique em “new Database Connection”.
15. No campo “Connection Name” entre com o nome da conexão; Drive: MySql;
HostName: localhost; DataBase Name: test(default do mySql); username: root e
password fica vazio.

16. Click em NewTable para criar uma tabela na base de dados e entre com os
seguintes dados:
17. Depois de criada a tabela, clique em DataBase - DataBase synchronisation.
18. Volte para o eclipse e dentro de src, crie uma package chamada:
br.com.NomeDoProjeto.Modelo.
19. Dentro da package modelo, crie uma classe chamada Aluno, como abaixo.

public class Aluno {


private String nome;
private String sexo;
private int idade;
private String curso;

public String getCurso() {


return curso;
}
public void setCurso(String curso) {
this.curso = curso;
}
public int getIdade() {
return idade;
}
public void setIdade(int idade) {
this.idade = idade;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}

20. Na pasta src crie uma package chamada br.com.NomeDoProjeto.Dao.


21. Dentro da package, crie uma classe AlunoDao, como abaixo:

import java.sql.Connection;
import java.sql.SQLException;
import br.com.NomeDoProjeto.JDBC.ConnectionFactory;

public class AlunoDao {


// conexão com o banco de dados
private Connection connection;

// construtor que recebe a conexão


public AlunoDao(Connection con) {
this.connection = con;
}

public AlunoDao() throws SQLException {


this.connection = ConnectionFactory.getConnection();
}
}

22. Dentro da classe AlunoDao, vamos criar um método cadastraAluno e


listaAluno.

public void cadastraAluno(Aluno aluno) throws Exception {


// prepared statement para inserção
PreparedStatement stmt = this.connection
.prepareStatement("insert into
aluno(nome,sexo,idade,curso) values (?, ?, ?, ?)");

// seta os valores
stmt.setString(1, aluno.getNome());
stmt.setString(2, aluno.getSexo());
stmt.setInt(3, aluno.getIdade());
stmt.setString(4,aluno.getCurso() );

// executa
stmt.execute();
stmt.close();

public List<Aluno> listaAluno() throws SQLException {


String sql = "select * from aluno";
PreparedStatement stmt =
this.connection.prepareStatement(sql);
ResultSet rs = stmt.executeQuery();
// Criando uma lista de aluno
List<Aluno> list = new ArrayList<Aluno>();
//Criando um aluno
//Aluno aluno = new Aluno(); ERRO AQUI
//Fazendo uma laco para setar os atributos de aluno
while (rs.next()) {
Aluno aluno = new Aluno();
aluno.setNome(rs.getString("nome"));
aluno.setIdade(rs.getInt("idade"));
aluno.setSexo(rs.getString("sexo"));
aluno.setCurso(rs.getString("curso"));

// adicionando o objeto à lista


list.add(aluno);
}

rs.close();
stmt.close();

return list;
}

23. Dentro da pasta WebContent, crie um arquivo chamado testando.jsp. (No código
abaixo cuidado com a nomenclatura dos imports, pois nele estarão as nomes das
Package que criaremos e outras bibliotecas que a aplicação utiliza)

<%@ page import="java.util.List"%>


<%@ page import="br.com.Nome_do_Projeto.dao.*"%>
<%@ page import="br.com.Nome_do_Projeto.*"%>

<html>
<%
// Adicionando um aluno
Aluno aluno = new Aluno();
aluno.setNome("fabio");
aluno.setIdade(20);
aluno.setSexo("m");
aluno.setCurso("web");
AlunoDao dao = new AlunoDao();
dao.cadastraAluno(aluno);
// criando uma lista de aluno
List<Aluno> lista;
// Recebendo uma lista de aluno
lista = dao.listaAluno();
// Exibindo no console o nome de todos os aluno
for (int i = 0; i < lista.size(); i++) {
%>
<li><%=lista.get(i).getNome()%></li>
<%}%>

</html>

24. Execute o projeto – Clique com o botão direito do mouse no jsp e depois clique
em Run As - Run on Server.
25. Escolha a opção tomcat 6 e depois clique em finish.

Exercício de fixação
1. Desenvolva uma aplicação web que resolva o seguinte problema:

• Uma faculdade precisa matricular os alunos na faculdade;


• Faça uma aplicação web para:
¾ Inserir, excluir e alterar um Aluno ;
¾ Faça uma tela para pesquisar Aluno por nome;
• Segue exemplo resolvido;
• Crie uma Package chamada br.comWebJsp.Modelo;
• Dentro da Package, crie uma classe chamada Aluno, a qual deve conter todos
os atributos de um aluno;

public class Aluno {


private String nome;
private int codigo;
private String sexo;
private int idade;
private String curso;

public String getCurso() {


return curso;
}
public void setCurso(String curso) {
this.curso = curso;
}
public int getIdade() {
return idade;
}
public void setIdade(int idade) {
this.idade = idade;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
}
• Crie uma Package chamada br.comWebJsp.JDBC.
• Dentro da Package, construa uma classe chamada ConnectionFactory.

package br.com.WebJsp.JDBC;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionFactory {


private static final String URL = "jdbc:mysql://localhost/test";

private static final String DRIVER = "com.mysql.jdbc.Driver";

private static final String USUARIO = "root";

private static final String SENHA = "";

public static Connection getConnection() throws SQLException {


try {
Class.forName(DRIVER);
System.out.println("Conectando ao banco");
return DriverManager.getConnection(URL, USUARIO,
SENHA);
} catch (ClassNotFoundException e) {
throw new SQLException(e.getMessage());
}
}
}

• No DBDesigner, crie a tabela Aluno conforme imagem a seguir (lembre de


conectar o Mysql e sincronizar a tabela a uma base de dados).
• Crie uma Package chamada br.com.WebJsp.DAO.
• Dentro da Package, construa uma classe chamada AlunoDAO, a qual
possuirá todos os códigos SQL possíveis.

package br.com.WebJsp.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import br.com.WebJsp.JDBC.ConnectionFactory;
import br.com.WebJsp.Modelo.Aluno;

public class AlunoDao {


// conexão com o banco de dados
private Connection connection;

// construtor que recebe a conexão


public AlunoDao(Connection con) {
this.connection = con;
}

public AlunoDao() throws SQLException {


this.connection = ConnectionFactory.getConnection();
}

/**
* Cadastra um aluno no banco
*
* @param aluno -
* Aluno passado por Parâmetro
* @throws Exception
*/
public void cadastraAluno(Aluno aluno) throws Exception {
// prepared statement para inserção
PreparedStatement stmt = this.connection
.prepareStatement("insert into
aluno(nome,sexo,idade,curso) values (?, ?, ?, ?)");

// seta os valores
stmt.setString(1, aluno.getNome());
stmt.setString(2, aluno.getSexo());
stmt.setInt(3, aluno.getIdade());
stmt.setString(4, aluno.getCurso());

// executa
stmt.execute();
stmt.close();

/**
* Altera um aluno passado por Parâmetro
*
* @param aluno -
* Aluno passado por Parâmetro
* @throws Exception
*/
public void alteraAluno(Aluno aluno) throws Exception {
// prepared statement para inserção
PreparedStatement stmt = this.connection
.prepareStatement("update aluno set
nome=?,sexo=?,idade=?,curso=? where codAluno=?");

// seta os valores
stmt.setString(1, aluno.getNome());
stmt.setString(2, aluno.getSexo());
stmt.setInt(3, aluno.getIdade());
stmt.setString(4, aluno.getCurso());
stmt.setInt(5, aluno.getCodigo());
// executa
stmt.executeUpdate();
stmt.close();

/**
* Retorna uma lista de todos os alunos contidos no banco
*
* @return
* @throws SQLException
*/
public List<Aluno> listaAluno() throws SQLException {
String sql = "select * from aluno";

PreparedStatement stmt =
this.connection.prepareStatement(sql);
ResultSet rs = stmt.executeQuery();
// Criando uma lista de aluno
List<Aluno> list = new ArrayList<Aluno>();
// Fazendo uma laço para setar os atributos de aluno
while (rs.next()) {
// Criando um aluno
Aluno aluno = new Aluno();

aluno.setCodigo(rs.getInt("codAluno"));
aluno.setNome(rs.getString("nome"));
aluno.setIdade(rs.getInt("idade"));
aluno.setSexo(rs.getString("sexo"));
aluno.setCurso(rs.getString("curso"));

// adicionando o objeto à lista


list.add(aluno);
}

rs.close();
stmt.close();

return list;
}

/**
* Retorna um aluno cujo código foi passado por parâmetro
*
* @param cod -
* codigo do aluno passado por Parâmetro
* @return
* @throws SQLException
*/
public Aluno getAluno(int cod) throws SQLException {

PreparedStatement stmt = this.connection


.prepareStatement("select * from aluno where
aluno.codAluno= "
+ cod);
ResultSet rs = stmt.executeQuery();

// criando o objeto aluno


Aluno aluno = new Aluno();

rs.next();

aluno.setNome(rs.getString("nome"));
aluno.setIdade(rs.getInt("idade"));
aluno.setSexo(rs.getString("sexo"));
aluno.setCurso(rs.getString("curso"));
aluno.setCodigo(rs.getInt("codAluno"));

rs.close();
stmt.close();

return aluno;
}

/**
* Retorna uma coleção de alunos cujo nome foi passado por
*parâmetro
* @param cod -
* código do aluno passado por Parâmetro
* @return
* @throws SQLException
*/
public List<Aluno> getAluno(String nome) throws SQLException {

PreparedStatement stmt = this.connection


.prepareStatement("select * from aluno where
aluno.nome LIKE '"
+ nome + "%'");

ResultSet rs = stmt.executeQuery();

// Criando uma lista de aluno


List<Aluno> list = new ArrayList<Aluno>();
// Fazendo uma laco para setar os atributos de aluno

while (rs.next()) {
// Criando um aluno
Aluno aluno = new Aluno();

aluno.setCodigo(rs.getInt("codAluno"));
aluno.setNome(rs.getString("nome"));
aluno.setIdade(rs.getInt("idade"));
aluno.setSexo(rs.getString("sexo"));
aluno.setCurso(rs.getString("curso"));

// adicionando o objeto à lista


list.add(aluno);
}

rs.close();
stmt.close();

return list;
}

/**
* Deleta um aluno cujo código foi passado por Parâmetro
*
* @param cod -
* código do aluno passado por Parâmetro
* @throws Exception
*/
public void deleteAluno(int cod) throws Exception {
// prepared statement para exclusão
PreparedStatement stmt = this.connection
.prepareStatement("delete from aluno where
aluno.codAluno="
+ cod);
// executa
stmt.execute();
stmt.close();
}
}

• Agora vamos desenvolver os JSP’s.


• Crie uma página chamada index.jsp e controle.jsp, a qual irá fazer chamada
para outras três páginas (addAluno.jsp, consultaAluno.jsp e
pesquisaAluno.jsp).
index.jsp
<%@ page info="index" session="false" buffer="1kb" %>
<html>
<head>
<title>
Menu
</title>
</head>
<body>
<A href="controle.jsp?pagina=cadastro"> Cadastro </A> <br>
<A href="controle.jsp?pagina=consulta"> Consulta </A> <br>
<A href="controle.jsp?pagina=Pesquisa"> Pesquisa </A> <br>
</body>
</html>
controle.jsp
<%@ page info="controle" session="false" buffer="1kb" %>
<% String acao = request.getParameter("pagina");
if (acao.equalsIgnoreCase("Cadastro")){ %>
<jsp:forward page="addAluno.jsp" />
<% } else if(acao.equalsIgnoreCase("Consulta")){ %>
<jsp:forward page="consulta.jsp" />
<% } else if(acao.equalsIgnoreCase("Pesquisa")){ %>
<jsp:forward page="pesquisa.jsp" />
<% } else { %>

<jsp:forward page="index.jsp" />


<% } %>
• Agora, vamos desenvolver uma página para adicionar os alunos no banco de
dados. O JSP fará chamada à classe Aluno e ao AlunoDAO. Esta para
adicionar os dados no banco e aquela para guardar as informações na
memória.
addAluno.jsp
<%@ page import="java.util.List"%>
<%@ page import="br.com.WebJsp.dao.*"%>
<%@ page import="br.com.WebJsp.Modelo.*"%>
<%@ page import="br.com.WebJsp.JDBC.*"%>

<html>
<head>
<title>
Adicionando e Consultando no Banco Utilizando Scriplet
</title>
</head>
<body>
<%
AlunoDao dao = new AlunoDao();
if(request.getParameter("add") != null){
// Adicionando um aluno
Aluno aluno = new Aluno();
aluno.setNome(request.getParameter("nome"));

aluno.setIdade(Integer.parseInt(request.getParameter("idade")));
aluno.setSexo(request.getParameter("sexo"));
aluno.setCurso(request.getParameter("curso"));
dao.cadastraAluno(aluno);
}
%>
<form name = "Add" ACTION="addAluno.jsp" METHOD="POST">

nome: <input type="TEXT" name="nome"><br>

sexo: <input type="TEXT" name="sexo"><br>

curso:<input type="TEXT" name="curso"><br>

idade:<input type="TEXT" name="idade"><br>


<br>
<input type="Submit" name="add" value="Adicionar">
</form>
<br><br>
<A href="index.jsp"> Menu </A> <br>
</body>
</html>

• Agora, vamos construir um JSP para fazer consulta e exclusão de dados.


Para excluir determinada informação, utilizaremos checkBox - caso o
usuário o acione e clique no botão delete, será chamado o código para
deletar um registro no banco de dados. Para isso, o JSP fará chamada ao
método deleteAluno, que se encontra na classe AlunoDAO. Ainda nessa
página, é passado um link com o código do aluno como parâmetro para fazer
chamada à página alterarAluno.jsp; através do parâmetro é acionado um
código para alterar os dados do aluno.
consulta.jsp
<%@ page info="consulta" session="false" buffer="1kb" %>
<%@ page import="java.util.List"%>
<%@ page import="br.com.WebJsp.dao.*"%>
<%@ page import="br.com.WebJsp.Modelo.*"%>
<%@ page import="br.com.WebJsp.JDBC.*"%>

<html>
<head>
<title>
Consulta
</title>
</head>
<body>
Consulta
<%
// Caso o usário clique no botão remover
if(request.getParameter("remove") != null){
//Cria a instância de uma AlunoDao
AlunoDao dao = new AlunoDao();
//Caso tenha algum checkBox selecionado
if(request.getParameterValues("alunos") != null){
//O vetor de alunos recebe todos os códigos dos alunos selecionados
String alunos[] =
request.getParameterValues("alunos");
//É feito um laço com todos os alunos selecionados
for (int i = 0; i < alunos.length; i++) {
//Cada código é passado por parâmetro para ser deletado
dao.deleteAluno(Integer.parseInt(alunos[i]));
}
}
}
%>
<br><br>
<form name = "consulta" ACTION="consulta.jsp" METHOD="POST">
<%
AlunoDao dao = new AlunoDao();
// criando uma lista de aluno
List<Aluno> lista;
// Recebendo uma lista de aluno
lista = dao.listaAluno();
// Exibindo no console o nome de todos os aluno
for (int i = 0; i < lista.size(); i++) {
//CheckBox que possui o código do aluno no seu value
%>

<input type="checkbox" name="alunos" value=


"<%=lista.get(i).getCodigo()%>" />
<!-- link para alteraAluno.jsp que passa o código do
aluno como parâmetro -->
<A href=
"alteraAluno.jsp?cod=<%=lista.get(i).getCodigo()%>">
<%=lista.get(i).getNome()%> </A> <br>

<%}%>
<br> <br>
<input type="Submit" name="remove" value="Delete">
</form>
<br><br>
<A href="index.jsp"> Menu </A> <br>
</body>
</html>
• Nessa página, iremos alterar os dados do aluno, lembrando que esse JSP
recebe um parâmetro (código do aluno) de consulta.jsp; através dele,
podemos alterar os dados por meio de um UpDate, o qual se encontra no
método alteraAluno da classe AlunoDao.
alteraAluno.jsp
<%@ page import="java.util.List"%>
<%@ page import="br.com.WebJsp.dao.*"%>
<%@ page import="br.com.WebJsp.Modelo.*"%>
<%@ page import="br.com.WebJsp.JDBC.*"%>

<html>
<head>
<title>
Adicionando e Consultando no Banco Utilizando Scriplet
</title>
</head>
<body>
<%
//É acionado quando o usuário clica no botão alterar
if(request.getParameter("alterar") != null){
//Instância do AlunoDao
AlunoDao dao = new AlunoDao();
// Instância de um aluno
Aluno aluno = new Aluno();
//Setando as novas informações do aluno
aluno.setNome(request.getParameter("nome"));
aluno.setIdade(Integer.parseInt(request.getParameter("idade")));
aluno.setSexo(request.getParameter("sexo"));
aluno.setCurso(request.getParameter("curso"));

aluno.setCodigo(Integer.parseInt(request.getParameter("codigo"))
);
//Faz chamado do método alteraAluno na classe AlunoDao
dao.alteraAluno(aluno);
%>
<!-- redirecionando a página-->
<jsp:forward page="consulta.jsp" />
<%
}
%>

<form name = "Altera" ACTION="alteraAluno.jsp" METHOD="POST">

<%
// Setando o aluno pelo código
int cod =
Integer.parseInt(request.getParameter("cod"));
AlunoDao dao = new AlunoDao();
Aluno aluno;
// O objeto aluno irá receber os dados do aluno
// cujo código foi passado como parâmetro
aluno = dao.getAluno(cod);
%>
<!-- Dados do aluno cujo código foi passado por parâmetro -->
<input type="hidden" name="codigo" value="<%=
aluno.getCodigo() %>">
nome: <input type="TEXT" name="nome" value="<%=
aluno.getNome() %>"><br>

sexo: <input type="TEXT" name="sexo" value="<%=


aluno.getSexo() %>"><br>

curso:<input type="TEXT" name="curso" value="<%=


aluno.getCurso() %>"><br>

idade:<input type="TEXT" name="idade" value="<%=


aluno.getIdade() %>"><br>
<br>
<input type="Submit" name="alterar" value="Alterar">

</form>
<br><br>
<A href="index.jsp"> Menu </A> <br>
</body>
</html>

• Por fim, vamos desenvolver um JSP que faça pesquisa por nome de aluno.
pesquisa.jsp
<%@ page info="menu" session="false" buffer="1kb" %>
<%@ page import="java.util.List"%>
<%@ page import="br.com.WebJsp.dao.*"%>
<%@ page import="br.com.WebJsp.Modelo.*"%>
<%@ page import="br.com.WebJsp.JDBC.*"%>

<html>
<head>
<title>
Pesquisa
</title>
</head>
<body>
Pesquisa

<br><br>
<form name = "consulta" ACTION="pesquisa.jsp" METHOD="POST">
<!-- Nome a ser pesquisado -->
nome: <input type="TEXT" name="nome">
<input type="Submit" name="pesquisa" value="Pesquisa">
<br> <br>
<%
// Caso o usuário clique no botão pesquisa
if(request.getParameter("pesquisa") != null){
AlunoDao dao = new AlunoDao();
// criando uma lista de aluno
List<Aluno> lista;
//Recebe o nome que foi entrado no compo nome do html
String nome = request.getParameter("nome");
// Recebendo uma lista de aluno que tenha o nome que foi
passado por parâmetro
lista = dao.getAluno(nome);
// A mesma lógica do consulta.jsp(faz chamada para
deletar e alterar aluno)
for (int i = 0; i < lista.size(); i++) {
%>
<input type="checkbox" name="alunos" value=
"<%=lista.get(i).getCodigo()%>" />
<A href=
"alteraAluno.jsp?cod=<%=lista.get(i).getCodigo()%>">
<%=lista.get(i).getNome()%> </A> <br>

<%}
}
if(request.getParameter("remove") != null){
AlunoDao dao = new AlunoDao();
if(request.getParameterValues("alunos") != null){
String alunos[] =
request.getParameterValues("alunos");
for (int i = 0; i < alunos.length; i++) {
dao.deleteAluno(Integer.parseInt(alunos[i]));
}
}
}
%>
<br>
<input type="Submit" name="remove" value="Delete">
</form>
<br><br>
<A href="index.jsp"> Menu </A> <br>
</body>
</html>
• Agora é só executar a aplicação no servidor.
Exercício proposto para Atividade Extra
Desenvolva a aplicação abaixo seguindo o exemplo do Aluno.

1) Crie uma tabela no banco chamada Funcionário.


2) A tabela possuirá os seguintes atributos: código (Auto Incremento), nome, sexo,
cargo, salário.
3) Crie um Projeto web Java, utilizando o Tomcat no eclipse.
4) Crie as seguintes Package: br.com.Nome_do_Projeto.Modelo
br.com.Nome_do_Projeto.Dao
br.com.Nome_do_Projeto.JDBC
5) Crie uma classe ConnectionFactory dentro da Package
br.com.Nome_do_Projeto.JDBC e faça suas devidas implementações.
6) Crie uma classe funcionário dentro da Package br.com.Nome_do_Projeto.Modelo
e faça suas devidas implementações.
7) Crie uma classe funcionarioDao dentro da Package
br.com.Nome_do_Projeto.Dao e faça suas devidas implementações.
8) Copie e cole o arquivo jar contendo a implementação do mysql dentro da pasta lib e
depois o importe ao projeto.
9) Dentro da pasta web, crie um arquivo menu.jsp, o qual contém dois links:
controle.jsp?pagina=cadastro e controle.jsp?pagina=consulta.
10) Dentro da pasta web, crie um arquivo controle.jsp, que serve para fazer as
chamadas das página cadastro.jsp e consulta.jsp.
11) Dentro da pasta web, crie um arquivo cadastro.jsp, que serve para fazer interação
com usuário e cadastrará um funcionário no banco.
12) Dentro da pasta web, crie um arquivo consulta.jsp, que serve para retornar todos os
funcionários do banco.
13) No arquivo consulta.jsp, crie um checkBox para cada nome.
14) No arquivo consulta.jsp, crie um botão que apague todos os funcionários
selecionados pelo usuário.
15) No arquivo consulta.jsp, o usuário ao clicar o nome do funcionário, vai abrir uma
página chamada altera.jsp. Dica: passe o código do funcionário por parâmetro.
16) Dentro da pasta web, crie um arquivo altera.jsp, que serve para alterar um
funcionário.
17) Dentro da pasta web, crie um arquivo pesquisa.jsp, que serve para pesquisar se
existe determinado funcionário no banco. Utilize a cláusula Like no sql.

16. Conhecendo alguns frameworks – Hibernate e JFS.

O JSF (Java Server Faces) é um framework de desenvolvimento web que


tem como objetivo aumentar a produtividade no desenvolvimento das aplicações.
Uma aplicação Java Server Faces é formada por componentes da própria
API (botão, caixa de texto, link, dentre outros), o qual dispara eventos quando
estimulados pelo usuário. Podemos implementar métodos para estes estímulos e
então tratar as ações do usuário numa classe Java separada dos códigos HTML.
Esse framework é baseado em MVC - arquitetura de software - que separa os
dados da interface, de maneira que as alterações nas interfaces não alteram a
manipulação dos dados.
Para maiores informações sobre JSF, faça o download do seguinte material:
http://www.guj.com.br/content/articles/misc/myfaces.pdf.
O Hibernate é um framework desenvolvido em Java e é utilizado para
realizar mapeamento Objeto/Relacional. Usando o Hibernate, quase não há
nescessidade de escrever código SQL, pois utiliza sua própria HQL (Hibernate
Query Language), acelerando o desenvolvimento da aplicação.
Para conhecer mais sobre o Hibernate, procure por tutoriais no fórum:
http://www.guj.com.br/.

17. Apresentação de outras linguagens de programação para web – DotNet, PHP, Ruby.

Podemos desenvolver para WEB em outras linguagens, como: DotNet, PHP,


Ruby, entre outras.
O .Net é uma ferramenta criada pela Microsoft para desenvolvimento de
softwares para web. Com essa tecnologia, podemos desenvolver em várias
linguagens, p. ex: Delphi (Object Pascal), Visual Basic, c#, c++, j# (similar ao
Java).
O .Net oferece um ambiente Orientada a objeto, possui suporte total de XML
e Web Services. Essa ferramenta utiliza o CLR (Common Language RunTime),
aplicação similar a máquina virtual do Java, que se encarrega de executar os códigos
fontes produzidos por ela e o .NET Framework Class Library, que proporciona
um ambiente de execução gerenciado, simplificando o desenvolvimento, a
publicação e a integração com várias linguagens de programação.
Embora se possa desenvolver aplicações .NET utilizando somente o notepad
e o compilador .NET, o ambiente de desenvolvimento mais comum é o visual
Studio .NET, já que possui características que facilitam o trabalho do programador,
como os componentes visuais para criação de formulários de páginas Web.
O PHP (Hypertext Preprocessor) é uma linguagem de programação de uso
free utilizada para desenvolvimento WEB. Essa tecnologia é uma linguagem de
elaboração de script e orientada a objeto.
O Ruby é uma linguagem de programação criada em 1994, com vastas
semelhanças às linguagens Perl, SmallTalk e Pyton. Ruby é 100% orientada a objeto
e multiplataforma; o software mais famoso dessa linguagem é o Ruby on Rails, que
é um framework free utilizado para desenvolvimento web, cuja filosofia é
velocidade e praticidade.