Del 5. Servlets och Java Servlet API. Att skriva en enkel webbapplikation

Detta material är en del av serien "Introduktion till företagsutveckling". Tidigare artiklar:

• om nätverkande
• om mjukvaruarkitektur
• om HTTP/HTTPS
• om grunderna i Maven

Vet du redan hur man skriver Java-applikationer som visar text på konsolen, men du vet fortfarande inte riktigt hur du skapar din första webbapplikation? Bra, gör dig bekväm. I den här artikeln kommer vi att bekanta oss med servlets och skriva en applikation som du kan skryta med för dina vänner utan att skicka en JAR-fil till dem och utan att tvinga dem att ladda ner Java. Låt oss skriva en enkel webbapplikation . Om du inte redan är bekant med metoderna som används inom webbutveckling rekommenderar jag att du börjar med att läsa den första artikeln i serien " Introduktion till företagsutveckling" .

Vad är en servlet?

Låt oss först ta reda på vad servlets är och varför du hör om dem så ofta. Java Servlet API är ett standardiserat API avsett att implementeras på servern. Den interagerar med kunder enligt ett förfrågningssvarsschema. En servlet är en klass som kan ta emot förfrågningar från en klient och returnera svar till klienten. I själva verket är servlets exakt de byggstenar vi använder för att skapa en klient-server-arkitektur i Java. Du kanske minns att vi redan talade om den arkitekturen i en annan av artiklarna i serien. Vi kommer inte att slå runt: låt oss skriva lite kod direkt.

Vad du behöver för att skapa en webbapplikation

För största möjliga bekvämlighet när du arbetar med Java-servlets behöver du IntelliJ IDEA Ultimate Edition. Det är en betalprodukt, men du kan aktivera en 30-dagars provperiod eller använda tidig åtkomstversionen, som alltid är gratis. Installera också Apache Tomcat – vår applikations server. Tomcat är en servletbehållare: den behandlar inkommande förfrågningar och skickar dem till vår applikation. Ladda ner Tomcat här .

Låt oss skapa vår första webbapplikation

Om allt är klart, skapa ett Maven-projekt. Om du inte är bekant med Maven, ta en titt på den tidigare artikeln . Låt oss börja!

1. Lägg till ett javax.servlet-api-beroende i pom.xml och ange WAR-paketering:

   
   <?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 servletklass:

   
   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. För att köra programmet måste du skapa en Tomcat-konfiguration:

3. Därefter anger vi vilken version av Tomcat vi kommer att använda, och URL och port för att kommunicera med servern. Du borde ha något sånt här:

4. Nu behöver vi bara specificera artefakten (det sammansatta projektet i ett JAR-arkiv) som kommer att distribueras i behållaren. Du kan klicka på Fix- knappen och välja war exploded : detta betyder att efter att projektet har byggts om kommer artefakten automatiskt att placeras i servletbehållaren.

5. Standardvärdet för Application context är servlets_war_exploded . Det betyder att vi kommer åt applikationen på: http://localhost:8080/servlets_war_exploded .

   Varför skulle vi vilja ha någon extra text? Låt oss ta bort det som är onödigt. Nu är vår webbapplikations adress: http://localhost:8080 .

6. Klicka på OK. Vi ser att vi nu kan starta applikationen:

   Nu när du öppnar programmet i din webbläsare bör du få ett 404-fel. Detta är vettigt, eftersom adressen http://localhost:8080/ behöver en servlet som mappar till "/", men vår enda servlet mappar till "/hello" .

7. Vi kan komma åt den på http://localhost:8080/hello . När vi gör det får vi det förväntade svaret - strängen "Hej"!

Om allt fungerar, låt oss analysera koden. För att göra en HTTP-servlet av en vanlig klass måste den ärva klassen HttpServlet. Ovanför klassdeklarationen anger vi anteckningen @WebServlet(). Det är här vi binder (eller mappar) servleten till en specifik sökväg ("/hej"). Den här anteckningen dök endast upp i Java Servlet API 3.0, så Internet har många exempel där servlet-mappning sker genom en XML-fil. Detta är inte längre nödvändigt. För att hantera GET-förfrågningar åsidosätter vi doGet()metoden. Var uppmärksam på metodens parametrar: HttpServletRequestoch HttpServletResponse. Objektet HttpServletRequestger oss all nödvändig information om begäran. I , HttpServletResponseskriver vi vårt svar och ställer in de nödvändiga rubrikerna.

Arbeta med parametrar och en session

Låt oss förbättra vår servlet så att den kan behandla begärandeparametrar och arbeta med en session:

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();
   }
}

Nu arbetar servleten med en session, vilket ökar värdet för visitCountervarje gång sidan besöks. Om visitCounterattributet ännu inte har skapats (vid första besöket på sidan) getAttribute()returnerar metoden null, så vi måste kontrollera om det finns null. Detsamma gäller för begäran parametrar. Om användaren inte skickar användarnamnsparametern kommer dess värde att vara null. I det här fallet hälsar vi användaren som en anonym besökare. För att skicka en parameter i en GET-förfrågan används en frågesträng. Till exempel kan vi använda följande URL: http:// localhost:8080/hello? Användarnamn=Paul. Du kan läsa mer om HTTP-förfrågningar i föregående artikeli serien. Vår applikation har för närvarande inte mycket logik, men det är lite irriterande att vi får ett 404-fel vid rotsökvägen. För att fixa detta skapar vi en annan servlet och mappar den till startsidan: @WebServlet("/"). Syftet med denna servlet är att omdirigera förfrågningar till sökvägen "/hej". Det finns två sätt att göra detta: att använda "vidarebefordra" eller "omdirigera". Kanske är det värt att förstå skillnaden mellan dem. En vidarebefordran delegerar behandlingen av begäran till en annan servlet på servern. Kunden är inte inblandad. För att göra detta, lägg till följande kod i den nya servletens doGet()-metod:

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

I den här koden kommer vi åt servletkontexten, hämtar förfrågningsavsändaren för den relevanta servleten och ber den att behandla en specifik begäran med de angivna argumenten (req, resp.). En omdirigering returnerar till klienten den adress som klienten måste använda för att behandla sin begäran. De flesta webbläsare navigerar automatiskt till den returnerade webbadressen. För att implementera en omdirigering måste du lägga till denna kod:

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

Vi anropar redirect()metoden på HttpServletResponseparametern och skickar den adressen som klienten behöver använda. Här är en viktig detalj: HTTP-parametrar måste också läggas till i slutet av den fullständiga omdirigeringsvägen, vilket inte är särskilt bekvämt. I vår situation är det att föredra att använda , forwardmen ibland redirectär det bättre att använda. Om du förstår skillnaden i hur de fungerar kommer du inte att göra fel val. Koden för den nya servleten ser ut så här:

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");
   }
}

Sammanfattning

Din första webbapplikation är klar. I nästa artikel kommer du att lära dig hur du distribuerar det utan att använda IntelliJ IDEA. Vi skrev en ansökan som endast behandlar GET-förfrågningar. De återstående HTTP-metoderna hanteras på liknande sätt — genom att åsidosätta motsvarande metoder för den överordnade klassen. Du kan använda enkla servlets som denna för att bygga sofistikerade mångsidiga webbapplikationer. Att använda stora ramverk som Spring gör naturligtvis detta mycket enklare. Men om du verkligen vill fördjupa dig i alla funktioner hos servlets kan du läsa den officiella specifikationen . Del 6. Servletbehållare Del 7. Introduktion av MVC-mönstret (Model-View-Controller)