Servlets. Vi skriver en servlet för att spionera på sociala nätverksanvändare Din inmatade data

En Java Servlet är ett program på serversidan skrivet i programmeringsspråket med samma namn som tar emot signaler från en klient och skickar svar tillbaka till den. Det är nyckelelementet som utgör den typiska Java EE, förutom JSP, EJB, XML och andra relaterade teknologier. En applikation kan paketeras i en WAR-fil (Web AR chive) för distribution på en webbserver. En server som kan köra en Java-servlet kallas en container. Ett program som körs på en sådan server kan skapa dynamiska webbsidor.

Grunderna i Java Servlet

De mest populära och mest använda behållarna är Tomcat och JBoss. Tekniskt sett är en Servlet en normal Java-klass som har en tillägg för Common Client/Server Protocol, eller HTTP. I praktiken används den för att bearbeta förfrågningar, genom HttpServlet GET- respektive POST-överstyrningarna. Java Servlet-behållaren tillhandahåller Http.ServletRequest och Http.ServletResponse, som är begäran-svar-objekt. Och används vanligtvis i samband med JSP för att generera dynamiskt innehåll.

Typiskt modellscenario:

  • JSP:n ger användaren ett datainmatningsformulär.
  • Servleten tar emot indata, bearbetar den och skickar ett svar.
  • För högkvalitativt arbete använder han speciella filter.

    • Java Servlet-filter är Java-plugin-program som används för att fånga upp och bearbeta förfrågningar innan de skickas till servleten och svarade efter att dess kod har slutförts, och innan behållaren skickar svaret tillbaka till klienten.

    Vanliga uppgifter att utföra med filter:

  • Registrering av frågeparametrar för registrering av filer.
  • Autentisering och auktorisering av resursbegäran.
  • Formatera förfrågningstexten eller rubriken innan den skickas till servleten.
  • Komprimering av svarsdata som skickas till klienten.
  • Ändrade svar, lade till några cookies.
  • Java Servlet-huvudinformation.

    • Filter ingår och konfigureras i en distributionsbeskrivningsfil (web.xml). Servlets och filter känner inte till varandra, så du kan lägga till eller ta bort ett filter genom att helt enkelt redigera web.xml. Det är acceptabelt att ha flera filter för en enskild resurs, eller kedjefilter för web.xml, eller köra Java Servlet-filter genom att implementera javax.servlet.Filter-gränssnittet.

    Parallella förfrågningar till servern behandlas av trådar, vilket ger viktiga egenskaper hos webben - multithreading och parallellism.

    Huvud funktioner:

  • Bärbarhet. Eftersom Java är plattformsoberoende, gäller detsamma för servlets. Till exempel är det möjligt att bygga det på Windows operativsystem så att GlassFish-utvecklare använder det som en webbserver och sedan kan köra det på vilket annat operativsystem som helst som Unix, Linux med apache Java Servlet webbserver. Den här funktionen gör den bärbar, och detta är dess främsta fördel jämfört med CGI.
  • Effektivitet och skalbarhet. När en Servlet väl har distribuerats och laddats på en webbserver kan den omedelbart börja exekvera klientförfrågningar. Det anropas av en lätt tråd så att flera klientförfrågningar kan fyllas samtidigt med Javas multitrådsfunktion. Till skillnad från CGI, där servern initierar en ny process för varje klientförfrågan.
  • Pålitlighet. Genom att ärva de bästa Java-funktionerna som sophämtning, undantagshantering, Java-säkerhetshanterare och andra är det mindre benäget för hanteringsproblem och minnesläckor. Detta gör utvecklingen av applikationen i den säker och felfri.

    • Behovet av dynamiska webbsidor

    Det finns många anledningar till varför ett företag skulle vilja skapa dynamiska webbsidor i farten, till exempel när data på en webbplats ändras ofta. Nyhets- och vädersajter förlitar sig vanligtvis på CGI för att hålla innehållet fräscht utan utvecklarnas ständiga uppmärksamhet. Webbsidor för e-handel som visar aktuella priser och lagernivåer använder CGI för att få detta innehåll på begäran och hämtar det från företagets interna infrastruktur.

    Många användare har erfarenhet av att använda Java-teknik för att skapa CGI-baserade webbtjänster, men Java Servlets är mer effektiva, kraftfulla, enklare att använda och billigare än traditionella CGI-alternativ.

    Fördelar med Java Servlets:

  • Effektivitet. I traditionell CGI startar varje HTTP-begäran en ny CGI-process. Även om dess kod är välimplementerad, finns det ofta en betydande mängd overhead, inte bara när processen startas, utan även under dess exekvering. När servlets används förblir JVM laddad i minnet och varje begäran hanteras av en Java-tråd. Som ett exempel på en Java Servlet, om det finns X antal samtidiga förfrågningar i den traditionella CGI-modellen, betyder detta att koden för programmet laddas in i minnet X gånger. Detta blir en överdriven belastning på webbservern. Men i en servletmiljö finns det X-trådar där endast en kopia av dess klass körs. Resultatet av detta är ökad effektivitet och skalbarhet över flera plattformar.
  • Bekvämlighet. När du använder ett program är det ingen idé att lära sig ett nytt språk, som Perl, bara för att utföra CGI-funktioner. Dessutom har servlets en rik infrastruktur för många HTML-relaterade uppgifter, vilket avsevärt påskyndar utvecklingsprocessen.
  • Kraft - Tyvärr lämnar traditionella CGI-skript mycket övrigt att önska. Deras vanliga program kan till exempel inte prata direkt med webbservrar, vilket gör att hela gränssnittet måste skapas. Servlets kan kommunicera direkt med webbservrar, vilket underlättar operationer som kräver direkt åtkomst till datalager. De är också unika eftersom de kan kommunicera med andra servlets och underhålla information mellan förfrågningar, vilket gör sessionsspårning extremt enkel.
  • Java-portabilitet sträcker sig direkt till servlets. Faktum är att nästan alla större webbservrar som för närvarande används stöder Java Servlets antingen direkt eller via en plug-in.
  • Sparsamhet. Ur utvecklingssynpunkt är det mycket billigare att implementera servlets än andra alternativ som kräver anpassad kodning för att kommunicera korrekt med webbservrar. Java Servlet-omdirigering är redo att gå och kan sänka kostnaderna för verksamheten så mycket som möjligt utan att offra fördelarna med dynamiskt innehåll.

    • 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"och kan beskrivas på följande sätt: när en förfrågan kommer från en klient kan webbservern avgöra vilken servlet som behöver exekveras med hjälp av en speciell konfigurationsfil. Därefter startar webbservern JVM, som i sin tur exekverar servleten. Servleten bearbetar begäran och skickar innehållet på webbservern (eventuellt i form av en HTML-sida) Webbservern skickar ett svar (en HTML-sida som genereras av servleten) till klienten.

    WEB-servern är i grunden en sorts behållare som laddas ner 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"s 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 Mellanlagret fungerar som en applikationsserver i det så kallade treskiktiga klient-serversystemet och är placerat mellan en "lättvikts" klient, såsom en webbläsare, och datakällan.

    Servlet som proxy

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

    Tillfälligt och permanent servlett"s

    Servlets kan startas och stoppas för varje klientförfrågan. De kan också startas när webbservern startar och existerar tills den stoppas. 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 varar tills den stoppas. Servlets installeras som beständiga tillägg till servern om kostnaden för att starta de är mycket höga (t.ex. upprättande av en databasanslutning) om de erbjuder beständig funktionalitet på serversidan (t.ex. en RMI-tjänst), eller i fall där de behöver svara på klientförfrågningar så snabbt som möjligt. Det finns ingen specifik kod att tilldela servlett"men permanent eller tillfälligt; detta är en funktion för att ställa in webbservern.

    Servlet 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 servletinstans. Webbservern interagerar med servleten genom ett enkelt gränssnitt: javax.servlet.servlet.

    Gränssnittet javax.servlet.Servlet innehåller tre huvudmetoder:

    • i det()
    • service()
    • förstöra()

    och två hjälpmetoder:

    • getServletConfig()
    • getServletInfo()

    Likheter mellan gränssnitt servlett"och Java-appleten är uppenbar. Det är så den designades! 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å sin 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 göra anslutningar till sina servrar. Om servleten är permanent installerad på servern laddas den när servern startar. Annars anropar servern servleten på den första begäran från klienten att utföra tjänsten som tillhandahålls av den servleten.

    Det är garanterat att metoden i det() kommer att avslutas före alla andra anrop till servleten, som att anropa en metod service(). 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 referens till ett objekt ServletConfig, som innehåller argument för att initiera servleten. Detta objekt har en metod getServletContext(), som returnerar ett objekt ServletContext En som innehåller information om servletmiljön.

    Servlet core, service() metod

    Metod service()är servlettens hjärta. Varje begäran från klienten resulterar i ett metodanrop service(). Den här metoden läser förfrågan och genererar ett svarsmeddelande med hjälp av dess två argument ServletRequest och ServletResponse:

    Det finns alltså två sätt att skicka 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 skicka information från klienten till servleten är via en InputStream (eller Reader).

    Metodarbete service()är i grunden enkel - 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 service() kräver externa resurser som filer, databaser, då är det nödvändigt att säkerställa att åtkomst till resurser är trådsäker.

    Servlet lossning, destroy() 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 sista operationer. Innan du anropar en metod förstöra() servern väntar antingen på att alla serviceåtgärder är slutförda eller på att en viss tid löper ut. Detta innebär att metoden förstöra() kan anropas under utförandet av vilken lång metod som helst service().

    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 service() 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. tillgång till servletinitieringsparametrar och servletkontextobjekt ServletContext, som ger tillgång till servleten och dess miljö.

    Servlet info, 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 parametrar för HTTP-begäran till servleten, dvs. tillhandahåller data inklusive parameternamn och värden, attribut och indataström. Denna information skickas till metoden service().

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

    BufferedReader-läsare; Sträng param1; String param2; public void service(ServletRequest request, ServletResponse response) ( reader = request.getReader(); param1 = request.getParameter("First"); param2 = request.getParameter("Second"); )

    Ytterligare information om begäran är tillgänglig för servleten genom metoder, de viktigaste är listade 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 förfrågan.
    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 ta emot text från förfrågans text.
    getRealPath() Returnerar den verkliga sökvägen för den angivna virtuella sökvägen.
    getRemoteAddr() IP-adressen till klienten som skickade denna begäran.
    getRemoteHost() Värdnamnet för klientdatorn som skickade begäran.
    getScheme() Returnerar schemat som används i denna begärans URL (till exempel https, http, ftp, etc.).
    getServerName() Värdnamnet för servern som accepterade denna 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 klienten. Alla metoder för detta verktyg tjänar exakt denna uppgift:

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

    Den första metoden returnerar MIME-kodningstypen (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 utdataströmmen för servleten. Denna ström används till exempel för att mata ut binära filer. 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-huvudfältet "Content-Length"

    public void setContentType(strängtyp)

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

    Utgångsströmmen buffras. Detta innebär att en del av datan kommer att skickas 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 sändning av innehållet i bufferten till klienten utan att vänta på att den ska fyllas och rensa denna buffert från data.

    Public boolean isCommitted()

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

    public void reset()

    Om HTTP-huvudet ännu inte har skickats "å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 som bilder på webbsidor. Beskrivningsdetaljer och exempel på hur JFreeChart används i servlets tillhandahålls.

    Servlet med grafikbibliotek Chart.js

    JNI i Servlet

    I vissa fall kan du behöva använda JNI i en WEB-applikation. Ett exempel på användning av JNI i servlets presenteras.

    JMS-meddelanden i en servlet

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

    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. Även om servlets kan tjä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 bygga servlets.

    • Vad är strukturen för ett webbprojekt?

    • Vad är en servletbehå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 läses den in i minnet och metoden init() anropas. När applikationen körs anropas service()-metoder för att behandla klientförfrågningar. När applikationen avslutas anropas metoden destroy() och servleten laddas ur minnet.

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

    En servletbehållare kan fungera som en helt fristående webbserver, tillhandahålla sidor till en annan webbserver som Apache eller integreras i en Java EE-applikationsserver. Tillhandahåller datautbyte mellan servlet och klienter, utför sådana 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()?

    För att anropa en JSP med en relativ sökväg, använd metoden forward(); för att komma åt en JSP med en absolut sökväg, använd metoden sendRedirect(). Skillnaden mellan dessa metoder är att ett redan existerande förfrågningsobjekt skickas med metoden forward() och en ny begäran bildas när metoden sendRedirect() anropas. Information i det senare fallet bör överföras med andra föremål. Dessutom är metoden forward() snabbare.

    • Vad vet du om servletfilter?

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

    • avlyssna servletinitiering innan servleten initieras.
    • bestämma innehållet i begäran innan servleten anropas.
    • ändra rubrikerna och förfrågningsdata där den inkommande begäran är paketerad.
    • modifiera rubrikerna och svarsdata i vilka det mottagna svaret är packat.
    • avlyssna servletinitiering efter ett anrop till servleten.

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

    • void init(FilterConfig config) kastar ServletException;
    • void förstör();
    • void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 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 köra filtret och anropar sedan doFilter() så många gånger som det görs förfrågningar direkt till det filtret. När filtret avslutat sitt arbete anropas metoden destroy().

    • Varför behöver vi 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 den 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 för att spåra hur en begäran skapas och förstörs, och hur attribut läggs till och tas bort från en servlet. Servlet 2.4 lade till följande klasser:

    • ServletRequestListener
    • ServletRequestEvent
    • ServletRequestAttributeListener
    • ServletRequestAttributeEvent

    • Hur hanterar man undantag som kastas av en annan servlet i applikationen?

    Eftersom webbläsaren bara förstår HTML, kommer servletbehållaren att hantera undantaget och generera ett HTML-svar när ett program skapar ett undantag. Detta liknar vad som händer med felkoder som 404, 403, etc. Servlet API ger stöd för inbyggda servlets för att hantera undantag och fel som vi kan ställa in i distributionsbeskrivningen. Huvuduppgiften för sådana servlets är att hantera felet eller undantaget och skicka ett mänskligt läsbart 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 artefaktkonfigurationsfilen som kommer att distribueras till 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 distributionsalternativ för en modul eller applikation med specifika inställningar, säkerhetsalternativ och beskriver specifika konfigurationskrav. Syntaxen för distributionsbeskrivningsfiler är XML.

    • Hur implementerar man servletstart med programstart?

    Servletbehållaren laddar vanligtvis servleten på den första begäran från klienten, men ibland är det nödvändigt att ladda servleten direkt i början av applikationen (till exempel om servleten är stor 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), vilket kommer att indikera att servleten ska laddas vid start.

    Värdet måste vara int. Om värdet är negativt kommer servleten att laddas på begäran av klienten, 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 ett ServletConfig-objekt?

    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-parametrar 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 ett ServletContext-objekt?

    Gränssnittet javax.servlet.ServletContext definierar en uppsättning 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 åtkomst till en eller flera servlets till de initierade parametrarna för en webbapplikation. 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 för att ge programmatiskt tillägg av lyssnare och filter till en 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 unik per servlet, medan ServletContext är unik för hela applikationen.
    • ServletConfig används för att tillhandahålla initieringsparametrar till en servlet, och ServletContext används för att tillhandahålla aför alla servlets.
    • Vi har inte möjlighet att ställa in attribut på ServletConfig-objektet, medan vi kan ställa in attribut på 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 en klient. Alla metoder för detta verktyg tjänar detta syfte.

    • 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 några metoder som är identiska till namn och syfte med ServletContext.

    • Vad är en förfrågan avsändare?

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

    • void forward(ServletRequest var1, ServletResponse var2) - vidarebefordrar en begäran från en servlet 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) i svaret.

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

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

    Deadlock (deadlock) kan erhållas genom att implementera ett loopat metodanrop, till exempel anropa doPost ()-metoden i doGet ()-metoden och anropa doGet () i doPost ()-metoden.

    • Hur får man servletadressen 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 man serverinformation från servlet?

    Serverinformation kan hämtas 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 få 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 servletens begäran- och svarstyper. 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.

    En av de roligaste funktionerna i Java är dess mångfacetterade natur. Naturligtvis är det fantastiskt att skapa traditionella stationära och till och med mobilapplikationer. Men vad händer om du vill gå utanför allfartsvägarna och gå in på Java-webbutvecklingsområde? Den goda nyheten för dig är att språket kommer med ett komplett Servlet API som låter dig bygga robusta webbapplikationer utan alltför mycket krångel.

    Bygga Java-applikationer med Servlets

    Så vi har redan skapata. Men i sitt nuvarande tillstånd gör det bokstavligen ingenting. Vi vill att kunder ska kunna registrera sig med 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 när registreringen är framgångsrik. Detta är vad vi kommer att göra nu.

    Jobbar på utseendet

    Applikationens utseende kommer att definieras av två JSP-filer - i MVC-sammanhang kallas de vyer. Den första kommer att ansvara för att visa registreringsformuläret och eventuella fel som uppstår efter validering av de angivna uppgifterna. Den andra kommer att vara en normal välkomstsida som visar de uppgifter som kunden har angett efter att registreringsprocessen har slutförts.

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

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

    Registrering

    $(överträdelse).