JavaServer Pages

In informatica **JavaServer Pages**, usualmente indicate con le abbreviation **JSP** (legite anque alcun vices como **Java Scripting Preprocessor**), es un technologia de programmation web in Java pro le disveloppamento del "logica de presentation" (typicamente secundo le patrono Modello-Vista-Controllator (MVC)) de applicationes Web, pro provider contentos dynamic in formato HTML o XML. Illo se basa sur un ensemble de etiquettas de HTML/XML special, intra un pagina web HTML, con le qual on pote invocar functiones predefinite in forma de codice Java (JSTL) e/o functiones Javascript. In addition, illo permitte de crear bibliothecas de nove etiquettas qui extende le ensemble del etiquettas standard (JSP Custom Tag Library). Le bibliothecas de etiquettas JSP pote esser considerate extensiones independente del platteforma del functionalitate de un servitor web.

## Description
In le contexto del platteforma Java, le technologia JSP es correlate con isto del servlet: al tempore del prime invocation, le paginas web JSP es de facto traducite automaticamente per un compilator JSP a in servlet. Un pagina web JSP pote dunque esser vidite como un representation de alto nivello de un servlet. A causa de iste dependentia conceptual, anque le uso del technologia JSP require le presentia, super le servitor web, de un *[[servlet container]]*, ultra que de un servitor specific JSP dicite "motor JSP" (qui include le compilator JSP); usualmente, *servlet container* e motor JSP es integrate in un unic producto (per exemplo, Tomcat exeque ambe le functiones).

JSP es un technologia alternative in comparation a numerose altere approches al generation de paginas web dynamic, per exemplo PHP, o ASP o le plus traditional CGI. Illo differe de iste technologias non tanto per le typo de contentos dynamic qui pote esser producite, quanto per le architectura interne del programmatura qui constitue le application web (e, de consequentia, sur le tempores de disveloppamento, le portabilitate, le modificabilitate, le performantias, e altere aspectos de qualitate del programmatura).

### Paradigma MVC
Sun Microsystems recommenda de usar le patrono Modello-Vista-Controllator (MVC) con le paginas web JSP de maniera a divider le nivello de presentation ab isto del elaboration del requesta e ab le memorisation del datos. Le normal servlet o pagina web JSP dedicate es usate pro tractar le datos. Post que le eleboration es terminate, le controlo passa a un pagina web JSP qui serve solo a visualisar le rendimento. Iste ultima pagina web JSP deberea continer solo HTML, XML e action e etiquetta JSP; le pagina web deberea facer uso del JavaBeans pro obtener le datos.

In altere terminos in le disveloppamento de un application web le convention vole que in le JSP il ha minus de codice Java possibile e illo presente va reclamar codice Java native (objectos e methodos) implementate in classes separate special dicite exactemente JavaBeans. Iste separation permitte de facto un facile reuso de codice del Javabeans un vice reclamate in un qualcunque puncto requirite del application web.

## Structura de un pagina JSP
Un **pagina JSP** es un documento de texto, scribite con un syntaxe specific, qui representa un pagina web de contento partialmente o totalmente dynamic. Per elaborar le pagina web JSP, le motor JSP produce dynamicamente le pagina web HTML final qui essera presentate al navigator web del usator. Le pagina web JSP pote continer tres typos de elementos, le quales corresponde a tres diverse modos de elaboration: **contentos static**, **directivas** e **scripto**.

### Contentos static
Le contentos static es portiones del pagina web JSP qui debe esser mantenite integralmente in le pagina web generate dynamicamente, sin alcun elaboration. Illos debe dunque esser scribite in le linguage de marcation del qual le cliente pote beneficiar directemente, per exemplo HTML (si le cliente es un navigator web), WML (si le cliente es un telephono mobile qui accede al pagina web in WAP) o XML (varie typos de cliente).

### Directivas
Le directivas JSP pote esser interpretate como commandos al motor JSP. Iste commandos es exequite in un phase de pretractamento, prime que le portiones del pagina web contenente scripto es elaborate. Le duo directivas principal es `include` e `page`.
* `include`: ordina al motor JSP de includer un altere file in isto currente. Illo es un operation equivalente a isto de copiar e collar le contento del file indicate in isto currente. (Un directiva de iste typo es simile a ist previdite per le preprocessator del C/C++). Iste directiva pote esser usate, per exemplo, pro realisar contentos recurrente in diverse paginas web de un sito web.
:
```xml
<%@ include file="fileaincluder.ext" %>
```

* `page`: il ha numerose variationes del directiva `page`, con scopios plus tosto diverse inter illos:
: `page import` corresponde al `import` Java, e indica qual classes essera usate in le resto del documento;
::
```xml
<%@ page import="java.util.*" %> //importa tote le classes del pacchetto java.util
```

: `page contentType` indica in qual formato le documento sia scribite (per exemplo HTML o XML)
::
```xml
<%@ page contentType="text/html" %>
```

: `page errorPage` specifica le "pagina de error" qui debe esser visualisate si le elaboration del pagina web dynamica face fiasco in sequito de verificar si de alcun exception
: `page isErrorPage` indica si isto currente es un pagina de error
::
```xml
<%@ page isErrorPage=false %> //specifica que isto non es un pagina de error
```

: `page isThreadSafe` indica si le servlet generate per le pagina web JSP es *[[thread safe]]*
: `page taglib` indica que le pagina web JSP face uso de un bibliotheca de etiquettas. Le bibliotheca debe esser identificate per un URI (Uniform Resource Identifier)
::
```xml
<%@ taglib prefix="myprefix" uri="taglib/mitaglib.tld" %>
```


### ''Scripting''
Le tertie categoria de elementos presente in un pagina web JSP es fragmentos de codice original in Java. Iste fragmentos de codice es dunque exequite per le Machina Virtual Java e produce in rendimento un texto, qui va contribuer al fonte del pagina web in via de generation. Le invocation de codice Java es le clave del generation de paginas web dynamic in JSP; per exemplo, le paginas web JSP de un sito web de compras ''online'' poterea includer codice Java qui verifica le disponibilitate de un producto e genera in rendimento un pagina web qui reporta iste information.

#### Declarationes
Le pagina web JSP pote includer declarationes de attributos e methodos, introducite per le sequentia `<%!`. Tal attributos e methodos devenira parte del classe "servlet" generate per le compilator JSP (lor position intra le texto del pagina web JSP es irrelevante). Le disveloppator qui ha familiaritate con le technologia servlet pote exploitar iste possibilitate, per exemplo, pro redefinir le "methodos de cyclo de vita" del servlet, como `jspInit`.


```xml
<%! int serverInstanceVariable = 1; %>
```


#### Expressiones
Le expressiones es introducite per le sequentia `<%=`, e contine un qualcunque expression Java. Durante le elaboration del pagina web JSP, le expression es evalutate per le motor JSP, le resultato es convertite in serie de characteres, e le serie immergite in le codice HTML/XML in le puncto correspondente a isto ubi le expression mesme appareva.

```xml
<body>
	Vos es le usator registrate nr. <%= registroUtenti.conta() %>
<body>
```


#### Scriptlet
Le scriptlets es fragmentos de codice immergite in un qualunque puncto del texto. Conceptualmente, on pote immaginar que durante le construction del pagina web dynamic, le motor JSP include sin elaborationes le contentos static, in procedente ab alto verso le basso in le documento, e exeque immediatemente eventual scriptlet incontrate durante le operation. Technicamente, iste scriptlets es includite in le methodos del servlet generate per le pagina web JSP, intra le methodos qui produce le responsa a un requesta HTTP.

#### Variabiles implicite
Le elementos de codice in un pagina web JSP pote referer se a un ensemble de variabiles predefinite:
: `out`: representa le fluxo de rendimento super le qual le pagina web es producite. On tracta de un objecto de classe `JSPWriter`. Su uso es sovente implicite (per exemplo in le expressiones), sed si il es necessari, on pote referer se a iste variabile
: `page`: representa le servlet generate per le pagina web JSP
: `pageContext`: un objecto de classe `PageContext`, qui contine datos associate al pagina web. Le objecto pote esser transferite ab un pagina web JSP a un altere
: `request`: le objecto de classe `HttpServletRequest` qui representa le requesta HTTP qui ha portate al activation del pagina web JSP/servlet
: `response`: le objecto de classe `HttpServletResponse` qui representa le responsa HTTP a inviar
: `session`: le objecto de classe `HttpSession` qui representa le session HTTP intra le qual le pagina web JSP ha essite invocate 
: `application`: illo permitte de acceder e de memorisar le objectos pro render illos accessibile a un qualcunque usator e modificabile de cata pagina web
: `config`: illo es sovente lassate inusate, visto que le informationes mittite a disposition per iste objecto implicite es generalmente ponite e relevate in automatico.

### Actiones JSP
Le actiones JSP es etiquettas XML qui permitte de controlar alcun aspectos del comportamento del servitor web. Alcun exemplos es le sequentes:
:``: cede le controlo a un altere pagina web JSP, con retorno del controlo a elaboration terminate; simile a un appello de procedura
:``: cede le controlo, definitivemente, a un altere pagina web JSP
:``: introduce un parametro additional in le contexto de actiones como `include` e `forward`.

## Bibliothecas de etiquettas JSP
Ultra al actiones predefinite, le disveloppatores pote adder *action* disveloppate per illes pro usar le API pro le extensiones del etiquettas JSP. Le disveloppatores scribe un classe Java qui implementa un del interfacies Tag e provide un descrition XML del bibliotheca in le qual on specifica le etiquettas e le classes Java qui lo implementa.

Considera le sequente codice:

```xml
<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>
...
<myprefix:myaction> <%-- le etiquetta de apertura %>
...
</myprefix:myaction> <%-- le etiquetta de clausura %>
...
```

Le compilator JSP cargara le file `mytaglib.tld` e videra que le etiquetta `myaction` es implementate per le classe `MyActionTag`. Le prime vice que le etiquetta es usate in le file, un instantia de `MyActionTag` essera create. Dunque (e cata vice que le etiquetta es usate), le methodo `doStartTag()` essera invocate quando le etiquetta de apertura es incontrate. Le resultato del etiquetta de apertura es examinate e on determina como tractar le contento del etiquetta. Le contento es le texto inter le etiquettas de apertura e de clausura. Le methodo `doStrtTag()` pote restituer un del valores sequente:
* `SKIP_BODY` - le contento del etiquetta non essera examinate.
* `EVAL_BODY_INCLUDE` - illo tracta le contento del etiquetta.
* `EVAL_BODY_TAG` - illo tracta le contento del TAG e invia le resultato in le stream de rendimento.
**NOTA**: si le etiquetta extende le classe `BodyTagSupport` illo essera invocate quando le corpore ha essite tractate a pena ante invocar le methodo `doEndTag`. Iste methodo es usate pro implementar constructiones de buclas.

Quando le etiquetta de clausura es incontrate, le methodo `doEndTag` es invocate. Iste methodo pote restituer un del valores sequente.
* `EVAL_PAGE` - illo indica que le resto del pagina web JSP debe esser tractate.
* `SKIP_PAGE` - illo indica que il non debe haber ulterior elaborationes. Le controlo lassa le pagina web JSP. Illo es empleate per le actiones in avante.

Le etiquetta `MyAction` describite in alto poterea haber un implementation simile a iste:


```java
public class MyActionTag extends TagSupport 
{
	//Releases all instance variables.
	public void release() {...}

	public MyActionTag() { ... }
		
	//called for the start tag
	public int doStartTag() { ... }

	//called at the end tag
	public int doEndTag() throws JspTagException { ... }
}
```

## Internationalisation
Le internationalisation del paginas web JSP es obtenite mediante le mesme technica usate in le normal applicationes Java, in altere parolas in usante le *[[resource bundles]]*.

## Exemplos
Le sequente fragmento suggere como on poterea crear un intestation a diverse paginas web, de sorta que le presentation pote variar in alcun detalio (per exemplo, per render non cliccabile le ligamine al pagina web currente):


```xml
<jsp:include page="intestation.jsp" > //include un parte standard
	<jsp:param name="istepagina" value="contacts"/> //forni informationes specific
</jsp:include>
```


Le proxime exemplo illustra como diriger in modo uniforme le insertion de un applet Java in un pagina web. Ante le advento del etiquetta `OBJECT`, il non existeva un methodo univoc pro integrar le applet Java. Iste etiquetta es bastante tenue e on spera que in le futuro illo essera integrate in maniera de supportar attributos dynamic. Al stato actual, le etiquetta non supporta de appellar dynamicmente al applet Java; per exemplo, si il ha un applet Java qui designa un grafico qui require que le punctos sia passate como parametros, on non pote usar le etiquetta `jsp:params` a minus que le punctos non es constante. Il non es possibile dunque, iterar super un ResultSet pro crear le etiquetta de `jsp:param`. Bisogna dunque diriger a mano cata etiquetta de `jsp:param`; cata un de iste etiquettas comocunque pote haber un nomine dynamic e un contento dynamic.

```xml
<jsp:plugin type=applet height="100%" width="100%"
	archive="myjarfile.jar,myotherjar.jar"
	codebase="/applets"
	code="com.foo.MyApplet" >
	<jsp:params>
		<jsp:param name="enableDebug" value="true" />
	</jsp:params>
	<jsp:fallback>
		Your browser does not support applets.
	</jsp:fallback>
</jsp:plugin>
```


In le sequente fragmento, un objecto con nomine `myBean` es create o rendite accessibile. Illo pertine al classe `MyBean` del pacchetto `com.foo` e qui essera accessibile per tote le duration del requesta. Isto significa que le objecto essera accessibile e valide in tote le paginas web qui es riappellate per le etiquetta `jsp:include` e `jsp:forward` ab le pagina web qui primemente ha recipite le requesta. Le attributo `scope` pote haber le sequente valores:
* `request` - le attributo essera valide in toto pro tote le duration del requesta. Quando le requesta habera essite processate per tote le paginas web JSP, le objecto essera dereferentiate.
* `page` - le attributo essera disponibile solo per le pagina web currente.
* `session` - le attributo es disponibile pro tote le duration del session del usator.
* `application` - le attributo es disponibile pro cata instantia e non es jammais dereferentiate. Illo es lo mesme de definir un variabile static o global.

```xml
<jsp:useBean id="myBean" class="com.foo.MyBean" scope="request" />
<jsp:getProperty name="myBean" property="lastChanged" />
<jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />
```


## JSP 2.0
Le nove version del specification JSP include nove functionalitate designate a incrementar le productivitate del disveloppator. In detalio:
* un Expression Language (EL) qui permitte al disveloppatores de crear patronos de stilo (como illos de Velocity);
* un methodo plus simple e veloce de crear nove etiquettas.

## Ligamines externe
* official
* Tutorial official Sun
* Tutorial e guide free