Część 5. Serwlety i Java Servlet API. Pisanie prostej aplikacji internetowej

Ten materiał jest częścią serii „Wprowadzenie do rozwoju przedsiębiorstwa”. Poprzednie artykuły:

Czy wiesz już, jak pisać aplikacje Java, które wyświetlają 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 pliku JAR i bez zmuszania ich do pobierania Javy. Napiszmy prostą aplikację internetową . Jeśli nie jesteś jeszcze zaznajomiony z podejściami stosowanymi w tworzeniu stron internetowych, polecam zacząć od przeczytania pierwszego artykułu z serii „ Wprowadzenie do rozwoju przedsiębiorstwa ”.

Co to jest serwlet?

Najpierw dowiedzmy się, czym są serwlety i dlaczego tak często się o nich słyszy. Java Servlet API to standardowe API przeznaczone do implementacji na serwerze. Współdziała z klientami zgodnie ze schematem żądanie-odpowiedź. Serwlet to klasa, która może odbierać żądania od klienta i zwracać klientowi odpowiedzi . W rzeczywistości serwlety są dokładnie tymi elementami, których używamy do tworzenia architektury klient-serwer w Javie. Być może pamiętasz, że mówiliśmy już o tej architekturze w innym artykule z tej serii. Nie będziemy owijać w bawełnę: napiszmy od razu trochę kodu.

Co jest potrzebne do stworzenia aplikacji internetowej

Aby zapewnić największą wygodę podczas pracy z serwletami Java, potrzebujesz IntelliJ IDEA Ultimate Edition. Jest to produkt płatny, ale możesz aktywować 30-dniową wersję próbną lub skorzystać z wersji wczesnego dostępu, która jest zawsze bezpłatna. Zainstaluj także Apache Tomcat — serwer naszej aplikacji. Tomcat to kontener serwletów: przetwarza przychodzące żądania i przekazuje je do naszej aplikacji. Pobierz Tomcata tutaj .

Stwórzmy naszą pierwszą aplikację internetową

Jeśli wszystko jest gotowe, utwórz projekt Maven. Jeśli nie znasz Mavena, zapoznaj się z poprzednim artykułem . Zaczynajmy!

W pliku pom.xml dodaj zależność javax.servlet-api i określ pakiet WAR:

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

Aby uruchomić aplikację, musisz utworzyć konfigurację Tomcat:
Następnie wskazujemy, której wersji Tomcata będziemy używać oraz adres URL i port do komunikacji z serwerem. Powinieneś mieć coś takiego:
Teraz musimy 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ć wybuch wojny : oznacza to, że po przebudowie projektu artefakt zostanie automatycznie umieszczony w kontenerze serwletów.
Domyślną wartością kontekstu aplikacji jest servlets_war_exploded . Oznacza to, że uzyskujemy dostęp do aplikacji pod adresem: http://localhost:8080/servlets_war_exploded .

Dlaczego mielibyśmy chcieć dodatkowego tekstu? Usuńmy to, co zbędne. Teraz adres naszej aplikacji internetowej to: http://localhost:8080 .
Kliknij OK. Widzimy, że możemy teraz uruchomić aplikację:

Teraz, gdy otworzysz aplikację w przeglądarce, powinieneś otrzymać błąd 404. Ma to sens, ponieważ adres http://localhost:8080/ potrzebuje serwletu, który jest mapowany na "/", ale nasz jedyny serwlet jest mapowany na "/hello" .
Możemy uzyskać do niego dostęp pod adresem http://localhost:8080/hello . Gdy to zrobimy, otrzymamy oczekiwaną odpowiedź — ciąg „Cześć”!

Jeśli wszystko działa, przeanalizujmy kod. Aby uczynić serwlet HTTP ze zwykłej klasy , musi on dziedziczyć klasę HttpServlet. Nad deklaracją klasy wskazujemy @WebServlet()adnotację. W tym miejscu wiążemy (lub mapujemy) serwlet z określoną ścieżką („/hello”). Ta adnotacja pojawiła się tylko w Java Servlet API 3.0, więc w Internecie można znaleźć wiele przykładów mapowania serwletów za pośrednictwem pliku XML. To nie jest już konieczne. Aby obsłużyć żądania GET , nadpisujemy doGet()metodę. Zwróć uwagę na parametry metody: HttpServletRequesti HttpServletResponse. Obiekt HttpServletRequestudostępnia nam wszystkie niezbędne informacje dotyczące zapytania. W HttpServletResponse, piszemy naszą odpowiedź i ustawiamy niezbędne nagłówki.

Praca z parametrami i sesją

Poprawmy nasz serwlet, 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();
   }
}

Teraz aplet działa z sesją, zwiększając wartość za visitCounterkażdym razem, gdy strona jest odwiedzana. Jeśli visitCounteratrybut nie został jeszcze utworzony (przy pierwszej wizycie na stronie), metoda getAttribute()zwraca null, więc musimy sprawdzić, czy nie ma null. To samo dotyczy parametrów żądania. Jeśli użytkownik nie przekaże parametru nazwy użytkownika, wówczas jego wartość będzie równa null. W takim przypadku witamy użytkownika jako anonimowego gościa. Aby przekazać parametr w żądaniu GET, używany jest ciąg zapytania. Na przykład możemy użyć następującego adresu URL: http://localhost:8080/hello? Nazwa użytkownika=Paweł. Możesz przeczytać więcej o żądaniach HTTP w poprzednim artykulew serii. Nasza aplikacja obecnie nie ma zbyt wiele logiki, ale trochę irytujące jest to, że w ścieżce głównej otrzymujemy błąd 404. Aby to naprawić, utworzymy inny serwlet i zmapujemy go na stronę startową: @WebServlet("/"). Celem tego serwletu jest przekierowanie żądań do ścieżki „/hello”. Można to zrobić na dwa sposoby: za pomocą „przekierowania” lub „przekierowania”. Być może warto zrozumieć różnicę między nimi. Forward deleguje przetwarzanie żądania do innego serwletu na serwerze. Klient nie jest zaangażowany. Aby to zrobić, dodaj następujący kod do metody doGet() nowego serwletu:

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

W tym kodzie uzyskujemy dostęp do kontekstu serwletu, uzyskujemy dyspozytora żądań dla odpowiedniego serwletu i prosimy go o przetworzenie określonego żądania z określonymi argumentami (req, resp). Przekierowanie zwraca klientowi adres, którego klient musi użyć do przetworzenia żądania . Większość przeglądarek automatycznie przechodzi do zwróconego adresu URL. Aby zaimplementować przekierowanie, musisz dodać ten kod:

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

Wywołujemy redirect()metodę na HttpServletResponseparametrze i przekazujemy jej adres, którego klient ma użyć. Oto ważny szczegół: parametry HTTP muszą być również dodane na końcu pełnej ścieżki przekierowania, co nie jest zbyt wygodne. W naszej sytuacji lepiej jest użyć forward, ale czasami użycie redirectjest lepsze. Jeśli zrozumiesz różnicę w sposobie ich działania, nie dokonasz złego wyboru. 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");
   }
}

Streszczenie

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 tylko żądania GET. Pozostałe metody HTTP są obsługiwane w podobny sposób — przez nadpisanie odpowiednich metod klasy nadrzędnej. Możesz używać prostych serwletów, takich jak ten, do tworzenia zaawansowanych, wszechstronnych aplikacji internetowych. Oczywiście użycie dużych frameworków, takich jak Spring, znacznie to ułatwia. Ale jeśli naprawdę chcesz zagłębić się we 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)