JavaServer-sider

JSP
Utvidelse	`.jsp`
MIME-type	`application/jsp`
Nettsted	www.oracle.com/technetwork/java/jsp-138432.html

I informatikk er JavaServer Pages , vanligvis indikert med forkortelsen JSP (også noen ganger lest som Java Scripting Preprocessor ), en nettprogrammeringsteknologi i Java for utvikling av presentasjonslogikken (typisk i henhold til MVC -mønsteret ) til webapplikasjoner , som gir innhold dynamisk i HTML- eller XML-format . Den er basert på et sett med spesielle tagger på en HTML-side, med hvilke forhåndsdefinerte funksjoner kan påkalles i form av kode Java ( JSTL ) og / eller JavaScript - funksjoner . I tillegg lar den deg lage nye tag-biblioteker som utvider settet med standard-tagger (JSP Custom Tag Library ). JSP-tag-biblioteker kan betraktes som plattformuavhengige utvidelser av en webservers funksjonalitet .

Beskrivelse

I sammenheng med Java-plattformen er JSP-teknologien korrelert med servletene : på tidspunktet for den første påkallingen blir JSP-sidene faktisk oversatt automatisk av en JSP-kompilator til en servlet . En JSP-side kan da sees på som en representasjon på høyt nivå av en servlet. På grunn av denne konseptuelle avhengigheten krever til og med bruk av JSP-teknologi tilstedeværelsen, på webserveren , av en servletbeholder , samt en spesifikk JSP-server kalt JSP-motoren (som inkluderer JSP-kompilatoren); vanligvis er containerservlet og JSP-motor integrert i ett produkt (for eksempel, Tomcat gjør begge deler).

JSP er en alternativ teknologi til en rekke andre tilnærminger til generering av dynamiske nettsider, for eksempel PHP , eller ASP eller den mer tradisjonelle CGI . Det skiller seg ikke så mye fra disse teknologiene for typen dynamisk innhold som kan produseres, men for den interne arkitekturen til programvaren som utgjør nettapplikasjonen (og følgelig utviklingstider, portabilitet, modifiserbarhet , ytelse og andre aspekter). av programvarekvalitet ).

MVC-paradigme

Sun Microsystems anbefaler å bruke Model-View-Controller- mønsteret med JSP-sider for å dele presentasjonslaget fra forespørselsbehandling og datalagring. Vanlige servlets eller dedikerte JSP-sider brukes til å behandle dataene. Etter at behandlingen er fullført, går kontrollen til en JSP-side som bare brukes til å se utdataene. Denne siste JSP-siden skal bare inneholde HTML- , XML- og JSP-handlinger og -koder; siden bør bruke JavaBeans for å få dataene.

Med andre ord, i utviklingen av en nettapplikasjon dikterer konvensjonen at i JSP er det så lite Java-kode som mulig, og at presenten går til å påkalle innfødt Java-kode (objekter og metoder ) implementert i separate spesialklasser kalt JavaBeans. Denne separasjonen muliggjør enkel gjenbruk av Java-bean-kode når den kalles opp på et hvilket som helst nødvendig punkt i webapplikasjonen.

Strukturen til en JSP-side

En JSP er et tekstdokument, skrevet med en spesifikk syntaks , som representerer en nettside med delvis eller helt dynamisk innhold. Ved å behandle JSP-siden, produserer JSP-motoren dynamisk den endelige HTML-siden som vil bli presentert for brukerens nettleser . JSP-siden kan inneholde tre typer elementer, som tilsvarer tre forskjellige behandlingsmoduser: statisk innhold , direktiver og skript .

Statisk innhold

Statisk innhold er deler av JSP-siden som må bevares i sin helhet på den dynamisk genererte nettsiden, uten noen behandling. Derfor må de skrives på tag-språket som klienten kan bruke direkte, for eksempel HTML (hvis klienten er en nettleser), WML (hvis klienten er en mobiltelefon som får tilgang til siden i WAP ) eller XML (ulike typer av klienten).

Direktiv

JSP-direktiver kan tolkes som kommandoer rettet mot JSP-motoren. Disse kommandoene utføres i en forhåndsbehandlingsfase før de skriptede delene av siden behandles . De to hoveddirektivene er includeog page.

include: Instruerer JSP-motoren til å inkludere en annen fil i den gjeldende. Dette tilsvarer å kopiere og lime inn innholdet i den angitte filen i den gjeldende. (Et slikt direktiv ligner det som forventes av C / C ++- forprosessoren ). Dette direktivet kan for eksempel brukes til å lage gjentagende innhold på forskjellige sider på et nettsted.

<%@ include file="filedaincludere.ext" %>

page: det er mange varianter av direktivet page, med ganske forskjellige formål:

page importtilsvarer importJava, og indikerer hvilke klasser som skal brukes i resten av dokumentet;

<%@ page import="java.util.*" %> //importa tutte le classi del package java.util

page contentTypeangir i hvilket format dokumentet er skrevet (for eksempel HTML eller XML)

<%@ page contentType="text/html" %>

page errorPagespesifiserer "feilsiden" som skal vises hvis dynamisk sidebehandling mislykkes på grunn av et unntak

page isErrorPageindikerer om den gjeldende er en feilside

<%@ page isErrorPage=false %> //specifica che non è una pagina di errore

page isThreadSafeindikerer om servleten generert av JSP-siden er trådsikker

page taglibindikerer at JSP-siden bruker et tag-bibliotek . Biblioteket må identifiseres via en URI (Uniform Resource Identifier )

<%@ taglib prefix="myprefix" uri="taglib/miataglib.tld" %>

Skripting

Den tredje kategorien med elementer på en JSP-side er kildekodebiter (Java). Disse kodefragmentene blir deretter utført av Java Virtual Machine og sender ut en tekst, som bidrar til kilden til nettsiden som genereres. Å påkalle Java-kode er nøkkelen til å generere dynamiske sider i JSP; for eksempel kan JSP-sidene til en nettbutikk inneholde Java-kode som sjekker tilgjengeligheten til et produkt og gir ut en side som rapporterer denne informasjonen .

Erklæringer

JSP-siden kan inkludere attributt- og metodedeklarasjoner , introdusert av sekvensen <%! . Disse attributtene og metodene vil bli en del av "servlet"-klassen generert av JSP-kompilatoren (deres plassering i teksten på JSP-siden er irrelevant). Utvikleren som er kjent med servlet-teknologi kan dra nytte av denne muligheten, for eksempel til å overstyre "livssyklusmetodene" til servlets, som jspInit.

<%! int serverInstanceVariable = 1; %>

Uttrykk

Uttrykk introduseres av sekvensen <% = , og inneholder et hvilket som helst Java-uttrykk. Under behandlingen av JSP-siden blir uttrykket evaluert av JSP-motoren, resultatet konverteres til en streng, og strengen settes inn i HTML / XML-koden på det punktet som tilsvarer det der selve uttrykket vises.

<body>

Sei l'utente registrato nr. <%= registroUtenti.conta() %>

</body>

Scriptlet

Skriptletter er kodebiter som er innebygd hvor som helst i teksten. Konseptuelt kan du forestille deg at under konstruksjonen av den dynamiske nettsiden, vil JSP-motoren inkludere statisk innhold uten prosessering, fortsette fra topp til bunn i dokumentet, og umiddelbart utføre eventuelle scriptlets som oppstår under operasjonen. Teknisk sett er disse scriptlets inkludert i servletmetodene som genereres av JSP-siden, innenfor metodene som produserer svaret på en HTTP -forespørsel .

Implisitte variabler

Kodeelementer i en JSP-side kan referere til et sett med forhåndsdefinerte variabler:

out: representerer utdatastrømmen som nettsiden er produsert på. Det er et klasseobjekt JSPWriter. Bruken er ofte implisitt (for eksempel i uttrykk), men denne variabelen kan refereres til om nødvendig

page: representerer servleten generert av JSP-siden

pageContext: et klasseobjekt PageContext, som inneholder data knyttet til hele siden. Objektet kan overføres fra en JSP-side til en annen

request- Klasseobjektet som HttpServletRequestrepresenterer HTTP -forespørselen som førte til at JSP/servlet-siden ble aktivert

response: klasseobjektet som HttpServletResponserepresenterer HTTP-svaret som skal sendes

session: klasseobjektet som HttpSessionrepresenterer HTTP-økten der JSP-siden ble påkalt

application: lar deg få tilgang til og lagre objekter for å gjøre dem tilgjengelige for enhver bruker og redigerbare fra hvilken som helst side

config: den blir ofte stående ubrukt, siden informasjonen som gjøres tilgjengelig av dette implisitte objektet vanligvis settes og oppdages automatisk.

JSP-handlinger

JSP-handlinger er XML -koder som lar deg kontrollere visse aspekter av webserverens oppførsel . Noen eksempler er følgende:

jsp:include: gir kontrollen til en annen JSP-side, med retur av kontrollen på slutten av behandlingen; ligner på et prosedyrekall

jsp:forward: gir kontroll, permanent, til en annen JSP-side

jsp:param: introduserer en tilleggsparameter i sammenheng med handlinger som includeog forward.

JSP Tag Libraries

I tillegg til de forhåndsdefinerte handlingene, kan utviklere legge til handlinger utviklet av dem ved å bruke API-ene for JSP-tagutvidelsen. Utviklere skriver en Java-klasse som implementerer et av Tag-grensesnittene og gir en XML-beskrivelse av biblioteket der taggene og java-klassene som implementerer dem er spesifisert.

La oss vurdere følgende kode:

<% @ taglib uri = "mytaglib.tld" prefiks = "mitt prefiks"%>
 ...
<myprefix: myaction> <% - åpningstaggen%>
 ...
</ myprefix: myaction> <% - den avsluttende taggen%>
...

JSP-kompilatoren vil laste mytaglib.tld -filen og se at 'myaction'-taggen er implementert av 'MyActionTag'-klassen. Første gang taggen brukes i filen, vil 'MyActionTag' bli instansiert. Deretter (og hver gang taggen brukes), vil ' doStartTag ()'- metoden bli påkalt når åpningstaggen påtreffes. Resultatet av åpningstaggen undersøkes og det bestemmes hvordan innholdet i koden skal behandles. Innholdet er teksten mellom åpnings- og avslutningstaggen. Metoden doStartTag () kan returnere én av følgende verdier:

SKIP_BODY - innholdet i taggen vil ikke bli skannet.
EVAL_BODY_INCLUDE - behandle innholdet i taggen.
EVAL_BODY_TAG - behandle innholdet i TAG-en og send resultatet til utdatastrømmen.

MERK : Hvis taggen utvider BodyTagSupport -klassen, vil den bli påkalt når brødteksten har blitt behandlet like før doEndTag- metoden påkalles . Denne metoden brukes til å implementere sløyfekonstruksjoner.

Når den avsluttende taggen oppdages, påkalles doEndTag- metoden . Denne metoden kan returnere en av følgende verdier.

EVAL_PAGE - indikerer at resten av JSP-siden skal behandles.
SKIP_PAGE - indikerer at det ikke skal være ytterligere behandling. Kontrollen forlater JSP-siden. Den brukes til fremadrettede handlinger.

MyAction-taggen beskrevet ovenfor kan ha en implementering som ligner denne:

public class MyActionTag utvider TagSupport {
   // Slipper alle instansvariabler.
   offentlig ugyldig utgivelse () {...}

   offentlig MyActionTag () {...}

   // etterlyste startkoden
   public int doStartTag () {...}

   // kalt på slutten tag
   public int doEndTag () kaster JspTagException {...}
}

Internasjonalisering

Internasjonalisering av JSP-sider oppnås gjennom samme teknikk som brukes i vanlige Java-applikasjoner, det vil si ved bruk av ressursbunter .

Eksempler

Følgende utdrag foreslår hvordan du kan lage en overskrift til forskjellige nettsider, slik at presentasjonen kan variere i noen detalj (for eksempel gjøre koblingen til gjeldende side ikke-klikkbar):

<jsp: include page = "header.jsp"> // inkluderer en standard del
<jsp: param name = "denne siden" verdi = "kontakter" /> // Jeg oppgir spesifikk informasjon
</ jsp: include>

Det neste eksemplet illustrerer hvordan du konsekvent administrerer innsetting av en applet på en nettside. Før bruken av <OBJECT> -taggen var det ingen unik måte å integrere appleter på. Denne taggen er ganske sparsom og forhåpentligvis i fremtiden vil den bli integrert for å støtte dynamiske attributter. Foreløpig støtter ikke taggen dynamiske anrop til appleten; for eksempel, hvis du har en applet som tegner en graf som krever at punkter sendes som parametere, kan du ikke bruke jsp: params -taggen med mindre punktene er konstante. Det er derfor ikke mulig å iterere over et ResultSet for å lage jsp: param-tagger. Vi må derfor administrere hver jsp-tag for hånd: param; hver av disse taggene kan imidlertid ha et dynamisk navn og dynamisk innhold.

<jsp: plugin type = applet høyde = "100%" width = "100%"
      arkiv = "myjarfile.jar, myotherjar.jar"
      kodebase = "/ appleter"
      code = "com.foo.MyApplet">
  <jsp: params>
     <jsp: param name = "enableDebug" verdi = "true" />
  </ jsp: params>
  <jsp: fallback>
    Nettleseren din støtter ikke appleter.
  </ jsp: fallback>
</ jsp: plugin>

I det følgende utdraget blir et objekt med navnet myBean opprettet eller gjort tilgjengelig som tilhører MyBean -klassen til com.foo- pakken og som vil være tilgjengelig så lenge forespørselen varer. Dette betyr at objektet vil være tilgjengelig og gyldig på alle sider som kalles opp gjennom <jsp: include> og <jsp: forward> taggene fra siden som først mottok forespørselen. Omfang - attributtet kan ha følgende verdier:

forespørsel - attributtet vil være gyldig i alt så lenge forespørselen varer. Når forespørselen er behandlet av alle JSP-sider, vil objektet bli avvist.
side – attributtet vil kun være tilgjengelig for gjeldende side.
session – attributtet er tilgjengelig så lenge brukerens økt varer.
applikasjon - attributtet er tilgjengelig for alle forekomster og blir aldri referert til. Det er det samme som å definere en statisk eller global variabel.

<jsp: useBean id = "myBean" class = "com.foo.MyBean" scope = "request" />
<jsp: getProperty name = "myBean" egenskap = "lastChanged" />
<jsp: setProperty name = "myBean" egenskap = "lastChanged" verdi = "<% = ny dato ()%>" />

JSP 2.0

Den nye versjonen av JSP-spesifikasjonen inkluderer nye funksjoner som tar sikte på å øke utviklerproduktiviteten. I detalj:

et Expression Language (EL) som lar utviklere lage stilmaler (som de til Velocity );
en raskere og enklere måte å lage nye tagger på.

Relaterte elementer

Andre prosjekter

Wikimedia Commons inneholder bilder eller andre filer på JavaServer-sider

Eksterne lenker

Offisiell side , på oracle.com .
Offisiell Sun-opplæring , på java.sun.com .
Gratis veiledninger og guider på courses.coreservlets.com . Hentet 12. oktober 2006 (arkivert fra originalen 19. januar 2007) .