Meny
Är gratis
registrering
Hem  /  PÅ/ Att skriva en servlet för att spionera på användare av sociala medier. Java

Att skriva en servlet för att spionera på användare av sociala medier. Java

Servlets är java-program som körs på serversidan av en webbapplikation. Precis som appletar dynamiskt utökar funktionaliteten hos en webbläsare, utökar servlets dynamiskt funktionaliteten hos en webbserver. Medan servlets kan betjäna vilken begäran som helst, används de vanligtvis för att utöka webbservrar. För sådana applikationer definierar Java Servlet-teknologin HTTP-specifika servletklasser. Paketen javax.servlet och javax.servlet.http tillhandahåller gränssnitt och klasser för att skapa servlets.

  • Vad är strukturen för ett webbprojekt?

  • Vad är en Servlet-behållare? Servlets livscykel.

En servletbehållare är ett program som hanterar servlets livscykel.
Servlets livscykel: Den hanteras av servletbehållaren, första gången servleten öppnas laddas den in i minnet och metoden init () anropas. Genom hela applikationen anropas metoden service () för att hantera klientförfrågningar. När applikationen avslutas anropas metoden destroy () och servleten laddas ur minnet.

  • Vilka är uppgifterna, funktionerna för servletbehållaren?

En servletbehållare kan fungera som en komplett fristående webbserver, fungera som sidleverantör för en annan webbserver som Apache, eller integreras i en Java EE-applikationsserver. Tillhandahåller datautbyte mellan servlet och klienter, tar hand om funktioner som att skapa en mjukvarumiljö för en fungerande servlet, identifiera och auktorisera klienter, organisera en session för var och en av dem.

  • Hur skiljer sig sendRedirect () från forward ()?

Metoden framåt () används för att anropa en JSP med hjälp av en relativ sökväg, och metoden sendRedirect () används för att referera till en JSP som använder en absolut sökväg. Skillnaden mellan dessa metoder är att ett befintligt begäranobjekt skickas med metoden forward () och en ny begäran genereras när metoden sendRedirect () anropas. I det senare fallet bör information överföras med andra objekt. Dessutom är metoden framåt () snabbare.

  • Vad vet du om servletfilter?

Implementeringen av filtergränssnittet låter dig skapa ett objekt som fångar upp begäran, kan omvandla rubriken och innehållet i klientens begäran. Filter skapar inte en förfrågan eller svar, de ändrar dem bara. Filtret förbehandlar begäran innan det når servleten och bearbetar sedan (om nödvändigt) svaret som kommer från servleten. Filtret kan interagera med olika typer av resurser, i synnerhet, och med servlets och JSP-sidor. Servlet-filter kan:

  • avlyssna initieringen av servletten innan servletten initieras.
  • bestämma innehållet i begäran innan servleten initieras.
  • ändra förfrågningsrubriker och data i vilka den inkommande förfrågan är packad.
  • modifiera svarsrubriker och data i vilka det mottagna svaret är packat.
  • avlyssna initieringen av en servlet efter ett anrop till servleten.

Ett servletfilter kan konfigureras för att fungera med en enda servlet eller grupp av servlets. Grunden för att generera filter är javax.servlet.Filter-gränssnittet, som implementerar tre metoder:

  • void init (FilterConfig config) kastar ServletException;
  • void förstöra ();
  • void doFilter (ServletRequest-begäran, ServletResponse-svar, FilterChain-kedjan) kastar IOException, ServletException;

Metoden init () anropas innan filtret börjar köras och ställer in filtrets konfigurationsobjekt. Metoden doFilter utför själva arbetet med filtret. Således anropar servern init () en gång för att starta filtret, och anropar sedan doFilter () så många gånger som förfrågningar kommer att göras direkt till detta filter. När filtret har avslutat sitt arbete anropas metoden destroy ().

  • Varför behöver du lyssnare i servlets?

Kontext- och sessionslyssnare är klasser som kan hålla reda på när ett sammanhang eller en session initierades, eller hålla reda på när de ska förstöras och när attribut lades till eller togs bort från sammanhanget eller sessionen. Servlet 2.4 utökar förfrågningslyssnarmodellen genom att låta dig spåra hur en begäran skapas och förstörs, och hur attribut läggs till och tas bort från servleten. Följande klasser har lagts till i Servlet 2.4:

  • ServletRequestListener
  • ServletRequestEvent
  • ServletRequestAttributeListener
  • ServletRequestAttributeEvent

  • Hur hanterar jag undantag som kastas av en annan servlet i programmet?

Eftersom webbläsaren bara förstår HTML, kommer servletbehållaren att hantera undantaget och generera ett HTML-svar när applikationen skapar ett undantag. Detta liknar vad som händer med felkoder som 404, 403, etc. Servlet API ger stöd för våra egna servlets för att hantera undantag och fel, som vi kan specificera i distributionsbeskrivningen. Huvuduppgiften för sådana servlets är att hantera felet eller undantaget och skicka ett tydligt HTML-svar till användaren. Du kan till exempel ge en länk till huvudsidan, samt en beskrivning av vissa detaljer om felet.

  • Vad är en distributionsbeskrivning?

Distributionsbeskrivningen är en artefaktkonfigurationsfil som kommer att distribueras i servletbehållaren. I Java Platform, Enterprise Edition-specifikationen beskriver en distributionsbeskrivning hur en komponent, modul eller applikation (som en webb- eller företagsapplikation) ska distribueras.

Den här konfigurationsfilen anger distributionsalternativen för en modul eller applikation med specifika inställningar, säkerhetsalternativ och beskriver de specifika konfigurationskraven. Syntaxen för är XML.

  • Hur implementerar jag en servletstart med en applikationsstart?

Servletbehållaren laddar vanligtvis servleten på den första klientbegäran, men ibland är det nödvändigt att ladda servleten direkt i början av applikationen (till exempel om servleten är skrymmande och kommer att ta lång tid att ladda). För att göra detta måste du använda elementet load-on-startup i deskriptorn (eller loadOnStartup-kommentaren), som kommer att indikera om servleten ska laddas vid start.

Värdet måste vara int. Om värdet är negativt kommer servleten att laddas på klientens begäran, och om 0 och längre kommer den att laddas i början av applikationen. Ju lägre nummer, desto tidigare hamnar servleten i nedladdningskön.

  • Vad är ServletConfig-objektet?

Gränssnittet javax.servlet.ServletConfig används för att skicka konfigurationsinformation till en servlet. Varje servlet har sitt eget ServletConfig-objekt, som servletbehållaren ansvarar för att instansiera. Init-parametrarna i web.xml (eller WebInitParam-annoteringar) används för att ställa in konfigurationsparametrar. Metoden getServletConfig () används för att hämta ServletConfig-objektet för denna servlet.

  • Vad är ServletContext-objektet?

Gränssnittet javax.servlet.ServletContext definierar ett antal metoder som en servlet använder för att kommunicera med sin servletbehållare, som att hämta MIME-typen för en fil, skicka förfrågningar eller skriva till en loggfil. ServletContext-objektet är unikt och tillgängligt för alla servlets i en webbapplikation. Vi kan använda ServletContext-objektet när vi behöver ge tillgång till en eller flera servlets till webbapplikationens initierade parametrar. För att göra detta, använd elementet i web.xml. ServletContext-objektet kan erhållas med metoden getServletContext () i ServletConfig-gränssnittet.

Servlet-behållare kan också tillhandahålla kontextobjekt som är unika för en grupp av servlets. Var och en av grupperna kommer att associeras med en annan uppsättning webbadresser för värdsökvägar.

ServletContext har utökats i Servlet 3-specifikationen och ger programmatiskt tillägg av lyssnare och filter till din applikation. Det här gränssnittet har också många användbara metoder som getMimeType (), getResourceAsStream (), etc.

  • Vad är skillnaden mellan ServletContext och ServletConfig?

Nedan är några av skillnaderna:

  • ServletConfig är ett unikt objekt för varje servlet, medan ServletContext är unikt för hela applikationen.
  • ServletConfig används för att tillhandahålla initieringsparametrar till servleten och ServletContext används för att tillhandahålla aför alla servlets.
  • Vi har inte möjlighet att ställa in attribut i ServletConfig-objektet, medan vi kan ställa in attribut i ServletContext-objektet som kommer att vara tillgängliga för andra servlets.

  • ServletResponse-gränssnitt.

ServletResponse-gränssnittet är ett verktyg för att skicka data till klienten. Alla metoder för detta verktyg tjänar exakt detta syfte.

  • ServletRequest-gränssnitt.

ServletRequest-gränssnittet är ett verktyg för att hämta parametrar för HTTP-begäran. Detta gränssnitt har flera metoder som är identiska till namn och syfte med ServletContext.

  • Vad är Request Dispatcher?

RequestDispatcher-gränssnittet används för att skicka en begäran till en annan resurs (detta kan vara HTML, JSP eller en annan servlet i samma applikation). Vi kan använda detta för att lägga till innehåll från en annan resurs till svaret. Detta gränssnitt används för intern kommunikation mellan servlets i samma sammanhang. Det finns två metoder implementerade i gränssnittet:

  • void forward (ServletRequest var1, ServletResponse var2) - Vidarebefordrar en begäran från servleten till en annan resurs (servlet, JSP eller HTML-fil) på servern.
  • void include (ServletRequest var1, ServletResponse var2) - Inkluderar resursinnehåll (Servlet, JSP eller HTML-sida) som svar.

Gränssnittet kan nås med metoden ServletContext getRequestDispatcher (String s). Sökvägen måste börja med en /, som kommer att tolkas som relativt till sammanhangets aktuella rotväg.

  • Hur kan du skapa ett dödläge i en servlet?

Ett dödläge kan erhållas genom att implementera ett loopat metodanrop, till exempel genom att anropa doPost ()-metoden i doGet ()-metoden och anropa doGet () i doPost ()-metoden.

  • Hur får jag adressen till servleten på servern?

För att få den faktiska sökvägen till servleten på servern, kan du använda denna konstruktion: getServletContext () GetRealPath (request.getServletPath ()).

  • Hur får jag serverinformation från en servlet?

Serverinformation kan erhållas med ServletContext-objektet med metoden getServerInfo (). De där. getServletContext (). getServerInfo ().

  • Hur får man klientens ip-adress på servern?

Använd request.getRemoteAddr () för att hämta klientens ip i servleten.

  • Vad vet du om servlet-inpackningskurser?

Servlet HTTP API tillhandahåller två omslagsklasser, HttpServletRequestWrapper och HttpServletResponseWrapper. De hjälper utvecklare att implementera sina egna implementeringar av förfrågnings- och svarservlettyperna. Vi kan utöka dessa klasser och åsidosätta endast de nödvändiga metoderna för att implementera våra egna svars- och begäranobjekttyper. Dessa klasser används inte i standardservletprogrammering.

Nästan tjugo år har gått sedan programmeringsspråket Java kom. Under denna tid profeterade Java död och glömska, programmerare på marken skrattade åt dess hämning och girighet efter resurser. Men det fanns också de som trodde på Java, de utvecklade alla typer av bibliotek, utvecklade en gemenskap, bevisade envist att det inte finns några gränser för Java: realtid, inbäddad, AI - allt är möjligt. Vi bestämde oss för att inte stå åt sidan och göra en liten serie artiklar om Java i det här avsnittet. Gå!

Din vattenkokare väljer Java

Enligt Oracle själva är den virtuella Java-maskinen för närvarande installerad på mer än tre miljarder enheter. Och det här är inte bara datorer och smartphones, utan också kameror, TV-apparater, Blu-ray-spelare, skrivare, SIM-kort, bankautomater och till och med bilar. Listan kommer att växa stadigt och med det erbjudanden från arbetsgivare för Java-programmerare. Redan nu överstiger antalet lediga jobb för Java-programmerare resten. Och företag är villiga att betala mer och mer, tjuvjagar anställda och organiserar bättre arbetsvillkor.

Och vad är det bra för?

Java-programmerare lockas av syntaxens minimalism. Inga onödiga modifierare och serviceord. Till och med frånvaron av multipelt arv, vilket till en början något förvirrade C++-programmerare, visar sig vara rimligt och motiverat i slutändan. Enkel logik, automatisk minneshantering, detaljerad dokumentation, forum med svar på alla möjliga frågor, öppen källkod - allt detta gör att du snabbt kan fördjupa dig i utvecklingsprocessen och avsevärt minskar antalet potentiella fel. Även indiska bönder lär sig Java på ett par månader, det är åtminstone vad deras diplom säger :). Dessutom är Java ett tolkat språk. Kompilatorn översätter källkoden till så kallad bytecode, som är lätt att konvertera tillbaka, vilket gör Java särskilt attraktivt för reverse engineering.

Nåväl, låt oss börja

Java är ett objektorienterat språk, vilket innebär att alla variabler, metoder, konstanter deklareras inom en klass. Förutom klasser finns det också gränssnitt - en speciell abstrakt konstruktion som låter dig beskriva ett objekts beteende utan att specificera en specifik implementering. Och om det inte finns något multipelt arv av klasser i Java, kan en klass implementera valfritt antal gränssnitt, vilket gör att ett objekt kan ha många funktioner, men bara tillhandahålla en del av dem.

Datatyper kan delas in i två grupper: enkel (int, long, char och så vidare) och objekt: klasser, gränssnitt, arrayer. Enkla typer är alltid och överallt av fast dimension. Till exempel, på vilken arkitektur och vilken enhet som helst, tar en int upp fyra byte minne. Detta är ganska praktiskt för beräkningar. Datamatrisen innehåller en speciell attributlängd, som lagrar storleken på matrisen, för vilket särskilt tack till utvecklarna. Olika typer av data överförs till metoder på olika sätt. Enkla typer passeras alltid av värde. Objekt - alltid genom referens för att spara minne. Detta betyder att om vi skickar int a = 10 och ändrar dess värde till 5 i den anropade metoden, så kommer a i den ursprungliga metoden fortfarande att vara 10. Men om vi ändrar egenskapen för objektet kommer det att ändras i den ursprungliga metoden också.

Kom ihåg minnet

Även om en Java-programmerare är befriad från behovet av att allokera och frigöra minne, kan okunnighet om några av funktionerna i den virtuella maskinen och sopsamlaren lätt förvandla ditt program till ett omättligt monster som slukar CPU-tid och allt tillgängligt minne.

När du skapar en ny array, kom alltid ihåg att det är mycket lättare att skapa många små bitar av minne än en stor. Annars riskerar du att råka ut för ett Minneslöst fel, vilket ungefär betyder att du hade minne, men allt kom ut.

Många programmerare, när de byter till Java och lär sig om automatisk minnesrensning, börjar skapa objekt i enorma mängder, i hopp om att allt detta ska klarna av sig själv. Samtidigt är en sophämtare som en maskin som kan plocka upp sopor som bara slängs i en papperskorg nära ett hus. Om du inte längre behöver vissa data, bör du inte lagra den ifall, som en hög med gamla vykort - tilldela pekaren till datan null, hjälp städaren att städa upp :). Det är också bra att göra listan tydlig om du inte redan behöver den. Kom ihåg att objektet kommer att lagras i minnet så länge det finns referenser till det i koden. Även om ditt program körs på 16 gigabyte minne och inte hotar att krascha med Out of memory, kommer det att bli mer och mer klumpigt och långsamt av ett överskott av använt minne. 99 % av användarklagomålen om långsamma Java-program beror på ineffektivt skriven källkod. Om du ständigt behöver skapa objekt som används snabbt och som inte längre behövs, till exempel många små meddelanden, överväg att skapa en pool som kommer att lagra ett antal instanser för upprepad användning. Kom ihåg att det är kostsamt att skapa och ta bort ett objekt.

För sakens skull, mina herrar

Ett exempel är bättre än tusen ord. Du kan bläddra igenom manualen och titta på standard Hellowords utan oss, så vi antar att du redan har gjort detta och är redo att implementera ett mer intressant exempel.

Du och jag kommer att ta hand om serverapplikationen av Java och skriva ett litet program för att "spionera" användarna av sociala nätverk. För att göra detta behöver du inte ens hitta ett jobb på NSA - användarna sprider allt till sig själva, och vi behöver bara få denna information, organisera den och visa den vackert. Låt oss ta en av de populära socialtjänsterna, till exempel foursquare, och rita upp våra vänners rörelse på en karta.

Låt oss först se vad vi kan dra ut ur foursquare. Efter att ha gått igenom utvecklarsidorna riktar vi vår uppmärksamhet mot två metoder:

  • https://developer.foursquare.com/docs/users/checkins - Platser som användaren besöker. Tyvärr stöds det än så länge bara för den användare som är registrerad i programmet, och det finns rykten om att det på grund av implementeringsbegränsningar kommer att förbli så;
  • https://developer.foursquare.com/docs/checkins/recent - platser besökta av vänner till den registrerade användaren. Om du leker lite med den här funktionen blir ett tråkigt faktum tydligt: ​​för varje vän returneras exakt en plats - den sista där han checkade in.

För att använda foursquare API måste du registrera vår framtida applikation, gå till denna adress: https://en.foursquare.com/developers/register och fyll i fälten (ja, du måste registrera dig i själva foursquare, men du klarar det bra utan mig).

Av de viktiga fälten kan du endast markera "Application name", "Download / Welcome page url" (ange en godtycklig webbadress här) och "Redirect URI(s)" - detta är adressen som servern skickar oss till efter registrering. Vi kommer att skriva det önskade värdet här senare, men för närvarande kan du bara ange vilken webbadress som helst. Klicka på "Spara" och vår spårningsapp har registrerats framgångsrikt.

Att klättra upp i molnen

Captain Obvious förmedlar att alla serverapplikationer kräver en server för att köras. Höj servern själv hemorrojder, så vi kommer att använda de nu populära molnlösningarna. Molnet kommer att sponsras av Google Corporation, eftersom deras Google App Engine är gratis, ganska lätt att installera och använda. Gå först hit och ladda ner Google App Engine SDK för Java.

Nu kan du börja skapa ditt projekt. För Java-utveckling använder jag IntelliJ IDEA, men du kan använda den kostnadsfria och lika välkända Eclipse-miljön.

Låt oss välja ett nytt Java-projekt. Låt oss kalla det nsa_tracker.


På nästa flik, markera webbapplikationen och Google App Engine till vänster och ange sökvägen till den tidigare nedladdade och uppackade App Engine SDK.


Luta dig nu tillbaka och låt IDE göra sitt. Om du valde IDEA och gjorde allt korrekt, kommer du som ett resultat att se ett färdigt projekt som, när det startas, öppnar ett webbläsarfönster med tomt innehåll. Du kan börja koda.

Vi börjar leta

Så vi har en mapp med ett projekt, som innehåller src-mappen. Vi kommer att lägga källorna där. Java-källor är grupperade efter paket. Ett paket är en mapp på disken. Paket behövs för att inte samla alla källor i en hög, utan för att separera dem, styrt av logikens principer. Det skulle till exempel vara logiskt att lägga koden relaterad till användargränssnittet i ui-paketet och nätverksinteraktioner i nätverkspaketet. Detta underlättar avsevärt utvecklingen och stödet av projektet senare. Historiskt sett har det varit praxis att starta paketstrukturen med företagsnamnet följt av programnamnet. Detta kommer att hjälpa till att enkelt identifiera våra källor bland högen av samma i framtiden. För vårt program kommer vi att skapa org.nsa.tracker-paketet. I den kommer vi att skapa klasser.

Servlets används på servern för att behandla användarförfrågningar. En servlet är en klass som vanligtvis ärver från HttpServlet och fungerar på basis av begäran-svar. Allt du behöver är att åsidosätta doGet-metoden. På begäran från användaren måste vi logga in på foursquare, ladda ner listan över vänners incheckningar och omdirigera förfrågan till sidan med kartan.

För att arbeta med foursquare API kommer vi att använda det fria foursquare-api-java-biblioteket, som kan hämtas härifrån. Java Library är ett ZIP-arkiv med en jar-tillägg som innehåller kompilerade Java-klasser som implementerar specifik funktionalitet. För auktorisering behöver vi ClientId och ClientSecret som erhållits vid registreringsstadiet av ansökan i foursquare. Eftersom dessa parametrar inte ändras under programkörning kommer vi att deklarera dem som konstanter.

Privat statisk slutsträng CLIENT_ID = "FAKE_CLIENT_ID"; privat statisk slutsträng CLIENT_SECRET = "FAKE_CLIENT_SECRET";

Final betyder att denna variabel har tilldelats ett slutvärde som inte kan ändras. Static gör variabeln tillgänglig för alla instanser av den givna klassen. Med hjälp av auktoriseringsexemplet från foursquare-api-java-biblioteket får vi följande kod:

Skyddad void doGet (HttpServletRequest req, HttpServletResponse resp.) kastar ServletException, IOException (FoursquareApi foursquareApi = new FoursquareApi (CLIENT_ID, CLIENT_SECRET, CALLBACK_URL. getPara-kod req.) .getAuthenticationUrl ());) else (försök (foursquareApi.authenticateCode (kod); // Registrering lyckad, ladda data Resultat result = foursquareApi.checkinsRecent ("0.0,0.0", 100, 0l); ) catch (FoursquareApiException e) (e.printStackTrace ();)))

Lägg märke till "kastar ServletException, IOException" i metoddeklarationen. Denna rad betyder att metoden potentiellt kan kasta ett av dessa undantag. Ett undantag i Java är ett objekt som signalerar när ett undantag har kastats. De är verifierbara och icke verifierbara. Markerade undantag bör hanteras genom att omge en del av koden med ett försöksfångstblock, eller skickas ovanför. Omarkerade undantag hanteras vanligtvis inte eftersom de kastas i fall där programmet inte kan återställa sitt tillstånd. I den här metoden hanterar vi bara FoursquareApiException.

När webbservern tar emot en begäran om en applikation, använder den en distributionsbeskrivning för att matcha webbadressen för begäran med koden som behöver behandla begäran. Distributionsbeskrivningen är en XML-fil med namnet web.xml. Låt oss lägga till en beskrivning av spårningsservleten.

Spår org.nsa.tracker.TrackerServlet Spår / Spår

Nu kommer förfrågningar att / spåra att hanteras av vår TrackerServlet. Du kan ställa in Callback URL-parametern till rätt värde http: // localhost: 8080 / track.

För att visa resultaten kan du använda Static Maps API, vänligen tillhandahållet av samma Google-företag (https://developers.google.com/maps/documentation/staticmaps/). Vår servlet kommer att generera en enkel HTML-sida och returnera den som svar på en användarförfrågan.

StringBuilder sb = new StringBuilder (" NSA-spårare"); sb.append (" "); sb.append ("

    "); index = 1; för (Incheckning: result.getResult ()) (sb.append (" ") .append (index ++). append (" - ") .append (checkin.getUser (). getFirstName ()) .append (" ") .append (checkin.getUser (). getLastName ()). append ("");) sb.append ("
"); sb.append (" ");

För att generera sidan används klassen StringBuilder, detta beror på att strängar i Java är oföränderliga objekt. När du sammanfogar strängar med operatorn +. en ny rad skapas i minnet. StringBuilder sparar minne genom att använda en char-array för att lagra sammanlänkade strängar. Vi skickar svaret till användaren:

Byte resultBytes = sb.toString (). GetBytes ("utf-8"); resp.setContentLength (resultBytes.length); resp.getOutputStream (). skriv (resultBytes);

... Och allt är klart. Vi lanserar den och ser något som liknar en bild med talesättet "Resultatet av programmets arbete".


Vad kommer härnäst?

Applikationen kan förbättras, till exempel för att separera datainsamling och visning. Flytta insamlingen av data till en separat tjänst som kommer att fungera konstant och komma ihåg alla användarrörelser i databasen. Då kommer det att vara möjligt att visa inte enskilda punkter, utan en ansluten rutt. Genom att gräva lite i foursquare API kan du extrahera ännu mer information om användaraktivitet.

Men jag hoppas att jag lyckades med huvudsaken: att övertyga dig om att Java är enkelt och coolt. Vi ses om en månad!

Böcker för Java-programmerare

Vi rekommenderar att du börjar lära dig språket med boken ”Java. En nybörjarguide av Herbert Schildt. Nästa nivå är "Java. Den kompletta guiden "från honom, och du kan lära dig mer om servlets i boken" Java Servlet och JSP Cookbook "av Bruce W. Perry.

Servletär ett java-program som körs på serversidan av en webbapplikation. Precis som appletar dynamiskt utökar funktionaliteten hos en webbläsare, utökar servlets dynamiskt funktionaliteten hos en webbserver.

Arbete servlett"men kan beskrivas enligt följande: när en begäran kommer från en klient kan webbservern använda en speciell konfigurationsfil för att bestämma vilken servlet som ska köras. Därefter startar webbservern JVM, som i sin tur kör servleten. Servlet bearbetar begäran och överför innehållet till webbservern (eventuellt i form av en HTML-sida) Webbservern skickar ett svar (en servlet-genererad HTML-sida) till klienten.

En WEB-server är i grunden en slags behållare som laddas servlett"s, exekverar dem och, efter att ha fått resultatet från dem, skickar det till klienten.

Servlet i webbapplikationsarkitektur

På grund av dess kraft och flexibilitet, servlett"Du kan spela en betydande roll i systemets arkitektur. De kan utföra applikationsuppgifter avsedda för mellanskiktet, fungera som en proxyserver för klienten och till och med förbättra funktionaliteten i mellanskiktet genom att lägga till stöd för nya protokoll och andra funktioner Mellanskiktet fungerar som en applikationsserver i det så kallade treskiktsklient-serversystemet och är placerad mellan en "lättviktig" klient, såsom en webbläsare, och datakällan.

Servlet som proxyserver

För att stödja appletar kan servlets fungera som deras proxyservrar. Detta kan vara viktigt eftersom Java-säkerhet endast tillåter appletar att ansluta till servern från vilken de laddades ner. Om appleten behöver ansluta till en databasserver på en annan dator, servlett kan skapa denna anslutning för appleten.

Tillfälligt och permanent servlett"NS

Servlets kan starta och stoppa för varje klientförfrågan. De kan också starta när webbservern startar och existera tills den stannar. Temporär servlett"s laddas på begäran och erbjuder ett bra sätt att spara serverresurser för sällan använda funktioner. Beständiga servlets laddas när webbservern startar och existerar tills webbservern stängs av. Servlets installeras som beständiga tillägg till servern om overhead är mycket hög (som att upprätta en databasanslutning) om de erbjuder beständig funktionalitet på serversidan (som en RMI-tjänst), eller i fall där de behöver svara på klientförfrågningar så snabbt som möjligt. servlett"men permanent eller tillfälligt; detta är en funktion för att konfigurera webbservern.

Servlets livscykel, javax.servlet.Servlet

Servlets körs på webbserverplattformen som en del av samma process som själva webbservern. Webbservern ansvarar för att initiera, anropa och förstöra varje instans av servleten. Webbservern kommunicerar med servleten genom ett enkelt gränssnitt: javax.servlet.Servlet.

Gränssnittet javax.servlet.Servlet inkluderar tre huvudmetoder:

  • i det ()
  • tjänst ()
  • förstöra ()

och två hjälpmetoder:

  • getServletConfig ()
  • getServletInfo ()

Likheter mellan gränssnitt servlett"ah och Java-appletar är uppenbara. Det är precis vad det var designat för att göra! Java-servlets är för webbservrar vad appletar är för webbläsare. En applet körs i en webbläsare och utför åtgärder på begäran genom ett speciellt gränssnitt. En servlet gör samma sak när du arbetar på en webbserver.

Servlet-initiering, init ()-metod

Första gången servleten laddas anropas metoden init (). Detta gör att servleten kan utföra alla installationsarbeten, som att öppna filer eller upprätta anslutningar till sina servrar. Om servleten är permanent installerad på servern laddas den när servern startar. Annars anropar servern servleten när den tar emot den första begäran från en klient att utföra en tjänst som tillhandahålls av den servleten.

Det är garanterat att metoden i det () kommer att avslutas före alla andra anrop till servleten - som till exempel ett metodanrop tjänst ()... anteckna det i det () kommer bara att ringas en gång; den kommer inte att anropas förrän servleten laddas ur och sedan laddas av servern igen.

Metod i det () tar ett argument - en objektreferens ServletConfig som innehåller argument för att initiera servleten. Detta objekt har en metod getServletContext () returnera ett objekt ServletContext som innehåller information om servletens miljö.

Servlet kärna, tjänst () metod

Metod tjänst ()är servlettens hjärta. Varje begäran från klienten resulterar i ett metodanrop tjänst ()... Denna metod läser begäran och konstruerar ett svarsmeddelande med hjälp av dess två argument ServletRequest och ServletResponse:

Det finns alltså två sätt att överföra information från klienten till servleten. Den första är genom att skicka värden i förfrågningsparametrar. Parametervärden kan infogas i URL:en. Det andra sättet att överföra information från klienten till servleten är genom en InputStream (eller Reader).

Metodarbete tjänst () i grunden enkelt - det skapar ett svar på varje klientförfrågan som skickas till den från servern. Tänk dock på att det kan finnas flera parallella förfrågningar som behandlas samtidigt. Om metoden tjänst () kräver externa resurser, såsom filer, databaser, är det nödvändigt att säkerställa att åtkomsten till resurserna är trådsäker.

Lossa en servlet, förstöra () metod

Metod förstöra () anropas för att frigöra alla resurser (såsom öppna filer och databasanslutningar) innan servleten laddas ur. Denna metod kan vara tom om det inte finns något behov av att utföra några efterbehandlingsåtgärder. Innan du anropar metoden förstöra () servern väntar antingen på att alla serviceåtgärder ska slutföras eller på att en viss tid löper ut. Detta innebär att metoden förstöra () kan anropas medan någon långkörningsmetod körs tjänst ().

Det är viktigt att formalisera metoden förstöra () på ett sådant sätt att man undviker att stänga de nödvändiga resurserna tills alla samtal tjänst () kommer inte att ta slut.

Servlet-konfiguration, getServletConfig ()-metoden

Metod getServletConfig () returnerar en referens till ett objekt som implementerar gränssnittet ServletConfig... Detta objekt ger tillgång till, dvs. åtkomst till servletinitieringsparametrar och servletkontextobjekt ServletContext som ger tillgång till servleten och dess miljö.

Servlet information, getServletInfo () metod

Metod getServletInfo () definieras av programmeraren som skapar servleten för att returnera en sträng som innehåller information om servleten, såsom författaren och versionen av servleten.

ServletRequest-gränssnitt

ServletRequest tillhandahåller klientinformation om parametrarna för HTTP-begäran till servleten, dvs. tillhandahåller data inklusive parameternamn och värden, attribut och en indataström. Denna information skickas till metoden tjänst ().

Nästa servlet exempel visar hur man får information från en parameter begäran metod tjänst ():

BufferedReader-läsare; Sträng param1; String param2; offentlig void-tjänst (ServletRequest-begäran, ServletResponse-svar) (reader = request.getReader (); param1 = request.getParameter ("First"); param2 = request.getParameter ("Andra");)

Ytterligare information om begäran är tillgänglig för servleten genom metoder, varav de viktigaste visas i följande tabell:

getAttribute () Returnerar värdet för det angivna attributet för denna begäran.
getContentLength () Begär storlek, om känd.
getContentType () Returnerar MIME-typen för begärandekroppen.
getInputStream () Returnerar en InputStream för att läsa binär data från begärandekroppen.
GetParameterNames () Returnerar en array av strängar med namnen på alla parametrar.
getParameterValues ​​() Returnerar en matris med värden för den angivna parametern.
getProtocol () Returnerar protokollet och versionen för begäran som en sträng av formuläret /..
getReader () Returnerar en BufferedReader för att hämta texten från förfrågans brödtext.
getRealPath () Returnerar den verkliga sökvägen för den angivna virtuella sökvägen.
getRemoteAddr () IP-adressen till klienten som gör denna begäran.
getRemoteHost () Värdnamnet för klientdatorn som gjorde denna begäran.
getScheme () Returnerar schemat som används i URL:en för denna begäran (till exempel https, http, ftp, etc.).
getServerName () Värdnamnet på servern som accepterade begäran.
getServerPort () Returnerar portnumret som användes för att ta emot denna begäran.

ServletResponse-gränssnitt

Gränssnitt ServletResponseär ett verktyg för att skicka data till en klient. Alla metoder för detta verktyg tjänar exakt till att lösa detta problem:

Public java.lang.String getCharacterEncoding () public void setLocale (java.util.Locale loc) public java.util.Locale getLocale ()

Den första metoden returnerar den MIME-typ av kodning (till exempel UTF8), där informationen kommer att visas. De två andra metoderna fungerar också med teckenuppsättning. De anger språket som används i dokumentet (till exempel - ryska).

Public ServletOutputStream getOutputStream () kastar java.io.IOException

Metoden getOutputStream returnerar en utdataström för servleten. Denna ström används till exempel för att mata ut binärer. Textdata kan matas ut med java.io.Writer:

Public java.io.PrintWriter getWriter () kastar java.io.IOException

Metoden getWriter () konverterar automatiskt strängar till den teckenuppsättning som anges i metoderna getCharacterEncoding () och getLocale ().

Public void setContentLength (int len)

Metoden setContentLength anger värdet för HTTP-huvudet "Content-Length"

Public void setContentType (strängtyp)

Metoden setContentType används för att skicka dokumentets MIME-innehållstyp. HTTP-huvudfältet "Content-Type".

Utgångsströmmen buffras. Detta innebär att en bit data kommer att returneras till klienten först efter att bufferten är full.

Public void setBufferSize (int size) public int getBufferSize () public void flushBuffer () kastar java.io.IOException public void resetBuffer ()

Ovanstående 4 metoder gör det möjligt att ställa in storleken på sändningsbufferten, få dess storlek, initiera att skicka innehållet i bufferten till klienten utan att vänta på att den fylls, och även rensa denna buffert med data.

Public boolean isCommitted ()

Med isCommitted-metoden kan du få en flagga om sändningen av data till klienten redan har börjat. Flaggan kommer att vara positiv om HTTP-svarshuvudet redan har skickats.

Offentlig ogiltig återställning ()

Om HTTP-huvudet inte har skickats ännu, "återställer" återställningsmetoden HTTP-huvudet till dess "standardvärden".

JFreeChart-diagram i servlets

JFreeChart-grafikbiblioteket kan användas i servlets för att skapa diagram och visa dem på webbplatsens sidor som bilder. Detaljer och exempel på hur JFreeChart används i servlets finns.

Servlet med Chart.js grafikbibliotek

JNI i servlett

I vissa fall kan du behöva använda JNI i en WEB-applikation. Ett exempel på hur JNI används i servlets finns.

JMS-meddelanden i en servlet

Servlet kan användas för att byta JMS meddelanden mellan applikationer. Ett exempel på användning av en servlet för att skicka och läsa JMS-meddelanden i en JBoss-behållare tillhandahålls.

Vad är servlets? Servlets är faktiskt HTTP- och FTP-bearbetningsmoduler som används för att bygga webbgrindar.

Grunden för dessa portaler är själva WEB-servern - ett program som håller serversocket, tar emot och överför data. Oftast, för att påskynda arbetet, är servern inte skriven i Java, utan i något annat programmeringsspråk (till exempel i C ++).

En grundläggande servlet fungerar tillsammans med servern. Det är till honom som servern skickar data och från honom tar emot svaret som skickas till klienten. Faktum är att den underliggande servleten är "hjärnan" på servern. Huvudfunktionen för denna servlet är att läsa klientens begäran, dekryptera den och, i enlighet med dekrypteringen, överföra arbetet till den servlet som ansvarar för denna typ av begärd information. Ofta fungerar servern själv som den underliggande servleten för att uppnå hastighet. Det är precis så här Jacarta Tomcat fungerar.

Figuren visar ett diagram över överföringen av samtal (förfrågningar) och svar (svar) mellan servern och servlets. Detta diagram visar driften av en HTTP-server som har flera JSP-sidor och två resurser "/ sample1" och "/ sample2", som bearbetas av två servlets - "Sample1 Servlet" respektive "Sample2 Servlet".

Låt oss analysera steg för steg vad som visas i figuren:

  1. klienten ansluter till servern
  2. servern skickar begäran till "Basic Servlet"
  3. den underliggande servleten extraherar resurs-URI från begäran
    • om URI:n pekar på "/ sample1" så är begäran helt(oförändrad) skickas till "Sample1 Servlet"-servleten, som vidarebearbetar denna begäran
    • om URI:n pekar på "/ sample2", skickar servern begäran till "Sample2 Servlet"
    • i alla andra fall skickas begäran till modulen "JSP Servlet".
  4. servleten som fick kontroll bearbetar data, skapar ett svar och sedan skickas svaret tillbaka till den underliggande servleten.
  5. basservleten, utan att bearbeta den mottagna datan, skickar den omedelbart tillbaka till servern
  6. servern utfärdar data till klienten

Således är uppgiften att behandla en förfrågan uppdelad i logiska delar, för var och en av vilka en separat modul, sin egen "mjukvarubricka", är ansvarig. Faktum är att det kan finnas många fler steg i behandlingen av en förfrågan. Till exempel kan olika moduler ansvara för metoderna "GET" och "POST".

Servlet-gränssnitt

Gemensamt för alla dessa moduler är att de är sammankopplade från ände till ände med hjälp av javax.servlet.Servlet-gränssnittet

Låt oss ta en titt på det här gränssnittet. Den listar bara 5 metoder:

Public void init (ServletConfig config) kastar ServletException Denna metod anropas för att informera servleten om att den ingår som en modul för att betjäna klientförfrågningar. Config-parametern separerar javax.servlet.ServletConfig-gränssnittet, som innehåller information om servermiljön, servletnamn, initialparametrar och andra godsaker. Gränssnittet javax.servlet.ServletConfig kommer att diskuteras lite senare. Det antas att efter att ha anropat den här funktionen kommer servleten att spara den här konfigurationen i sin variabel och utfärda den med en annan metod: public ServletConfig getServletConfig () Efter att ha tagit emot systeminformation med "getServletConfig ()", kanske servern vill ta reda på det författarens namn, datum för skapande, annan information om servleten, vilket uppnås genom att anropa public String getServletInfo ()

För att bearbeta begäran och få resultatet av dess bearbetning, använd funktionen

Offentlig void-tjänst (ServletRequest-förfrågan, ServletResponse-svar) kastar ServletException, java.io.IOException I den här funktionen skickas två verktyg till koden som ska behandla data: ett för att ta emot data från servern och det andra för att skicka resultatet av servletten. Följaktligen är dessa förfrågnings- och svarsparametrar som separerar javax.servlet.ServletRequest och javax.servlet.ServletResponse-gränssnitten. Allt arbete med data utförs exakt genom dessa gränssnitt, så låt oss prata om dem mer i detalj.

Efter att servern inte längre behöver denna modul anropas metoden

Public void destroy () som slutför alla operationer med servletobjektet.

ServletConfig-gränssnitt

De fyra självförklarande metoderna utgör javax.servlet.ServletConfig-gränssnittet:

Public String getServletName () public ServletContext getServletContext () public String getInitParameter (String name) public java.util.Enumeration getInitParameterNames ()

Jag tror att syftet med alla funktioner är tydligt, förutom

Public ServletContext getServletContext () Denna metod returnerar en länk till ett mycket användbart serververktyg:

ServletContext-gränssnitt

ServletContext är ett gränssnitt som definierar åtkomst till följande mycket användbara funktioner:

Public Object getAttribute (String name) public java.util.Enumeration getAttributeNames () public void setAttribute (String name, Object object) public void removeAttribute (String name) Fyra metoder för att arbeta med attribut. Attributens roll utförs av vilket objekt som helst av vilken klass som helst. Syftet med dessa funktioner är att överföra olika objekt mellan orelaterade servlets. public String getInitParameter (String name) public java.util.Enumeration getInitParameterNames () Tillgång till parametrarna som servern startades med. Det kan också finnas ett värdnamn, port och andra användbara saker. public int getMajorVersion () public int getMinorVersion () Returnerar Servlet API-versionerna. public String getMimeType (String file) Returnerar den MIME-typ som är associerad med filen som anges i filvariabeln. Kom ihåg hur du var tvungen att definiera MIME i SimpleWEBServer och uppskatta bekvämligheten! public java.util.Set getResourcePaths () public java.net.URL getResource (strängsökväg) kastar java.net.MalformedURLException public InputStream getResourceAsStream (strängsökväg) Returnerar sökvägar till resurser som är tillgängliga för servern och själva resurserna som webbadresser och strömmar data . public RequestDispatcher getRequestDispatcher (sökväg) public RequestDispatcher getNamedDispatcher (namn) RequestDispatcher är ett verktyg för att vidarebefordra en begäran till en annan resurs. Dessa funktioner behövs för att få objektet för detta verktyg för de angivna resurserna. Det vill säga, för att vidarebefordra en begäran till servleten "sample1" från servletkroppen, kan du göra detta: getServletConfig (). GetServletContext (). GetNamedDispatcher ("sample1"). Forward (begäran, svar);

Själva klassen RequestDispatcher innehåller bara två metoder:

Public void forward (ServletRequest request, ServletResponse response) throws ServletException, java.io.IOException public void include (ServletRequest request, ServletResponse response) throws ServletException, java.io.IOException Den första är att omdirigera begäran, och den andra är att inkludera resultatet av den anropade servleten till resultatet av den nuvarande. Till exempel, servlet 1 skriver ut ordet "test 1", anropar sedan inkluderar för servlet två och skriver sedan ut ordet "test 2". Servlet 2 skriver bara ut ordet "och". Servlet 1 kommer att mata ut strängen "test 1 och test 2". public void log (String msg) Skriv något till serverloggen. public void log (String message, Throwable throwable) Definiera ett undantag och en fras som kommer att loggas när detta undantag tas emot. public String getRealPath (String path) Översätter en sökväg som "/index.html" till "http: //host/contextPath/index.html" public String getServerInfo () Returnerar servernamnet. public ServletContext getContext (String uripath) Denna metod låter dig utbyta ServletContext mellan olika resurser på samma server. public String getServletContextName () Returnerar namnet på den servlet som detta ServletContect-gränssnittsobjekt tillhör.

ServletRequest-gränssnitt

ServletRequest-gränssnittet är ett verktyg för att hämta parametrar för HTTP-begäran. Det här gränssnittet har flera metoder som är identiska till namn och syfte med ServletContext:

Public Object getAttribute (String name) public java.util.Enumeration getAttributeNames () public void setAttribute (String name, Object o) public void removeAttribute (java.lang.String name) public String getServerName () public RequestDispatcher getRequestDispatcher (String sökväg)

Med de återstående metoderna kan du bekvämt arbeta med HTTP-förfrågningshuvudet:

Public String getCharacterEncoding () public void setCharacterEncoding (String env) kastar java.io.UnsupportedEncodingException Arbetar med teckenkodning i HTTP-huvudfält. Funktionerna ställer in metoden för att dekryptera CGI-förfrågningar från % NN-formuläret till vanliga tecken. Till exempel vilken standard - KOI8-R, windows-1251 eller UTF-8 - ska användas för att dekryptera kyrilliska tecken. public int getContentLength () public String getContentType () Läser fälten "Content-Length", "Content-Type" från HTTP-förfrågan. public jString getParameter (String name) public java.util.Enumeration getParameterNames () public String getParameterValues ​​(String name) public java.util.Map getParameterMap () Funktioner för att hämta ett fält från HTTP-huvudet och dess värde. public ServletInputStream getInputStream () kastar java.io.IOException public java.io.BufferedReader getReader () kastar java.io.IOException Hämta den inkommande dataströmmen eller dess "läsare". Reader används för att läsa textinformation - den kommer automatiskt att dekryptera strängar enligt den angivna teckenuppsättningen. Uppmärksamhet! Det finns en betydande bugg i J2EE 1.3: vid dekryptering av % 25-tecknet (tecknet % i Post och Get-förfrågningar) ger Reader ett fel (felet ses på Tomcat 4 och Resign-servrarna). Det är möjligt att en liknande bugg finns med andra symboler. public String getProtocol () Hämta HTTP-versionen av förfrågningsprotokollet (till exempel "HTTP / 1.1"). public String getScheme () Returnerar namnet på förfrågningsschemat. Till exempel "http", "https" eller "ftp". public int getServerPort () public String getRemoteAddr () public String getRemoteHost () public boolean isSecure () Serverport, klient-IP, klientens värdnamn och om anslutningen är privat (HTTPS) public java.util.Locale getLocale () public java.util .Enumeration getLocales () Kundens föredragna dokumentspråk (resultatet av bearbetning av fältet "Acceptera-språk")

ServletResponse-gränssnitt

ServletResponse-gränssnittet är ett verktyg för att skicka data till klienten. Alla metoder för detta verktyg tjänar exakt detta syfte:

Public java.lang.String getCharacterEncoding () public void setLocale (java.util.Locale loc) public java.util.Locale getLocale () Den första metoden returnerar MIME-typen av kodning (till exempel UTF8), i vilken information kommer att finnas visas. De två andra metoderna fungerar också med teckenuppsättning. De anger språket som används i dokumentet (till exempel - ryska). public ServletOutputStream getOutputStream () kastar java.io.IOException Returnerar utdataströmmen för servleten. Denna ström används till exempel för att mata ut binärer. Textdata kan matas ut med java.io.Writer: public java.io.PrintWriter getWriter () kastar java.io.IOException Denna metod konverterar automatiskt strängar till den teckenuppsättning som anges i metoderna getCharacterEncoding () och getLocale (). public void setContentLength (int len) Den här metoden ställer in värdet för HTTP-huvudfältet "Content-Length" public void setContentType (String type) Metod för att skicka dokumentets MIME-innehållstyp. HTTP-huvudfältet "Content-Type". public void setBufferSize (int size) public int getBufferSize () public void flushBuffer () kastar java.io.IOException public void resetBuffer () Poängen är att utdataströmmen är buffrad. Detta innebär att nästa bit data kommer att skickas till klienten först efter att bufferten är full. Dessa metoder gör det möjligt att ställa in storleken på sändningsbufferten, få dess storlek, initiera att skicka innehållet i bufferten till klienten, utan att vänta på att den fylls, samt rensa denna buffert med data. public boolean isCommitted () Med den här metoden kan du få en flagga om data redan har skickats till klienten. Flaggan kommer att vara positiv om HTTP-svarshuvudet redan har skickats. public void reset () Om HTTP-huvudet inte har skickats än, "återställer" denna metod HTTP-huvudet till dess "standardvärden".

Fördefinierade Servlettyper

Java Servlet API innehåller, förutom de faktiska gränssnitten, även flera servletklasser som kan fungera som bas för dina program.

Basen för alla dessa klasser är den abstrakta klassen javax.servlet.GenericServlet:

Offentlig abstrakt klass GenericServlet implementerar Servlet, ServletConfig, java.io.Serializable

Som du kan se från definitionen av den här klassen har den alla metoder för Servlet- och ServletConfig-gränssnitten. Den enda oimplementerade metoden är

Offentlig abstrakt void-tjänst (ServletRequest req, ServletResponse res) kastar ServletException, java.io.IOException som förklarades abstrakt.

På basis av denna klass skapades en annan abstrakt klass - javax.servlet.http.HttpServlet:

Offentlig abstrakt klass HttpServlet utökar GenericServlet implementerar java.io.Serializable

Denna klass skapades i enlighet med konceptet "ännu mer bekvämlighet för programmeraren" och har många användbara metoder:

Skyddad void doDelete (HttpServletRequest req, HttpServletResponse resp) kastar ServletException, java.io.IOException skyddad void doGet (HttpServletRequest req, HttpServletResponse resp.) kastar Servlet. throwException requestio. HttpServletResponse resp) kastar ServletException, java.io.IOException skyddad void doPost (HttpServletRequest req, HttpServletResponse resp) kastar Servlet.Exception kastar ServletException, java.io.IOException skyddad void mottagande doTrace, throwtSerp. IOException-skyddad void-tjänst (HttpServletRequest req, HttpServ throws, java. resp. , ServletR esponse res) kastar ServletException, java.io.IOException Olika tjänstealternativ (ServletRequest req, ServletResponse res) för olika HTTP-metoder från DELETE och GET till PUT och TRACE. Och för att bekvämt ta emot data via CGI-gränssnittet utan att dekryptera huvudet skapades klasserna HttpServletRequest och HttpServletResponse, som ingår i HttpServlet i javax.servlet package.http protected long getLastModified (HttpServletRequest Request the time) Denna metod returnerar tiden. av den senaste modifieringen av HttpServlet-objektet req Det tar tidsvärdet från "Datum"-fältet i HTTP-förfrågans huvud. Om fältet inte hittas returnerar det -1.

Följaktligen kommer vi att analysera gränssnitten HttpServletRequest och HttpServletResponse. De ärver från ServletRequest respektive ServletResponse.

HttpServletRequest har, förutom metoderna som ärvts från ServletRequest, också följande mycket användbara metoder:

Cookie getCookies () Returnerar uppsättningen cookies som skickats av klienten till servern.

Cookie-klassen, som är en del av samma javax.servlet.http-paket, innehåller all möjlig information om en cookie. De viktigaste metoderna i denna klass är

Int getMaxAge () String getName () String getValue () anger hur mycket tid denna cookie har kvar att leva, namnet på cookien och dess värde. Också Cookie (String name, String value) void setValue (String newValue) void setMaxAge (int expiry) för att skapa en cookie, ställa in dess värde och högsta ålder. long getDateHeader (String name) Returnerar datumet från HTTP-huvudet, om det finns något. int getIntHeader (java.lang.String name) Returnerar det numeriska värdet för fältet med namnet från HTTP-förfrågningshuvudet String getMethod () Returnerar HTTP-förfrågningsmetoden. String getQueryString () String getRequestURI () StringBuffer getRequestURL () Returnerar strängen som finns i dokumentets URL efter "?"-tecknet, dokumentets URI och hela URL:en. HttpSession getSession () HttpSession getSession (boolean create) boolean isRequestedSessionIdFromCookie () boolean isRequestedSessionIdFromURL () boolean isRequestedSessionIdValid () Funktioner. så att du kan arbeta med en så viktig dataöverföringsmekanism som sessioner.

Sessioner behövs för att dra data från sida till sida efter användaren. En användare besöker till exempel sida (1), där en del data skickas till honom för sida (2), och att man sparar några andra saker för sida (3).

I princip kan du på sidan (1) skicka data till användaren, sedan få den på sidan (2), lägga till något, skicka den till användaren ... På så sätt måste du hela tiden skicka hela datamängden från klienten till servern och tillbaka, och många gånger. Förutom att sådan vidarebefordran inte alltid är bekväm, äter den också upp trafik.

Du kan göra samma sak annorlunda - använd sessionsmekanismen. Denna mekanism fungerar enligt följande: servern sparar data som skickas av användaren i en separat fil - sessionsfilen. Allt arbete med att ändra data kommer att göras med innehållet i denna fil. Klienten ges en "sessionsnyckel" (alias Session key, aka Sesseion ID) - en unik pekare till en fil som innehåller data specifikt för denna användare. Nu, för att ta emot all data om denna klient, behöver servern bara känna till sessionsnyckeln. Fördelen med denna metod är bekvämligheten och hastigheten av dess användning.

Dessa är alla huvudmetoderna i HttpServletRequest-gränssnittet. För en fullständig lista över metoder, se Java Servlet API-dokumentationen.

Nu om HttpServletRequest-gränssnittet. Den största skillnaden mellan klasserna som delar detta gränssnitt är att data inte matas ut omedelbart. Först samlas all data till ett HTTP-svar. Svaret skickas först efter att HttpServlet.service () har körts färdigt.

Och så, om metoderna:

Void addHeader (String name, String value) void addIntHeader (String name, int värde) void addDateHeader (String name, long date) Metoder lägger till parametrar till HTTP-huvudet. Den sista metoden ställer in parametern "Datum". void addCookie (Cookie-cookie) Metoden lägger till en cookie i rubriken boolean containsHeader (String name) Låter dig ta reda på om rubriken redan innehåller den angivna parametern. String encodeURL (String url) String encodeRedirectURL (String url) Den första metoden kodar tecken med hjälp av % NN-ersättningen. Den andra metoden gör samma sak och anropar void sendRedirect (String location) void setStatus (int sc) void sendError (int sc) void sendError (int sc, String msg) Den första ställer in returkoden, de andra två skickar ett felmeddelande . Gränssnittet har följande möjliga fel för sc-parametern, motsvarande HTTP-protokollets returkoder: SC_CONTINUE - Statuskod (100) SC_SWITCHING_PROTOCOLS - Statuskod (101) SC_OK - Statuskod (200) SC_CREATED - Statuskod (201) SC_ACCEPTED - Statuskod (202 ) SC_NON_AUTHORITATIVE_INFORMATION - Statuskod (203) SC_NO_CONTENT - Statuskod (204) SC_RESET_CONTENT - Statuskod (205) SC_PARTIAL_CONTENT - Statuskod (206) SC_MULTIPLE_CHOICES_0S_0 Statuskod (Statuskod) -20 Statuskod (Statuskod) 303) SC_NOT_MODIFIED - Statuskod (304) SC_USE_PROXY - Statuskod (305) SC_BAD_REQUEST - Statuskod (400) SC_UNAUTHORIZED - Statuskod (401) SC_PAYMENT_REQUIRED - Statuskod (402) -Statuskod (402) -Statuskod (402) -Statuskod (402) (SCus_FOWMETHALL) -kod (SCus_FOWMEET)NO Statuskod (405) SC_NOT_ACCEPTABLE - Statuskod (406) SC_PROXY_AUTHENTICATION_REQUIRED - Statuskod (407) SC_REQUEST_TIMEOUT - Statu s-kod (408) SC_CONFLICT - Statuskod (409) SC_GONE - Statuskod (410) SC_LENGTH_REQUIRED - Statuskod (411) SC_PRECONDITION_FAILED - Statuskod (412) SC_REQUEST_ENTITY_TOO_LARGE - Status (4_1REQUETSC_1313) Statuskod (FILEATSC (4513)NOTE-kod (4513) Statuskod (4513) NO ) SC_EXPECTATION_FAILED - Statuskod (417) SC_INTERNAL_SERVER_ERROR - Statuskod (500) SC_NOT_IMPLEMENTED - Statuskod SC_BAD_CodeAEW2) (504) SC_HTTP_VERSION_NOT_SUPPORTED - Statuskod (505)

Det är allt som finns att säga om HttpServletResponse

Använda Servlets i WEB-applikationer

Låt oss nu prata om att använda servlets i WEB-applikationer. För att göra detta kommer jag att ge två användbara exempel som kan vara användbara i praktiken.

Det första exemplet visar metoder för att arbeta med en HttpServlet och mata ut komprimerat HTML-innehåll. I teorin visas HTML-sidan i webbläsarsvaret i vanlig text, men för att minska mängden data som skickas kan du använda GZIP-komprimering. Moderna webbläsare (minst fjärde generationens webbläsare och högre) stöder denna metod för att skicka textinformation och kommer att göra sidan som om den inte hade komprimerats.

importera java. io. *; importera javax. servlet. *; importera javax. servlett. http. *; importera java. util. blixtlås. *; // servlet ärver från HttpServlet public class ZipServlet utökar HttpServlet ( // funktion för att hantera GET-metoden public void doGet (HttpServletRequest request, HttpServletResponse response) kastar ServletException, IOException ( // ställ in sidan som ett HTML-dokument svar. setContentType ("text / html"); // ta parametern "Accept-Encoding" från HTTP-huvudet Strängkodningar = begäran. getHeader ("Acceptera-kodning"); // ta parametern "encoding" - den tidigare angivna kodningen av dokumentet String encodeFlag = begäran. getParameter ("kodning"); // Var kommer vi att skriva ut PrintWriter ut; // om fältet "Acceptera-kodning" finns i begäran if (kodningar! = null) ( // och om det här fältet innehåller värdet "gzip" och kodningen inte har ställts in ännu, if ((kodningar. indexOf ("gzip")! = - 1) &&! encodeFlag. är lika med ("ingen")) ( // då kommer utdata att följas av en och komprimera texten med GZIP out = new PrintWriter (ny GZIPOutputStream (response. getOutputStream ()), false); // och ställ in en flagga för webbläsaren att dokumentet ska komprimeras svar. setHeader ("Innehållskodning", "gzip"); ) annat ut = svar. getWriter (); ) annat // annars kommer vi att mata ut utan komprimering ut = svar. getWriter (); ut. println ("Detta är ett test!!!"); // skriv brödtexten i dokumentet ut. stänga (); // och stäng utgången. // Allt, efter slutförandet av denna funktion, kommer dokumentet att skickas } }

Det andra exemplet visar hur en servlet kan rendera en sida kontinuerligt. Denna typ av sidvisning kan användas till exempel i chattar: för att läsa nya meddelanden behöver du inte uppdatera sidan varje gång, nya meddelanden kommer helt enkelt att laddas ner med tiden. Det bör noteras att vissa proxyservrar inte stöder denna typ av dataöverföring, men med detta - tyvärr - kan ingenting göras.

importera java. io. *; importera javax. servlet. *; // programmet implementerar Servlet-gränssnittet class DoloadServlet implementerar Servlet (ServletConfig config; // ServletConfig object public DoloadServlet () () // gör inget // spara konfiguration under initiering public void init (ServletConfig config) kastar ServletException (this. config = config;) // ger ut sparad konfiguration public ServletConfig getServletConfig () (retur config;) // servlet info public String getServletInfo () (retur "DoloadServlet";) public void destroy () () // gör inget // Bearbetar begäran public void-tjänst (ServletRequest-begäran, ServletResponse-svar) kastar ServletException, java. io. IOException ( // vi kommer inte att analysera begäran, det är bara rörigt // skapa ett HTTP-huvud: Stränghuvud = "HTTP / 1.0 200 OK \ n" + + "Server: DoloadServlet \ n" + "Innehållstyp: text / html; teckenuppsättning = UTF-8 \ n"+ "Anslutning: Keep-Alive \ n" + "Innehållskodning: flerdelad / blandad \ n"+ "Transfer-Encoding: chunked" + "Pragma: no-cache \ n \ n"; // lägg nu till de ursprungliga uppgifterna // för detta exempel - 20 taggar "
"med radbrytning för (int i = 0; i< 20 ; i++ ) head = head + "
\ n "; // ta utdataströmmen ServletOutputStream os = svar. getOutputStream (); // skriv titeln och initiala data där os. tryck (huvud); // skicka allt som skrivits till bufferten till klienten svar. flushBuffer (); // börja lägga till nya rader: // dessa rader kommer att se ut så här: radnummer, sedan "
\ n " // varje ny rad visas var tredje sekund int i = 0; medan (sant) ( // öka räknaren i ++; // skriv raden os. skriv ut ("" + i + "
\ n "); // spola buffertsvaret.flushBuffer (); // frys strömmen i 3 sekunder försök (sömn (3000);) fånga (Undantag e) ())))

Det återstår att säga att servletmekanismen är väldigt flexibel och låter dig göra saker som kan kräva att du skriver en separat WEB-server (som till exempel i fallet med en CV-servlet). Nackdelarna med servlets är den låga hastigheten vid den första lanseringen (servleten kompileras helt enkelt av JIT-maskinen), hög minnesförbrukning och avsaknaden av alla Java-program - den låga hastigheten att arbeta med strängar. Den senare omständigheten blir märkbar när servlets fungerar som accepterar textdata i POST-förfrågningar. En POST-begäran på 50 KB till en HttpServlet vid analys med HttpServletRequest.getReader () kan förlama servern i ett par minuter. Detsamma gäller andra Java-program.

Här är två små exempel:

// ges en sträng Strängtext // exempel 1 // arbetar med en sträng med "+"-operationen för String String test1 = ""; för (int i = 0; i< text. length(); i++ ) test1 += text. charAt(i); // exempel 2 // arbetar med en sträng med en buffert char buf = ny röding [text. längd ()]; för (int i = 0; i< text. length(); i++ ) buf[ i] = text. charAt(i); String sample2 = new String(buf);

Om vi ​​tar små strängar - upp till 2-3 kb, så är skillnaderna i exemplens arbete obetydliga, men om vi tar en strängtext med en storlek på minst 10 kb, så kommer programmet i det första fallet att fungera med strängen mycket långsammare. Detta är designat i java och är ett problem i implementeringen av funktionerna i klassen String. Så om du vill skriva en snabb servlet, undvik att arbeta med långa strängar genom String-klassen, använd till exempel StringBuffer-klassen. Denna varning gäller i första hand att ta emot stora texter från nätverket och bearbeta lokala filer (till exempel vid en textdatabas för en gästbok med ett stort antal meddelanden).

Ett annat problem gäller multitasking av WEB-systemet. Tänk på att flera användare kan begära din servlet samtidigt. Det finns ofta problem med datasynkronisering, utbyte av information mellan olika beräkningstrådar av samma servlet, och det vanligaste problemet är problemet med synkron åtkomst till filer och andra namngivna systemresurser. Till exempel har ett program öppnat en fil för läsning, medan det andra försöker skriva något där. Som ett resultat får det andra programmet antingen ett undantag eller väntar på att filen ska frigöras för skrivning. I detta avseende vill jag uppmärksamma er: lämna inte oavslutna bäckar bakom er och stäng bäckar så snart det inte längre finns ett behov av dem. Streamen kommer naturligtvis att stängas automatiskt senare, men detta kommer bara att hända när "rensaren" kommer till den, och under tiden kommer det andra programmet fortfarande inte att ha skrivåtkomst till filen.

Förutom multitasking vill jag notera att med metoderna "Object getAttribute (String name)" och "void setAttribute (String name, Object object)" i ServletContext-gränssnittet kan du utbyta data mellan servlets, inklusive synkronisering av data.

En av de trevligaste egenskaperna hos Java är dess mångfacetterade natur. Naturligtvis är det bra att bygga traditionella stationära appar och till och med mobilappar. Men vad händer om du vill gå utanför allfartsvägarna och gå in på territoriet för att utveckla webbapplikationer i Java? Den goda nyheten för dig är att språket kommer med ett komplett Servlet API som låter dig bygga robusta webbapplikationer utan mycket krångel.

Skriva Java-applikationer med Servlets

Så vi har redan skapat konfigurationsfilerna för applikationen. Men i sitt nuvarande tillstånd gör det bokstavligen ingenting. Vi vill att kunder ska kunna registrera sig med hjälp av ett HTML-formulär, så nästa sak vi behöver göra är att skapa JSP-filer som visar ovanstående formulär och kundinformation efter att registreringen har lyckats. Detta är vad vi ska göra nu.

Vi jobbar med utseendet

Applikationens utseende kommer att bestämmas av två JSP-filer - i MVC-sammanhang kallas dessa vyer. Den första kommer att ansvara för att visa registreringsformuläret och eventuella fel som uppstår efter att ha kontrollerat de angivna uppgifterna. Den andra kommer att vara en vanlig välkomstsida, som visar de uppgifter som kunden har angett efter framgångsrikt slutförande av registreringsprocessen.

Här är den första JSP-filen:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> registrering

registrering

$ (överträdelse).