TOC

Guia para JavaServer Pages (JSP)

Guia para JavaServer Pages (JSP)

Índice

  • link: #overview [ 1. Visão geral]

  • link: #jsp [ 2. JavaServer Pages]

  • link: #syntax [ 2.1. Sintaxe JSP]

  • link: #contents [ 2.2. Conteúdo estático e dinâmico]

  • link: #implicit [ 2.3. Objetos implícitos]

  • link: #implicit [ 2.4. Outros objetos implícitos]

  • link: #directives [ 2.5. Diretivas]

  • link: #page [ 2.6. Diretivas de página]

  • link: #threeExamples [ 3.0. Três exemplos]

  • link: #htmlRendered [ 3.1. HTML renderizado no servlet]

  • link: #staticJava [ 3.2. Java em um conteúdo estático JSP]

  • link: #forwarding [ 3.3. JSP com encaminhamento]

  • link: #tryIt [ 3.4. Experimente!]

  • link: #conclusion [ 4. Conclusão]

*1. Visão geral *

O JavaServer Pages (JSP) permite a injeção de conteúdo dynamic no conteúdo estatic usando Java e Java Servlets* . Podemos fazer solicitações para um Java Servlet, executar lógica relevante e renderizar uma visualização específica do lado do servidor para ser consumida no lado do cliente . Este artigo fornecerá uma visão geral completa do JavaServer Pages usando Java 8 e Jave 7 EE.

Começaremos explorando alguns conceitos-chave relevantes para o JSP: a diferença entre o conteúdo dynamic e static, o ciclo de vida do JSP e a sintaxe do JSP, bem como as diretivas e os objetos implícitos criados na compilação!

*2. Páginas JavaServer *

O JavaServer Pages (JSP) permitiu que dados específicos do Java fossem passados ​​ou colocados em uma visualização .jsp e consumidos no lado do cliente.

Os arquivos JSP são essencialmente arquivos .html, com alguma sintaxe extra e algumas pequenas diferenças iniciais:

  1. o sufixo .html é substituído por .jsp (é considerado um tipo de arquivo .jsp) e

  2. a seguinte tag é adicionada à parte superior dos elementos de marcação .html:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

Vamos examinar alguns dos principais conceitos do JSP.

====* 2.1 Sintaxe JSP *

Existem duas maneiras de adicionar código Java a um .jsp. Primeiro, podemos usar a sintaxe básica do Java Scriptlet, que envolve a colocação de blocos de código Java em duas tags Scriptlet:

<% Java code here %>

O segundo método é específico para XML:

<jsp:scriptlet>
    Java code here
</jsp:scriptlet>

Importante, é possível usar a lógica condicional do lado do cliente com JSP usando as cláusulas if, then e else e, em seguida, agrupar os blocos relevantes de marcação com esses colchetes.

<% if (doodad) {%>
    <div>Doodad!</div>
<% } else { %>
    <p>Hello!</p>
<% } %>

Por exemplo, se doodad for verdadeiro, exibiremos o primeiro elemento div, caso contrário, exibiremos o segundo elemento p!

====* 2.2 Estático e _ Dinâmico_ Conteúdo *

O conteúdo da web Static são ativos fixos que são consumidos independentemente de solicitações RESTful, SOAP, HTTP, HTTPS ou outras informações enviadas pelo usuário.

O conteúdo Static, no entanto, é fixo e não é modificado pelas entradas do usuário. Os conteúdos da web Dynamic são os ativos que respondem, são modificados ou alterados à luz das ações ou informações do usuário!

A tecnologia JSP permite a separação clara de responsabilidades entre o conteúdo dynamic e static.

O servidor (servlet) gerencia o conteúdo dynamic e o cliente (a página .jsp real) é o contexto static no qual o conteúdo dinâmico é injetado.

Vamos dar uma olhada nos implicit objects que são criados pelo JSP e que permitem acessar dados relevantes ao JSP do lado do servidor!

====* 2.3 Objetos implícitos *

Objetos implícitos são gerados pelo mecanismo JSP automaticamente durante compilation.

Objetos implícitos incluem os objetos HttpRequest e HttpResponse e expõem várias funcionalidades do servidor para uso em seu servlet e para interagir com seu .jsp! Aqui está a lista de implicit objects que são criados:

*request* + _request_ pertence à classe _javax.servlet.http.HttpServletRequest_. O objeto _request_ expõe todos os dados de entrada do usuário e os disponibiliza ao lado do servidor.
*response* + _response_ pertence à classe _javax.servlet.http.HttpServletResponse_ e determina o que é passado de volta para o cliente depois que uma _request_ é feita.

Vamos dar uma olhada nos objetos implícitos request e response, já que eles são os mais importantes e mais usados.

O exemplo abaixo demonstra um método de servlet muito simples e incompleto para lidar com solicitações GET. Omiti a maioria dos detalhes para que possamos focar em como usar os objetos request e response:

protected void doGet(HttpServletRequest request,
  HttpServletResponse response) throws ServletException, IOException {
    String message = request.getParameter("message");
    response.setContentType("text/html");
    . . .
}

Primeiro, vemos que os objetos request e response são passados ​​como parâmetros para o método, tornando-os disponíveis dentro de seu escopo.

Podemos acessar os parâmetros de solicitação usando a função .getParameter () _. Acima, capturamos o parâmetro _message e inicializamos uma variável de string para que possamos usá-lo em nossa lógica do lado do servidor. Também podemos acessar o objeto response, que determina o que e como serão os dados passados ​​para a exibição.

Acima, definimos o tipo de conteúdo. Não precisamos retornar o objeto response para que ele seja exibido na página JSP na renderização!

*out* + _out_ pertence à classe _javax.servlet.jsp.JspWriter_ e é usado para gravar conteúdo no cliente.

Há pelo menos duas maneiras de imprimir na sua página JSP e vale a pena discutir as duas aqui. out é criado automaticamente e permite gravar na memória e, em seguida, no objeto response:

out.print(“hello”);
out.println(“world”);

É isso aí!

A segunda abordagem pode ter melhor desempenho, pois permite gravar diretamente no objeto response! Aqui, usamos PrintWriter:

PrintWriter out = response.getWriter();
out.println("Hello World");

2.4. Outros objetos implícitos

Aqui estão alguns outros _ objetos implícitos_ que também são bons de saber!

*session* + _session_ pertence à classe _javax.servlet.http.HttpSession_ mantém os dados do usuário durante a sessão.
*application* + _application_ pertence à classe _javax.servlet.ServletContext_ armazena parâmetros de todo o aplicativo definidos na inicialização ou que precisam ser acessados ​​em todo o aplicativo.
*exception* + _exception_ pertence à classe _javax.servlet.jsp.JspException_ é usada para exibir mensagens de erro em páginas JSP com a tag _ <% @ page isErrorPage = "true"%> _.
*page* + _page_ pertence à classe _java.lang.Object_ permite acessar ou referenciar as informações atuais do servlet.
*pageContext* + _pageContext_ pertence à classe _javax.servlet.jsp.PageContext_ padroniza o escopo _page_, mas pode ser usado para acessar os atributos _request_, _application_ e _session_.
*config* + _config_ pertence à classe _javax.servlet.ServletConfig_ é o objeto de configuração do servlet, permitindo obter o contexto, o nome e os parâmetros de configuração do servlet.

Agora que cobrimos os implicit objects fornecidos pelo JSP, passemos a directives que permitem que as páginas .jsp acessem (indiretamente) alguns desses objetos.

2.5 Diretivas

O JSP fornece diretivas prontas para uso que podem ser usadas para especificar as principais funcionalidades dos nossos arquivos JSP. Existem duas partes nas diretivas JSP: (1) a própria diretiva e (2) o atributo dessa diretiva ao qual é atribuído um valor.

Os três tipos de diretivas que podem ser referenciadas usando tags de diretiva são _ <% @ page…%> _ que define dependências e atributos da JSP, incluindo content type e language, _ <% @ include…%> _ que especifica uma importação ou arquivo a ser usado e _ <% @ taglib…%> _ que especifica uma biblioteca de tags que define ações personalizadas a serem usadas por uma página.

Portanto, como exemplo, uma diretiva de página seria especificada usando tags JSP da seguinte maneira: _ <% @ page attribute = ”value”%> _

E podemos fazer isso usando XML da seguinte maneira: _ <jsp: directory.page attribute = ”value”/> _

2.6 Atributos de diretiva de página

Há muitos atributos que podem ser declarados em uma diretiva de página:

*autoFlush* __ <% @ page autoFlush = "false"%> __ * *+* *

autoFlush controla a saída do buffer, limpando-o quando o tamanho do buffer é atingido. O valor padrão é verdadeiro_.

*buffer* __ <% @ buffer de página = ”19kb”%> __ * *+* *

buffer define o tamanho do buffer usado por nossa página JSP. O valor padrão é 8kb.

*errorPage* __ <% @ page errorPage = ”errHandler.jsp”%> __ * *+* *

errorPage especifica uma página JSP como uma página de erro.

*extends* __ <% @ page extends = ”org.apache.jasper.runtime.HttpJspBase”%> __ * *+* *

extends especifica a superclasse do código do servlet correspondente.

*info* _ <% @ page info = ”Este é o meu JSP!” %> + _

info é usado para definir uma descrição baseada em texto para o JSP.

*isELIgnored* _ <% @ page isELIgnored = ”true”%> _

isELIgnored indica se a página ignorará ou não o Expression Language (EL) no JSP. O EL permite que a camada de apresentação se comunique com os beans gerenciados Java e faz isso usando a sintaxe _ $ \ {…} _ e, embora não abordemos os detalhes do EL aqui, existem vários exemplos abaixo, suficientes para compilar nosso exemplo de aplicativo JSP! O valor padrão para isELIgnored é false.

*isErrorPage* _ <% @ page isErrorPage = ”true”%> _

isErrorPage diz se uma página é ou não uma página de erro. Devemos especificar uma página de erro se criarmos um manipulador de erros para nossa página dentro do aplicativo.

*isThreadSafe* _ <% @ page isThreadSafe = ”false”%> _

isThreadSafe tem um valor padrão de true. isThreadSafe determina se o JSP pode ou não usar o multi-threading do Servlet. Em geral, você nunca desejaria + desativar essa funcionalidade.

*idioma* _ <% @ idioma da página = ”java”%> _

language determina qual linguagem de script usar no JSP. O valor padrão é Java.

*sessão* _ <% @ page session = ”value”%> _

session determina se deve ou não manter a sessão HTTP. O padrão é true e aceita valores de true ou false.

*trimDirectiveWhitespaces* _ <% @ page trimDirectiveWhitespaces = ”true”%> _

trimDirectiveWhitespaces elimina os espaços em branco na página JSP, condensando o código em um bloco mais compacto no momento da compilação. Definir esse valor como true pode ajudar a reduzir o tamanho do código JSP. O valor padrão é falso_.

*3. Três exemplos *

Agora que analisamos os conceitos centrais do JSP, vamos aplicar esses conceitos a alguns exemplos básicos que ajudarão você a colocar seu primeiro servlet servindo JSP em funcionamento!

Existem três maneiras principais de injetar Java em um .jsp e exploraremos cada uma dessas maneiras abaixo usando funcionalidades nativas no Java 8 e Java EE.

Primeiro, renderizaremos nossa marcação no lado do servidor para ser exibida no lado do cliente. Segundo, veremos como adicionar código Java diretamente ao nosso arquivo .jsp, independentemente dos objetos javax.servlet.http‘s request e response.

Terceiro, demonstraremos como encaminhar um HttpServletRequest para um .jsp específico e vincular o Java processado no servidor a ele.

Vamos configurar nosso projeto no Eclipse usando o tipo File/New/Project/Web/Dynamic web project/ para ser hospedado no Tomcat! Você deve ver depois de criar o projeto:

|-project
  |- WebContent
    |- META-INF
      |- MANIFEST.MF
    |- WEB-INF
      |- lib
      |- src

Vamos adicionar alguns arquivos à estrutura do aplicativo para terminar com:

|-project
  |- WebContent
    |- META-INF
      |- MANIFEST.MF
    |- WEB-INF
      |-lib
     * -web.xml
        |- ExampleTree.jsp
        |- ExampleTwo.jsp
        *- index.jsp
      |- src
        |- com
          |-
            *- ExampleOne.java
            *- ExampleThree.java

Vamos configurar o index.jsp, que será exibido quando acessarmos o contexto da URL no Tomcat 8:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>JSP Examples</title>
    </head>
    <body>
        <h1>Simple JSP Examples</h1>
        <p>Invoke HTML rendered by Servlet: <a href="ExampleOne" target="_blank">here</a></p>
        <p>Java in static page: <a href="ExampleTwo.jsp" target="_blank">here</a></p>
        <p>Java injected by Servlet: <a href="ExampleThree?message=hello!" target="_blank">here</a></p>
    </body>
</html>

Existem três a, cada um vinculado a um dos exemplos que veremos abaixo nas seções 4.1 a 4.4.

Também precisamos ter certeza de que temos nossa web.xml configurada:

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<servlet>
    <servlet-name>ExampleOne</servlet-name>
    <servlet-class>com..ExampleOne</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>ExampleOne</servlet-name>
    <url-pattern>/ExampleOne</url-pattern>
</servlet-mapping>

Uma observação principal aqui é - como mapear corretamente cada um de nossos servlets para um determinado mapeamento de servlet. Para associar cada servlet a um terminal específico em que ele pode ser consumido! Agora, examinaremos cada um dos outros arquivos abaixo!

3.1 HTML renderizado no servlet

Neste exemplo, vamos realmente pular a criação de um arquivo .jsp!

Em vez disso, criaremos uma representação de string da nossa marcação e, em seguida, gravá-la na resposta GET com PrintWriter depois que o ExampleOne Servlet receber uma solicitação GET:

public class ExampleOne extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request,
    HttpServletResponse response) throws ServletException, IOException {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      out.println(
    "<!DOCTYPE html><html>" +
    "<head>" +
    "<meta charset=\"UTF-8\"/>" +
    "<title>HTML Rendered by Servlet</title>" +
    "</head>" +
    "<body>" +
    "<h1>HTML Rendered by Servlet</h1></br>" +
    "<p>This page was rendered by the ExampleOne Servlet!</p>" +
    "</body>" +
    "</html>"
     );
   }
}

O que estamos fazendo aqui é injetar nossa marcação através do processamento direto de solicitações de servlet. Em vez de uma tag JSP, geramos nosso HTML, juntamente com todos e quaisquer dados específicos de Java a serem inseridos, puramente do lado do servidor, sem uma JSP estática!

Anteriormente, analisamos o objeto out, que é um recurso do JspWriter.

Acima, usei o objeto PrintWriter, que grava diretamente no objeto response.

JspWriter, na verdade, armazena em buffer a sequência a ser gravada na memória, que é gravada nos objetos response depois que o buffer na memória é liberado.

PrintWriter já está anexado ao objeto response. Eu preferi escrever diretamente no objeto response nos exemplos acima e abaixo por esses motivos.

3.2 Java em um conteúdo estático JSP

Aqui, criamos um arquivo JSP chamado ExampleTwo.jsp com uma tag JSP. Como visto acima, isso permite que o Java seja adicionado diretamente à nossa marcação. Aqui, imprimimos aleatoriamente um elemento de um _String [] _:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
    <head>
        <title>Java in Static Page Example</title>
    </head>
    <body>
        <h1>Java in Static Page Example</h1>
        <%
              String[] arr = {"What's up?", "Hello", "It's a nice day today!"};
          String greetings = arr[(int)(Math.random() *arr.length)];
            %>
        <p><%= greetings %></p>
    </body>
</html>

Acima, você verá a declaração da variável nos objetos das tags JSP: type variableName e uma initialization, como no Java comum.

Incluí o exemplo acima para demonstrar como adicionar Java a uma página estática sem recorrer a um servlet específico. Aqui, o Java é simplesmente adicionado a uma página e o ciclo de vida do JSP cuida do resto.

====* 3.3 JSP com encaminhamento *

Agora, para o nosso exemplo final e mais envolvido! Aqui, usaremos a anotação _ @ WebServlet_ no ExampleThree, que elimina a necessidade de mapeamentos de servlets em server.xml.

@WebServlet(
  name = "ExampleThree",
  description = "JSP Servlet With Annotations",
  urlPatterns = {"/ExampleThree"}
)
public class ExampleThree extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
      String message = request.getParameter("message");
      request.setAttribute("text", message);
      request.getRequestDispatcher("/ExampleThree.jsp").forward(request, response);
   }
}

ExampleThree usa um parâmetro de URL passado como message, vincula esse parâmetro ao objeto request e, em seguida, redireciona esse objeto request para ExampleThree.jsp.

Portanto, não apenas realizamos uma experiência verdadeiramente dinâmica na web, mas também o fizemos dentro de um aplicativo que contém vários arquivos .jsp.

_getRequestDispatcher (). forward () _ é uma maneira simples de garantir que a página .jsp correta seja renderizada.

Todos os dados vinculados ao objeto request enviado (do arquivo .jsp) serão exibidos! Veja como lidamos com essa última parte:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
    <head>
        <title>Java Binding Example</title>
    </head>
    <body>
        <h1>Bound Value</h1>
        <p>You said: ${text}</p>
    </body>
</html>

Observe a tag JSP incluída na parte superior de ExampleThree.jsp. Você notará que troquei as tags JSP aqui. Estou usando o Expression Language (que mencionei antes) para renderizar nosso parâmetro set (que é vinculado como _ $ \ {text} _)!

====* 3.4 Experimente! *

Agora, exportaremos nosso aplicativo para um .war para ser lançado e hospedado no Tomcat 8! Encontre seu server.xml e atualizaremos nosso Context para:

<Context path="/spring-mvc-xml" docBase="${catalina.home}/webapps/spring-mvc-xml">
</Context>

O que nos permitirá acessar nossos servlets e JSPs em localhost: 8080/spring-mvc-xml/jsp/index.jsp! Pegue uma cópia de trabalho em: GitHub. Parabéns!

====* 4. Conclusão*

Cobrimos bastante terreno! Aprendemos sobre o que são as JavaServer Pages, o que elas foram introduzidas para realizar, seu ciclo de vida, como criá-las e, finalmente, algumas maneiras diferentes de implementá-las!

Isso conclui a introdução ao JSP! Esteja bem e codifique!

Related