close

JavaServer-sider

Gå til navigasjon Gå til søk
ManchaServer-sider:EME
Dynamisk nettsidedel
Generell informasjon
utvikler Sun Microsystems
Teknisk informasjon
Planlagt inn Java
Støttede plattformer Java EE
Versjoner
Siste stabile versjon 2,3 ()
Lenker

JavaServer Pages (JSP) er en teknologi som hjelper programvareutviklere med å lage dynamiske nettsider basert på HTML og XML , blant andre typer dokumenter. JSP ligner på PHP , men bruker programmeringsspråket Java .

For å distribuere og kjøre JavaServer Pages, kreves det en webserver som støtter servletbeholdere som Apache Tomcat eller Jetty .

TagLibs -> JSP -> Application Server (Servlets) -> Client (nettleser)

Ytelsen til en JSP-side er den samme som den tilsvarende servleten, siden koden er kompilert som alle andre Java-klasser. På sin side vil den virtuelle maskinen dynamisk kompilere delene av applikasjonen som krever den til maskinkode. Dette gjør JSP mer effektiv og mer effektiv enn andre nettteknologier som kjører kode på en rent tolket måte.

Den største fordelen med JSP fremfor andre språk er at Java-språket er et generellt språk som overgår nettverdenen og er egnet for å lage klasser som håndterer forretningslogikk og datatilgang på en ryddig måte. Dette lar deg dele nettapplikasjoner i lag, og etterlater den delen som har ansvaret for å generere HTML-dokumentet i JSP-filen.

En annen fordel er at JSP arver portabiliteten til Java, og det er mulig å kjøre applikasjonene på flere plattformer uten endringer. Det er til og med vanlig at utviklere jobber på én plattform og applikasjonen ender opp med å kjøre på en annen.

Servlets og Java Server Pages (JSPs) er to metoder for å lage dynamiske nettsider på serveren ved å bruke Java-språket. I den forstand ligner de på andre metoder eller språk som PHP , ASP eller CGI , programmer som genererer nettsider på serveren. Imidlertid skiller de seg fra dem på andre ting.

Til å begynne med kjører JSP-er og servlets på en virtuell Java-maskin, noe som betyr at de i prinsippet kan brukes på alle typer datamaskiner, så lenge det er en virtuell Java-maskin for det. Hver servlet (eller JSP, vi vil bruke den om hverandre fra nå av) kjører på sin egen tråd, det vil si i sin egen kontekst; men den begynner ikke å kjøre hver gang den mottar en forespørsel, men fortsetter fra en forespørsel til den neste, slik at ingen tid går bort på å starte den (last program + tolk ). Dens utholdenhet lar den også gjøre en rekke ting mer effektivt: koble til databaser og administrere økter, for eksempel.

JSP-er er faktisk en alternativ måte å lage servlets på siden JSP-koden oversettes til Java-servletkode første gang den påkalles, og deretter er det den nye servletkoden som kjøres og produserer HTML-koden som utgjør responsnettsiden som utdata.

Beskrivelse

JSP kan sees på som en abstraksjon på høyt nivå av Java-servlets. JavaServer-sider oversettes til servlets i sanntid; hver servlet bufres og brukes på nytt til den opprinnelige JSP-en er endret. Med andre ord er JSP-er java-sider for et nettmiljø.

Eksempel på JSP-dokument

Kodeeksempel på en JSP-side: 

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

JSP-er

Eksempel på en JSP-bygning eller "output": 

pakke jsp_servlet;
importer java.util.*;
importer java.io.*;
import javax.servlet.*;
importer javax.servlet.http.*;
importer javax.servlet.jsp.*;
importer javax.servlet.jsp.tagext.*;
import com.foo.bar; //importert som et resultat av <%@  page  import = "com.foo.bar"  %>
saken...
klasse _myservlet implementerer javax.servlet.Servlet, javax.servlet.jsp.HttpJspPage {
	//innsatt som
	//resultat på <%!  int  serverInstanceVariable  =  1 ; %>
	int serverInstanceVariable = 1;
	…
	public void _jspService( javax.servlet.http.HttpServletRequest request,
		javax.servlet.http.HttpServletResponse-svar)
		kaster javax.servlet.ServletException,
		java.io.IOException
	{
		javax.servlet.ServletConfig config = ...;//hent servlet-konfigurasjon
		Objektside = dette;
		PageContext pageContext = …;//hent sidekonteksten for denne forespørselen
		javax.servlet.jsp.JspWriter ut = pageContext.getOut();
		HttpSession session = request.getSession( true );
		…

For å kjøre JSP-sider trenger du en webserver med en webbeholder som samsvarer med JSP- og Servlet-spesifikasjonene. Tomcat 5 er en komplett referanseimplementering for Java Servlet 2.2- og JSP 1.1-spesifikasjonene.

Syntaks

Implisitte variabler

JSP-sider inkluderer visse privilegerte variabler uten behov for å deklarere eller konfigurere dem:

Variabel Klasse
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

Direktiv

De er tagger som det genereres informasjon fra som kan brukes av JSP-motoren. De produserer ikke synlige utdata for brukeren, men konfigurerer heller hvordan JSP-siden skal kjøres.

Syntaksen er: 

 <%@ directiva atributo="valor" %>

De tilgjengelige direktivene er:

  • include: Inkluder innholdet i en fil på siden ved å bruke filattributtet .
<%@ include file="cabecera.html" %>
  • taglib: Importer tagbiblioteker (tagbiblioteker)
<%@ taglib uri="/tags/struts-html" prefix="html" %>
  • page: Spesifiserer attributter relatert til siden som skal gjengis. Attributtene er:
Egenskap Syntaks Utnyttelse
import <%@ page import="class; class" %> Importer Java-klasser og -pakker som skal brukes i JSP-filen.
session <%@ page session="false" %> Spesifiserer om dataene i økten skal brukes; standard til "true".
contentType <%@ page contentType="class; class" %> Spesifiserer MIME-typen til "response"-objektet; som standard "tekst/html; charset=ISO-8859-1".
buffer <%@ page buffer="12KB" %> Buffer brukt av forfatterobjekt "ut"; kan ta verdien av "ingen"; standard "8KB".
errorPage <%@ page errorPage="/path_to_error_page" %> Spesifiserer banen til feilsiden som vil bli påkalt hvis et unntak oppstår under kjøringen av denne JSP-filen.
isErrorPage <%@ page isErrorPage="true" %> Bestemmer om denne JSP-filen er en side for håndtering av unntak. Bare slike sider kan få tilgang til den implisitte variabelen "unntak", som inneholder unntaket som gjorde at feilsiden ble kalt.

Uttalelser

De lar oss deklarere variabler, funksjoner og statiske data. 

 <%! int maxAlumnosClase = 30; %>

Scriptlets

Skriptletter er deler av Java-kode som er innebygd mellom de statiske elementene på siden... 

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

Uttrykk

Uttrykk blir evaluert inne i servleten. De må ikke ende på ";". 

 <%= maxAlumnosClase + 1%>

Følgende eksempel vil sette "title"-attributtet i forespørselsobjektet som tittelen på siden: 

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

Tagger

JSP-tagger for å forenkle koden og gi mer funksjonalitet.

Å utvikle nettsteder ved å bruke tagger har visse fordeler som:

  • legge til rette for læring.
  • lette vedlikeholdet.
  • oppmuntre til modularitet og gjenbruk.
  • forenkle koden og redusere antall linjer som kreves.

Syntaksen vil være: 

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

Når Java-koden genereres for Servlet, vil denne hello -taggen bli tolket av Application Server som tilhørende lycka Tag Library . Dette biblioteket vil bli identifisert i deskriptorfilen til applikasjonen vår (web.xml) med ressursnavnet (URI) /taglib/lycka . 

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

En implementering av denne deskriptorfilen, /WEB-INF/tags/ lycka.tld kan være: 

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

Og til slutt vil applikasjonsserveren erstatte taggen med tilhørende Java-kode, 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;
   }

Og til slutt vil nettleseren vise: 

katten min er vakker

JSP-tagger

De er taggene som tilhører JSP-spesifikasjonen. De gir grunnleggende funksjonalitet.

Et første sett med tagger gir funksjonalitet på sidenivå på en veldig enkel måte:

  • <jsp:forward> , omdirigerer forespørselen til en annen URL
  • <jsp:include> , inkluderer teksten til en fil på siden
  • <jsp:plugin> , laster ned en Java-plugin (en applet eller en Bean).

En andre gruppe lar deg manipulere JavaBean-komponenter uten kunnskap om Java.

  • <jsp:useBean> , lar deg manipulere en Bean (hvis den ikke eksisterer, vil den bli opprettet), og spesifisere dens omfang, klasse og type.
  • <jsp:getProperty> , henter den spesifiserte egenskapen fra en tidligere erklært bønne og skriver den til responsobjektet.
  • <jsp:setProperty> , setter verdien til en egenskap til en tidligere erklært bønne.

JSTL-tagger

De leveres av Sun i JSTL- distribusjonen .

  • kjerne , iterasjoner, betingelser, URL-manipulering og andre generelle funksjoner.
  • xml , for XML-manipulering og for XML-transformasjon.
  • sql , for å administrere tilkoblinger til databaser.
  • i18n , for internasjonalisering og formatering av tegnstrenger som figurer.

Struts TagLib-tagger

Distribuert av Apache for å fungere sammen med Struts Framework.

  • PHP
  • bønner
  • HTML
  • logikk
  • nestet
  • vjgp

Egendefinerte etiketter

Vi har tidligere sett et eksempel for å lage en egendefinert tag lagret i vårt eget tag-bibliotek.

For å utvikle tilpassede tagger vil vi bruke Tag Libraries API.

Java Servlet API er: 

 javax.servlet.*

JSP API strekker seg fra dette API, 

 javax.servlet.jsp.*

Til slutt strekker Tag Libraries API seg fra sistnevnte, 

 javax.servlet.jsp.tagext.*

De mest relevante av denne API-en er:

  • grensesnitt _
    • Tag, som alle tagger må implementere.
    • BodyTag utvider den forrige og definerer flere metoder for å inspisere hoveddelen av en tag.
  • Klassene
    • BodyContent, en behandler for å lese og skrive til brødteksten til en tag.
    • BodyTagSupport, som implementerer BodyTag-grensesnittet.
    • TagAttributeInfo, for å få informasjon om attributtene til taggen som er deklarert i TLD.
    • TagData, som inneholder verdiene til attributtene.
    • TagExtraInfo, for å spesifisere ekstra informasjon om en tag, for eksempel variablene som den introduserer i koden eller attributtene som skal valideres.
    • TagInfo, basert på informasjon fra TLD.
    • TagLibraryInfo, representerer informasjonen til en TLD.
    • TagSupport, implementerer Tag-grensesnittet.
    • VariableInfo, inneholder informasjon som typen og omfanget av variablene opprettet eller modifisert av taggen.

En mer detaljert beskrivelse finner du på http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/jsp/tagext/package-summary.html

Et annet eksempel på en tag kan være følgende Java-kode: 

 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;
   }
 }

Ved å finne starten på taggen vil runtime først kalle opp doStart()-metoden etter at klassen er instansiert. Den kan returnere en av følgende verdier:

  • SKIP_BODY, behandler ikke innholdet i hoveddelen av taggen.
  • EVAL_BODY_INCLUDE , evaluerer hoveddelen av taggen.
  • EVAL_BODY_TAG , evaluerer hoveddelen av taggen og caster resultatet til en annen strøm lagret i en egenskap for taggen.

DoAfterBody()-metoden etter å ha behandlet hoveddelen av taggen.

Til slutt vil doEndTag()-metoden bli kalt. Du kan returnere:

  • EVAL_PAGE, for å fortsette å behandle JSP-siden
  • SKIP_PAGE, for å stoppe behandlingen av JSP-siden, for eksempel for å omdirigere siden

Erklært i biblioteksbeskrivelsen som 

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

Brukes på JSP-siden 

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

Og resultatet ditt ville være 

Dette er et eksempel

Se også

Eksterne lenker

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