Din första applikation som använder Java-servlets

Hej alla! Du kommer att bli bekant med servlets som ett grundläggande koncept för webbutveckling, och du kommer att kunna skriva en enkel applikation som använder dem. För att undvika onödiga åtgärder börjar vi inte från början. Vi kommer att fortsätta arbeta med vår applikation från min tidigare artikel om Hibernate . Men eftersom vi precis har börjat bekanta oss med servlets har jag tagit bort allt relaterat till Auto-klassen från applikationen och bara lämnat User-klassen och åtgärder som involverar den. Projektet kommer att vara uppbyggt så här: Så, servletter! Wikipedia säger: "En Java-servlet är en Java-mjukvarukomponent som utökar kapaciteten hos en server. Även om servlets kan svara på många typer av förfrågningar, implementerar de oftast webbcontainrar för att vara värd för webbapplikationer på webbservrar och kvalificerar sig därför som en server- side servlet web API." Detta är exakt sant. Här, för första gången, stöter vi på konceptet med en "klient-server-applikationsarkitektur." Det är ganska enkelt i grunden. Klienten kommer åt servern genom att skicka en HTTP-förfrågan. Servern genererar nödvändig data (hämtar till exempel den från en databas) och returnerar den till klienten. Det enklaste exemplet är när du klickar på knappen "Vänner" på ett visst socialt nätverk och därigenom skickar en förfrågan till servern. Servern uppdaterar listan över dina vänner i databasen och returnerar den till dig (klienten). Listan över HTTP-förfrågningar är ganska stor, så om du aldrig har stött på dem förut, är det bäst om du läser om dem någon annanstans, t.ex.här . Vårt mål är att: Skapa en CRUD-applikation med servlets. Applikationen måste kunna skapa, läsa, uppdatera och ta bort användare från databasen med hjälp av en servlet som bearbetar HTTP-förfrågningar. Vår applikation från Hibernate-artikeln kunde redan göra detta, men den styrdes direkt från Java-kod, närmare bestämt från main()-metoden. Den här gången är det klienten som skickar förfrågningarna, dvs du :) Det första vi behöver göra är att lägga till nya beroenden till vår pom.xml-fil.

<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>com.itis4</groupId>
    <artifactId>UsersDaoProject</artifactId>
    <version>1.0-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.6</version>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- PostgreSQL  -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>9.4.1212.jre7</version>
        </dependency>

        <!-- Hibernate 5.2.6 Final -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.6.Final</version>
        </dependency>

        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.4.RELEASE</version>
        </dependency>

    </dependencies>

</project>

Vi har lagt till 3 beroenden:

1. Själva biblioteket javax.servlet-api
2. JSTL-taggbiblioteket. Det kommer att behövas för att skapa klientsidan, nämligen JSP-sidorna
3. Spring-WebMVC. Vi kommer att behöva en vårklass, som vi kommer att prata om lite senare.

Servlethantering hanteras av servletbehållaren. I vårt fall kommer vi att använda Apache Tomcat. Det är ganska populärt — du har säkert redan hört talas om det :) Servlets livscykel består av följande steg:

1. Om det inte finns någon servlet i behållaren:
   
   • Servletklassen laddas av behållaren.
   • Behållaren skapar en instans av servletklassen.
   • Behållaren anropar metoden init(). Denna metod initierar servleten och anropas först, innan servleten kan betjäna förfrågningar. Under hela livscykeln anropas metoden init() endast en gång.
2. Betjäna kundens begäran. Varje begäran behandlas i sin egen separata tråd. Behållaren anropar metoden service() för varje begäran. Denna metod bestämmer typen av inkommande begäran och skickar den till lämplig metod för bearbetning. Servletutvecklaren måste tillhandahålla implementeringar för dessa metoder. Om en begäran kommer in för en hanterare som inte är implementerad anropas den överordnade klassens metod och slutar vanligtvis med att returnera ett fel till begäranden.


3. Om behållaren behöver ta bort servleten anropar den metoden destroy(), vilket tar servleten ur drift. Liksom metoden init() anropas även denna metod en gång under hela servletcykeln.

Vår servlet ser ganska enkel ut:

package servlets;

import models.User;
import services.UserService;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

public class UserSimpleServlet extends HttpServlet {

    private UserService service = new UserService();

    public void init(ServletConfig servletConfig) {
        try {
            super.init(servletConfig);
        } catch (ServletException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        List<User> users = service.findAllUsers();
        req.setAttribute("users", users);
        RequestDispatcher dispatcher = req.getRequestDispatcher("/showUsers.jsp");
        dispatcher.forward(req, resp);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

        String name = req.getParameter("name");
        int age = Integer.parseInt(req.getParameter("age"));
        User user = new User(name, age);
        service.saveUser(user);
        resp.sendRedirect("/users");

    }

    @Override
    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int id = Integer.parseInt(req.getParameter("id"));
        User user = service.findUser(id);
        user.setName(req.getParameter("name"));
        user.setAge(Integer.parseInt(req.getParameter("age")));
        service.updateUser(user);
        resp.sendRedirect("/users");
    }

    @Override
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        int id = Integer.parseInt(req.getParameter("id"));
        service.deleteUser(service.findUser(id));
        resp.sendRedirect("/users");
    }
}

Som du kan se innehåller den metoden init() som beskrevs ovan och implementerar 4 metoder som sammanfaller med fyra HTTP-förfrågningar: doPost(), doGet(), doPut() och doDelete(). De låter oss skapa, läsa, uppdatera och ta bort användare. Metoderna accepterar instanser av klasserna javax.servlet.http.HttpServletRequest och javax.servlet.http.HttpServletResponse som input, dvs förfrågningar som skickas till servern och svar som tas emot av klienten. Internt anropar metoderna de relevanta metoderna för UserService-klassen, och ett svar för klienten genereras och omdirigeras till /users URL. Till exempel, i metoden doGet() får vi en lista över alla användare. Därefter skapar vi ett RequestDispatcher-objekt, som låter oss inkludera objekt i en HTTP-förfrågan och omdirigera den till en specifik resurs (till exempel till en klient-JSP-sida). I metoden doPut() (som uppdaterar användardata) behandlar vi en HTTP-begäran, extraherar parametrarna för id, namn och ålder, hittar användaren med det angivna id:t, tilldelar den namnet och åldern i begäran och returnerar till /users-sidan. Men för att alla dessa metoder ska fungera korrekt måste vi konfigurera servleten. För att göra detta använder vi filen web.xml i WEB-INF-mappen.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1"
         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <servlet>
        <servlet-name>UserSimpleServlet</servlet-name>
        <servlet-class>servlets.UserSimpleServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>UserSimpleServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <servlet-name>UserSimpleServlet</servlet-name>
    </filter-mapping>

</web-app>

Alla taggar i den här filen är ganska intuitiva, men låt oss gå igenom dem i ordning. <welcome-file-list> - JSP-startsidan indikeras, som kommer att öppnas först när applikationen startar. I vårt fall är detta index.jsp. <servlet> - Registrering av vår UserSimpleServlet-klass som en servlet. <servlet-mapping> - en mycket viktig tagg. Den definierar webbadresserna som kommer att bearbetas av servleten. I vårt fall är det alla webbadresser, så vi anger helt enkelt "/". Men om vi hade en applikation som involverade användare och deras bilar (bilar), så kunde vi skapa en andra servlet (SimpleAutoServlet). Då skulle användarservletens mappning vara "/users" (dvs förfrågningar om användare), och autoservletens mappning skulle vara "/autos". Och slutligen, <filter>. Internt definierar den en instans av organisationen. springframework.web.filter.HiddenHttpMethodFilter-klass. Den här artikeln handlar inte om våren, så jag kommer inte att beskriva den i detalj. Jag ska bara säga att det bara är fastskruvat på vår applikation som en extra funktion. Saken är den att vi kommer att använda JSP-sidor för att skapa klientsidan. Vår data kommer att visas på sidan som en tabell med en lista över användare. Inuti JSP-sidorna kommer <form/> HTML-taggar att användas. Men bara HTTP GET- och POST-förfrågningar kan användas för att skicka data från ett <form/>. Med andra ord, för alla tre operationerna - uppdatering, radering och skapande av en användare - skulle vi bara behöva använda POST-förfrågningar. Att använda PUT- och DELETE-förfrågningar skulle inte vara ett alternativ för oss. I princip är detta ganska normalt och lätt att implementera, men HiddenHttpMethodFilter-klassen låter oss använda dem. På det här sättet, läsaren kommer tydligare att se skillnaden mellan operationer i applikationen. Låt oss slutligen gå vidare till kundsidan. Den representeras av fem JSP-sidor. index.jsp.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello!</title>
</head>
<body>
If you want to start working with the user database,<br>
click the button below:

<form action = "users" method="get">
    <input type="submit" value="Start working with database">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Add new user</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Age">
    <input type="submit" value="Save">
</form>
</body>
</html>

deleteUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Delete user</title>
</head>
<body>

Are you sure you want to delete the user ${param.id}?

&lform action="/users/${param.id}" method="post">
    <input type="hidden" name="id" value="${param.id}">
    <input type="hidden" name="_method" value="delete">
    <input type="submit" value="Delete">
</form>

</body>
</html>

showUsers.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>User list</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Age</td>
        <td>Actions</td>
    </tr>
    <c:forEach items="${users}" var = "user">
        <tr>
            <td>${user.getId()}</td>
            <td>${user.getName()}</td>
            <td>${user.getAge()}</td>
            <td>
                <form action = "updateUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="hidden" name="name" value="${user.getName()}">
                    <input type="hidden" name="age" value="${user.getAge()}">
                    <input type="submit" value="Modify" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Delete" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Add new user">
</form>
</body>
</html>

uppdateraUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Modify user data</title>
</head>
<body>

Edit user

<form action="/users/${param.id}" method="post">
    <input type="hidden" name = "id" value="${param.id}">
    <input type="text" name="name" value="${param.name}" placeholder=${param.name}>
    <input type="text" name="age" value="${param.age}" placeholder=${param.age}>
    <input type="hidden" name="_method" value="put">
    <input type="submit" value="Update">
</form>

</body>
</html>

En JSP-sida (JavaServer-sida) innehåller två typer av text: statisk källdata som kan formateras som text (HTML, SVG, WML eller XML), och JSP-element som används för att konstruera dynamiskt innehåll. För att hjälpa dig förstå vad en JSP-sida är, har jag kopierat ett avsnitt från en mycket bra artikel. "I grund och botten, första gången en JSP efterfrågas, förvandlas den till en servlet och fungerar som en servlet. Detta är mycket viktigt att förstå. En JSP-sida ÄR INTE som en HTML-sida — en nybörjarprogrammerare måste tydligt förstå att detta är en annan servlet. — det är bara så att du inte behöver programmera hur det visas. Det kan helt enkelt ritas. Och lägga till data där det behövs. Men eftersom en JSP-sida påminner om HTML, kommer en designer uppenbarligen att tycka att det är lättare. Och återigen BETONAR STARKT för nybörjare,en JSP-sida är en SERVLET. Den genereras, inklusive att lägga till all data, på servern. Det är här all data infogas. Och i webbläsaren får användaren den färdiga HTML-sidan, som inte har tecken på Java." Du kan vara säker på att en JSP-sida verkligen är en servlet, eftersom varje sida har en metod som måste köras. Till exempel indexera .jsp indikerar att när du klickar på knappen "Börja arbeta med databasen" kommer get-metoden att exekveras (metod = "get"). Sidan addUser.jsp, som är ansvarig för att skapa nya användare, kör postmetoden (metod = "inlägg") när du klickar på spara-knappen. Resten av JSP-sidan består av vanlig statisk HTML-uppmärkning, så vi kommer inte att uppehålla oss vid det. Det är ett ämne för en annan artikel och det finns mycket om detta ämne på Internet. Så vi har skapat vår applikation! Nu måste vi testa det i praktiken! För att göra detta behöver vi Apache Tomcat-servletbehållaren som nämns ovan. Du kan ladda ner behållarenfrån den officiella webbplatsen (jag använder version 8). Därefter måste vi skapa en konfiguration i IDEA för att köra vår applikation genom Tomcat. För att göra detta, öppna fliken "Redigera konfigurationer", skapa en ny konfiguration och välj "Tomcat Server Local". På fliken "Applikationsserver", ange sökvägen till Tomcat-mappen. Gå sedan till fliken "Deployment". Här konfigurerar vi distributionen av vår applikation på den lokala servern. Tryck på "+", välj "Artifact" -> YourProjectName:war (vi bygger programmet till en krigsfil). Och det sammanfattar det ungefär! På sidan "Server" kan du se att vår applikation kommer att köras på http://localhost:8080/. Spara konfigurationen och ge den ett namn (jag kallar min konfiguration "Tommy"). Därefter, på Maven-fliken i IDEA (på höger sida), kommer vi att använda war-plugin för att bygga vårt projekt till en krigsfil (Plugins -> war -> war: war). När bygget är klart, kör programmet och vänta. Framgång! Startsidan lanserades. Nu klickar vi på knappen "Börja arbeta med databasen". Vår index.jsp kommer att generera en GET-begäran som kommer att behandlas av servern. Servern kommer att generera ett svar och returnera det till oss i form av en lista över alla befintliga användare (förutsatt att det finns användare i databasen förstås). Och där är de! Att där har du det! Du skrev din första applikation med Java-servlets. Det var väl inte så illa? :) För läxor kan du återställa bilens funktionalitet från föregående artikel. Med andra ord, skapa en separat servlet och JSP-sidor för bilar, och lär applikationen hur man listar en användares bilar, lägger till nya bilar till en användare och redigerar och tar bort dem. PS Servlets och JavaServer Pages är ganska gamla tekniker. På Internet kan du ofta hitta kommentarer som "Vem behöver det här gamla skräpet?" Svaret är ganska enkelt: främst människor som kommer att arbeta med riktiga projekt, där de mycket möjligt kan stöta på mycket kod som använder dessa teknologier. Och även utan att förstå hur det fungerar är det ändå kul att skära upp "gammalt skräp" till något nytt :) För en mer grundlig studie av JSP och servlets kan du hänvisa till boken "Head First Servlets and JSP ". Den skrevs av samma författare som den berömda superboken "Head First Java", som många kommer att ta som en garanti för kvalitet :) Jag hoppas att denna artikel har varit till hjälp! Tack för din uppmärksamhet och lycka till med lärandet!