Initialiseringsparametere for kontekst og servlet

1. Oversikt

Servlets er vanlige Java-klasser som kjører i en servlet-beholder.

HTTP-servlets (en bestemt type servlet) er førsteklasses borgere i Java-webapplikasjoner. API for HTTP-servletter er rettet mot å håndtere HTTP-forespørsler gjennom den typiske forespørselsbehandling-svar-syklusen, implementert i klient-server-protokoller.

Videre kan servlets kontrollere samspillet mellom en klient (vanligvis en nettleser) og serveren ved hjelp av nøkkelverdipar i form av forespørsel / svarparametere.

Disse parametrene kan initialiseres og bindes til et applikasjonsomfang (kontekstparametere) og et servletspesifikt omfang (servletparametere).

I denne opplæringen lærer vi hvordan du definerer og får tilgang til parametere for kontekst og initialisering av servlet.

2. Initialisere servletparametere

Vi kan definere og initialisere servletparametere ved hjelp av merknader og standard distribusjonsbeskrivelse - the “Web.xml” fil. Det er verdt å merke seg at disse to alternativene ikke utelukker hverandre.

La oss utforske hvert av disse alternativene i dybden.

2.1. Bruke merknader

Ved å initialisere servlets-parametere med merknader kan vi beholde konfigurasjon og kildekode på samme sted.

I denne delen vil vi demonstrere hvordan du definerer og får tilgang til initialiseringsparametere som er bundet til en bestemt servlet ved hjelp av merknader.

For å gjøre dette implementerer vi en naiv UserServlet klasse som samler inn brukerdata gjennom et vanlig HTML-skjema.

La oss først se på JSP-filen som gjengir skjemaet vårt:

   Kontekst og initialisering Servletparametere Fyll ut skjemaet nedenfor:
Navn:E-post:

Merk at vi har kodet skjemaets handling attributt ved å bruke EL (uttrykksspråket). Dette gjør at den alltid kan peke på “/ UserServlet” bane, uavhengig av plasseringen av applikasjonsfilene på serveren.

De “$ {PageContext.request.contextPath}” uttrykk angir en dynamisk URL for skjemaet, som alltid er relativt til programmets kontekstbane.

Her er vår første servletimplementering:

@WebServlet (name = "UserServlet", urlPatterns = {"/ userServlet"}, initParams = {@WebInitParam (name = "name", value = "Ikke oppgitt"), @WebInitParam (name = "email", value = " Ikke oppgitt ")})) offentlig klasse UserServlet utvider HttpServlet {// ... @Override-beskyttet ugyldig doPost (HttpServletRequest-forespørsel, HttpServletResponse-svar) kaster ServletException, IOException {processRequest (forespørsel, svar); forwardRequest (forespørsel, svar, "/WEB-INF/jsp/result.jsp"); } beskyttet ugyldig processRequest (HttpServletRequest-forespørsel, HttpServletResponse-svar) kaster ServletException, IOException {request.setAttribute ("navn", getRequestParameter (forespørsel, "navn")); request.setAttribute ("e-post", getRequestParameter (forespørsel, "e-post")); } beskyttet ugyldig forwardRequest (HttpServletRequest-forespørsel, HttpServletResponse-svar, strengbane) kaster ServletException, IOException {request.getRequestDispatcher (bane). fremover (forespørsel, svar); } beskyttet streng getRequestParameter (HttpServletRequest forespørsel, strengnavn) {String param = request.getParameter (navn); return! param.isEmpty ()? param: getInitParameter (navn); }}

I dette tilfellet har vi definert to parametere for initialisering av servlet, Navn og e-post, av ved hjelp av initParams og @WebInitParam kommentarer.

Vær oppmerksom på at vi har brukt HttpServletRequest's getParameter () metode for å hente dataene fra HTML-skjemaet, og getInitParameter () metode for å få tilgang til parametere for initialisering av servlet.

De getRequestParameter () metoden sjekker om Navn og e-post forespørselsparametere er tomme strenger.

Hvis de er tomme strenger, får de tildelt standardverdiene for de samsvarende initialiseringsparametrene.

De doPost () metoden henter først navnet og e-postadressen som brukeren skrev inn i HTML-skjemaet (hvis noen). Deretter behandler den forespørselsparametrene og videresender forespørselen til en “Resultat.jsp” fil:

    Brukerdata brukerinformasjon
Navn: $ {name}
E-post: $ {email}

Hvis vi distribuerer vårt eksempler på webapplikasjon til en applikasjonsserver, for eksempel Apache Tomcat, Oracle GlassFish eller JBoss WidlFly, og kjører den, bør den først vise HTML-skjemsiden.

Når brukeren har fylt ut Navn og e-post felt og sendte inn skjemaet, vil det sende dataene:

Brukerinformasjon Navn: brukerens navn E-post: brukerens e-post

Hvis skjemaet bare er tomt, vil det vise parametere for initialisering av servlet:

Brukerinformasjon Navn: Ikke oppgitt E-post: Ikke oppgitt

I dette eksemplet har vi vist hvordan du definerer parametere for initialisering av servlet ved hjelp av merknader, og hvordan du får tilgang til dem med getInitParameter () metode.

2.2. Bruke Standard Deployment Descriptor

Denne tilnærmingen skiller seg fra den som bruker merknader, da den lar oss holde konfigurasjon og kildekode isolert fra hverandre.

For å vise hvordan du definerer initialiseringsservletparametere med “Web.xml” fil, la oss først fjerne initParam og @WebInitParam merknader fra UserServlet klasse:

@WebServlet (name = "UserServlet", urlPatterns = {"/ userServlet"}) offentlig klasse UserServlet utvider HttpServlet {...}

La oss deretter definere parametere for initialisering av servlet i “Web.xml” fil:

   UserServlet UserServlet navn Ikke oppgitt e-post Ikke gitt

Som vist ovenfor, definerer du initialiseringsparametere for servlet ved hjelp av “Web.xml” filen bare koker ned til å bruke , og koder.

Videre er det mulig å definere så mange servletparametere som nødvendig, så lenge vi holder oss til standardstrukturen ovenfor.

Når vi omdistribuerer applikasjonen til serveren og kjører den på nytt, skal den oppføre seg som den versjonen som bruker merknader.

3. Initialisere kontekstparametere

Noen ganger må vi definere noen uforanderlige data som må deles globalt og få tilgang til i en webapplikasjon.

På grunn av dataenes globale natur, burde vi gjøre det bruk kontekstinitialiseringsparametere for hele applikasjonen for å lagre dataene, i stedet for å ty til servletten.

Selv om det ikke er mulig å definere parametere for kontekstinitialisering ved hjelp av merknader, kan vi gjøre dette i “Web.xml” fil.

La oss anta at vi vil gi noen standardverdier som er standard for landet og provinsen der applikasjonen vår kjører.

Vi kan oppnå dette med et par kontekstparametere.

La oss omformere “Web.xml” arkiver deretter:

  provinsen Mendoza land Argentina

Denne gangen har vi brukt , , og koder for å definere provins og land kontekstparametere.

Selvfølgelig må vi omlegge UserServlet klasse slik at den kan hente disse parametrene og overføre dem til resultatsiden.

Her er servlets relevante seksjoner:

@WebServlet (name = "UserServlet", urlPatterns = {"/ userServlet"}) offentlig klasse UserServlet utvider HttpServlet {// ... beskyttet ugyldig processRequest (HttpServletRequest-forespørsel, HttpServletResponse-svar) kaster ServletException, IOException {request.settt ", getRequestParameter (forespørsel," navn ")); request.setAttribute ("e-post", getRequestParameter (forespørsel, "e-post")); request.setAttribute ("provins", getContextParameter ("provins")); request.setAttribute ("land", getContextParameter ("land")); } beskyttet String getContextParameter (String name) {- return getServletContext (). getInitParameter (name); }}

Vær oppmerksom på getContextParameter () metodeimplementering, som får først servletsammenheng gjennom getServletContext (), og henter deretter kontekstparameteren med getInitParameter () metode.

Deretter må vi omlegge “Resultat.jsp” fil slik at den kan vise kontekstparametrene sammen med de servlet-spesifikke parametrene:

Navn: $ {name}
E-post: $ {email}
Provins: $ {provins}
Land: $ {country}

Til slutt kan vi distribuere applikasjonen på nytt og utføre den igjen.

Hvis brukeren fyller HTML-skjemaet med et navn og en e-post, vil den vise disse dataene sammen med kontekstparametrene:

Brukerinformasjon Navn: brukerens navn E-post: brukerens e-post Provins: Mendoza Land: Argentina

Ellers vil det sende servlet og kontekstinitialiseringsparametere:

Brukerinformasjon Navn: Ikke oppgitt E-post: Ikke oppgitt Provins: Mendoza Land: Argentina

Mens eksemplet er konstruert, viser det hvordan du bruker kontekstinitialiseringsparametere for å lagre uforanderlige globale data.

Ettersom dataene er bundet til applikasjonskonteksten, i stedet for til en bestemt servlet, kan vi få tilgang til dem fra en eller flere servlets ved å bruke getServletContext () og getInitParameter () metoder.

4. Konklusjon

I denne artikkelen, vi lærte nøkkelbegrepene for kontekst- og servletinitialiseringsparametere og hvordan vi kan definere dem og få tilgang til dem ved hjelp av merknader og “Web.xml” fil.

I ganske lang tid har det vært en sterk tendens i Java å kvitte seg med XML-konfigurasjonsfiler og migrere til merknader når det er mulig.

CDI, Spring, Hibernate, for å nevne noen, er skarpe eksempler på dette.

Likevel er det ingenting som er galt med å bruke “Web.xml” fil for å definere kontekst og initialiseringsparametere for servlet.

Selv om Servlet API har utviklet seg i ganske raskt tempo mot denne tendensen, vi trenger fortsatt å bruke distribusjonsbeskrivelsen for å definere parametere for kontekstinitialisering.

Som vanlig er alle kodeeksemplene vist i denne artikkelen tilgjengelig på GitHub.

streamalism.org