| JSP | |
|---|---|
| Förlängning | .jsp |
| MIME -typ | application/jsp |
| Utvecklaren | Eclipse Foundation |
| Senaste släppningen | 3.1.0 (15 maj 2022 ) |
| Formattyp | filformat , mallmotor och teknisk specifikation |
| Standard(er) | JSR 245 |
| Hemsida | projects.eclipse.org/… ( engelska) |
| Mediafiler på Wikimedia Commons | |
JSP ( JavaServer Pages ) är en teknik som gör att webbutvecklare kan skapa innehåll som har både statiska och dynamiska komponenter. En JSP-sida innehåller två typer av text: statisk källdata, som kan vara i ett av textformaten HTML , SVG , WML eller XML , och JSP-element som konstruerar dynamiskt innehåll. Dessutom kan JSP-taggbibliotek, såväl som Expression Language (EL), användas för att bädda in Java -kod i det statiska innehållet på JSP-sidor.
JSP-sidkoden översätts till Java-servletkod med Jasper JSP-sidkompilatorn och kompileras sedan till Java Virtual Machine ( JVM ) bytekod . Servlet-behållare som kan köra JSP-sidor är skrivna på det plattformsoberoende Java-språket. JSP:er laddas på servern och hanteras från en speciell Java-serverpaketstruktur som kallas Jakarta EE Web Application. Vanligtvis är sidor förpackade i .war- och .ear -filarkiv .
JSP-teknik är en plattformsoberoende, portabel och lätt utbyggbar teknik för att utveckla webbapplikationer .
Sedan version 1.2 har utvecklingen av JavaServer Pages skett under Java Community Process . JSR 53 definierar JSP 1.2- och Servlet 2.3-standarderna, medan JSR 152 definierar JSP 2.0-specifikationen. I maj 2006 släpptes JSP-specifikationen 2.1 under JSR 245 som en del av Java EE 5 . Den 10 december 2009 släpptes JSP 2.2-specifikationen som innehållet i JSR 245- versionen .
Dessa versioner skiljer sig fundamentalt från de tidigare versionerna, som uppfattades som Javas svar på ASP . Några av kärnfunktionerna i tidigare versioner (som möjligheten att utveckla taggbibliotek) har tagits bort eller ersatts i enlighet med principen om separation av kod och innehåll. Eftersom det är svårt att navigera och separera innehållet från själva koden i stora volymer källkod , kom idén att separera (överföra) dem med hjälp av JSP-taggar, som <jsp:useBean/>. För att implementera denna idé har JSP-taggar delats upp i tre logiska grupper: direktiv, skriptelement och åtgärder.
JSP 1.2 utökar JavaServer Pages 1.1 (JSP 1.1)-specifikationen enligt följande:
Den nya versionen av JSP-specifikationen lägger till följande funktionalitet:
Java EE 5-plattformen fokuserar på enkel utveckling med hjälp av Java-språkanteckningar som introducerades av J2SE 5.0 . JSP 2.1 stöder detta mål genom att definiera annoteringar om beroendeinjektion på JSP-uttalanden och kontextlyssnare.
JavaServer Pages (JSP) låter dig separera den dynamiska delen av sidorna från den statiska HTML . Den dynamiska delen är innesluten i speciella taggar "<% %>":
Ditt värdnamn : <% = begäran . getRemoteHost () %>JSP-sidor har ett tillägg .jspoch placeras på samma plats som vanliga webbsidor. Strukturen på sådana sidor kan bestå av fem konstruktioner: HTML , kommentarer, skriptelement, direktiv och åtgärder. JSP-sidan kompileras till en servlet med statiskt innehåll som skickas till utgångsströmmen som är kopplad till tjänstemetoden . Därför, på den första begäran, kan denna process orsaka en liten fördröjning. Kommentarer i ett dokument eller program får inte programmet att sakta ner, eftersom de ignoreras av kompilatorn och utföraren. Skriptelement låter dig specificera Java -kod som senare kommer att bli en del av den slutliga servleten, direktiv låter dig kontrollera hela strukturen för servleten, och åtgärder tjänar till att specificera de befintliga komponenterna som används, samt styra beteendet hos JSP-motorn . För att göra skript enklare finns det fördefinierade variabler som request, response, pageContext, session, out, application, config, page, exception. Ett exempel på en JSP-sida som använder alla JSP-komponenter:
Kommentarer används för att förklara källkoden för ett program. På JSP-sidor kan kommentarer delas in i två grupper:
JSP-källkodskommentarer är markerade med en speciell teckensekvens: <%--i början och --%>i slutet av kommentaren. Denna typ av kommentar tas bort när JSP-sidan kompileras. JSP-kommentarexempel:
<% -- Visar produktkatalogen och den aktuella varukorgen . --%>HTML -markeringskommentarer formateras enligt reglerna för HTML-språket. Den här typen av kommentarer behandlas som statisk text av JSP-kompilatorn och placeras i HTML-dokumentet. JSP-uttryck inuti HTML-kommentarer körs. HTML-kommentarexempel:
<!-- Sidans skapandedatum : < %= new java . util . Datum () %> -->JSP-specifikationen särskiljer tre typer av skriptelement:
Deklarationer används vanligtvis för att definiera variabler, metoder, inre klasser och andra giltiga Java-konstruktioner på klassnivå. Uttrycken blir argument till out.print()-metoden. Med hjälp av scriptlets bäddas fungerande delar av Java-koden in i JSP-sidor.
JSP-deklarationerJSP-deklarationer låter dig definiera variabler, metoder, inre klasser och så vidare. Deklarationer används för att definiera Java-konstruktionerna som används i programmet. Eftersom deklarationer inte renderas används de vanligtvis tillsammans med JSP-uttryck eller scriptlets. JSP-exemplet visar antalet förfrågningar till den här sidan sedan servern startades (eller sedan servleten senast ändrades och laddades om). Observera att vi i exemplet använder både en deklaration och ett uttryck, och att inuti konstruktionen finns ett semikolon ( ; ) efter deklarationen:
<%! privat int accessCount = 0 ; % > Antal sidträffar sedan serverladdning : < % = ++ accessCount % > JSP-uttryckJSP-uttryck används för att infoga Java-värden direkt i utgången. Java-uttryck utvärderas, konverteras till en sträng och infogas på sidan. Dessa beräkningar sker vid körning (det vill säga när sidan efterfrågas), och därför finns det full tillgång till information om själva begäran. I uttryck kan du använda konstanter, variabler, anrop till olika metoder. Alla uttryck, oavsett hur komplext innehållet är, utvärderas till ett enda resultat eller nummer. JSP-sidor förlitar sig på JSP Writer , som tar alla resultat av ett uttryck, konverterar det till en typ String(text) och buffrar det . Till exempel visar följande kod datum och tid för en given sidförfrågan:
Aktuell tid : <%= new java . util . Datum () %> Ditt värdnamn : <% = begäran . getRemoteHost () %>Du måste vara uppmärksam på tre regler:
JSP-skript låter dig infoga vilken kod som helst i en servletmetod som genereras när sidan renderas, vilket gör att du kan använda de flesta av Java-konstruktionerna. Skript har också tillgång till samma fördefinierade variabler som uttryck. Därför måste du till exempel använda en fördefinierad variabel för att visa ett värde på en sida out.
<% String queryData = begäran . getQueryString (); ut . println ( "Ytterligare frågedata: " + queryData ); %>Koden inuti scriptleten infogas som den skrevs. All statisk HTML (malltext) före eller efter skriptlet konverteras med hjälp av print. Till exempel innehåller följande JSP-kodavsnitt blandad mall- och skripttext:
<% if ( Math . random () < 0.5 ) { %> < B > Ha en trevlig dag </ B > ! <% } else { %> < B > Ha en dålig dag </ B > för dig ! <% } %>Efter att ha konverterat scriptleten kommer koden att se ut så här:
if ( Math . random ( ) < 0,5 ) { out . println ( "<B>Ha en trevlig</B> dag!" ); } annat { ut . println ( "<B>Ha en dålig dag</B> för dig!" ); }Detta innebär att scriptlets inte behöver innehålla kompletta Java-snuttar, och att block som lämnas öppna kan påverka statisk HTML utanför scriptleten.
JSP-sidan kan skicka ett meddelande till lämplig behållare med instruktioner om vad som ska göras. Dessa meddelanden kallas direktiv. Alla direktiv börjar med <%@, följt av namnet på direktivet och ett eller flera attribut med värden och slutar med %>. Direktiven på JSP-sidan gör att behållaren skickar en begäran om att exekvera en specifik tjänst som inte deklareras i det genererade dokumentet. Formen av direktiv kan representeras enligt följande:
<% @ direktivattribut = "värde" % >Du kan också kombinera att ställa in flera attribut på ett enda direktiv:
<% @ direktiv attribut1 = "värde1" attribut2 = "värde2" ... attributN = " värdeN " %>Det finns tre huvudtyper av direktiv: page , som låter dig göra saker som att importera klasser, ändra en servlets superklass och så vidare; include , som låter dig infoga en fil i en servletklass när du översätter en JSP-fil till en servlet; och taglib , som låter dig utöka många taggar med dina egna, vilket JSP-behållaren kan tolka.
JSP siddirektivSom namnet antyder tillhandahåller detta direktiv attribut för JSP-sidan. Attributen som definieras i detta direktiv är inbäddade i den givna JSP-sidan och alla dess kapslade statiska element, oavsett om de infogades med direktivet includeeller med åtgärden jsp:include. Utformningen av direktivet är pageföljande:
<% @ page attribute = " värde " %>Låt oss ta följande post som ett exempel:
<% @ page import = ” java . util . * , com . mina klasser . * ” buffert = ” 15 kb ” %>Detta direktiv anger att JSP-sidan kommer att importera klasser från två Java-paket java.utiloch com.myclassesanger sedan storleken på buffertminnet som ska användas för att bearbeta den givna JSP-sidan.
Tänk sedan på direktivets attribut page:
Du kan uppnå samma resultat med ett scriptlet:
<% svar . setContentType ( "text/plain" ); %> JSP inkluderar direktivDetta direktiv låter dig inkludera filer i en servlet när du översätter en JSP-sida. Att använda direktivet ser ut så här:
<% @ include file = "relativ url" %>Den givna URL :en tolkas vanligtvis i förhållande till JSP för sidan där länken finns, men som med alla andra relativa URL :er kan du berätta för systemet var resursen du är intresserad av i förhållande till webbserverns hemkatalogen genom att prefixet URL :en med en " / " symbol . Innehållet i en include-fil behandlas som vanlig JSP-text och kan därför inkludera element som statisk HTML , skriptelement, direktiv och åtgärder. Till exempel använder många webbplatser ett litet navigeringsfält på varje sida. På grund av problemen med att använda HTML- ramar löses denna uppgift ofta genom att placera en liten tabell överst eller i den vänstra halvan av sidan, vars HTML -kod upprepas många gånger för varje sida på webbplatsen. Direktivet includeär det mest naturliga sättet att utföra denna uppgift, och räddar utvecklaren från mardrömmen att kopiera HTML till varje enskild fil. Det händer så här:
<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" > < html > < head > < title > Testsida < / title > </ head > < body > <% @ include file = "/navbar .html" %> <!-- Ett specifikt fragment av denna sida ... --> </ body > </ html >Observera att eftersom direktivet includeinkluderar filer under sidöversättning, efter att ha gjort ändringar i navigeringsfältet, måste du översätta alla JSP-sidor på nytt med det. Vilket i det här fallet är en bra kompromiss, eftersom navigeringsfältet som regel ändras ganska sällan och anslutningsprocessen inte förlorar sin effektivitet. Om de inkluderade filerna ändras ganska ofta kan du använda åtgärden istället jsp:include. Den här åtgärden inkluderar filen vid åtkomst till JSP.
JSP taglib direktivSom du redan vet, på JSP-sidor skrivs element med taggar (konventionella skyltar, etiketter, varumärken). Uppsättningen taggar som en JSP-container kan tolka kan utökas med så kallade taggbibliotek. Du kan också bifoga åtgärder till en utökad uppsättning taggar, vilket resulterar i en förlängning av själva JSP-språket. Taggar kan delas in i standardtaggar och anpassade taggar. Ett generaliserat sätt att skriva kan se ut så här:
<% @ taglib uri = " URI för att tagga biblioteket " prefix = " teckenprefix " % >Taggbiblioteket måste identifieras av en URI- adress (en unik resursidentifierare). URI kan vara antingen absolut eller relativ. Den unika resursidentifieraren identifierar platsen för ett taggbibliotek ( TLD ) som definierar det bibliotekets egna taggar. Ett exempel på en direktivpost:
<% @ taglib uri = " http://www.moywebserver.ru/naydiznaki.tld " prefix = "iskat" %>En JSP-sida kan innehålla ett oändligt antal direktiv taglib, men varje direktiv måste ges ett annat prefix som definierar innehållet i biblioteket på sidan. Som prefix kan du använda vilken text, vilket ord som helst. Medan ett direktiv taglibkan användas var som helst på en JSP-sida, måste alla inbyggda taggar som dessa direktiv använder användas bakom dem.
JSP-åtgärder använder XML -syntaxkonstruktioner för att styra driften av servletmotorn. Du kan dynamiskt inkludera en fil, återanvända JavaBeans , dirigera användaren till en annan sida eller generera HTML för ett Java-plugin . Alla dessa åtgärder diskuteras i detalj nedan. Kom ihåg att, som med all XML , är element- och attributnamn skiftlägeskänsliga. Åtgärder kan delas in i två grupper: standard och skapad (egna, som programmeraren skapar). Följande standardåtgärder är tillåtna:
Denna åtgärd låter dig ladda en JavaBean för senare användning på en JSP-sida. Den här funktionen låter dig återanvända Java-klasser utan att offra fördelarna med JSP-servlets. Dessutom är detta ett sätt att ta bort mycket av Java-bearbetningen från JSP-sidan. Om du överför Java-bearbetning från en JSP-sida till en JavaBean, kan dessa funktioner sedan användas på andra JSP-sidor. Den enklaste syntaxen för att specificera bönan som ska användas är:
< jsp : useBean id = "name" class = "package.class" />Vanligtvis betyder detta att "skapa en ny instans av ett objekt av den klass som specificeras av klassen och associera det med en variabel som heter id ". Du kan dock ställa in scope- attributet (tar värdena page|request|session|application, pageför sidan, requestför förfrågningar, sessionför sessioner eller dialoger, applicationför applikationen), som beaninte bara är associerad med den aktuella sidan. I det här fallet är det användbart att få referenser till befintliga beans, och åtgärden jsp:useBeaninstansierar bara ett nytt objekt om inget objekt finns med samma id och scope- värden . Nu när du har en bean, kan du ändra dess egenskaper med en åtgärd jsp:setProperty, eller genom att använda ett skript för att göra det och explicit anropa objektets metod med variabelnamnet som specificerats tidigare via id- attributet . Kom ihåg att med bönor , när du säger "den här bönan har en egenskap av typ X med namnet foo" menar du verkligen "den här klassen har en metod getFoosom returnerar data av typ X och en annan metod som tar X setFoosom en parameter." Åtgärden jsp:setPropertybehandlas mer i detalj i nästa avsnitt, men för närvarande bör du komma ihåg att du antingen explicit kan ställa in värde genom att ställa in param- attributet för att få värdet från motsvarande frågeparameter, eller helt enkelt räkna upp egenskaper för att få värden från frågeparametrar med samma namn som egenskaper. Du kan få värdena för befintliga egenskaper med hjälp av JSP-uttryck eller scriptlets genom att anropa lämplig metod getXxx, eller (oftast) genom att använda en åtgärd jsp:getProperty.
Klassen som ges till bönan måste finnas i serverns normala klasskatalog, inte i den del som är reserverad för klasser som automatiskt laddas om efter redigering. Till exempel för Java Web Server måste alla klasser som används placeras i en katalog classeseller .jar -fil i katalogen lib, inte i katalogen servlets. Nedan är ett enkelt exempel som laddar beanoch ställer in/får en enkel strängparameter.
BeanTest.jsp
<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" > < html > < head > < title > Återanvända JavaBeans i JSP < / title > < / head > < body > < h1 > Återanvända JavaBeans i JSP </ h1 > < jsp : useBean id = "test" class = "hall.SimpleBean" /> < jsp : setProperty name = "test" egenskap = "meddelande" värde = "Hej WWW" /> < p > Meddelande : < jsp : getProperty name = "test" egenskap = "meddelande" /> </ p > </ body > </ html >SimpleBean.java
pakethall ; _ public class SimpleBean { private String message = "Meddelandetext ej angiven" ; public String getMessage () { return ( meddelande ); } public void setMessage ( String message ) { this . meddelande = meddelande _ } }Lite mer information om hur du använder jsp:useBean. Det enklaste sättet att använda bean det är att använda konstruktionen:
< jsp : useBean id = "name" class = "package.class" />att ladda beanoch sedan använda jsp:setPropertyoch jsp:getPropertyför att ändra och få dess egenskaper (parametrar). Det finns dock två andra sätt. Först kan du använda behållarformatet, nämligen:
< jsp : useBean ... > Kropp </ jsp : useBean >för att säkerställa att kroppen endast exekveras när en instans beanskapas för första gången, och inte när en befintlig hittas och används bean. Som diskuteras nedan, beanskan delas, så inte alla uttryck jsp:useBeanresulterar i en ny instans av bean. För det andra, förutom id och class , finns det tre andra attribut du kan använda: scope , type och beanName . Dessa attribut beskrivs nedan:
Du kan använda jsp:setPropertyden tidigare beskrivna beans. Du kan göra detta på två sätt. Först kan du använda jsp:setPropertyefter men utanför elementet jsp:useBean, som visas i exemplet:
< jsp : useBean id = "myName" ... /> ... < jsp : setProperty name = "myName" property = "someProperty" ... />I det här fallet jsp:setPropertykörs den oavsett om en befintlig instans hittades beaneller om en ny instans skapades. Ett annat alternativ är att placera jsp:setPropertyi elementets brödtext jsp:useBean, som visas i ett annat exempel:
< jsp : useBean id = "myName" ... > ... < jsp : setProperty name = "myName" property = "someProperty" ... /> </ jsp : useBean >Detta jsp:setPropertygörs endast om en ny instans av objektet har skapats, och inte när en befintlig hittas. En åtgärd jsp:setPropertyaccepterar följande fyra attribut:
Om du inte använder varken valueeller paramär det samma sak som om du hade gett ett namn som parammatchar namnet property. Du kan tillämpa den här principen att automatiskt använda förfrågningsegenskaper vars namn matchar egenskapsnamnen och gå längre genom att ställa in egenskapsnamnet till " * " och utelämna parametrarna värde och param . I det här fallet kommer servern att bearbeta de giltiga egenskaperna och frågeparametrarna för att matcha identiska namn. Följande är ett exempel som används beanför att skapa en tabell med primtal. Om en parameter finns numDigitsi begärandedata skickas den till bean numDigits. Likadant för numPrimes. JspPrimes.jsp
<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" > < html > < head > < title > Återanvända JavaBeans i JSP < / title > < / head > < body > < h1 > Återanvända JavaBeans i JSP </ h1 > < jsp : useBean id = "primeTable" class = "hall.NumberedPrimes" /> < jsp : setProperty name = "primeTable" egenskap = "numDigits" /> < jsp : setProperty name = "primeTable" egenskap = "numPrimes" /> < p > Flera teckenprimtal < jsp : getProperty name = " primeTable " property = "numDigits" /> : < jsp : getProperty name = "primeTable" property = " numberedList" /> </ p > </ body > </ html > jsp:getProperty actionDetta element bestämmer värdet på egenskapen bean, konverterar den till en sträng och skickar den till utgångsströmmen. För att utföra en åtgärd måste två attribut ställas in: namnet bean, som är förinställt i åtgärden jsp:useBean, och namnet på egenskapen vars värde måste bestämmas. Följande är ett exempel på hur du använder den här åtgärden:
< jsp : useBean id = "itemBean" ... /> ... < UL > < LI > Antal artiklar : < jsp : getProperty name = "itemBean" property = "numItems " / > < LI > Enhetspris : < jsp : getProperty name = "itemBean" property = "unitCost" /> </ UL > jsp:include actionDen här åtgärden låter dig infoga innehållet i filerna på den skapade sidan. Åtgärdssyntax:
< jsp : include page = "relativ URL" flush = "true" />Till skillnad från direktivet include, som infogar en fil under JSP-översättningsstadiet av sidan, infogar denna åtgärd filen när sidan efterfrågas. Detta resulterar i en viss förlust av effektivitet och eliminerar möjligheten för JSP-kod i den inklistrade filen, men det ger en betydande fördel i flexibilitet.
Ett exempel på att infoga innehållet i fyra filer på en JSP-sida:
<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd" > < html > < head > < title > Nyheter </ title > </ head > < body > < h1 > Nyheter </ h1 > < p > Här är utdrag från våra fyra mest populära artiklar : </ p > < ol > < li >< jsp : include page = "news/Item1. html" flush = "true" /></ li > < li >< jsp : include page = "news/Item2.html" flush = "true" /></ li > < li >< jsp : include page = " news/ Item3.html" flush = "true" /></ li > < li >< jsp : include page = "news/Item4.html" flush = "true" /></ li > </ ol > </ body > </ html > jsp:forward actionDen här åtgärden låter dig skicka begäran till en annan statisk HTML-sida, servlet eller JSP-sida. Till skillnad från en åtgärd jsp:includeavslutas behandlingen av den aktuella sidan. Den använder ett attribut page, som måste innehålla en relativ URL , baserat på vilken objektet är beställt request. jsp:paramDu kan lägga till andra parametrar till de ursprungliga frågeparametrarna som skickats till en annan sida med hjälp av en åtgärd . Attributvärdet pagekan antingen vara ett statiskt värde eller ett värde som beräknas under begäran, som visas i följande två exempel:
< jsp : forward page = "/utils/errorReporter.jsp" /> < jsp : forward page = "<%= someJavaExpression %>" />Med hjälp av en åtgärd jsp:forwardkan du också överföra kontrollen till en annan sida, men med villkoret att innan du anropade den här åtgärden skrevs ingenting till det utgående buffertminnet (annars kommer ett undantag att kastas IllegalStateException).
jsp:param-åtgärden och jsp:params-åtgärdenDen här åtgärden ger information om namn/värdetyp. Denna åtgärd används huvudsakligen tillsammans med de redan bekanta åtgärderna jsp:includeoch jsp:forward. Dessutom kan den också användas tillsammans med åtgärden jsp:plugin. I andra fall spelar användningen av denna åtgärd ingen roll. Används jsp:parammed åtgärder jsp:includeoch jsp:forwardskickar det ursprungliga objektet till nya sidor request, som kommer att utökas med de nya parametrarna. Om du anger nya värden för redan befintliga parametrar, är det de nya värdena som kommer att ha företräde. Med hjälp av en åtgärd jsp:paramskan du ställa in flera parametrar samtidigt
jsp:plugin-åtgärdDenna åtgärd låter dig infoga elementet OBJECT eller EMBED (beroende på vilken typ av webbläsare du använder) som krävs för att köra appletar som använder Java-plugin. Med andra ord tjänar den här åtgärden till att generera HTML för att bädda in Java API på JSP-sidan. På samma sätt kan du klistra in URL:en för att ladda ner moduler för Java API från JavaSoft, som ger möjlighet att köra appletar i webbläsaren. Anmälningsformuläret för denna åtgärd ser ut så här:
< jsp : plugin -typ = "bean|applet" code = "klassfil" codebase = "CodeBase-objekt" align = "plats" archive = "arkivlista" höjd = "höjd" hspace = "horisontellt utrymme" jreversion = "version" name = "komponentnamn" vspace = "vertical space" width = "width" nspluginurl = "url" iepluginurl = "url" > < jsp : params > < jsp : param name = "name1" value = "value1" /> < jsp : param name = "name2" value = "value2" /> ... < jsp : param name = "nameN" value = "valueN" /> </ jsp : params > < jsp : fallback > </ jsp : fallback > </ jsp : plugin >Låt oss titta på ett exempel på hur den här åtgärden används i appletkoden:
< jsp : plugin type = "applet" code = "Blink.class" width = 300 höjd = 100 > < jsp : params > < jsp : param name = lbl value = "Ja, det är godare än bara skivat bröd! " /> < jsp : param name = speed value = "4" /> < jsp : params > < jsp : fallback > Din webbläsare kan av någon okänd anledning inte köra denna applet </ fallback > </ jsp : plugin >| Java | |
|---|---|
| Plattformar | |
| Sun Technologies | |
| Viktiga tredjepartstekniker | |
| Berättelse |
|
| Språkegenskaper | |
| Skriptspråk |
|
| Java-konferenser |
|