Az első Java szervleteket használó alkalmazás

Üdv mindenkinek! Megismerheti a servleteket, mint a webfejlesztés alapfogalmát, és képes lesz egyszerű alkalmazást írni, amely ezeket használja. A szükségtelen tevékenységek elkerülése érdekében nem kezdjük a nulláról. Folytatjuk a munkát a hibernálással kapcsolatos korábbi cikkemben szereplő alkalmazásunkon . De mivel még csak most kezdünk ismerkedni a szervletekkel, az alkalmazásból eltávolítottam mindent, ami az Auto osztállyal kapcsolatos, és csak a User osztályt és az azzal kapcsolatos műveleteket hagytam meg. A projekt a következőképpen épül fel: Szóval, szervletek! A Wikipédia kijelenti: "A Java servlet egy olyan Java szoftverkomponens, amely kiterjeszti a szerver képességeit. Bár a szervletek sokféle kérésre tudnak válaszolni, leggyakrabban webkonténereket valósítanak meg webes alkalmazások webszervereken való tárolására, és így szervernek minősülnek. oldali szervlet webes API." Ez pontosan igaz. Itt találkozunk először az "ügyfél-szerver alkalmazásarchitektúra" fogalmával. Lényegében meglehetősen egyszerű. A kliens HTTP kérés elküldésével éri el a szervert. A szerver előállítja a szükséges adatokat (például lekéri egy adatbázisból), és visszaküldi a kliensnek. A legegyszerűbb példa az, amikor rákattint a "Barátok" gombra egy bizonyos közösségi hálózaton, és ezzel kérést küld a szervernek. A szerver frissíti a barátok listáját az adatbázisban, és visszaküldi Önnek (a kliensnek). A HTTP kérések listája meglehetősen nagy, így ha még soha nem találkozott velük, akkor az a legjobb, ha máshol olvas róluk, pl.itt . Célunk: CRUD alkalmazás létrehozása szervletekkel. Az alkalmazásnak képesnek kell lennie a felhasználók létrehozására, olvasására, frissítésére és az adatbázisból való törlésére a HTTP-kéréseket feldolgozó szervlet használatával. A Hibernate cikkből származó alkalmazásunk már képes volt erre, de közvetlenül Java kódból, pontosabban a main() metódusból vezérelte. Ezúttal a kliens küldi majd a kéréseket, azaz Ön :) Az első dolgunk, hogy új függőséget adjunk a pom.xml fájlunkhoz.

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

3 függőséget adtunk hozzá:

1. Maga a javax.servlet-api könyvtár
2. A JSTL címkekönyvtár. Erre a kliens oldal, nevezetesen a JSP oldalak létrehozásához lesz szükség
3. Spring-WebMVC. Szükségünk lesz egy tavaszi órára, amiről egy kicsit később fogunk beszélni.

A szervlet kezelését a szervlet konténer kezeli. Esetünkben az Apache Tomcat-et fogjuk használni. Elég népszerű – valószínűleg már hallott róla :) A szervlet életciklusa a következő lépésekből áll:

1. Ha nincs szervlet a tárolóban:
   
   • A servlet osztályt a tároló tölti be.
   • A tároló létrehozza a szervlet osztály példányát.
   • A tároló meghívja az init() metódust. Ez a metódus inicializálja a szervletet, és először meghívásra kerül, mielőtt a szervlet kiszolgálhatná a kéréseket. A teljes életciklus során az init() metódus csak egyszer kerül meghívásra.
2. Kiszolgálja az ügyfél kérését. Minden kérés feldolgozása különálló szálon történik. A tároló minden kérésnél meghívja a service() metódust. Ez a módszer meghatározza a bejövő kérés típusát, és elküldi azt a megfelelő metódusnak feldolgozásra. A szervlet fejlesztőjének biztosítania kell ezeknek a módszereknek a megvalósítását. Ha egy kérés érkezik egy nem implementált kezelőhöz, akkor a szülőosztály metódusa kerül meghívásra, és általában hibát ad vissza a kérelmezőnek.


3. Ha a tárolónak el kell távolítania a szervletet, akkor meghívja a delete() metódust, amely megszünteti a szervlet működését. Az init() metódushoz hasonlóan ezt a metódust is egyszer meghívjuk a teljes szervlet ciklus alatt.

A servletünk meglehetősen egyszerűnek tűnik:

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

Mint látható, tartalmazza a fentebb leírt init() metódust, és 4 metódust valósít meg, amelyek egybeesnek négy HTTP kéréssel: doPost(), doGet(), doPut() és doDelete(). Lehetővé teszik számunkra a felhasználók létrehozását, olvasását, frissítését és törlését. A metódusok a javax.servlet.http.HttpServletRequest és a javax.servlet.http.HttpServletResponse osztályok példányait fogadják be bemenetként, azaz a kiszolgálónak küldött kéréseket és a kliens által kapott válaszokat. Belsőleg a metódusok meghívják a UserService osztály vonatkozó metódusait, és a kliens számára válasz jön létre, és átirányítja a /users URL-re. Például a doGet() metódusban megkapjuk az összes felhasználó listáját. Ezután létrehozunk egy RequestDispatcher objektumot, amely lehetővé teszi, hogy objektumokat vegyen fel egy HTTP-kérésbe, és átirányítsa azt egy adott erőforráshoz (például egy ügyfél JSP-oldalára). A doPut() metódusban (amely frissíti a felhasználói adatokat) feldolgozunk egy HTTP kérést, kibontjuk az azonosítót, nevet és életkor paramétereket, megkeressük a megadott azonosítóval rendelkező felhasználót, hozzárendeljük a kérésben szereplő nevet és életkort, majd visszaadjuk. a /users oldalra. De ahhoz, hogy ezek a módszerek megfelelően működjenek, be kell állítani a szervletet. Ehhez a WEB-INF mappában található web.xml fájlt használjuk.

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

A fájlban található összes címke meglehetősen intuitív, de nézzük meg őket sorban. <welcome-file-list> - Megjelenik a JSP kezdőlapja, amely először nyílik meg az alkalmazás indításakor. Esetünkben ez az index.jsp. <servlet> - UserSimpleServlet osztályunk servletként történő regisztrációja. <servlet-mapping> - nagyon fontos címke. Meghatározza a szervlet által feldolgozandó URL-címeket. A mi esetünkben ez mind URL-ek, ezért egyszerűen "/"-t jelölünk. De ha lenne egy alkalmazásunk, amely a felhasználókat és az autóikat (autokat) foglalja magában, akkor létrehozhatnánk egy második szervletet (SimpleAutoServlet). Ekkor a felhasználói szervlet leképezése "/users" (vagyis a felhasználókra vonatkozó kérések), az automatikus szervlet leképezése pedig "/autos". És végül a <szűrő>. Belsőleg az org egy példányát határozza meg. springframework.web.filter.HiddenHttpMethodFilter osztály. Ez a cikk nem a tavaszról szól, ezért nem írom le részletesen. Csak azt mondom, hogy csak kiegészítő funkcióként van rácsavarozva az alkalmazásunkra. A helyzet az, hogy JSP-oldalakat fogunk használni az ügyféloldal létrehozásához. Adataink az oldalon táblázatként jelennek meg a felhasználók listájával. A JSP-oldalakon belül <form/> HTML-címkék kerülnek felhasználásra. De csak a HTTP GET és POST kérések használhatók adatok küldésére egy <form/>-ból. Más szóval, mindhárom művelethez – frissítés, törlés és felhasználó létrehozása – csak POST kéréseket kellene használnunk. A PUT és DELETE kérések használata nem lenne lehetséges számunkra. Elvileg ez teljesen normális és könnyen megvalósítható, de a HiddenHttpMethodFilter osztály lehetővé teszi a használatát. Ily módon az olvasó tisztábban fogja látni a különbséget a műveletek között az alkalmazásban. Végül térjünk át az ügyféloldalra. Öt JSP-oldal képviseli. 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>

updateUser.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>

A JSP (JavaServer Page) oldal kétféle szöveget tartalmaz: statikus forrásadatokat, amelyek szövegként formázhatók (HTML, SVG, WML vagy XML), valamint JSP elemeket, amelyek dinamikus tartalom létrehozására szolgálnak. Hogy segítsek megérteni, mi az a JSP-oldal, kimásoltam egy részt egy nagyon jó cikkből. "Alapvetően, amikor először kérnek egy JSP-t, az servletté alakul, és servletként működik. Ezt nagyon fontos megérteni. A JSP-oldal NEM olyan, mint egy HTML-oldal – egy kezdő programozónak világosan meg kell értenie, hogy ez egy másik szervlet. — csak arról van szó, hogy nem kell beprogramozni, hogy hogyan jelenjen meg. Egyszerűen meg lehet rajzolni. És ha szükséges, adatokat adunk hozzá. De mivel egy JSP-oldal a HTML-re emlékeztet, a tervezőnek nyilvánvalóan könnyebb lesz. És még egyszer Kezdőknek ERŐSEN HANGSÚLYOZVA,a JSP oldal egy SERVLET. Előállításra kerül, beleértve az összes adat hozzáadását a szerveren. Ide kerül az összes adat. A böngészőben pedig a felhasználó megkapja a kész HTML oldalt, amelyen nincsenek Java jelek." Biztos lehet benne, hogy egy JSP-oldal valóban servlet, mert minden oldalnak van egy végrehajtandó metódusa. Például index A .jsp azt jelzi, hogy amikor rákattint az "Indítson munkát az adatbázissal" gombra, akkor a get metódus végrehajtásra kerül (method = "get"). Az addUser.jsp oldal, amely az új felhasználók létrehozásáért felelős, végrehajtja a post metódust (method = "post"), amikor rákattint a mentés gombra. A JSP oldal többi része normál statikus HTML jelölésekből áll, ezért nem foglalkozunk vele. Ez egy másik cikk témája, és rengeteg van róla témában az interneten. elkészítettük az alkalmazásunkat! Most működés közben kell tesztelnünk! Ehhez szükségünk van a fent említett Apache Tomcat szervlet konténerre. Letöltheti a tárolóta hivatalos webhelyről (én a 8-as verziót használom). Ezután létre kell hoznunk egy konfigurációt az IDEA-ban, hogy az alkalmazásunkat a Tomcaton keresztül futtassuk. Ehhez nyissa meg a "Konfigurációk szerkesztése" lapot, hozzon létre egy új konfigurációt, és válassza a "Tomcat Server Local" lehetőséget. Az „Alkalmazáskiszolgáló” lapon adja meg a Tomcat mappa elérési útját . Ezután lépjen a „Deployment” fülre. Itt konfiguráljuk az alkalmazásunk telepítését a helyi szerveren. Nyomja meg a "+" gombot, válassza az "Artifact" -> YourProjectName:war lehetőséget (az alkalmazást háborús fájlba építjük). És ez nagyjából összefoglalja! A "Szerver" oldalon láthatja, hogy alkalmazásunk a http://localhost:8080/ címen fog futni. Mentse el a konfigurációt, és adjon neki nevet (a konfigurációmat "Tommy"-nak hívom). Ezután az IDEA Maven lapján (jobb oldalon) a war plugint használjuk, hogy háborús fájlba építsük projektünket (Plugins -> war -> war: war). A felépítés befejezése után futtassa az alkalmazást, és várjon. Siker! Elindult a kezdőoldal. Most kattintsunk a "Munka megkezdése az adatbázissal" gombra. Az index.jsp fájlunk egy GET kérést generál, amelyet a szerver dolgoz fel. A szerver választ generál, és visszaküldi nekünk az összes létező felhasználó listája formájában (természetesen feltételezve, hogy vannak felhasználók az adatbázisban). És ott vannak! Hogy ott van! Az első alkalmazásodat Java szervletekkel írtad. Nem volt olyan rossz, igaz? :) Házi feladathoz visszaállíthattad az előző cikkből az autó funkcionalitását. Más szavakkal, hozzon létre egy külön szervletet és JSP-oldalakat az autókhoz, és tanítsa meg az alkalmazást, hogyan listázza ki a felhasználó autóit, hogyan adhat hozzá új autókat a felhasználóhoz, illetve hogyan szerkesztheti és törölheti azokat. A PS-szervletek és a JavaServer Pages meglehetősen ősi technológiák. Az interneten gyakran találhatunk olyan megjegyzéseket, mint "Kinek kell ez a régi szemét?" A válasz nagyon egyszerű: főleg olyan emberek, akik valós projekteken fognak dolgozni, ahol valószínűleg sok olyan kóddal találkozhatnak, amely ezeket a technológiákat használja. És még a működésének megértése nélkül is szórakoztató a "régi szemetet" feldarabolni valami újba :) A JSP és a servletek alaposabb tanulmányozásához lásd a " Head First Servlets and JSP" című könyvet.. Ugyanazok a szerzők írták, mint a híres "Head First Java" szuperkönyvet, amit sokan a minőség garanciájának fognak venni :) Remélem hasznos volt ez a cikk! Köszönöm a figyelmet, és sok sikert a tanuláshoz!