java example - Quelle est la différence entre inclure des fichiers avec une directive JSP include, inclure une action JSP et utiliser des fichiers JSP Tag?





other page (5)


Il existe plusieurs mécanismes pour réutiliser le contenu dans un fichier JSP.

Les 4 mécanismes suivants pour inclure du contenu dans JSP peuvent être catégorisés comme réutilisation directe :
(pour les 3 premiers mécanismes citant "Head First Servlets et JSP" )

1) La directive include:

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

Statique : ajoute le contenu de la valeur de l'attribut de fichier à la page en cours au moment de la traduction . La directive était à l'origine destinée aux modèles de mise en page statiques, comme les en-têtes HTML.

2) L'action standard <jsp:include> :

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

Dynamique : ajoute le contenu de la valeur de l'attribut page à la page en cours au moment de la demande . A été destiné plus pour le contenu dynamique provenant de JSP.

3) La balise JSTL <c:import> :

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

Dynamique : ajoute le contenu de la valeur de l'attribut URL à la page en cours, au moment de la demande . Cela ressemble beaucoup à <jsp:include> , mais c'est plus puissant et plus flexible: contrairement aux deux autres includes, l' URL <c:import> peut être de l'extérieur du conteneur Web !

4) Préludes et codas:

Statique : les préludes et les codas ne peuvent être appliqués qu'aux débuts et aux fins des pages .
Vous pouvez implicitement inclure des préludes (également appelés en-têtes) et des codas (également appelés bas de page) pour un groupe de pages JSP en ajoutant respectivement des éléments <include-prelude> et <include-coda> dans un élément <jsp-property-group> Descripteur de déploiement de l'application web web.xml . Lire la suite ici:
Configuration des inclusions implicites au début et à la fin des pages JSP
Définition des inclusions implicites

Tag File est une méthode indirecte de réutilisation du contenu, la façon d' encapsuler le contenu réutilisable . Un fichier de balises est un fichier source contenant un fragment de code JSP réutilisable en tant que balise personnalisée .

Le BUT d'includes et Tag Files est différent.

Le fichier de balise (un concept introduit avec JSP 2.0) est l'une des options pour créer des balises personnalisées . C'est un moyen plus rapide et plus simple de créer des tags personnalisés . Les balises personnalisées , également appelées extensions de balises, sont des éléments JSP qui permettent d'insérer des logiques personnalisées et des sorties fournies par d'autres composants Java dans des pages JSP. La logique fournie par une balise personnalisée est implémentée par un objet Java appelé gestionnaire de balises .

Certains exemples de tâches pouvant être exécutées par des balises personnalisées incluent l'exploitation d'objets implicites, le traitement de formulaires, l'accès à des bases de données et d'autres services d'entreprise tels que les courriers électroniques et les répertoires et l'implémentation du contrôle de flux.

Concernant votre Edit

Peut-être que dans votre exemple (dans votre édition ), il n'y a pas de différence entre l'utilisation de l'inclusion directe et d'un fichier de variables. Mais les balises personnalisées ont un riche ensemble de fonctionnalités . Ils peuvent

  • Être personnalisé au moyen d'attributs transmis depuis la page d'appel.

  • Transmettez les variables à la page d'appel.

  • Accédez à tous les objets disponibles pour les pages JSP.

  • Communiquer entre eux. Vous pouvez créer et initialiser un composant JavaBeans, créer une variable EL publique qui fait référence à ce bean dans une balise, puis utiliser le bean dans une autre balise.

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

Lisez aussi ceci à partir de "Pro JSP 2": Comprendre les balises personnalisées JSP .

Lecture utile.

Conclusion

Utilisez les bons instruments pour la tâche concrète.

Utilisez les fichiers de balises comme un moyen rapide et facile de créer des balises personnalisées .

En ce qui concerne le contenu inclus dans JSP (citation d' here ):

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

  • Utilisez l'action include uniquement pour le contenu qui change souvent, et si la page à inclure ne peut pas être définie tant que la page principale n'est pas demandée.

Il semble qu'il existe deux méthodes pour modéliser avec JSP. Y compris les fichiers avec l'un de ces énoncés

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

ou en utilisant des fichiers de balises JSP

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

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

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

Alors, quelle méthode dois-je utiliser? L'un est-il maintenant considéré comme obsolète ou sont-ils tous deux valables et couvrent-ils différents cas d'utilisation?

modifier

Est-ce que l'utilisation de ce fichier de balise n'est pas la même que l'utilisation d'un 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 appelez-le sur une 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 le même que d'utiliser un paramètre include et passing. Les fichiers Tag sont-ils les mêmes que ceux inclus?




Question en double possible

<@include> - La balise directive indique au compilateur JSP de fusionner le contenu du fichier inclus dans la 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 d'inclusion directement dans votre JSP.

  • Une seule servlet est exécutée au moment de l'exécution.
  • Les variables de scriptlet déclarées dans la page parent sont accessibles 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 en tant que JSP autonome. Cela peut être un fragment de code ou un texte brut. La page incluse ne sera jamais compilée de manière autonome. La page incluse peut également avoir n'importe quelle extension, bien que .jspf soit devenue une extension conventionnellement utilisée.
  • Un inconvénient des anciens conteneurs est que les modifications apportées aux pages d'inclusion peuvent ne pas prendre effet tant que la page parente n'est pas mise à jour. Les versions récentes de Tomcat vérifient les mises à jour des pages d'inclusion et forcent une recompilation du parent si elles sont mises à jour.
  • Un autre inconvénient est que, puisque le code est directement incorporé dans la méthode de service de la servlet générée, la méthode peut devenir très grande. S'il dépasse 64 Ko, votre compilation JSP échouera probablement.

<jsp:include> - D'autre part, la balise JSP Action indique au conteneur de suspendre l'exécution de cette page, d'exécuter la page incluse et de fusionner la sortie de cette 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 conditionnellement incluses lors de l'exécution. Ceci est souvent utile pour les structures de modèles qui construisent des pages hors des inclusions. La page parent peut déterminer quelle page, le cas échéant, inclure en fonction de certaines conditions d'exécution.
  • Les valeurs des variables de scriptlet doivent être explicitement passées à la page include.
  • La page incluse doit pouvoir être utilisée seule.
  • Vous risquez moins de rencontrer des erreurs de compilation en raison du dépassement de la taille maximale de la méthode dans la classe de servlet générée.

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




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

<jsp:include /> permet de passer des 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" %>




Java Revisited

  1. La ressource incluse par la directive include est chargée pendant la durée de la traduction jsp, tandis que la ressource incluse par l'action include est chargée pendant l'heure de la requête.
  2. Toute modification sur la ressource incluse ne sera pas visible dans le cas d'une directive include jusqu'à ce que le fichier jsp soit à nouveau compilé. En cas d'action include, tout changement de ressource incluse sera visible dans la prochaine requête.
  3. La directive Include est une importation statique, tandis que l'action include est une importation dynamique
  4. La directive Include utilise l'attribut de fichier pour spécifier la ressource à inclure tandis que l'action include utilise l'attribut de page dans le même but.



Outre tous les autres aspects importants déjà mentionnés ici, Collections API (par exemple, l'interface de carte) est en cours de modification constante pour se conformer aux "derniers et meilleurs" ajouts à la spécification Java.

Par exemple, comparez Java 5 Map itérant:

for (Elem elem : map.keys()) {
  elem.doSth();
}

par rapport à l'ancienne approche Hashtable:

for (Enumeration en = htable.keys(); en.hasMoreElements(); ) {
  Elem elem = (Elem) en.nextElement();
  elem.doSth();
}

En Java 1.8, on nous promet également de pouvoir construire et accéder à HashMaps comme dans de bons vieux langages de script:

Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];

Mise à jour: Non, ils n'atterriront pas en 1.8 ... :(

Les améliorations de la collection de Project Coin seront-elles dans JDK8?







java jsp include jsp-tags tagfile