Oracle Certified Professional, Java EE 5 Web Component Developer. Resumo do livro Heard First - Servlets e JSP (5º edição) Erick Ferreira Macedo

Transcrição

1 Oracle Certified Professional, Java EE 5 Web Component Developer Resumo do livro Heard First - Servlets e JSP (5º edição) Erick Ferreira Macedo

2 Capítulo 1 - Introdução a Arquitetura. HTTP (HyperText Transfer Protocol) é o protocolo que os cliente e os Servidores usam para se comunicarem.o HTTP roda no topo do TCP/IP com caracteristica especificas para Web HTML - Informa o Browser como exibir o conteúdo <img> - Quando o browser encontra uma tag de imagem, ele gera outra solicitação http para ir buscar o recurso especificado. Métodos HTTP GET : seu objetivo é conseguir alguma coisa no servidor.a "?" separa o caminho dos parâmetros. Os parâmetros são separados usando "&" - O total de caracteres é realmente limitado (dependendo do servidor) - Os dados ficará expostos. - O GET permite armazenar um pagina de formulário aos favoritos, ao contrário do POST. Solicitação GET : O caminho até o recurso e quaisquer parâmetros adicionados a URL estão incluídos na linha de solicitação.(figura pagina 15.) POST : Com o POST, você pode solicitar algo e, ao mesmo tempo enviar dados. - São designados para solicitações mais complexa, como adicionar dados do formulário em um banco de dados. - Os parâmetros enviados via Post não ficam limitados da maneira que ficariam quando se usa um GET. Solicitação POST : Os parâmetros são enviados no corpo da mensagem "payload".(figura pagina 16.) Resposta HTTP : Uma resposta HTTP é composta de header e corpo. A informação do header informa o browser o protocolo que está sendo usado, se a solicitação obteve êxito, e que tipo de conteúdo está incluso no corpo (MIME Type ou Content-Type). O corpo possui o conteúdo (HTML).(figura pagina 17) URL (Uniform Resource Locators ou Localizadores Uniforme de recusos) : Todo recurso na web tem seu próprio e único endereço nesta padrão. Ele começa com um protocolo, seguido pelo nome do servidor, um número de porta opcional e geralmente um caminho específico acompanhado do nome do recurso. Ex:(Protocolo de Comunicação) + (Nome único do servidor Fisico) + (Porta : Opcional o padrão é 80) + (caminho do recurso) + (nome do conteúdo). Os números das portas TCP é de são reservadas.

3 Capítulo 2 - Arquitetura da aplicação Web CGI - Common Gateway Interface (Interface de passagem comum) - Geralmente é escrito em Perl. Funcionamento : O servidor recebe uma solicitação e "vê" que a solicitação é para um programa assistente (CGI), então o servidor abre e roda o programa em um processo separado. A aplicação do servidor envia junto os parâmetros do request, a aplicação CGI constrói a nova página e devolve o HTML ao servidor, para o servidor o HTML da aplicação CGI é um pagina estática, a aplicação assistente e fechada e o servido envia a resposta ao cliente. Container : O Container oferece os seguintes benefícios para sua aplicação Web : Suporte para comunicação (O Container conhece o protocolo entre o servidor e ele mesmo ), Gerenciamento do ciclo de vida dos servlets, Suporte a multithread, Segurança Declarada e Suporte ao JSP para que você possa se concentrar na lógica de negocio. Funcionamento : Ao receber uma solicitação (HTTP request), o container cria dois objetos HttpServletRequest e HttpServletResponse, encontra o servlet correto baseado na URL do request, cria ou aloca uma thread para o servlet e passa os objetos ao chamar o metodo service do servlet. O método service() é responsavel por chamar o doxxx() depedendo do tipo do request, no caso do doget ele gera um página dinâmica e a insere no objeto response, a thread termina, o container converte o objeto HttpServletResponse em uma resposta HTTP e envia de volta para o cliente e apaga os objetos HttpServletRequest e HttpServletResponse. OBS: É gerado um processo para rodar um programa CGI no servidor para cada solicitação que chega do cliente, diferente dos Servlets que é um único processo a JVM e é criados threads para cada solicitação. Deployment Descriptor DD :Oferece um mecanismo declarado para a customização das suas aplicações sem tocar no código fonte.mapear o nome dos servlets aumenta a flexibilidade e a segurança da sua aplicação. Benefícios do DD: -Reduz a necessidade de alteração do código-fonte que já foi testado. -Permite que você ajuste os recursos da sua aplicação, mesmo que não possua o código fonte. -Permite que você adapte sua aplicação de acordo com diferentes recursos como banco de dados, sem ter que recompilar e testar nenhum código -Facilita a manutenção das informações dinâmicas, tais como segurança, controle de acesso. -Permite que aqueles que não sejam programadores modifiquem e distribuam suas aplicações Capítulo 3 - Minitutorial do MVC (Não se aplica neste resumo)

4 Capítulo 4 - Sendo um Servlet Servlet : O Servlet possui dois estados : Inicializado = Após rodar o construtor e init Não existe = Antes de rodar o construtor e init ou após o destroy. Ciclo de Vida : O Container carrega a classe, o construtor roda,chama o init(passando um ServletConfig) apenas uma vez durante a vida do servlet e antes de executar o metodo service, chama o service e cada solicitação roda em uma thread separada, e por fim o destroy para dar o servlet uma chance de limpar antes de morrer, como o init ele é chamado apenas uma vez. Você pode sobreescrever o init() da versão padrão, ele é chamado pelo init(servletconfig) da super classe,não há uma regra que impeça de sobreescrever o init(servletconfig) mais se você sobreescrever é melhor chamar o super init(servletconfig), você deve sobreescrever pelo menos um método de serviço(doxxx).as classes do servlet esta em javax.servlet ou javax.servlet.http (exeto aquelas relacionada a JSPs). Solicitação Existe oito métodos no HTTP1.1, Na classe HttpServlet apenas um, o doconnect() não é suportado, os outros sete tem seu método doxxx() em HttpServlet. GET:Pede para obter a coisa(recurso/arquivo) na URL requisitada. POST: Pede para o servidor aceitar informações do corpo anexada na solicitação. HEAD:Pede apenas parte do header daquilo que o get retorna, é como um GET sem corpo na RESPOSTA TRACE:Pede um loopback da mensagem de solicitação, para que o cliente veja o que está sendo recebido do outro lado, para teste de troubleshoot. PUT :Diz para colocar a informação anexada, o corpo, na URL requisitada. DELETE:Diz para apagar a coisa(recurso/arquivo) na URL requisitada. OPTIONS:Solicita uma lista de métodos HTTP. CONNECT:Diz para conectar em caso de tunneling. POST: Os paramêtros são enviados no corpo("payload"), e tambem são separados por "&". Funcionalidade : O POST é usado para serem processados, mudar alguma coisa no servidor. Desvantagem : Não aceita bookmark(adicionar aos favoritos) GET os paramêtros são enviados na url depois do "?" Funcionalidade : O GET é usado para obter coisas, nada mais. Desvantagem : Segurança, Tamanho dos dados que possam ser enviados

5 Idempotente significa que você pode fazer a mesma coisa repetidamente, sem os indesejáveis efeitos colaterais, ou seja a mesma solicitação pode ser feitas duas vezes, sem nenhuma conseguência negativa para o servidor.segundo a especificação HTTP 1.1 o GET, PUT, HEAD são idempotente, o POST não é idepotente.tenha sempre em mente a diferença entre o método HTTP GET e o doget() do servlet, apesar da especificação HTTP garantir que o HTTP GET é idempotente, não existe nada que possa impedi-lo de implementar um metodo doget não idempotente no seu servlet. Método HTTP padrão em um action de um form HTML é o GET, se você não tiver um método correspondente no servlet é gerado um ERRO. Métodos da solicitação, ServletRequest e HttpServletRequest. getheader("nomeheader") : retorna um string com o valor do Header getintheader("nomeheader") : converte o retorno em um inteiro, é usado quando você tem certeza que o retorno é um número. getremoteport() : Usado para obter a porta do cliente. O cliente é remoto na visão do servidor. getserverport() : Usado para obter a porta para qual a solicitação foi inicialmente enviada. getlocalport() : Usada para obter a porta para qual a solicitação foi parar, pois o servidor encontra uma porta para cada thread. Resposta Métodos da resposta, ServletResponse e HttpServletResponse. setheader("nome","valor") : Acrescenta um novo valor se o header não existir, caso contrário sobreescrever o valor. setintheader("nome", 1) : Acrescenta um novo valor "inteiro" se o header não existir, caso contrário SOBREESCREVE o valor. addheader("nome","valor") : Adiciona um novo valor se o header não existir, caso contrário é adicionado OUTRO valor para o mesmo header. setcontenttype("text/html") : conhecido como MIME-TYPE adiciona um header na resposta. getoutputstream() : retorna um ServletOutputStream é usado para saída com bytes. Usa o WRITE() para escrever, ex: sos.write(b). getwrite() : retorna um PrintWriter é usado para saída com caracteres. Usa o PRINTLN() para escrever, ex: pw.println("texte") sendredirect("string") : o browser que faz o trabalho, pois ele retorna um codigo 301 com um header "Location" contendo a url como valor.você pode especificar o endereço completo para o sendredirect ou usar URLs relativas com "/" (relativo a raiz) ou sem "/" (relativo ao final da url que fez a solicitação). Se você escrever na resposta e depois usar o sendredirect é lançado uma IllegalStateException.

6 Capítulo 5 - Sendo uma Aplicação Web Parâmetros Um parâmetro é um objeto não configurado dinamicamente, os parâmetros existe em três objetos da API do Servlet, são os ServletContext, ServletRequest e ServletConfig. Parâmetros init: É considerado constantes para o momento da distribuição, não permite configuração. Não existe nenhum setinitparameter(), e os paramêtros só retorna String. A expressão "parâmetro init" se refere aos paramêtros init do Servlet por padrão. ServletConfig : Um objeto por servlet, sua principal função é disponibilizar parâmetros do init e tambem fornece um getservletcontext(). Os parâmetros init do Servlets são lidos apenas uma vez, quando o container inicia. No DD, dentro da tag <servlet> <init-param> <param-name>admin </param-name> <param-value>admin@gmail.com.br</param-value> </init-param> SevletContext : Um objeto por aplicação, sua principal função é disponibilizar parâmetros para à aplicação. Os ServletContext é unico por aplicação(jvm), em um ambiente distribuido com varias JVM existirão varios ServletContext. Você obtem o servletcontext de duas formas, pelo ServletConfig ou chamar o getservletcontext quando estiver na classe GenericServlet No DD, fora da tag <servlet> <context-param> <param-name>admin </param-name> <param-value>admin@gmail.com.br</param-value> </context-param> Atributos Um atributo é um objeto configurado dinamicamente, os atributos existe em três objetos da API do Servlet, são os ServletContext, ServletRequest e HttpSession. A diferença de um atributo para um parêmetro é que os atributo podem ser setados dinamicamente e seu tipo de retorno é objeto, os parametros não podem ser setados dinamicamente e seu tipo de retorno é String.

7 Atributos do Contexto não são thread-safe, a solução é sincronizar no próprio objeto do contexto, porem isto só funciona se todos os outros códigos que manipulam os mesmos atributos do contexto tambem sincronizarem no ServletContext. Atributos da Sessão não são thread-safe, a solução é sincronizar no próprio objeto de sessão, o HttpSession. Obs: sincronizar o método service é ruim porque detona a capacidade de processamento simultaneo e não protege contra a concorrencia,pois significa que apenas uma thread de cada vez em uma classe do servlet pode estar rodando, mais isto não impede que outros servlets ou JSPs de acessarem o atributo. Apenas os atributos da Solicitação e as variáveis locais são thread-safe. Importante: Não se esqueça que atributos devem ser convertidos já que o tipo de retorno é um objeto Listeners ServletContextListener : É um interface que refere ao ciclo de vida do ServletContext (inicialização e destruição), basta sua classe implementar a interface e declara no DD: <Listener> <listener-class>foo.mylistener</listener-class> </listener> OBS: HttpSessionBindingEvent é subclasse de HttpSessionEvent Interfaces Métodos Eventos ServletContextListener contextinitialized, ServletContextEvent contextdestroyed ServletContextAttributeListener attributeadded, attributeremoved, ServletContextAttributeEvent attributereplaced ServletRequestListener requestinitialized, ServletRequesEvent requestdestroyed ServletRequestAttributeListener attributeadded, attributeremoved, ServletRequestAttributeEvent attributereplaced HttpSessionListener sessioncreated, sessiondestroyed HttpSessionEvent getsession() HttpSessionAttributeListener attributeadded, attributeremoved, attributereplaced HttpSessionBindingEvent (getsession(), getname(), getvalue()) HttpSessionBindingListener valuebound, valueunbound HttpSessionBindingEvent (Não existe configuração no DD) HttpSessionActivationListener sessiondidactivate, sessionwillpassivate HttpSessionEvent (Não existe configuração no DD)

8 Importante : O método getvalue() que existe nas classes de eventos retorna o valor antigo do atributo, caso ele seja substituído. Outros SingleThreadModel (SMT) é designado a proteger variáveis de instacia. Assegura que os servlets lidem apenas com uma solicitação de cada vez.se o Container implementar o SMT com "pool" a semântica do Servlet muda. RequestDispatcher : O trabalho é realizado do lado do servidor, ele é usado para encaminha uma solicitação. O RequestDispatcher possui dois métodos : forward(servletrequest req, ServletResponse resp). include(servletrequest req, ServletResponse resp). Existe duas forma de conseguirmos um RequestDispatcher, através da solicitação e/ou do contexto: ServletRequest :RequestDispatcher view=request.getrequestdispatcher("pagina.jsp"), o argumento String pode ser relativo, ou começar com "/" da raiz. ServletContext :RequestDispatcher view=getservletcontext.getrequestdispatcher("/pagina.jsp"), o argumento String só pode começar com "/" da raiz, senão será lançada uma illegalargumentexception. Obs: O paramêtro(caminho do recurso) do método getresourceasstream do ServletContext deve começar com "/" Importante : Você não pode transferir a solicitação se você já submeteu uma resposta, ou seja, chamou o flush(), isso lança uma IllegalStateException. Capítulo 6 - Gerenciamento de Sessão HttpSession : É usado para manter o estado de conversação durante várias solicitações, ou seja, para uma sessão inteira com o mesmo cliente. O container usa o session ID para se comunicar com o cliente que envia de volta com cada solicitação subsequente. A uníca coisa que você tem que fazer é informar ao Container que você quer criar ou usar uma sessão mais é o Container que gera a session ID, criando um novo objeto cookie, inserindo a session ID dentro do cookie e configurando- o como parte da resposta. Nas solicitações subsequentes, o Container recebe a session ID de um cookie da solicitação, compara-a com uma sessão existente e associa essa sessão com a solicitação atual. Podemos obter o HttpSession atraves do HttpServletRequest e dos eventos HttpSessionEvent e HttpSessionBindingEvent. Se o cliente não aceitar cookies você não receberá nenhuma exceção, porem o getsession() sempre retornará uma nova sessão. Um alternativa é a reescrita de URL porem você deve codificar todas as URLs que você envia na resposta. Por padrão o Container é configurado para usar os cookies primeiro, com a reescrita de URL apenas em último caso, exceto na primeira vez, porque ele não consegui saber se o cookie está funcionado.

9 Na primeira resposta enviada ao cliente ele tenta o cookie e a reescrita de URL. Assim na segunda solicitação ele terá a session ID anexada à URL, mas se o cliente aceitar cookies ele terá tambem um cookie session ID. Assim se o cookie respondeu, quer dizer que o cliente aceita cookies, então ele ignora a reescrita de URL. Obs: A única maneira de usar a reescrita de URL é se TODAS as páginas que são parte de uma sessão forem dinâmicas, ou seja HTML estáticos não funcionam. Obs: A reescrita de URLs é especifica por fabricante, o tomcat usa ";" no final da url. Métodos referentes ao HttpSession. request.getsession() : sempre retorna uma sessão : nova ou existente. request.getsession(true) : sempre retorna uma sessão : nova ou existente. request.getsession(false) : só retorna uma sessão se ela existir caso contrario ele retorna null. session.isnew() : retorna verdadeiro se o cliente ainda não respondeu.se a sessão estiver destruída é lançada uma IllegalStateException getcreationtime() : Retorna o momento que a sessão foi criada pela primeira vez. getlastaccessedtime() : Retorna a última vez que o Container recebeu uma solicitação para uma determinada sessão, retorna em milisegundos. getmaxinactiveinterval() : Retorna o tempo máximo em segundos permitido entra as solicitações do cliente para esta sessão. setmaxinactiveinterval() : Especifica o tempo máximo em segundos que você quer permitir entre as solicitações, terá o mesmo efeito do timeout. invalidate() : Finaliza a sessão, desvincula todos os atributos da sessão.se a sessão estiver destruída é lançada uma IllegalStateException Timeout no DD : <web-app> <session-config> <session-timeout>15</session-timeout> </session-config> </web-app> Importante: O timeout do DD está em minutos no setmaxinactiveinterval está em segundos. Importante: Se chamar algum método da sessão após ela destruída é lançada uma IllegalStateException. Importante: Configura o timeout para -1 a sessão nunca expirará. Existe três formas de matar uma sessão. -Por timeout (configuração no DD ou chamar o setmaxinactiveinterval ) -Chamar o invalidade. -A aplicação cai.

10 O objeto HttpSession é único em um ambiente clusterizado, ou sejá ele não existe em mais de uma VM, pois acontece a migração de sessão, e se torna passiva em uma VM e ativa em outra. Cookie : É uma par de String/Valor usado para trocar informações entre o servidor e o cliente. Originalmente foi desenvolvido para trabalhar com sessões, porem podemos usar para outras coisas. Por padrão, um cookie vive enquanto dura a sessão, mas podemos mandar um cookie permanecer mesmo depois que o browser é fechado. Funcionamento Servidor envia um cookie na resposta com um header : Set-Cookie:username=Tomas Cliente devolve um cookie através da solicitação como um header : Cookie:username=Tomas Você pode obter headers relacionado ao cookie, mas você não deve, pois tudo está encapsulado em três classes na API do servlet: -javax.servlet.http.httpservletrequest : getcookies(), retorna um Array de cookies. -javax.servlet.http.httpservletresponse: addcookies(), adiciona um new Cookie(String,String); -javax.servlet.http.cookie : Cookie(String,String) - Construtor cookie.setmaxage(30*60) : é definido em SEGUNDOS, configura este valor para -1 faz com que o cookie desapareça se o browser fechar. cookie.getmaxage() : retorna em SEGUNDOS o tempo de vida do cookies. Capítulo 7 - Sendo um JSP JSP : é uma pagina dinamica que é transformda em um Servlet completo rodando em sua aplicação. Quando o Container transforma o JSP em um servlet ele cria uma subclasse de HttpServlet e implementa a interface HttpJspPage com os métodos jspinit(), jspdestroy e um método de serviço chamado _jspservice(), no inicio do método de serviço é criado uma pilha de declarações de objetos implícitos e atribuições. Ciclo de vida JSP Funcionamento : O container lê o web.xml, mais não faz nada com os JSPs até que ele seja solicitado pela primeira vez, na primeira solicitação o container tenta traduzir em código java (Erros de sintaxe JSP são detectados), depois o container tenta compilar o código java para um arquivo.class, o Container carrega a classe do servlet gerada e faz com que o método jspinit() rode, e objeto se torna um servlet completo. É criado uma nova thread para tratar a solicitação e o método _jspservice() do servlet roda.

11 Tudo que acontece depois é uma rotina normal do servlet.a tradução e a compilação acontecem uma única vez. Obs: Existe um menção na especificação para que os JSPs sejam traduzidos e compilados antecipadamente, isso depende do fabricante, então não é garantido. Metodos da interface javax.servlet.jsp.jsppage jspinit() : Este método é chamado pelo método init(), Você pode sobreescrever. JspDestroy() : Este método é chamado pelo método destroy(), Você pode sobreescrever. Metodo da interface javax.servlet.jsp.httpjsppage que extende a JspPage _jspservice() : Este método é chamado pelo método service, Não pode sobreescrever. Configurando parâmetros init em JSPs. <web-app> <servlet> <servlet-name>myjsp</servlet-name> <jsp-file>/paginajsp.jsp</jsp-file> <init-param> <param-name>admin </param-name> <param-value>admin@gmail.com.br</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>myjsp</servlet-name> <url-pattern>/paginajsp.jsp</url-pattern> // Deve ser igual o jsp-file, caso contrário não funciona </servlet-mapping> </web-app> Objetos Implícitos em um JSP API Objeto Implícito. JspWriter HttpServletRequest HttpServletResponse HttpSession ServletContext ServletConfig JspException PageContext Object out(um JspWriter é um PrintWriter com algumas funções de buffer) request response session application config exception(disponível apenas para paginas de erros definidas) pagecontext(encapsula outros objetos implícitos) page

12 Existe quadro escopos para atributos em um JSP Aplicação(application), requisição(request), sessão(session) e pagina(page). PageContext : É um subclasse de JspContext e encapsula outros objetos implícitos. Podemos usar uma referência do PageContext para obter atributos a partir de qualquer escopo. Obs: Os métodos referentes a atributos fica em JspContext porem as constantes para os escopos fica na classe PageContext. Métodos (JspContext) : setattribute(string, Object) : só funciona para escopo de pagina. setattribute(string,object, int escopo) : funciona em todos escopos getattribute(string) : só funciona para escopo de pagina. getattribute(string, int escopo) : funciona em todos escopos getattributenamesinscope(int escopo) : todos atributos de um escopo findattribute(string) : quando não se sabe o escopo, este método procura do mais restrito para o menos restrito (page, request, session e application). EL Expression Language : oficialmente tornou-se parte da especificação a partir da JSP2.0. É um jeito simples de invocar código Java que você normalmente faria com scriptlets e espressões. Uma expressão EL sempre se parece com ${algumacoisa}. Para desabilitar a EL é necessario a seguinte configuração no DD. <web-app> <jsp-config> <jsp-property-group> <url-pattern>*.jsp</url-pattern> <el-ignored>true</el-ignored> </jsp-property-group> </jsp-config> </web-app> scripting-invalid : <scripting-invalid> é usado para impedir que um JSP possua elementos scripting (scriptlets, expressões e declarações). No DD <web-app> <jsp-config> <jsp-property-group> <url-pattern>*.jsp</url-pattern> <scripting-invalid>true</scripting-invalid> </jsp-property-group> </jsp-config> </web-app>

13 Importante : A única forma de invalidar scripting é através da tag <scripting-invalid> no DD. Importante: A EL e os scripting são habilidata por padrão Importante: O atributo iselignored da diretiva page tem prioridade, e sempre ganha. Ações padrões, vem em dois sabores : Ação padrão - padrão : <jsp:include page="pagina.jsp" /> Ação padrão - não padrão : <c:set var="rate" value="80" /> Tipos de elementos JSP Diretiva : é um recurso que você tem para dar instruções especiais ao Container no momento da tradução da pagina. Vem em 3 tipos : page, include, taglib -Page : Defini propriedades especificas da página. Ex: <%@ page import="foo.*, java.util.* "%> Atributos : import : defini import do java, alguns vem incluso como java.lang, javax.servlet, javax.servlet.http e javax.servlet.jsp isthreadsafe : defini se o servlet gerado precisa implementar o STM,o padrão é true, que significa que minha aplicação é thread safe e não precisa do STM. contenttype : define o MIME type para a resposta. iselignored : defini se a EL será ignorada. iserrorpage : defini se é uma pagina de erro, o padrão é false, se for true tem acesso ao objeto implicito exception. errorpage : defini a URL para o recurso aonde as Throwables devem ser enviadas. -Taglib : Defini as bibliotecas disponíveis para um JSP. Ex: <%@ taglib prefix="cool" tagdir="/web- INF/tags/cool" %> -Include : Defini a pagina que será incluido no momento da tradução. Ex: <%@ include file="pagina.html" %> Scriptlet : Código java dentro de um JSP que é incluso dentro de um métodos de serviço, variaveis aqui são sempre locais. <% Float one = new Float(42.5); %> Expressão : Exibe o conteúdo entre as tags, este conteúdo e passado como argumento para um out do PrintWriter que é incluso dentro de um método de serviço. <%= "Olá" %>

14 Declaração : Uma decalaração JSP é sempre definida dentro da classe, mais fora do método de serviço. As declarações servem para as variáveis estática, de instância e para os métodos. Obs : Você pode declara um método depois a variavél, sem problemas na ordem. <%! int y =3; %> Template Text : HTML simplês EL : ${applicationscope.mail} Ação : <jsp:include page="pagina.jsp" /> Ação Pãdrão Capítulo 8 - Páginas sem scripts jsp:usebean : É uma maneira de declarar e inicializar um objeto real que você está usando em <jsp:getproperty>.é como se você estivesse setando um atributo. Ele procura por um atributo no scopo definido em "scope", caso ele não encontre, ele cria um. Ex: request.setattribute("pessoa", p); <jsp:usebean id="pessoa" type="foo.pessoa" class="foo.empregado" scope="request" > <jsp:setproperty name="pessoa" property="name" value="fred" /> (Funciona de forma condicional dentro do corpo, só executa se um bean não for encontrado) </jsp:usebean> <jsp:getproperty name="pessoa" property="name" />( Só funciona se o jsp:usebean declarar o atributo) Obs:O atributo id do <jsp:usebean> é obrigatório. Obs:Se você não definir o atributo scope, o padrão será page. Obs:Se você especificar um atributo type, você só podera especificar propriedades <jsp:setproperty> no tipo do Type e não do class. Polimorfismo :O type é o que você declara, pode ser um tipo de classe, um tipo abstrado, interface ou qualquer coisa que você usa como referência ao "class". Obs:Podemos fazer combinações de ações-padrão com scripting Obs: Erros -<jsp:usebean id="pessoa" type="foo.empregado" class="foo.pessoa" /> //Ao acessar diretamente o JSP com essa tag é gerado p seguinte erro: Erro cannot convert from Pessoa to Empregado -Pessoa p = new Pessoa();request.setAttribute("pessoa",p);<jsp:useBean id="pessoa" class="foo.empregado" scope="request" /> //foo.pessoa cannot be cast to foo.empregado O atributo Param : Você pode enviar um parâmetro de solicitação direto para um bean. Ex: <jsp:setproperty name="pessoa" property="name" param="name" />.

15 Se o nome do parâmetro da solicitação for igual o nome da propriedade do bean e você não especificar o value e nem o param o valores são diretamente preenchidos. Ex: <jsp:setproperty name="pessoa" property="name" />. Se TODOS os nomes de parâmetros da solicitação coincidir com os nomes da propriedades, todos são preenchidos, caso não encontre algum apenas não sera preenchido. Ex: <jsp:setproperty name="pessoa" property="*" /> //As tags do bean convertem as propriedades primitivas automaticamente. Importante: O bean deve ter um construtor publico sem argumento, ou seja seguir a "Lei do Bean", caso contrário é gerado um erro Importante: Se o type for usado sem um class, só irá funcionar se o bean já existir (O container NUNCA tenta instaciar um type mesmo se ele for concreto), se o class for usado (com ou sem o type), a classe dever ser concreta e possuir um construtor padrão Importante: A conversão automática String-Primitiva NÃO funciona se você usar scripting. <jsp:setproperty name="pessoa" property="id" value="<%= req.getparameter("id")%>" />// Isto gera um erro porque id é inteiro, se fosse String funcionaria. EL Expression Language. A EL facilita a exibição de propriedades aninhadas, ou seja propriedades de propriedades,o que não é possível com <jsp:getproperty> sem uma classe especial. A primeira variável na expressão ou é um objeto implícito ou um atributo(que pode ser definido pelo "jsp:usebean" ou algum "setattribute"). Objetos implícitos EL. pagescope:um Map dos atributos do escopo da pagina. requestscope:um Map dos atributos do escopo da solicitação sessionscope : Um Map dos atributos do escopo da sessão applicationscope : Um Map dos atributos do escopo da aplicação param : Um Map dos parâmetros da solicitação paramvalues:um Map dos parâmetros da solicitação header : Um Map dos header da solicitação headervalues : Um Map dos header da solicitação cookie : Um Map para cookies Ex: ${cookie.username.value} initparam : Um Map para os parâmetros init do contexto. pagecontext : De todos os objeto implícitos apenas o pagecontext não é um mapeamento.ele é uma referência ao um objeto real. Obs: Os objetos implícitos EL não são os mesmo disponíveis para os scripts JSP, exeto o pagecontext.

16 Operadores EL Operador ponto "." : O que está a esquerda DEVE ser ou um Map ou um Bean, e o que está na direita DEVE ser uma chave de um Map ou uma propriedade de um Bean, e seguir as regras normais de nomenclatura java(deve inicia com letra, _, $ depois do primeiro caracter pode ter número, não pode ser uma palavra chave java). Operador [] : O que está a esquerda pode ser um Map, bean um List ou um array e o que vai na direita não precisa seguir as regras de nomenclatura java e ser for um String literal (entre aspas) ela pode ser uma chave map, um propriedade bean, ou ainda um índice dentro de uma List ou array. Obs: Um índice String é forçado no int para os arrays e Lists, caso ele não possa ser forçado isto gerará um erro. Obs: Se o que for entre os [] não for uma String literal, o Container avalia buscando por um atributo, se ele não encontrar, retornará nulo. Obs: Os indice dos Lists e arrays iniciam do 0, em Maps eles iniciam do 1. Obs: Na EL, na expressão e a ação padrão "getproperty" apresenta o texto bruto para o HTML, por exemplo <b></b> não é apresentado na pagina, é necessário converter os caracteres em seus respectivos formatos. Ex :"&lt". Operadores Aritméticos Adição : + Subtração : - Multiplicação : * Divisão : / e div (Você pode dividir por 0 na EL o resultado é infinito) Resto : % e mod (você não pode usar o operador resto com zero, você terá um exceção.) Operadores Lógicos AND : && e and OR : e or NOT :! e not Operadores relacionais Igual : == e eq Diferente :!= e ne Menor que : < e it Maior que : > e gt Menor ou igual a : <= e le Maior ou igual a : >= e ge

17 Palavra reservadas EL : true, false, null, instanceof (reservada para o futuro), empty(retorna verdadeiro se algo é nulo ou vazio). Importante: A EL trata os valores nulos graciosamente, sem gerar exceções, Nas expressões aritméticas a el trata uma variável desconhecida como zero e nas expressões lógicas como false. Funções EL : É um classe java simple com um método público e estático e pode ter argumentos com o nome totalmente qualificados, o método deveria(mais não é obrigatório) ter um tipo de retorno.a função dever ter um TLD que defina a função usada no JSP, o nome usada na EL não precisa ser igual o nome do método, e é no TLD que você mapeia isso. Ex: no TLD <taglib...> <tlib-version>1.0</tlib-version> <uri>funcoesdados</uri> <function> <name>jogardados</name> <function-class>foo.dado</function-class> <function-signature>jogar()</function-signature> <function> </taglib> No JSP. <%@ taglib prefix="dados" uri="funcoesdados" %> ${dados:jogardados()} Templates : Existe três mecanismo de includes diferente, iremos ver dois, a diretiva include e a açãopadrão <jsp:include/> -Diretiva include : Diz ao Container o seguinte, copie tudo do arquivo incluído e cole neste arquivo, bem aqui. Durante a tradução Ex: <@% include file="header.jsp" %> Vantagem : Performance Desvantagem: Os dados não estará atualiados e a classe do Servlet ficará maior. -Ação Padrão <jsp:include/> : Diz ao Container o seguinte, insira a RESPOSTA do arquivo incluído aqui, e continue com o restante. DURANTE O RUNTIME. O mais Ex: <jsp:include page="header.jsp" /> Vantagem : Os dados sempre estará atualiados. Desvantagem: Performance Obs : O Container faz um RequestDispatcher para a pagina a ser incluída chamando o método include() do RequestDispatcher.

18 <jsp:param> : Pode ser usado somente corpo do <jsp:include> ou <jsp:forward> para passar parâmetros(infomações).se o nome do parâmetro já tiver um valor na solcitação este será substituído. Ex: <jsp:include page="header.jsp"> <jsp:param name="titulo" value="titulo da pagina"> </jsp:include> e na pagina incluída ${param.titulo} <jsp:forward>:você pode encaminhar de um JSP para outro,ou de um JSP para um servlet,ou de um JSP para qualquer outro recurso da sua aplicação. Com o <jsp:forward> o buffer é limpo antes do encaminhamento, ou sejá nada que você escrever antes do encaminhamento aparecerá, se ele for realizado. Ex: <jsp:forward page="logout.jsp" /> Importante: se você fizer um flush(); e chamar o forward, tudo que estava antes do forward é exibido para o cliente e nada mais, o container lança uma IllegalStateException mais o cliente não ve ela na pagina. Importante: A diretiva include insere a FONTE do arquivo no momento da tradução, mais a ação padrão <jsp:include/> insere a RESPOSTA do arquivo no runtime. Obs: Ambos mecanismo de inclusão podem incluir paginas JSPs e HTMLs. Obs: Os JSP incluído pode possuir seus próprios conteúdos incluidos. Obs: Existe algumas limitaçoes para arquivos incluídos, eles não pode altera código do status da resposta nem criar headers, nem chamar o addcookies(). Obs: Não coloque HTML de abertura e fechamento e tags BODY dentro das suas paginas incluídas, pois não ira funcionar em todos Browsers. Capítulo 9 - Tags Customizadas JSTL 1.1 centrais - São Tag Customizadas prontas para iteragir com seu JSP. Não faz parte da especificação JSP2.0. TAG: <c:foreach> :Tag que integra-se perfeitamente a um loop for que interage em uma coleção(map, Coleção, array ou String delimitada por vírgula) Ex:<c:forEach var="movie" items="${listmovie}" varstatus="moviecount"> ${moviecount.count} ${movie} </c:foreach> Atributos: -var : A variável que armazena o objeto da coleção, tem apenas escopo de tag. -items : a coleção. -varstatus :é uma instância de javax.servlet.jsp.jstl.core.looptagstatus que contem o atributo count Obs: Você pode aninha tags <c:foreach>, tr é linha, td é coluna.

19 TAG: <c:if> : Realiza um test condicional, é como um "if" Ex:<c:if test="${usertype eq 'member'}"> Acesso permitido </c:if> Atributos: text : condição booleana TAG: <c:choose> : Realiza um test condicional Se Não realiza outro, é como um "if", "else". Ex:<c:choose> <c:when test="${usertype eq 'member'}" > Acesso permitido <c:when> <c:otherwise> Acesso não permitido </c:otherwise> <c:choose> TAG: <c:out> : Tag para exibir texto. Proteje contra o ataque de hack com cruzamento de sites, pois código javascripts não são interpretados na saída do c:out. Concorrentes:expressões,<jsp:getProperty> e EL,em todas essas os texto não são convertidos e não é possível definir um valor padrão caso os texto seja nulo. Ex: <c:out value='${pagecontext.currenttip}' default="tipo padrão" /> Atributos: -escapexml : O padrão é true, isso quer dizer que os caracteres serão convertidos para XML, ou seja o browser apresentará caracteres como <,>,&,',". -default ou <c:out value='${user}'>user</c:out> : defini um valor padrão caso o value for avaliado para null. TAG: <c:set> : Essa tag é usada para definir um valor em um Map, propriedade em um bean, e criar um atributo no escopo definido. Concorrentes:<jsp:setProperty> só é capaz de fazer uma coisa: definir a propriedade de um bean. Pode ser usada de duas formas com var OU com target. -Versão var : serve para definir variáveis de atributos. Ex:<c:set var="user" scope="session" value="cowboy" /> Atributos: var : Obrigatório, Se NÃO houver um atributo no escopo sessão chamado "user", está tag cria um, mais só se o valor não for nulo. value : testar para ver se é Obrigatório se não especificado no corpo o valor do atributo. scope : Opicional, O padrão é o de pagina.

20 Importante: Se o valor de value ou o corpo for avaliado como nulo, e existir um atributo com o mesmo nome do var, ele será removido do scopo, se o scopo não for espeficicado ele começará olhando da pagina, request, sessão e aplicação. - Versão target: serve para definir propriedades de beans e valores de Maps. Ex:<c:set target="${pessoa}" property="name" value="cowboy" /> Atributos: target : Obrigatório, Não pode ser uma String literal, Se for nulo ou não for um Map nem um Bean o container gera uma Exceção. property : Se for um bean defina o nome da propriedade, se for um Map defina o nome da chave. value : testar para ver se é Obrigatório, se não especificado no corpo o valor do atributo. Scope : Opicional, O padrão é o de pagina. Importante: O container gera uma exceção se o target for nulo, não for um Map, não for um Bean,e se for uma Bean MAIS a propriedade não igual ao property. TAG: <c:remove> : usado para remover um atributo. Ex:<c:remove var="user" scope="request" /> Atributos: var :obrigatório, o nome do atributo, DEVE SER UMA STRING LITERAL. scope : Opicional, O padrão é o de pagina. TAG <c:import/> : é um tipo de include dinâmico, o arquivo que será incluido pode se localizar dentro ou fora do container. Durante a solicitação Ex:<c:import url=" /> Concorrentes: a diretiva include <%@ include file="header.html" %>, e a ação padrão include <jsp:include page="header.jsp" /> Atributos: url : url que será inclusa, pode se localizar dentro ou fora do container TAG <c:param/> :Pode ser usado no corpo do <c:import/> para passar parâmetros(infomações).se o nome do parâmetro já tiver um valor na solcitação este será substituído. Concorrentes: <jsp:param> Ex:<c:import url="header.jsp" > <c:param name="titulo" value="hello people" /> </c:import> e na pagina incluída ${param.titulo} TAG <c:url/> : usado para criar um link, realiza a reescrita da url automáticamente caso o cliente não aceitar cookies. Ex: c:url value="/inputcomments.jsp" var="valorurl"/> Concorrentes: scripting Ex: <a href="\<% response.encodeurl("/beertest.do")%>\" >click </a>

21 Atributos: value : A url do link. Var : opcional, use este atributo caso queira acessar o valor de value posteriormente. Obs:O <c:url> realiza a reescrita da url automaticamente, porem não realiza a codificação.a codificação de url significa substituir o caracteres não seguros\reservados por outros caracteres,e então, toda pagina é decodificada novamente no lado do servidor.por exemplo,não são permitidos espaços em URL,mais você pode substituir por "+" ou seja ao invès disso <c:url value="/inputcomments.jsp?first=${first}" precisamos forçar o c:url codificar a URL, precisamos usar o <c:param> em seu corpo. Ex: <c:url value="/inputcomments.jsp" var="valorurl"/> <c:param name="primeironome" value="${first}" /> </c:url> TAG <c:catch/> : Semelhante a try/catch do java, serve como try(tentar) e como capturar(catch). Ex:<c:catch var="myexception"> <% int x = 10/0; %> </c:catch> Atributos : var : opcional, um objeto var é uma instância de Throwable e possui a propriedade message com escopo de pagina. Importante : nada roda dentro do corpo de um <c:catch> após a exceção. TAG <c:fortokens> : permite fazer iterações sobre tokens nos quais VOCê defini um delimitador. Funciona da mesma forma que o StringTokenizer. TAG <c:redirect> :? Erros Diretiva page : usada para definir paginas de erro Atributos : iserrorpage : se true confirma ao container que está é uma pagina de erro. Ex: <%@ page iserrorpage="true" %> errorpage : Caso acontecer uma exceção em uma pagina que tenha este atributo, a solicitação sera encaminhada para a pagina de errorpage.ex: <%@ page errorpage="paginaerro.jsp" %> Objeto implícito :Em um scriptlet você terá um objeto implícito "exception" e com EL "${pagecontext.exception}". o objeto exceção implícito fica disponível apenas para paginas de erro com a diretiva page explicitamente definida, Em outras palavras, configurar o pagina de erro no DD não é o suficiente.

22 TAGs TLD : É um descritor de bibliotecas de tags, e descreve duas coisas principais: Tag customizada e funções EL.A classe handler, o TLD e o JSP são os três elementos que você precisa para distribuir e rodar uma aplicação web que usa tag. <taglib...> <tlib-version>1.0</tlib-version>// Obrigatório (A Tag não o valor) <short-name>funções</short-name>// Obrigatório, para uso de ferramentas <uri>funcoesdados</uri> // Opcional,O uri é um identificador único de no TLD, ou seja, é o nome único para a bibliotecas de tags que o TLD descreve.porem se você NÃO especificar um <uri> dentro do TLD, o container tentará usar o atributo uri da diretiva taglib como um caminho para o próprio TLD. <function> <name>jogardados</name> <function-class>foo.dado</function-class> <function-signature>jogar()</function-signature> <function> <tag> <description>função advice</description>// Obrigatório <name>advice</name>// Obrigatório <tag-class>foo.advicehandle</tag-class>// Obrigatório <body-content>empty</body-content>// Obrigatório <attribute> <name>user</name> <required>true</required> <rtexprvalue>true</rtexprvalue>// Opcional,Se true, o atributo pode ser um valor de expressão em runtime, ou seja, não precisa ser uma String literal. <type>foo.user</type>// Opcional, usa o nome totalmente qualificado como tipo do atributo que conhecida com o método "Set" do Handler. </attribute> </tag> </taglib> Atributo - <rtexprvalue> : Você pode usar três tipos de expressões para o valor de um atributo (ou corpo da tag), que permita expressões em runtime. 1-)Expressões EL : <my:advice user="${user}" /> 2-)Expressões Scripts : <my:advice user='<%=request.getattribute("user") %>' /> 3-)Ações Padrões : <my:advice> <jsp:attribute name="user">${user}</jsp:attribute> </my:advice> Importante :O <jsp:attribute> pode ser inserido em um tag mesmo se o seu corpo estiver declarado como empty, e o valor do seu atributo name é o nome do atributo da tag externa.

23 Atributo - <body-content> : Defini informações sobre o corpo da Tag, existe quatro tipos. <body-content>empty</body-content> // A tag não pode ter um corpo. <body-content>scriptless</body-content> // A tag não pode ter elementos scripts, mais pode ter texto, templates, el, ações padrões ou customizadas. <body-content>tagdependent</body-content> //Somente texto puro. <body-content>jsp</body-content> // Pode ser qualquer coisa que possa ser inserida em um JSP. Existe três maneira de invocar uma tag com o corpo vazia, sao elas: 1-)<my:advice user="${user}" /> 2-)<my:advice user="${user}"></my:advice> 3-)<my:advice> <jsp:attribute name="user">${user}</jsp:attribute> </my:advice> Localização do TLD. Antes do JSP 2.0 : Era necessário especificar um mapeamento no DD entre o <uri> do TLD e a real localização do arquivo TLD. <web-app> <jsp-config> <taglib> <taglib-uri>funcoesdados</taglib-uri>// O que você usa no atributo uri da diretiva taglib <taglib-location>/web-inf/myfuncoes.tld<taglib-location> // A localização real do TLD <taglib> <jsp-config> </web-app> Depos do JSP 2.0 : O Container automaticamente cria um mapa entre o arquivo TLD e nome <uri>. Se você de fato especificar uma <taglib-location> explícita no DD, o Container JSP2.0 irá usá-la. Quatro lugares onde se o Container procura por TLDs. 1-)Diretamente dentro de WEB-INF 2-)Diretamente dentro de um subdiretório de WEB-INF 3-)Dentro do diretório META-INF em um arquivo JAR, que fica no interior de WEB-INF/lib 4-)Dentro de um subdiretório de META-INF em um arquivo JAR, que fica no interior de WEB-INF/lib Obs: Não use prefix para taglibs que esteja na lista reservada(jsp, jspx, java, javax, servlet, sun, sunw).

24 Capitulo 10 - Desenvolvendo tag customizadas. Tag Files : Implementa funcionalidade da Tag em outra pagina usando JSP. Adicionado na JSP 2.0, é um tipo de "tag handler junior", ou menos especificos, são includes "bombados".apenas someando um arquivo.jsp a ser incluído para.tag e colocando o arquivo em seu lugar correto, este já se torna uma Tag File.O nome da tag é o mesmo nome do arquivo. Ex: um arquivo header.tag <%@ taglib prefix="mytag" tagdir="/web-inf/tags" %> <mytag:header/> Atributos : Os Tag Files usam diretivas attribute para atributos. Ex:<%@attribute name="titulo" required="true" rtexprvalue="true" %> e na tag <mytag:header titulo="olá Mundo"/> Obs: O valor do atributo name da diretiva attribute é o nome do atributo usado na Tag. Atributos dinamicos : Os Tag Files usam a diretiva tag para atributos dinamicos. Ex: <%@ tag dynamic-attributes='tagattrs' %> // o valor do atributo é uma variável no escopo de pagina que mantem um hashmap. Importante: Os atributos de tag customizadas são declarados no TLD, as Tag File usam a diretiva attribute. Importante: Se você tiver um atributo como required="true" e não usar ele na tag, o container lança uma exceção "status 500". Importante: No <jsp:include> e <c:include> as informações são enviadas por PARÂMETROS de solicitação, assim qualquer parte da aplicação consegui vê-la,com tag files as informações são passada como atributo de escopa de tag. Corpo : Aúnica maneira de declara um corpo para uma Tag é usando a diretiva "tag" com atributo bodycontent. Geralmente um corpo é usado, quando as informações a serem processadas é muito grande e não é possível fazer o mesmo usando a diretiva attribute. <body-content> : define o conteúdo do corpo da tag, diferente das tag customizadas na Tag Files esse atributo não é obrigatório, e seu padrão é scriptless. Existe três valores possível para o body-content : empty, tagdepentent e scriptless, ou sejá nunca será permitido scripting em Tag Files. Localização : Existe 4 lugares que os Tag Files devem residir. 1-)Diretamente dentro de WEB-INF/tags 2-)Dentro de um subdiretório de WEB-INF/tags 3-)Dentro do diretório META-INF/tags em um arquivo jar, que ficar no interior de WEB-IF/lib 4-)Dentro do subdiretório META-INF em um arquivo jar, que ficar no interior de WEB-IF/lib

25 Importante: Se os Tag Files forem distribuídos em um jar, obrigatóriamente ele devem ter um TLD. Importante: Os Tag Files, tem acesso aos HttpServletResponse, HttpServletRequest, e o JspContext super classe de PageContext. Importante: Você não pode usar scripting no corpo de um Tag File mais pode usar dentro do arquivo.tag. Importante: O TLD para um Tag File, descreve apenas a localização dos.tag nada mais.se você criar um TLD para as TAGs File, mesmo combinada com tag customizadas o Container considerará tanto os tags files quanto as tags customizadas. Ex: <taglib...> <tlib-version>1.0</tlib-version> <uri>mytag</uri> <tag-file> <name>header</name> <path>/meta-inf/tags/header.tag</path> </tag-file> </taglib> Tag Handler : Implementa funcionalidades da tag com uma classe java especial, é simplesmente um classe java que faz o trabalho da tag. Tag Handler Simples : Adicionado na JSP 2.0, é uma classe que extende a SimpleTagSupport e implementa o método dotag() que declara um JspException e IOException(não precisa embrulhar o print em try/catch). <taglib> <tlib-version>1.0</tlib-version> <uri>mytag</uri> <tag> <description>simple Tag</description> <name>simple</name> <tag-class>foo.simpletag</tag-class> <body-content>empty</body-content> <attribute> <name>list</name>o mesmo nome declarado como propriedade na classe handler e como atributos da tag <required>true</required> <rtexprvalue>true</rtexprvalue>//opcional,se true, o atributo pode ser um valor de expressão em runtime, ou seja, não precisa ser uma String literal. <type>foo.user</type>// Opcional, usa o nome totalmente qualificado como tipo do atributo que conhecida com o método "Set" do Handler. </attribute> </tag> </taglib>

26 Para processar o corpo é necessário usar o getjspbody().invoke(null) dentro do dotag(), o argumento null, diz para o output ir para resposta, em vez de algum outro write que você informe. JspTag<interface> -> SimpleTag<interface> -> SimpleTagSupport<classe> (inclui 3 métodos incluindo o getjspbody()), em 99,9999% iremos extender a SimpleTagSupport. Ciclo de vida Quando um JSP invoca uma tag, uma nova instacia da classe é criada, e quando o método dotag() finaliza o objeto handler desaparece(handler não são reutilizados) 1-) Carrega a classe 2-) Executa o construtor 3-) chama o setjspcontext(jspcontext) 4-) Se estiver aninhada,chama o setparent(jsptag) 5-) Se tiver atributos, chama o set dos atributos 6-) Se a tag não for declarada com body-content empty e tiver um corpo chama o JspBody(JspFragment) 7-) Chama o dotag(), você sempre substituirá isso. JspFragment : É um objeto que representa o código JSP, trata-se de algo que serve para rodar e gerar um output, O corpo da tag que invoca um Handler Simples e é encapsulado no objeto JspFragment e então passado como argumento no método setjspbody(jspfragment). O JspFragment tem dois métodos -JspContext getjspcontext() -void invoke(java.io.writer) SkipPageException : É uma execeção usada para Tag Handler Simples, a pagina é avaliada parcialmente até o ponto da exceção. Quando a página incluída gera uma SkipPageException, somente ela será interrompida. Importante: Não pode conter quaisquer elementos de script. Importante: Se você colocar algum conteúdo dentro de um tag declarada como body-content empty, o Container gera um exceção. Importante: Se um atributo não for um tipo primitivo ou uma String literal, o valor de <rtexprvalue> deve ser true. Importante: O setjspbody() é invocado somente se esta duas coisas forem verdadeiras: 1-) A tag NÃO está declarada como body-content empty 2-) A tag tiver um corpo ou seja: não deve ser uma tag vazia como <foo:bar/> e <foo:bar></foo:bar> Tag Handler Clássica : É usado na era pré JSP2.0, é uma forma mais complexas de escrever tags customizadas, geralmente extendemos a TagSupport ou BodyTagSupport