Desenvolvimento para Web com Java

Everton Coimbra de Araújo
Desenvolvimento
para Web
com Java
Visual Books
Sumário
Prefácio ...........................................................................13
Introdução ......................................................................15
1 Preparando o Ambiente para o
Desenvolvimento .....................................................19
1.1 Internet como Plataforma ....................................................... 19
1.2 Execução das Aplicações ........................................................ 21
1.3 Distribuindo as Aplicações .................................................... 23
1.4 Preparando o Ambiente Para Desenvolvimento ................ 24
1.4.1 Obtendo e Instalando o Apache Tomcat ........................... 24
1.4.2 Iniciando (Startando) o Tomcat .......................................... 25
1.5 Praticando ................................................................................ 29
1.5.1 Uma Página com Conteúdo Estático ................................. 29
1.6 Resumo do Capítulo ............................................................... 31
2 Técnicas para Deploy ..............................................33
2.1 Estrutura de Uma Aplicação WEB ........................................ 33
2.2 Criando um Projeto no Eclipse ............................................. 34
2.2.1 Implantando a Aplicação Web Básica ............................... 38
2.3 Técnicas para Deploy .............................................................. 39
2.3.1 Criando um Web Application ARchive (WAR) ............... 39
2.3.2 Utilizando a Aplicação Manager do Tomcat para
Deploy e Undeploy .............................................................. 41
2.3.3 Utilizando ANT para Processo de Empacotamento e
Deploy de uma Aplicação Web ......................................... 43
2.4 Resumo do Capítulo ............................................................... 50
3 Servlets ........................................................................51
3.1 Criando um Projeto para Testar o uso de Servlets ............. 51
3.1.1 Criando o Servlet .................................................................. 52
3.1.2 Entendendo o que Foi Feito ................................................ 56
3.1.3 Configurando a Aplicação para Conhecer o Servlet ....... 56
3.1.4 Implementando o Comportamento do Servlet ................ 58
3.1.5 Testando o Servlet Criado ................................................... 59
3.1.5.1 Erros Possíveis ao Fazer Uso do Ant Integrado
ao Eclipse ............................................................................ 59
3.2 Obtendo Dados Através de um Servlet ............................... 60
3.2.1 Entendendo o que Foi Feito ................................................ 62
3.2.2 Testando o Servlet ................................................................ 62
3.2.3 Entendendo a URL ............................................................... 63
3.2.4 Usando o Método Post ........................................................ 64
3.3 Resumo do Capítulo ............................................................... 66
4 Web Tools Platform .................................................67
4.1 Criando Projeto para Testar o WTP ...................................... 67
4.2 Implementando uma Funcionalidade ao Novo Projeto .... 72
4.3 Configurando e Habilitando o Tomcat no Eclipse
Através do WTP ....................................................................... 73
4.4 Realizando o Deploy Através do WTP ................................ 75
4.5 Iniciando e Parando o Tomcat Através do WTP ................ 77
4.6 Executando a Aplicação ......................................................... 78
4.7 Criando Servlet com Auxílio do WTP .................................. 79
4.8 Implementando a Funcionalidade no Servlet ..................... 82
4.8.1 Validando os Valores Informados ..................................... 84
4.8.2 Aplicando Boas Práticas ...................................................... 86
4.9 Resumo do Capítulo ............................................................... 87
5 Java Server Pages......................................................89
5.1 Criando uma Página JSP com Conteúdo Estático .............. 89
5.2 Testando o Arquivo JSP Criado ............................................ 91
5.3 Entendendo o que é um Arquivo JSP ................................... 91
5.3.1 O Ciclo de Vida de um Arquivo JSP ................................. 92
5.4 Usando o JSP para Validar uma Requisição ....................... 94
5.5 Criando Páginas de Erros Configuráveis Através do
web.xml ..................................................................................... 96
5.5.1 Obtendo Informações do Erro Ocorrido ......................... 100
5.6 Prevendo a Possibilidade de Ocorrência de Erro em um
JSP ............................................................................................ 101
5.7 Resumo do Capítulo ............................................................. 104
6 Acesso a Dados com JSP e Servlets ................... 105
6.1 Escolhendo o Banco de Dados para as Implementações 105
6.2 Preparando o Ambiente para Uso do Apache Derby ...... 105
6.3 Criando um Projeto para Acesso a Dados ......................... 106
6.4 Criando o Banco de Dados e a Primeira Tabela ............... 108
6.5 Autenticando o Usuário com Acesso ao Banco de
Dados ....................................................................................... 111
6.5.1 Entendendo a Implementação do Método que Acessa
Dados ................................................................................... 112
6.5.2 Delegando a Autenticação ................................................ 114
6.6 Acessando Dados Através de uma Página JSP ................. 116
6.6.1 Listando os Dados de uma Tabela .................................. 117
6.7 Resumo do Capítulo ............................................................. 119
7 Fazendo Uso do MVC com FrontController ... 121
7.1 Características do Desenvolvimento de Aplicações
Web com Servlets e JSPs ....................................................... 121
7.2 Model-View-Controller (MVC) ........................................... 122
7.3 Front Controller ..................................................................... 124
7.3.1 Participantes e Responsabilidades .................................. 124
7.4 Implementando um Exemplo Básico com MVC e
FrontController ...................................................................... 126
7.4.1 Implementando o FrontController ................................... 127
7.5 FrontController com Formulário HTML ............................ 130
7.5.1 Padrão de Projeto Singleton ............................................. 132
7.5.2 Data Access Object (DAO) ................................................. 134
7.6 Fazendo Uso de Tags JSP, Beans e Scriptlets para a
Recuperação de Dados em uma Página JSP ...................... 138
7.7 Fazendo Uso de JSTL para a Recuperação de Dados
em uma Página JSP ................................................................ 140
7.8 Resumo do Capítulo ............................................................. 141
8 Java Server Faces ................................................... 143
8.1 Obtendo uma Implementação Java Server Faces ............. 143
8.2 Implementando em JSF ......................................................... 144
8.2.1 Criando uma Página JSP para o Projeto JSF ................... 147
8.2.2 Configurando a Aplicação Web para o Uso de JSF ....... 149
8.2.3 Managed Beans ................................................................... 150
8.2.3.1 Escopos para Managed Beans ....................................... 152
8.2.4 Executando a Aplicação .................................................... 154
8.2.4.1 View State em JSF ............................................................ 154
8.2.5 Navegação entre Páginas .................................................. 157
8.3 Resumo do Capítulo ............................................................. 158
9 Java Persistence API (JPA) ................................... 159
9.1 POJOs como Entities ............................................................. 159
9.2 Obtendo uma Implementação da JPA ................................ 161
9.3 Configurando o Projeto para Fazer Uso de JPA ............... 162
9.4 Criando a Página JSF que Fará Uso da JPA ....................... 164
9.5 Executando a Aplicação ....................................................... 165
9.6 Listando os Registros Inseridos/Existentes ...................... 166
9.7 Alterando Registros .............................................................. 169
9.8 Removendo Registros ........................................................... 176
9.9 Resumo do Capítulo ............................................................. 181
10 RichFaces ............................................................... 183
10.1 Configurando o Ambiente de Desenvolvimento ........... 183
10.2 Criando a Primeira Aplicação RichFaces ......................... 185
10.3 Adicionando AJAX .............................................................. 187
10.3.1 Realizando o Submit Através do AJAX ........................ 188
10.3.2 Realizando uma Atualização Parcial na Página .......... 189
10.3.3 Dando Suporte AJAX aos Controles .............................. 190
10.4 Acrescentando Validadores ............................................... 190
10.5 Panel com Abas .................................................................... 194
10.6 Simple Toggle Panel ........................................................... 200
10.7 Modal Panel ......................................................................... 204
10.8 Melhorando a Implementação ........................................... 208
10.8.1 Enviando Parâmetros para Atributos de um
Managed Bean ................................................................... 208
10.8.2 Capturando as Fases do Ciclo de Vida de
Requisições JSF ................................................................. 209
10.8.3 Melhorando a Forma de Permitir ou Negar a
Renderização de um Controle ........................................ 211
10.8.4 Fazendo Uso de Logs ....................................................... 213
10.9 Resumo do Capítulo ........................................................... 214
11 Facelets ................................................................... 215
11.1 Obtendo o Facelets .............................................................. 215
11.2 Criando Aplicação e Configurando-a para o Uso
Facelets .................................................................................. 215
11.3 Criando Páginas JSF com Facelets .................................... 216
11.4 O que são Templates? ......................................................... 219
11.5 Implementando Templates com o Facelets ..................... 220
11.5.1 Navegabilidades ............................................................... 223
11.6 Resumo do Capítulo ........................................................... 225
12 Relatórios ............................................................... 227
12.1 O que são JasperReports e iReport? ................................. 227
12.2 Configurando o iReport para o Acesso a uma Base
de Dados ............................................................................... 228
12.3 Criando os Dados para Criação de Relatórios ................ 230
12.4 Criando um Relatório Inicial ............................................. 232
12.5 Visualizando o Relatório em Execução ........................... 237
12.6 Gerando o Relatório Através de uma Aplicação Web
com Uso de Servlets ............................................................ 238
12.7 Gerando o Relatório Através de uma Aplicação Web
Usando JSF ............................................................................ 239
12.8 Resumo do Capítulo ........................................................... 241
Referências ................................................................. 243