JavaServer Pages (JSP) é uma tecnologia padrão Java que lhe permite escrever páginas dinâmicas e orientadas por dados para suas aplicações Web Java. JSP é construído em cima da especificação servlet Java. As duas tecnologias normalmente trabalham juntas, especialmente em aplicações Web Java mais antigas., A partir de uma perspectiva de codificação, A diferença mais óbvia entre eles é que com servlets você escreve código Java e, em seguida, incorporar a marcação do lado cliente (como HTML) para esse código, enquanto com JSP você começa com o script do lado cliente ou markup, em seguida, incorporar tags JSP para conectar sua página à infra-estrutura Java.
JSP também está intimamente relacionado com JSF (JavaServer Faces), uma especificação Java para construir aplicações web MVC (model-view-controller). JSP é uma tecnologia relativamente mais simples e mais antiga do que JSF, que é o padrão para frameworks web Java como Eclipse Mojarra, MyFaces e PrimeFaces., Embora não seja incomum ver JSP usado como interface para aplicações JSF mais antigas, Facelets é a tecnologia de visualização preferida para implementações JSF modernas.
embora o JSP possa não ser a sua primeira escolha para construir páginas web dinâmicas, é uma tecnologia Web Java de base. As páginas JSP são relativamente rápidas e fáceis de construir, e elas interagem perfeitamente com servlets Java em um container servlet como Tomcat. Você vai encontrar JSP em aplicações Web Java mais antigas, e de vez em quando você pode achar útil para construir páginas web Java simples e dinâmicas., Como um desenvolvedor Java, você deve pelo menos estar familiarizado com JSP.
Este artigo será uma introdução rápida às páginas JavaServer, incluindo a JSP Standard Tag Library (JSTL). Os exemplos mostram-lhe como escrever uma página HTML simples, incorporar marcas JSP para se ligar a um servlet Java e executar a página em um container servlet.
veja os artigos anteriores desta série para saber mais sobre servlets Java e Faces JavaServer.
escrevendo páginas JSP
uma página JSP simples (.jsp) consiste em marcação HTML incorporada com tags JSP., Quando o arquivo é processado no servidor, o HTML é renderizado como a área de aplicação, uma página web. As tags JSP incorporadas serão usadas para chamar o código e os dados do servidor. O diagrama na Figura 1 mostra a interação entre HTML, JSP e o servidor de aplicações web.
Figura 1. JSP overview
Listing 1 shows a simple JSP page.Lista 1., Uma página JSP simples
<html> <body> <p>${2 * 2} should equal 4</p> </body></html>na lista 1, você vê um bloco de HTML que inclui uma expressão JSP, que é uma instrução para o servidor Java escrita usando linguagem de expressão (EL). Na expressão “${2 * 2}“, o “${}” é a sintaxe JSP para interpolar o código em HTML. Quando executado, o JSP irá apresentar os resultados da execução do que estiver dentro da expressão. Neste caso, a saída será o número 4.
JSP no recipiente servlet
as páginas JSP devem ser implantadas dentro de um recipiente servlet Java., A fim de implantar uma aplicação web Java baseada em JSP e servlets, você vai empacotar o seu .JSP files, Java code, and application metadata in A.arquivo de guerra, o que é simples .arquivo zip com uma estrutura convencional para aplicações web.
Uma vez carregado o JSP no seu recipiente servlet, será compilado num servlet. JSPs e servlets Java compartilham características semelhantes, incluindo a capacidade de acessar e responder a objetos requisitados. Apache Tomcat 9x é a implementação de referência para as especificações Servlet 4.0 e JSP 2.3. (Note que atualizações entre JSP 2.,2 e 2.3 são relativamente menores.)
exemplo app para JSP
vamos usar uma aplicação exemplo no Tomcat para começar com páginas JavaServer. Se você ainda não tiver o Tomcat instalado, navegue até a página de download do Tomcat e selecione a instalação do Tomcat para o seu sistema operacional. A partir desta escrita, Tomcat 9 é o lançamento atual, compatível com Servlet 4.0 e JSP 2.3.
pode instalar o Tomcat como um serviço Windows, ou executá-lo a partir da linha de comandos com /bin/catalina.sh start ou /bin/catalina.bat., De qualquer forma, Inicie o Tomcat, então vá para localhost:8080 para ver a página de boas-vindas do Tomcat mostrada na Figura 2.
Figura 2. Tomcat welcome page
implícitos Objects in Tomcat
na página de boas-vindas Tomcat, clique no link de exemplos e clique em exemplos JSP.
a seguir, abra os objetos implícitos executam a aplicação web. A figura 3 mostra a saída para esta aplicação. Demora um minuto a estudar esta saída.
Figura 3., Sample JSP output
Request parameters
implícitos objects are built-in objects accessible via a JSP page. Como um desenvolvedor de página web, você vai usar esses objetos para criar acesso a coisas como parâmetros de solicitação, que são os dados enviados a partir do navegador ao emitir um pedido HTTP. Considere o URL do navegador para Implícito Objetos:
This example is a very simple introduction to using JSP tags to access server-side request parameters. In this case, the JSP page uses the built-in (implicit) object called param to access the web application’s request parameters. The param object is available inside the JSP expression syntax that you saw in Listing 1.
In that example, we used an expression to do some math: ${2 * 2}, which output 4.
In this example, the expression is used to access an object and a field on that object: ${param.foo}.
JSP in a web application
On the Implicit Objects page, click the back arrow, followed by the Source link. This will lead you to the JSP code for the Implicit Objects web app, which is shown in Listing 2.
Listing 2. JSP code for the Implicit Objects web app
JSP functions
A JSP function encapsulates a chunk of reusable functionality. In this case, the functionality is to escape XML. JSP offers a variety of functions, and you can also create functions yourself. To use a function, you import its library into your JSP page, then call the function.
In Listing 2, the escapeXML function is included with the line:
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>A sintaxe é bastante claro: ele importa as funções necessárias e atribui-lhes um prefixo (neste caso, “fn”) que pode ser usado em todas as expressões a seguir.,
the JSP Standard Tag Library (JSTL)
The import line in Listing 2 calls taglib, which is short for tag library, or (in this case) JSP Standard Tag Library (JSTL). Bibliotecas de marcas definem bits reutilizáveis de funcionalidade para JSP. JSTL é a biblioteca de tags padrão, contendo uma coleção de taglibs que enviam com todas as implementações servlet e JSP, incluindo Tomcat.
a biblioteca “funções” é apenas uma das taglibs incluídas na JSTL., Outra taglib comum é o core biblioteca, que você importa ao chamar:
<%@ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c" %>como “fn”, a designação “c” é convencional, e você vai vê-la através da maioria das páginas JSP.uma etiqueta de exemplo da biblioteca principal é
<c:out value = "${'<div>'}"/> que produz o<div> tag com o XML já escapado. Esta função é importante porque a saída do conteúdo diretamente para uma página web via ${variable} abre a porta para ataques de injeção de script., Esta função simples é usada para proteger páginas web de tais ataques.
a Biblioteca Central também inclui várias etiquetas para iteração e controle de fluxo (como se/ELSE handling).
chamando os taglibs nas páginas JSP
Agora que você tem uma pega no básico JSP, vamos fazer uma alteração na aplicação exemplo. Para Iniciar, localize o aplicativo objeto implícito em sua instalação Tomcat. O caminho é: apache-tomcat-8.5.33/webapps/examples/jsp/jsp2/el.,
Abra esse arquivo e localize o functions incluem:
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>logo abaixo desta linha, adicione uma nova linha:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>Hit Voltar e adicionar outra linha:
<c:out value = "${'This is a test of the JSTL Core Library'}"/>Agora recarregar a página http://localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar.
Você deve ver suas atualizações refletidas na saída.
Layout of a JSP web application
Tomcat follows the standard layout for Java servlet and JSP pages., A estrutura geral é uma pasta com o nome da aplicação, que é implantada dentro do diretório
do Tomcat.
no aplicativo Objetos implícitos, a aplicação é /examples. Abrir essa pasta revela três filhos importantes: o arquivo /WEB-INF, o diretório index.html, e um conjunto de outros diretórios.
O diretório WEB-INF contém metadados que informam Tomcat como executar o aplicativo.
O resto do conteúdo, incluindo o índice.,html, é diretamente acessível, assim como seria em um servidor web típico. Da mesma forma, o implicit-objects.jsp está disponível para ver, e é tratado automaticamente como uma página JSP (não uma página HTML) pelo servidor.
Request-response architecture
In a typical servlets/JSP application, servlets receive requests and interact with server-side components and services (such as the database) to fulfill them. Uma vez tratado, o resultado do pedido é encaminhado para uma página JSP, que apresenta a resposta.,
um servlet usa a seguinte sintaxe ao enviar uma resposta ao pedido para uma página JSP:
request.getRequestDispatcher("path/to/jsp.jsp").forward(req,res);quaisquer dados que o servlet tenha inserido nos vários âmbitos JSP serão acessíveis ao JSP. Um escopo é simplesmente um intervalo de vida para um determinado objeto. Os objetos de pedido e resposta são objeto de pedido escopo, o que significa que eles vivem para a duração do pedido. Outros âmbitos incluem escopo de página (vivendo enquanto a página JSP faz) e escopo de sessão (terminando quando o usuário termina a sessão dada).,
Conclusion
JavaServer Pages is a well known and versatile technology for developing Java web application views. Combinado com servlets, as páginas JSP são muito poderosas, e fornecem acesso a toda a gama de capacidades Java. Embora o JSP possa não ser a sua primeira escolha para desenvolver uma aplicação web Java moderna, você vai encontrar páginas JSP em aplicações legadas. É também uma boa escolha para aplicações mais simples, onde você deseja conectar rapidamente sua interface HTML ao código Java do servidor., As tags JSTL são capazes de lidar com a maioria dos Requisitos de aplicação web, e bibliotecas de terceiros estendem essa funcionalidade para tecnologias específicas e casos de uso.