Apostila de JSPTraduo Resumida do Livro Web Development with JavaServer Pages de Duane K. Fields e Mark A. KolbProf. Carlos Ribeiro

____________________________________________________________________________________

ndice1. INTRODUO .................................................................................................................................. 5 1.1 1.2 1.3 Desempenho ............................................................................................................................. 5 Separando a Apresentao da Implementao.......................................................................... 7 Diviso do Trabalho ................................................................................................................. 8

2. FUNDAMENTOS............................................................................................................................... 9 2.1 2.2 2.3 2.4 2.5 Primeiro Exemplo de Pgina JSP ............................................................................................ 9 Segunda Verso do Exemplo Al Mundo ................................................................................ 9 Verso do Exemplo Al Mundo com Bean ............................................................................ 10 Convenes sobre Tags .......................................................................................................... 12 Como JSP Funciona................................................................................................................ 13

3. PROGRAMANDO SCRIPTS JSP.................................................................................................. 17 3.1 Linguagens de Script .............................................................................................................. 17 3.2 Tags JSP ................................................................................................................................. 17 3.3 Diretivas JSP .......................................................................................................................... 17 3.3.1 Diretiva de Pgina .............................................................................................................. 18 3.3.2 Diretiva Include .................................................................................................................. 23 3.3.3 Diretiva Tag Library ........................................................................................................... 23 3.4 Elementos de Script ................................................................................................................ 24 3.4.1 Declaraes......................................................................................................................... 24 3.4.2 Expresses .......................................................................................................................... 27 3.4.3 Scriptlets ............................................................................................................................. 28 3.5 Fluxo de Controle ................................................................................................................... 29 3.5.1 Condies ........................................................................................................................... 29 3.5.2 Iterao ............................................................................................................................... 30 3.5.3 Tratamento de excees...................................................................................................... 31 3.6 Comentrios............................................................................................................................ 32 3.6.1 Comentrios de Contedo...................................................................................................32 3.6.2 Comentrios JSP................................................................................................................. 32 3.6.3 Comentrios da Linguagem de Script................................................................................. 33 4. OBJETOS IMPLCITOS E AES ........................................................................................ 34 4.1 Objetos Implcitos................................................................................................................... 34 4.1.1 Objetos Relacionados a Servlets......................................................................................... 35 4.1.2 Entrada e Sada ................................................................................................................... 37 4.1.3 Objetos Contextuais............................................................................................................ 42 4.1.4 Tratamento de Erros ........................................................................................................... 49 4.2 Aes ...................................................................................................................................... 49 4.2.1 Forward............................................................................................................................... 50 4.2.2 Plug-in ................................................................................................................................ 53 4.2.3 Bean Tags ........................................................................................................................... 53

____________________________________________________________________________________ Apostila de JSP 2

____________________________________________________________________________________ 5. UTILIZANDO COMPONENTES JSP....................................................................................... 54 5.1 O Modelo de Componentes JSP ............................................................................................. 54 5.1.1 Arquiteturas de Componentes............................................................................................. 54 5.1.2 Benefcios da Abordagem Baseada em Componentes........................................................ 54 5.1.3 O Projeto de Componentes para Aplicaes Web .............................................................. 54 5.2 Fundamentos de JavaBeans .................................................................................................... 55 5.3 JSP Bean Tags ........................................................................................................................ 58 5.3.1 Programao com Componentes Baseados em Tags.......................................................... 58 5.3.2 Acessando Componentes JSP ............................................................................................. 59 5.3.3 Inicializando Beans............................................................................................................. 65 5.3.4 Controlando o Escopo de um Bean..................................................................................... 69 6. DESENVOLVENDO COMPONENTES JSP ............................................................................ 75 6.1 O Que Faz de um Bean um Bean............................................................................................ 75 6.1.1 Convenes......................................................................................................................... 75 6.1.2 O Construtor Bean .............................................................................................................. 76 6.1.3 Definindo as Propriedades de um Bean .............................................................................. 77 6.1.4 Propriedades Indexadas ...................................................................................................... 79 6.1.5 Propriedades Boleanas........................................................................................................ 82 6.1.6 Converso de Tipo JSP....................................................................................................... 83 6.1.7 Configurando Beans ........................................................................................................... 83 6.2 Alguns Exemplos.................................................................................................................... 85 6.2.1 Exemplo: HoraCorrenteBean.............................................................................................. 85 6.2.2 Um Bean que Calcula Juros Compostos............................................................................. 86 6.3 Interfaces Definidas para Beans .............................................................................................90 6.3.1 A Interface Serializable ...................................................................................................... 90 6.3.2 A Interface HttpSessionBindingListener ............................................................................ 90 6.4 Misturando Scriptlets e Bean Tags ......................................................................................... 91 6.4.1 Acessando Beans Atravs de Scriptlets .............................................................................. 91 6.4.2 Acessando Objetos Criados Atravs de Scriptlets .............................................................. 91 7. TRABALHANDO COM BANCOS DE DADOS ....................................................................... 95 7.1 JSP e JDBC............................................................................................................................. 95 7.1.1 JNDI e Data Sources........................................................................................................... 95 7.2 Aplicaes de Banco de Dados com JSP................................................................................ 96 7.2.1 Criando Componentes JSP a partir de Dados de uma Tabela............................................. 96 7.2.2 Tipos de Dados JSP e JDBC............................................................................................... 98 7.2.3 Mantendo Conexes Persistentes...................................................................................... 100 7.2.4 Manipulando Grandes Conjuntos de Resultados .............................................................. 102 7.3 Exemplo: Ferramenta para Controle de Reservas para Conferncias ........................................ 106 7.3.1 Resumo do Projeto............................................................................................................ 106 7.3.2 O Banco de Dados ............................................................................................................ 107 7.3.3 Resumo do Projeto............................................................................................................ 107 8. PROJETANDO APLICAES JSP ........................................................................................ 114 8.1 Aplicaes para a Web ......................................................................................................... 114 8.1.1 O Fluxo de Aplicaes para a Web .................................................................................. 115 8.1.2 Abordagens de Projeto...................................................................................................... 116 ____________________________________________________________________________________ Apostila de JSP 3

____________________________________________________________________________________ 8.2 Projeto Page-Centric............................................................................................................. 116 8.2.1 Pginas Baseadas em Funes.......................................................................................... 116 8.2.2 Construindo Pginas Compostas ...................................................................................... 118 8.2.3 Limitaes da Abordagem Page-Centric .......................................................................... 120 8.3 Abordagem Servlet-Centric .................................................................................................. 120 8.3.1 O Exemplo Al Mundo com Servlets............................................................................... 121 8.3.2 JSP e a API Servlet........................................................................................................... 122 8.3.3 Servlets para Controle de Aplicaes ............................................................................... 125 8.3.4 Servlets para o Tratamento da Lgica da Aplicao......................................................... 126 8.3.5 Servlets como Ponto nico de Entrada ............................................................................ 129 8.3.6 Tratando Erros no Servlet.................................................................................................133 8.3.7 Exemplo: Uma Aplicao Servlet-Centric........................................................................ 133 8.3.8 Retornando uma Lista de Empregados ............................................................................. 139 8.3.9 Retornando um nico Empregado ................................................................................... 140 8.4 Enterprise JavaBeans............................................................................................................ 141 8.4.1 O que so Enterprise JavaBeans ....................................................................................... 142 8.4.2 JavaBeans x EJBs ............................................................................................................. 142 8.4.3 Projeto de Aplicaes com EJBs ...................................................................................... 142 9. EXECUTANDO TAREFAS COMUNS COM JSP ................................................................. 144 9.1 Tratando Cookies.................................................................................................................. 144 9.1.1 Gerenciando Cookies........................................................................................................ 144 9.1.2 A Classe Cookie ............................................................................................................... 144 9.1.3 Exemplo 1: Criando um Cookie ....................................................................................... 146 9.1.4 Exemplo 2: Recuperando um Cookie ............................................................................... 147 9.2 Criando Pginas de Erro ....................................................................................................... 148 9.2.1 Uma Pgina com Erro....................................................................................................... 149 9.9.2 Mtodos para a Coleta de Dados sobre o Erro.................................................................. 149 9.2.3 Enviando Correio Eletrnico ............................................................................................ 153 9.2.4 A pgina de Erro............................................................................................................... 155 9.3 Misturando JSP e JavaScript ................................................................................................ 158 9.4 Construindo Interfaces Interativas ........................................................................................ 161 9.4.1 Mtodos Utilitrios ........................................................................................................... 162 9.4.2 O Formulrio Exemplo ..................................................................................................... 164 9.4.3 Criando o Formulrio ....................................................................................................... 164 9.4.4 Campos de Texto e Escondidos ........................................................................................ 165 9.4.5 reas de Texto.................................................................................................................. 165 9.4.6 Botes de Rdio................................................................................................................ 166 9.4.7 Caixas de Seleo ............................................................................................................. 166 9.4.8 Caixas de Confirmao..................................................................................................... 166 9.4.9 Cdigo Fonte do Formulrio ............................................................................................ 167 9.5 Validando Dados de Formulrio........................................................................................... 170 9.5.1 Validao de Dados nos Lados Cliente e Servidor ........................................................... 170 9.5.2 Exemplo de Validao no Lado Servidor ......................................................................... 170 9.6 Tarefas Variadas ................................................................................................................... 174 9.6.1 Determinando a ltima Data de Modificao de uma Pgina .......................................... 174 9.6.2 Executando Comandos de Sistema ................................................................................... 175 9.6.3 Gerando XML................................................................................................................... 176 10. BIBLIOGRAFIA .................................................................................................................... 177

____________________________________________________________________________________ Apostila de JSP 4

____________________________________________________________________________________

1. INTRODUO Em 1996 a Sun Microsystems introduziu os servlets como pequenas aplicaes baseadas em Java para adicionar funcionalidade dinmica aos servidores web. Java Servlets possuem um modelo de programao similar a scripts CGI, uma vez que eles recebem do servidor web uma requisio HTTP como entrada e geralmente constrem o contedo apropriado para a resposta que o servidor web dever encaminhar ao usurio. 1.1 Desempenho No entanto, diferentemente dos CGIs que necessitam de um novo processo na memria para tratar cada nova requisio, todos os servlets associados a um servidor web so executados dentro de um nico processo. Este processo executa a Mquina Virtual Java (JVM) que dependente de plataforma para executar (em qualquer plataforma) programas Java compilados. Em vez de criar um processo para cada requisio, a JVM cria uma thread Java para manipular cada requisio enviada a um servlet. Threads Java causam um overhead muito menor do que a completa instanciao de processos para a execuo de programas CGI, isto , o overhead causado para a instanciao e destruio de uma thread significativamente menor do que para a instanciao e destruio de um processo. Por esta razo threads costumam ser chamadas de processos peso leve. Por utilizarem menos recursos, so muito mais eficientes do que processos. Por exemplo, processos geralmente copiam a memria do processo pai, enquanto as threads compartilham a memria com o processo pai. Por outro lado, como as requisies a servlets e a pginas JSP so atendidas por um mesmo processo (JVM) que persiste alm do ciclo de vida de uma nica requisio, servlets tambm podem evitar operaes que consomem muito tempo, tal como a conexo com bancos de dados. Isto , uma nica conexo pode ser compartilhada por vrias requisies. Por exemplo, o acesso a banco de dados muito mais rpido quando se utiliza um pool de conexes reutilizveis que sempre permanecem abertas. Ao mesmo tempo, como servlets so escritos em Java, eles se beneficiam do ncleo da plataforma Java: um modelo de programao orientado a objetos, gerenciamento de memria automtico, portabilidade total e acesso a uma rica coleo de APIs Java agora disponveis para acesso a bancos de dados, recursos de rede, etc. Uma desvantagem potencial desta abordagem, no entanto, reside no cdigo fonte do programa. Como resultado, qualquer modificao em um documento requer a interveno de um programador. O designer de uma pgina HTML no pode modificar o layout de uma pgina a menos que saiba como mexer no cdigo fonte do servlet. De fato, qualquer mudana em um elemento esttico de um documento requer a correspondente mudana do cdigo fonte. Como discutido no pargrafo anterior, a incorporao de contedo dinmico a um documento envolve alguma forma de programao para descrever como este contedo____________________________________________________________________________________ Apostila de JSP 5

____________________________________________________________________________________

gerado. Cdigo de programa, no entanto, tende a ser caro na criao e manuteno, logo, minimizar a necessidade de programao geralmente um objetivo desejvel. JSP combina este objetivo com o suporte completo todas as caractersticas da linguagem Java.JSP um sistema hbrido entre os sistemas template existentes, pois suportam dois estilos diferentes para se adicionar contedo dinmico a pginas web. Como PHP e ASP, scripts podem ser embutidos em pginas JSP contendo cdigo de programao. No caso de JSP este cdigo geralmente Java, embora, de acordo com a especificao de JSP, uma linguagem de script alternativa possa ser utilizada. E como ColdFusion, JSP suporta um conjunto de tags no estilo HTML que interagem com objetos Java no

servidor, sem a necessidade de aparecer cdigo Java na pgina. Em particular, estes tags so projetados para se criar, consultar e modificar server-side JavaBeans. De fato, a especificao de JSP 1.1 prov um mecanismo que permite que os desenvolvedores criem bibliotecas de tags customizados que possam ser carregados em uma pgina JSP. Estes tags customizados podero ento ser utilizados na pgina assim como os tags JSP padro. Como uma demonstrao do poder desta abordagem, a empresa Live Software, construtora do JRun (um software que habilita a execuo se servlets e de pginas JSP em qualquer servidor web), desenvolveu um conjunto de tags JSP customizados que reproduziam os tags utilizados pelo produto ColdFusion da Allaire. Este produto (um clone do ColdFusion, multi-plataforma e baseado em Java) foi liberado em maio de 1999 como . A Allaire ficou to impressionada com o produto que em maio de 1999 comprou a Live Software. Servlets e JavaServer Pages apareceram pela primeira vez como parte do Java Web Server da Sun, um servidor HTTP escrito em Java. Posteriormente a Sun liberou a tecnologia servlet como uma extenso padro da linguagem Java. A primeira especificao de JSP surgiu em Junho de 1999. Logo aps a Sun ter publicado a especificao para servlets, outras companhias comearam a adicionar suporte a servlets em seus produtos. Atualmente h uma srie de produtos de terceiros capazes de adicionar a funcionalidade de servlets e JSP a servidores web. Dois dos mais populares produtos nesta categoria so JRun da Allaire e o ServletExec da New Atlanta. E em junho de 1999 a Sun Microsystems e a Apache Software Foundation anunciaram o projeto Jakarta, com o objetivo de gerar uma implementao Open Source de servlets e JSP que tambm ir servir de referncia para estas tecnologias. E dentre os Enterprise Web Application Servers podemos encontrar o Netscape Application Server, IBM WebSphere e BEA WebLogic, entre outros. Atualmente, o desenvolvimento de aplicaes JSP est comeando a deixar de ser um processo manual. Boas ferramentas de desenvolvimento esto sendo desenvolvidas. Vrios vendedores de ferramentas para a construo de sites para a web esto____________________________________________________________________________________ Apostila de JSP 6

____________________________________________________________________________________

providenciando o suporte a JSP nas verses de seus produtos. Entre eles podemos citar Dreamweaver Ultradev (sucessor do Drumbeat 2000 que deixa de existir) da Macromedia, Visual Age for Java da IBM, e o HomeSite da Allaire. 1.2 Separando a Apresentao da ImplementaoJSP agora parte integrante do desenvolvimento de aplicaes para web utilizando

Java. Em funo da sua habilidade de separar a apresentao da lgica de implementao atravs da combinao de texto markup padro com elementos de script e componentes orientados a objetos (JavaBeans), JSP prov uma excelente tecnologia de front-end para a web. Isto , possvel manter uma estrita separao entre a apresentao dos dados a exibio da informao para o usurio final e a sua implementao o cdigo necessrio para gerar a informao. O benefcio de desacoplar estes dois aspectos que isto permite que modificaes sejam efetuadas em um dos lados sem afetar o outro. Por exemplo, a forma como os dados so exibidos (tipo de letra, cor, layout da pgina) podem ser revisados sem que seja necessrio modificar qualquer cdigo Java. Da mesma forma, enquanto a interface com um componente permanece inalterada, a implementao do componente pode ser alterada (por ex., para melhorar o desempenho ou a manutenibilidade) sem nenhum efeito sobre as pginas JSP que utilizam o componente. Se uma pgina JSP contm apenas tags e nenhum cdigo Java, o primeiro requisito para garantir a separao entre apresentao e implementao foi atingido, uma vez que no haver nenhum cdigo de implementao misturado com cdigo de apresentao. O segundo requisito fcil de explicar: no deve haver nenhum cdigo HTML em seus JavaBeans, uma vez que nada impede que um JavaBean possua uma propriedade que inclua strings de HTML. Por exemplo, pode ser tentador criar um JavaBean que tenha a habilidade de gerar uma grande tabela HTML a partir dos resultados de uma query a um banco de dados. Se, por qualquer razo, for necessrio modificar a aparncia da tabela HTML, o JavaBean necessitar ser editado, compilado e testado. Em algumas situaes, no entanto, a gerao de cdigo HTML programaticamente a melhor soluo. Por exemplo, escrever uma aplicao que mostre as 10 ltimas transaes bancrias de um cliente utilizando um Bean que retorne uma transao seria desajeitado. Isto porque JSP no inclui nenhum built-in tag para interagir com propriedades de Beans. Para resolver este dilema, as solues seriam: incluir cdigo Java em sua pgina JSP, ou, escrever um Bean que gere sada HTML. Felizmente JSP prov uma terceira alternativa, especificamente criada para se gerar cdigo HTML programaticamente utilizando cdigo Java. O programador pode implementar um novo tag JSP e empacot-lo em uma biblioteca especfica de uma aplicao. Pginas JSP podero, ento, import-lo. A utilizao de tags customizados no resolve o problema da separao entre apresentao e implementao, mas h duas vantagens na gerao de cdigo HTML____________________________________________________________________________________ Apostila de JSP 7

____________________________________________________________________________________

atravs de tags customizados. Em primeiro lugar, tags customizados so uma forma de se evitar a insero de cdigo Java em uma pgina HTML e, segundo, no lado da programao, a gerao de cdigo HTML isolada dentro do cdigo da tag library. A tag library ter dependncias sobre o seu cdigo JavaBeans, mas no vice-versa. Logo, tags customizados provem uma interface bem definida entre apresentao e implementao, sem contaminar arquivos JSP com cdigo de implementao, ou a propriedade de um Bean com cdigo de apresentao. E o fato de que JSP suporta a utilizao de componentes atravs de JavaBeans, promete habilitar um novo conjunto de ferramentas para a criao de pginas web graficamente, utilizando a abordagem da programao visual. A habilidade de criar sofisticadas pginas JSP sem escrever um nico tag HTML pode ser uma realidade em breve. 1.3 Diviso do Trabalho Um importante efeito colateral deste desacoplamento entre apresentao e implementao atravs de pginas JSP que ele promove uma clara diviso do trabalho no desenvolvimento e manuteno de aplicaes para a web. De fato, raro o indivduo que possui grande habilidade em programao e no projeto artstico. Como resultado a maioria das equipes de desenvolvimento de aplicaes para a web possuem pessoas com habilidades distintas, representando mltiplas especialidades. Projetistas, artistas grficos e codificadores HTML so responsveis pela apresentao. Programadores Java e projetistas de sistemas so responsveis pela implementao. Equipes grandes de corporaes podem incluir ainda editores, consultores de marketing, administradores de banco de dados, administradores de rede e administradores de sistemas.

____________________________________________________________________________________ Apostila de JSP 8

____________________________________________________________________________________

2. FUNDAMENTOS JavaServer Pages (JSP) uma tecnologia baseada na linguagem Java que simplifica o processo de desenvolvimento de sites de contedo dinmico. Com JSP, web designers e desenvolvedores podem rapidamente incorporar elementos dinmicos em suas pginas utilizando cdigo Java embutido e uns poucos markup tags bastante simples. Pense em JSP como um tipo de linguagem de script executada no servidor web, embora, internamente seu funcionamento seja bastante diferente. Como os elementos HTML estticos provem uma estrutura (framework) na qual o contedo dinmico gerado pelo cdigo script ser inserido, ferramentas como JSP, PHP, ASP, ColdFusion e etc, so conhecidas como sistemas template. 2.1 Primeiro Exemplo de Pgina JSP Nesta sesso vamos criar uma pgina JSP que envia para o browser cliente a frase Al Mundo!. Al Mundo!

Para chamar esta pgina JSP: http://sbd:8100/jsp/aluno01/exercicio01/alomundo.jsp Embora o exemplo acima contenha apenas cdigo HTML, no h nada errado nisto. Este arquivo, com a extenso .jsp seria interpretado como uma requisio JSP. O servidor web encaminharia a requisio ao container JSP local (a JSP engine) para processamento. Naturalmente, o container JSP no encontraria nenhum elemento JSP e, consequentemente, apenas devolveria estes comandos HTML ao servidor web que os encaminharia ao browser do usurio. 2.2 Segunda Verso do Exemplo Al Mundo Abaixo vem uma nova verso do exemplo anterior, desta vez no entanto, gerando contedo dinamicamente atravs do uso um par de tags JSP. Al, ! ____________________________________________________________________________________ Apostila de JSP 9

____________________________________________________________________________________

Neste exemplo JSP tenta inicializar a varivel visitante a partir da requisio HTTP. Um valor default designado varivel visitante caso um valor no seja fornecido pela requisio. Uma expresso JSP ento utilizada para inserir o valor desta varivel na sada HTML da pgina. Parmetros de requisies so passados a pginas JSP utilizando o mecanismo normal de passagem de parmetros HTTP. Para requisies do tipo GET valores de parmetros so codificados e adicionados ao URL. Para chamar esta pgina JSP: http://sbd:8100/jsp/aluno01/exercicio02/alomundo.jspou http://sbd:8100/jsp/aluno01/exercicio02/alomundo.jsp?nome=Vinicius+Aguiar

O que torna este documento especial a sua terminao .jsp. Por default o nosso servidor Web, configurado para reconhecer arquivos com a extenso .jsp e traduzilos para Java Servlets. Esta operao totalmente transparente para o cliente que solicita a pgina. E o browser cliente v apenas a resposta do servidor web requisio do usurio. Em outras palavras, quando o servidor web recebe a requisio correspondente a uma pgina JSP, esta requisio encaminhada ao container JSP para processamento. o container JSP quem l e interpreta o cdigo no arquivo .jsp e gera o contedo dinmico, inserindo o resultado no contedo esttico existente na pgina e retornando a pgina completa ao servidor HTTP. Esta a pgina que enviada de volta ao browser. 2.3 Verso do Exemplo Al Mundo com Bean Alm se suportar scripts, JSP possui tags para a interao com Java Beans. A vantagem de se utilizar a abordagem baseada em Java Beans, como vimos no captulo anterior, que esta abordagem promove a reutilizabilidade de cdigo (vrias pginas JSP podem utilizar a classe AloBean sem a necessidade de escrever nenhuma linha de cdigo Java adicional) e a separao entre apresentao e implementao (um arquivo contm apenas HTML e tags tipo HTML, e outro contm apenas Java). Tambm fica evidente que esta ltima abordagem requer um esforo maior para alcanar os mesmos resultados. Antes de examinarmos a pgina JSP que faz uso de um Bean preciso cri-lo. Abaixo vem o cdigo para um Bean denominado AloBean, que possui uma propriedade denominada nome.

____________________________________________________________________________________ Apostila de JSP 10

____________________________________________________________________________________ package jsp.aluno01.exercicio03; public class AloBean implements java.io.Serializable { String nome; public AloBean () { this.nome = "Mundo!"; } public String getNome () { return nome; } public void setNome (String nome) { this.nome = nome; } }

Java Beans, como se pode ver, so implementados como classes Java que aderem a um conjunto de convenes para sua instanciao e para o acesso e determinao de suas propriedades. Para conhecer todos os detalhes sobre estas convenes veja o captulo Desenvolvendo Componentes. Por enquanto observe que a classe AloBean possui um construtor sem argumentos, mas que designa um valor default para a propriedade nome. Esta propriedade acessada atravs do mtodo getNome(), e pode ser modificada atravs do mtodo setNome(). Agora vejamos a utilizao deste Bean na pgina JSP abaixo: Al, !

O tag indica que o Bean de uma classe particular ser utilizado nesta pgina. Aqui a classe AloBean especificada. Alm disso, um identificador, alo, especificado para a instncia deste Bean. Este identificador poder ser utilizado mais tarde, para referenciar o Bean no arquivo JSP. J o tag , neste exemplo, utilizado para modificar a propriedade nome do Bean alo baseado no valor do parmetro nome da requisio. Este tag indica que deve ser pesquisado na requisio HTTP um parmetro denominado nome, e se encontrado, seu valor deve ser copiado da requisio para a propriedade nome do Bean. E o tag , utilizado para acessar o valor de uma propriedade do Bean e inseri-lo na pgina no local do tag original. Neste caso, o tag recupera a propriedade nome do Bean associado ao identificador alo.

____________________________________________________________________________________ Apostila de JSP 11

____________________________________________________________________________________

Neste caso foi preciso criar, no servidor web, a pgina JSP jsp/aluno01/exercicio03/alomundo.jsp sob o diretrio onde so armazenados os arquivos .html e o Bean jsp/aluno01/exercicio03/AloBean sob o diretrio onde so armazenados os arquivos .class. Caso venhamos a executar esta pgina JSP assim: http://sbd:8100/jsp/aluno01/exercicio03/alomundo.jsp a sada ser Al Mundo! pois o valor default da propriedade nome o string Mundo!. Como nenhum parmetro foi fornecido, o tag no pde designar um novo valor para a propriedade nome. Por esta razo foi utilizado o valor default, designado pelo construtor, que foi chamado como resultado do tag . Por outro lado, se executarmos esta pgina JSP assim, http://sbd:8100/jsp/aluno01/exercicio03/alomundo.jsp?nome=Vinicius+Aguiar o tag encontraria um parmetro denominado nome na requisio HTTP e atribuiria o valor deste parmetro propriedade nome do Bean. 2.4 Convenes sobre Tags Tags JSP podem ser classificados em duas categorias bsicas: tags orientados a scripts inspirados no ASP, e um conjunto completo de tags baseados em Extensible Markup Language (XML). 2.4.1 Tags Orientados a Scripts

Estes tags so facilmente reconhecidos pelos seus delimitadores. Comeam com , e um caracter adicional pode aparecer aps

____________________________________________________________________________________ Apostila de JSP 12

____________________________________________________________________________________

2.4.2

Tags Baseados em XML

Tags XML so case-sensitive enquanto tags HTML no so. XML requer que todos os valores de atributos apaream entre aspas simples ou duplas. Valores de atributos HTML s necessitam aparecer entre aspas quando contm espaos em branco. XML tambm faz uma distino entre os tags que contm um corpo e os que no contm: os tags que no contm corpo (tags que contm corpo so aqueles que possuem abertura e fechamento, como ... ) so delimitados por < e />. Por exemplo:

E os tags que possuem um corpo utilizam a mesma sintaxe do HTML. O tag de abertura utiliza < para indicar o incio do tag e > para indicar o seu fim. E o tag de fechamento utiliza para indicar o seu fim. Abaixo vem um exemplo de tag JSP com corpo:

Neste caso o contedo do corpo outro tag JSP. O tag no corpo no possui ele prprio um corpo, logo, segue a outra conveno. 2.5 Como JSP Funciona O primeiro componente de uma implementao de JavaServer Pages baseada em servlets um servlet especial geralmente referenciado como compilador de pgina. O container configurado para chamar este servlet para todas as requisies cujos URLs possuam a extenso .jsp (ou outra qualquer que tenha sido configurada). A tarefa deste servlet encontrar a pgina JSP solicitada, e compil-la em um servlet se necessrio. Este servlet ter a funo de gerar o contedo dinmico da pgina JSP. Logo, sempre que o servidor HTTP recebe uma requisio de uma pgina JSP, esta requisio encaminhada ao container JSP que chama o compilador de pgina para tratar a requisio. Na primeira vez que uma requisio recebida para uma pgina JSP especfica, esta pgina JSP compilada em um servlet. Para compilar a pgina, o compilador de pgina JSP examina a pgina procurando por tags JSP. O contedo desta pgina traduzido no equivalente cdigo Java que, quando executado, ir gerar a sada indicada pelo contedo do arquivo original. Comandos HTML estticos so traduzidos em Java strings e so escritos sem modificao e na mesma seqncia no output stream. Tags JSP so traduzidos em cdigo Java para a gerao de contedo dinmico: tags para acesso a Beans so traduzidos nas correspondentes chamadas a objetos e propriedades, enquanto elementos de scripts so transferidos sem modificao. Uma vez construdo todo o cdigo do servlet, este____________________________________________________________________________________ Apostila de JSP 13

____________________________________________________________________________________

cdigo compilado e o arquivo .class resultante colocado no diretrio apropriado para execuo subsequente. A figura abaixo mostra o processo de criao e execuo de servlets JSP.

A maioria dos sistemas de gerao de contedo dinmico se baseiam em tags especiais, linguagens de scripts interpretadas, ou a combinao de ambos. Na maioria destes sistemas os arquivos que contm estes tags e/ou scripts devem sofrer o parse toda vez que o documento requisitado. Este parse produz um overhead que evitado com JavaServer Pages, uma vez que os arquivos JSP sofrem o parse apenas na primeira vez que so requisitados. JSP mais lento do que outras abordagens na primeira requisio, mas mais rpido nas requisies subsequentes. Existe tambm um mecanismo que faz com que uma pgina JSP possa ser prcompilada pelo container JSP antes de qualquer usurio requisitar por esta pgina.____________________________________________________________________________________ Apostila de JSP 14

____________________________________________________________________________________

Alm disso a JVM que executada dentro do container JSP procura manter residente na memria do servidor web o cdigo associado a uma classe servlet JSP se as requisies encaminhadas a esta classe ocorrem regularmente. Sada Buferizada Um servidor HTTP pode receber vrios tipos de requisies (GET ou POST, por exemplo) que determinam como dados de parmetros so transmitidos para o servidor. Requisies tambm podem ser acompanhadas por informaes de header que so tipicamente utilizadas para identificar o tipo e capacidades do browser, controle de cache e o suporte a cookies. Da mesma forma o protocolo HTTP permite que o servidor envie informaes adicionais de volta para o cliente na forma de headers de resposta. Estes headers so enviados de volta ao cliente juntamente com o contedo solicitado, que referenciado como o corpo da resposta. Headers de resposta so principalmente utilizados para enviar ao browser informao de status sobre a requisio. E assim como headers de requisio, tambm podem ser utilizados para controlar o cache e para enviar cookies. Uma limitao do protocolo HTTP que o servidor no pode comear a enviar um documento para um browser, mudar de idia, e pedir ao browser para no mostr-lo. O servidor web pode abortar a transmisso do documento, mas o que j foi enviado exibido. Por exemplo, se um erro ocorre no meio do processamento de uma pgina, todo o contedo gerado at o momento do erro exibido pelo browser, seguido da mensagem de erro. Para resolver este problema os projetistas de JSP determinaram que toda sada gerada por uma pgina JSP no deve ser automaticamente enviado ao browser a medida que a pgina gerada. Todo o contedo da pgina deve ser temporariamente armazenado em um buffer de sada. A sada armazenada no buffer s deve ser enviada ao browser (como o corpo de uma resposta HTTP) aps o processamento de toda a pgina. Como a sada armazenada em um buffer possvel gerar informao de header em qualquer ponto do processamento de uma pgina JSP. Por exemplo, uma pgina JSP pode incluir cdigo (ou um tag customizado) que condicionalmente envia um cookie, e este cdigo (ou tag) pode aparecer em qualquer lugar da pgina. Assim sendo, o autor de uma pgina JSP possui a garantia de que o corpo da resposta no ser enviado at que toda a pgina seja processada, logo o header de resposta que envia o cookie necessariamente ser enviado antes do corpo da resposta. A buferizao da sada tambm permite que o processamento de uma resposta seja abortado a qualquer momento, permitindo assim que uma nova resposta seja gerada. Esta deciso pode ser baseada na lgica de programao associada ao processamento____________________________________________________________________________________ Apostila de JSP 15

____________________________________________________________________________________

da pgina JSP, ou pode resultar da deteco de um erro durante o processamento da pgina. importante levar em considerao, no entanto, que o buffer de sada finito. Seu tamanho default de 8K, mas este valor pode ser alterado para cada pgina. Uma vez atingido o limite de 8K (ou o valor especificado) a sada gerada at o momento enviada ao browser cliente e o buffer e esvaziado para posterior utilizao. A partir do momento que seu contedo enviado ao browser novas informaes de header no podem mais ser adicionadas.

____________________________________________________________________________________ Apostila de JSP 16

____________________________________________________________________________________

3. PROGRAMANDO SCRIPTS JSP A abordagem purista recomendada no captulo anterior para o desenvolvimento de aplicaes baseadas em JavaBeans nem sempre a soluo mais prtica. Por exemplo, no desenvolvimento do prottipo de uma aplicao o cronograma de desenvolvimento pode no fornecer tempo suficiente para a construo de todos os componentes necessrios aplicao. Nestes casos a alternativa a utilizao de uma linguagem de script dentro de pginas JSP. 3.1 Linguagens de Script A linguagem de script default para JSP Java. Se uma linguagem de script capaz de interagir com objetos Java, ou pode ser estendida para interagir com objetos Java, ento esta linguagem uma boa candidata para integrao com um container JSP. H no mercado, por exemplo, containers JSP que utilizam Java Script como linguagem de script. 3.2 Tags JSPJSP prov quatro categorias principais de markup tags: Directives um conjunto de tags que especificam caractersticas especficas para

uma pgina, isto , contm informaes de como um documento que contm estas diretivas deve ser processado.Scripting Elements so utilizados para embutir instrues de programao,

escritas na linguagem de script designada para a pgina.Comments so utilizados para adicionar strings de documentao a pginas JSP. Actions suportam vrios comportamentos diferentes. Assim como elementos de

script, actions so processados para cada requisio recebida pela pgina. Actions podem transferir o controle entre pginas, especificar Applets e interagir com componentes server-side JavaBeans. 3.3 Diretivas JSP Uma diretiva pode, por exemplo, especificar qual a linguagem de script utilizada em uma determinada pgina, incluir o contedo de outra pgina, ou indicar que a pgina utiliza uma determinada biblioteca de tags customizados (custom tag library).

____________________________________________________________________________________ Apostila de JSP 17

____________________________________________________________________________________

Diretivas no produzem diretamente nenhuma sada que seja visvel para os usurios finais quando a pgina requisitada. Elas determinam a forma como um container JSP ir processar a pgina. 3.3.1 Diretiva de Pgina

A sintaxe bsica a seguinte:

O espao em branco aps opcional mas recomendvel para melhorar a leitura. Como todos os tags JSP, a diretiva de pgina suporta a sintaxe baseada em XML, como vem abaixo:

Nos exemplos abaixo ser utilizada a primeira sintaxe por ser mais simples e mais utilizada na prtica. A figura abaixo relaciona os 11 atributos que podem ser utilizados nesta diretiva.

possvel especificar vrias diretivas de pgina em uma nica pgina. Com a exceo do atributo import, no entanto, nenhum atributo de pgina individual pode aparecer em mais de uma diretiva de pgina.____________________________________________________________________________________ Apostila de JSP 18

____________________________________________________________________________________

Por exemplo, as diretivas abaixo so vlidas:

Esta uma diretiva de pgina invlida, pois session aparece duas vezes:

E estas so diretivas invlidas, pois o atributo info est repetido:

O Atributo Info Permite a incluso de comentrios que podero ser vistos por outras ferramentas, programaticamente. O Atributo Language Especifica a linguagem de script a ser utilizada na pgina. O default Java.

O Atributo ContentType Este atributo utilizado para indicar o tipo MIME da resposta sendo gerada pela pgina JSP. Os tipos MIME mais comuns so text/html, text/xml, e text/plain., indicando respostas em HTML, XML ou texto puro. O tipo MIME default text/html.

O Atributo Extends Este atributo identifica a superclasse a ser utilizada pelo container JSP quando ele est traduzindo a pgina JSP em um Servlet, e especificado assim:

____________________________________________________________________________________ Apostila de JSP 19

____________________________________________________________________________________

Se, como geralmente ocorre, a pgina JSP est sendo entregue atravs do protocolo HTTP, ento a superclasse especificada deve implementar a interface javax.servlet.jsp.JspPage. Na prtica este atributo raramente utilizado. O Atributo Import Ao contrrio do atributo extends, o uso deste atributo bastante comum.

O Atributo Session O atributo session indica se a pgina JSP participa ou no do gerenciamento de sesses. Isto , se haver ou no uma sesso associada a esta pgina. O valor default para este atributo true. Caso no haja uma sesso associada a uma pgina h um leve ganho de desempenho quando especificamos este fato.

O Atributo Buffer Para desabilitar a buferizao que ocorre por default em relao ao contedo encaminhado aos browsers, faa:

Alternativamente, este atributo pode ser utilizado para se modificar o tamanho default do buffer em kilobytes, assim:

Geralmente os containers JSP, com o objetivo de melhorar o desempenho, criam um pool de buffers de sada em vez de criar um buffer de sada para cada requisio de pgina JSP. Em particular, a sada buferizada permite que se faa uso do atributo errorPage para transferir o controle para uma pgina de erro amigvel quando ocorrem excees ao longo da execuo de uma pgina JSP. Tais pginas de erro customizadas so geralmente preferidas em vez de uma mensagem de erro da JVM no meio de uma sada normal. Alm disso, pginas de erro podem ser escritas para notificar o webmaster ou a____________________________________________________________________________________ Apostila de JSP 20

____________________________________________________________________________________

equipe de desenvolvimento quando um erro de run-time ocorre. Veja o captulo Executando Tarefas JSP Comuns para maiores informaes sobre tratamento de erros. Lembre-se de estipular um tamanho para o buffer de sada caso o valor default de 8k no seja suficiente. O Atributo AutoFlush Este atributo controla o comportamento do container JSP quando o buffer de sada de uma pgina enche. Se este atributo for designado para true (o default), o buffer de sada ser automaticamente enviado ao servidor HTTP, que o responsvel por enviar este contedo ao browser cliente.

Por outro lado, se este atributo for designado para false, o container JSP no enviar o buffer automaticamente para o servidor HTTP quando ele encher. Em vez disso, o container JSP gerar uma exceo, que ter o efeito de interromper o processamento da pgina JSP e exibir uma pgina de erro no browser que originou a requisio da pgina. Atravs do uso deste atributo pode-se descobrir o tamanho da resposta gerada por uma pgina JSP. O Atributo IsThreadSafe Este atributo utilizado para indicar se sua pgina JSP, uma vez compilada em um servlet, ser capaz de responder a vrias requisies simultneas. Caso contrrio, este atributo deve ser designado para false, assim:

Quando este atributo designado para false, o container JSP despachar as requisies para a pgina seqencialmente, na ordem em que foram recebidas, esperando pelo trmino do processamento da requisio corrente antes de iniciar a prxima. Quando este atributo designado para true (o default), uma nova thread criada para tratar cada requisio para a pgina. Assim, vrias requisies para uma mesma pgina podero ser tratadas simultaneamente. Se este atributo pode ou no ser designado para true, no entanto, geralmente depende dos recursos que so utilizados. Por exemplo, se sua pgina JSP cria e armazena uma conexo de banco de dados, esta conexo dever ser utilizada apenas por um usurio final de cada vez caso esta pgina trate transaes no atmicas, exceto se controles especiais forem efetuados na utilizao da conexo (como a utilizao de blocos synchronized). Se, por outro lado, uma pgina JSP acessa um pool de conexes de____________________________________________________________________________________ Apostila de JSP 21

____________________________________________________________________________________

banco de dados e espera por uma conexo livre antes de comear seu processamento, ento o atributo isThreadSafe pode provavelmente ser designado para true. Logo, preciso examinar cuidadosamente todas as variveis estticas e todos os objetos utilizados por pginas JSP cujos escopos sejam session ou application (veja o prximo captulo). Finalmente, importante saber que se uma pgina JSP designa o atributo isThreadSafe para false, possvel determinar que uma implementao instancie vrias instncias do servlet correspondente a fim de prover um desempenho melhor. Desta forma as instncias individuais manipulam uma requisio de cada vez. No entanto, atravs da criao de um pool de instncias, o container JSP poder ainda tratar um limitado nmero de requisies simultneas. O Atributo ErrorPage Este atributo utilizado para especificar uma pgina alternativa que dever ser exibida caso um erro (no capturado) ocorra enquanto o container JSP processa uma pgina. Esta pgina alternativa especificada atravs de um URL local, conforme vem abaixo:

Isto , o URL do atributo errorPage deve especificar uma pgina JSP no mesmo servidor da pgina que gerou o erro. Um URL relativo tambm pode ser especificado. Neste caso o URL ser relativo pgina que provocou o erro. No contexto do atributo errorPage, URLs absolutos comeam por /, enquanto URLs relativos no. Se a sada de uma pgina JSP no est sendo armazenada em um buffer e alguma sada j tiver sido gerada antes da ocorrncia do erro, no ser possvel efetuar um forward para a pgina de exibio de erro. Caso a sada esteja sendo armazenada em um buffer e o atributo autoFlush esteja designado para true, no momento em que o buffer encher e a sada for enviada pela primeira vez, tambm no ser mais possvel efetuar o forward para a pgina de exibio de erro. O Atributo IsErrorPage O atributo isErrorPage utilizado para marcar uma pgina JSP que serve como pgina de exibio de erro para uma ou mais pginas JSP.

____________________________________________________________________________________ Apostila de JSP 22

____________________________________________________________________________________

Quando este atributo designado para true, ele indica que a pgina corrente ser capaz de acessar o objeto implcito exception que ser ligado ao objeto Java exception. O valor default deste atributo false. 3.3.2 Diretiva Include

Esta diretiva permite que se inclua o contedo de um arquivo em outro. O arquivo a ser includo identificado atravs de um URL local.

Como todos os tags JSP, h uma sintaxe XML alternativa para esta diretiva;

O valor do atributo file da diretiva include pode especificar um URL absoluto ou relativo. O container JSP recompila uma pgina JSP quando detecta que ela foi modificada. Isto no se aplica a um arquivo includo a uma pgina. Isto , o container JSP no controla dependncias entre arquivos. 3.3.3 Diretiva Tag Library

Esta diretiva utilizada para notificar o container JSP que a pgina utiliza uma ou mais bibliotecas de tags customizados (custom tag libraries). Uma biblioteca de tags uma coleo de tags customizados que podem ser utilizados para estender a funcionalidade do JSP. Esta funcionalidade estendida se aplica pgina que utiliza o tag customizado. Utilizando esta diretiva podemos indicar, por exemplo, que uma pgina JSP ir utilizar uma determinada biblioteca de tags. A partir deste momento todos os tags existentes nesta biblioteca se tornam disponveis para uso na pgina.

ou a variao XML

Em ambas as sintaxes, o valor do atributo uri indica o local do arquivo Tag Library Descriptor (TLD) para a biblioteca, e o atributo prefix especifica o identificador do namespace XML que ser pr-adicionado a todas as ocorrncias dos tags da biblioteca na____________________________________________________________________________________ Apostila de JSP 23

____________________________________________________________________________________

pgina. Por exemplo, a seguinte diretiva carrega uma biblioteca de tags cujo TLD acessvel atravs do URI local /EncomTags:

Dentro da pgina na qual esta diretiva aparece, os tags definidos por esta biblioteca so acessados utilizando o prefixo mcp. Um tag desta biblioteca denominado endProgram, ento, seria referenciado dentro da pgina como . Note que todos os tags customizados seguem a sintaxe XML. Como o prefixo especificado externamente biblioteca (em cada pgina), vrias bibliotecas podem ser carregadas em uma nica pgina sem o risco de ocorrerem conflitos entre os nomes dos tags. Se duas bibliotecas definem tags com o mesmo nome, uma pgina JSP ainda assim capaz de carrega e utilizar ambas as bibliotecas j que os tags podem ser identificados pelo prefixo especificado para a biblioteca. Por razes de segurana, a especificao JSP determina que containers JSP podem ler apenas TDLs armazenadas no servidor local. 3.4 Elementos de Script Elementos de script permitem que os desenvolvedores insiram cdigo diretamente em uma pgina JSP, inclusive cdigo capaz de gerar sada que enviada de volta ao usurio.JSP prov trs tipos de elementos de script: declaraes, expresses e scriptlets. E

nenhum dos tags para elementos de script suportam atributos. 3.4.1 Declaraes

Declaraes so utilizadas para definir variveis e mtodos especficos de uma pgina JSP. Declaraes de Variveis Variveis definidas como declaraes se tornam variveis de instncia da classe servlet na qual a pgina JSP ser traduzida e compilada. Exemplo:

Esta declarao ter o efeito de criar 3 variveis de instncia no servlet criado para a pgina JSP. Estas variveis podem ser referenciadas por quaisquer elementos de script na pgina, incluindo aqueles que aparecem antes da declarao destas variveis.____________________________________________________________________________________ Apostila de JSP 24

____________________________________________________________________________________

Quando variveis de instncia JSP so declaradas, importante ter em mente que vrias threads podero acessar simultaneamente estas variveis. Se um elemento de script em uma pgina modifica o valor de uma varivel de instncia, todas as referncias subsequentes a esta varivel de instncia utilizaro o novo valor, inclusive referncias em outras threads. Se voc deseja criar uma varivel cujo valor local ao processamento de uma nica requisio, isto deve ser feito em um scriptlet. Variveis declaradas so associadas pgina (atravs da classe servlet), e no a requisies individuais. Para definir uma varivel de classe, isto , uma varivel esttica (variveis cujos valores so compartilhados entre todas as instncias de uma classe), faa:

Na prtica, como o container JSP geralmente cria apenas uma instncia da classe servlet representando uma pgina JSP em particular, h pouca diferena entre se declarar uma varivel de classe e uma varivel de instncia. A principal exceo a esta regra quando a pgina JSP designa o valor false ao atributo isThreadSafe da diretiva de pgina, indicando que a pgina no a prova de threads. Neste caso o container pode criar vrias instncias da classe servlet da pgina, para poder tratar requisies simultneas (uma requisio por instncia). Para compartilhar uma varivel entre estas vrias instncias esta varivel necessita ser declarada como esttica. Declaraes de Mtodos Mtodos definidos atravs de declaraes se tornam mtodos da classe servlet na qual a pgina JSP ser compilada. Por exemplo, a seguinte declarao define um mtodo para calcular fatoriais:

Este mtodo pode ser referenciado por quaisquer elementos de script na pgina, incluindo aqueles que aparecem antes da declarao do mtodo. Vrios mtodos e variveis podem aparecer dentro de um nico tag de declarao, conforme vem abaixo:

Assim como existem variveis de classe, h tambm os mtodos de classe. So mtodos estticos que no podem referenciar variveis de instncias, mas apenas variveis de classe. Na prtica, como geralmente no possvel obter o nome da classe servlet correspondente a uma pgina JSP particular, mtodos de classe no so utilizados em pginas JSP. Tratando Eventos do Ciclo de Vida Um evento de inicializao de uma pgina JSP ocorre na primeira vez que um container recebe uma requisio para esta pgina. E um evento de destruio da pgina ocorre quando o container JSP est sofrendo um shutdown ou quando a pgina retirada da memria por no ter sido utilizada recentemente. O evento de inicializao tratado atravs da declarao de um mtodo especial que ser automaticamente chamado pelo container JSP quando o evento correspondente ocorrer. O evento de inicializao tratado pelo mtodo denominado jspInit() e o de destruio tratado pelo mtodo denominado jspDestroy(). Exemplos: void jspInit() Cdigo de inicializao aparece aqui! void jspDestroy() Cdigo de destruio aparece aqui!

Um exemplo de utilizao do mtodo jspInit() seria a criao de um pool de conexes de banco de dados antes que uma requisio possa ser atendida. ____________________________________________________________________________________ Apostila de JSP 26

____________________________________________________________________________________

Observao: o mtodo construtor da classe PoolDeConexoes reutiliza um pool de conexes existente ou, se necessrio, cria um. Da mesma forma, se o mtodo jspDestroy for definido, ele ser chamado aps todas as requisies pendentes terem sido processadas, mas logo antes do container JSP retirar de servio o servlet correspondente.

Se esta pgina a nica pgina a utilizar o pool, o pool pode encerrar as conexes pois elas no so mais necessrias. 3.4.2 Expresses

Declaraes so utilizadas para adicionar variveis e mtodos a pginas JSP, mas no so capazes de contribuir diretamente para a gerao de contedo dinmico de uma pgina. Para este fim deve-se utilizar o elemento JSP denominado expression.

ou a variao XML: expresso

O efeito deste elemento avaliar a expresso especificada e substituir o valor resultante na sada da pgina, no exato local do elemento. Por exemplo:

Esta expresso resultaria na sua substituio pelo nmero 479001600. Considerando que elementos de script produzem sada apenas atravs de expresses, e no atravs de comandos, como condicionar uma sada de uma pgina JSP? Atravs do operador abaixo:

____________________________________________________________________________________ Apostila de JSP 27

____________________________________________________________________________________

3.4.3

Scriptlets

Declaraes e expresses so intencionalmente limitadas no tipo de cdigo script que elas suportam. Scriptlets podem conter quaisquer comandos de linguagem, e no adicionam automaticamente contedo sada de uma pgina JSP. A seguir vem um exemplo de scriptlet:

Este scriptlet instancia um objeto que utilizado para instanciar dois outros objetos. Mtodos so ento chamados sobre estes objetos para efetuar alguns clculos. Note que este scriptlet ser executado para cada requisio recebida por uma pgina. No exemplo acima duas novas instncias da classe Recognizer sero criadas toda vez que a pgina JSP que contm este scriptlet requisitada. importante saber ainda que, quaisquer variveis introduzidas em um scriptlet ficam disponveis para uso em scriptlets subsequentes e expresses na mesma pgina (sujeitas a regras de escopo de variveis). O scriptlet acima, por exemplo, poderia ser seguido da expresso:

Esta expresso inseriria o resultado do mtodo statusReport() na sada da pgina. Para se controlar o escopo de uma varivel introduzida em um scriptlet, pode-se utilizar blocos de cdigo. Um bloco pode englobar mais de um scriptlet, conforme vem no exemplo abaixo: Alerta de Intruso Entrada no autorizada, disparar recognizers... Status

First Recognizer:

second Recognizer:

Nvel de Alerta: ____________________________________________________________________________________ Apostila de JSP 28

____________________________________________________________________________________

Neste exemplo, o primeiro scriptlet introduz um novo bloco de programa antes de criar duas instancias de Recognizer. O segundo scriptlet, no final da pgina, fecha este bloco. Dentro deste bloco, as instncias r1 e r2 podem ser referenciadas livremente. Aps o bloco ser fechado, no podem mais ser referenciadas, pois seu escopo delimitado pelo bloco no qual foram declaradas. J a varivel grid, que foi definida fora do bloco, no sofre esta limitao. A razo para isto funcionar tem a ver como o contedo de uma pgina JSP traduzido no cdigo fonte de um servlet. Contedo esttico, tal como cdigo HTML, traduzido em comandos Java que imprimem o texto como sada do servlet. Da mesma forma, expresses so traduzidas em comandos Java que avaliam a expresso, convertem o resultado em um string, e imprimem este string como sada do servlet. Scriptlets, no entanto, no passam por qualquer traduo, e so simplesmente inseridos no cdigo fonte do servlet. Comandos Java correspondentes a contedo esttico de pginas JSP, expresses e scriptlets so utilizados para criar o mtodo _jspService() do servlet correspondente. Este mtodo responsvel por gerar a sada da pgina JSP. Diretivas e declaraes tambm so traduzidas em cdigo servlet mas no contribuem com o mtodo _jspService() e no so afetados pelo escopo determinado por scriptlets. Por outro lado, os tags JSP de acesso a Beans, discutidos no captulo 5, so traduzidos em comandos Java para o mtodo _jspService() e esto sujeitos s restries de escopo introduzidas por scriptlets. 3.5 Fluxo de Controle A possibilidade dos scriptlets introduzirem blocos de comandos sem fech-los pode ser utilizada para afetar o fluxo do controle atravs de vrios elementos, estticos ou dinmicos, que controlam a sada gerada pela pgina. 3.5.1 Condies

O comando if pode ser utilizado para gerar contedo condicional em uma pgina JSP. Exemplo:

{

%>

Argumentos maiores do que 20 causam um erro de overflow. ! =

____________________________________________________________________________________ Apostila de JSP 29

____________________________________________________________________________________

3.5.2

Iterao

Java possui trs comandos diferentes para controlar a execuo de loops: for loop, while loop e o comando do/while. Todos podem ser utilizados atravs de scriptlets para adicionar iterativamente contedo a uma pgina JSP, e so particularmente teis na exibio de dados tabulares. A seguir vem um exemplo de um fragmento de cdigo que utiliza o mtodo fatorial definido anteriormente para construir uma tabela de fatoriais de um nmero. xx! xx! Fatorial ! = Fatorial fora dos limites. ____________________________________________________________________________________ Apostila de JSP 31

____________________________________________________________________________________

A razo da exceo IllegalArgumentException ser gerada porque valores inteiros do tipo long (em Java) esto limitados a 64 bits. E vinte o maior nmero cujo fatorial pode ser armazenado em um long. Note que toda a sada gerada at o momento da chamada ao mtodo fatorial aparece na pgina. Isto ocorre porque o cdigo do servlet que produz esta sada no gera nenhuma exceo, e portanto executado quando a pgina processada. Assim que a chamada a fatorial() ocorre, no entanto, a exceo gerada e o controle transferido ao bloco catch, que imprime a mensagem de erro. Alm das bibliotecas de tags customizados (custom tag libraries), scriptlets que fazem uso de blocos so a nica forma de se implementar em uma pgina JSP contedo condicional, iterativo, ou de se utilizar tratamento de exceo customizado. Por outro lado, o uso excessivo de scriptlets pode acarretar problemas de manuteno. 3.6 Comentrios H comentrios que so transmitidos para o browser como parte da resposta JSP e aqueles que so visveis apenas no arquivo JSP original. 3.6.1 Comentrios de Contedo

Para escrever um comentrio que ser includo na sada de uma pgina JSP, utilize a seguinte sintaxe:

Estes comentrios so enviados para o usurio como parte da resposta. Como so comentrios, no produzem nenhuma sada visvel, mas podem ser vistos pelo usurio final atravs dos itens de menu Exibir / Cdigo fonte do browser. 3.6.2 Comentrios JSP

Comentrios JSP so independentes do tipo de contedo sendo produzido pela pgina. Tambm so independestes da linguagem de script que est sendo utilizada. Sintaxe:

O corpo deste comentrio ignorado pelo container JSP. Quando a pgina compilada em um servlet, qualquer coisa que aparece entre estes delimitadores ignorada.

____________________________________________________________________________________ Apostila de JSP 32

____________________________________________________________________________________

3.6.3

Comentrios da Linguagem de Script

E finalmente, comentrios tambm podem ser introduzidos em uma pgina JSP dentro de scriptlets utilizando a sintaxe de comentrio nativa da linguagem de script que estiver sendo utilizada. Em Java a sintaxe utilizada para a produo de comentrios a seguinte:// comentrio em uma nica linha /* Comentrio abrangendo mais de uma linha */

Exemplo de utilizao de comentrios em scriptlets:

Evite o estilo de comentrio abaixo. Dependendo da implementao do container JSP poder no funcionar:O fatorial de 3 , certo?

Nestes casos utilize os delimitadores /* ... */

____________________________________________________________________________________ Apostila de JSP 33

____________________________________________________________________________________

4. OBJETOS IMPLCITOS E AES Trs tipos de tags foram introduzidos no captulo 3: diretivas, elementos de script e comentrios. O ltimo tipo, Aes (Actions), sero introduzidos neste captulo. Aes encapsulam comportamento comum, em simples tags que podem ser utilizados em qualquer pgina JSP. Aes so a base para a existncia dos tags customizados, mas uma srie de aes (actions) fazem parte da especificao bsica de JSP. Estas aes padro so suportadas por todos os containers JSP. Antes de estudarmos as aes padro, vamos primeiramente examinar um conjunto de objetos Java que o container JSP torna disponvel para os desenvolvedores de pginas JSP. 4.1 Objetos Implcitos O container JSP disponibiliza, para os desenvolvedores, uma srie de objetos implcitos que podem ser utilizados no desenvolvimento de pginas JSP. Estes objetos so denominados implcitos pois sua disponibilidade em uma pgina JSP automtica. Estes objetos podem ser acessados pelos desenvolvedores atravs de elementos de script. Mais especificamente, podem ser utilizados nomes especficos de variveis que permitem o acesso a estes objetos. A tabela abaixo relaciona todos os objetos implcitos que podem ser utilizados em uma pgina JSP.

____________________________________________________________________________________ Apostila de JSP 34

____________________________________________________________________________________

Os nove objetos implcitos fornecidos por JSP pertencem a uma das seguintes categorias:

Objetos relacionados ao servlet decorrente da pgina JSP; Objetos utilizados na entrada e sada de dados; Objetos que fornecem informaes sobre o contexto no qual cada pgina JSP est sendo processada. Objetos resultantes de erros.

Alm desta categorizao funcional, os objetos request, session, application e pageContext so capazes de armazenar e recuperar valores arbitrrios de atributos. Os mtodos padro para o gerenciamento de atributos fornecidos pelas classes e interfaces destes quatro objetos so relacionados na tabela abaixo:

4.1.1

Objetos Relacionados a Servlets

O Objeto Page O objeto page representa a prpria pgina JSP ou, mais especificamente, uma instncia da classe servlet na qual a pgina ser traduzida. Logo, o objeto page pode ser utilizado para se chamar qualquer dos mtodos definidos para aquela classe servlet. O atributo extends da diretiva de pgina pode ser utilizado para especificar a classe do servlet explicitamente, caso contrrio uma classe especfica de implementao ser utilizada pelo container JSP na construo do servlet. Em ambos os casos, a classe servlet sempre implementa a interface javax.servlet.jsp.JspPage. Nos casos especficos de aplicaes JSP para a web, construdas com HTTP, a classe servlet deve implementar a interface javax.servlet.jsp.HttpJspPage. Na prtica, o objeto page raramente utilizado quando a linguagem de script Java, pois o objeto page representado pela varivel this. Abaixo vem um fragmento de cdigo que exemplifica a utilizao deste objeto implcito: ____________________________________________________________________________________ Apostila de JSP 35

____________________________________________________________________________________

Page info: Esta expresso ir inserir, na sada gerada pela pgina, o valor do string de documentao desta pgina. Como a classe servlet varia de uma pgina para outra, o tipo padro do objeto page object. Logo, para se poder acessar mtodos definidos na interface javax.servlet.jsp.HttpJspPage o objeto page deve primeiramente sofrer um cast. O Objeto Config O objeto config armazena dados de configurao do servlet na forma de parmetros de inicializao no qual a pgina JSP compilada. Como pginas JSP raramente interagem com parmetros de inicializao, este objeto implcito raramente utilizado na prtica. Este objeto uma instncia da interface javax.servlet.ServletConfig. O cdigo abaixo mostra um exemplo de utilizao do objeto implcito config.

Neste caso, em vez de armazenar o nome do usurio e a password diretamente no cdigo da pgina JSP, estas informaes foram fornecidas atravs de parmetros de inicializao e so acessadas atravs do objeto config.

____________________________________________________________________________________ Apostila de JSP 36

____________________________________________________________________________________

4.1.2

Entrada e Sada

O objeto request representa os dados enviados a uma pgina JSP, e o objeto response representa o resultado enviado ao usurio. O objeto implcito out representa o stream de sada associado ao objeto response, no qual o contedo da pgina escrito. O Objeto Request O objeto request representa a requisio que disparou o processamento da pgina corrente. Para requisies HTTP, este objeto prov acesso a todas as informaes associadas requisio, como sua fonte, o URL requisitado, e quaisquer headers, cookies ou parmetros associados requisio. O objeto request deve implementar a interface javax.servlet.ServletRequest. Quando o protocolo utilizado HTTP, o request objeto deve implementar uma subclasse desta interface, javax.servlet.http.HttpServletRequest. O objeto request um dos quatro objetos implcitos JSP que suportam atributos, atravs dos mtodos apresentados na tabela abaixo:

A interface HttpServletRequest tambm inclui mtodos para a recuperao de parmetros de requisio e cabealhos HTTP. Veja tabelas abaixo:

____________________________________________________________________________________ Apostila de JSP 37

____________________________________________________________________________________

Outros mtodos freqentemente utilizados desta interface encontram-se listados na tabela abaixo:

Entre os usos mais comuns do objeto request est a procura de valores de parmetros e cookies. Abaixo vem um fragmento de cdigo que ilustra o uso do objeto request para acessar um valor de parmetro: Resultado: ! = String ivlido. Informe um nmero.

O valor do parmetro num recuperado do objeto request. Note que todos os valores de parmetros so armazenados como strings, logo preciso efetuar uma converso antes de se poder utilizar este valor como um nmero. O Objeto Response O objeto response representa a resposta que ser enviada de volta ao usurio como resultado do processamento de uma pgina JSP. Este objeto implementa a interface javax.servlet.ServletResponse. Como ele representa uma resposta HTTP, ele tambm implementa uma subclasse desta interface, javax.servlet.http.HttpServletResponse. Os mtodos principais desta ltima interface encontram-se relacionados nas tabelas abaixo:

____________________________________________________________________________________ Apostila de JSP 38

____________________________________________________________________________________

Abaixo vem um exemplo de um scriptlet que designa, atravs do objeto response, vrios headers que impedem que o browser faa o cache desta pgina JSP.

____________________________________________________________________________________ Apostila de JSP 39

____________________________________________________________________________________

O scriptlet primeiramente informa que a data de expirao da pgina uma data no passado. Isto indica que ao browser que o contedo da pgina j expirou, logo seu contedo no deveria sofrer cache. O mtodo setDateHeader deve receber como data de expirao da pgina um objeto do tipo java.util.Date. E o zero informado representa a meia noite de 31 de dezembro de 1969. A verso 1.0 do protocolo HTTP 1.0 utiliza o header Pragma com valor no-cache para indicar que a pgina no deve sofrer cache. J a verso 1.1 do protocolo HTTP substituiu o header Pragma pelo header Cache-Control (mais especfico para controle de cache), mas recomenda a incluso do header Pragma por questes de compatibilidade com o passado. Logo, se a requisio indicar que o browser (ou servidor proxy) suporta HTTP 1.1, ambos os headers so enviados. O Objeto Out Este objeto implcito representa o stream de sada para a pgina. O contedo deste output stream enviado ao browser como o corpo (body) da resposta. Utilizando este objeto implcito, sada pode ser gerada de dentro do corpo de um scriptlet, sem a necessidade de se fechar temporariamente o scriptlet para se inserir contedo esttico ou expresses JSP. Gerando os nmeros de 1 a 10.

____________________________________________________________________________________ Apostila de JSP 40

____________________________________________________________________________________

A tabela abaixo apresenta uma srie de mtodos que podem ser utilizados para controlar o buffer de sada, e gerenciar o seu relacionamento com o stream de sada que envia contedo de volta ao browser.

Segue abaixo um fragmento de cdigo que utiliza o objeto out para exibir o status do buffer: Status do buffer: / = %

Esta uma forma de se descobrir o tamanho do buffer necessrio para se gerar uma pgina. Os mtodos fornecidos para limpar o contedo do buffer so bastante teis. Em algumas situaes, quando um erro detectado necessrio escrever novamente a pgina que deve ser encaminhada ao usurio. Veja o exemplo abaixo: Exemplo para calcular o fatorial de um nmero. 20)) throw new IllegalArgumentException ("Fora dos Limites."); else if (x == 0) return 1; else return x * fatorial (x-1); } %> ____________________________________________________________________________________ Apostila de JSP 41

____________________________________________________________________________________ Resultado: ! = // No preciso chamar out.clearBuffer() aqui pois nenhum // contedo foi gerado. String ivlido. Informe um nmero. Fatorial fora dos limites.

Lembre-se, no entanto, que uma vez enviado algum contedo ao usurio no mais possvel modificar o header de resposta j encaminhado. 4.1.3 Objetos Contextuais

O Objeto Session Este objeto implcito JSP representa uma sesso do usurio corrente. Uma sesso de um usurio corresponde a uma srie de interaes do usurio com o servidor web. No entanto, se um certo intervalo de tempo decorre sem que novas requisies do usurio sejam encaminhadas ao servidor, a sesso expira. O objeto session armazena informaes sobre a sesso. Dados especficos da aplicao so adicionados ao objeto session atravs de atributos, utilizando-se os mtodos da tabela abaixo:

____________________________________________________________________________________ Apostila de JSP 42

____________________________________________________________________________________

E informaes sobre a sesso podem ser obtidas atravs dos mtodos constantes da tabela abaixo:

Um dos usos mais importantes do objeto session o armazenamento e a recuperao de valores de atributos, com o objetivo de transmitir informaes especficas do usurio entre pginas. A seguir vem um scriptlet que armazena dados em um objeto session na forma de um objeto hipottico denominado dadosUsuario.

Aps este scriptlet ter sido utilizado para armazenar dados atravs do mtodo setAtribute(), um outro elemento de script, na mesma ou em outra pgina JSP, posteriormente visitada pelo usurio poder acessar os mesmos dados da sesso utilizando o mtodo getAttribute(), conforme vem abaixo:

Observe que quando este scriptlet recupera o dado armazenado no objeto sesso necessrio efetuar a operao de cast, pois o tipo utilizado para valores de atributos java.lang.Object, que o tipo retornado pelo mtodo getAttribute().JSP prov um mecanismo

que permite que objetos sejam notificados quando so adicionados ou removidos de uma sesso do usurio. Em particular, se um objeto armazenado em uma sesso e sua classe implementa a interface javax.servlet.http.HttpSessionBindingListener, ento certos mtodos____________________________________________________________________________________ Apostila de JSP 43

____________________________________________________________________________________

definidos na interface sero chamados sempre que ocorrerem eventos relacionados com a sesso. E finalmente deve ser mencionado que, diferentemente da maioria dos outros objetos implcitos JSP que podem ser acessados sempre que necessrio por qualquer pgina JSP, o uso do objeto session restrito s pginas que efetuam o gerenciamento de sesso. E isto indicado atravs do atributo session da diretiva de pgina. O default, no entanto, que todas as pginas participam do gerenciamento de sesso. O Objeto Application Este objeto implcito representa a aplicao qual a pgina JSP pertence. Ele uma instncia da interface javax.servlet.ServletContext. Pginas JSP so agrupadas em aplicaes de acordo com seus URLs. Containers JSP tratam o primeiro nome de diretrio em um URL como uma aplicao. Por exemplo: http://server/games/index.jsp, http://server/games/matrixblaster.jsp, e http://server/games/space/paranoids.jsp so considerados parte da mesma aplicao denominada games. Alternativamente, o controle completo sobre o agrupamento de uma aplicao pode ser obtido atravs do uso de arquivos do tipo Web Application Descriptor. Os mtodos da interface javax.servlet.ServletContext podem ser agrupados em cinco categorias principais:

Mtodos para recuperar informaes de verso do container servlet. Observe que se trata da verso do container servlet (JVM que executa os servlets) e no JSP. (Tabela 4.13) Mtodos para acessar recursos server-side representados por nomes de arquivos e URLs. (Tabela 4.14) O objeto application que tambm prov suporte para log. (Tabela 4.15) Mtodos para obter e designar valores de atributos. (Tabela 4.2) Mtodos para prover acesso a parmetros de inicializao associados com a aplicao como um todo (os parmetros de inicializao especficos de uma pgina so acessados atravs do objeto config).

____________________________________________________________________________________ Apostila de JSP 44

____________________________________________________________________________________

Do ponto de vista do desenvolvedor os mtodos mais teis so aqueles utilizados para associar atributos com uma aplicao. Em particular, um grupo de pginas JSP que reside em uma mesma aplicao podem utilizar atributos de aplicao para implementar recursos compartilhados. Considere, por exemplo, uma outra verso do exemplo que implementa um pool de conexes de banco de dados.

____________________________________________________________________________________ Apostila de JSP 45

____________________________________________________________________________________

Neste exemplo, o pool de conexes construdo da mesma forma, e continua a ser armazenado em uma varivel de classe denominada pool. Antes de construir o pool de conexes, no entanto, um atributo de aplicao checado para se verificar se o pool j foi construdo anteriormente. A diferena mais significativa que podemos, desta forma, ter um pool de conexes para cada aplicao. Parmetros de inicializao associados com a aplicao podem ser acessados por qualquer pgina JSP da aplicao. Estes parmetros devem ser especificados atravs do arquivo Web Application Descriptor. A utilizao de parmetros de inicializao de aplicao permite que este cdigo seja reutilizado por vrias pginas de uma mesma aplicao, sem a necessidade de se especificar parmetros de inicializao vrias vezes (parmetros de inicializao associados ao objeto config devem ser especificados em cada pgina). Este reuso pode ser facilitado atravs da diretiva JSP include, e garante que o pool de conexes ser criado uma nica vez, por aplicao, e compartilhado entre as diversas pginas. O Objeto PageContext O objeto pageContext prov, atravs de cdigo de programao, acesso a todos os outros objetos implcitos. Para os objetos implcitos que suportam atributos, o objeto pageContext tambm prov mtodos para acessar estes atributos. O objeto pageContext implementa mtodos para a transferncia do controle da pgina corrente para outra pgina, temporariamente para gerar sada a ser includa na sada da pgina corrente, ou permanentemente para transferir o controle. O objeto pageContext uma instncia da classe javax.servlet.jspPageContext. Os principais mtodos desta classe pertencem a 4 grupos principais: Um conjunto de mtodos para programaticamente acessar todos os outros objetos JSP implcitos. (Tabela 4.16) No momento estes mtodos no so muito teis uma vez que podemos acessar estes objetos (em scriptlets) atravs de variveis de script. No entanto, vamos descobrir sua utilidade quando estudarmos como os tags customizados so implementados. O segundo grupo de mtodos permite que pginas JSP despachem requisies de uma pgina JSP para outra. (Tabela 4.17) Maiores detalhes sobre esta funcionalidade sero estudados quando estudarmos as aes e .

____________________________________________________________________________________ Apostila de JSP 46

____________________________________________________________________________________

E os dois outros grupos de mtodos lidam com atributos. A classe qual pertence o objeto implcito pageContext implementa todos os mtodos de acesso a atributos relacionados na tabela da pg 35. E para permitir que os atributos de outros objetos implcitos JSP tambm possam ser acessados programaticamente, a classe javax.servlet.jspPageContext prov uma srie de mtodos relacionados abaixo:

____________________________________________________________________________________ Apostila de JSP 47

____________________________________________________________________________________

Como j foi mencionado anteriormente, quatro diferentes objetos implcitos so capazes de armazenar atributos: o objeto pageContext, o objeto request, o objeto session e o objeto application. Como resultado desta habilidade, estes objetos so tambm referenciados como scopes, pois a longevidade de um valor de atributo varia em funo de qual dos quatro objetos foi utilizado para armazenar o valor do atributo. Atributos de pgina armazenados no objeto pageContext, duram apenas enquanto durar o processamento de uma nica pgina. Atributos de requisio tambm possuem vida curta, mas podem ser passados entre pginas a medida que o controle transferido. Atributos de sesso persistem enquanto o usurio estiver interagindo com o servidor web. E os atributos de aplicao persistem enquanto o container JSP mantm uma ou mais pginas de uma aplicao carregadas na memria. Apenas uma nica thread dentro de um container JSP pode acessar atributos armazenados nos escopos de pgina ou requisio: a thread que manipula o processamento da requisio associada. A preocupao se uma aplicao thread safe, ento, maior quando atributos de sesso e de aplicaes so utilizados. Como vrias requisies para uma pgina de uma aplicao sero tratadas simultaneamente, objetos armazenados com o escopo de aplicao devem ser robustos com respeito ao acesso por estas mltiplas threads. Da mesma forma, como um usurio pode ter vrias janelas de browser abertas, todas acessando uma mesma pgina JSP ao mesmo tempo, tambm deve ser assumido que objetos armazenados com o escopo de sesso podem ser acessados por mais de uma thread de cada vez. Alm dos mtodos relacionados na tabela acima cujos parmetros incluem uma especificao de escopo, a classe javax.servlet.jsp.PageContext prov constantes estticas que representam estes quatro escopos. Session Atribute:

Estas constantes esto relacionadas na tabela abaixo:

____________________________________________________________________________________ Apostila de JSP 48

____________________________________________________________________________________

Os ltimos dois mtodos relacionados na ltima tabela da pg 47 permitem que desenvolvedores procurem em todos os escopos definidos, por um atributo com determinado nome. Em ambos os casos, o objeto pageContext ir procurar o atributo na seguinte ordem: pgina, requisio, sesso e aplicao. 4.1.4 Tratamento de Erros

Esta ltima categoria de objetos implcitos possui apenas o objeto exception. O Objeto Exception Assim como o objeto session o objeto exception no se encontra automaticamente disponvel em toda pgina JSP. Este objeto pode ser acessado apenas nas pginas que foram designadas como pginas de erro utilizando o atributo isErrorPage da diretiva de pgina. Nestas pginas que so pginas para tratamento de erros, o objeto exception ser uma instncia da classe java.lang.Throwable correspondendo a um erro no capturado que causou a transferncia do controle para a pgina de erro. Os mtodos mais teis da classe java.lang.Throwable encontram-se na tabela abaixo:

Abaixo vem um fragmento de cdigo que demonstra o uso do objeto exception: Aviso! O seguinte erro foi detectado:

4.2