Deel 5. Servlets en de Java Servlet API. Schrijven van een eenvoudige webapplicatie

Dit materiaal maakt deel uit van de serie "Inleiding tot Enterprise Development". Vorige artikelen:

• over netwerken
• over software-architectuur
• over HTTP/HTTPS
• over de basis van Maven

Weet u al hoe u Java-applicaties moet schrijven die tekst weergeven op de console, maar weet u nog niet echt hoe u uw eerste webapplicatie moet maken? Geweldig, maak het jezelf gemakkelijk. In dit artikel maken we kennis met servlets en schrijven we een applicatie waarover je kunt opscheppen bij je vrienden zonder ze een JAR-bestand te sturen en zonder ze te dwingen Java te downloaden. Laten we een eenvoudige webapplicatie schrijven . Als u nog niet bekend bent met de benaderingen die worden gebruikt bij webontwikkeling, raad ik u aan om te beginnen met het lezen van het eerste artikel in de serie " Inleiding tot Enterprise Development ".

Wat is een servlet?

Laten we eerst eens kijken wat servlets zijn en waarom je er zo vaak over hoort. De Java Servlet API is een gestandaardiseerde API die bedoeld is om op de server te worden geïmplementeerd. Het communiceert met klanten volgens een verzoek-antwoordschema. Een servlet is een klasse die verzoeken van een client kan ontvangen en antwoorden kan terugsturen naar de client. In feite zijn servlets precies de bouwstenen die we gebruiken om een ​​client-serverarchitectuur in Java te creëren. U herinnert zich misschien dat we al over die architectuur spraken in een ander artikel in de serie. We gaan er niet omheen draaien: laten we meteen wat code schrijven.

Wat u nodig heeft om een ​​webapplicatie te maken

Voor het grootste gemak bij het werken met Java-servlets hebt u IntelliJ IDEA Ultimate Edition nodig. Het is een betaald product, maar u kunt een proefperiode van 30 dagen activeren of de versie met vroege toegang gebruiken, die altijd gratis is. Installeer ook Apache Tomcat — de server van onze applicatie. Tomcat is een servletcontainer: het verwerkt inkomende verzoeken en geeft ze door aan onze applicatie. Download Tomcat hier .

Laten we onze eerste webapplicatie maken

Als alles klaar is, maak dan een Maven-project aan. Als u niet bekend bent met Maven, bekijk dan het vorige artikel . Laten we beginnen!

1. Voeg in pom.xml een javax.servlet-api-afhankelijkheid toe en geef WAR-verpakking op:

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

   Eenvoudige 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. Om de toepassing uit te voeren, moet u een Tomcat-configuratie maken:

3. Vervolgens geven we aan welke versie van Tomcat we zullen gebruiken, en de URL en poort voor communicatie met de server. Je zou zoiets als dit moeten hebben:

4. Nu hoeven we alleen nog het artefact (het samengestelde project in een JAR-archief) op te geven dat in de container zal worden geïmplementeerd. U kunt op de knop Herstellen klikken en oorlog exploderen selecteren : dit betekent dat nadat het project opnieuw is opgebouwd, het artefact automatisch in de servletcontainer wordt geplaatst.

5. De standaardwaarde voor toepassingscontext is servlets_war_exploded . Dit betekent dat we toegang hebben tot de applicatie op: http://localhost:8080/servlets_war_exploded .

   Waarom zouden we extra tekst willen? Laten we verwijderen wat niet nodig is. Nu is het adres van onze webapplicatie: http://localhost:8080 .

6. Klik OK. We zien dat we de applicatie nu kunnen starten:

   Wanneer u nu de applicatie in uw browser opent, zou u een 404-fout moeten krijgen. Dit is logisch, omdat het adres http://localhost:8080/ een servlet nodig heeft die is toegewezen aan "/", maar onze enige servlet is toegewezen aan "/hello" .

7. We hebben er toegang toe op http://localhost:8080/hello . Zodra we dat doen, krijgen we het verwachte antwoord - de tekenreeks "Hallo"!

Als alles werkt, gaan we de code analyseren. Om van een gewone klasse een HTTP-servlet te maken , moet deze de HttpServlet-klasse erven. Boven de klassendeclaratie geven we de @WebServlet()annotatie aan. Dit is waar we de servlet binden (of toewijzen) aan een specifiek pad ("/hello"). Deze annotatie verscheen alleen in Java Servlet API 3.0, dus het internet heeft veel voorbeelden waarbij servlettoewijzing plaatsvindt via een XML-bestand. Dit hoeft niet meer. Om GET-verzoeken af ​​te handelen , overschrijven we de doGet()methode. Besteed aandacht aan de parameters van de methode: HttpServletRequesten HttpServletResponse. Het HttpServletRequestobject geeft ons alle benodigde informatie over de aanvraag. In de HttpServletResponse, schrijven we onze reactie en stellen we de nodige headers in.

Werken met parameters en een sessie

Laten we onze servlet verbeteren zodat deze aanvraagparameters kan verwerken en met een sessie kan werken:

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 werkt de servlet met een sessie, waardoor de waarde van visitCounterelke keer dat de pagina wordt bezocht, wordt verhoogd. Als het visitCounterattribuut nog niet is gemaakt (bij het eerste bezoek aan de pagina), getAttribute()retourneert de methode null, dus we moeten controleren op null. Hetzelfde geldt voor verzoekparameters. Als de gebruiker de gebruikersnaamparameter niet doorgeeft, is de waarde null. In dit geval begroeten we de gebruiker als een anonieme bezoeker. Om een ​​parameter in een GET-verzoek door te geven, wordt een querystring gebruikt. We kunnen bijvoorbeeld de volgende URL gebruiken: http:// localhost:8080/hello? Gebruikersnaam=Paul. U kunt meer lezen over HTTP-verzoeken in het vorige artikelIn de serie. Onze applicatie heeft momenteel niet veel logica, maar het is een beetje vervelend dat we een 404-fout krijgen in het rootpad. Om dit op te lossen, maken we nog een servlet en koppelen we deze aan de startpagina: @WebServlet("/"). Het doel van deze servlet is om verzoeken om te leiden naar het "/hello"-pad. Er zijn twee manieren om dit te doen: door "forward" of "redirect" te gebruiken. Misschien is het de moeite waard om het verschil tussen hen te begrijpen. Een forward delegeert de verwerking van het verzoek naar een andere servlet op de server. De opdrachtgever is hierbij niet betrokken. Voeg hiervoor de volgende code toe aan de methode doGet() van de nieuwe servlet:

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

In deze code hebben we toegang tot de servletcontext, halen de verzoekverzender voor de relevante servlet op en vragen deze om een ​​specifiek verzoek te verwerken met de opgegeven argumenten (req, resp). Een omleiding stuurt het adres terug naar de klant dat de klant moet gebruiken om zijn verzoek te verwerken. De meeste browsers navigeren automatisch naar de geretourneerde URL. Om een ​​omleiding te implementeren, moet u deze code toevoegen:

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

We noemen de redirect()methode op de HttpServletResponseparameter en geven het adres door dat de client moet gebruiken. Hier is een belangrijk detail: HTTP-parameters moeten ook worden toegevoegd aan het einde van het volledige omleidingspad, wat niet erg handig is. In onze situatie verdient het de voorkeur om te gebruiken forward, maar soms redirectis gebruiken beter. Als u het verschil begrijpt in hoe ze werken, maakt u niet de verkeerde keuze. De code voor de nieuwe servlet ziet er als volgt uit:

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

Samenvatting

Je eerste webapplicatie is klaar. In het volgende artikel leert u hoe u het kunt implementeren zonder IntelliJ IDEA te gebruiken. We hebben een applicatie geschreven die alleen GET-verzoeken verwerkt. De overige HTTP-methoden worden op een vergelijkbare manier afgehandeld: door de overeenkomstige methoden van de bovenliggende klasse te overschrijven. U kunt eenvoudige servlets zoals deze gebruiken om geavanceerde, veelzijdige webapplicaties te bouwen. Het gebruik van grote frameworks zoals Spring maakt dit natuurlijk veel gemakkelijker. Maar als u echt dieper wilt ingaan op alle mogelijkheden van servlets, kunt u de officiële specificatie lezen . Deel 6. Servlet-containers Deel 7. Introductie van het MVC-patroon (Model-View-Controller)