Część 5. Serwlety, API serwletów Java. Napisanie prostej aplikacji internetowej

Materiał ten stanowi część serii „Wprowadzenie do rozwoju przedsiębiorstwa”. Poprzednie artykuły:

• o sieci ;
• o architekturze oprogramowania ;
• o protokołach HTTP/HTTPS ;
• o podstawach Mavena .

Czy wiesz już, jak pisać aplikacje w Javie wyświetlające tekst na konsoli, ale nadal nie wiesz, jak stworzyć swoją pierwszą aplikację internetową? Świetnie, rozgość się. W tym artykule zapoznamy się z serwletami i napiszemy aplikację, którą możesz pochwalić się znajomym, bez wysyłania im jarnika czy zmuszania do pobierania Javy. Napiszmy aplikację internetową . Jeśli nie znasz jeszcze podejść stosowanych w programowaniu stron internetowych, radzę zacząć lekturę od pierwszego artykułu z serii „ Wprowadzenie do rozwoju przedsiębiorstwa ”.

Co to jest serwlet

Najpierw dowiedzmy się, czym jest serwlet i dlaczego tak często się o nim słyszy. Java Servlet API to ustandaryzowany interfejs API przeznaczony do implementacji na serwerze i współpracy z klientem w oparciu o schemat żądanie-odpowiedź. Serwlet to klasa, która może odbierać żądania od klienta i zwracać do niego odpowiedzi. Tak, serwlety w Javie są właśnie elementami, z których zbudowana jest architektura klient-serwer. Jeśli pamiętacie, rozmawialiśmy już o tym w jednym z artykułów z tej serii. Nie owijajmy w bawełnę: napiszmy od razu jakiś kod.

Czego potrzebujesz do stworzenia aplikacji internetowej

Aby wygodnie pracować z serwletami w Javie, będziesz potrzebować Intellij IDEA Ultimate Edition. Jest płatna, ale możesz aktywować 30-dniowy okres próbny lub skorzystać z wersji wczesnego dostępu – zawsze jest bezpłatna. Zainstaluj także nasz serwer aplikacji - Apache Tomcat. Tomcat to kontener serwletów: to on przetwarza przychodzące żądania z zewnątrz i przekazuje je do naszej aplikacji. Możesz pobrać Tomcat z tego linku .

Stworzenie pierwszej aplikacji internetowej

Jeśli wszystko jest gotowe, utwórzmy projekt Maven. Jeśli nie znasz Mavena, zwróć uwagę na poprzedni artykuł . Zacznijmy!

1. W pom.xml dodaj zależność javax.servlet-api i ustaw wojnę o pakowanie:

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

   Prosta klasa serwletu:

   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. Aby uruchomić aplikację, musisz utworzyć konfigurację Tomcat:

3. Następnie wskazujemy, z której wersji Tomcata będziemy korzystać, adres URL, pod którym możemy uzyskać dostęp do serwera oraz port. Powinieneś otrzymać coś takiego:

4. Pozostaje tylko określić artefakt (złożony projekt w archiwum jar), który zostanie wdrożony w kontenerze. Możesz kliknąć przycisk Napraw i wybrać opcję war eksplodowała : oznacza to, że po przebudowaniu projektu artefakt zostanie automatycznie umieszczony w kontenerze serwletu.

5. Kontekst aplikacji jest domyślnie ustawiony na servlets_war_exploded , co oznacza, że ​​dostęp do aplikacji należy uzyskać pod adresem: http://localhost:8080/servlets_war_exploded .

   Dlaczego potrzebujemy dodatkowego tekstu? Usuńmy niepotrzebne rzeczy. Teraz adres naszej aplikacji to: http://localhost:8080 .

6. Kliknij OK. Widzimy, że mamy teraz możliwość uruchomienia aplikacji:

   Teraz po uruchomieniu aplikacji przeglądarka powinna się otworzyć i wyświetlić błąd 404. Jest to logiczne, gdyż pod adresem http://localhost:8080/ powinien znajdować się serwlet z odwzorowaniem „/”, a nasz jedyny serwlet ma odwzorowanie „/hello” .

7. Kontaktujemy się z nim pod adresem http://localhost:8080/hello i otrzymujemy oczekiwaną odpowiedź - ciąg „Hello”!

Jeśli wszystko działa, spójrzmy na kod. Aby utworzyć serwlet http ze zwykłej klasy , musisz odziedziczyć go z klasy HttpServlet. Nad klasą podajemy adnotację @WebServlet(), w której wiążemy (mapujemy) serwlet z określoną ścieżką („/hello”). Ta adnotacja pojawiła się tylko w Java Servlet API 3.0, dlatego w Internecie istnieje wiele przykładów, w których mapowanie serwletów odbywa się poprzez plik XML. Teraz nie jest to konieczne. Aby przetworzyć żądania GET , nadpisujemy metodę doGet(). Zwróć uwagę na argumenty metody - HttpServletRequest i HttpServletResponse. Z obiektu HttpServletRequest możemy pobrać wszystkie niezbędne informacje o żądaniu, w HttpServletResponse możemy zapisać naszą odpowiedź i ustawić niezbędne nagłówki.

Praca z parametrami i sesją

Ulepszmy nasz serwlet tak, aby mógł przetwarzać parametry żądania i pracować z sesją:

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

Serwlet aktualnie wykonuje sesję, zwiększając wartość VisitCounter za każdym razem, gdy strona jest odwiedzana. Jeśli atrybut VisitCounter nie został jeszcze utworzony (przy pierwszej wizycie na stronie), metoda getAttribute() zwróci wartość null, dlatego należy sprawdzić wartość null. To samo dotyczy parametrów żądania. Jeśli użytkownik nie przekazał parametru username, jego wartość będzie równa null. W takim przypadku powitamy użytkownika jako anonimowego. Aby przekazać parametr w żądaniu GET, używane są zmienne ścieżki, co oznacza, że ​​musisz uzyskać dostęp do łącza http://localhost:8080/hello?username=Pavel . Więcej o żądaniach http przeczytasz w poprzednim artykule z tej serii. Teraz nasza aplikacja ma minimalną logikę, ale błąd 404 w ścieżce głównej jest trochę denerwujący. Aby to naprawić, utwórzmy kolejny serwlet i zamapujmy go na stronę początkową @WebServlet("/"). Zadaniem tego serwletu jest przekierowywanie żądań na ścieżkę „/hello”. Można to zrobić na dwa sposoby: za pomocą przesyłania dalej lub przekierowania. Być może warto zrozumieć, jaka jest między nimi różnica. forward - deleguje przetwarzanie żądań do innego serwletu na serwerze, klient nie jest zaangażowany. Aby to zrobić, musisz dodać następujący kod do metody doGet() nowego serwletu:

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

W tym kodzie uzyskujemy dostęp do kontekstu serwletu, pobieramy z niego menedżera żądań żądanego serwletu i prosimy go o przetworzenie konkretnego żądania z określonymi parametrami (req, resp). przekierowanie - zwraca klientowi adres, pod który musi się skontaktować, aby obsłużyć jego żądanie. Większość przeglądarek automatycznie przechodzi do przesłanego linku. Aby zaimplementować przekierowanie, musisz dodać ten kod:

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

W HttpServletResponse wywołujemy metodę redirect() i przekazujemy jej adres, z którym klient ma się skontaktować. Ważny szczegół: parametry http trzeba też dodać na końcu pełnej ścieżki przekierowania, co nie jest zbyt wygodne. W naszej sytuacji lepiej jest użyć forwardu, ale zdarza się, że lepiej jest użyć przekierowania. Jeśli zrozumiesz różnicę w ich pracy, nie pomylisz się ze swoim wyborem. Kod nowego serwletu wygląda następująco:

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

Konkluzja

Twoja pierwsza aplikacja internetowa jest gotowa. W następnym artykule dowiesz się jak go wdrożyć bez użycia Intellij IDEA. Napisaliśmy aplikację, która przetwarza wyłącznie żądania GET. Pozostałe metody http przetwarzane są w ten sam sposób - przesłaniając odpowiednie metody klasy nadrzędnej. Używając takich prostych serwletów, można budować złożone, bogate aplikacje internetowe. Oczywiście, używając dużych frameworków, takich jak Spring, jest to znacznie łatwiejsze. Jeśli jednak naprawdę chcesz bardziej szczegółowo poznać wszystkie możliwości serwletów, możesz przeczytać oficjalną specyfikację . Część 6. Kontenery serwletów Część 7. Wprowadzenie do wzorca MVC (Model-View-Controller) Część 8. Pisanie małej aplikacji w trybie spring-boot