om du har haft möjlighet att bygga webbapplikationer med hjälp av tekniker som Common Gateway Interface (CGI) och servlets, är du van vid tanken på att skriva ett program för att generera hela sidan (den statiska och den dynamiska delen) med samma program. Om du letar efter en lösning där du kan separera de två delarna, leta inte längre. JavaServer Pages (JSP) är här.
JSP-sidor låter dig skilja front-end-presentation från affärslogik (mellan-och back-end-nivåer). Det är en stor snabb applikationsutveckling (RAD) strategi för webbapplikationer. Denna serie artiklar ger en praktisk handledning som förklarar hur man utvecklar moderna webbapplikationer för dagens och morgondagens marknad. Denna serie börjar med den här artikeln, som förklarar begreppen och fördelarna med JSP-teknik, och sedan visar hur du använder denna spännande teknik, och hur man skapar återanvändbara komponenter för hantering av formulär.
den dynamiska webben
webben har utvecklats från ett nätverksbaserat hypermedia distribuerat informationssystem som erbjuder statisk information till en marknadsplats för försäljning och köp av varor och tjänster. De alltmer sofistikerade applikationerna för att möjliggöra denna marknadsplats kräver en teknik för att presentera dynamisk information.
första generationens lösningar inkluderade CGI, som är en mekanism för att köra externa program via en webbserver. Problemet med CGI-skript är skalbarhet; en ny process skapas för varje begäran.
andra generationens lösningar inkluderade webbserverleverantörer som tillhandahåller plug-ins och API: er för sina servrar. Problemet är att deras lösningar var specifika för deras serverprodukter. Till exempel tillhandahöll Microsoft Active Server Pages (asp) som gjorde det lättare att skapa dynamiskt innehåll. Men deras lösning fungerade bara med Microsoft IIS eller Personal Web Server. Därför, om du ville använda ASP var du tvungen att förbinda dig till Microsoft-produkter och du skulle inte njuta av friheten att välja din favorit webbserver och operativsystem!
en annan andra generationens teknik som är ganska populär i företagsberäkning är servlets. Servlets gör det lättare att skriva applikationer på serversidan med Java-teknik. Problemet med antingen CGI eller servlets är dock att du måste följa skriv, kompilera och distribuera livscykeln.
JSP-sidor är en tredje generationens lösning som enkelt kan kombineras med vissa andra generationens lösningar, skapa dynamiskt innehåll och göra det enklare och snabbare att bygga webbaserade applikationer som fungerar med en mängd andra tekniker: webbservrar, webbläsare, applikationsservrar och andra utvecklingsverktyg.
JavaServer Pages (JSP)
JSP-tekniken är en öppen, fritt tillgänglig specifikation utvecklad av Sun Microsystems som ett alternativ till Microsofts Active Server Pages (Asp) – teknik och en nyckelkomponent i Java 2 Enterprise Edition (J2EE) – specifikationen. Många av de kommersiellt tillgängliga applikationsservrarna (som BEA WebLogic, IBM WebSphere, Live JRun, Orion och så vidare) stöder redan JSP-teknik.
JSP kontra ASP
JSP och ASP levererar liknande funktioner. De använder båda taggar för att tillåta inbäddad kod i en HTML-sida, sessionsspårning och databasanslutning. Några av de triviala skillnaderna är:
- ASP-sidor skrivs i VBScript och JSP-sidor skrivs i Java-programmeringsspråket. Därför är JSP-sidor plattformsoberoende och ASP-sidor inte.
- JSP-sidor använder JavaBeans-teknik eftersom komponentarkitekturen och ASP-sidor använder ActiveX-komponenter.
Utöver dessa triviala skillnader finns det ett antal viktiga skillnader som kan hjälpa dig att välja en teknik för din organisation:
- hastighet och skalbarhet : även om ASP-sidor är cachade tolkas de alltid. Däremot kompileras JSP-sidor i Java servlets och laddas i minnet första gången de anropas och körs för alla efterföljande samtal. Detta ger JSP sidor aspeed och skalbarhet fördel jämfört med ASP sidor.
- Extensible Tags : JSP-sidor har en avancerad funktion som kallas extensible tags. Denna mekanism gör det möjligt för utvecklare att skapa egna taggar. Med andra ord, extensible taggar kan du förlänga JSP pages tag syntax. Du kan inte göra detta med ASP-sidor.
- valfrihet : om du inte installerar Chili!Mjuk ASP, ASP-sidor fungerar bara med Microsoft IIS och personlig webbserver. Att använda ASP-sidor kräver ett åtagande för Microsoft-produkter, medan JSP-sidor inte binder dig till någon specifik webbserver eller operativsystem. JSP-sidor blir en allmänt stödd standard.
för en mer detaljerad jämförelse mellan JSP-sidor och ASP-sidor, se jämföra JSP och ASP.
mjukvarumiljö
för att köra JSP-sidor behöver du en webbserver med en webbbehållare som överensstämmer med JSP-och servlet-specifikationerna. Webbbehållaren körs på webbservern och hanterar exekveringen av alla JSP-sidor och servlets som körs på den webbservern. Tomcat 3.2.1 är en komplett referensimplementering för Java Servlet 2.2 och JSP 1.1 SPECIFIKATIONER. Ladda ner och installera binära versioner av Tomcat.
för att konfigurera Tomcat:
- Ställ in miljövariabeln
JAVA_HOMEför att peka på rotkatalogen för din Java 2 Standard Edition (J2SE) – installation. - Ställ in miljövariabeln
TOMCAT_HOMEför att peka på rotkatalogen för din Tomcat-installation. - för att starta Tomcat, använd
TOMCAT_HOME/bin/startup.batför windows ellerstartup.shför UNIX.
som standard börjar den lyssna på port 8080. - Spara dina
.jspfiler iTOMCAT_HOME/webapps/examples/jspoch dina JavaBeans klasser iTOMCAT_HOME/webapps/examples/web-inf/classes.
Obs: Om du arbetar under Windows, kan du få en Out of space miljö fel när du försöker starta Tomcat. Det finns två sätt att åtgärda detta: antingen ändra den ursprungliga minnesinställningen för DOS-fönstret till ett värde större än 3200 eller redigera konfigurationen.sys-fil och Lägg till följande rad: SHELL=c:\PATHTO\command.com /E:4096 /P.
hur JSP-sidor fungerar
en JSP-sida är i grunden en webbsida med traditionell HTML och bitar av Java-kod. Filändelsen för en JSP-sida är”.jsp ”snarare än”.html” eller ”.htm”, och som talar om för servern att denna sida kräver särskild hantering som kommer att åstadkommas genom en server förlängning eller en plug-in. Här är ett enkelt exempel:
prov 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> det här exemplet innehåller traditionell HTML och viss Java-kod. Taggen <% identifierar början på en scriptlet, och taggen %> identifierar slutet på en scriptlet. När date.jsp begärs från en webbläsare ser du något som liknar Figur 1.
Figur 1: Begär datum.jsp
bakom kulisserna
när den här sidan (date.jsp) heter, kommer den att sammanställas (av JSP-motorn) till en java servlet. Vid denna tidpunkt hanteras servlet av servlet-motorn precis som alla andra servlet. Servlet-motorn laddar sedan servlet-klassen (med en klasslastare) och kör den för att skapa dynamisk HTML som ska skickas till webbläsaren, som visas i Figur 2. I det här exemplet skapar servlet ett Date – objekt och skriver det som en sträng till out – objektet, vilket är en utgångsström till webbläsaren.
Figur 2: Request/Response Flow när du anropar en JSP
nästa gång sidan begärs, kör JSP-motorn den redan laddade servlet om inte JSP-sidan har ändrats, i vilket fall den automatiskt kompileras om till en servlet och körs.
Skriptelement
i exemplet date.jsp används hela klassnamnet Date inklusive paketnamnet, vilket kan bli tråkigt. Om du vill skapa en instans av Date helt enkelt genom att använda: Date today = new Date(); utan att behöva ange hela klassvägen, använd page – direktivet enligt följande:
Sample 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>ändå är ett annat sätt att göra samma sak med <%= – taggen genom att skriva:
Prov 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> som du kan se kan samma sak åstadkommas med olika taggar och tekniker. Det finns flera JSP-skriptelement. Här är några konventionella regler som hjälper dig att använda JSP-skriptelement effektivt:
- använd
<% ... %>för att hantera deklarationer, uttryck eller någon annan typ av giltigt kodavsnitt. Exempel 1 ovan är ett exempel. - använd
page– direktivet som i<%@page ... %>för att definiera skriptspråket. Det kan också användas för att angeimport– satser. Här är ett exempel:<%@page language="java" import="java.util.*" %>. - använd
<%! .... %>för att deklarera variabler eller metoder. Till exempel:<%! int x = 10; double y = 2.0; %>. - använd
<%= ... %>för att definiera ett uttryck och kasta resultatet som ettString. Till exempel:<%= a+b %>eller<%= new java.util.Date() %>. - använd
include– direktivet som i<%@ include ... %>för att infoga innehållet i en annan fil i huvudfilen för JSP. Till exempel:<%@include file="copyright.html" %>.
Hanteringsformulär
en av de vanligaste delarna av e-handelsapplikationer är ett HTML-formulär där användaren anger viss information som namn och adress. Med hjälp av JSP lagras formulärets data (informationen som användaren anger i formuläret) i request – objektet som skickas från webbläsaren till JSP-behållaren. Begäran behandlas och resultatet skickas via objektet response tillbaka till webbläsaren. Dessa två objekt är implicit tillgängliga för dig.
för att visa hur man hanterar HTML-formulär med JSP, här är ett exempelformulär med två fält: ett för namn och det andra för e-post. Som du kan se definieras HTML-formuläret i en JSP-källfil. Metoden request.getParameter används för att hämta data från formuläret till variabler som skapats med JSP-taggar.
sidan process.jsp skriver ut antingen ett formulär eller den information som användaren tillhandahåller beroende på värdena i formulärets fält. Om formulärets värden är null visas formuläret, annars visas informationen från användaren. Observera att formuläret skapas och hanteras med kod i samma JSP-fil.
prov 4: process.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> om process.jsp begärs från en webbserver ser du något som liknar Figur 3.
Figur 3: process.jsp loaded
ange ditt namn och e-post och klicka på Process för att skicka in formuläret för bearbetning, och du ser något som liknar Figur 4.
Figur 4: Form bearbetas
återanvändbara komponenter
ovanstående exempelform är enkel i den meningen att det inte finns mycket kod inblandad. När mer kod är inblandad är det viktigt att inte blanda affärslogik med frontendpresentation i samma fil. Att skilja affärslogik från presentation tillåter ändringar på båda sidor utan att påverka den andra. Produktions – JSP-kod bör dock begränsas till front-end-presentation. Så, hur implementerar du affärslogikdelen?
det är där JavaBeans kommer in för att spela. Denna teknik är en bärbar, plattformsoberoende komponentmodell som låter utvecklare skriva komponenter och återanvända dem överallt. I samband med JSP innehåller JavaBeans affärslogik som returnerar data till ett skript på en JSP-sida, vilket i sin tur formaterar data som returneras från JavaBean-komponenten för visning av webbläsaren. En JSP-sida använder en JavaBean-komponent genom att ställa in och få de egenskaper som den tillhandahåller.
vilka är fördelarna
det finns flera fördelar med att använda JavaBeans för att öka JSP-sidor:
- återanvändbara komponenter: olika applikationer kommer att kunna återanvända komponenterna.
- Separation av affärslogik och presentationslogik: du kan ändra hur data visas utan att påverka affärslogiken.
- skydda din immateriella egendom genom att hålla källkoden säker.
exempel: använda JavaBeans med JSP
låt oss nu se hur du ändrar exemplet process.jsp ovan för att använda JavaBeans. I ovanstående form är dessa två fält: name och email. I JavaBeans kallas dessa egenskaper. Så först skriver du en JavaBean-komponent med setX och getX metoder, där X är egenskapsnamnet. Om du till exempel har get and set-metoder: setName och getName har du en egenskap som kallas name. Prov 5 visar en FormBean komponent.
bra komponenter måste kunna samverka med andra komponenter från olika leverantörer. För att uppnå komponentåteranvändning finns det därför två viktiga regler (som införs av JavaBeans-arkitekturen) att följa:
- din bönklass måste tillhandahålla en konstruktör utan argument så att den kan skapas med
Beans.instantiate. - din bönklass måste stödja uthållighet genom att implementera gränssnittet
SerializableellerExternalizable.
Prov 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; } } för att kunna använda komponenten FormBean i JSP-filen måste du initiera bean-komponenten. Detta görs med taggen <jsp:useBean>. Nästa rad <jsp:setProperty> körs när bönan instansieras och används för att initiera bönans egenskaper. I det här fallet ställs båda egenskaperna ( name och email) in med ett enda uttalande. Alternativt är det möjligt att ställa in egenskaperna en i taget, men först måste du hämta formulärets datum. Här är ett exempel på hur du skulle ställa in egenskapen name :
<%! String yourname, youremail; %> <% yourname = request.getParameter("name"); %> <jsp:setProperty name="formbean" property="name" value="<%=yourname%>"/> när egenskaperna har initierats med data som hämtats från formuläret hämtas egenskapsvärden för presentation med <jsp:getProperty> i else – delen, som visas i prov 6.
prov 6: process2.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> slutsats
utvecklare som är intresserade av att utveckla webbapplikationer för kvalitetsproduktion bör bekanta sig med tekniker som inte bara är tillämpliga på dagens marknad utan även morgondagens, nämligen JSP och XML. Nästa artikel kommer att diskutera de funktioner som JSP-tekniken tillhandahåller som är idealiska för att arbeta med XML; och visa dig hur du effektivt använder JSP med XML. JSP och XML är en utmärkt kombination för webbapplikationer som delar information, eftersom JSP-sidor har XML-stöd inbyggt i dem i form av JSP custom tag libraries. Håll ögonen öppna för mer information om detta i nästa artikel i denna serie.