Als u de mogelijkheid hebt gehad om web applicaties te bouwen met behulp van technologieën zoals Common Gateway Interface (CGI) en servlets, bent u gewend aan het idee om een programma te schrijven om de hele pagina te genereren (het statische en het dynamische deel) met hetzelfde programma. Als u op zoek bent naar een oplossing waarin u de twee delen kunt scheiden, zoek dan niet verder. JavaServer Pages (JSP) zijn hier.
met JSP-pagina ‘ s kunt u front-end-presentatie scheiden van business logic (Midden-en back-end-lagen). Het is een grote snelle applicatie ontwikkeling (RAD) benadering van webapplicaties. Deze serie artikelen biedt een hands-on tutorial waarin wordt uitgelegd hoe u moderne webapplicaties voor de markt van vandaag en morgen te ontwikkelen. Deze serie begint met dit artikel, waarin de concepten en voordelen van JSP-technologie worden uitgelegd, en laat u vervolgens zien hoe u deze opwindende technologie kunt gebruiken en hoe u herbruikbare componenten kunt maken voor het verwerken van formulieren.
het dynamische Web
het Web is geëvolueerd van een netwerkgebaseerd hypermedia gedistribueerd informatiesysteem dat statische informatie biedt naar een marktplaats voor het verkopen en kopen van goederen en diensten. De steeds geavanceerdere toepassingen om deze markt mogelijk te maken vereisen een technologie voor het presenteren van dynamische informatie.
oplossingen van de eerste generatie omvatten CGI, een mechanisme voor het uitvoeren van externe programma ‘ s via een webserver. Het probleem met CGI scripts is schaalbaarheid; een nieuw proces wordt gemaakt voor elke aanvraag.
oplossingen van de tweede generatie omvatten webserververkopers die plug-ins en API ‘ s voor hun servers leveren. Het probleem is dat hun oplossingen waren specifiek voor hun server Producten. Zo heeft Microsoft Active Server Pages (ASP) geleverd, waardoor het makkelijker is om dynamische content te maken. Hun oplossing werkte echter alleen met Microsoft IIS of persoonlijke webserver. Daarom, als je ASP wilde gebruiken, moest je jezelf committeren aan Microsoft-producten en zou je niet genieten van de Vrijheid van het selecteren van je favoriete webserver en besturingssysteem!
een andere tweede generatie technologie die vrij populair is in enterprise computing is servlets. Servlets maken het makkelijker om server-side applicaties te schrijven met behulp van Java-technologie. Het probleem met CGI of servlets is echter dat je de levenscyclus van schrijven, compileren en implementeren moet volgen.
JSP pages zijn een oplossing van de derde generatie die gemakkelijk kan worden gecombineerd met een aantal oplossingen van de tweede generatie, waardoor dynamische inhoud wordt gecreëerd en het gemakkelijker en sneller wordt om webgebaseerde applicaties te bouwen die werken met een verscheidenheid aan andere technologieën.: webservers, webbrowsers, toepassingsservers en andere ontwikkeltools.JavaServer Pages (JSP)
de JSP-technologie is een open, vrij beschikbare specificatie ontwikkeld door Sun Microsystems als een alternatief voor Microsoft ‘ s Active Server Pages (ASP) – technologie en een belangrijk onderdeel van de Java 2 Enterprise Edition (J2EE) – specificatie. Veel van de commercieel beschikbare applicatieservers (zoals BEA WebLogic, IBM WebSphere, Live JRun, Orion, enzovoort) ondersteunen al JSP-technologie.
JSP versus ASP
JSP en ASP leveren vergelijkbare functionaliteit. Beide gebruiken tags om ingebedde code in een HTML-pagina, session tracking en database-verbinding mogelijk te maken. Enkele van de triviale verschillen zijn:
- ASP-pagina ’s zijn geschreven in VBScript en JSP-pagina’ s zijn geschreven in de programmeertaal Java. Daarom zijn JSP-pagina ’s platformonafhankelijk en ASP-pagina’ s niet.
- JSP-pagina ’s gebruiken JavaBeans-technologie als de componentarchitectuur en ASP-pagina’ s gebruiken ActiveX-componenten.
naast deze triviale verschillen, zijn er een aantal belangrijke verschillen die u kunnen helpen bij het kiezen van een technologie voor uw organisatie:
- snelheid en schaalbaarheid : hoewel ASP-pagina ‘ s in de cache worden geplaatst, worden ze altijd geïnterpreteerd. JSP-pagina ‘ s worden daarentegen gecompileerd in Java-servlets en geladen in het geheugen de eerste keer dat ze worden aangeroepen, en uitgevoerd voor alle volgende oproepen. Dit geeft JSP pagina ’s aspeed en schaalbaarheid voordeel ten opzichte van ASP pagina’ s.
- uitbreidbare Tags: JSP-pagina ‘ s hebben een geavanceerde functie die bekend staat als uitbreidbare tags. Dit mechanisme stelt ontwikkelaars in staat om aangepaste tags te maken. Met andere woorden, extensible tags kunt u de syntaxis van de JSP pages tag uitbreiden. Dit kan niet met ASP pagina ‘ s.
- keuzevrijheid: tenzij u Chili!installeertSoft ASP, ASP-pagina ‘ s werken alleen met Microsoft IIS en persoonlijke webserver. Het gebruik van ASP-pagina ’s vereist een verbintenis met Microsoft-producten, terwijl JSP-pagina’ s u niet binden aan een specifieke webserver of besturingssysteem. JSP pagina ‘ s worden steeds een breed gedragen standaard.
voor een meer gedetailleerde vergelijking tussen JSP-pagina ’s en ASP-pagina’ s, zie JSP en ASP vergelijken.
softwareomgeving
om JSP-pagina ‘ s te draaien, hebt u een webserver nodig met een webcontainer die voldoet aan de specificaties van JSP en servlet. De webcontainer wordt uitgevoerd op de webserver en beheert de uitvoering van alle JSP-pagina ‘ s en servlets die op die webserver draaien. Tomcat 3.2.1 is een complete referentie-implementatie voor de Java Servlet 2.2 en JSP 1.1 specificaties. Download en installeer binaire versies van Tomcat.
om Tomcat te configureren:
- Stel de omgevingsvariabele
JAVA_HOMEin om naar de rootdirectory van uw Java 2 Standard Edition (J2SE) installatie te verwijzen. - Stel de omgevingsvariabele
TOMCAT_HOMEin om naar de rootdirectory van uw Tomcat-installatie te verwijzen. - om Tomcat te starten, gebruik
TOMCAT_HOME/bin/startup.batvoor windows ofstartup.shvoor UNIX.
standaard zal het luisteren beginnen op poort 8080. - Sla uw
.jspbestanden op inTOMCAT_HOME/webapps/examples/jspen uw JavaBeans-klassen inTOMCAT_HOME/webapps/examples/web-inf/classes.
Opmerking: Als u onder Windows werkt, kunt u een Out of space environment-fout krijgen wanneer u Tomcat probeert te starten. Er zijn twee manieren om dit op te lossen: verander de initiële geheugeninstelling van het DOS venster naar een waarde groter dan 3200 of bewerk de configuratie.sys-bestand en voeg de volgende regel toe: SHELL=c:\PATHTO\command.com /E:4096 /P.
hoe JSP pagina ‘ s werken
een JSP pagina is in principe een webpagina met traditionele HTML en bits Java code. De bestandsextensie van een JSP pagina is”.jsp “liever dan”.html “or”.htm”, en dat vertelt de server dat deze pagina vereist speciale behandeling die zal worden uitgevoerd door een server extensie of een plug-in. Hier is een eenvoudig voorbeeld:
monster 1: Datum.jsp
<HTML><HEAD><TITLE>JSP Example</TITLE></HEAD><BODY BGCOLOR="ffffcc"><CENTER><H2>Date and Time</H2><% java.util.Date today = new java.util.Date();out.println("Today's date is: "+today);%></CENTER> </BODY> </HTML> dit voorbeeld bevat traditionele HTML en wat Java code. De tag <% identificeert het begin van een scriptlet, en de tag %> identificeert het einde van een scriptlet. Wanneer date.jsp wordt opgevraagd vanuit een webbrowser, ziet u iets dat lijkt op Figuur 1.
figuur 1: Datum aanvragen.jsp
achter de schermen
wanneer deze pagina (date.jsp) wordt aangeroepen, zal deze worden gecompileerd (door de JSP-engine) in een java servlet. Op dit punt wordt de servlet net als elke andere servlet door de servlet Motor afgehandeld. De servlet engine laadt dan de servlet klasse (met behulp van een klasse loader) en voert het uit om dynamische HTML te maken om naar de browser te worden verzonden, zoals getoond in Figuur 2. In dit voorbeeld maakt de servlet een Date object en schrijft het als een tekenreeks naar het out object, dat een uitvoerstroom naar de browser is.
Figuur 2: Request / Response Flow bij het aanroepen van een JSP
de volgende keer dat de pagina wordt opgevraagd, voert de JSP-engine de reeds geladen servlet uit, tenzij de JSP-pagina is gewijzigd, in welk geval deze automatisch opnieuw wordt gecompileerd tot een servlet en wordt uitgevoerd.
Scriptelementen
in het date.jsp voorbeeld wordt de volledige Date klassenaam gebruikt, inclusief de pakketnaam, die vervelend kan worden. Als u een instantie van Date wilt aanmaken door simpelweg: Date today = new Date(); te gebruiken zonder het volledige klassepad te hoeven specificeren, gebruik dan de page richtlijn als volgt:
Monster 2: date2.jsp
<%@page import="java.util.*" %><HTML> <HEAD> <TITLE>JSP Example</TITLE> </HEAD> <BODY BGCOLOR="ffffcc"><CENTER> <H2>Date and Time</H2> <% java.util.Date today = new java.util.Date();out.println("Today's date is: "+today);%></CENTER></BODY> </HTML>een andere manier om hetzelfde te doen met de tag <%= is door te schrijven:
monster 3: date3.jsp
<%@page import="java.util.*" %> <HTML> <HEAD> <TITLE>JSP Example</TITLE> </HEAD> <BODY BGCOLOR="#ffffcc"> <CENTER> <H2>Date and Time</H2> Today's date is: <%= new Date() %> </CENTER> </BODY> </HTML> zoals je kunt zien, hetzelfde kan worden bereikt met behulp van verschillende tags en technieken. Er zijn verschillende JSP scripting elementen. Hier zijn een aantal conventionele regels die u zullen helpen JSP scripting elementen effectief te gebruiken:
- gebruik
<% ... %>om declaraties, uitdrukkingen of andere geldige codefragmenten af te handelen. Voorbeeld 1 hierboven is een voorbeeld. - gebruik de
pagerichtlijn zoals in<%@page ... %>om de scripttaal te definiëren. Het kan ook worden gebruikt omimportstatements te specificeren. Hier is een voorbeeld:<%@page language="java" import="java.util.*" %>. - gebruik
<%! .... %>om variabelen of methoden te declareren. Bijvoorbeeld:<%! int x = 10; double y = 2.0; %>. - gebruik
<%= ... %>om een expressie te definiëren en werp het resultaat als eenString. Bijvoorbeeld:<%= a+b %>of<%= new java.util.Date() %>. - gebruik de
includerichtlijn zoals in<%@ include ... %>om de inhoud van een ander bestand in het hoofdbestand van JSP in te voegen. Bijvoorbeeld:<%@include file="copyright.html" %>.
afhandeling van formulieren
een van de meest voorkomende onderdelen van e-commerce applicaties is een HTML-formulier waarin de gebruiker bepaalde informatie invoert, zoals naam en adres. Met behulp van JSP worden de gegevens van het formulier (de informatie die de gebruiker invoert in het formulier) opgeslagen in het request – object dat vanuit de browser naar de JSP-container wordt verzonden. Het verzoek wordt verwerkt en het resultaat wordt via het response object teruggestuurd naar de browser. Deze twee objecten zijn impliciet beschikbaar voor u.
om aan te tonen hoe HTML-formulieren met behulp van JSP moeten worden behandeld, is hier een voorbeeldformulier met twee velden: een voor naam en een voor e-mail. Zoals u kunt zien, wordt de HTML-vorm gedefinieerd in een JSP bronbestand. De request.getParameter methode wordt gebruikt om gegevens uit het formulier op te halen naar variabelen die zijn gemaakt met behulp van JSP-tags.
de pagina process.jsp drukt een formulier af of de door de gebruiker verstrekte informatie, Afhankelijk van de waarden van de velden van het formulier. Als de waarden van het formulier null zijn, wordt het formulier weergegeven, anders wordt de door de gebruiker verstrekte informatie weergegeven. Merk op dat het formulier is gemaakt en wordt behandeld door code in hetzelfde JSP-bestand.
monster 4: proces.jsp
<HTML> <HEAD> <TITLE>Form Example</TITLE> </HEAD> <BODY BGCOLOR="#ffffcc"> <% if (request.getParameter("name")==null && request.getParameter("email") == null) { %> <CENTER> <H2>User Info Request Form</H2> <FORM METHOD="GET" ACTION="/developer/technicalArticles/xml/WebAppDev/process.jsp"> <P> Your name: <input type="text" name="name" size=26> <P> Your email: <input type="text" name="email" size=26> <P> <input type="submit" value="Process"> </FORM> </CENTER> <% } else { %> <%! String name, email; %> <% name = request.getParameter("name"); email = request.getParameter("email"); %> <P> <B>You have provided the following info</B>: <P> <B>Name</B>: <%= name %><P> <B>Email</B>: <%= email %> <% } %> </BODY> </HTML> als process.jsp wordt opgevraagd bij een webserver, ziet u iets dat lijkt op Figuur 3.
Figuur 3: proces.JSP geladen
Voer uw naam en e-mailadres in en klik op proces om het formulier in te dienen voor verwerking, en u ziet iets dat lijkt op Figuur 4.
Figuur 4: Form is processed
herbruikbare componenten
het bovenstaande voorbeeldformulier is eenvoudig in die zin dat er niet veel code mee gemoeid is. Wanneer er meer code is betrokken, dan is het belangrijk om business logica niet te mengen met front-end presentatie in hetzelfde bestand. Het scheiden van business logic en presentatie maakt veranderingen aan beide zijden mogelijk zonder de andere te beïnvloeden. Echter, productie JSP code moet worden beperkt tot front-end presentatie. Dus, hoe implementeer je de business logic deel?
dat is waar JavaBeans komen om te spelen. Deze technologie is een draagbaar, platformonafhankelijk componentmodel waarmee ontwikkelaars componenten kunnen schrijven en ze overal kunnen hergebruiken. In de context van JSP, JavaBeans bevatten business logic die gegevens terug naar een script op een JSP pagina, die op zijn beurt formatteert de gegevens terug van de JavaBean component voor weergave door de browser. Een JSP pagina maakt gebruik van een JavaBean component door het instellen en het krijgen van de eigenschappen die het biedt.
Wat zijn de voordelen
er zijn verschillende voordelen aan het gebruik van JavaBeans om JSP-pagina ‘ s te vergroten:
- herbruikbare componenten: verschillende toepassingen kunnen de componenten hergebruiken.
- scheiding van bedrijfslogica en presentatielogica: u kunt de manier waarop gegevens worden weergegeven wijzigen zonder de bedrijfslogica te beïnvloeden.
- uw intellectuele eigendom beschermen door de broncode veilig te houden.
voorbeeld: JavaBeans gebruiken met JSP
laten we nu eens kijken hoe we het process.jsp voorbeeld hierboven kunnen aanpassen om JavaBeans te gebruiken. In het bovenstaande formulier zijn dit twee velden: name en email. In JavaBeans worden deze eigenschappen genoemd. Dus, eerst schrijf je een JavaBean component met setX en getX methoden, waarbij X de eigenschapsnaam is. Bijvoorbeeld, als je get en set methoden hebt: setName en getName dan heb je een eigenschap die bekend staat als name. Monster 5 toont een FormBean component.
goede componenten moeten kunnen samenwerken met andere componenten van verschillende leveranciers. Daarom, om component hergebruik te bereiken, zijn er twee belangrijke regels (die worden opgelegd door de JavaBeans architectuur) te volgen:
- uw bean-klasse moet een constructor zonder argumenten leveren, zodat deze kan worden aangemaakt met
Beans.instantiate. - uw bean-klasse moet persistentie ondersteunen door de interface
SerializableofExternalizablete implementeren.
Monster 5: FormBean.java
package userinfo; import java.io.*; public class FormBean implements Serializable { private String name; private String email; public FormBean() { name = null; email = null; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setEmail(String email) { this.email = email; } public String getEmail() { return email; } } om het FormBean component in het JSP bestand te gebruiken, moet u het bean component instantiate. Dit wordt gedaan met het <jsp:useBean> label. De volgende regel <jsp:setProperty> wordt uitgevoerd wanneer de boon wordt geïnstalleerd, en wordt gebruikt om de eigenschappen van de boon te initialiseren. In dit geval worden beide eigenschappen ( name en email) ingesteld met behulp van een enkele statement. Als alternatief is het mogelijk om de eigenschappen één voor één in te stellen, maar eerst moet u de datum van het formulier ophalen. Hier is een voorbeeld van hoe u de eigenschap name zou instellen:
<%! String yourname, youremail; %> <% yourname = request.getParameter("name"); %> <jsp:setProperty name="formbean" property="name" value="<%=yourname%>"/> zodra de eigenschappen zijn geïnitialiseerd met gegevens uit het formulier, worden de eigenschapswaarden opgehaald voor presentatie met <jsp:getProperty> in het else deel, zoals getoond in Monster 6.
Monster 6: procedé2.jsp
<jsp:useBean class="userinfo.FormBean"/><jsp:setProperty name="formbean" property="*"/> <HTML> <HEAD><TITLE>Form Example</TITLE></HEAD><BODY BGCOLOR="#ffffcc"><% if (request.getParameter("name")==null && request.getParameter("email") == null) { %><CENTER><H2>User Info Request Form </H2><form method="GET" action="/developer/technicalArticles/xml/WebAppDev/process2.jsp"><P>Your name: <input type="text" name="name" size=27><p> Your email: <input type="text" name="email" size=27> <P> <input type="submit" value="Process"></FORM></CENTER><% } else { %><P><B>You have provided the following info</B>: <P> <B>Name</B>: <jsp:getProperty name="formbean"property="name"/> <P> <B>Email</B>: <jsp:getPropertyname="formbean" property="email"/> <% } %> </BODY> </HTML> conclusie
ontwikkelaars die geïnteresseerd zijn in het ontwikkelen van webapplicaties voor kwaliteitsproductie, moeten zich vertrouwd maken met technologieën die niet alleen van toepassing zijn op de huidige markt, maar ook op die van morgen, namelijk JSP en XML. Het volgende artikel zal de mogelijkheden bespreken die de JSP-technologie biedt die bij uitstek geschikt zijn voor het werken met XML; en laten zien hoe je JSP effectief kunt gebruiken met XML. JSP en XML zijn een uitstekende combinatie voor webapplicaties die informatie delen, omdat JSP-pagina ‘ s XML-ondersteuning hebben ingebouwd in hen in de vorm van JSP aangepaste tagbibliotheken. Stay tuned voor meer informatie hierover in het volgende artikel in deze serie.