P. 1
JSTL

JSTL

|Views: 1,039|Likes:
Published by Amanda Figueiredo

More info:

Published by: Amanda Figueiredo on Nov 18, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

07/09/2013

pdf

text

original

Sections

  • 1. A LINGUAGEM DE EXPRESSÕES
  • 1.1 Expressões e o tag <c:out>
  • 1.1.1 Qual a Aparência de uma Expressão
  • 1.1.2 Onde Expressões Funcionam
  • 1.1.3 Valor Default em <c:out>
  • 1.1.4 Caracteres Especiais e <c:out>
  • 1.2 Variáveis com Escopo e a Linguagem de Expressões
  • 1.2.1 Sintaxe Básica para Acessar Variáveis com Escopo
  • 1.2.2 Operações envolvendo Variáveis
  • 1.3 Parâmetros de Requisição e a Linguagem de Expressões
  • 1.4 Expressões mais Poderosas
  • 1.4.1 Diferentes formas de Acessar Propriedades
  • 1.4.2 Acessando Outros Dados Através da Linguagem de Expressões
  • 2. CONTROLANDO O FLUXO COM CONDIÇÕES
  • 2.1 Condições Sim-Não com <c:if>
  • 2.1.1 A Sintaxe Básica de <c:if>
  • 2.1.2 Utilizando <c:if> com Tags HTML
  • 2.1.3 Tags <c:if> Aninhados
  • 2.1.4 Os Atributos var e scope
  • 2.2 Condições Mutuamente Exclusivas
  • 3. CONTROLANDO O FLUXO COM ITERAÇÕES
  • 3.1 A Iteração de Propósito Geral com <c:forEach>
  • 3.2 Iteragindo sobre Strings com <c:forTokens>
  • 3.2.1 Como JSLT Efetua o Parse de Strings
  • 3.3 Iteração Avançada com <c:forEach> e <c:forTokens>
  • 3.3.1 Efetuando um Loop Sobre Parte de uma Coleção
  • 3.3.2 Efetuando um Loop Sobre Números
  • 3.3.3 Status do Loop
  • 3.4 Um Exemplo de Loop
  • 3.4.1 Entendendo o Exemplo
  • 3.4.2 Utilizando varStatus no Exemplo
  • 4. IMPORTANDO TEXTO
  • 4.1 Incluindo Texto com o Tag <c:import>
  • 4.1.1 Recuperando Dados de URLs
  • 4.1.2 Salvando Informações para Uso Posterior
  • 4.1.3 Efetuando Comunicação com Páginas Importadas
  • 4.1.4 Exemplos de Import
  • 4.2 Redirecionando com <c:redirect>
  • 4.3 Formatando URLs com <c:url>
  • 4.3.1 Formatando URLs com <c:url>
  • 4.3.2 Porque Utilizar <c:url>
  • 5. PÁGINAS COM ACESSO A BANCOS DE DADOS
  • 5.1 Quando Utilizar o Suporte JSTL a Bancos de Dados
  • 5.2 Criando uma Conexão de Banco de Dados com <sql:setDataSource>
  • 5.2.1 Cuidado com <sql:setDataSource>
  • 5.3 Executando Queries com <sql:query>
  • 5.3.1 Executando uma Query de Banco de Dados
  • 5.3.2 Lendo o Resultado de uma Query
  • 5.3.3 Limitando o Tamanho do Resultado de uma Query
  • 5.4 Modificando Dados com <sql:update>
  • 5.4.1 Uso Simplificado do Tag <sql:update>
  • 5.4.2 Medindo o Efeito de um Tag <sql:update>
  • 5.5 Utilizando <sql:param> com Queries Ajustáveis
  • 5.5.1 Queries Modelos (Templates)
  • 5.5.2 Utilizando <sql:param>
  • 5.5.3 Parâmetros do Tipo Date com <sql:dateParam>
  • 5.6 Gerenciando Transações com <sql:transaction>
  • 5.6.1 O Tag <sql:transaction>
  • 5.6.2 Níveis de Isolamento
  • 6. FORMATAÇÃO
  • 6.1 Imprimindo Números com <fmt:formatNumber>
  • 6.1.1 Uso Básico de <fmt:formatNumber>
  • 6.1.2 Diferentes Formas de Imprimir um Número
  • 6.1.3 Armazenando um Número em vez de Imprimi-lo
  • 6.1.4 Imprimindo Diferentes Tipos de Números
  • 6.1.5 Agupamento de Milhar
  • 6.1.6 Controlando Quantos Dígitos Devem Ser Impressos
  • 6.1.7 Utilizando Padrões
  • 6.2 Imprimindo Datas
  • 6.2.1 Utilizando Padrões
  • 6.3 Lendo Números com <fmt:parseNumber>
  • 6.3.1 Porque Efetuar o Parse de Números
  • 6.3.2 Como <fmt:parseNumber> Funciona por Default
  • 6.3.3 Modificando as Regras de Parse de <fmt:parseNumber>
  • 6.4 Lendo Datas com <fmt:parseDate>
  • 6.4.1 Como <fmt:parseDate> Funciona por Default
  • 6.4.2 Modificando Como <fmt:parseDate> Efetua o Parse de Datas
  • 7. TAREFAS COMUNS
  • 7.1 Tratando Parâmetros do tipo CheckBox
  • 7.1.1 O Formulário HTML
  • 7.1.2 Um Manipulador de CheckBox Simples
  • 7.1.3 Tratando Alguns CheckBoxes de Forma Especial
  • 7.2 Lendo Datas
  • 7.2.1 O Formulário HTML
  • 7.2.2 Tratando o Formulário e Lendo a Data
  • 7.3 Tratando Erros
  • 7.3.1 Capturando Erros com <c:catch>
  • 7.3.2 Enviando Erros para uma Página de Erro
  • 7.4 Validando Entrada de Dados
  • 7.4.1 Diferentes Tipos de Validação de Formulários
  • 7.4.2 Tarefas Relacionadas à Validação de um Formulário

Apostila de JSTL

Tradução Resumida do Livro JSTL in Action de Shawn Bayern

Prof. Carlos Ribeiro

Índice
1. A LINGUAGEM DE EXPRESSÕES....................................................................................................................... 4 1.1 Expressões e o tag <c:out> ............................................................................................................................. 4 1.1.1 Qual a Aparência de uma Expressão............................................................................................................ 5 1.1.2 Onde Expressões Funcionam ....................................................................................................................... 5 1.1.3 Valor Default em <c:out> ........................................................................................................................ 5 1.1.4 Caracteres Especiais e <c:out> ................................................................................................................ 6 1.2 Variáveis com Escopo e a Linguagem de Expressões......................................................................................... 6 1.2.1 Sintaxe Básica para Acessar Variáveis com Escopo .................................................................................... 6 1.2.2 Operações envolvendo Variáveis ................................................................................................................. 7 1.3 Parâmetros de Requisição e a Linguagem de Expressões ................................................................................... 7 1.4 Expressões mais Poderosas ................................................................................................................................. 7 1.4.1 Diferentes formas de Acessar Propriedades ................................................................................................. 7 1.4.2 Acessando Outros Dados Através da Linguagem de Expressões................................................................. 8 2. CONTROLANDO O FLUXO COM CONDIÇÕES .............................................................................................. 13 2.1 Condições Sim-Não com <c:if> ................................................................................................................... 13 2.1.1 A Sintaxe Básica de <c:if> .................................................................................................................... 13 2.1.2 Utilizando <c:if> com Tags HTML....................................................................................................... 13 2.1.3 Tags <c:if> Aninhados .......................................................................................................................... 14 2.1.4 Os Atributos var e scope ....................................................................................................................... 14 2.2 Condições Mutuamente Exclusivas .................................................................................................................. 15 3. CONTROLANDO O FLUXO COM ITERAÇÕES ............................................................................................... 16 3.1 A Iteração de Propósito Geral com <c:forEach> ........................................................................................ 16 3.2 Iteragindo sobre Strings com <c:forTokens>............................................................................................. 17 3.2.1 Como JSLT Efetua o Parse de Strings ....................................................................................................... 17 3.3 Iteração Avançada com <c:forEach> e <c:forTokens> ....................................................................... 18 3.3.1 Efetuando um Loop Sobre Parte de uma Coleção...................................................................................... 18 3.3.2 Efetuando um Loop Sobre Números .......................................................................................................... 18 3.3.3 Status do Loop ........................................................................................................................................... 19 3.4 Um Exemplo de Loop ....................................................................................................................................... 19 3.4.1 Entendendo o Exemplo .............................................................................................................................. 20 3.4.2 Utilizando varStatus no Exemplo............................................................................................................... 22 4. IMPORTANDO TEXTO ........................................................................................................................................ 23 4.1 Incluindo Texto com o Tag <c:import> ............................................................................................................ 23 4.1.1 Recuperando Dados de URLs .................................................................................................................... 23 4.1.2 Salvando Informações para Uso Posterior ................................................................................................. 24 4.1.3 Efetuando Comunicação com Páginas Importadas .................................................................................... 24 4.1.4 Exemplos de Import ................................................................................................................................... 26 4.2 Redirecionando com <c:redirect> ............................................................................................................ 28 4.3 Formatando URLs com <c:url> ................................................................................................................... 28 4.3.1 Formatando URLs com <c:url> ............................................................................................................ 28 4.3.2 Porque Utilizar <c:url> ......................................................................................................................... 29 5. PÁGINAS COM ACESSO A BANCOS DE DADOS ........................................................................................... 30 5.1 Quando Utilizar o Suporte JSTL a Bancos de Dados........................................................................................ 30 5.2 Criando uma Conexão de Banco de Dados com <sql:setDataSource> ................................................. 30 5.2.1 Cuidado com <sql:setDataSource> ................................................................................................ 32 5.3 Executando Queries com <sql:query> ....................................................................................................... 32 5.3.1 Executando uma Query de Banco de Dados .............................................................................................. 33 5.3.2 Lendo o Resultado de uma Query .............................................................................................................. 33

2

5.3.3 Limitando o Tamanho do Resultado de uma Query................................................................................... 36 5.4 Modificando Dados com <sql:update> ..................................................................................................... 36 5.4.1 Uso Simplificado do Tag <sql:update> .............................................................................................. 37 5.4.2 Medindo o Efeito de um Tag <sql:update> ........................................................................................ 37 5.5 Utilizando <sql:param> com Queries Ajustáveis........................................................................................ 38 5.5.1 Queries Modelos (Templates) .................................................................................................................... 38 5.5.2 Utilizando <sql:param>........................................................................................................................ 38 5.5.3 Parâmetros do Tipo Date com <sql:dateParam> ............................................................................... 40 5.6 Gerenciando Transações com <sql:transaction> .................................................................................. 40 5.6.1 O Tag <sql:transaction>............................................................................................................................. 40 5.6.2 Níveis de Isolamento.................................................................................................................................. 42 6. FORMATAÇÃO..................................................................................................................................................... 43 6.1 Imprimindo Números com <fmt:formatNumber> .................................................................................... 43 6.1.1 Uso Básico de <fmt:formatNumber>................................................................................................. 43 6.1.2 Diferentes Formas de Imprimir um Número .............................................................................................. 44 6.1.3 Armazenando um Número em vez de Imprimi-lo...................................................................................... 44 6.1.4 Imprimindo Diferentes Tipos de Números................................................................................................. 44 6.1.5 Agupamento de Milhar .............................................................................................................................. 44 6.1.6 Controlando Quantos Dígitos Devem Ser Impressos ................................................................................. 44 6.1.7 Utilizando Padrões ..................................................................................................................................... 45 6.2 Imprimindo Datas ............................................................................................................................................. 45 6.2.1 Utilizando Padrões ..................................................................................................................................... 46 6.3 Lendo Números com <fmt:parseNumber> ............................................................................................... 46 6.3.1 Porque Efetuar o Parse de Números........................................................................................................... 47 6.3.2 Como <fmt:parseNumber> Funciona por Default ............................................................................. 47 6.3.3 Modificando as Regras de Parse de <fmt:parseNumber> .................................................................. 48 6.4 Lendo Datas com <fmt:parseDate>.......................................................................................................... 49 6.4.1 Como <fmt:parseDate> Funciona por Default .................................................................................. 50 6.4.2 Modificando Como <fmt:parseDate> Efetua o Parse de Datas ......................................................... 50 7. TAREFAS COMUNS............................................................................................................................................. 51 7.1 Tratando Parâmetros do tipo CheckBox ........................................................................................................... 51 7.1.1 O Formulário HTML.................................................................................................................................. 51 7.1.2 Um Manipulador de CheckBox Simples.................................................................................................... 52 7.1.3 Tratando Alguns CheckBoxes de Forma Especial ..................................................................................... 53 7.2 Lendo Datas ...................................................................................................................................................... 54 7.2.1 O Formulário HTML.................................................................................................................................. 54 7.2.2 Tratando o Formulário e Lendo a Data ...................................................................................................... 55 7.3 Tratando Erros................................................................................................................................................... 56 7.3.1 Capturando Erros com <c:catch> ......................................................................................................... 56 7.3.2 Enviando Erros para uma Página de Erro .................................................................................................. 58 7.4 Validando Entrada de Dados............................................................................................................................. 59 7.4.1 Diferentes Tipos de Validação de Formulários .......................................................................................... 59 7.4.2 Tarefas Relacionadas à Validação de um Formulário ................................................................................ 59

3

Por default. isto só faz sentido se o atributo value contiver uma expressão na linguagem de expressões JSTL.. A LINGUAGEM DE EXPRESSÕES JSTL utiliza uma linguagem denominada uma expression language para simplificar o acesso à informação. A classe Java que implementa o tag customizado lê os atributos do tag e produz um efeito específico. para se descobrir o que um usuário digitou em uma caixa de texto denominada “nomeusuario” era necessário programar o seguinte código: <%= request.1 Expressões e o tag <c:out> O tag <c:out> nos permite imprimir o resultado de uma expressão. <c:out> imprime o que quer que apareça no seu atributo value. Antes de JSTL era necessário conhecer Java para produzir determinadas páginas JSP. Por exemplo. Os atributos de <c:out> são: Atributo value default escapeXml Descrição Obrigatório Default Nenhum Nenhum True A expressão (na linguagem de expressões Sim JSTL) a ser calculada A expressão a ser calculada se value Não falhar Se algum caracter deve ser substituído Não (scaped).1. Por exemplo. 4 .getParameter("nomeusuario") %> A linguagem de expressões JSTL torna bem mais simples a construção de páginas. para imprimir o caracter & como &amp. eles não são enviados para o browser. simplesmente imprime um texto. Neste caso. Quando tags JSTL aparecem em uma página. O tag <c:out> possui a mesma funcionalidade de uma expressão (<%= conteúdo %>) JSP. 1. Por exemplo: <c:out value="Alô Mundo!"/> Naturalmente.

1.1.1. O resultado desta avaliação é fornecido ao tag como o valor do atributo.2 Onde Expressões Funcionam Em JSTL 1. no caso do valor da variável nomeusuario não ser encontrado – será impresso ninguem. <c:out value="${nomeusuario}" default="Ninguem"/> Esta é uma outra forma de especificar um valor default: <c:out value="${nomeusuario}"/> Ninguem </c:out> 5 . esta expressão é calculada. Tudo o que aparece no meio é tratado como uma expressão. se a expressão falhar – por exemplo.1 Qual a Aparência de uma Expressão Uma expressão começa com ${ e termina com }. <a href="${link}" /> Neste caso o texto ${link} não é interpretado como uma expressão JSTL. Todos os tags JSTL funcionam assim. 1. Exemplo: <c:out value="${1 + 2}"/> Neste caso será impresso o valor 3. Não se pode escrever: <p>Oi ${nomeusuario}</p> Expressões JSTL também não possuem significado especial como valor de um atributo de um tag HTML.1. expressões possuem um significado especial apenas dentro de atributos de tags JSTL.3 Valor Default em <c:out> No exemplo abaixo.0. quando uma expressão aparece em um atributo de um tag JSTL. Na maioria dos casos.1.

Em alguns casos raros. Para obter este efeito basta designar o valor false para o atributo escapeXml. ao ser impressa com o tag </c:out>. o browser receberia os caracteres <o> . pode-se utilizar com segurança <c:out> como valor de um atributo de um tag HTML.usuario}"/>" /> Se esta substituição não ocorresse automaticamente. Normalmente este mecanismo de substituição dos caracteres especiais funciona exatamente como se deseja. conforme vem abaixo: <input type="text" name="usuario" value="<c:out value="${param. Por exemplo. na seguinte ordem: página. 1. <c:out value="${texto}" escapeXml="false"/> Isto pode ser útil caso se deseje acrescentar ao texto tags HTML como <b>.2 Variáveis com Escopo e a Linguagem de Expressões 1. sessão e aplicação. requisição. Uma expressão como ${usuario} significa “ a variável com escopo denominada usuario”. Se <c:out> não fizesse estas substituições. se uma variável possui o valor <o>. a linguagem de expressões JSTL lida com variáveis com escopo.1. será produzido o seguinte resultado: &lt. Logo.sem as substituições – o que faria o browser interpretar estes caracteres como um tag HTML desconhecido.4 Caracteres Especiais e <c:out> Por default. você pode desejar desligar este mecanismo de substituição de caracteres especiais de <c:out>.1. Como este mecanismo também substitui as aspas simples e as aspas duplas que ocorrem dentro de <c:out>. um browser HTML irá exibir o texto <o>.1 Sintaxe Básica para Acessar Variáveis com Escopo Em certo sentido. 6 . Quando um nome de uma variável com escopo aparece sozinho em uma expressão – como em ${usuario} – isto faz com que a linguagem de expressão procure por esta variável em todos os escopos possíveis. o tag <c:out> com caracteres com significados especiais em HTML e XML são substituídos (scaped) pelas entities references correspondentes. a linha acima provocaria um erro. etc. <i>.o&gt.2.

A razão de JSTL utilizar duas sintaxes 7 . Variável usuario em escopo de aplicação.usuario} ${applicationScope. assim como com listas ordenadas.2 Operações envolvendo Variáveis JSTL suporta os seguintes operadores matemáticos em expressões: Operador + * / ou div % ou mod Descrição Adição Subtração Multiplicação Divisão Resto Exemplo ${10 ${10 ${10 ${10 ${10 + * / % 2} 2} 2} 2} 2} 1.usuario} Significado Variável usuario em escopo de página. Para uma página poder imprimir o nome do usuário armazenado no objeto sessão: <c:out value="${session.4 Expressões mais Poderosas 1.3 Parâmetros de Requisição e a Linguagem de Expressões Para apontar para um parâmetro de requisição utilizando a linguagem de expressão.usuario} ${sessionScope. Também é possível acessar propriedades de coleções não ordenadas utilizando a sintaxe com colchetes ([]). Utilizando paramValues lhe permite recuperar uma coleção de todos os parâmetros com um determinado nome. Por exemplo.Como recuperar o valor de uma variável em determinado escopo: Exemplo de Expressão ${pageScope. utilize simplesmente ${param. Variável usuario em escopo de requisição.usuario}"/> 1.usuario} ${requestScope.1 Diferentes formas de Acessar Propriedades Vimos anteriormente que é possível utilizar o ponto (.telefone}. 1.nome} em vez de ${param.nome}.4.nome}. Se um parâmetro de requisição possui diversos valores será necessário utilizar ${paramValues. Variável usuario em escopo de sessão.2.) para acessar um membro de uma coleção não ordenada. para obter a propriedade telefone da variável usuario é possível escrever ${usuario.

uma vez que esta é uma tarefa do código Java sendo executado em um servidor. Observe as aspas em torno do nome da propriedade. 1. Os cabeçalhos contêm informações como: o tipo do browser. por exemplo. pode-se utilizar a notação com colchetes. informações sobre a localização da máquina cliente. é possível acessá-lo através da expressão ${cookie.corPreferida}.4. Para acessar esta informação pode ser utilizada a expressão: ${header["User-Agent"]} Parâmetros de Inicialização Assim como variáveis com escopo. Por outro lado. No entanto. ocorrerá o seguinte: ${usuario. os programadores de código java (back-end) podem designar informações denominadas context initialization parameters. Se você não utilizar aspas com colchetes. etc.2 Acessando Outros Dados Através da Linguagem de Expressões Cookies JSTL não nos permite criar cookies.headerUrl} 8 . Browsers enviam informações sobre seu fabricante e modelo para os servidores através de um cabeçalho denominado User-Agent. uma propriedade denominada meu-endereco poderia ser acessada assim: ${usuario[“meu-endereco”]}. Para acessar um parâmetro de inicialização utilize a seguinte sintaxe: ${initParam. se você sabe que existe um cookie denominado corPreferida.diferentes é porque Java Script também utiliza estas sintaxes. se uma propriedade utiliza um caracter especial como ponto ou hífem. Cabeçalhos (Headers) Cabeçalhos são dados que servidores web e browsers utilizam para se comunicar.telefone} – sempre recupera o telefone do usuário. ${usuario[info]} – esta expressão primeiramente procura pelo valor da variável info para em seguida utilizar seu valor para obter uma propriedade de usuario.

Servlet Informação sobre seu Context.message} designada como errorPage.remoteUser} servidor efetua autenticação ${pageContext.request O método HTTP . se o .new} nova.excepti Para uma página on. 9 .requestURL} acessar a página ${pageContext.request O URL utilizado para . se a sessão é .PageContext A variável que pode ser acessada com ${pageContext} permite que você acesse algumas informações detalhadas sobre o ambiente corrente da página.contextPath} Application ${pageContext.0 “Algo muito ruim aconteceu” Comparações Você pode utilizar a linguagem de expressões para produzir valores boleanos.0.request O nome da sua Web .serverInfo} container JSP ${pageContext.request Uma coleção ordenada .jsp true Apache Tomcat/5. uma descrição do erro que ocorreu. caso contrário ${pageContext. <= ou le. > ou gt. GET p1=valor1&p2=valor2 http://server/app/pagin a.authType} utilizado pela página.request O query string da . >= ou ge.request O tipo de autenticação . false. se aplicável ${pageContext.queryString} página ${pageContext. como no exemplo abaixo: ${2 == 2} Os operadores possíveis são: == ou eq.session true.method} utilizado para enviar a requisição ${pageContext. < ou lt.request O ID do usuário. != ou ne.cookies} contendo todos os cookies recebidos pela página ${pageContext. Expressão Descrição Exemplo de Valor BASIC djdavis /jstl n/a ${pageContext.

mes} será true apenas se o parâmetro mes não tiver sido especificado no formulário ou se seu valor for um string vazio.mes == 6 and param. Exemplos: ${(param.. || e !.ultimonome}" /> Esta habilidade de utilizar múltiplas expressões é interessante em outros tags da biblioteca JSTL.mes == 5) or (param.mes} Múltiplas Expressões <c:out value="Oi ${usuario.dia == 25)} ${not empty param.Para comparar valores de variáveis deve ser utilizada a seguinte sintaxe: ${usuario. or e not ou &&.peso gt usuario..mes eq "Maio"} Verificando se uma Variável Existe Pode-se utilizar a palavra-chave empty para determinar se um determinado parâmetro existe.primeironome}" /> <c:out value="${usuario..ultimonome}" /> embora a combinação abaixo produza o mesmo resultado: Oi <c:out value="${usuario.. Operadores Boleanos e Parênteses O operadores relacionais são: and.primeironome} ${usuario. 10 .. Verificar . ${empty param..qi} Pode-se verificar se um parâmetro de requisição possui um determinado valor: ${param...

O mais básico é <c:set>.Salvando Dados com <c:set> Muitos tags JSTL podem criar variávies com escopo. Por exemplo. para que possamos reutilizá-la diversas vezes. outras páginas na mesma sessão do usuário poderão referenciar o email assim: ${sessionScope.email}" /> Neste caso. será atribuído à variável o valor que estiver no corpo do tag. Exemplo de designação de valor a uma variável com escopo de página: <c:set var="quatro" value="${3 + 1}" /> Para que esta variável tenha escopo de sessão será preciso fazer o seguinte: <c:set var="quatro" scope="session" value="${3 + 1}" /> Utilizando o Corpo do Tag Se você escrever um tag <c:set> sem um atributo value. Atributo value var scope Descrição A expressão a ser calculada O nome da variável com escopo O escopo da variável Obrigatório Default Não Sim Não Conteúdo do corpo Nenhum page Os atributos var e scope são os únicos atributos de tags JSTL com os quais não se pode utilizar expressões. Este código criará uma variável com escopo chamada literalmente ${usuario}.email} 11 . em primeiro lugar. não se pode escrever: var=”${usuario}”. Quando <c:set> é Útil O tag <c:set> é útil. quando desejamos avaliar alguma coisa uma única vez. Um outro uso seria: <c:set var="email" scope="session" value="${param. Todo o espaço em branco – no início e no final do corpo – é removido.

nada acontecerá. 12 .Removendo Dados com <c:remove> Atributos do tag <c:remove>: Atributo var scope Descrição Obrigatório Default Nenhum qualquer O nome da variável com escopo a Sim remover O escopo da variável a ser Não removida Exemplo: <c:remove var="email" scope="session" /> Quando o scope não é especificado todos os escopos são pesquisados. Se a variável não for encontrada. sendo removida a variável quando ela for encontrada em um dos quatro escopos possíveis.

</c:if> <c:out value="${usuario. Se true.1.2.1 Condições Sim-Não com <c:if> 2.2 Utilizando <c:if> com Tags HTML Pode-se utilizar o tag <c:if> em qualquer lugar de uma página HTML. não processa. caso se trate de um doutor. Nome do atributo que receberá um Não valor boleano Escopo do atributo que recebe o Não valor boleano O atributo test do tag <c:if> aceita qualquer expressão boleana: <c:if test="${usuario. caso contrário.niveleducacional == 'doutorado'}"> color="red" </c:if> > <c:out value="${usuario. CONTROLANDO O FLUXO COM CONDIÇÕES 2.1. 2. Exemplo: <font size="2" <c:if test="${usuario.niveleducacional == 'doutorado'}"> Dr. Sim processa o corpo.”.nome}"/> </font> 13 .nome}"/> Neste caso será impresso o nome do usuário precedido do texto “Dr.1 A Sintaxe Básica de <c:if> Atributos do tag <c:if>: Atributo test var scope Descrição Obrigatório Default Nenhum Nenhum page Condição a ser avaliada.

</c:if> <c:if test="${erro2}"> <li> Ocorreu o erro 2. </c:if> </ul> </c:if> 2. Deste momento em diante o valor desta variável não mudará.errors.serious. conforme vem abaixo: <c:if test="${sessionScope.erro1 seja alterado. Exemplo: <c:if test="${sessionScope. </c:if> [ .erro1}" var="erro1"/> 14 . esta variável é boleana.errors.1. um corpo de página grande . seus dados não foram slavos. quando o primeiro tag é alcançado... no entanto..flags. </c:if> Neste exemplo.serious. Neste caso.errors. Se você utilizar o tag <c:if> apenas para salvar o valor da variável definida em var.flags.erro1}" var=”erro1”> Salva a variável Um erro sério ocorreu.3 Tags <c:if> Aninhados Exemplo: <c:if test="${erro1 or erro2}"> <ul> <c:if test="${erro1}"> <li> Ocorreu o erro 1.1.Caso o nível educacional seja diferente de 'doutorado' obteremos: <font size="2"> Nome </font> 2.flags.serious. mesmo que o valor de sessionScope. neste caso <c:if> não precisará ter um corpo. e o resultado é armazenado em uma variável com escopo de página denominada erro1.] <c:if test="${erro1}"> Usa a variável Desde que um erro sério ocorreu. a expressão no atributo test é avaliada..4 Os Atributos var e scope Estes atributos são utilizados para criar e expor uma variável com escopo que outros tags podem utilizar.

15 . <c:when>. <c:choose> <c:when test="${erro1}"> <li>Ocorreu o erro 1. mais adiante na página poderão utilizar a variável erro1.</li> </c:when> <c:when test="${erro3}"> <li>Ocorreu o erro 3.</li> </c:otherwise> </c:choose> O tag <c:when> não possui o atributo var. 2.</li> </c:when> <c:otherwise> <li>Nenhum erro ocorreu. e <c:otherwise>. Exemplo: Neste exemplo apenas uma das quatro mensagens será exibida.Outros tags.2 Condições Mutuamente Exclusivas JSTL suporta condições mutuamente exclusivas através de três tags: <c:choose>.</li> </c:when> <c:when test="${erro2}"> <li>Ocorreu o erro 2. mas ele pode utilizar uma variável boleana criada anteriormente por um tag <c:if>.

o corpo do tag <c:forEach> será processado uma vez. e o item corrente será exposto através de uma variável de página com escopo cujo nome é especificado pelo atributo var de <c:forEach>.condicoesDeSaude}" var="doenca"> <li><c:out value="${doenca}"/></li> </c:forEach> </ul> Este tag <c:forEach> efetua um loop sobre todos os itens da propriedade condicoesDeSaude da variável usuario. a linguagem de expressões pode retornar uma coleção de itens. mas você possui as seguintes doenças:<p> <ul> <c:forEach items="${usuario. Nome do atributo que exporá o item Não corrente. CONTROLANDO O FLUXO COM ITERAÇÕES 3. Para cada item em uma coleção. 16 .1 A Iteração de Propósito Geral com <c:forEach> O tag <c:forEach> é um tag JSTL para controle de loops de propósito geral. O tag <c:forEach> nos permite percorrer praticamente qualquer coleção de itens que a linguagem de expressões é capaz de retornar. Como vimos anteriormente. Os atributos do tag <forEach> para iteração básica vem abaixo: Atributos items var Descrição Obrigatório Default Nenhum Nenhum Uma coleção sobre a qual ocorrerá a Não iteração.3. Exemplo: <p>Lamento.

" var="corrente"> <li><c:out value="${corrente}"/></li> </c:forTokens> Logo..c." var="corrente"> <li><c:out value="${corrente}"/></li> </c:forTokens> Produzirá a seguinte saída: <li>a</li> <li>b</li> <li>c</li> <li>d</li> 3.b.. <c:forTokens items="a.3.. este código produz a mesma lista exibida acima.2.d" delims=".d" delims=".c.1 Como JSLT Efetua o Parse de Strings Diversos caracteres delimitadores consecutivos são tratados como um único delimitador.b.2 Iteragindo sobre Strings com <c:forTokens> O tag <c:forTokens> efetua um loop sobre tokens (substrings de um string maior delimitados por um caracter específico) . Os atributos do tag <forTokens> para iteração básica vem abaixo: Atributos items delims var Descrição Obrigatório Default Nenhum String de entrada sobre o qual Não ocorrerá a iteração Caracter delimitador que separa os tokens Nome do atributo que expõe o token Não corrente Nenhum Exemplo: <c:forTokens items="a. 17 .

Exemplo: <c:forEach begin="1" end="5" var="corrente"> <c:out value="${corrente}"/> </c:forEach> O exemplo acima produzirá a seguinte saída: 12345 Em <c:forTokens> o atributo items é obrigatório. 1=segundo. Atributos begin end step Descrição Obrigatório Default 0 Último item 1 O item que inicia o loop.d.c." var="letra" begin="2" end="4"> <li><c:out value="${letra}"/></li> </c:forTokens> Esta iteração irá exibir as letras c. d.3. os atributos begin e end aceitam expressões. utilize apenas <c:forEach>. etc. Não Passo da iteração.e" delims=".1 Efetuando um Loop Sobre Parte de uma Coleção Ambos <c:forEach> e <c:forTokens> aceitam 3 parâmetros opcionais para suportar o loop sobre parte de uma coleção.3 Iteração Avançada com <c:forEach> e <c:forTokens> 3. e 4.) O item que encerra o loop. Não (0=primeiro.3.3. e e – os tokens com índices 2. 3. Se você deseja iteragir sobre número.2 Efetuando um Loop Sobre Números Se você não especificar o atributo items (que é opcional). 18 . então os atributos begin e end deverão estar presentes. Como a maioria dos atributos JSLT.b. Não Exemplo: <c:forTokens items="a.3.

b. Como ainda não vimos como recuperar informações de arquivos XML e de bancos de dados. Se var=”corrente”. Se a iteração atual é a primeira." var="letra" begin="0" end="4" step="2"> <c:out value="${letra}"/> </c:forTokens> Letra 'a' index = 0 count = 1 first = true last = false Letra 'c' index = 2 count = 2 first = false last = false Letra 'e' index = 4 count = 3 first = false last = true 3. Propriedades Tipo index count first last número número boolean boolean Descrição O índice do ítem corrente da coleção. começando com 1.c. utilizaremos o tag <c:forEach> para gerar números automaticamente. se varStatus=”s”.d.3.4 Um Exemplo de Loop Vamos escrever uma página exemplo que permita o usuário paginar através de informações. A tabela abaixo mostra propriedades úteis desta variável.3. é criada uma variável com escopo de página denominada “s” que contém informações sobre a iteração corrente. não poderemos exibir dados reais. 19 .3 Status do Loop Assim como o atributo var em <c:forEach> e <c:forTokens>. Logo. A posição da volta corrente na iteração. Exemplo: <c:forTokens items="a. o atributo varStatus permite que você crie uma variável com escopo que pode ser acessada dentro do loop. o item corrente é exposto dentro do loop através de uma variável com escopo de página denominada corrente. Se a iteração atual é a última.e" delims=". Da mesma forma.

porPagina 20 . ou através de um outro meio qualquer.inicio + porPagina . Evidentemente estes valores poderiam ser designados através de parâmetros de requisição.<%@ taglib prefix="c" uri="http://java.1}"> <c:if test="${status. A quantidade de resultados que devem ser exibidos para o usuário de cada vez.1}"/> ] </a> </c:forEach> <c:forEach var="corrente" varStatus="status" begin="${param. <c:set var="totalDeItens" scope="session" value="100"/> <c:set var="porPagina" scope="session" value="20"/> totalDeItens Representa o número total de itens que gostaríamos que o usuário fosse capaz de percorrer.inicio}" end="${param.1 Entendendo o Exemplo Dois tags <c:set> foram utilizados para configurar o comportamento da nossa página.sun.1}" step="${porPagina}"> <a href="?inicio=<c:out value="${inicioDaFaixa}"/>"> [ <c:out value="${ inicioDaFaixa }"/> <c:out value="${ inicioDaFaixa + porPagina .last}"> </ul> </c:if> </c:forEach> 3.4.com/jstl/core" %> <c:set var="totalDeItens" scope="session" value="100"/> <c:set var="porPagina" scope="session" value="20"/> <c:forEach var="inicioDaFaixa" begin="0" end="${totalDeItens .first}"> <ul> </c:if> <li><c:out value="${corrente}"/></li> <c:if test="${status.

first}"> <ul> </c:if> <li><c:out value="${corrente}"/></li> <c:if test="${status.last}"> </ul> </c:if> </c:forEach> Quando nenhuma faixa é selecionada – isto é. Estes dados dependem apenas de duas variáveis que configuram o comportamento da nossa página: totalDeItens e porPagina.inicio}" end="${param. Este parâmetro pode ser acessado através da expressão ${param. Esta seção terá sempre a mesma aparência. <c:forEach var="inicioDaFaixa" begin="0" end="${totalDeItens .1}"> <c:if test="${status.inicio}. contendo um parâmetro inicio com o valor 20. Isto acontece em função do valor default definido para o parâmetro begin.1}" step="${porPagina}"> <a href="?inicio=<c:out value="${inicioDaFaixa}"/>"> [ <c:out value="${ inicioDaFaixa }"/> <c:out value="${ inicioDaFaixa + porPagina . Logo. conforme vem no código abaixo. 21 . se o parâmetro inicio é vazio – começamos com o número 0.inicio + porPagina . quando o usuário seleciona uma faixa específica. quando o valor deste parâmetro não existe. independentemente da faixa escolhida pelo usuário. o parâmetro inicio irá indicar o início da faixa que o usuário deseja. <c:forEach var="corrente" varStatus="status" begin="${param.Agora podemos imprimir a seção no topo da página.1}"/> ] </a> </c:forEach> Observe que um link como <a href="?inicio=20"> provoca o envio de uma requisição para a página corrente.

count % 2 == 0}"> </font> </c:if> <c:if test="${status.com/jstl/core" %> <c:set var="totalDeItens" scope="session" value="100"/> <c:set var="porPagina" scope="session" value="20"/> <c:forEach var="inicioDaFaixa" begin="0" end="${totalDeItens .inicio}" end="${param.1}"/> ] </a> </c:forEach> <c:forEach var="corrente" varStatus="status" begin="${param.1}" step="${porPagina}"> <a href="?inicio=<c:out value="${inicioDaFaixa}"/>"> [ <c:out value="${ inicioDaFaixa }"/> <c:out value="${ inicioDaFaixa + porPagina . as linhas ímpares serão impressas com um tipo de letra na cor vermelha.sun.last}"> </ul> </c:if> </c:forEach> 22 .first}"> <ul> </c:if> <c:if test="${status.4.inicio + porPagina .3.count % 2 == 0}"> <font color=”red”> </c:if> <li><c:out value="${corrente}"/></li> <c:if test="${status.1}"> <c:if test="${status. <%@ taglib prefix="c" uri="http://java.2 Utilizando varStatus no Exemplo Com o código abaixo.

4.html"> URLs relativos em JSTL funcionam da mesma forma como URLs relativos em HTML. / seguida do nome de uma aplicação web local. mas <c:import> também permite que você armazene o texto recuperado em uma variável com escopo em vez de impri-la. URLs que começam por uma / possuem um significado diferente para tags JSTL do seu significado em HTML.jpg"/> então o arquivo foto. Às vezes você deseja apenas imprimir a informação recuperada. Nome do atributo para expor o conteúdo String do url. Este diretório armazena imagens que são compartilhadas por páginas estáticas e dinâmicas. Obrigatório Sim Não Não Não Default Nenhum Contexto corrente Nenhum Page Exemplo de <c:import> com um caminho relativo para o url: <c:import url="cabecalho. você pode utilizar o tag <c:import>.1 Recuperando Dados de URLs Para importar uma página residente no diretório corrente: <c:import url="cabecalho. Em HTML.4. Por outro lado.1 Incluindo Texto com o Tag <c:import> Para recuperar conteúdo de uma página JSP local ou proveniente de outro servidor.html"/> 23 . a imagem será procurada no diretório imagens na raiz da aplicação web de página JSP. Observe que um servidor web geralmente possui diversas aplicações web. Escopo do atributo que irá expor o conteúdo String do url. se utilizarmos este mesmo URL como entrada de um tag JSTL. IMPORTANDO TEXTO 4. A tabela abaixo mostra os atributos do tag <c:import>: Atributos url context var scope Descrição O url que se deseja recuperar e importar na página.1. se você utilizar o tag <img src="/imagens/foto.jpg virá do diretório imagens na raiz de todo o servidor web.

quando se importa uma página de um mesmo container JSP.. você pode utilizar os objetos request. No entanto. e application para se comunicar com a página de destino.jsp seria preciso: <c:import url="/target/target.Supondo que a página atual.jsp está em um diretório denominado target.servidor.html" var="copyright"/> <c:out value="${copyright}"/> .jsp"/> 4.. source.3 Efetuando Comunicação com Páginas Importadas Às vezes não é suficiente apenas recuperar uma página. para source.. ambos os diretórios na raiz da aplicação web corrente.jsp"/> Importando de Outra Aplicação Web É possível recuperar arquivos de outra aplicação web especificando o nome da outra aplicação web utilizando o atributo context do tag <c:import>. Primeiramente é possível utilizar o tag <c:param> para enviar parâmetros de requisição para a página. todos os parâmetros de requisição da página de origem são passados automaticamente para a página de destino. e na maioria das vezes é o que você deseja. session.jsp"/> Agora suponha que target. O escopo de página é o único não compartilhado. se você está importando um URL relativo para uma página da mesma aplicação. <c:import context="/outra" url="/diretorio/target. Se a página é gerada dinâmicamente. Isto é exatamente o que <jsp:include> faz.jsp importar target. a única forma de recuperar o arquivo utilizando <c:import> é através do seguinte URL: <c:import url="http://www.com/copyright-notice.2 Salvando Informações para Uso Posterior Por default.jsp.com/diretorio/target.1. você pode desejar customizar sua saída. conforme vem abaixo: <c:import url="http://legal. E em segundo lugar. Além disso. Mais conteúdo . <c:out value="${copyright}"/> 4.jsp esteja localizada em um servidor web diferente.1. está em um diretório denominado source e que a página target. 24 . <c:import> recupera informação de um URL e a imprime imediatamente na sua página.. você pode desejar importar uma página e incluir seu texto diversas vezes. Neste caso.

A tabela abaixo mostra os atributos do tag <c:param>: Atributos name value Descrição Nome do parâmetro Valor do parâmetro Obrigatório Sim Não Default Nenhum Corpo Exemplo: Como enviar um parâmetro para a página target.net/aplicacao/target.jsp"/> <c:param name="param" value="valor"/> </c:import> Este código causa o envio de uma requisição HTTP do tipo GET.podem incluir estruturas de dados arbitrárias. as variáveis com escopo – que podem ser acessadas tanto pela origem como pelo destino de um tag <c:import> . assim: http://www. <c:param> permite o envio de simples parâmetros de comunicação.net/aplicacao/target.O Tag <c:param> O tag <c:param> é um tag filho opcional do tag <c:import> (e de alguns outros tags JSTL). Em contraste com os parâmetros de requisição. 25 .jsp. só funcionam quando a página de destino pertence à mesma aplicação web da origem. que possuem a forma nome=valor.servidor. Elas suportam comunicação em dois sentidos. 2.jsp?param=valor Observações: 1.servidor. no entanto. Quando ele aparece ele diz para <c:import> para enviar um parâmetro de requisição para a página que ele está carregando. Parâmetros de requisição são flexíveis mas podem representar apenas texto e suportam comunicação em apenas um sentido (da origem para o destino). <c:import url="http://www.

jsp: <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> <table width="100%"> <tr> <td align="left" bgcolor="#888888"> <big><font color="#FFFFFF"> <c:out value="${param. Código de cabecalho.jsp – Uma primeira página exemplo.jsp: <%@ taglib prefix="c" uri="http://java.4 Exemplos de Import O exemplo abaixo mostra como padronizar a aparência dos cabeçalhos das páginas de uma aplicação através do uso de <c:import>. Exemplo 1: Customização com <c:param> Nosso exemplo utiliza três páginas: • pagina1.4.jsp – Uma segunda página exemplo.titulo}"/> </font></big> </td> <td align="right"> <small> Exemplo de Aplicação com Import </small> </td> </tr> </table> <hr /> Código da pagina1. • pagina2. </body> </html> 26 .jsp – Uma página JSP que imprime imformação de cabeçalho que é utilizada por ambas as páginas.com/jstl/core" %> <html> <body> <c:import url="cabecalho.1.jsp"> <c:param name="titulo" value="Benvindo à Página 1"/> </c:import> <h4>Informações da Página 1</h4> Texto da <b>Pagina 1</b>. • cabecalho.sun.

com/jstl/core" %> <html> <body> <c:import url="cabecalho. a página origem.jsp: <%@ taglib prefix="c" uri="http://java.jsp recebeu de volta: <c:out value="${requestScope.jsp: <%@ taglib prefix="c" uri="http://java.sun.saida}" /> Código de destino.jsp recebeu: <c:out value="${requestScope.jsp importa destino.Código da pagina2.. Exemplo 2: Customização sem <c:param> Código de origem.jsp: <%@ taglib prefix="c" uri="http://java.entrada}" /> <c:set var="saida" scope="request" value="TEXTO DE SAÍDA" /> 27 . <hr /> <c:import url="destino.sun.jsp.jsp" /> <hr /> origem. e ambas enviam dados uma da outra. </font> </body> </html> No exemplo abaixo.com/jstl/core" %> destino.com/jstl/core" %> <c:set var="entrada" scope="request" value="TEXTO DE ENTRADA" /> Chamando destino.sun.jsp"> <c:param name="titulo" value="Bevindo à Página 2"/> </c:import> <font color="pink"> <h4>Informações da Página 2</h4> Esta é a <b>página 2</b>..jsp. <br/> Uma versão aboiolada da página 1.

Exemplo 3: Assim como o <c:import>.3 Formatando URLs com <c:url> 4.1 Formatando URLs com <c:url> A função do tag <c:url> é imprimir um URL (ou armazená-lo em uma variável com escopo).4.jsp"/> <c:param name="estoque" value="IBM"/> </c:redirect> 4. A tabela abaixo mostra os atributos do tag <c:url>: Atributos value context var scope Descrição URL base para imprimir ou armazenar / seguido do nome da aplicação web local Nome do atributo para expor o URL final Escopo do atributo para expor o URL final Obrigatório Sim Não Não Não Default Nenhum Contexto corrente Nenhum Page 28 . isto é.3. <c:redirect> também permite o uso de <c:param> dentro dele para enviar um parâmetro de requisição para a página que irá receber o redirecionamento: <c:redirect context="/aplic" url="/comprar. o valor de ambos os atributos (context e url) devem começar com uma /.jsp"/> Quando o atributo context é fornecido. <c:when test="${param. em outra aplicação: <c:redirect context="/aplic" url="/comprar.acao == 'comprar'}"> <c:redirect url="comprar.jsp"/> </c:when> Exemplo 2: Redirecionando para uma página em outro contexto.2 Redirecionando com <c:redirect> A tabela abaixo mostra os atributos do tag <c:redirect>: Atributos url context Descrição Obrigatório Default Nenhum Contexto Corrente URL que receberá o redirecionamento Sim / seguida do nome da aplicação web Não local Exemplo 1: Redirecionando para uma página no mesmo diretório da origem.

o URL aponta para o diretório info abaixo da raiz da sua aplicação web: <c:import url="/info/copyright. O tag <c:url> também é útil quando se deseja salvar um URL (utilizando os atributos var e scope) e utilizá-lo diversas vezes na sua aplicação. O tag <c:url> efetua estes ajustes para você. Duas outras razões são: • Freqüentemente URLs necessitam ser reescritos para preservar a sessão de um usuário por várias páginas. também é possível incluir tags <c:param> no corpo de um tag <c:url>. Isto é.gif"/>"/> Você pode utilizar o atributo context do tag <c:url> para criar um URL para uma página em outra aplicação web existente no seu container JSP. • Em tags HTML como o que vem abaixo. 29 .txt"> Para que uma imagem seja localizada na pasta imagens da sua aplicação web utilize o tag <c:url>.txt">Leia as informações de Copyright</a> Mas em um tag JSTL como o que vem abaixo. se um URL começa com uma /. o URL referencia o diretório info na raiz do servidor web: <a href="/info/copyright. como no exemplo abaixo: <a href="<c:url value="comprar.3. Simplesmente o insira na sua página sempre que você quiser imprimir um URL. e não para a raiz do servidor. Você pode desejar ajustar URLs relativos a contextos para que eles apontem para a raiz da sua aplicação web.jsp"> <c:param name="HD" value="Quantum"/> </c:url>">Compre um HD Quantum</a> 4. É fácil utilizar <c:url>. e não para todo o servidor.2 Porque Utilizar <c:url> A primeira razão é pelo fato de ser mais fácil construir um link que passa parâmetros para a página de destino. O tag <c:url> reescreve os URL (acrescentando o ID da sessão) automaticamente.Assim como o <c:import> e <c:redirect>. assim: <img src="<c:url value="/imagens/logo. ele é mapeado para o diretório raiz da sua aplicação web. Com freqüência você desejará inserir <c:url> no meio de um tag HTML.

Porque um componente de apresentação deveria conhecer onde os dados estão mantidos? Esta abordagem explica a popularidade de frameworks de aplicações baseados em servlets. declarar este banco de dados como default na sessão do usuário. Em vez disso. Em um ambiente como este páginas JSP apenas exibem informações formatadas. Em muitas aplicações grandes. e o tag que fornece esta informação é o <sql:setDataSource>. Com esta informação. para pequenas aplicações. e então passar a requisição do usuário para uma página JSP.2 Criando uma Conexão de Banco de Dados com <sql:setDataSource> Os tags JSTL de acesso a bancos de dados necessitam saber qual banco de dados deve ser utilizado. Ou eles podem te passar uma variável com escopo como entrada para os tags JSTL de banco de dados. os tags JSTL de acesso a banco de dados são bastante úteis. Este tag aceita como atributos todas as informações necessárias para efetuar uma conexão com um banco de dados. Você pode decidir expor uma variável com escopo que represente o banco de dados. Servlets podem invocar diretamente qualquer lógica que uma aplicação necessite. então estas páginas JSP não necessitam acessar bancos de dados. o tag <sql:setDataSource> não é necessário. o tag <sql:setDataSource> é bastante útil. você não precisará utilizar os tags JSTL de acesso a banco de dados. 5. pois desenvolvedores Java gerenciam todas as conexões de banco de dados. 30 . protótipos. você pode fazer duas coisas: 1. No entanto. Muitas aplicações contêm servlets para tratar as requisições provenientes dos usuários. ou projetos onde você é o único desenvolvedor. você irá provavelmente utilizar JavaBeans ou tags customizados construídos pelos programadores. Se uma aplicação utiliza páginas JSP apenas para exibir informações. PÁGINAS COM ACESSO A BANCOS DE DADOS 5. e não para tratar lógica de aplicação. Se você está trabalhando em um projeto onde os programadores Java tratam todos os acessos a bancos de dados. No entanto. Estes desenvolvedores podem designar um banco de dados default de tal forma que você nunca precise se preocupar com esta questão. e nunca se preocupar com isto novamente. Você pode definir um banco de dados (set up a database) toda vez que um usuário se logar. para pequenas aplicações.1 Quando Utilizar o Suporte JSTL a Bancos de Dados A maioria das grandes aplicações para a Web baseadas em Java não são construídas inteiramente de páginas JSP.5. 2. ou para as aplicações onde todo o gerenciamento de acesso a banco de dados é efetuado por páginas JSP em vez de por código Java.

OracleDriver" url="jdbc:oracle:thin:@sbd:1521:orcl" user="jstl01" password="jstl01" var="bancoUm" scope="session" /> Este tag expõe uma variável com escopo denominada bancoUm.jdbc.A tabela abaixo mostra os atributos do tag <sql:setDataSource>: Atributos dataSource driver url user password var scope Descrição Um banco de dados existente a ser utilizado O nome da classe Java do driver JDBC O URL para acesso a um banco via JDBC Nome do usuário Senha do usuário Nome da variável que representa o banco Escopo da variável ou um novo default Obrigatório Default Não Não Não Não Não Não Não Nenhum Nenhum Nenhum Nenhum Nenhum Nenhum page Para preparar conexões para um banco Oracle. Você pode fazer isto adicionando um atributo var: <sql:setDataSource driver="oracle.jdbc.OracleDriver" url="jdbc:oracle:thin:@sbd:1521:orcl" user="jstl01" password="jstl01" scope="session" /> O atributo scope o tag <sql:setDataSource> irá definir um novo banco de dados para a scope=”request” sessão do usuário. Poderíamos ter especificado ou scope=”application”. Após termos exposto bancoUm. poderíamos utilizar o seguinte tag: <sql:setDataSource driver="oracle. podemos tornar este banco o default para escopo de requisição. Observe que um conjunto de páginas pode utilizar um banco com escopo de aplicação enquanto outro conjunto utiliza um banco com escopo de sessão.driver. Se um código Java. assim: 31 . Se a sua aplicação trabalha com vários bancos de dados. Um outro tag pode expor uma variável diferente denominada bancoDois. criou uma variável com escopo que aponta para um banco de dados. você pode utilizá-la para expor uma variável com escopo que representa o banco. ou um tag <sql:setDataSource> que você utilizou. você pode informar o nome desta variável em outros tags <sql:setDataSource> para definir um novo default. em vez de utilizar <sql:setDataSource> para estabelecer uma conexão default.driver.

sessão ou aplicação proveniente de código Java.<sql:setDataSource dataSource="${bancoUm}" scope="request" /> Note que quando você utiliza os atributos url. 5. então o tag <sql:query> irá se conectar ao banco de dados utilizando esta variável fornecida. A tabela abaixo mostra os atributos do tag <sql:setDataSource>: Atributos sql dataSource startRow maxRows var scope Descrição O comando sql SELECT a ser executado O provedor de uma conexão de BD A linha do resultado que deve ser retornada Quantidade máxima de linhas a retornar Nome da variável que deve expor o resultado Escopo da variável que deve expor o resultado Obrigatório Default Não Não Não Não Sim Não Corpo Ver seção 5.x Nenhum Page Se você fornecer uma variável com escopo para o atributo dataSource. Você pode omitir user ou a password caso seu banco não exija estas informações. exceto o url.2 0 (a 1ª linha) ver seção x. Logo. o uso deste tag é ineficiente para aplicações necessitam suportar muitos usuários.2. isto é. às vezes. 5.3 Executando Queries com <sql:query> O objetivo do tag <sql:query> é expor uma variável com escopo que representa o resultado de uma query de banco de dados.1 Cuidado com <sql:setDataSource> O tag <sql:setDataSource> não implementa um pool de conexões. driver. de um pool de conexões default para as páginas JSP. Você pode deixar de informar o driver porque. através de código Java. Neste caso o tag <sql:query> teria a seguinte sintaxe: 32 . Você pode expor uma variável com escopo para o atributo dataSource através do tag <sql:setDataSource>. você pode deixar de informar todos eles. um administrador de sistema pode prometer para você que o driver já estará registrado. user. Uma solução mais eficiente seria a designação. e password. apenas abre uma nova conexão com o banco de dados que será utilizada pela página JSP. ou você pode recuperar uma variável com escopo de requisição.

.<sql:query dataSource="${sessionScope. Esta variável com escopo possui uma série de propriedades. e se as suas páginas não possuem um banco default definido por um programador Java.3. 33 . então o tag <sql:query> irá tentar encontrar um banco default. então será necessário utilizar o atributo dataSource para estes exemplos funcionarem. O objetivo deste tag é simplesmente executar a query e armazenar o resultado em uma variável com escopo definida por var e scope. Se um banco default não foi definido com <sql:setDataSource>.1 Executando uma Query de Banco de Dados Exemplo 1: <sql:query var="resultado"> SELECT * FROM CLIENTES <sql:query> Exemplo 2: <sql:query var="resultado" sql="SELECT * FROM CLIENTES" /> Exemplo 3: <sql:query var="resultado" sql="${query}" /> Exemplo 4: Recuperando a query de um documento XML <sql:query var="resultado"> <x:out select="$doc/query/queryCliente" /> <sql:query> Observação: Estes exemplos assumem que um banco defaut está corretamente definido. Estas propriedades nos permitem acessar duas coisas sobre o resultado: • • Os dados na tabela Informações sobre os dados (metadata). /> Se você não utilizar o atributo dataSource.3.. 5.bancoUm}" .2 Lendo o Resultado de uma Query O tag <sql:query> não exibe o resultado da query. 5. Mais adiante veremos como configurar um banco de dados default.

Veja o item 5. mas columnNames é uma simples coleção que nos permite acessar nomes de colunas por nome.NOME e row. é necessário escrever um loop similar. Ambos os atributos são coleções de coleções. Esta abordagem pode ser interessante se você não conhece os nomes das colunas. A variável do tag <sql:query> nos permite acessar dados através de duas propriedades: rows e rowsByIndex. A diferença entre rows e rowsByIndex é que durante cada loop você acessa os dados em rows utilizando os nomes de colunas. E a propriedade rowsByIndex nos permite acessar valores para cada linha.limitedByMaxRows indica se a quantidade de linhas retornada pelo tag <sql:query> foi truncada. por número.NOME}"/></td> <td><c:out value="${row. e acessa dados em rowsByIndex utilizando os números das colunas.rows}" var="row"> <tr> <td><c:out value="${row. também poderíamos ter escrito ${row. as seguintes propriedades podem ser recuperadas a respeito deste resultado: • • • resultado. por nome. é preciso utilizar row[0] e row[1]. Exemplo: <sql:query var="usuariosEspertos"> SELECT NOME. resultado. Mas em vez de referenciar row. Ambas as propriedades expõem coleções.4.nome}.NOME}.rowCount nos permite recuperar a quantidade de linhas no resultado. 34 .QI}"/></td> </tr> </c:forEach> <table> Embora tenhamos escrito ${row.Acessando Metadata Supondo que você utilizou um tag <sql:query> para criar uma variável denominada resultado. A propriedade rows nos perimte acessar valores de colunas individuais em cada linha. Geralmente você irá desejar percorrer estas coleções para imprimir os resultados. resultado. Para utilizar rowsByIndex.columnNames retorna uma lista de nomes de colunas. QI FROM USUARIOS WHERE QI > 120 <sql:query> <table> <c:forEach items="${usuariosEspertos.QI.

rowsByIndex}" var="row" varStatus="s"> <c:if test="${s.resultado. combinar dados e metadata para produzir um cabeçalho conveniente. você pode escrever uma página genérica denominada imprimeQuery.columnNames}" var="col"> <th><c:out value="${col}"/></th> </c:forEach> </tr> </c:if> <tr> <c:forEach items="${row}" var="valor"> <td><c:out value="${valor}"/></td> </c:forEach> </tr> <c:if test="${s.rowsByIndex}" var="row"> <tr> <td><c:out value="${row[0]}"/></td> <td><c:out value="${row[1]}"/></td> </tr> </c:forEach> <table> É possível.first}"> <h4>Relação de Usuários Espertos</h4> <table border="1"> <tr> <c:forEach items="${requestScope.resultado.last}"> </table> </c:if> </c:forEach> 35 . Exemplo: <c:forEach items="${requestScope. QI FROM USUARIOS WHERE QI > 120 <sql:query> <table> <c:forEach items="${usuariosEspertos. enviando para ela o resultado de um tag <sql:query> utilizando um atributo com escopo de requisição.Exemplo: <sql:query var="usuariosEspertos"> SELECT NOME. em um único loop. Esta abordagem é útil quando se deseja escrever uma página genérica para tratar diversas queries.jsp e incluir esta página. Por exemplo.

<c:if> Programadores Java podem designar um valor default para o atributo maxRows das suas páginas. SALARIO FROM EMPREGADOS WHERE SALARIO > 2000 <sql:query> <c:if test="${empregados.limitedByMaxRows}"> O resultado da sua query retornou empregados demais. O Atributo startRow A query abaixo retorna todas as linhas da tabela de clientes exceto as duas primeiras linhas (as linhas cujos números são 0 e 1): <sql:query var="clientes" startRow="2"> SELECT NOME.5. SALARIO FROM EMPREGADOS WHERE SALARIO > 2000 <sql:query> Para ser informado que que a resposta da query foi truncada você utilizar a propriedade limitedByMaxRows da variável exposta por <sql:query>. então será atribuída à variável clientes uma coleção vazia. seja mais específico da próxima vez. assim: <sql:query var="empregados" maxRows="20"> SELECT NOME.4 Modificando Dados com <sql:update> Novamente cabe salientar que grandes aplicações são mantidas mais facilmente quando páginas JSP não acessam bancos de dados diretamente. JSTL provê o tag <sql:update> que poderá ser utilizado sem problemas em aplicações relativamente pequenas. deixando esta tarefa para código Java em JavaBeans ou para tags customizados. 5. mas você sempre poderá efetuar o override deste valor. SALARIO FROM CLIENTES <sql:query> Se a tabela só possuir duas linhas. No entanto. 36 . Por favor. atribua –1 a maxRows. Se você quer garantir que o resultado de sua query não será truncado.3 Limitando o Tamanho do Resultado de uma Query Como limitar em 20 linhas o resultado de uma query: <sql:query var="empregados" maxRows="20"> SELECT NOME.3.

4.1 Uso Simplificado do Tag <sql:update> Através do tag <sql:update> é possível emitir comandos Insert.00 reais. A tabela abaixo mostra os atributos do tag <sql:update>: Atributos sql dataSource var scope Descrição O comando sql UPDATE a ser executado O provedor de uma conexão de BD Nome da variável que deve expor a quantidade de linhas afetadas Escopo da variável que deve expor a quantidade de linhas afetadas Obrigatório Default Não Não Não Não Corpo Ver seção 5.2 Nenhum Page Exemplo 1: <sql:update> INSERT INTO EMPREGADOS(NUMERO. 80) </sql:update> Exemplo 2: <sql:update sql="DELETE FROM EMPREGADOS WHERE NUMERO = 1"/> 5. </c:if> 37 .5. etc.</p> <c:if value="${n == 0}"> Nenhum empregado foi removido. NOME. PESO) VALUES(1. todos com salário maior do que 2000. Create Table.4. 'João Carlos'.2 Medindo o Efeito de um Tag <sql:update> Você pode utilizar o atributo var do tag <sql:update> para saber qual foi a quantidade de linhas afetadas pelo tag. Delete. Update. Exemplo 1: <sql:update var="n"> DELETE FROM EMPREGADOS WHERE SALARIO > 2000 </sql:update> <p>Foram removidos <c:out value="${n}"/> empregados.

Você poderá preencher estas interrogações utilizando o tag <sql:param>.endereco}"/> <sql:param value="${idade}"/> </sql:query> 38 . o final da query será: WHERE NOME = 'SERGIO' OR NOME <> 'SERGIO' Logo. Utilizando esta sintaxe você pode escrever uma query template e deixar de fora todas as partes não conhecidas. A tabela abaixo mostra o atributo do tag <sql:param>: Atributos value Descrição Valor do parâmetro Obrigatório Default Não Corpo Exemplo 1: <sql:query var="resultado"> SELECT * FROM CLIENTES WHERE NOME = ? AND ENDERECO = ? AND IDADE = ? <sql:param value="${page. Este tag deve ser acrescentado como filho dos tags <sql:query> e de <sql:update>.1 Queries Modelos (Templates) É possível utilizar o tag <c:out> para completar parte de uma query: <sql:query var="resultado"> SELECT * FROM CLIENTES WHERE NOME = <c:out value='"${nomeCliente}"'/> </sql:query> E se o usuário digitar: SERGIO' OR NOME <> 'SERGIO Neste caso. 5.nomeusuario}"/> <sql:param value="${param.5.5 Utilizando <sql:param> com Queries Ajustáveis 5.5.2 Utilizando <sql:param> JSTL permite que você evite estes problemas utilizando uma sintaxe especial emprestada de JDBC. não é uma boa idéia utilizar <c:out> para construir comandos SQL. colocando interrogações (?) nos seus lugares.5.

numero}"/> <sql:param value="${param.numero}"/> </sql:update> Exemplo 4: Se o tag <sql:param> não contiver um atibuto value.nome}"/> <sql:param value="${param.salario"/> </sql:update> Exemplo 3: <sql:update> UPDATE EMPREGADOS SET SALARIO = ? WHERE NUMERO = ? <sql:param value="${param. é possível produzir um valor utilizando outros tags.numero}"/> </sql:update> 39 . Exemplo 2: <sql:update> INSERT INTO EMPREGADOS (NUMERO. <sql:update> UPDATE EMPREGADOS SET SALARIO = ? WHERE NUMERO = ? <sql:param> <x:out select="$doc/empregados/empregado/salario"/> </sql:param> <sql:param value="${param. SALARIO) VALUES (?. NOME. Logo. ?.salario"/> <sql:param value="${param. na ordem em que as interrogações aparecem.Quando um tag possui várias interrogações. ?) <sql:param value="${param. o tag irá utilizar o conteúdo de seu corpo. ele deve ter exatamente um tag <sql:param> para cada interrogação.

Não date.6. Exemplo: <sql:query> SELECT * FROM USUARIOS WHERE DATA_NASC < ? <sql:dateParam value="${dataNasc}"/> </sql:query> 5. Para ter certeza de que você conseguirá adicionar datas às suas queries. Este processo permite a você amarrar o sucesso de uma operação de bano de dados ao sucesso de 40 . se você tiver uma variável com escopo representando uma data (mais adiante veremos como criar esta variável com escopo). Se um erro fatal ocorrer em qualquer lugar dentro deste bloco – por exemplo.1 O Tag <sql:transaction> JSTL suporta transações através do tag <sql:transaction>. Ou todos os tags filhos de <sql:transaction> são bem sucedidos. JSTL provê o tag <sql:dateParam> cujos atributos são relacionados absixo: Atributos value type Descrição Obrigatório Default Nenhum timestamp A data que irá substituir a ? Sim Um dos seguintes valores: time. seguida de outro update baseado na query intermediária. se você decidir recuperar um arquivo com <c:import> e este arquivo não for encontrado – então toda a transação será interrompida e sofrerá um rollback imediato. pode aparecer dentro de um tag <sql:transaction>. uma data (date). tags JSTL. e o atributo type permite que você descreva mais precisamente como o banco deve tratar o valor: apenas armazena a hora do dia (time). ou ambos – data e hora (timestamp). ou outro conteúdo JSP. talvez não seja possível utilizar esta variável com <sql:param>. Esta é a razão pela qual o tag <sql:transaction> permite que tags <sql:query> participem de uma transação. Note que qualquer texto válido.5.3 Parâmetros do Tipo Date com <sql:dateParam> Considere o comando SQL abaixo: SELECT * FROM USUARIOS WHERE DATA_NASC < ? Neste caso. ou todos falham juntos.6 Gerenciando Transações com <sql:transaction> 5.5. Vai depender do driver que você estiver utilizando. Este tag age como o tag pai dos tags <sql:update> e <sql:query>. ou timestamp O atributo value requer uma expressão que aponte para uma variável com escopo que armazene uma data. Sua transação pode ser formada por um update seguida de uma query.

contaCreditada}"/> </sql:update> </sql:transaction> 41 . Mas quando este tag aparece dentro de um tag <sql:transaction>. ele utiliza o banco definido para seu pai <sql:transaction>.2 Ver seção 5. se basear em um banco de dados default.operações que não são de banco de dados.? WHERE NUMERO = ? <sql:param value="${param. considere o seguinte tag: <sql:update sql="${comando}"/> Este tag normalmente utilizaria o banco de dados default.contaDebitada}"/> </sql:update> <sql:update> UPDATE CONTAS SET SALDO = SALDO + ? WHERE NUMERO = ? <sql:param value="${param.valor}"/> <sql:param value="${param. Quando um tag <sql:transaction> aparece na sua página.2 Quem provê a conexão de banco Não de dados Nível de isolamento das Não transações O tag <sql:transaction> determina qual banco de dados será utilizado da mesma forma que <sql:query> e <sql:update>. e esta conexão é fornecida. Ele não apaga.valor}"/> <sql:param value="${param. Por exemplo. uma vez que nenhum atributo dataSource foi especificado. ele imediatamente inicia uma transação de banco de dados. que pode ter sido estabelecido por <sql:setDataSource> ou por código Java. variáveis com escopo criadas ao longo da execução deste bloco. Ele pode utilizar seu atributo dataSource ou.6. Tenha em mente apenas que <sql:transaction> efetua o rollback apenas das operações de banco de dados. Exemplo: <sql:transaction dataSource="${database}"> <sql:update> UPDATE CONTAS SET SALDO = SALDO . por exemplo. caso não seja especificado. A tabela abaixo mostra os atributos do tag <sql:transaction>: Atributos dataSource isolation Descrição Obrigatório Default Ver seção 5. por default para todos os tags <sql:query> e <sql:update> filhos de <sql:transaction>. Esta transação utiliza uma conexão de banco de dados.

42 . mas envolve novas linhas adicionadas a uma tabela que aparecem no segundo SELECT (enquanto. e seus respectivos significados: Níveis de Isolamento Dirty Reads? read_uncommited read_commited repeatable_read serializable --Evita Evita Evita ----Evita Evita tabela abaixo do atributo isolation do tag Nonrepeatable reads? Phantom reads? ------Evita Esta tabela mostra os quatro níveis de isolamento possíveis e os tipos de leituras indesejáveis que eles proíbem. Uma dirty read (leitura suja) é aquela capaz de recuperar linhas ainda não comitadas por outros usuários.6. uma nonrepeatable read pode afetar dados existentes). E uma phantom read (leitura fantasma) é como uma nonrepeatable read. Você poderia pensar que serializable é o melhor nível de isolamento. No entanto. este nível de isolamento provoca uma queda no desempenho considerável. uma vez que evita todos os problemas. Uma nonrepeatable read (leitura sem repetição) ocorre quando o mesmo comando SELECT retorna diferentes resultados quando executado mais de uma vez dentro de uma mesma transação.5.2 Níveis de Isolamento A mostra o valores possíveis <sql:transaction>.

sun.1.com/jstl/fmt" %> 6. FORMATAÇÃO Neste capítulo veremos uma coleção de tags JSTL que auxiliam na leitura e escrita de números e datas.1 Imprimindo Números com <fmt:formatNumber> 6. Tdos os tags introduzidos neste capítulo vêm da biblioteca fmt de tags JSTL.6.1 Uso Básico de <fmt:formatNumber> O uso mais simples deste tag imprime o número utilizando a melhor suposição sobre o formato que o usuário deseja ver. datas e outros dados. A tabela abaixo mostra alguns atributos do tag <fmt:formatNumber>: Atributos value type Descrição Obrigatório Não Não Não Não Não Não Não Não Não Não Não Não Default Corpo number Nenhum Nenhum true Nenhum Nenhum Nenhum Nenhum Nenhum Nenhum page O número a ser formatado Se deve ser impresso: numbers. currency ou percentage currencyCode ISO-4217 currency code currencySymbol Símbolo monetário (como $) groupingUsed Se deve haver agrupamento de milhar maxIntegerDigits Número máximo de dígitos inteiros minIntegerDigits Número mínimo de dígitos inteiros maxFractionDigits Número máximo de dígitos fracionários minFractionDigits Número mínimo de dígitos fracionários pattern Padrão a ser utilizado var Variável que deve expor o número formatado como um String scope Escopo da variável var 43 . Exemplo: <fmt:formatNumber value="${valor}"/> Se você está utilizando o Internet Explorer. você pode experimentar diferentes locais modificando no painel de controle as opção referente ao país/língua. Browsers podem transmitir informações sobre seus locale – essencialmente. o local e os formatos preferidos para números. Para utilizar qualquer dos exemplos apresentados neste capítulo será preciso acrescentar no topo da página a seguinte diretiva: <%@ taglib prefix="fmt" uri="http://java.

1.1" minIntegerDigits="1" minFractionDigits="2" maxFractionDigits="2"/> 44 .74901" type="currency"/> 6.6 Controlando Quantos Dígitos Devem Ser Impressos <fmt:formatNumber value="0. com escopo de sessão: <fmt:formatNumber value="${valor}" var="numero" scope="session"/> 6.2 Diferentes Formas de Imprimir um Número Suponha que sua empresa produz um tag que imprime um número.1.3 Armazenando um Número em vez de Imprimi-lo Para armazenar um número na variável numero.1. como o seguinte: <minhaEmpresa:imprimeFrete/> Para formatar a saída a ser impressa: <fmt:formatNumber> <minhaEmpresa:imprimeFrete/> <fmt:formatNumber/> 6.5 Agupamento de Milhar <fmt:formatNumber value="500000.1.6.1.01" groupingUsed="true"/> 6.4 Imprimindo Diferentes Tipos de Números Percentuais: <fmt:formatNumber value="24" type="percent"/> Valor Monetário: <fmt:formatNumber value="78.

Não há como interpretar Strings como data.util. ou você pode utilizar o tag <fmt:parseDate> para produzir uma variável do tipo Date. É possível recuperar uma data de um banco de dados. Você pode obter uma data de algumas formas.5 Nenhum Nenhum page O atributo value do tag <fmt:formatDate> deve apontar para uma variável do tipo date. assim: <jsp:useBean id="umaData" class="java.2 Imprimindo Datas A tabela abaixo mostra os atributos do tag <fmt:formatDate>: Atributos value type dateStyle timeStyle timeZone pattern var scope Descrição A data a ser impressa Se deve ser impresso: data.577E3 pattern="###.Date"/> <fmt:formatDate value="${umaData}"/> 45 .Date"/> Este tag cria uma variável com escopo de página denominada umaData que armazena a data corrente. que será examinado mais adiante. de código Java. Exemplo: <jsp:useBean id="umaData" class="java.##E0"/> 6.1.util. short) Estilo pré-formatado para hora Time zone a ser utilizado Padrão explícito a ser utilizado Variável que deve expor a data formatada como um String Escopo da variável var Obrigatório Sim Não Não Não Não Não Não Não Default Nenhum date default default Ver 6. Você também pode produzir uma data utilizando o tag <useBean>. Esta é a tarefa do tag <fmt:parseDate>. timeou ambos Estilo pré-formatado para data (full.7 Utilizando Padrões Um caso especial difícil de solucionar sem a utilização de padrões é o uso da notação científica: <fmt:formatNumber value="52577" irá imprimir: 52.6.

util. É preciso primeiramente efetuar o parse destes valores. Por exemplo.2. você não pode tratar estes valores como números. O tag <fmt:parseNumber> é específico para casos nos quais é necessário interpretar números mais complicados.6.3 Lendo Números com <fmt:parseNumber> JSTL possui dois tags que nos auxiliam na leitura de números e datas: <fmt:parseNumber> e <fmt:parseDate>. 46 . se o usuário digita 50.1 Utilizando Padrões O atributo pattern nos permite especificar exatamente como uma data deve aparecer.de um arquivo XML ou de um banco de dados .Date"/> Data: <fmt:formatDate value="${umaData}" pattern="dd/MM/yyyy"/><br> Hora: <fmt:formatDate value="${umaData}" pattern="hh:mm:ss"/> 6.000 (incluindo o ponto) ou se você lê . A tabela abaixo mostra os caracteres mais úteis que você pode utilizar em um pattern: Caracter(es) yy yyyy MM MMMM dd EEEE H HH h hh m mm s ss a Significado Ano com dois dígitos Ano com 4 dígitos Mês com dois dígitos Mês por extenso Dia com dois dígitos Dia da semana por extenso Hora com 1 dígito no padrão 24h Hora com 2 dígitos no padrão 24h Hora com 1 dígito no padrão 12h Hora com 2 dígitos no padrão 12h Minuto com 1 dígito Minuto com 2 dígitos Segundo com 1 dígito Segundo com 2 dígitos AM / PM Exemplo 02 2002 04 abril 07 Sexta-feira 21 21 9 09 4 04 6 06 PM Exemplo: <jsp:useBean id="umaData" class="java.valores que incluem vírgulas ou espaços em branco> Nestes casos.

Após efetuar o parse. Você necessita efetuar uma operação matemática sobre um número digitado pelo usuário ou recuperado de algum lugar.2 Como <fmt:parseNumber> Funciona por Default O tag <fmt:parseNumber> recebe o número que deve sofrer o parse através do seu atributo value ou através do seu corpo. <sql:query> (como valor dos atributos startRow ou maxRows). fazer com que todos sejam exibidos com a mesma aparência.3. por default. 47 . Às vezes (embora raramente) você possui um String como 500.00. Você deseja normalizar a exibição de números – isto é. o valor resultante é armazenado na variável com escopo indicada ou é impresso sem nenhuma formatação especial. Quando o tag <fmt:parseNumber> é utilizado para efetuar o parse de um número digitado pelo usuário (ou recuperado de algum outro local) ele assume. Antes de poder passar um número para o tag <fmt:formatNumber> é preciso efetuar o seu parse com <fmt:parseNumber>. e aparecem de formas diferentes.000 mas necessita de um número para ser utilizado em tags como <c:forEach> (como valor dos atributos begin. mas tudo o que você tem é um String como 500.3.000. Você sentirá a necessidade de efetuar o parse de números nas seguintes situações: • • • • Você necessita salvar um valor numérico em um banco de dados utilizando <sql:update> e <sql:param>. Mas alguns de seus números podem vir de usuários ou bancos de dados diferentes. currency.2 Nenhum page 6. e etc. que os usuários poderão entrar com valores com formatações do país/língua do usuário. 6.A tabela abaixo mostra os atributos do tag <fmt:parseNumber>: Atributos value type integerOnly pattern parseLocale var scope Descrição O String que deve sofrer o parse Como efetuar o parse(number. e step). ou percent) Se a parte fracionária deve ser descartada Informações mais detalhadas de como efetuar o parse do número Locale a ser utilizado em vez do default Variável que deve expor o número após o parse (como um número) Escopo da variável var Obrigatório Default Não Não Não Não Não Não Não Corpo number false Nenhum Ver 6.1 Porque Efetuar o Parse de Números Na maioria das páginas você provavelmente não necessitará efetuar o parse de números. end.3.

Por exemplo, considere o formulário HTML abaixo:
<form method="post" action="parseNumber.jsp"> Qual é o seu número favorito? <input type="text" name="favorito" size="10"/><br/> <input type="submit" value="Enviar"/> </form>

A página JSP abaixo mostra como tratar este formulário:
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %> <p>Você digitou "<c:out value="${param.favorito}"/>". </p> <fmt:parseNumber var="fav" value="${param.favorito}"/> <p>Aparentemente este número corresponde ao número <c:out value="${fav}"/>.</p> <p>Se você multiplicar este número por 2 e somar 1, você obtém <c:out value="${fav * 2 + 1}"/>, certo?</p>

6.3.3 Modificando as Regras de Parse de <fmt:parseNumber> Os demais atributos de <fmt:parseNumber> permitem que você modifique as regras que serão utilizadas por default. Ignorando Dígitos Fracionários
<fmt:parseNumber var="numero" value="50.05" integerOnly=”true”/>

Modificando o Locale Como ignorar o Locale informado pelo Browser:
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %> <html> <body> <h4>Utilizando o Locale Referente aos EUA</h4> <fmt:setLocale value="en_US"/> <fmt:parseNumber var="numero1" value="50,05"/> <fmt:parseNumber var="numero2" value="50,05" integerOnly="true"/>

48

<p>O parse de 50,05 corresponde ao número <c:out value="${numero1}"/> sem formatação. <p>O parse de 50,05 corresponde ao número <fmt:formatNumber value="${numero1}"/> com formatação. <p>O parse de 50,05 - removendo a parte fracionária - corresponde ao número <fmt:formatNumber value="${numero2}" /> com formatação. <h4>Utilizando o Locale Referente ao Brasil</h4> <fmt:setLocale value="pt_BR"/> <fmt:parseNumber var="numero1" value="50,05"/> <fmt:parseNumber var="numero2" value="50,05" integerOnly="true"/> <p>O parse de 50,05 corresponde ao número <c:out value="${numero1}"/> sem formatação. <p>O parse de 50,05 corresponde ao número <fmt:formatNumber value="${numero1}"/> com formatação. <p>O parse de 50,05 - removendo a parte fracionária - corresponde ao número <fmt:formatNumber value="${numero2}" /> com formatação. </body> </html>

6.4 Lendo Datas com <fmt:parseDate> A tabela abaixo mostra os atributos do tag <fmt:parseDate>: Atributos
value type pattern parseLocale timeZone var scope

Descrição

Obrigatório

Default
Corpo date Nenhum Ver 6.3.2 Ver 6.5 Nenhum page

O String que deve sofrer o parse Não Como efetuar o parse(time, date, ou Não ambos) Pdrão a ser utilizado ao efetuar o Não parse de uma data O locale que deve ser utilizado, em Não vez do default O time zone a ser aplicado à data Não Variável que deve expor a data após o Não parse (como um número) Escopo da variável var Não

49

Os atributos value, var, scope e parseLocale funcionam exatamente como no tag <fmt:parseNumber>. 6.4.1 Como <fmt:parseDate> Funciona por Default O funcionamento do tag <fmt:parseDate> assim como outros tags de formatação e de parse, é dependente do locale default do browser do usuário. Sem nenhum atributo além de value, ele efetua o parse de uma data da mesma forma como <fmt:formatDate> formata uma data. As regras de parse são bastante restritivas. Logo, o tag
<fmt:parseDate value="Aug 24, 1981"/>

irá funcionar para o locale English, mas
<fmt:parseDate value="Aug 24, 1981"/>

causará um erro pois falta a vírgula. Este comportamento torna o default muito pouvo útil. 6.4.2 Modificando Como <fmt:parseDate> Efetua o Parse de Datas O tag <fmt:parseDate> possui o atributo pattern, que é a forma mais útil de utilizar este tag. O atributo pattern aceita um padrão de data – com a mesma sintaxe vista na seção 6.2.1 – e efetua o parse de acordo com este padrão. Exemplo:
<fmt:parseDate var="umaData" value="26/05/1990" pattern="dd/MM/yyyy"/>

50

Suponha que uma página HTML possui os seguintes tags: <input type="checkbox" name="lingua" value="ingles" /> <input type="checkbox" name="lingua" value="espanhol" /> <input type="checkbox" name="lingua" value="frances" /> Se o usuário clicar nas três caixas.nome} onde nome é o nome do parâmetro que você deseja (lingua.jsp"> <p>Por favor selecione as línguas que você conhece:</p> <p>Inglês <input type="checkbox" name="lingua" value="Inglês" /> <p>Espanhol <input type="checkbox" name="lingua" value="Espanhol" /> <p>Francês <input type="checkbox" name="lingua" value="Francês" /> <p><input type="submit" value="Enviar" /></p> </form> 51 . neste caso). Espanhol e Francês. Você pode utilizar o tag <c:forEach> para efetuar um loop sobre os parâmetos individuais nesta coleção.1 O Formulário HTML <form method="post" action="checkbox. Você pode acessar uma coleção que contém todos estes valores através da expressão ${paramValues.1 Tratando Parâmetros do tipo CheckBox Parâmetros de CheckBox são especiais uma vez que o mesmo nome pode ser mapeado a diversos valores.1. 7. TAREFAS COMUNS 7.7. o parâmetro língua terá os três valores: Inglês. para tratá-los um de cada vez.

Há outras maneiras de garantir que os tags <ul> e </ul> serão impresos apenas quando a lista tiver pelo menos um item.last}"> </ul> </c:if> </c:forEach> 52 .lingua}" var="idioma"> <li><c:out value="${idioma}"/></li> </c:forEach> </ul> </c:when> <c:otherwise> Você não selecionou nenhuma caixa de verificação.sun.2 Um Manipulador de CheckBox Simples Segue abaixo a página JSP manipuladora do formulário HTML acima: <%@ taglib prefix="c" uri="http://java.first}"> <ul> </c:if> <li><c:out value="${idioma}"/></li> <c:if test="${s. O raciocínio é o seguinte: uma coleção inexistente é como uma coleção com zero elementos.7. </c:otherwise> </c:choose> Na verdade não é um problema efetuar um loop sobre um parâmetro inexistente. O tag <c:forEach> simplesmente não fará nada. Exemplo: <c:forEach items="${paramValues. No entanto. como desejamos enviar uma mensagem caso o usuário não selecione nenhuma língua.lingua}" var="idioma" varStatus="s"> <c:if test="${s.com/jstl/core" %> <c:choose> <c:when test="${not empty paramValues.1. foi acrescentado o tag <c:choose>. logo faz sentido efetuar uma iteração zero vezes.lingua}"> As línguas que você conhece são: <ul> <c:forEach items="${paramValues.

3 Tratando Alguns CheckBoxes de Forma Especial Com o tag <c:forEach> é possível utilizar expressões para referenciar o item corrente – idioma. neste caso – para tomar decisões sobre como tratar cada item individualmente. </c:otherwise> </c:choose> Para atualizar o banco de dados quando a página é carregada com a língua Inglesa selecionada.sun. poderíamos executar o código abaixo: <sql:update> UPDATE idiomas set ingles = ingles + 1 </sql:update> 53 .lingua}" var="idioma"> <c:choose> <c:when test="${idioma == 'Inglês'}"> <font size="+2"> </c:when> <c:otherwise> <font size="-2"> </c:otherwise> </c:choose> <li><c:out value="${idioma}"/></li> </font> </c:forEach> </ul> </c:when> <c:otherwise> Você não selecionou nenhuma caixa de virificação.7.1.lingua}"> As línguas que você conhece são: <ul> <c:forEach items="${paramValues. Exemplo: <%@ taglib prefix="c" uri="http://java.com/jstl/core" %> <c:choose> <c:when test="${not empty paramValues.

com/jstl/core" %> <html> <body> <form method="post" action="trataData.7. 54 . e dois campos gerados dinamicamente: dia e ano.2.2 Lendo Datas 7.1 O Formulário HTML <%@ taglib prefix="c" uri="http://java. Nesta página há um campo de formulário estático (mes). entre com a data de seu nascimento: <p> <select name="dia"> <c:forEach begin="1" end="31" var="dia"> <option><c:out value="${dia}"/></option> </c:forEach> </select> <select name="mes"> <option value="01">Janeiro</option> <option value="02">Fevereiro</option> <option value="03">Março</option> <option value="04">Abril</option> <option value="05">Maio</option> <option value="06">Junho</option> <option value="07">Julho</option> <option value="08">Agosto</option> <option value="09">Setembro</option> <option value="10">Outubro</option> <option value="11">Novembro</option> <option value="12">Dezembro</option> </select> <select name="ano"> <c:forEach begin="1930" end="2003" var="ano"> <option><c:out value="${ano}"/></option> </c:forEach> </select> <input type="submit" value="Enviar" /> </form> </body> </html> Note que embora a página acima gere um simples formulário de entrada de dados HTML.sun.jsp"> Por favor. não se trata de uma página HTML estática.

Para provar que a data realmente passou pelo processo de parse mandamos imprimi-la utilizando o estilo full que exibe o dia da semana correspondente. <p> Você nasceu em <fmt:formatDate value="${umaData}" dateStyle="short"/>.com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.mes}/${param.sun. como vem no exemplo abaixo: <sql:update> UPDATE usuarios SET data_nasc = ? <sql:param value="${umaData}"/> </sql:update> 55 .dia}/${param.sun. Observe que no tag <fmt:parseDate> foi incluído o atributo parseLocale para fazer com que o parse ocorra com base no locale português/Brasil em vez de utilizar o locale do browser.2 Tratando o Formulário e Lendo a Data Segue abaixo o código fonte da página manipuladora do formulário: <%@ taglib prefix="c" uri="http://java.ano}" pattern="d/MM/yyyy"/> <p> Você nasceu <fmt:formatDate value="${umaData}" dateStyle="full"/>. a data sofrerá o parse corretamente e será armazenada na variável data. <p> Você nasceu em <fmt:formatDate value="${umaData}" pattern="dd/MM/yyyy"/>.7.com/jstl/fmt" %> <fmt:parseDate var="umaData" parseLocale="pt_BR" value="${param. Naturalmente poderíamos ter feito outras coisas com a data além de apenas imprimi-la. Assim.2.

Neste caso. Nestes casos. Utilizar uma facilidade que JSP provê conhecida como error page (geralmente escrita como errorPage). caso o banco de dados esteja fora dor ar.1 Capturando Erros com <c:catch> Este tag permite que você capture o erro para descartá-lo ou para armazenar informações sobre ele para uso posterior. sem o contador.7. Fazendo isto você ganha em flexibilidade. Por outro lado.3 Tratando Erros Quando você utiliza tags JSTL. será apresentada uma mensagem de erro. Se uma página possui um contador que atualiza seu valor em um banco de dados. 56 . A tabela abaixo mostra o único atributo do tag <c:catch>: Atributos var Descrição Variável que expõe informações sobre o erro Obrigatório Não Default Nenhum Erros que acontecem no corpo de um tag <c:catch> não fazem com que seja abortada toda a execução da página. Uma errorPage JSP é uma página que você pode projetar para tratar erros de diversas páginas.3. você poderá descartar um erro significativo. A seguir será apresentado um exemplo onde o usuário digita um número inteiro que deverá passar pelo processo de parse. Basta apontar todas elas para uma mesma página de erro e definir o que esta página deve fazer quando um erro ocorre. mas pode tornar as páginas muito complicadas. qualquer erro que ocorra em sua página faz com que a execução da página falhe. Uma vantagem desta página de erro é que ela permite que o mesmo comportamento seja utilizado para um conjunto de páginas. a página será executada. todos os erros que ocorrerem no corpo do tag serão ignorados e a execução da página irá prosseguir. Se você utilizar <c:catch> sem um atributo var. existem basicamente três coisas que você pode fazer com os erros: • Evitar pensar neles. Se o processo de parse não for bem sucedido. Utilizar o tag <c:catch> para capturar e até mesmo tentar recuperar erros dentro da mesma página. Esta abordagem é boa enquando você está debugando a página. geralmente o container JSP provê informações sobre o tipo de erro que ocorreu. mas parece pouco profissional para os usuários. Estes erros abortam apenas o resto do corpo do tag <c:catch>. • • 7. a atualização deste contador poderá estar envolta em um tag <c:catch>. Quando você faz isso.

</p> <c:catch var="erro"> <fmt:parseNumber var="num" value="${param. se erro está Empty. então as demais linhas de código dentro do tag <c:catch> não serão executadas. durante a execução de <fmt:parseNumber>. não faz sentido efetuar operações aritméticas com ele.sun. Observe que se um erro ocorre durante o processo de parse.numero}"/> <p>Multiplicando <c:out value="${num}"/> por dois e somando 1 dá <c:out value="${num * 2 + 1}"/>. então nenhum erro ocorreu.com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.message}"/> ou simplesmente: <c:out value="${erro}"/> Esta última opção inclui algumas outras informações técnicas sobre o erro que ocorreu. Caso contrário teremos certeza de que um erro ocorreu dentro do bloco <c:catch>.sun.<%@ taglib prefix="c" uri="http://java. o seguinte tag pode ser utilizado: <c:out value="${erro. Neste caso. </p> </c:catch> <c:if test="${not empty erro}"> Erro: o que você digitou não é um número. isto é.numero}"/>".com/jstl/fmt" %> <html> <body> <p>Você digitou "<c:out value="${param. As variáveis criadas pelo tag <c:catch> possuem pelo menos uma propriedade útil: message. este comportamento faz sentido: se o valor digitado não é um número. A coisa mais útil que se pode fazer com a variável criada com o tag <c:catch var="erro"> é verificar se ela está empty. que contém alguma informação que descreve o erro que ocorreu. 57 . Esta propriedade é útil se você quer que o usuário tenha uma idéia do erro que ocorreu. Para incluir informações sobre o erro ocorrido. </c:if> </body> </html> Para adicionar o tratamento de erro a esta página adicionamos o tag <c:catch> em torno dos tags que podem provocar erros. Este tag garante que nenhum erro que ocorra será percebido pelo container JSP.

Para declarar uma página de erro.com/jstl/fmt" %> <fmt:parseDate value="abcd"/> 58 . No entanto. A variável pageContext. Esta página de erro é uma página JSP normal.sun.sun.com/jstl/fmt" %> <h4>Erro!</h4> <p>Algo ruim ocorreu em uma das suas páginas:</p> <p><c:out value="${pageContext.com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java. paginaDeErro. o container exibe. o usuário recebe um forward para esta página de erro sempre que um erro ocorre (como se você tivesse manualmente incluído um tag <jsp:forward> na sua página). Note que você pode utilizar o tag <c:catch> e a página de erro na mesma página JSP.jsp" %> <%@ taglib prefix="c" uri="http://java. você deve utilizar a diretiva <%@ page errorPage=”destino” %>.7.sun. a sua própria mensagem de erro.com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.sun.exception. Criando uma Página de Erro Listagem da página de erro: <%@ page isErrorPage="true" %> <%@ taglib prefix="c" uri="http://java.message} para imprimir informações sobre o erro que ocorreu. onde destino é o nome da página de erro.3. A página de erro receberá o forward apenas se um erro ocorrer e não for capturado pelo bloco <c:catch>.exception. por exemplo.exception é a variável com escopo que é armazenada pelo bloco <c:catch>.message}"/></p> Note como utilizamos a expressão ${pageContext. Quando sua página possui uma página de erro. Listagem da página que contém um erro: <%@ page errorPage="paginaDeErro.jsp. por default.2 Enviando Erros para uma Página de Erro Quando um erro alcança o container JSP. A única diferença é que ela deve incluir a seguinte linha: <%@ page isErrorPage="true" %> Esta linha indica ao container JSP que ele pode utilizar esta página como página de erro. você pode modificar este comportamento utilizando uma página de erro JSP.

a função das páginas JSP é apenas apresentar e formatar a informação.email}" var="semEmail" /> <c:if test="${empty param.sun. em grandes aplicações para a web. até que todos os campos do formulário tenham sido informados corretamente. O código Java executado no back-end cuida do resto. Garantir que se um campo foi preenchido um outro também deveria ter sido (ou não).com/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.idade}" var="semIdade" /> <c:catch var="erroIdade"> <fmt:parseNumber var="idadeNumerica" value="${param.idade}" /> <c:if test="${idadeNumerica < 13}" var="abaixo13" /> </c:catch> <c:if test="${not empty erroIdade}" var="idadeInvalida" /> <c:if test="${not (semNome or semEmail or semIdade or idadeInvalida or abaixo13)}"> 59 .7.nome}" var="semNome" /> <c:if test="${empty param.sun. 7.4. Exemplo: <%@ taglib prefix="c" uri="http://java.4. Os tags JSTL disponíveis para validação incluem coisas como: • • • Verificar se o usuário digitou algo em um campo de um formulário (ou o deixou em branco). Esta página é exibida repetidamente. especialmente me uma aplicação que utiliza Struts ou um outro framework para prover a separação do trabalho e implementação.4 Validando Entrada de Dados 7.enviado}"> <c:if test="${empty param. Comparar um número digitado pelo usuário com uma faixa de valores. Em uma aplicação deste tipo.com/jstl/fmt" %> <html> <body> <h1>Serviço de Correio Eletrônico Tabajara</h1> <c:if test="${param.2 Tarefas Relacionadas à Validação de um Formulário A seguir será apresentada uma página JSP responsável pela validação dos campos de um formulário de entrada de dados exibido por esta mesma página JSP. não é função das páginas JSP efetuar validação de entrada de dados.1 Diferentes Tipos de Validação de Formulários A primeira coisa a compreender sobre validação é que.

jsp" /> </c:if> </c:if> <form method="post"> <p> Obrigado por assinar o serviço de correio eletrônico Tabajara.<c:set value="${param.nome}"/>" /> <br /> <c:if test="${semNome}"> <small><font color="red"> Erro: Você deve digitar seu nome </font></small> </c:if> </p> <p> Digite seu endereço de e-mail: <input type="text" name="email" value="<c:out value="${param. </p> <input type="hidden" name="enviado" value="true" /> <p> Digite seu nome: <input type="text" name="nome" value="<c:out value="${param.email}" var="email" scope="request"/> <c:set value="${param.idade}" var="idade" scope="request"/> <jsp:forward page="obrigado.email}"/>" /> <br /> <c:if test="${semEmail}"> <small><font color="red"> Erro: Você deve digitar seu endereço de e-mail </font></small> </c:if> </p> <p> Digite sua idade: <input type="text" name="idade" size="3" value="<c:out value="${param. você começará a receber "de grátis" todo tipo de "spam" que você sempre quis.<br/> Ao submeter suas informações no formulário abaixo.idade}"/>" /> <br /> <c:choose> <c:when test="${semIdade}"> <small><font color="red"> Erro: Você deve digitar sua idade </font></small> </c:when> 60 .nome}" var="nome" scope="request"/> <c:set value="${param.

O tag <c:if test="${empty param. um campo hidden designa o valor true para o 61 .<c:when test="${idadeInvalida}"> <small><font color="red"> Erro: Não fui capaz de decifrar sua idade </font></small> </c:when> <c:when test="${abaixo13}"> <small><font color="red"> Erro: Se manca garoto!!! Você é muito jovem para assinar o serviço <br> de e-mail Tabajara.idade}" /> <c:if test="${idadeNumerica < 13}" var="abaixo13" /> </c:catch> designa uma variável com escopo de página denominada erroIdade caso ocorra um erro durante o processo de parse. Neste caso. O código abaixo. </font></small> </c:when> </c:choose> </p> <input type="submit" value="Assinar" /> </form> </body> </html> Esta página começa com lógica de validação de dados. Para testar se o usuário digitou um número no campo idade utilizamos o elemento <c:catch>. Primeiramente o tag <c:if> é utilizado para determinar se esta página está respondendo a um formulário ou exibindo o formulário pela primeira vez. efetuamos um forward para a página seguinte. cresça e tente novamente.nome não possui um valor significativo.nome}" var="semNome" /> designa true a uma variável com escopo de página denominada semNome. <c:catch var="erroIdade"> <fmt:parseNumber var="idadeNumerica" value="${param. são designados valores para três variáveis com escopo de request para que a página seguinte possa recuperar seus valores. Aqui tem besteira demais para você! <br> Por favor. Se o forward não acontecer. caso nenhum erro tenha ocorrido. Observe que antes do forward. então o formulário será exibido. Em seguida os parâmetros enviados a esta página são validados. se param. Em seguida.

botões de rádio.lingua == 'Francês'}"> selected="selected" </c:if> >Francês</option> </select> O atributo selected=”selected” será impresso apenas para o valor correto. Você pode fazer isto comparando o valor do parâmetro com os valores do tag <option> que você está prestes a imprimir. Para campos do tipo <input type=”text”> podemos utilizar o atributo value para fornecer um valor para o campo.obs}"/><textarea> Observe que o tag form não possui um atributo action. 62 .campo enviado para indicar que o formulário está sendo submetido pelo usuário em vez de solicitado pela primeira vez. e caixas de confirmação – é mais complicado designar valores default. Para campos do tipo <textarea>. indicando que a mesma página JSP deve receber a requisição quando este formulário for submetido.nome}"> Para outros tipos de campos de entrada de dados – caixas de seleção. não basta especificar um atributo value para o valor default. No caso do campo idade. e para cada campo. Por exemplo: <select name="Idioma"> <option value="Inglês" <c:if test="${param.lingua == 'Inglês'}"> selected="selected" </c:if> >Inglês</option> <option value="Francês" <c:if test="${param. Os campos do formulário (nome. foi utilizado o tag <c:choose> uma vez que três mensagens de erro diferentes podem ser emitidas. se um erro é detectado. Você deve adicionar o atributo selected=”selected” ao tag <option> correto. uma mensagem em vermelho é impressa. você adiciona o atributo checked=”checked”. simplesmente insira o valor desejado no corpo da <textarea>: <textarea name="observação"><c:out value="${param. email e idade) recebem os valores dos parâmetros enviados à página. Para uma caixa do tipo <select>. Botões de rádio e caixas de confirmação funcionam da mesma forma. assim: <input type="text" name="nome" value="<c:out value="${param. mas em vez de adicionar o atributo selected=”selected”.

com/jstl/core" %> <html> <body> <font face="arial"> <h4> Excelente! Os seguintes dados foram recebidos e estão corretos: </h4> <ul> <li>Nome: <c:out value="${requestScope.idade}" /> </ul> </font> </body> </html> 63 .A página JSP abaixo é exibida quando não é detectado mais nenhum erro nos campos do formulário: <%@ taglib prefix="c" uri="http://java.email}" /> <li>Idade: <c:out value="${requestScope.sun.nome}" /> <li>E-Mail: <c:out value="${requestScope.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->