close

JavaServer sider

Gå til navigation Gå til søg
ManchaServer sider:EME
Dynamisk webside del
Generel information
Udvikler Sun Microsystems
Teknisk information
Planlagt ind Java
Understøttede platforme Java EE
Versioner
Seneste stabile version 2,3 ()
Links

JavaServer Pages (JSP) er en teknologi, der hjælper softwareudviklere med at skabe dynamiske websider baseret på HTML og XML , blandt andre typer dokumenter. JSP ligner PHP , men bruger programmeringssproget Java .

For at implementere og køre JavaServer Pages kræves en webserver , der understøtter servlet -containere såsom Apache Tomcat eller Jetty .

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

Ydeevnen af ​​en JSP-side er den samme som den tilsvarende servlet, da koden er kompileret som enhver anden Java-klasse. Til gengæld vil den virtuelle maskine dynamisk kompilere de dele af applikationen, der kræver det til maskinkode. Dette gør JSP performer og mere effektiv end andre webteknologier, der eksekverer kode på en rent fortolket måde.

Den største fordel ved JSP i forhold til andre sprog er, at Java-sproget er et generelt sprog, der overgår webverdenen og er velegnet til at skabe klasser, der håndterer forretningslogik og dataadgang på en pæn måde. Dette giver dig mulighed for at adskille webapplikationer i lag, hvilket efterlader den del, der har ansvaret for at generere HTML-dokumentet i JSP-filen.

En anden fordel er, at JSP arver Javas portabilitet, og det er muligt at køre applikationerne på flere platforme uden ændringer. Det er endda almindeligt, at udviklere arbejder på én platform, og applikationen ender med at køre på en anden.

Servlets og Java Server Pages (JSP'er) er to metoder til at skabe dynamiske websider på serveren ved hjælp af Java-sproget. I den forstand ligner de andre metoder eller sprog, såsom PHP , ASP eller CGI'er , programmer, der genererer websider på serveren. De adskiller sig dog fra dem på andre ting.

Til at begynde med kører JSP'er og servlets på en Java virtuel maskine, hvilket betyder, at de i princippet kan bruges på enhver type computer, så længe der er en Java virtuel maskine til det. Hver servlet (eller JSP, vi vil bruge den i flæng fra nu af) kører på sin egen tråd, det vil sige i sin egen kontekst; men den begynder ikke at udføre hver gang den modtager en anmodning, men fortsætter fra den ene anmodning til den næste, så der ikke spildes nogen tid på at påkalde den (indlæs program + tolk ). Dens vedholdenhed giver den også mulighed for at gøre en række ting mere effektivt: at oprette forbindelse til databaser og administrere sessioner, for eksempel.

JSP'er er faktisk en alternativ måde at skabe servlets på, da JSP-koden oversættes til Java-servlet-kode første gang, den kaldes, og derefter er det den nye servlet-kode, der udføres og producerer HTML-koden, der udgør responswebsiden, som output.

Beskrivelse

JSP kan ses som en abstraktion på højt niveau af Java-servlets. JavaServer-sider oversættes til servlets i realtid; hver servlet cachelagres og genbruges, indtil den originale JSP er ændret. Med andre ord er JSP'er java-sider til et webmiljø.

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-build eller "output": 

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

For at køre JSP-sider skal du bruge en webserver med en webcontainer, der overholder JSP- og Servlet-specifikationerne. Tomcat 5 er en komplet referenceimplementering til Java Servlet 2.2- og JSP 1.1-specifikationerne.

Syntaks

Implicitte variabler

JSP-sider indeholder visse privilegerede variabler uden behov for at erklære 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

Direktiver

De er tags, hvorfra der genereres information, som kan bruges af JSP-motoren. De producerer ikke synligt output til brugeren, men konfigurerer snarere, hvordan JSP-siden vil blive eksekveret.

Dens syntaks er: 

 <%@ directiva atributo="valor" %>

De tilgængelige direktiver er:

  • include: Inkluder indholdet af en fil på siden ved hjælp af filattributten .
<%@ include file="cabecera.html" %>
  • taglib: Importer tagbiblioteker (tagbiblioteker)
<%@ taglib uri="/tags/struts-html" prefix="html" %>
  • page: Specificerer attributter relateret til siden, der skal gengives. Attributterne er:
Attribut Syntaks Udnyttelse
import <%@ page import="class; class" %> Importer Java-klasser og -pakker, der skal bruges i JSP-filen.
session <%@ page session="false" %> Angiver, om dataene i sessionen skal bruges; standard til "sand".
contentType <%@ page contentType="class; class" %> Angiver MIME-typen for "response"-objektet; som standard "text/html; charset=ISO-8859-1".
buffer <%@ page buffer="12KB" %> Buffer brugt af forfatterobjekt "ud"; kan tage værdien af ​​"ingen"; standard "8KB".
errorPage <%@ page errorPage="/path_to_error_page" %> Angiver stien til den fejlside, der vil blive fremkaldt, hvis der opstår en undtagelse under udførelsen af ​​denne JSP-fil.
isErrorPage <%@ page isErrorPage="true" %> Bestemmer, om denne JSP-fil er en undtagelseshåndteringsside. Kun sådanne sider kan få adgang til den implicitte variabel "undtagelse", som indeholder den undtagelse, der forårsagede, at fejlsiden blev kaldt.

Udsagn

De giver os mulighed for at erklære variabler, funktioner og statiske data. 

 <%! int maxAlumnosClase = 30; %>

Scriptlets

Scriptlets er stykker Java-kode, der er indlejret mellem de statiske elementer på siden... 

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

Udtryk

Udtryk evalueres inde i servlet'en. De må ikke ende med ";". 

 <%= maxAlumnosClase + 1%>

Følgende eksempel ville sætte attributten "title" indeholdt i anmodningsobjektet som titlen på siden: 

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

Tags

JSP-tags for at forenkle koden og give mere funktionalitet.

Udvikling af websteder ved hjælp af tags har visse fordele, såsom:

  • lette læring.
  • lette vedligeholdelsen.
  • fremme modularitet og genbrug.
  • forenkle koden og reducere antallet af krævede linjer.

Dens syntaks ville være: 

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

Når Java-koden genereres til Servlet, vil dette hej -tag blive fortolket af applikationsserveren som tilhørende lycka - tagbiblioteket . Dette bibliotek vil blive identificeret i deskriptorfilen i vores applikation (web.xml) med ressourcenavnet (URI) /taglib/lycka . 

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

En implementering af denne deskriptorfil, /WEB-INF/tags/ lycka.tld kunne 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 endelig vil applikationsserveren erstatte tagget med dets 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 endelig ville browseren vise: 

min kat er smuk

JSP-tags

Det er de tags, der tilhører JSP-specifikationen. De giver grundlæggende funktionalitet.

Et første sæt tags giver funktionalitet på sideniveau på en meget enkel måde:

  • <jsp:forward> , omdirigerer anmodningen til en anden URL
  • <jsp:include> , inkluderer teksten fra en fil på siden
  • <jsp:plugin> , downloader et Java-plugin (en applet eller en Bean).

En anden gruppe giver dig mulighed for at manipulere JavaBean-komponenter uden kendskab til Java.

  • <jsp:useBean> , giver dig mulighed for at manipulere en Bean (hvis den ikke findes, vil Beanen blive oprettet), og specificerer dens omfang, klasse og type.
  • <jsp:getProperty> , henter den angivne egenskab fra en tidligere erklæret bean og skriver den til responsobjektet.
  • <jsp:setProperty> , indstiller værdien af ​​en egenskab for en tidligere erklæret bønne.

JSTL-tags

De leveres af Sun i JSTL- distributionen .

  • kerne , iterationer, conditionals, URL-manipulation og andre generelle funktioner.
  • xml , til XML-manipulation og til XML-Transformation.
  • sql , til at administrere forbindelser til databaser.
  • i18n , til internationalisering og formatering af tegnstrenge som figurer.

Struts TagLib tags

Distribueret af Apache til at arbejde sammen med Struts Framework.

  • PHP
  • bønner
  • HTML
  • logik
  • indlejret
  • vjgp

Brugerdefinerede etiketter

Vi har tidligere set et eksempel på at lave et brugerdefineret tag gemt i vores eget tagbibliotek.

For at udvikle brugerdefinerede tags vil vi bruge Tag Libraries API.

Java Servlet API er: 

 javax.servlet.*

JSP API strækker sig fra denne API, 

 javax.servlet.jsp.*

Endelig strækker Tag Libraries API sig fra sidstnævnte, 

 javax.servlet.jsp.tagext.*

De mest relevante af denne API er:

  • grænseflader _
    • Tag, som alle tags skal implementere.
    • BodyTag udvider den forrige og definerer yderligere metoder til at inspicere et tags brødtekst.
  • Klasserne
    • BodyContent, en handler til at læse og skrive til et tags brødtekst.
    • BodyTagSupport, som implementerer BodyTag-grænsefladen.
    • TagAttributeInfo, for at få oplysninger om attributterne for tagget, der er erklæret i TLD'et.
    • TagData, som indeholder attributternes værdier.
    • TagExtraInfo, for at specificere ekstra information om et tag, såsom de variabler, som det introducerer i koden eller de attributter, der vil blive valideret.
    • TagInfo, baseret på oplysninger fra TLD.
    • TagLibraryInfo, repræsenterer informationen fra en TLD.
    • TagSupport, implementerer Tag-grænsefladen.
    • VariableInfo, indeholder oplysninger såsom typen og omfanget af de variabler, der er oprettet eller ændret af tagget.

En mere detaljeret beskrivelse kan findes på http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/jsp/tagext/package-summary.html

Et andet eksempel på et tag kunne 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;
   }
 }

Efter at have fundet starten af ​​tagget, vil runtime først kalde doStart() metoden, efter at klassen er instantieret. Det kan returnere en af ​​følgende værdier:

  • SKIP_BODY, behandler ikke indholdet af taggets brødtekst.
  • EVAL_BODY_INCLUDE , evaluerer tekstens krop.
  • EVAL_BODY_TAG , evaluerer taggets krop og caster resultatet til en anden strøm, der er gemt i en egenskab for tagget.

Metoden doAfterBody() efter at have behandlet tekstens krop.

Til sidst vil doEndTag() metoden blive kaldt. Du kan returnere:

  • EVAL_PAGE for at fortsætte med at behandle JSP-siden
  • SKIP_PAGE, for at stoppe behandlingen af ​​JSP-siden, for eksempel for at omdirigere siden

Erklæret i biblioteksbeskrivelsen som 

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

Brugt på JSP-siden 

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

Og dit output ville være 

Dette er et eksempel

Se også

Eksterne links

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