Del 5. Servlets og Java Servlet API. Skrive en enkel nettapplikasjon

Dette materialet er en del av serien "Introduksjon til bedriftsutvikling". Tidligere artikler:

• om nettverk
• om programvarearkitektur
• om HTTP/HTTPS
• om det grunnleggende om Maven

Vet du allerede hvordan du skriver Java-applikasjoner som viser tekst på konsollen, men du vet fortsatt ikke helt hvordan du lager din første nettapplikasjon? Flott, gjør deg komfortabel. I denne artikkelen skal vi bli kjent med servlets og skrive en applikasjon som du kan skryte av til vennene dine uten å sende dem en JAR-fil og uten å tvinge dem til å laste ned Java. La oss skrive en enkel nettapplikasjon . Hvis du ikke allerede er kjent med tilnærmingene som brukes i webutvikling, anbefaler jeg at du begynner med å lese den første artikkelen i serien " Introduksjon til bedriftsutvikling ".

Hva er en servlet?

Først, la oss finne ut hva servlets er og hvorfor du hører om dem så ofte. Java Servlet API er en standardisert API beregnet på å implementeres på serveren. Den samhandler med klienter i henhold til en forespørsel-svar-ordning. En servlet er en klasse som kan motta forespørsler fra en klient og returnere svar til klienten. Faktisk er servlets akkurat byggesteinene vi bruker for å lage en klient-server-arkitektur i Java. Du husker kanskje at vi allerede snakket om den arkitekturen i en annen av artiklene i serien. Vi kommer ikke til å slå rundt busken: la oss skrive litt kode med en gang.

Hva du trenger for å lage en nettapplikasjon

For størst mulig bekvemmelighet når du arbeider med Java-servlets, trenger du IntelliJ IDEA Ultimate Edition. Det er et betalt produkt, men du kan aktivere en 30-dagers prøveversjon eller bruke tidlig tilgangsversjonen, som alltid er gratis. Installer også Apache Tomcat – applikasjonens server. Tomcat er en servletbeholder: den behandler innkommende forespørsler og sender dem til applikasjonen vår. Last ned Tomcat her .

La oss lage vår første nettapplikasjon

Hvis alt er klart, lag et Maven-prosjekt. Hvis du ikke er kjent med Maven, ta en titt på forrige artikkel . La oss begynne!

1. I pom.xml, legg til en javax.servlet-api-avhengighet og spesifiser WAR-pakning:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
   
      <groupId>org.example</groupId>
      <artifactId>servlets</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
   
      <dependencies>
          <dependency>
              <groupId>javax.servlet</groupId>
              <artifactId>javax.servlet-api</artifactId>
              <version>4.0.1</version>
          </dependency>
      </dependencies>
   </project>

   Enkel servletklasse:

   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.io.PrintWriter;
   
   @WebServlet("/hello")
   public class MainServlet extends HttpServlet {
   
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          resp.setContentType("text/html");
          PrintWriter printWriter = resp.getWriter();
          printWriter.write("Hello!");
          printWriter.close();
      }
   }

2. For å kjøre applikasjonen må du opprette en Tomcat-konfigurasjon:

3. Deretter angir vi hvilken versjon av Tomcat vi skal bruke, og URL og port for å kommunisere med serveren. Du bør ha noe sånt som dette:

4. Nå trenger vi bare å spesifisere artefakten (det sammensatte prosjektet i et JAR-arkiv) som skal distribueres i containeren. Du kan klikke på Fix- knappen og velge war exploded : dette betyr at etter at prosjektet er gjenoppbygd, vil artefakten automatisk bli plassert i servlet-beholderen.

5. Standardverdien for applikasjonskontekst er servlets_war_exploded . Dette betyr at vi får tilgang til applikasjonen på: http://localhost:8080/servlets_war_exploded .

   Hvorfor vil vi ha ekstra tekst? La oss slette det som er unødvendig. Nå er adressen til nettapplikasjonen vår: http://localhost:8080 .

6. Klikk OK. Vi ser at vi nå kan starte applikasjonen:

   Nå når du åpner applikasjonen i nettleseren din, bør du få en 404-feil. Dette er fornuftig, fordi adressen http://localhost:8080/ trenger en servlet som tilordner "/", men vår eneste servlet tilordner "/hello" .

7. Vi kan få tilgang til den på http://localhost:8080/hello . Når vi gjør det, får vi det forventede svaret - strengen "Hei"!

Hvis alt fungerer, la oss analysere koden. For å lage en HTTP-servlet ut av en vanlig klasse , må den arve HttpServlet-klassen. Over klasseerklæringen angir vi merknaden @WebServlet(). Det er her vi binder (eller kartlegger) servleten til en bestemt bane ("/hallo"). Denne merknaden dukket bare opp i Java Servlet API 3.0, så Internett har mange eksempler der servlet-tilordning skjer gjennom en XML-fil. Dette er ikke lenger nødvendig. For å håndtere GET-forespørsler overstyrer vi doGet()metoden. Vær oppmerksom på metodens parametere: HttpServletRequestog HttpServletResponse. Objektet HttpServletRequestgir oss all nødvendig informasjon om forespørselen. I HttpServletResponse, skriver vi svaret vårt og setter de nødvendige overskriftene.

Arbeid med parametere og en økt

La oss forbedre servleten vår slik at den kan behandle forespørselsparametere og jobbe med en økt:

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class MainServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       HttpSession session = req.getSession();
       Integer visitCounter = (Integer) session.getAttribute("visitCounter");
       if (visitCounter == null) {
           visitCounter = 1;
       } else {
           visitCounter++;
       }
       session.setAttribute("visitCounter", visitCounter);
       String username = req.getParameter("username");
       resp.setContentType("text/html");
       PrintWriter printWriter = resp.getWriter();
       if (username == null) {
           printWriter.write("Hello, Anonymous" + "<br>");
       } else {
           printWriter.write("Hello, " + username + "<br>");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

Nå fungerer servleten med en økt, og øker verdien for visitCounterhver gang siden besøkes. Hvis visitCounterattributtet ennå ikke er opprettet (ved første besøk på siden), getAttribute()returnerer metoden null, så vi må se etter null. Det samme gjelder forespørselsparametere. Hvis brukeren ikke passerer brukernavnparameteren, vil verdien være null. I dette tilfellet hilser vi brukeren som en anonym besøkende. For å sende en parameter i en GET-forespørsel, brukes en spørringsstreng. For eksempel kan vi bruke følgende URL: http:// localhost:8080/hello? Brukernavn=Paul. Du kan lese mer om HTTP-forespørsler i forrige artikkeli serien. Vår applikasjon har foreløpig ikke mye logikk, men det er litt irriterende at vi får en 404-feil ved rotbanen. For å fikse dette, oppretter vi en annen servlet og tilordner den til startsiden: @WebServlet("/"). Formålet med denne servleten er å omdirigere forespørsler til "/hello"-banen. Det er to måter å gjøre dette på: ved å bruke "videresending" eller "viderekobling". Kanskje det er verdt å forstå forskjellen mellom dem. En videresending delegerer behandlingen av forespørselen til en annen servlet på serveren. Oppdragsgiver er ikke involvert. For å gjøre dette, legg til følgende kode i den nye servletens doGet()-metode:

getServletContext().getRequestDispatcher("/hello").forward(req, resp);

I denne koden får vi tilgang til servlet-konteksten, henter forespørselsformidleren for den aktuelle servleten, og ber den behandle en spesifikk forespørsel med de spesifiserte argumentene (req, resp.). En omdirigering returnerer til klienten adressen som klienten må bruke for å behandle forespørselen. De fleste nettlesere navigerer automatisk til den returnerte URL-en. For å implementere en omdirigering må du legge til denne koden:

resp.sendRedirect(req.getContextPath() + "/hello");

Vi kaller redirect()metoden på HttpServletResponseparameteren og gir den adressen som klienten trenger å bruke. Her er en viktig detalj: HTTP-parametere må også legges til på slutten av hele omdirigeringsbanen, noe som ikke er veldig praktisk. I vår situasjon er det å foretrekke å bruke forward, men noen ganger redirecter det bedre å bruke. Hvis du forstår forskjellen i hvordan de fungerer, vil du ikke ta feil valg. Koden for den nye servleten ser slik ut:

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/")
public class IndexServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        getServletContext().getRequestDispatcher("/hello").forward(req, resp);
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

Sammendrag

Din første nettapplikasjon er ferdig. I den neste artikkelen vil du lære hvordan du distribuerer den uten å bruke IntelliJ IDEA. Vi skrev en søknad som kun behandler GET-forespørsler. De gjenværende HTTP-metodene håndteres på lignende måte - ved å overstyre de tilsvarende metodene til den overordnede klassen. Du kan bruke enkle servlets som dette for å bygge sofistikerte allsidige nettapplikasjoner. Å bruke store rammer som Spring gjør selvfølgelig dette mye enklere. Men hvis du virkelig ønsker å gå dypere inn i alle egenskapene til servlets, kan du lese den offisielle spesifikasjonen . Del 6. Servlet-beholdere Del 7. Introduserer MVC-mønsteret (Model-View-Controller)