Blog Tecnologia e Educação

Neste artigo veremos como trabalhar com bancos de dados e JSP.

Esta aplicação poderia ser um exemplo de uma aplicação simples baseada em uso exclusivo de páginas JSP. Mas isto significaria não aproveitar os recursos de orientação a objetos proporcionada pelo Java.

Vamos então fazer um aplicativo com uma arquitetura MVC (Model-View-Controller). O NetBeans será utilizado como IDE para este desenvolvimento e o SGBDR será o Java DB.

Funcionalidades

Nosso aplicativo de exemplo é uma mera agenda de contatos

Diagrama de Caso de Uso

O usuário pode consultar sua lista de amigos, incluir novos, alterar ou excluir os cadastrados

Arquitetura

O desenvolvimento desta aplicação é dividido em três partes

• Modelo: Classes utilizadas para representação dos dados
• Controle: Classe que contém as regras da aplicação
• Visão: Páginas JSP com a interface da aplicação

Banco de Dados

Comecemos por criar um banco de dados. Vá à aba de serviços do NetBeans, clique com o botão direito do mouse no ícone do Java DB e selecione “Criar Banco de Dados”. Selecione um nome como “amigos”, o nome do usuário administrativo do banco e sua senha. Clique com o botão direito do mouse sobre o ícone do banco de dados recém-criado e selecione “Conectar”. Expanda o nó deste banco de dados, clique com o botão direito do mouse sobre “Tabelas” e selecione “Criar tabela”. Crie uma tabela com campos de identificação (numérico), prenome, sobrenome, telefone (este três são campos de texto) e data de nascimento (com formato de data).

Modelo

Pacote modelo

O modelo será composto por quatro elementos

• Conexao: Classe que tem apenas um método denominado “obterConexao” que retorna um java.sql.Connection referente à conexão com o banco de dados criado anteriormente
• Contato: Um JavaBeans que representará os registros da tabela de contatos. Além do necessário para configurar um JavaBeans, teremos o método “valido” para indicar se os dados são consistentes com o que se espera e um método para retornar a data de nascimento convertida para String. Foi adicionado também um atributo “mensagem” para armazenar mensagens de erro caso os valores não sejam válidos.
• DAO: Uma interface com assinatura dos métodos para atualizar, incluir e excluir registros na tabela, além de retornar um contato ou uma lista com todos os contatos.
• ContatoDAOImp: Uma classe que implementa DAO e um método “novoID” para calcular o valor da chave da primária antes de incluir um novo contato na tabela. As instruções SQL são construídas com PreparedStatement para facilitar a formatação dos dados e reduzir a possibilidade de ataques do tipo SQL Injection.

Controle

pacote Controle

O pacote de controle tem uma classe chamada “Controle“. Esta classe é um Servlet.

Escreveremos nela um método para converter uma String de uma data em um objeto java.util.Date.

No processamento da requisição (método “processRequest”) iremos examinar um parâmetro que denominaremos “acao”. Este parâmetro indicará o que desejamos fazer no momento. Sempre que possível este processamento irá criar um objeto “Contato” com os dados recebidos nos outros parâmetros. Dependendo do parâmetro “acao”, o processamento pode tomar distintos caminhos. Vejamos as possibilidades

• Inserção. Se os dados do objeto Contato forem válidos, ele invocará o método de inserção do “ContatoDAOImp” e recuperará uma lista de contatos armazenados. Se houver ao menos um registro na tabela será chamado o arquivo “listagem.jsp” ou, caso contrário, o arquivo “insercao.jsp”. Se os dados não forem válidos, será invocada a página “erro.jsp”
• Exclusão. Ele invocará o método de remoção de registro do ”ContatoDAOImp” e seguirá os mesmos passos realizados após uma inserção.
• Solicitação de alteração. Um objeto “Contato” é passado para “atualizar.jsp” para que possa ser criado um formulário HTML para obtenção dos dados a alterar.
• Alteração. Segue o mesmo princípio da inserção, apenas invocando o método de alteração no lugar do da inserção.
• Padrão. A ação padrão consiste em recuperar a lista de contatos e exibir “listagem.jsp” ou “insercao.jsp”.

Ao invocar “listagem.jsp”, faz-se necessário obter um java.util.List com todos os contatos, definí-lo como atributo da requisição (método “request.setAttribute”). Usamos os métodos “request.getRequestDispatcher” para definir a página de destino e “forward” em um objeto RequestDispatcher para desviar a execução para a página selecionada.

O desvio para a página de erro ou com o formulário de atualização cria um objeto com a interface HttpSession para atribuir um objeto “Contato” à sessão e transfere a execução para a página desejada.

Visão

A interface da aplicação é baseada em arquivos JSP. São eles

• index. Página inicial da aplicação e que contém apenas um link para o servlet “Controle”
• listagem. Exibe uma tabela com os contatos armazenados e um formulário para inclusão de novos contatos. Para reduzir a quantidade de código, utilizou-se JSTL. JSTL é uma biblioteca de tags e seu uso facilita a produção de páginas JSP.
• insercao. Este arquivo contém o formulário para inserção de contatos e é utilizado quando não há contatos no banco de dados.
• atualizar. Exibe um formulário com os dados de um contato para sua alteração. Para utilizar os atributos de um objeto “Contato”, é feita referência a um JavaBeans.
• erro. Utiliza o mesmo recurso da página “atualizar” para exibir a mensagem de erro produzida quando os dados do contato não são válidos.

Além dos cinco arquivos JSP citados foi utilizado um arquivo CSS e um arquivo com o formulário de inclusão que é incorporado às páginas “insercao.jsp” e “listagem.jsp”.

Obtenha as apresentações deste artigo. Você pode fazer o download da apresentação sobre JSP e banco de dados para exibição e a apresentação sobre JSP e banco de dados com notas.

Você pode declarar métodos e variáveis estáticas em documentos JSP. Para isto você utilizará as declarações. Estes métodos e variáveis podem ser invocados em outras partes do documento.

Para testar o uso de declarações, escreva o seguinte no início de um documento JSP:

<%! int visitas = 0;%>

No corpo do documento, insira o seguinte:

<h3>Número de acessos: <%= ++visitas %></h3>

Acesse seguidamente esta página e veja a quantidade de visitas ser incrementada.

Outra forma de obter o mesmo resultado é declarar, além da variável, um método como o seguinte:

<%!
private int qtdeVisitas() {
return ++visitas;
}
%>

Troque a exibição do resultado por

<%= qtdeVisitas() %>

E veja o resultado.

As páginas JSP utilizam diretivas para encaminhar instruções ao servidor sobre como compilar estas páginas durante sua transformação em Servlets. As diretivas não geram nenhuma saída visível, mas é importante para sua compilação.

Existem três tipos de diretivas:

• Página (page)
• Inclusão (include)
• Biblioteca de etiquetas (taglib)

As diretivas podem ser indicadas entre tags <%@ %> ou utilizando notação XML.

Diretivas de página

As diretivas de página afetam o comportamento da página em si. São 13 opções, como descritas a seguir

• language. Especifica a linguagem de programação utilizada na página. O valor padrão implicitamente definido é “Java”. Este é, aliás, o único valor aceito para esta diretiva. Pode ser utilizada em duas formas
  <%@page language=”Java” %>
  <jsp:directive.page language=”Java” />
• import. Equivalente ao uso do comando import em Java. Permite o uso de outras classes Java no código. Formas de uso:
  <%@page import=”java.util.*” %>
  <jsp:directive.page import=”java.util.*” />
  Esta diretiva foi utilizada no exemplo de tratamento de formulários em JSP.
• session. Indica se a página participa de uma sessão ou não. O valor padrão é “true”. Não participar de uma sessão fará com que exista ganho de desempenho na página. Por outro lado, isto também fará com que não seja possível o uso do objeto session ou de um Javabean com escopo de sessão. Formas de uso:
  <%@page session=”false” %>
  <jsp:directive.page session=”false” />
• buffer. Controla o tamanho do buffer da página. O padrão é “8kb”. Admite-se outros valores ou “none”. O comportamento padrão é enviar o conteúdo do buffer quando ele estiver cheio. O desempenho irá melhorar se o buffer não chegar a este ponto. Portanto, em páginas com muito conteúdo, o uso de buffer maior irá afetar positivamente o desempenho.
• autoFlush. Indica o comportamento de esvaziamento automático do buffer. O valor padrão é “true” e indica que os dados do buffer devem ser enviados para o cliente quando o buffer estiver cheio. Caso ele receba o valor “false”, os dados do buffer somente serão enviados quando o processamento da página encerrar ou com o uso do método out.flush(). O valor não pode ser definido como “false” se a diretiva buffer estiver com o valor “none”. Formas de uso:
  <%@page autoFlush=”false” %>
  <jsp:directive.page autoFlush=”false” />
  Veja este exemplo de diretivas buffer, autoFlush e método out.Flush() em JSP.
• isThreadSafe. O valor padrão é “true”, o que indica que o servidor J2EE pode criar threads distintas para responder diversas requisições simultâneas à mesma página. Se o valor for “false”, apenas uma requisição poderá ser atendida por vez. Formas de uso:
  <%@page isThreadSafe=”false” %>
  <jsp:directive.page isThreadSafe=”false” />
• info. O valor atribuído a info costuma ser uma String que pode ser recuperada em algum Servlet da aplicação com o método Servlet.getServletInfo() ou em página JSP com o método getServletInfo(). Formas de uso:
  <%@page info=”Diretiva info” %>
  <jsp:directive.page info=”Diretiva info” />
• errorPage. Indica uma URL relativa de uma página para a qual a página atual enviará exceções que podem ser obtidas com uso do objeto implícito exception. Formas de uso:
  <%@page errorPage=”/trataerro.jsp” %><jsp:directive.page errorPage=”/trataerro.jsp” />
• isErrorPage. Se definida como “true” indica que esta página terá acesso ao objeto implícito exception, podendo lidar com esta exceção. Formas de uso:
  <%@page isErrorPage=”false” %>
  <jsp:directive.page isErrorPage=”false” />
  Veja este exemplo de uso de diretivas errorPage e isErrorPage em JSP.
• contentType. Indica o tipo de MIME da página. O valor padrão é “text/html”. Formas de uso:
  <%@page contentType=”text/html” %>
  <jsp:directive.page contentType=”text/html” />
• pageEncoding. Define a codificação de caracteres da página. O valor padrão é “ISO-8859-1″, mas o uso de “UTF-8″ é recomendável. Formas de uso:<%@page pageEncoding=”UTF-8″ %>
  <jsp:directive.page pageEncoding=”UTF-8″ />
• isELIgnored. Define se expressões EL serão ignoradas (com o valor “true”) ou processadas. As expressões EL serão tratadas em outro artigo. Formas de uso:
  <%@page isELIgnored=”false” %>
  <jsp:directive.page isELIgnored=”false” />
• extends. Indicar o nome completo de uma superclasse que esta deva herdar. Esta opção deve ser utilizada com muito cuidado, pois pode alterar muito severamente o funcionamento da página.Formas de uso:
  <%@page extends=”java.lang.Object” %>
  <jsp:directive.page extends=”java.lang.Object” />

Diretivas de inclusão

As diretivas de inclusão são utilizadas para incluir um documento externo à página. Podem ser utilizadas para inserção de conteúdo padronizado (rodapés, cabeçalhos, menus e barras laterais, por exemplo) ou mesmo para outras páginas JSP. As formas de uso são:

• <%@include file=”cabecalho.html” %>
• <jsp:directive.include file=”cabecalho.html” />

Diretivas de bibliotecas de etiquetas

Indica uso de bibliotecas de etiquetas customizadas. As etiquetas customizadas serão tratadas em outro artigo.

Este material é um exercício para você aprender a manipular dados de formulários com JSP, utilizando NetBeans.

Roteiro para obtenção de dados de formulários em JSP

1. Crie um projeto tipo “Aplicação Web” na categoria “Aplicações Web” no NetBeans, sem utilizar nenhum framework.
2. Além do documento index.jsp (criado automaticamente), crie um novo documento JSP denominado resposta.jsp. O index.jsp conterá um formulário e o resposta.jsp vai exibir os dados obtidos neste formulário. Altere o conteúdo das tags title e h1 dos dois documentos JSP de maneira conveniente.
3. No index.jsp, insira um formulário após o h1 arrastando-o da paleta. Em “Ação”, procure o documento resposta.jsp e fornece um nome ao formulário. Organize este formulário com fieldset e legend.
4. Insira no formulário campos input de vários tipos (text, hidden, password, checkbox, radio, reset e submit) arrastando-os da paleta.
   • Obtenha, com input do tipo text, valores de texto, números e datas.
   • Utilize a tag label onde for coerente.
   • Utilize o atributo checked nos campos radio e checkbox, para indicar respostas pré-indicadas.
   • Utilize os atributos size e maxlength nos campos text e password.
   • Utilize também um elemento select com o atributo multiple e outro sem este atributo, utilizando os atributos selected em alguns dos elementos option.
   • Insira um elemento textarea. Faça com que os inputs, select e textarea sejam de uma mesma classe, exceto os inputs do tipo hidden, submit e reset ou outros necessários para a aparência da página.
5. Obtenha em resposta.jsp
   • os nomes dos campos com request.getParameterNames
   • conteúdo de campos de resposta única com request.getParameter e de campos de resposta múltipla com request.getParameterValues
   • tente converter valores numéricos e de data
   • tente obter outros dados com outros métodos do objeto request

Após tentar realizar estes passos, compare seu resultado com este Exemplo de tratamento de formulário em JSP. Mas esforce-se em fazer esta comparação apenas após ter realizado o maior esforço possível para resolver as tarefas propostas sozinho.

A apresentação de slides a seguir mostra os primeiros passos para trabalhar com JSP e NetBeans

A tecnologia JSP permite a construção de aplicações WEB robustas e dinâmicas com todas as vantagens associadas à tecnologia Java. Nesta apresentação veremos como instalar um ambiente para programação em JSP e como iniciar seu uso.

O conteúdo da apresentação é o seguinte:

• Instalação do ambiente Java
• Instalação da IDE NetBeans
• Configuração da IDE NetBeans
• Uso do NetBeans
• Configuração de navegadores de Internet
• Programação em JSP
• Delimitadores em JSP
• Comentários em JSP
• Tipos de Dados em JSP
• Variáveis e Finais em JSP
• Expressões em JSP

Você tem alguma sugestão para melhorar o conteúdo desta apresentação?

Divulgo aqui uma apresentação de slides sobre como a tecnologia Java pode ser utilizada no desenvolvimento de websites dinâmicos.

O conteúdo desta apresentação é o seguinte:

• Plataforma Java
• Servlets
• JSP
• Ciclo de vida de Servlets
• Ciclo de vida de JSP
• Servidores de conteúdo J2EE

Obtenha o arquivo de Soluções Java para Websites Dinâmicos

Este artigo é composto por uma apresentação de slides com conteúdo de aula de JSP.

A tecnologia JSP permite a construção de aplicações WEB robustas e dinãmicas com todas as vantagens associadas à tecnologia Java.

Para poder compreender o uso de JSP é preciso obter uma visão geral do funcionamento de aplicações na Internet e este é o objetivo deste material.

Esta apresentação é composta por

• Sites estáticos e dinâmicos
• Web 2.0
• Linguagens de programação para WEB
• Infrestrutura web
• Servidores de conteúdo
• Hospedagem de websites
• Navegadores
• Computação em Nuvem
• Protocolo HTTP

Vocês têm algum comentário?

Para implementação de cookies em JSP, utilizamos três arquivos:

• index.jsp – Página inicial
• gravacookie.jsp – Obtém dados de um formulário e grava-os em um cookie
• lecookie.jsp – Lê os dados de um cookie e exibe estes dados

Veja o conteúdo dos arquivos

Página inicial

<%--
Document   : index
Created on : 29/04/2009, 11:40:25
Author     : cid
--%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Cookies em JSP</title>
</head>
<body>
<h1>Obtendo dados</h1>
<form name="f_cookie" action="gravacookie.jsp" method="POST">
<label for="nome">Nome: </label>
<input type="text" name="nome" value="" size="20" /><br>
<input type="submit" value="Criar cookie" name="b_cookie" />
</form>
</body>
</html>

Gravando o cookie

<%--
Document   : gravacookie
Created on : 29/04/2009, 11:41:19
Author     : cid
--%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@page import="java.util.*" %>
<%
String nome = request.getParameter("nome");
if (nome == null) {
nome = "";
}
Date agora = new Date();
String timestamp = agora.toString();
Cookie ck = new Cookie("usuario", nome);
// o valor -1 indicaria que o Cookie existirá enquanto
// o navegador estiver aberto
ck.setMaxAge(365 * 24 * 60 * 60);
ck.setComment("Apenas para testes");

response.addCookie(ck);
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Cookies em JSP</title>
</head>
<body>
<h1>Gravando um cookie</h1>
<p>Cookie deve ter sido gravado com sucesso!</p><br>
<a href="lecookie.jsp">Veja o resultado</a>
</body>
</html>

Lendo a partir do cookie

<%--
Document   : lecookie
Created on : 29/04/2009, 11:41:28
Author     : cid
--%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%
String nomeCookie = "usuario";
Cookie cks[] = request.getCookies();
Cookie meuCookie = null;
if (cks.length > 0) {
for (int i = 0; i < cks.length; i++) {
if (cks[i].getName().equals(nomeCookie)) {
meuCookie = cks[i];
break;
}
}
}
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Cookies em JSP</title>
</head>
<body>
<h1>Obtendo resultados!</h1>
<%
if (meuCookie == null) {
%>
<p>O Cookie não foi localizado!</p>
<%    } else {
%>
<h2>Bem-vindo, <%= meuCookie.getValue()%></h2>
<%
}
%>
</body>
</html>

Além dos métodos citados no código temos mai um interessante: o setSecure(boolean). Utilize “true” em setSecure para indicar que este cookie só pode ser utilizado com HTTPS ou SSL.

Material de Aula para cursos de introdução à tecnologia JSP.

Conteúdo

• Infraestrutura de Internet
• Soluções Java para sites dinâmicos
• Tecnologias de interface com usuário
• Primeiros passos em JSP
• Estruturas de decisão e repetição em JSP (Estruturas if..else if..else, switch..case..default, try..catch..finally, while, do..while, for)
• Vetores e coleções de objetos em JSP (Vetores unidimensionais e multidimensionais; Collection, Set, HashedSet, TreeSet, List, ArrayList, LinkedList, Map, HashMap, TreeMap)
• Formulários e JSP
• Formulários com Javabeans e JSP
• Diretivas em JSP
• Declarações em JSP
• Cookies em JSP
• Sessões em JSP
• Banco de dados em JSP
• Servlets
• MVC e JSP

Referência

• Lógica de Programação e Algoritmos
  • Conteúdo geral de Lógica de Programação e Algoritmos
• HTML e CSS
  • Arquivo de referência
  • Ferramenta de Aprendizado de HTML
  • Cartão de Referência de HTML
  • Cartão de Referência de CSS
• Javascript
  • Miniapostila
  • Tutorial
  • Cartão de Referência
• Java
  • Cartão de Referência
  • Cartão Básico de Referência
  • Página de Referência
• JSP
  • Cartão de Referência JSP