Quelle est la différence entre inclure des fichiers avec la directive JSP include, L'action JSP include et utiliser des fichiers de Tag JSP?

il semble qu'il y ait deux méthodes pour templater avec JSP. Y compris les fichiers avec l'un de ces énoncés 

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

ou à l'aide de balises JSP fichiers 

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

et dans une autre page JSP l'appeler avec 

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

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

Alors, quelle méthode dois-je utiliser? Est maintenant considéré comme obsolète ou les deux sont-ils valides et à couvrir les différents cas d'utilisation?

Modifier

n'est-ce pas la même chose que d'utiliser une include? 

// 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/>

et l'appeler sur un autre JSP avec 

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

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

cela me semble être la même chose qu'utiliser un include et lui passer des paramètres. Est-ce que les fichiers D'étiquettes sont les mêmes que les includes?

143
demandé sur informatik01 2013-01-29 13:58:32

5 réponses

il existe plusieurs mécanismes pour réutiliser le contenu d'un fichier JSP.

Le suivant 4 mécanismes d'inclure du contenu dans JSP peuvent être classés comme des la réutilisation directe :

(pour les 3 premiers mécanismes citant "Head First Servlets and JSP " )

1) la directive include: 

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

statique : ajoute le contenu de l'attribut file à la page courante au moment de la traduction . La directive a été conçu à l'origine pour les modèles de mise en page statique, comme les en-têtes HTML.

2) le <jsp:include> action standard: 

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

dynamique : ajoute le contenu de la valeur de l'attribut page à la page actuelle au moment de la demande . Était destiné Plus À dynamique contenu provenant de JSPs.

3) Le <c:import> JSTL tag: 

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

dynamique : ajoute le contenu de la valeur de L'attribut URL à la page courante, au moment de la demande . Il fonctionne un peu comme <jsp:include> , mais il est plus puissant et flexible: contrairement à la les deux autres comprennent le <c:import> url peut être de l'extérieur de la conteneur web !

4) Préludes et codas:

statique : préludes et codas ne peuvent être appliqués qu'aux commencements et aux fins des pages .

Vous pouvez implicitement inclure préludes (aussi appelé en-têtes) et codas (aussi appelé pied de page) pour un groupe de JSP les pages en ajoutant des Les éléments <include-prelude> et <include-coda> respectivement compris dans un élément <jsp-property-group> dans l'application Web web.descripteur de déploiement xml . Pour en savoir plus:

* configuration implicite comprend Au début et à la fin de JSPs

• définition implicite comprend

"

Tag Fichier est un méthode indirecte de la réutilisation de contenu, la manière de encapsulation de contenu réutilisable . Un est un fichier source contenant un fragment de code JSP réutilisable comme .

l'objet des fichiers includes et Tag est différent.

Tag file (un concept introduit avec JSP 2.0) est l'une des options pour créer des étiquettes personnalisées . C'est un moyen plus rapide et plus facile de construire les étiquettes personnalisées . "Custom tags , également connu sous le nom de tag extensions, sont des éléments JSP qui permettent la logique personnalisée et la sortie fournie par D'autres composants Java pour être insérés dans les pages JSP. La logique fournie par une balise personnalisée est implémentée par un objet Java connu sous le nom de tag handler .

quelques exemples de tâches qui peuvent être exécutées par des étiquettes personnalisées comprennent l'exploitation sur des objets implicites, le traitement de formulaires, l'accès à des bases de données et d'autres services d'entreprise tels que le courrier électronique et les répertoires, et la mise en œuvre du contrôle de flux.

concernant votre édition

peut-être dans votre exemple (dans votre Edit ), il y a aucune différence entre l'utilisation de direct include et un fichier de balise. Mais étiquettes personnalisées ont un riche ensemble de caractéristiques . Ils peuvent

  • être personnalisé au moyen d'attributs passés à partir de la page d'appel.

  • de Passer des variables de retour à l'appel de la page.

  • accédez à tous les objets disponibles sur les pages JSP.

  • communiquer entre eux. Vous pouvez créer et initialiser un composant JavaBeans, créer une variable EL publique qui se réfère à ce haricot dans une étiquette, puis utiliser le haricot dans une autre étiquette.

  • être imbriqués les uns dans les autres et communiquer au moyen de variables privées.

lire aussi "Pro JSP 2": comprendre les étiquettes personnalisées JSP .

lecture utile.

Conclusion

utilisez les bons instruments pour la tâche de béton.

Utiliser Tag des Fichiers comme un moyen facile et rapide de créer des balises personnalisées .

comme pour le contenu inclus dans JSP (citation de ici ):

  • utilisez le inclure la directive si le fichier change rarement. C'est la manière la plus rapide du mécanisme. Si votre conteneur ne détecte pas automatiquement modifications, vous pouvez forcer les modifications à prendre effet en supprimant le page fichier de classe.

  • utilisez l'action inclure seulement pour le contenu qui change souvent, et si la page à inclure ne peut pas être décidé jusqu'à ce que la page principale est demander.

272
répondu informatik01 2017-09-15 18:39:37

Une Double Question

<@include> - la balise de directive demande au compilateur JSP de fusionner le contenu du fichier inclus dans le JSP avant de créer le code de servlet généré. C'est l'équivalent de couper et coller le texte de votre page include directement dans votre JSP.

  • un seul servlet est exécuté à l'exécution.
  • variables Scriptlet déclarées dans le la page parent est accessible dans la page incluse (rappelez-vous, il s'agit de la même page).
  • la page incluse n'a pas besoin d'être compilée comme un JSP autonome. Il peut être un fragment de code ou texte brut. La page incluse ne sera jamais compilée de manière autonome. La page incluse peut aussi avoir n'importe quelle extension, cependant .jspf est devenu une extension conventionnelle.
  • l'un des inconvénients des contenants plus anciens est que les changements aux pages d'inclusion peuvent ne pas prenez effet jusqu'à ce que la page mère soit mise à jour. Les versions récentes de Tomcat vérifieront les pages include pour les mises à jour et forceront une recompilation du parent si elles sont mises à jour.
  • un autre inconvénient est que depuis le code est inlined directement dans la méthode de service du servlet généré, la méthode peut croître très grande. Si elle dépasse 64 Ko, votre compilation JSP échouera probablement.

<jsp:include> - Les JSP d'Action de la balise de l'autre main charge le conteneur pour interrompre l'exécution de cette page, aller courir inclus dans la page, et de fusionner la sortie de la page dans la sortie de cette page.

  • chaque page incluse est exécutée en tant que servlet distinct au moment de l'exécution.
    • Les Pages
  • peuvent être incluses conditionnellement au moment de l'exécution. Cela est souvent utile pour les cadres de templating qui construisent des pages à partir d'includes. La page mère peut déterminer quelle page, le cas échéant, à inclure selon une condition de fonctionnement.
  • les valeurs des variables scriptlet doivent être explicitement passées à la page include.
  • la page incluse doit pouvoir être exécutée seule.
  • il est moins probable que vous rencontriez des erreurs de compilation en raison du dépassement de la taille maximale de la méthode dans la classe servlet générée.

selon vos besoins, vous pouvez utiliser <@include> ou <jsp:include>

21
répondu Darth 2017-05-23 11:47:15

avantage principal de <jsp:include /> sur <%@ include > est:

<jsp:include /> permet de passer les paramètres 

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

ce qui n'est pas possible dans <%@include file="somefile.jsp" %>

7
répondu Saurabh Ande 2016-06-22 20:45:10

les trois modèles d'options - <%@include> , <jsp:include> et <%@tag> sont valides, et les trois couvrent des cas d'utilisation différents.

avec <@include> , L'analyseur JSP in-lines le contenu du fichier inclus dans le JSP avant compilation (similaire à un C #include ). Vous utiliseriez cette option avec du contenu simple et statique: par exemple, si vous vouliez inclure des éléments d'en-tête, de pied de page ou de navigation dans chaque page de votre application web. Le contenu inclus fait partie du JSP compilé et il n'y a aucun coût supplémentaire à l'exécution.

<jsp:include> (et <c:import> de JSTL , qui est similaire et encore plus puissant) conviennent le mieux au contenu dynamique. Utilisez ceux-ci lorsque vous avez besoin d'inclure du contenu à partir d'une autre URL, locale ou distante; lorsque la ressource que vous incluez est elle-même dynamique; ou lorsque le contenu inclus utilise des variables ou des définitions de haricots qui entrent en conflit avec la page including. <c:import> vous permet également de stocker l' texte inclus dans une variable, que vous pouvez manipuler ou réutiliser davantage. Ces deux encourir un runtime coût pour l'expédition: c'est minime, mais vous devez être conscient du fait que la dynamique est pas "libre".

utilisez des fichiers d'étiquettes lorsque vous voulez créer des composants d'interface utilisateur réutilisables. Si vous avez une liste de Widgets, disons, et que vous voulez itérer sur les Widgets et les propriétés d'affichage de chacun (dans une table, ou sous une forme), vous créerez une balise. Les Tags peuvent prendre des arguments, en utilisant <%@tag attribute> et ces arguments peuvent être soit obligatoires ou optionnels - un peu comme les paramètres de méthode.

Les fichiers de balise

sont un mécanisme plus simple, basé sur JSP, pour écrire des bibliothèques de balise, qui (avant JSP 2.0) Il fallait utiliser du code Java. C'est beaucoup plus propre d'écrire des fichiers de balises JSP quand il y a beaucoup de rendu à faire dans la balise: vous n'avez pas besoin de mélanger Java et le code HTML comme vous auriez à le faire si vous aviez écrit vos balises en Java.

5
répondu Hari 2013-02-08 08:08:41

Java Revisited

  1. la ressource incluse par la directive include est chargée pendant le temps de traduction jsp, tandis que la ressource incluse par l'action include est chargée pendant le temps de requête.
  2. aucun changement sur la ressource incluse ne sera visible en cas de directive include jusqu'à ce que le fichier jsp soit compilé à nouveau. Bien que dans le cas de l'action include, tout changement dans la ressource incluse sera visible dans la prochaine demande.
  3. directive include est statique d'importation, tandis que comprendre l'action est dynamique à l'importation
  4. Include directive utilise l'attribut file pour spécifier la ressource à inclure tandis que l'attribut include action use page a la même fin.
1
répondu Abhijeet Ashok Muneshwar 2013-10-18 06:34:13