Qual é a diferença entre incluir arquivos com a diretiva JSP include, JSP include action e usar JSP Tag Files?

155

Parece que existem dois métodos para modelar com JSP. Incluindo arquivos com uma dessas instruções

<%@ include file="foo.html" %>
<jsp:include page="foo.html" />

ou usando arquivos de tag JSP 

// Save this as mytag.tag
<%@ tag description="Description" pageEncoding="UTF-8"%>
<html>
<head>
</head>
<body>
    <jsp:doBody/>
</body>
</html>

E em outra página JSP, chame-a com

<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>

<t:mytag>
    <h1>Hello World</h1>
</t:mytag>

Então, qual método devo usar? Agora, um é considerado obsoleto ou ambos são válidos e cobrem diferentes casos de uso?

Editar

Usar este arquivo de tag não é o mesmo que incluir uma inclusão?

// Save this as product.tag
<%@ tag description="Product templage" pageEncoding="UTF-8"%>
<%@ tag import="com.myapp.Product" %>
<%@ attribute name="product" required="true" type="com.myapp.Product"%>

Product name: ${product.name} <br/>
Quantity: ${product.quantity} <br/>

E chame-o em outro JSP com

<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>

<t:product>
    <c:forEach items="${cart.products}" var="product">
        <t:product product="${product}"/>
    </c:forEach>
</t:product>

Parece-me o mesmo que usar parâmetros de inclusão e passagem para ele. Os arquivos de tags são os mesmos que os incluídos?

java jsp include jsp-tags tagfile sonicboom
fonte

Respostas:

293

Visão geral dos elementos de sintaxe JSP

Primeiro, para tornar as coisas mais claras, aqui está uma breve visão geral dos elementos de sintaxe JSP :

  • Diretivas : Elas transmitem informações sobre a página JSP como um todo.
  • Elementos de script : são elementos de codificação Java, como declarações, expressões, scriptlets e comentários.
  • Objetos e escopos : os objetos JSP podem ser criados explícita ou implicitamente e são acessíveis em um determinado escopo, como em qualquer lugar da página JSP ou da sessão.
  • Ações : Elas criam objetos ou afetam o fluxo de saída na resposta JSP (ou ambas).

Como o conteúdo é incluído no JSP

Existem vários mecanismos para reutilizar o conteúdo em um arquivo JSP.

Os 4 mecanismos a seguir para incluir conteúdo no JSP podem ser categorizados como reutilização direta :
(para os 3 primeiros mecanismos citados em "Head First Servlets and JSP" )

1) A diretiva include :

<%@ include file="header.html" %>

Estático : adiciona o conteúdo do valor do atributo de arquivo à página atual no momento da tradução . A diretiva foi originalmente projetada para modelos de layout estático, como cabeçalhos HTML.

2) A <jsp:include> ação padrão :

<jsp:include page="header.jsp" />

Dinâmico : adiciona o conteúdo do valor do atributo da página à página atual no momento da solicitação . Destina-se mais ao conteúdo dinâmico proveniente de JSPs.

3) A <c:import>tag JSTL:

<c:import url=”http://www.example.com/foo/bar.html” />

Dinâmico : adiciona o conteúdo do valor do atributo URL à página atual, no momento da solicitação . Funciona muito <jsp:include>, mas é mais poderoso e flexível: ao contrário das outras duas inclusões, o <c:import> URL pode ser de fora da Web Container !

4) Prelúdios e codas:

Estático : prelúdios e codas podem ser aplicados apenas no início e no final das páginas .
Você pode incluir implicitamente prelúdios (também chamados de cabeçalhos) e codas (também chamados de rodapés) para um grupo de páginas JSP, adicionando <include-prelude>e <include-coda>elementos, respectivamente, dentro de um <jsp-property-group>elemento na aplicação Web web.xml descritor de implementação. Leia mais aqui:
• Configurando inclusões implícitas no início e no final das JSPs
• Definindo inclusões implícitas

O Tag File é um método indireto de reutilização de conteúdo, a maneira de encapsular conteúdo reutilizável . Um arquivo de tag é um arquivo de origem que contém um fragmento de código JSP que pode ser reutilizado como uma tag customizada .

O PROPÓSITO de inclusões e arquivos de tags é diferente.

O arquivo de tags (um conceito introduzido no JSP 2.0) é uma das opções para criar tags personalizadas . É uma maneira mais rápida e fácil de criar tags personalizadas . Tags customizadas , também conhecidas como extensões de tag, são elementos JSP que permitem que lógica e saída customizadas fornecidas por outros componentes Java sejam inseridas nas páginas JSP. A lógica fornecida por meio de uma tag customizada é implementada por um objeto Java conhecido como manipulador de tags .

Alguns exemplos de tarefas que podem ser executadas por tags personalizadas incluem operação em objetos implícitos, formulários de processamento, acesso a bancos de dados e outros serviços corporativos, como email e diretórios, e implementação de controle de fluxo.

Em relação à sua edição

Talvez no seu exemplo (no seu Edit ), não haja diferença entre o uso de inclusão direta e um arquivo de tag. Mas as tags personalizadas têm um rico conjunto de recursos . Eles podem

  • Seja customizado por meio de atributos transmitidos da página de chamada.

  • Passe as variáveis ​​de volta para a página de chamada.

  • Acesse todos os objetos disponíveis nas páginas JSP.

  • Comunicar uns com os outros. Você pode criar e inicializar um componente JavaBeans, criar uma variável pública EL que se refere a esse bean em uma tag e, em seguida, usar o bean em outra tag.

  • Estar aninhados um no outro e se comunicar por meio de variáveis ​​privadas.

Leia também isso em "Pro JSP 2": Noções básicas sobre tags personalizadas JSP .

Leitura útil.

Conclusão

Use as ferramentas certas para cada tarefa.


Use Arquivos de tags como uma maneira rápida e fácil de criar tags personalizadas que podem ajudá-lo a encapsular conteúdo reutilizável .

Quanto ao conteúdo incluso no JSP (citação aqui ):

  • Use a diretiva de inclusão se o arquivo mudar raramente . É o mecanismo mais rápido. Se o seu contêiner não detectar alterações automaticamente, você poderá forçar as alterações, excluindo o arquivo de classe da página principal.
  • Use a ação de inclusão apenas para conteúdo que muda frequentemente e se a página a incluir não pode ser decidida até que a página principal seja solicitada.
informatik01
fonte
Mas <jsp: include> não é o mesmo que usar arquivos de tags? Não vejo diferença ... Você pode passar variáveis ​​para arquivos incluídos em <jsp: include>, assim como você pode passar variáveis ​​para marcar arquivos. Ambos os métodos permitem reutilizar o conteúdo, eles parecem fazer exatamente a mesma coisa. Existe alguma diferença entre eles além de seus nomes?
sonicboom
@sonicboom Atualizou minha resposta
informatik01
1
@ informatik01 resposta muito boa, agradeço a profundidade, a boa formatação e a lista muito útil de 4 mecanismos.
Russell Silva
1
qual é exatamente a vantagem de <jsp: include> sobre <* @ include url ..>?
precisa saber é o seguinte
@KrsnaChaitanya Nota: você tem um erro de digitação (o asterisco *) na diretiva de inclusão. <jsp:include>é uma ação de inclusão padrão , <%@ include file="" %>é a diretiva de inclusão . Leia a última seção (na caixa cinza) que descreve as vantagens (ou seja, recomendações sobre quando escolher uma ou outra). Verifique também este artigo para obter uma descrição detalhada. Espero que isto ajude.
informatik01
21

Possível pergunta duplicada

<@include>- A tag diretiva instrui o compilador JSP a mesclar o conteúdo do arquivo incluído no JSP antes de criar o código do servlet gerado. É o equivalente a recortar e colar o texto da sua página de inclusão diretamente no seu JSP.

  • Apenas um servlet é executado em tempo de execução.
  • As variáveis ​​de scriptlet declaradas na página pai podem ser acessadas na página incluída (lembre-se, elas são a mesma página).
  • A página incluída não precisa ser compilada como um JSP independente. Pode ser um fragmento de código ou texto sem formatação. A página incluída nunca será compilada como autônoma. A página incluída também pode ter qualquer extensão, embora .jspf tenha se tornado uma extensão usada convencionalmente.
  • Uma desvantagem dos contêineres antigos é que as alterações nas páginas de inclusão podem não ter efeito até que a página pai seja atualizada. As versões recentes do Tomcat verificarão as páginas de inclusão para atualizações e forçarão uma recompilação do pai, se elas forem atualizadas.
  • Uma desvantagem adicional é que, como o código é incorporado diretamente no método de serviço do servlet gerado, o método pode crescer muito. Se exceder 64 KB, sua compilação JSP provavelmente falhará.

<jsp:include> - A tag JSP Action, por outro lado, instrui o contêiner a pausar a execução desta página, executar a página incluída e mesclar a saída dessa página na saída desta página.

  • Cada página incluída é executada como um servlet separado em tempo de execução.
  • As páginas podem ser condicionalmente incluídas no tempo de execução. Isso geralmente é útil para modelar estruturas que constroem páginas a partir de inclusões. A página pai pode determinar qual página, se houver, incluir de acordo com alguma condição de tempo de execução.
  • Os valores das variáveis ​​de scriptlet precisam ser explicitamente transmitidos para a página de inclusão.
  • A página incluída deve poder ser executada sozinha.
  • É menos provável que você encontre erros de compilação devido ao tamanho máximo do método ser excedido na classe de servlet gerada.

Dependendo das suas necessidades, você pode usar <@include>ou <jsp:include>

Darth
fonte
1
Você quer dizer como você mostrou na sua pergunta <t:mytag><h1>Hello World</h1></t:mytag>:? Isso não é uma inclusão, é o uso normal de uma tag (como <jsp:useBean>ou <c:if>).
uooo
Então, qual é a diferença entre o uso de arquivos de tags e inclui, como parece, os arquivos de tags podem ser usados ​​para incluir conteúdo em uma página?
Sonicboom
9

A principal vantagem do <jsp:include />excesso <%@ include >é:

<jsp:include /> permite passar parâmetros

<jsp:include page="inclusion.jsp">
    <jsp:param name="menu" value="objectValue"/>
</jsp:include>

o que não é possível em <%@include file="somefile.jsp" %>

Saurabh Ande
fonte
E os tagfiles, eu sei como os inlcudes funcionam. Gostaria de saber como os arquivos de tags se relacionam com as inclusões, pois parece que elas fornecem a mesma funcionalidade. Qual é a diferença entre usar tagsfiles e usar include?
Sonicboom
que tal <%@include file="somefile.jsp?menu=value" %>? Isso também é restrito?
Roshana Pitigala 29/11/19
5

Todas as três opções de modelo - <%@include>, <jsp:include>e <%@tag>são válidas, e todas as três abrangem diferentes casos de uso.

Com <@include>, o analisador JSP alinha o conteúdo do arquivo incluído no JSP antes da compilação (semelhante a um C #include). Você usaria essa opção com conteúdo simples e estático: por exemplo, se desejasse incluir elementos de cabeçalho, rodapé ou navegação em todas as páginas do aplicativo da web. O conteúdo incluído se torna parte do JSP compilado e não há custo extra no tempo de execução.

<jsp:include>(e JSTLs <c:import>, que é semelhante e ainda mais poderoso) são mais adequados para conteúdo dinâmico. Use-os quando precisar incluir conteúdo de outro URL, local ou remoto; quando o recurso que você está incluindo é dinâmico; ou quando o conteúdo incluído usa variáveis ​​ou definições de bean que entram em conflito com a página de inclusão. <c:import>também permite armazenar o texto incluído em uma variável, que você pode manipular ou reutilizar. Ambos incorrem em um custo de tempo de execução adicional para o envio: isso é mínimo, mas você deve estar ciente de que a inclusão dinâmica não é "gratuita".

Use arquivos de tags quando desejar criar componentes reutilizáveis ​​da interface do usuário. Se você tem uma Lista de Widgets, digamos, e deseja iterar sobre os Widgets e exibir as propriedades de cada um (em uma tabela ou em um formulário), criaria uma tag. As tags podem receber argumentos, usando <%@tag attribute>e esses argumentos podem ser obrigatórios ou opcionais - um pouco como os parâmetros do método.

Os arquivos de tag são um mecanismo mais simples, baseado em JSP, de escrever bibliotecas de tags, que (antes do JSP 2.0) você precisava escrever usando o código Java. É muito mais limpo gravar arquivos de tag JSP quando há muita renderização na tag: você não precisa misturar código Java e HTML como faria se escrevesse suas tags em Java.

Hari
fonte
1

De acordo com: Java Revisitado

  1. Os recursos incluídos pela diretiva include são carregados durante o tempo de conversão jsp, enquanto os recursos incluídos pela ação include são carregados durante o tempo de solicitação.

  2. Qualquer alteração nos recursos incluídos não será visível no caso da diretiva include até que o arquivo jsp seja compilado novamente. Enquanto em caso de ação de inclusão, qualquer alteração no recurso incluído será visível na próxima solicitação.

  3. A diretiva Include é uma importação estática, enquanto a ação include é uma importação dinâmica.

  4. A diretiva Include usa o atributo file para especificar os recursos a serem incluídos, enquanto a ação include usa o atributo page para o mesmo objetivo.

Abhijeet Ashok Muneshwar
fonte