close

Pagine JavaServer

Vai alla navigazione Vai alla ricerca
Pagine ManchaServer:EME
Parte della pagina Web dinamica
Informazione Generale
sviluppatore Microsistemi solari
Informazioni tecniche
Previsto in Giava
Piattaforme supportate Java EE
Versioni
Ultima versione stabile 2.3 ()
Collegamenti

JavaServer Pages (JSP) è una tecnologia che aiuta gli sviluppatori di software a creare pagine Web dinamiche basate su HTML e XML , tra gli altri tipi di documenti. JSP è simile a PHP , ma utilizza il linguaggio di programmazione Java .

Per distribuire ed eseguire JavaServer Pages, è necessario un server Web che supporti contenitori servlet come Apache Tomcat o Jetty .

TagLibs -> JSP -> Application Server (servlet) -> Client (browser)

Le prestazioni di una pagina JSP sono le stesse del servlet equivalente, poiché il codice viene compilato come qualsiasi altra classe Java. A sua volta, la macchina virtuale compilerà dinamicamente le parti dell'applicazione che la richiedono per il codice macchina. Ciò rende JSP performante e più efficiente rispetto ad altre tecnologie web che eseguono il codice in modo puramente interpretato.

Il principale vantaggio di JSP rispetto ad altri linguaggi è che il linguaggio Java è un linguaggio generico che supera il mondo web ed è adatto per creare classi che gestiscono la logica aziendale e l'accesso ai dati in modo ordinato. Ciò consente di separare le applicazioni Web in livelli, lasciando la parte incaricata di generare il documento HTML nel file JSP.

Un altro vantaggio è che JSP eredita la portabilità di Java ed è possibile eseguire le applicazioni su più piattaforme senza modifiche. È persino comune per gli sviluppatori lavorare su una piattaforma e l'applicazione finisce per essere eseguita su un'altra.

Servlet e Java Server Pages (JSP) sono due metodi per creare pagine Web dinamiche sul server utilizzando il linguaggio Java. In tal senso sono simili ad altri metodi o linguaggi come PHP , ASP o CGI , programmi che generano pagine web sul server. Tuttavia, differiscono da loro in altre cose.

Per cominciare, JSP e servlet vengono eseguiti su una macchina virtuale Java, il che significa che, in linea di principio, possono essere utilizzati su qualsiasi tipo di computer, purché sia ​​disponibile una macchina virtuale Java. Ogni servlet (o JSP, lo useremo in modo intercambiabile d'ora in poi) gira sul proprio thread, cioè nel proprio contesto; ma non inizia l'esecuzione ogni volta che riceve una richiesta, ma persiste da una richiesta all'altra, in modo che non si perda tempo a invocarla (carica programma + interprete ). La sua persistenza gli consente anche di fare una serie di cose in modo più efficiente: connettersi ai database e gestire le sessioni, ad esempio.

I JSP sono in realtà un modo alternativo per creare servlet poiché il codice JSP viene tradotto in codice servlet Java la prima volta che viene invocato e successivamente è il nuovo codice servlet che viene eseguito producendo come output il codice HTML che compone la pagina Web di risposta.

Descrizione

JSP può essere visto come un'astrazione di alto livello di servlet Java. Le pagine JavaServer sono tradotte in servlet in tempo reale; ogni servlet viene memorizzato nella cache e riutilizzato fino a quando il JSP originale non viene modificato. In altre parole, i JSP sono pagine java per un ambiente web.

Esempio di documento JSP

Esempio di codice di una pagina JSP: 

<%@  page  errorPage = "myerror.jsp"  %> 
<%@  page  import = "com.foo.bar"  %> 
<html> 
<head> 
<%!  int  serverInstanceVariable  =  1 ; %>
…
<%!  int  localStackBasedVariable  =  1 ; %>
…

JSP

Esempio di una build JSP o "output": 

pacchetto jsp_servlet;
importa java.util.*;
importa java.io.*;
importa javax.servlet.*;
importa javax.servlet.http.*;
importa javax.servlet.jsp.*;
importa javax.servlet.jsp.tagext.*;
import com.foo.bar; //importato come risultato di <%@  page  import = "com.foo.bar"  %>
importa...
classe _myservlet implementa javax.servlet.Servlet, javax.servlet.jsp.HttpJspPage {
	//inserito come
	//risultato di <%!  int  serverInstanceVariable  =  1 ; %>
	int serverInstanceVariable = 1;
	…
	public void _jspService( richiesta javax.servlet.http.HttpServletRequest,
		javax.servlet.http.HttpServletResponse risposta )
		genera javax.servlet.ServletException,
		java.io.IOException
	{
		javax.servlet.ServletConfig config = ...;//ottieni la configurazione del servlet
		Pagina oggetto = questo;
		PageContext pageContext = …;//ottieni il contesto della pagina per questa richiesta
		javax.servlet.jsp.JspWriter out = pageContext.getOut();
		Sessione HttpSession = request.getSession( true );
		…

Per eseguire le pagine JSP, è necessario un server Web con un contenitore Web conforme alle specifiche JSP e Servlet. Tomcat 5 è un'implementazione di riferimento completa per le specifiche Java Servlet 2.2 e JSP 1.1.

Sintassi

Variabili implicite

Le pagine JSP includono alcune variabili privilegiate senza la necessità di dichiararle o configurarle:

Variabile Classe
pageContext javax.servlet.jsp.PageContext
request javax.servlet.http.HttpServletRequest
response javax.servlet.http.HttpServletResponse
session javax.servlet.http.HttpSession
config javax.servlet.ServletConfig
application javax.servlet.ServletContext
out javax.servlet.jsp.JspWriter
page java.lang.Object
exception java.lang.Exception

Direttive

Sono tag da cui vengono generate informazioni che possono essere utilizzate dal motore JSP. Non producono output visibile per l'utente, ma configurano come verrà eseguita la pagina JSP.

La sua sintassi è: 

 <%@ directiva atributo="valor" %>

Le direttive disponibili sono:

  • include: include il contenuto di un file nella pagina utilizzando l' attributo file .
<%@ include file="cabecera.html" %>
  • taglib: Importa librerie di tag (librerie di tag)
<%@ taglib uri="/tags/struts-html" prefix="html" %>
  • page: specifica gli attributi relativi alla pagina da visualizzare. Gli attributi sono:
Attributo Sintassi Utilizzo
import <%@ page import="class; class" %> Importa classi e pacchetti Java da utilizzare all'interno del file JSP.
session <%@ page session="false" %> Specifica se utilizzare i dati contenuti nella sessione; il valore predefinito è "vero".
contentType <%@ page contentType="class; class" %> Specifica il tipo MIME dell'oggetto "risposta"; per impostazione predefinita "testo/html; set di caratteri=ISO-8859-1".
buffer <%@ page buffer="12KB" %> Buffer utilizzato dall'oggetto writer "out"; può assumere il valore di "none"; predefinito "8KB".
errorPage <%@ page errorPage="/path_to_error_page" %> Specifica il percorso della pagina di errore che verrà richiamata se si verifica un'eccezione durante l'esecuzione di questo file JSP.
isErrorPage <%@ page isErrorPage="true" %> Determina se questo file JSP è una pagina di gestione delle eccezioni. Solo tali pagine possono accedere alla variabile implicita "exception", che contiene l'eccezione che ha causato la chiamata della pagina di errore.

Dichiarazioni

Consentono di dichiarare variabili, funzioni e dati statici. 

 <%! int maxAlumnosClase = 30; %>

Scriptlet

Gli scriptlet sono pezzi di codice Java incorporati tra gli elementi statici della pagina... 

 <% ... código Java ... %>

Espressioni

Le espressioni vengono valutate all'interno del servlet. Non devono terminare con ";". 

 <%= maxAlumnosClase + 1%>

L'esempio seguente metterebbe l'attributo "titolo" contenuto nell'oggetto richiesta come titolo della pagina: 

 <%
   String titulo = "";
   if (request.getAttribute("titulo") != null) {
     titulo = (String) request.getAttribute ("titulo");
   }
 %>
 ...
 <title><%=titulo%></title>
 ....

Tag

Tag JSP per semplificare il codice e fornire più funzionalità.

Lo sviluppo di siti Web utilizzando i tag presenta alcuni vantaggi come:

  • facilitare l'apprendimento.
  • facilitare la manutenzione.
  • incoraggiare la modularità e il riutilizzo.
  • semplificare il codice e ridurre il numero di righe richieste.

La sua sintassi sarebbe: 

 <%@ taglib uri="/taglib/lycka" prefix="lycka" %>
 ...
 <lycka:hola/>
 ...

Quando si genera il codice Java per il servlet, questo tag hello verrà interpretato dal server delle applicazioni come appartenente alla libreria di tag lycka . Questa libreria sarà identificata nel file descrittore della nostra applicazione (web.xml) con il nome della risorsa (URI) /taglib/lycka . 

 <taglib-uri>/taglib/lycka</taglib-uri>
 <taglib-location>/WEB-INF/tags/lycka.tld</taglib-location>

Un'implementazione di questo file descrittore, /WEB-INF/tags/lycka.tld potrebbe essere: 

 <?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" 
    "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
 
 <taglib>
   <tlibversion>1.0</tlibversion>
   <jspversion>1.1</jspversion>
   <shortname>simp</shortname>
   <uri>http://www.hachisvertas.net/jcs/taglibs/lycka</uri>
   <info>A simple sample tag library</info>
 
   <tag>
     <name>hola</name>
     <tagclass>org.lcyka.taglibs.miEtiqueta</tagclass>
     <bodycontent>empty</bodycontent>
     <info>Alaba la belleza de mi gata.</info>
   </tag>
 </taglib>

Infine, il server delle applicazioni sostituirà il tag con il codice Java associato, org.lcyka.taglibs.myTag : 

 package org.lcyka.taglibs;
 import ...;
 public class miEtiqueta extends TagSupport {
   public int doStartTag {
     try {
       pageContext.getOut().print("Mi gata es preciosa");
     } catch (IOException ioe) {
     }
     return SKIP_BODY;
   }

E infine il browser mostrerebbe: 

il mio gatto è bellissimo

Tag JSP

Sono i tag appartenenti alla specifica JSP. Forniscono funzionalità di base.

Un primo set di tag fornisce funzionalità a livello di pagina in un modo molto semplice:

  • <jsp:forward> , reindirizza la richiesta a un altro URL
  • <jsp:include> , include il testo di un file all'interno della pagina
  • <jsp:plugin> , scarica un plugin Java (un'applet o un Bean).

Un secondo gruppo consente di manipolare i componenti JavaBean senza conoscere Java.

  • <jsp:useBean> , permette di manipolare un Bean (se non esiste, verrà creato il Bean), specificandone scope, classe e tipo.
  • <jsp:getProperty> , ottiene la proprietà specificata da un bean dichiarato in precedenza e la scrive nell'oggetto risposta.
  • <jsp:setProperty> , imposta il valore di una proprietà di un bean dichiarato in precedenza.

Tag JSTL

Sono forniti da Sun all'interno della distribuzione JSTL .

  • core , iterazioni, condizionali, manipolazione degli URL e altre funzioni generali.
  • xml , per la manipolazione XML e per la trasformazione XML.
  • sql , per gestire le connessioni ai database.
  • i18n , per l'internazionalizzazione e la formattazione di stringhe di caratteri come figure.

Tag Struts TagLib

Distribuito da Apache per funzionare in combinazione con Struts Framework.

  • PHP
  • fagioli
  • HTML
  • logica
  • nidificato
  • vjgp

Etichette personalizzate

In precedenza abbiamo visto un esempio per creare un tag personalizzato archiviato nella nostra libreria di tag.

Per sviluppare tag personalizzati, utilizzeremo l'API delle librerie di tag.

L'API del servlet Java è: 

 javax.servlet.*

L'API JSP si estende da questa API, 

 javax.servlet.jsp.*

Infine, l'API Tag Libraries si estende da quest'ultima, 

 javax.servlet.jsp.tagext.*

Le più rilevanti di questa API sono:

  • interfacce _
    • Tag, che tutti i tag devono implementare.
    • BodyTag estende il precedente e definisce metodi aggiuntivi per ispezionare il corpo di un tag.
  • Le classi
    • BodyContent, un gestore per leggere e scrivere nel corpo di un tag.
    • BodyTagSupport, che implementa l'interfaccia BodyTag.
    • TagAttributeInfo, per ottenere le informazioni degli attributi del tag dichiarato nel TLD.
    • TagData, che contiene i valori degli attributi.
    • TagExtraInfo, per specificare informazioni extra di un tag, come le variabili che introduce nel codice o gli attributi che verranno convalidati.
    • TagInfo, sulla base delle informazioni del TLD.
    • TagLibraryInfo, rappresenta le informazioni di un TLD.
    • TagSupport, implementa l'interfaccia Tag.
    • VariableInfo, contiene informazioni come il tipo e l'ambito delle variabili create o modificate dal tag.

Una descrizione più dettagliata è disponibile all'indirizzo http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/jsp/tagext/package-summary.html

Un altro esempio di tag potrebbe essere il seguente codice Java: 

 package org.lycka.taglibs;
 import ...;
 public class LowerCaseTag extends BodyTagSupport {
   public int doAfterBody() throws JspException {
     try {
       BodyContent body = getBodyContent();
       JspWriter writer = body.getEnclosingWriter();
       String bodyString = body.getString();
       if ( bodyString != null ) {
         writer.print( bodyString.toLowerCase());
       }
     } catch(IOException ioe) {
       throw new JspException("Error: IOException while writing to the user");
     }
     return SKIP_BODY;
   }
 }

Dopo aver trovato l'inizio del tag, il runtime chiamerà prima il metodo doStart() dopo che la classe è stata istanziata. Può restituire uno dei seguenti valori:

  • SKIP_BODY, non elabora il contenuto del corpo del tag.
  • EVAL_BODY_INCLUDE , valuta il corpo del tag.
  • EVAL_BODY_TAG , valuta il corpo del tag e trasmette il risultato a un altro stream archiviato in una proprietà del tag.

Il metodo doAfterBody() dopo l'elaborazione del corpo del tag.

Infine, verrà chiamato il metodo doEndTag(). Puoi restituire:

  • EVAL_PAGE, per continuare l'elaborazione della pagina JSP
  • SKIP_PAGE, per interrompere l'elaborazione della pagina JSP, ad esempio per reindirizzare la pagina

Dichiarato nel descrittore di libreria come 

 <tag>
   <name>lowercase</name>
   <tagclass>org.lycka.taglibs.LowerCaseTag</tagclass>
   <bodycontent>JSP</bodycontent>
   <info>Put body in lowercase.</info>
 </tag>

Utilizzato nella pagina JSP 

 <%@ taglib uri="/taglib/lycka" prefix="lycka" %>
 ...
 <lycka:lowercase>Esto es un EJEMPLO</lycka:lowercase>

E la tua uscita sarebbe 

Questo è un esempio

Vedi anche

Collegamenti esterni

Ottenuto da « https://es.wikipedia.org/w/index.php?title=JavaServer_Pages&oldid=144745104 »