Java para Web

Prévia do material em texto

Caelum - Java para desenvolvimento Web
Índice
Capítulo 1: Como aprender Java.........................................................................1
1.1 - Falando em Java......................................................................................1
1.2 - O que é realmente importante?..............................................................1
1.3 - Sobre os exercícios.................................................................................2
1.4 - Tirando dúvidas.......................................................................................2
1.5 - Sobre o curso..........................................................................................2
1.6 - Sobre os autores.....................................................................................2
Capítulo 2: O que é J2EE?...................................................................................3
2.1 - As especificações....................................................................................3
2.2 - Referência de Implementação................................................................3
Capítulo 3: Design Patterns................................................................................5
3.1 - Soluções para viagem.............................................................................5
3.2 - Singleton.................................................................................................5
3.3 - Exercícios................................................................................................6
3.4 - Um pouco mais........................................................................................7
Capítulo 4: JDBC – java.sql.................................................................................8
4.1 - O banco...................................................................................................8
4.2 - A tabela de exemplo................................................................................8
4.3 - Javabeans................................................................................................9
4.4 - A conexão em Java................................................................................10
4.5 - Factory..................................................................................................12
4.6 - Factory – facilitando o acesso ao banco................................................12
4.7 - Exercícios..............................................................................................13
4.8 - Inserindo dados.....................................................................................13
4.9 - DAO – Data Access Object....................................................................14
4.10 - Pesquisando........................................................................................16
4.11 - Exercícios............................................................................................17
4.12 - Um pouco mais....................................................................................18
4.13 - Exercícios............................................................................................18
4.14 - Desafios...............................................................................................18
4.15 - Fixando o conhecimento.....................................................................18
Capítulo 5: Servlet Contêiner...........................................................................21
5.1 - Introdução.............................................................................................21
5.2 - Servlet Contêiner..................................................................................21
5.3 - Tipos de contêiner.................................................................................22
5.4 - Instalando o tomcat...............................................................................22
5.5 - Iniciando o tomcat.................................................................................22
5.6 - Parando o tomcat..................................................................................22
Capítulo 6: JSP e JSTL – Java Server Pages......................................................24
6.1 - JSP.........................................................................................................24
6.2 - Configurando o Tomcat.........................................................................25
6.3 - O que é uma página JSP........................................................................25
6.4 - Exercício................................................................................................27
6.5 - Listando os contatos..............................................................................27
6.6 - HTML e Java: eu não quero código Java no meu jsp!...........................27
6.7 - JSTL.......................................................................................................28
6.8 - As empresas hoje em dia.......................................................................28
6.9 - Instalação..............................................................................................28
i
Caelum - Java para desenvolvimento Web
6.10 - Cabeçalho para a jstl core..................................................................28
6.11 - For.......................................................................................................28
6.12 - Exercícios............................................................................................29
6.13 - Import: trabalhando com cabeçalhos e rodapés.................................30
6.14 - Exercícios............................................................................................30
6.15 - Desafios...............................................................................................31
Capítulo 7: Servlets...........................................................................................32
7.1 - Servlet............................................................................................. ......32
7.2 - A estrutura de diretórios.......................................................................34
7.3 - Mapeando uma servlet no web.xml......................................................34
7.4 - Exercícios..............................................................................................34
7.5 - web.xml – Mais informações.................................................................35
7.6 - OutputStream x PrintWriter.................................................................35
7.7 - doGet, doPost e outros..........................................................................35
7.8 - Parâmetros............................................................................................36
7.9 - Exercícos....................................................................................... ........37
7.10 - HTML e Java: eu não quero código Html na minha servlet!...............37
Capítulo 8: Introdução ao Apache Ant e ao arquivo WAR................................40
8.1 - Build......................................................................................................40
8.2 - Integração com IDEs.............................................................................41
8.3 - Build.xml básico....................................................................................41
8.4 - Um arquivo build.xml de verdade.........................................................42
8.5 - Criando os diretórios.............................................................................43
8.6 - Compilando...........................................................................................43
8.7 - Web archive (.war)................................................................................43
8.8 - Tomcat Manager...................................................................................448.9 - Um pouco mais......................................................................................44
8.10 - Exercícios............................................................................................44
Capítulo 9: Controle de erro.............................................................................46
9.1 - Exceptions....................................................................................... ......46
9.2 - Página de erro.......................................................................................46
9.3 - Quando acontece um erro em uma página jsp......................................47
9.4 - Exercícios..............................................................................................47
9.5 - Quando acontece um erro em uma servlet...........................................48
9.6 - Exercícios..............................................................................................48
Capítulo 10: Model View Controller.................................................................51
10.1 - Servlet ou JSP?....................................................................................51
10.2 - Melhorando o processo.......................................................................51
10.3 - Model View Controller........................................................................53
10.4 - Request e dispatchers.........................................................................54
Capítulo 11: Construindo um Framework MVC...............................................55
11.1 - Nossa interface...................................................................................55
11.2 - Criando um controlador e um pouco mais de reflection.....................55
11.3 - Configurando o web.xml.....................................................................57
11.4 - Executando o TestaSYP.......................................................................57
11.5 - Melhorando o SYP...............................................................................57
Capítulo 12: Jakarta Struts...............................................................................60
12.1 - Struts...................................................................................................60
12.2 - Configurando o Struts.........................................................................60
ii
Caelum - Java para desenvolvimento Web
12.3 - Uma ação Struts..................................................................................61
12.4 - Configurando a ação no struts-config.xml..........................................62
12.5 - Preparando um sistema de login.........................................................63
12.6 - Passo 1: Formbean..............................................................................64
12.7 - Passo 2: A página de login..................................................................65
12.8 - O arquivo formulario.jsp.....................................................................65
12.9 - Exercício..............................................................................................66
12.10 - A ação................................................................................................66
12.11 - A ação no struts-config.xml...............................................................66
12.12 - ok.jsp e erro.jsp.................................................................................67
12.13 - Testando............................................................................................68
12.14 - Cookies..............................................................................................68
12.15 - Sessão...............................................................................................69
12.16 - Configurando o tempo limite............................................................69
12.17 - Registrando o usuário logado na sessão...........................................69
12.18 - Exercícios..........................................................................................70
Capítulo 13: Inversão de Controle....................................................................72
13.1 - IoC - Eu não quero mais importar o que eu não conheço...................72
13.2 - Vantagens............................................................................................73
13.3 - VRaptor...............................................................................................73
13.4 - Instalando e configurando o VRaptor.................................................73
13.5 - Minha primeira lógica de negócios.....................................................74
13.6 - E o jsp com o formulário?...................................................................75
13.7 - E a página final?..................................................................................75
13.8 - Como configurar tudo isso?................................................................75
13.9 - Chain? Cadeia?....................................................................................75
13.10 - Exercícios..........................................................................................76
13.11 - Um pouco mais..................................................................................76
Capítulo 14: Hibernate 3..................................................................................77
14.1 - Vantagens............................................................................................77
14.2 - Criando seu projeto.............................................................................77
14.3 - Modelo.................................................................................................78
14.4 - Configurando.......................................................................................78
14.5 - Configurando a classe/tabela Produto ...............................................78
14.6 - Criando as tabelas...............................................................................79
14.7 - Propriedades do banco........................................................................79
14.8 - Sessões................................................................................................79
14.9 - Salvando novos objetos.......................................................................80
14.10 - Buscando pelo id...............................................................................80
14.11 - Exercícios..........................................................................................80
14.12 - Buscando com uma cláusula where..................................................81
14.13 - Atualizando.......................................................................................81
14.14 - Exercícios..........................................................................................81
Capítulo 15: E agora?.......................................................................................83
15.1 - Certificação.........................................................................................83
15.2 - Frameworks........................................................................................83
15.3 - Revistas...............................................................................................83
15.4 - Falando em Java..................................................................................83
Capítulo 16: Apêndice A - Jakarta Velocity.......................................................85
iii
Caelum - Java para desenvolvimento Web
16.1 - Velocity................................................................................................85
16.2 - Vantagens............................................................................................86
16.3 - Templates Velocity..............................................................................8616.4 - Instalando e configurando o Velocity e Velocity Tools.......................86
16.5 - Exercícios............................................................................................87
16.6 - Seu primeiro template........................................................................87
16.7 - Exercícios............................................................................................88
16.8 - Mesclando velocity e o struts..............................................................88
16.9 - Exercícios............................................................................................88
16.10 - Objetos mais complexos....................................................................88
16.11 - Diretivas............................................................................................89
16.12 - IF................................................................................................... ....89
16.13 - FOREACH..........................................................................................90
16.14 - PARSE...............................................................................................90
16.15 - Comentários......................................................................................91
16.16 - Outras ferramentas...........................................................................91
16.17 - ImportTool.........................................................................................91
16.18 - CookieTool........................................................................................91
16.19 - Um pouco mais..................................................................................92
Capítulo 17: Apêndice B - Criando taglibs avançadas......................................93
17.1 - O problema..........................................................................................93
17.2 - A solução.............................................................................................94
17.3 - Descrição das tags e bibliotecas.........................................................95
17.4 - Um pouco mais....................................................................................96
17.5 - Exercícios............................................................................................96
Capítulo 18: Apêndice C - Design Patterns.......................................................98
18.1 - Factory – exemplo de cache de objetos..............................................98
Capítulo 19: Apêndice D - Servlets................................................................102
19.1 - Configuração de uma servlet............................................................102
19.2 - Exercícios..........................................................................................103
19.3 - Aplicação...........................................................................................103
iv
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
1Como aprender Java
“Homens sábios fazem provérbios, tolos os repetem”
Samuel Palmer -
Como o material está organizado e dicas de como estudar em casa.
1.1 - Falando em Java
Esta é a apostila da Caelum que tem como intuito ensinar Java de uma 
maneira elegante, mostrando apenas o que é necessário no momento correto e 
poupando o leitor de assuntos que não costumam ser de seu interesse em 
determinadas fases do aprendizado.
O material aqui contido pode ser publicamente distribuído desde que não seja 
alterado e seus créditos sejam mantidos. Ele não pode ser usado para ministrar 
qualquer curso. Caso você esteja interessado em usá-lo para este fim, entre em 
contato através do email contato@caelum.com.br.
1.2 - O que é realmente importante?
Muitos livros, ao passar os capítulos, mencionam todos os detalhes da 
linguagem juntamente com os princípios básicos dela. Isso acaba criando muita 
confusão, em especial pois o estudante não consegue distinguir exatamente o que é 
importante aprender e reter naquele momento daquilo que será necessário mais 
tempo e. Principalmente, experiência para dominar.
Se uma classe abstrata deve ou não ter ao menos um método abstrato, se o if 
só aceitar argumentos booleanos e todos os detalhes de classes internas realmente 
não devem ser preocupações para aquele que possui como objetivo primário 
aprender Java. Esse tipo de informação será adquirida com o tempo e não é 
necessária até um segundo momento.
Neste curso separamos essas informações em quadros especiais, já que são 
informações extras. Ou então apenas citamos num exercício e deixamos para o leitor 
procurar informações se for de seu interesse.
Algumas informações não são mostradas e podem ser adquiridas em tutoriais 
ou guias de referência, normalmente são detalhes que para um programador 
experiente em Java é algo importante.
Por fim falta mencionar sobre a prática, que deve ser tratada seriamente: 
todos os exercícios são muito importantes e os desafios podem ser feitos quando o 
curso acabar. De qualquer maneira recomendamos aos alunos estudar em casa, 
principalmente aqueles que fazem os cursos intensivos.
O curso
Para aqueles que estão fazendo o curso Java para desenvolvimento Web, é 
Capítulo 1 - Como aprender Java - Página 1
capítulo 1
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
recomendado estudar em casa aquilo que foi visto durante a aula, tentando resolver os 
exercícios que não foram feitos e os desafios que estão lá para envolver mais o leitor 
no mundo de Java.
1.3 - Sobre os exercícios
Os exercícios do curso variam entre práticos até pesquisas na Internet, ou 
mesmo consultas sobre assuntos avançados em determinados tópicos para incitar a 
curiosidade do aprendiz na tecnologia.
Existem também, em determinados capítulos, uma série de desafios. Eles 
focam mais no problema computacional que na linguagem, porém são uma 
excelente forma de treinar a sintaxe e principalmente familiarizar o aluno com a 
biblioteca padrão Java, além de o aluno ganhar velocidade de raciocínio.
1.4 - Tirando dúvidas
Para tirar dúvidas dos exercícios, ou de Java em geral, recomendamos o fórum 
do site do GUJ (www.guj.com.br), onde sua dúvida será respondida prontamente.
Se você já participa de um grupo de usuários java ou alguma lista de 
discussão, pode tirar suas dúvidas nos dois lugares.
Fora isso, sinta-se a vontade de entrar em contato conosco para tirar todas as 
suas dúvidas durante o curso.
1.5 - Sobre o curso
A Caelum (http://www.caelum.com.br) oferece os cursos e a apostila "Falando 
em Java", que aborda o ensino dessa linguagem e tecnologia de forma mais simples 
e prática do que em outros cursos, poupando o aluno de assuntos que não são de 
seu interesse em determinadas fases do seu aprendizado.
As apostilas "Falando em Java" estão parcialmente disponíveis no site 
http://www.caelum.com.br/fj.jsp.
Se você possui alguma colaboração, como correção de erros, sugestões, novos 
exercícios e outros, entre em contato conosco!
1.6 - Sobre os autores
Guilherme Silveira (guilherme.silveira@caelum.com.br) é programador e web 
developer certificado pela Sun, trabalhando com Java desde 2000 como especialista 
e instrutor. Programou e arquiteturou projetos na Alemanha. Cofundador do GUJ, 
escreve para a revista Mundo Java, estuda Matemática Aplicada na USP e é instrutor 
na Caelum.
Paulo Silveira (paulo.silveira@caelum.com.br) é programador e 
desenvolvedor certificado Java. Possui grande experiência com servlets, que utilizou 
na Alemanha, e vários outros projetos Java, onde trabalhou como consultor sênior. 
Foi instrutor Java pela Sun, cofundador do GUJ e criador do framework vRaptor. É 
formado em ciênciada computação pela USP, onde realiza seu mestrado.
Sérgio Lopes (sergio@caelum.com.br) é programador e desenvolvedor Java 
desde 2002. É moderador do Grupo de Usuários Java – GUJ - e estuda Ciência da 
Computação na USP.
Capítulo 1 - Como aprender Java - Página 2
J2EE
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
2O que é J2EE?
“Ensinar é aprender duas vezes.” 
Joseph Joubert -
Java 2 Enterprise Edition
2.1 - As especificações
O J2EE não passa de uma série de especificações bem detalhadas, dando uma 
receita de como deve ser implementado um software que faz um determinado 
serviço.
Estaremos vendo no curso os vários serviços que um software deve 
implementar para seguir as especificações do J2EE. Estaremos vendo também 
conceitos muito importantes, para depois estar firmando jargões como servidor de 
aplicação e containers.
Esses serviços variam desde envio de emails, até complexos serviços de 
transação.
Porque a Sun faz isso? A idéia é que você possa criar uma aplicação que utilize 
esses serviços. Como esses serviços são bem complicados, você não perderá tempo 
implementando essa parte do sistema, porém terá de comprar de alguém (existem 
implementações gratuitas de excelente qualidade). 
E em algum dia, você pode decidir querer trocar essa implementação atual por 
uma que é mais rápida em determinados pontos (e conseqüentemente mais cara).
Você continua utilizando a mesma interface, isto é, como você chama aquelas 
funcionalidades do J2EE. O que muda é a implementação da especificação, você tem 
essa liberdade, não está preso a um código e a especificação garante que sua 
aplicação funcionará com a implementação de outra empresa.
Onde encontrar as especificações.
O grupo responsável por gerir as especificações usa o site do Java Community Process:
http://www.jcp.org/
Lá você pode encontrar tudo sobre as Java Specification Requests, isto é, os novos 
pedidos de bibliotecas e especificações para o Java, tanto para J2SE, quanto EE e 
outros.
Sobre o J2EE, você pode encontrar em:
http://java.sun.com/j2ee/
2.2 - Referência de Implementação
Existe um grande download do J2EE na página da Sun. Se J2EE é uma 
Capítulo 2 - O que é J2EE? - Página 3
capítulo 2
REFERÊNCIA DE 
IMPLEMENTAÇÃO
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
especificação, o que preciso pegar?
Nesse download você terá a documentação, um monte de jars onde ficam as 
interfaces que são implementadas pelas empresas (vendors), ferramentas e outros. 
Repare que aqui não vem a Virtual Machine, compilador e o conteúdo do J2SE. J2EE 
precisa do J2SE se você quiser desenvolver.
O que realmente ocupa muito espaço é a RI - Reference Implementation 
(Referência de implementação, ou J2EE RI). Como as especificações do J2EE não são 
muito simples, e a Sun precisa testá-las para ver se tudo de necessário se encontra 
por lá, a própria Sun desenvolve uma implementação que vem junto com o J2EE, 
apenas para testes dos usuários.
Você pode estar usando a RI no seu ambiente de trabalho, mas vale a pena 
lembrar que ela não é rápida, e nem tem facilidades de uso na hora da instalação, 
criação de uma nova aplicação e outros.
Outra utilidade da RI é para que as empresas que desejam vender seu próprio 
produto, possam estar tirando dúvidas de casos em que a especificação não tenha 
sido muito clara, testando esse caso na RI.
Baixando a J2EE
http://java.sun.com/j2ee/1.4/download-dr.html
A última versão é a 1.4. Cuidado ao fazer o download pois existe uma versão que 
também vem todo o J2SE.
Capítulo 2 - O que é J2EE? - Página 4
DESIGN 
PATTERNS
SINGLETON
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
3Design Patterns
“Nunca chegamos aos pensamentos. São eles que vêm.”
Martin Heidegger -
Neste capítulo, você irá aprender a:
• solucionar o problema de controle de acesso ao construtor de objetos;
• criar instâncias únicas de objetos em um programa;
• resolver alguns problemas clássicos de orientação a objetos.
3.1 - Soluções para viagem
Orientação à objetos resolve as grandes dores de cabeças que tínhamos na 
programação procedural, restringindo e centralizando responsabilidades. 
Mas algumas coisas não podemos simplesmente resolver com orientação à 
objetos pois não existe palavra chave para uma funcionalidade tão específica.
Alguns desses pequenos problemas aparecem com tamanha freqüência que as 
pessoas desenvolvem uma solução padrão para o mesmo. Com isso, ao nos 
defrontarmos com um desses problemas clássicos, podemos rapidamente 
implementar essa solução genérica com uma ou outra modificação. Essa solução 
padrão tem o nome de Design Pattern (padrão de projeto).
A melhor maneira para aprender o que é um Design Pattern é vendo um. No 
decorrer dos outros capítulos sempre estaremos vendo outros Design Patterns.
A bíblia
O livro mais conhecido de Design Patterns foi escrito em 1995 e tem trechos de código 
em C++ e Smalltalk. Mas o que realmente importa são os conceitos e os diagramas 
que fazem desse livro independente de qualquer linguagem. Além de tudo, o livro é de 
leitura agradável.
Design Patterns, Erich Gamma et al.
3.2 - Singleton
Em alguns casos, desejamos que determinada classe só possa ser instanciada 
uma vez. Isto é, só queremos um objeto daquela classe e que a referência para ao 
mesmo seja compartilhada por diversos outros objetos.
Isto é muito comum quando a classe representa uma entidade única no 
sistema, como o presidente de uma empresa, o gerenciador de logs da aplicação ou 
o controlador de usuários.
Como faremos? Com certeza aproveitaremos o truque anterior, deixando o 
construtor privado e criando um método estático para retornar a referência. Mas o 
que fazer para retornar sempre uma referência para a mesma instância?
Capítulo 3 - Design Patterns - Página 5
capítulo 3
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
public Presidente getPresidente() {
return referenciaUnica;
}
Quem é essa referenciaUnica? Um atributo estático, como era o nosso mapa 
de páginas no cache.
1. public class Presidente {
2. private static Presidente referenciaUnica = 
new Presidente(“Nome do 
Presidente”);
3. private String nome;
4.
5. private Presidente(String nome) {
6. this.nome = nome;
7. }
8.
9. public static Presidente getPresidente() {
10. return Presidente.referenciaUnica;
11. }
12. }
E, quando alguém quiser uma referência para o presidente:
Presidente presidente = Presidente.getPresidente();
E poderia até ser que o método getPresidente não retornasse sempre uma 
referência para mesma instância, depende do que você quer que sua aplicação faça. 
Se um dia quisermos deixar que mais de um Presidente exista na nossa aplicação, 
podemos deixar o construtor público ou, melhor ainda, criar um método de Factory 
que receba o nome do Presidente como argumento.
Classes com tudo estático
Uma outra alternativa seria criar uma classe cheia de métodos e atributos estáticos, 
tais como a System e a Math. Apesar de funcionar, essa solução não é orientada à 
objetos. Se você precisar passar um System como argumento, como poderia fazer 
isso?
Uma classe só com métodos estáticos tem a característica de uma pequena biblioteca 
de funções.
3.3 - Exercícios
1-) Dado o sistema a seguir, aplique o pattern Singleton. A classe Logger usa 
a variável membro ativo para realmente imprimir informações, enquanto que a 
classe Aplicacao é o nosso programa e utiliza dois objetos de tipo Logger. 
1. public class Logger {
2.
3. /* por default não imprime o log */
4. private boolean ativo = false;
5.
6. public Logger() {
7. }
8.
9. public boolean isAtivo() {
10. return this.ativo;
11. }
12.
13.public void setAtivo(boolean b) {
Capítulo 3 - Design Patterns - Página 6
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
14. this.ativo = b;
15. }
16.
17. public void log(String s) {
18. if(this.ativo) {
19. System.out.println("LOG :: " + s);
20. }
21. }
22. }
Agora a classe Aplicacao, em outro arquivo:
1. public class Aplicacao {
2.
3. public static void main(String[] args) {
4.
5. Logger log1 = new Logger();
6. log1.setAtivo(true);
7. log1.log("PRIMEIRA MENSAGEM DE LOG");
8.
9. Logger log2 = new Logger();
10. log2.log("SEGUNDA MENSAGEM DE LOG");
11.
12. }
13. }
Resultado da aplicação antes de aplicar o pattern:
PRIMEIRA MENSAGEM DE LOG
Ao aplicar o pattern, a classe aplicação deverá utilizar o mesmo objeto do tipo 
Logger nas duas chamadas ao método log, portanto o resultado da aplicação será:
PRIMEIRA MENSAGEM DE LOG
SEGUNDA MENSAGEM DE LOG
Passo 1: Torne o construtor de Logger privado
Passo 2: Crie uma váriavel estática logger para conter uma referência única ao 
objeto de Logger; instancie a variável na declaração
Passo 3: Crie um método estático getLogger que devolve a referência para o 
logger
Passo 4: Na classe Aplicacao, substitua o “new Logger()” pelo uso do método 
estático getLogger criado no passo 3.
3.4 - Um pouco mais...
1-) Pesquise sobre outros Patterns. Strategy, Facade, Proxy e Decorator são 
alguns interessantes.
2-) Como um Design Pattern deve ser aplicado? Em que momento? Antes, 
durante ou depois da implementação?
Capítulo 3 - Design Patterns - Página 7
BANCO DE 
DADOS
PERSISTÊNCIA
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
4JDBC – java.sql
“O medo é o pai da moralidade” 
Friedrich Wilhelm Nietzsche -
Ao término desse capítulo, você será capaz de:
• conectar-se a um banco de dados qualquer através da api java.sql;
• criar uma fábrica de conexões usando o design pattern Factory;
• pesquisar dados através de queries;
• executar comandos no banco de dados;
• DAO – Data Access Object.
4.1 - O banco
O banco de dados é onde guardamos os dados que pertencem ao nosso 
sistema. A maioria dos banco de dados comerciais hoje em dia são relacionais e 
derivam de uma estrutura diferente daquela orientada a objetos.
O MYSQL é o banco de dados que usamos para nossos exemplos, portanto 
iremos utilizar o seguinte comando no seu terminal para acessar o mesmo:
mysql -u root
Banco de dados
Para aqueles que não conhecem um banco de dados, é recomendado ler mais sobre o 
mesmo e SQL para começar a usar a api JDBC.
O processo de armazenagem e captura de dados em um banco é chamado de 
persistência. A biblioteca padrão de persistência em banco de dados em Java é a 
JDBC mas já existem diversos projetos do tipo ORM (Object Relational Mapping) que 
solucionam muitos problemas que a estrutura da api do JDBC (e ODBC) gerou.
4.2 - A tabela de exemplo
Para criar uma tabela nova, devemos rodar o comando mysql para entrar no 
mesmo. Agora nos preparamos para usar o banco de dados teste:
use teste;
A seguinte tabela será usada nos exemplos desse capítulo:
create table contatos (
id BIGINT NOT NULL AUTO_INCREMENT,
nome VARCHAR(255),
email VARCHAR(255),
endereco VARCHAR(255),
primary key (id)
);
No banco de dados relacional, é comum representar um contato (entidade) em 
Capítulo 4 - JDBC – java.sql - Página 8
capítulo 4
JAVABEANS
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
uma tabela de contatos, portanto o nome da tabela fica no plural.
4.3 - Javabeans
O que são Javabeans? A pergunta que não quer se calar pode ser respondida 
muito facilmente uma vez que a maior confusão feita aí fora é entre Javabeans e 
Enterprise Java Beans (EJB).
Javabeans são classes que possuem o construtor sem argumentos e métodos 
de acesso do tipo get e set! Mais nada! Simples não?
Já os EJBs são java beans com características mais avançadas e são o assunto 
principal do curso FJ-31.
Podemos usar beans por diversos motivos, normalmente as classes de modelo 
da nossa aplicação costumam ser java beans.
Agora iremos utilizar:
• uma classe com métodos do tipo get e set para cada um de seus 
parâmetros, que representa algum objeto
• uma classe com construtor sem argumentos que representa uma coleção de 
objetos
A seguir, você vê um exemplo de uma classe javabean que seria equivalente 
ao nosso modelo de entidade do banco de dados:
1. package br.com.caelum.jdbc.modelo;
2.
3. public class Contato {
4.
5. private Long id;
6. private String nome;
7. private String email;
8. private String endereco;
9.
10. // métodos get e set para id, nome, email e endereço
11.
12. public String getNome() {
13. return this.nome;
14. }
15. public void setNome(String novo) {
16. this.nome = novo;
17. }
18.
19. public String getEmail() {
20. return this.email;
21. }
22. public void setEmail(String novo) {
23. this.email = novo;
24. }
25.
26. public String getEndereco() {
27. return this.endereco;
28. }
29. public void setEndereco(String novo) {
30. this.endereco = novo;
31. }
32.
33. public Long getId() {
34. return this.id;
35. }
36. public void setId(Long novo) {
Capítulo 4 - JDBC – java.sql - Página 9
EJB
DRIVERMANAGER
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
37. this.id = novo;
38. }
39. }
A tecnologia javabeans é muito grande e mais informações sobre essa vasta 
área que é a base dos componentes escritos em java pode ser encontrada em:
http://java.sun.com/products/javabeans 
Se você quer saber mais sobre Enterprise Java Beans (EJB), a Caelum oferece 
o curso FJ-31.
4.4 - A conexão em Java
O sistema desenvolvido em Java abstrai o método através do qual é possível 
fazer uma conexão pois as conexões são feitas através de uma ponte que 
implementa todas as funcionalidades que um 
banco de dados padrão deve nos fornecer.
Por exemplo, toda conexão deve permitir 
executar código de atualizacão, pesquisa, etc.
Essa implenetação precisa ser escolhida. 
Essa escolha não é feita programaticamente e 
sim basta usar uma ponte.
Veja no esquema ao lado a ponte 
(implementação) entre o programa (cliente) e o 
banco de dados.
O serviço de encontrar uma ponte, ou seja, um driver certo é delegado para 
um controlador de drivers. Nada mais normal que ele se chame DriverManager.
Através dele, é possível chamar um método getConnection com uma url que 
indica qual o banco que desejo abrir.
O padrão da url para o driver 
do mysql que iremos utilizar é:
jdbc:mysql://ip/banco
Devemos substituir ip pelo 
ip da máquina e banco pelo nome 
do banco a ser utilizado.
Seguindo o exemplo da linha 
acima e tudo que foi dito até 
agora, é possível rodar o exemplo 
abaixo e receber uma conexão 
para um banco mysql na própria 
máquina....
1. package br.com.caelum.jdbc;
2.
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6.
7. public class JDBCExemplo {
Capítulo 4 - JDBC – java.sql - Página 10
Interface JDBC
BD
Implementação JDBC. Qual?
Cliente
Interface JDBC
MySQL
Implementação JDBC. MySQL
Cliente
DriverManager.getConnection("jdbc:mysql://localhost/teste");
DriverManager procura 
por algum de seus 
Drivers que aceite essa 
URL como parâmetro.
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
8.
9. public static void main(String[] args) {
10.
11. try {
12. Connection con = 
 
DriverManager.getConnection("jdbc:mysql://localhost/teste");
13. System.out.println("Conectado!");
14. con.close();
15. } catch (SQLException e) {
16. e.printStackTrace();
17. }
18. }
19. }
Mas ao testar o código acima, nada funciona. A conexão não pode ser aberta. 
Por que?
O sistema ainda não conseguedescobrir qual implementação do 
JDBC deve ser usado para a URL 
mencionada.
O primeiro passo é adicionar a 
implementação ao classpath: o 
arquivo jar contendo a 
implementação do mysql (mysql 
connector) precisa ser colocado em 
um lugar visível ou adicionado à 
variável de ambiente classpath.
Ainda falta registrar o driver do mysql no sistema. Para isso basta carregar ele 
através do método Class.forName(). Esse método abre uma classe que se registra 
com o DriverManager.getConnection().
1. package br.com.caelum.jdbc;
2.
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6.
7. public class JDBCExemplo {
8.
9. public static void main(String[] args) {
10.
11. try {
12. Class.forName("com.mysql.jdbc.Driver");
13. Connection con = 
 
DriverManager.getConnection("jdbc:mysql://localhost/teste", “root”, “”);
14. System.out.println("Conectado!");
15. con.close();
16. } catch (ClassNotFoundException e) {
17. e.printStackTrace();
18. } catch (SQLException e) {
19. e.printStackTrace();
20. }
21. }
22. }
Alterando o banco de dados
Teoricamente basta alterar as duas Strings que escrevemos para mudar de um banco 
para outro. Porém não é tudo tão simples assim, o código sql que veremos a seguir 
Capítulo 4 - JDBC – java.sql - Página 11
DriverManager
SQLServer
Oracle
MySQL
Class.forName("com.mysql.jdbc.Driver");
Avisando o DriverManager sobre
a existência de um Driver para o MySQL
Drivers conhecidos
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
pode funcionar em um banco mas não em outro. Depende de qual padrão sql o banco 
suporta.
Isso só causa dor de cabeça e existem certos arcabouços que resolvem isso facilmente, 
como é o caso do Hibernate (www.hibernate.org) e do Prevayler.
Lista de drivers
Os drivers podem ser baixados normalmente no site do vendedor do banco de dados.
Alguns casos, como no MSSQL, existem outros grupos que desenvolvem o driver em 
jtds.sourceforge.net
Enquanto isso, você pode achar o driver do MYSQL (chamado de mysql connector) no 
site www.mysql.org.
4.5 - Factory
Em determinado momento de nossa aplicação, gostaríamos de ter o controle 
sobre a construção dos objetos da nossa classe. Muita coisa pode ser feita através do 
construtor, como saber quantos objetos foram instanciados ou fazer o log sobre 
essas instanciações.
As vezes também queremos controlar um processo muito repetitivo e 
trabalhoso, como abrir uma conexão com o banco de dados.
4.6 - Factory – facilitando o acesso ao banco
Tomemos como exemplo a classe a seguir que seria responsável por abrir uma 
conexão com o banco:
1. package br.com.caelum.jdbc;
2.
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6.
7. public class ControladorDeConexoes {
8.
9. private final String URL = "jdbc:mysql://localhost/teste";
10. private final String DRIVER = "com.mysql.jdbc.Driver";
11. private final String USUARIO = "root";
12. private final String SENHA = "";
13.
14. public Connection abreConexao() throws SQLException {
15. try {
16. Class.forName(DRIVER);
17. return DriverManager.getConnection(URL,USUARIO,SENHA);
18. } catch (ClassNotFoundException e) {
19. throw new SQLException(e.getMessage());
20. }
21. }
22. }
Poderíamos colocar um aviso na nossa aplicação, notificando todos os 
programadores a criarem um novo ControladorDeConexoes e atraves dele adquirir 
uma conexao:
Connection con = new ControladorDeConexoes().abreConexao();
Podemos perceber que o método abreConexao é uma fábrica de conexões, isto 
é, ele fabrica conexões para mim, não importando de onde elas vieram. Portanto, 
Capítulo 4 - JDBC – java.sql - Página 12
PREPARED 
STATEMENT
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
nada mais natural do que chamar a classe de ConnectionFactory e o método de 
getConnection.
4.7 - Exercícios
1-) Crie uma classe chamada ConnectionFactory que fabrica conexões.
a) crie-a no pacote br.com.caelum.jdbc
b) coloque quatro variáveis estáticas finais String e seus respectivos valores:
 URL "jdbc:mysql://localhost/teste"
 DRIVER "com.mysql.jdbc.Driver"
 USUARIO “root”
 SENHA “”
c) crie o método estático getConnection que retorna uma nova conexão:
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());
}
}
2-) Crie uma classe chamada TestaConexao no pacote 
br.com.caelum.jdbc.teste
a) coloque o método main
b) fabrique uma conexão:
Connection con = ConnectionFactory.getConnection();
c) feche a conexão
con.close();
d) Trate os erros!
4.8 - Inserindo dados
Para inserir dados em uma tabela de um banco de dados entidade-relacional 
basta usar a cláusula INSERT. Precisamos especificar quais os campos que 
desejamos atualizar e os valores.
As cláusulas são executadas em um banco de dados através da interface 
PreparedStatement. Para receber um PreparedStatement relativo à conexão, basta 
chamar o método prepareStatement, passando como argumento o comando SQL 
com os valores vindos de variáveis preenchidos com uma interrogação. Logo em 
seguida, chamamos o método setString do PreparedStatement para preencher os 
valores, passando a posição (começando em 1) da interrogação no SQL e o valor que 
deve ser colocado. Por fim, uma chamada à execute executa o comando SQL.
1. package br.com.caelum.jdbc;
2.
3. import java.sql.Connection;
4. import java.sql.SQLException;
5. import java.sql.PreparedStatement;
6.
7. public class JDBCInsert {
8.
9. public static void main(String[] args) {
10.
11. try {
12.
13. // conectando
14. Connection con = ConnectionFactory.getConnection();
Capítulo 4 - JDBC – java.sql - Página 13
DAO
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
15. System.out.println("Conectado!");
16.
17. // cria um preparedStatement
18. PreparedStatement stmt = con.prepareStatement("insert into contatos 
(nome,email,endereco) values (?,?,?)");
19. 
20. // preenche os valores
21. stmt.setString(1, “Caelum”);
22. stmt.setString(2, “contato@caelum.com.br”);
23. stmt.setString(3, “R. Vergueiro 3185 cj57”);
24.
25. // executa 
26. stmt.execute();
27. stmt.close();
28.
29. System.out.println("Gravado!");
30.
31. con.close();
32.
33. } catch (SQLException e) {
34. e.printStackTrace();
35. }
36.
37. }
38. }
Fechando a conexão
Não é comum utilizar jdbc hoje em dia. O mais praticado é o uso de alguma api de 
ORM como o Hibernate ou EJB, porém aqueles que ainda insistem no uso de JDBC 
devem prestar atenção no momento de fechar a conexão.
O exemplo dado acima não fecha a mesma caso algum erro ocorra no momento de 
inserir algum dado no banco de dados.
O comum é fechar a conexão em um bloco finally.
Má prática: Statement
Ao invés de usar o PreparedStatement, você pode usar uma interface mais simples 
chamada Statement, que simplesmente executa uma cláusula SQL no método 
execute:
Statement stmt = con.createStatement();
stmt.execute(“insert into contatos (nome,email,endereco) values 
('Nome','Email','Endereco')”);
stmt.close();
Mas prefira a classe PreparedStatement que é mais rápida que Statement e deixa seu 
código muito mais limpo. Geralmente, seus comandos SQL conterão valores vindos de 
variáveis do programa Java; usando Statements, você terá que fazer muitas 
concatenações, mas usando PreparedStatements, isso fica mais limpo efácil.
4.9 - DAO – Data Access Object
Já foi possível sentir que colocar código SQL dentro de suas classes de lógica é 
algo nem um pouco elegante e muito menos viável quando você precisa manter o 
seu código. Quantas vezes você não ficou bravo com o programador responsável por 
aquele código ilegível?
A idéia do DAO é remover o código de acesso ao banco de dados de suas 
classes de lógica e colocá-lo em uma classe responsável pelo acesso ao mesmo. 
Capítulo 4 - JDBC – java.sql - Página 14
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
Assim o código de acesso ao banco de dados fica em um lugar só, ficando mais fácil 
dar manutenção ao mesmo.
Vamos começar alterando nosso programa de inclusão para deixá-lo mais 
simples.
Primeiro vamos usar a classe java.util.Scanner do Java 5 para ler os 
dados a serem gravados. Algo como o código a seguir:
// cria o Scanner
Scanner teclado = new Scanner(System.in);
// pronto para gravar
Contato contato = new Contato();
contato.setNome(teclado.next());
contato.setEmail(teclado.next());
contato.setEndereco(teclado.next());
Depois, seria muito melhor e mais elegante poder chamar um único método 
responsável pela inclusão, certo?
1. package br.com.caelum.jdbc;
2.
3. import java.sql.Connection;
4. import java.sql.SQLException;
5. import java.util.Scanner;
6.
7. public class JDBCInsertDAO {
8.
9. public static void main(String[] args) {
10.
11. try {
12.
13. // conectando
14. Connection con = ConnectionFactory.getConnection();
15. System.out.println("Conectado!");
16.
17. // cria o Scanner
18. Scanner teclado = new Scanner(System.in);
19. System.out.println("Entre com os dados:");
20. 
21. // pronto para gravar
22. Contato contato = new Contato();
23. contato.setNome(teclado.next());
24. contato.setEmail(teclado.next());
25. contato.setEndereco(teclado.next());
26.
27. // grave nessa conexão!!!
28. ContatoDAO dao = new ContatoDAO(con);
29.
30. // método elegante
31. dao.adiciona(contato);
32.
33. System.out.println("Gravado!");
34.
35. con.close();
36.
37. } catch (SQLException e) {
38. e.printStackTrace();
39. }
40.
41. }
42. }
Não é muito difícil visualizar uma classe com métodos responsáveis por 
adicionar objetos em um banco de dados, por exemplo:
Capítulo 4 - JDBC – java.sql - Página 15
RESULTSET
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
1. // atenção ao pacote!!
2. package br.com.caelum.jdbc.dao;
3.
4. import br.com.caelum.jdbc.*;
5. import java.sql.*;
6.
7. public class ContatoDAO {
8.
9. // a conexão com o banco de dados
10. private Connection connection;
11.
12. // construtor que recebe a conexão
13. public ContatoDAO(Connection con) {
14. this.connection = con;
15. }
16.
17. public ContatoDAO() throws SQLException {
18. this.connection = ConnectionFactory.getConnection();
19. }
20.
21. public void adiciona(Contato contato) throws SQLException {
22.
23. // prepared statement para inserção
24. PreparedStatement stmt = this.connection.prepareStatement("insert into 
contatos (nome,email,endereco) values (?, ?, ?)");
25.
26. // seta os valores
27. stmt.setString(1,contato.getNome());
28. stmt.setString(2,contato.getEmail());
29. stmt.setString(3,contato.getEndereco());
30.
31. // executa
32. stmt.execute();
33. stmt.close();
34. }
35. }
4.10 - Pesquisando
Para pesquisar também utilizamos a interface PreparedStatement, de forma 
que o método executeQuery retorna todos os contatos no exemplo a seguir.
O objeto retornado é do tipo ResultSet que permite navegar por seus 
registros através do método next. Esse método irá retornar false quando chegar ao 
fim da pesquisa, portanto ele é normalmente utilizado para fazer um loop nos 
registros.
Para retornar o valor de uma coluna no banco de dados basta chamar um dos 
métodos get do ResultSet, entre eles existe o mais comum: getString.
1. // pega a conexão e o Statement
2. Connection con = ConnectionFactory.getConnection();
3. PreparedStatement stmt = con.prepareStatement("select * from contatos");
4.
5. // executa um select
6. ResultSet rs = stmt.executeQuery();
7.
8. // itera no ResultSet
9. while (rs.next()) {
10. System.out.println(
11. rs.getString("nome") + " :: " + rs.getString("email")
12. );
13. }
14.
Capítulo 4 - JDBC – java.sql - Página 16
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
15. stmt.close();
16. con.close();
Recurso Avançado: O cursor
Assim como o cursor do banco de dados, só é possível mover para o próximo registro. 
Para permitir um processo de leitura para trás é necessário especificar na abertura do 
ResultSet que tal cursor deve ser utilizado.
Mas, novamente, podemos aplicar as idéias de DAO e criar um método 
getLista() no nosso ContatoDAO:
1. public List<Contato> getLista() throws SQLException {
2.
3. PreparedStatement stmt = 
this.connection.prepareStatement("select * from contatos");
4. ResultSet rs = stmt.executeQuery();
5.
6. List<Contato> list = new ArrayList<Contato>();
7.
8. while (rs.next()) {
9. // criando o objeto Contato 
10. Contato contato = new Contato();
11. contato.setNome(rs.getString(“nome”));
12. contato.setEmail(rs.getString(“email”));
13. contato.setEndereco(rs.getString(“endereco”));
14.
15. // adicionando o objeto à lista
16. list.add(contato);
17. }
18. 
19. rs.close();
20. stmt.close();
21.
22. return list;
23. }
4.11 - Exercícios
1-) Vamos usar o método lista agora para listar todos os contatos do nosso 
banco de dados:
Passo 1: Crie uma classe chamada TestaListaDAO com um método main
Passo 2: Pegue uma conexão no nosso ConnectionFactory:
Connection con = ConnectionFactory.getConnection();
Passo 3: Crie um ContatoDAO para essa conexão:
ContatoDAO dao = new ContatoDAO(con);
Passo 4: Liste os contatos com o DAO:
List<Contato> contatos = dao.getLista();
Passo 5: Itere nessa lista e imprima as informações dos contatos:
for (Contato contato : contatos) {
System.out.println(“Nome: “ + contato.getNome());
System.out.println(“Email: “ + contato.getEmail());
System.out.println(“Endereço: “ + contato.getEndereco() + “\n”);
}
Passo 6: Feche a conexão
con.close();
Capítulo 4 - JDBC – java.sql - Página 17
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
4.12 - Um pouco mais...
1-) Assim como o MYSQL existem outros bancos de dados gratuitos e open 
source na internet. O HSQLDB é um banco desenvolvido em Java que pode ser 
acoplado a qualquer aplicação e libera o cliente da necessidade de baixar qualquer 
banco de dados antes da instalação de um produto Java!
2-) O Hibernate tomou conta do mercado e virou febre mundial pois não se faz 
necessário escrever uma linha de código SQL!
3-) Outros projetos como o Hibernate são bastante famosos como o OJB e o 
Torque, cada um com suas próprias características implementando a funcionalidade 
de ORM.
4-) O Prevayler, iniciativa brasileira, funciona como uma camada de 
prevalência de seus objetos, de uma maneira muito diferente de uma ferramenta de 
ORM convencional.
5-) Se um projeto não usa nenhuma das tecnologias de ORM disponíveis, o 
mínimo a ser feito é seguir o DAO.
4.13 - Exercícios
1-) Remova dados do banco de dados através da query DELETE.
2-) Use cláusulas where para refinar sua pesquisa no banco de dados. Por 
exemplo: where nome like 'C%'
3-) Crie o método pesquisar que recebe um id (int) e retorna um objeto do tipo 
Contato.
4-) Crie o método remover na sua classe de DAO, ele recebe um id (int).
5-) Use a classe de DAO para procurar e remover contatos do banco de dados.
6-) Altere o último exemplo para que o nome, email eendereço do contato 
sejam perguntados ao usuário. Use esse programa novo para adicionar algumas 
entradas no banco de dados.
Relembrando java.io
Para a leitura de linhas do usuário podemos usar o código a seguir:
BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Entre com o nome: ");
String nome = buffer.readLine();
4.14 - Desafios
1-) Faça conexões para outros tipos de banco de dados disponíveis.
4.15 - Fixando o conhecimento
1-) Crie uma classe chamada Cliente com os campos id (Integer), nome, 
endereco, telefone (String) e data de nascimento (java.util.Date). Baseado nela:
a) crie uma tabela no banco de dados
b) crie uma classe do tipo DAO
Capítulo 4 - JDBC – java.sql - Página 18
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
c) use-a para instanciar novos clientes e colocá-los no seu banco
Capítulo 4 - JDBC – java.sql - Página 19
CONTÊINER
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
5Servlet Contêiner
“Que ninguém se engane: só se consegue a simplicidade através de muito 
trabalho.”
Clarice Lispector -
O que é e como funciona um servlet conteiner.
5.1 - Introdução
Da necessidade de gerar conteúdo dinâmico surgiram primeiro os programas 
de CGI (Common Gatway Interface).
Através de linguagens como C, C++, Perl, ASP, PHP, Cobol, Delphi, Shell etc, 
foi possível gerar conteúdo que permite ao usuário acesso à diversas funcionalidades 
através de páginas HTML, como quando você deseja comprar produtos em uma loja 
virtual.
Para melhorar o desempenho do último, inventaram o que viria a ser uma 
servlet, uma nova forma de trabalhar com requisições de clientes via web que 
economiza o tempo de processamento de uma chamada e a memória que seria 
gasta para tal processo, além de ser em Java e possuir todas as vantagens e 
facilidades de orientação a objeto.
Além do mais, servlets são portáveis tanto quanto qualquer programa escrito 
em Java, e aqueles que programam servlets não precisam mais se preocupar com a 
funcionalidade do servidor, que já foi escrita para nós e não precisa ser alterada.
HTML
Este curso tem como pré-requisito o conhecimento de HTML: saber utilizar as tags 
principais para a construção de páginas dinâmicas (html, body, form, input, textarea 
e select).
No caso de ainda não estar acostumado com páginas HTML, recomenda-se que tente 
ler algum tutorial para que não apareçam dificuldades durante o curso.
Em breve iremos estudar as servlets, mas antes estudaremos o JSP (Java 
Server Pages), que é como escrevemos a maior parte de nossas páginas dinâmicas 
em Java. 
5.2 - Servlet Contêiner
O contêiner é o componente responsável pelo controle das servlets: ele a 
instancia e utiliza à medida que se faz necessário.
É importante frisar que a mesma instância de uma servlet (o mesmo objeto) 
pode ser chamada mais de uma vez para diferentes requisições ao mesmo tempo.
Capítulo 5 - Servlet Contêiner - Página 20
capítulo 5
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
Atenção: Toda servlet deve possuir um construtor sem argumentos para que 
o contêiner possa criá-la.
O servlet contêiner inicializa a servlet e a usa durante todo o seu período ativo, 
até que irá desativá-la através do método destroy, para então liberar o objeto. 
Parâmetros de inicialização podem ser passados para a servlet e serão explicados 
mais adiante na seção de web.xml.
5.3 - Tipos de contêiner
Os 3 tipos mais comum de 
instalação de servlet contêiners 
e webservers são mostrados no 
gráfico.
No primeiro, todas as 
requisições vão direto para o 
webserver, que também é o 
contêiner.
No tipo dois, o webserver 
usa o contêiner como um plugin 
e envia as requisições 
pertinentes ao mesmo, 
enquanto, no tipo três, as 
requisições são feitas 
diretamente ao webserver ou ao 
contêiner.
Tomcat
Baixe o tomcat em http://jakarta.apache.org no link de download binaries. A última 
versão em 2005 era a 5.0 com suporte a api 2.4 de servlets.
O Tomcat virou implementação padrão e referência de novas apis de servlets, isto é, 
quando uma nova especificação surge, o tomcat costuma ser o primeiro servlet 
contêiner a implementar a nova api.
5.4 - Instalando o tomcat
Para instalar o Tomcat na Caelum, digite os passos a seguir no console 
(atenção em pôr o número da versão do tomcat no lugar de xxxx):
cp /caelum/jakarta-tomcat-xxxx.tar.gz ~/
cd ~
tar zxvf jakarta-tomcat-xxxx.tar.gz
Ao baixar o tomcat para o Windows em casa, você pode pegar uma versão que 
é o instalador .exe ou um .zip e descompactá-lo.
5.5 - Iniciando o tomcat
Entre no diretório de instalação e rode o programa startup.sh:
cd ~/jakarta-tomcat-xxxx/bin
./startup.sh
Capítulo 5 - Servlet Contêiner - Página 21
Clientes
Webserver + 
Servlet Contêiner 
juntos
Webserver
Servlet Contêiner
Webserver
Servlet Contêiner
Tipo 1 Tipo 2 Tipo 3
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
5.6 - Parando o tomcat
Entre no diretório de instalação do tomcat e rode o programa shutdown.sh:
cd ~/jakarta-tomcat-xxxx/bin
./shutdown.sh
Capítulo 5 - Servlet Contêiner - Página 22
JSP
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
6JSP e JSTL – Java Server Pages
“Que ninguém se engane: só se consegue a simplicidade através de muito 
trabalho.”
Clarice Lispector -
Nesse capítulo, você aprenderá:
• o que é JSP;
• o que é JSTL;
• taglib core.
6.1 - JSP
Agora que já instalamos o Tomcat, podemos nos preocupar com criar a nossa 
primeira aplicação web, que será baseada na tecnologia chamada de JSP, Java 
Server Pages, páginas dinâmicas que geram normalmente conteúdo html para 
servidores web.
Começamos importando o projeto projeto-jsp dentro do Eclipse. Ele possui a 
seguinte estrutura de diretórios e arquivos que irá facilitar o seu trabalho toda vez 
que você quiser criar um projeto desse tipo:
- src: diretório onde se encontram suas 
classes. Repare que existem duas classes dentro do 
pacote br.com.caelum.webbasico.modelo.
- target: diretório da sua aplicação web de 
verdade. Tudo que sua aplicação web precisa está 
aqui dentro. Coloque nesse diretório os arquivos de 
extensão html, jpg, gif, swf, jsp etc.
- target/WEB-INF/: todos os arquivos e 
diretórios dentro do diretório WEB-INF (maiúsculo) é 
invisível para o cliente final, portanto jamais coloque 
páginas html aqui, pois não serão acessíveis, 
exatamente por esse motivo colocamos os arquivos 
de configuração do banco de dados, de suas servlets 
etc nesse diretório.
- target/WEB-INF/classes: todas as classes 
são geradas dentro deste diretório (para mudar esta 
opção, consulte as instruções sobre o eclipse).
- target/WEB-INF/lib: aqui estão as bibliotecas (arquivos .jar) que serão 
necessárias para nossa aplicação web. Esses arquivos compõem o que iremos 
chamar mais adiante de JSTL.
- ListaDeTeste.java: esta classe extende java.util.ArrayList e representa uma 
lista que já inclui três mensagens em si mesmo automaticamente.
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 23
capítulo 6
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
- Mensagem.java: esta classe representa uma mensagem, com campos do 
tipo String representando quem enviou a mesma, para quem ela está indo, o corpo 
dela e um campo do tipo double com o custo do envio dessa mensagem.
- web.xml: esse arquivo representa a estrutura da nossa aplicação web, o 
arquivo que você terá descompactado não possui nenhuma informação vital, 
somente o básico para toda aplicação web.
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"version="2.4">
 <display-name>Aplicacao web simples</display-name>
</web-app>
WEB-INF/lib
O diretório lib dentro do WEB-INF pode conter todas as bibliotecas necessárias para a 
aplicação web, evitando assim que o classpath da máquina que roda a aplicação 
precise ser alterado.
Além do mais, cada aplicação web poderá usar suas próprias bibliotecas com suas 
versões específicas!
6.2 - Configurando o Tomcat
Vamos então configurar o tomcat. Para isso basta criar um arquivo de extensão 
xml com o nome de sua aplicação no diretório tomcat/conf/Catalina/localhost.
Iremos configurar a url /jspteste para o diretório 
/home/usuario/workspace/projeto-jsp/target/. Queremos também permitir que o 
tomcat faça o restart de sua aplicação sempre que julgar necessário.
Passo 1. vá para o diretório tomcat/conf/Catalina/localhost 
Passo 2. crie um arquivo chamado jspteste.xml
Passo 3. escreva o código a seguir no seu arquivo:
<Context path="/jspteste" docBase="/home/usuario/workspace/projeto-jsp/target/" debug="0" 
reloadable="true">
</Context>
O arquivo xml de configuração do tomcat
O processo de editar esse arquivo xml a mão só é feito na máquina do desenvolvedor, 
conforme veremos no capítulo que explica os arquivos .war.
Em processos de build mais desenvolvidos, não existe configuração a ser feita nem 
mesmo na máquina de desenvolvimento, sendo tudo automatizado por processos de 
build e deploy.
6.3 - O que é uma página JSP
O primeiro arquivo jsp que vamos criar é o chamado bemvindo.jsp. Esse 
arquivo poderia conter simplesmente código html, como o código a seguir:
<html>
Bem vindo
</html>
Afinal, JSP é uma página html comum que também contem código Java – e 
possui extensão jsp, claro.
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 24
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
Assim, fica claro que uma página jsp nada mais é que um arquivo baseado em 
html. Podemos adicionar também código java, portanto não seremos tão simplistas: 
seremos elegantes ao ponto de escrever um código java na nossa página. Que tal 
declarar uma variável do tipo String:
<%
String s = “Bem vindo!”;
%>
Simples! Para escrever código java na sua página basta escrevê-lo entre as 
tags <% e %>. Esse código é chamado de scriplet.
Essa idéia de colocar código de uma linguagem de programação junto com 
html não é tão nova. A Netscape possuia o SSJS (Server-Side Javascript) por 
exemplo, usando código baseado em javascript.
Scriplet
Scriplet é o código escrito entre <% e %>, esse nome é composto da palavra script 
(linguagem de script) com o sufixo let, que indica algo pequeno.
A Sun possui essa mania de colocar o sufixo let em muitas coisas como os scriptlets, 
servlets, portlets etc.
Podemos avançar mais um pouco com jsp e utilizar uma das variáveis já 
implicitas no jsp: todo arquivo jsp já possui uma variável chamada out (do tipo 
JspWriter) que permite imprimir objetos através do método println:
<% out.println(s); %>
Ou ainda podemos utilizar um atalho (muito parecido, ou igual, a outras 
linguagens de script para a web):
<%= s %><br>
Agora já estamos aptos a escrever o nosso primeiro jsp:
Passo 1. Crie o arquivo chamado bemvindo.jsp. Em qual diretório ele deve ser 
criado?
Passo 2. Digite o código a seguir.
<html>
<%
String s = "Bem vindo!";
%>
Duas versões diferentes na hora de imprimir algo:<br>
<% out.println(s); %><br>
<%= s %><br>
</html>
Passo 3. Acesse o site, o link é:
http://localhost:8080/jspteste/bemvindo.jsp
Comentários
Os comentários em uma página jsp devem ser feitos como o exemplo a seguir:
<%-- comentário em jsp --%>
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 25
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
6.4 - Exercício
1-) Se você possuísse um arquivo chamado database.properties, em que 
diretório você o colocaria?
2-) Em qual diretório você deve compilar suas classes? Porque esse diretório 
está dentro do diretório WEB-INF?
3-) Crie um javabean:
a) pacote br.com.caelum.webbasico.exercicio1
b) classe Livro
c) atributo String autor
d) atributo java.util.Date dataDePublicacao
e) atributo int paginas
f) atributo double preco
g) atributo boolean promocao
h) métodos get e set para cada um dos atributos
6.5 - Listando os contatos
Vamos avançar um pouco e escrever mais código nas nossas páginas jsp.
Poderíamos criar agora uma página que instancia um ContatoDAO do capítulo 
de JDBC e lista a tabela em forma de código html.
Iremos trabalhar com scriplets portanto a maior parte do código ficará entre 
tags do tipo <% e %>.
Vamos criar um ContatoDAO e listar todos os contatos usando o método 
getLista. Podemos visualizar o código final e ver realmente o que acontece e quão 
complicado ele fica:
<%@ page import="br.com.caelum.jdbc.*" %>
<%@ page import="br.com.caelum.jdbc.dao.*" %>
<%@ page import="br.com.caelum.jdbc.modelo.*" %>
<html><ul>
<%
java.sql.Connection con = ConnectionFactory.getConnection();
ContatoDAO dao = new ContatoDAO(con);
for (Contato contato : dao.getLista() ) {
%>
<li><%=contato.getNome()%>, <%=contato.getEmail()%>:
<%=contato.getEndereco()%></li>
<%
}
%>
</ul></html>
6.6 - HTML e Java: eu não quero código Java no meu jsp!
É complicado ficar escrevendo Java em seu arquivo jsp não é?
Primeiro fica tudo mal escrito e difícil de ler. O Java passa a atrapalhar o 
código html.
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 26
JSTL
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
Depois, quando o responsável pelo design gráfico da página quiser alterar algo 
terá que conhecer Java para entender o que está escrito lá dentro... hmm... não 
parece uma boa solução.
Uma idéia boa é o MVC, que será visto mais adiante neste curso.
6.7 - JSTL
Então seguindo a idéia de melhorar o código java que precisa de uma maneira 
ou de outra ser escrito na página jsp, a Sun sugeriu o uso da JavaServer Pages 
Standar Tag Library.... a JSTL.
A JSTL é a api que encapsulou em tags simples toda a funcionalidade que 
diversas páginas web precisam, como controle de laços (fors), controle de fluxo do 
tipo if else, manipulação de dados xml e internacionalização de sua aplicação.
Existe ainda uma outra parte famosa da JSTL, aquela que acessa banco de 
dados e permite escrever códigos sql na nossa página, mas se o designer não 
compreende java o que diremos de SQL??? O uso de tal parte da JSTL é 
desencorajado.
A JSTL foi a forma encontrada de padronizar o trabalho de milhares de 
programadores de páginas JSP.
6.8 - As empresas hoje em dia
Muitas páginas jsp no mundo ainda possuem muitos pedaços de scriplets 
espalhados dentro dela mesma.
Recomendamos a todos os nossos alunos que optarem pelo jsp como camada 
de visualização que utilizem a jstl e outras bibliotecas de tag para evitar o código 
incompreensível que pode ser gerado com scriplets.
O código das scriplets mais confundem do que ajudam, tornando a 
manutenção da página jsp cada vez mais custosa para o programador e para a 
empresa.
6.9 - Instalação
Para instalar a implementação mais famosa da JSTL basta baixar a mesma no 
site jakarta.apache.org.
Ao descompactar o arquivo, você irá encontrar os arquivos .jar que estão no 
diretório lib do seu projeto. Eles são a implementação padrão da JSTL feita pelo 
grupo jakarta.
Ao usar o jstl em alguma página precisamos primeiro definir o cabeçalho para 
utilizá-la. Existem quatro apis básicas e iremos aprender primeiro a utilizar a 
biblioteca chamada de core.
6.10 - Cabeçalho para a jstl core
Para utilizar a api do core precisamos adicionar o cabeçalho:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core"prefix="c" %>
6.11 - For
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 27
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
Usando a jstl core, vamos escrever o arquivo que lista todos contatos.
Primeiro o cabeçalho:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
Depois precisamos instanciar e declarar nossa variável. Revendo um pouco a 
variável que queremos criar:
• classe: br.com.caelum.jdbc.dao.ContatoDAO
• construtor: sem argumentos
• variável: dao
Vamos utilizar aqui uma ação que já é muito mais antiga que a jstl, vamos 
utilizar um bean, portanto a tag se chama jsp:useBean:
<jsp:useBean id="dao" class="br.com.caelum.jdbc.dao.ContatoDAO"/>
A partir deste momento, temos a variável dao no chamado escopo de página, 
que é onde os beans ficam armazenados. Podemos mostrar o nome do primeiro 
contato usando a jstl core. Para isso usaremos o prefixo configurado no cabeçalho: c.
<c:out value="${dao.lista[0].nome}"/>
Ou o seu e-mail:
<c:out value="${dao.lista[0].email}"/>
Que tal? Ainda não é tão elegante quanto queríamos, certo? O código dentro 
do atributo value é chamado de Expression Language (EL), e é parte de uma 
linguagem que vamos ver um pouco durante esse curso. Queremos então iterar e:
• array ou coleção: dao.lista
• variável temporária: contato
A jstl core irá criar para nós a variável contato para cada contato dentro da 
coleção chamada dao.lista (a coleção devolvida pelo método getLista do 
ContatoDAO).
<c:forEach var="contato" items="${dao.lista}">
<li>${contato.nome}, ${contato.email}: ${contato.endereco}</li>
</c:forEach>
Mais elegante que o código que foi apresentado usando scriplets, não?
forEach e varStatus
É possível criar um contador do tipo int dentro do seu laço forEach. Para isso basta 
definir o atributo chamado varStatus para a variável desejada e utilizar a propriedade 
count dessa variável.
<c:forEach var="contato" items="${dao.lista}" varStatus="id">
<li>${id.count} - ${contato.nome}</li>
</c:forEach>
6.12 - Exercícios
1-) Liste os contatos de ContatoDAO usando jsp:useBean e jstl.
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 28
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
Passo 1. Crie o arquivo lista-elegante.jsp
Passo 2. Preencha o arquivo:
a) Coloque o cabeçalho com a taglib e o <html>
b) Coloque o useBean
c) Faça o forEach
ci)Use o </html>
Passo 3. Acesse a página jsp através do browser. Repare que após criar uma 
nova página jsp não precisamos reiniciar o nosso container!
Solução:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<!-- cria a lista -->
<jsp:useBean id="dao" class="br.com.caelum.jdbc.dao.ContatoDAO"/>
<!-- for -->
<c:forEach var="contato" items="${dao.lista}">
<li>${contato.nome}, ${contato.email}: ${contato.endereco}</li>
</c:forEach>
</html>
2-) Scriplets ou JSTL. Qual dos dois é mais fácil para o designer entender?
6.13 - Import: trabalhando com cabeçalhos e rodapés
Uma pergunta que sempre aparece na vida dos programadores é a de como 
executar o código de outro arquivo jsp dentro de um primeiro arquivo jsp, isto é, 
você quer colocar um cabeçalho? Um rodapé?
Existe uma tag da jstl core que faz isso para você:
<c:import url="outrapagina.jsp"/>
6.14 - Exercícios
1-) Crie uma página chamada jstl-import.jsp.
a) Defina a jstl core
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
b) Importe cabecalho.jsp
c) Escreva alguma mensagem de texto
c) Importe rodape.jsp
2-)Crie a página cabecalho.jsp e escreva:
<html><header><h2>Aplicacao web basica</h2><br/></header>
3-) Crie a página rodape.jsp e escreva:
<br/><hr/>Copyright Caelum, 2004-2005</html>
4) Teste no browser abrindo o endereço: 
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 29
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
http://localhot:8080/jspteste/jstl-import.jsp 
welcome-file-list
O arquivo web.xml acima diz que os arquivos chamados “bemvindo.jsp” são os 
arquivos que devem ser chamados quando um cliente tenta acessar um diretório web 
qualquer.
O valor desse campo costuma ser “index.html” em outras linguagens de programação.
Você pode indicar mais de um arquivo para ser o seu welcome-file!
Por exemplo:
<welcome-file-list>
<welcome-file>bemvindo.jsp</welcome-file>
</welcome-file-list>
E acesse a URL:
http://localhost:8080/jspteste/
6.15 - Desafios
1-) Configure no eclipse os arquivos .jar. Porque tudo funcionou mesmo sem 
fazer tal configuração?
Capítulo 6 - JSP e JSTL – Java Server Pages - Página 30
SERVLET
CGI
HTTP
HTTPSERVLET
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
7Servlets
“Vivemos todos sob o mesmo céu, mas nem todos temos o mesmo horizonte.”
Konrad Adenauer -
Neste capítulo você irá aprender a criar pequenos objetos que funcionam como aplicações 
web.
7.1 - Servlet
Uma servlet funciona como um pequeno servidor (servidorzinho em inglês) 
que recebe chamadas de diversos clientes.
Cada servlet é um objeto que recebe tais chamadas e retorna algo, como por 
exemplo uma página html ou uma imagem do formato jpeg.
Diversas requisições podem 
ser feitas à uma mesma servlet ao 
mesmo tempo em um servidor, por 
isso ela é mais rápida que um 
programa CGI comum.
Novos dados não precisam 
ser criados para que o servidor 
execute sua nova tarefa.
O diagrama ao lado mostra 
três clientes acessando o mesmo 
servidor web/contêiner de servlets 
através do protocolo http.
A página a ser retornada pela 
servlet pode ser um jpeg, um gif, 
um arquivo html etc: arquivos de 
texto ou simplesmente binários.
O comportamento das servlets que iremos ver neste capítulo foi definido na 
classe HttpServlet do pacote javax.servlet. Eles se aplicam às servlets que 
trabalham através do protocolo Http.
A interface Servlet é a que define exatamente como uma servlet funciona, 
mas não é necessariamente o que vamos utilizar neste capítulo.
O funcionamento básico de uma servlet compreende:
- a inicialização da mesma, quando parâmetros podem ser lidos e variáveis 
comuns a todas as requisições devem ser inicializadas. Por exemplo, conexões ao 
banco de dados são estabelecidas nesse momento
Capítulo 7 - Servlets - Página 31
capítulo 7
Cliente IE
Servidor Web
----------------
Servlet 
Contêiner
recebe 
requisições via 
http
Cliente 
Firefox
Cliente
Opera
SINGLETHREAD
MODEL
Caelum – http://www.caelum.com.br - Java para desenvolvimento Web
void init (ServletConfig config);
- chamadas a métodos de serviço
void service(ServletRequest req, ServletResponse 
res);
- finalização, quando os recursos devem 
ser liberados
void destroy();
O exemplo a seguir mostra uma servlet 
implementando os métodos de inicialização, 
finalização e o service:
1. package br.com.caelum.servlet;
2.
3. import java.io.*;
4.
5. import javax.servlet.*;
6. import javax.servlet.http.*;
7.
8. public class OiMundo extends HttpServlet {
9.
10. public void destroy() {
11. super.destroy();
12. System.out.println("Destruindo a servlet");
13. }
14.
15. public void init() throws ServletException {
16. super.init();
17. System.out.println("Iniciando a servlet");
18. }
19.
20. protected void service(HttpServletRequest request, 
 HttpServletResponse response) throws ServletException, 
IOException {
21.
22. // recebe o writer
23. PrintWriter out = response.getWriter();
24.
25. // escreve o texto
26. out.println("<html>");
27. out.println("Caelum explica");
28. out.println("</html>");
29. }
30. }
Servlets e concorrência
Muitos programadores que começam a usar servlets acabam esquecendo dos 
problemas que