Ang iyong unang application gamit ang Java servlets

Kamusta kayong lahat! Sa artikulong ito, magiging pamilyar ka sa pangunahing konsepto ng web development ng mga servlet at makakasulat ka ng isang simpleng application gamit ang mga ito. Upang maiwasan ang mga hindi kinakailangang hakbang, hindi kami magsisimula mula sa simula, at patuloy na gagana sa aming aplikasyon mula sa aking nakaraang artikulo tungkol sa Hibernate . Gayunpaman, dahil nagsisimula pa lang tayo sa mga servlet, inalis ko ang lahat na nauugnay sa klase ng Auto mula sa application at iniwan lamang ang klase ng User at ang mga aksyon nito. Ang istraktura ng proyekto ay magiging ganito: Kaya, servlets! Sabi ng Wikipedia: "Ang servlet ay isang Java interface na ang pagpapatupad ay nagpapalawak sa functionality ng server. Ang isang servlet ay nakikipag-ugnayan sa mga kliyente sa pamamagitan ng isang prinsipyo ng kahilingan-tugon." At totoo nga. Dito natin unang nakatagpo ang konsepto ng "arkitektura ng application ng client-server". Ang kakanyahan nito ay medyo simple at umaangkop sa isang larawan (kinuha mula dito ). Nakikipag-ugnayan ang kliyente sa server sa pamamagitan ng pagpapadala ng kahilingan sa HTTP. Ang server ay bumubuo ng kinakailangang data (halimbawa, natatanggap ito mula sa database) at ibinabalik ito sa kliyente. Ang pinakasimpleng halimbawa: sa isang tiyak na social network nag-click ka sa pindutan ng "Mga Kaibigan" at sa gayon ay magpadala ng isang kahilingan sa server. Sinusuri ng server ang listahan ng iyong mga kaibigan sa database at ibinabalik ito sa iyo (ang kliyente). Ang listahan ng mga kahilingan sa HTTP ay medyo malaki, ngunit kung hindi mo pa ito nakatagpo, kung gayon para sa isang mas mahusay na pag-unawa mas mahusay na basahin ang tungkol sa mga ito, halimbawa, dito . Ang aming gawain ay: Gumawa ng CRUD application gamit ang mga servlet. Ang application ay dapat na makalikha, magbago, at magtanggal ng mga user mula sa database gamit ang isang servlet na nagpoproseso ng mga kahilingan sa HTTP. Ang aming aplikasyon mula sa artikulo tungkol sa Hibernate ay alam na kung paano ito gawin, ngunit ito ay direktang kinokontrol mula sa Java code, mas tiyak, mula sa pangunahing() na pamamaraan. Dito ang mga kahilingan ay ipapadala ng kliyente, iyon ay, ikaw :) Ang unang bagay na kailangan naming gawin ay magdagdag ng mga bagong dependencies sa aming pom.xml file

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

Nagdagdag kami ng 3 dependencies:

1. Ang javax.servlet-api library mismo;
2. JSTL tag library. Kakailanganin upang lumikha ng panig ng kliyente, katulad ng mga pahina ng JSP;
3. Spring-WebMVC. Kakailanganin natin ang isang klase sa Spring, na pag-uusapan natin mamaya.

Ang pagpapatakbo ng mga servlet ay pinamamahalaan ng lalagyan ng servlet. Sa aming kaso gagamitin namin ang Apache Tomcat. Medyo sikat na bagay, at malamang narinig mo na ito :) Ang life cycle ng isang servlet ay binubuo ng mga sumusunod na hakbang:

1. Kung walang servlet sa lalagyan.
   
   • Ang servlet class ay ni-load ng container.
   • Ang lalagyan ay lumilikha ng isang halimbawa ng klase ng servlet.
   • Tinatawag ng container ang init() na pamamaraan. Sinisimulan ng pamamaraang ito ang servlet at tinawag muna bago ang servlet ay makapagbigay ng mga kahilingan sa serbisyo. Ang init() na pamamaraan ay tinatawag na isang beses lamang sa buong lifecycle nito.
2. Naghahatid ng kahilingan ng kliyente. Ang bawat kahilingan ay pinoproseso sa sarili nitong hiwalay na thread. Tinatawag ng container ang service() na pamamaraan para sa bawat kahilingan. Tinutukoy ng paraang ito ang uri ng papasok na kahilingan at ibinabahagi ito sa paraang naaayon sa ganitong uri para sa pagproseso ng kahilingan. Ang servlet developer ay dapat magbigay ng mga pagpapatupad para sa mga pamamaraang ito. Kung ang isang kahilingan ay natanggap kung saan ang isang pamamaraan ay hindi ipinatupad, ang pamamaraan ng parent na klase ay tinatawag at karaniwang nagtatapos sa isang error na ibinabalik sa humiling.
3. Kung sakaling kailangang tanggalin ng container ang isang servlet, tinatawag nito ang destroy() method, na nag-aalis ng servlet mula sa serbisyo. Tulad ng init() na pamamaraan, ang pamamaraang ito ay tinatawag ding isang beses sa buong servlet cycle.

Magmumukhang simple ang aming servlet:

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

Tulad ng nakikita mo, naglalaman ito ng init() na pamamaraan, na inilarawan sa itaas, at nagpapatupad ng 4 na pamamaraan na kasabay ng apat na kahilingan sa HTTP - doGet(), doPost(), doPut() at doDelete(). Ang bawat isa sa kanila ay magbibigay-daan sa amin, ayon sa pagkakabanggit, na tumanggap, lumikha, mag-edit at magtanggal ng mga user. Ang mga pamamaraan ay kinukuha bilang input object ng javax.servlet.http.HttpServletRequest at javax.servlet.http.HttpServletResponse na mga klase - iyon ay, ang kahilingang ipinadala sa server at ang tugon na natatanggap ng kliyente. Sa loob ng mga pamamaraan, ang mga kinakailangang pamamaraan ng klase ng UserService ay isinasagawa, isang tugon ay nabuo para sa kliyente, at pagkatapos ay na-redirect sa /users address. Halimbawa, sa paraan ng doGet() nakakakuha kami ng listahan ng lahat ng user. Susunod, gumawa kami ng object ng RequestDispatcher class, na nagbibigay-daan sa amin na isama ang mga object sa isang Http request, pati na rin i-redirect ito sa isang partikular na mapagkukunan (halimbawa, isang client JSP page). Sa paraan ng doPut() (pag-update ng data ng user), pinoproseso namin ang kahilingan sa HTTP, i-extract ang id, pangalan at mga parameter ng edad mula rito, hanapin ang user na may tinukoy na id, italaga sa kanya ang pangalan at edad na kasama niya sa kahilingan, at bumalik sa page /users. Gayunpaman, para gumana nang tama ang lahat ng mga pamamaraang ito, kailangan nating i-configure ang servlet. Para dito ginagamit namin ang web.xml file sa WEB-INF folder.

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

Ang lahat ng mga tag sa file na ito ay, sa prinsipyo, intuitive, ngunit suriin natin ang mga ito nang sunud-sunod. <welcome-file-list> - ang panimulang pahina ng JSP ay tinukoy, na unang bubuksan kapag inilunsad ang application. Sa aming kaso, ito ang pahina ng index.jsp. <servlet> - pagrerehistro ng aming klase ng UserSimpleServlet bilang isang servlet. Ang <servlet-mapping> ay isang napakahalagang tag. Tinutukoy nito ang mga URL na ipoproseso ng servlet. Sa aming kaso, ang lahat ng ito ay mga URL, kaya ipinapahiwatig lang namin ang "/". Ngunit, halimbawa, kung mayroon kaming application sa mga user at kanilang mga makina, maaari kaming lumikha ng pangalawang servlet - SimpleAutoServlet. Kung gayon ang pagmamapa para sa servlet ng user ay magiging "/users" (iyon ay, mga kahilingang nauugnay sa pagproseso ng mga user), at para sa auto servlet ito ay magiging "/autos". At panghuli, <filter>. Tinutukoy nito sa loob ang isang object ng class org.springframework.web.filter.HiddenHttpMethodFilter. Ang artikulo ay walang kinalaman sa Spring, kaya hindi ko ito pag-uusapan nang detalyado. Sabihin ko lang na ito ay naka-attach sa aming application lamang bilang isang karagdagang tampok. Ang punto ay gagamitin namin ang mga pahina ng JSP upang lumikha ng panig ng kliyente. Ang aming data ay ipapakita sa pahina bilang isang talahanayan na may listahan ng mga user. Sa loob ng mga pahina ng JSP, gagamitin ang mga HTML <form/> tag. At ang HTTP GET at POST na mga kahilingan lamang ang maaaring gamitin upang magpadala ng data mula sa <form/>. Iyon ay, para sa lahat ng tatlong operasyon - pag-update, pagtanggal at paglikha ng isang user - kailangan lang naming gumamit ng mga kahilingan sa POST. Ang paggamit ng mga kahilingan sa PUT at DELETE ay hindi magiging available sa amin. At, sa prinsipyo, ito ay medyo normal at madaling ipatupad, ngunit ang klase ng HiddenHttpMethodFilter ay nagpapahintulot sa amin na gamitin ang mga ito. Gagawin nitong mas malinaw sa mambabasa ang mga pagkakaiba sa pagitan ng mga pagpapatakbo sa application. Sa wakas, lumipat tayo sa panig ng kliyente. Ito ay kinakatawan ng limang pahina ng JSP. index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Здравствуйте!</title>
</head>
<body>
Если вы хотите начать работу с базой данных пользователей - <br>
нажмите кнопку ниже:

<form action = "users" method="get">
    <input type="submit" value="Начать работу с базой данных">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Добавить нового пользователя</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Возраст">
    <input type="submit" value="Сохранить">
</form>
</body>
</html>

deleteUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Удалить пользователя</title>
</head>
<body>

Вы действительно хотите удалить пользователя ${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="Удалить">
</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>Список пользователей</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Возраст</td>
        <td>Действия</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="Изменить" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Удалить" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Добавить нового пользователя">
</form>
</body>
</html>

updateUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Изменить данные пользователя</title>
</head>
<body>

Редактировать пользователя

<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="Обновить">
</form>

</body>
</html>

Ang isang JSP page (Java Server Page) ay naglalaman ng dalawang uri ng text: static source data, na maaaring nasa isa sa mga text format (HTML, SVG, WML, o XML), at JSP elements, na bumubuo ng dynamic na content. Upang maunawaan kung ano ang JSP, hahayaan ko ang aking sarili na kopyahin at i-paste ang isang piraso ng napakagandang artikulo ng isang may-akda ( mula rito ). "Mahalaga, ang JSP ay na-convert sa isang servlet sa unang pagkakataon na ito ay na-access at gumagana bilang isang servlet. Ito ay napakahalaga na maunawaan. Ang JSP ay HINDI isang pahina tulad ng isang HTML na pahina - mahalaga para sa isang baguhan na programmer na malinaw na maunawaan na ito ay isa pang servlet - hindi mo na kailangang i-program ang output nito. Maaari mo lamang itong iguhit. At palitan ang data sa mga tamang lugar. Ngunit dahil ang pahina ng JSP ay kahit papaano ay kahawig ng HTML, ito ay malinaw na magiging mas madali para sa taga-disenyo. At muli kong MAHIGPIT na sinasabi sa mga nagsisimula - Ang JSP ay isang SERVLET . Inihanda ito kasama ang lahat ng data sa server. Dito inilalagay ang lahat ng data. At ang gumagamit ay tumatanggap ng isang handa na HTML na pahina sa browser, na hindi may anumang mga palatandaan ng JAVA." Makikita mo sa iyong sarili na ang pahina ng JSP ay talagang isang servlet, dahil ang bawat pahina ay naglalaman ng isang paraan na kailangang isagawa. Halimbawa, ang panimulang pahina na index.jsp ay nagsasaad na kapag nag-click ka sa pindutang "Start working with the database", method="get" ay isasagawa. Sa pahina ng addUser.jsp, na responsable para sa paglikha ng isang bagong user, kapag nag-click ka sa pindutan ng pag-save, ang method="post" ay isasagawa. Ang natitirang bahagi ng JSP ay binubuo ng ordinaryong static na HTML markup, kaya't hindi namin tatalakayin ang mga ito nang detalyado - ito ang paksa ng isang hiwalay na artikulo, kung saan marami sa Internet. Kaya, nilikha namin ang aming application, ang natitira ay upang subukan ito sa aksyon! Para magawa ito, kakailanganin namin ang Apache Tomcat servlet container na binanggit sa itaas. Maaari mong i-download ang pusa mula sa opisyal na website (ginagamit ko ang bersyon 8). Susunod, kailangan naming gumawa ng configuration sa IDEA para patakbuhin ang aming application sa pamamagitan ng Tomcat. Upang gawin ito, buksan ang tab na "I-edit ang Mga Configuration," lumikha ng bagong configuration at piliin ang Tomcat Server Local. Sa tab na Application Server, tukuyin ang path sa folder kung saan matatagpuan ang Tomcat. Susunod, pumunta sa tab na Deployment. Dito namin i-configure ang deployment ng aming application sa isang lokal na server. I-click ang "+", piliin ang "Artifact" -> Pangalan ng Iyong Proyekto: digmaan (bubuuin namin ang application sa isang file ng digmaan). Ganyan talaga! Sa pahina ng "Server" makikita mo na ang parehong application ay tatakbo sa "http://localhost:8080/". I-save ang configuration na ito at pangalanan ito ng isang bagay (ang pangalan ko sa config ay "Tommy"). Susunod, sa Maven tab sa IDEA (sa kanang bahagi) gagamitin namin ang war plugin upang itayo ang aming proyekto sa isang war file (Plugins -> war -> war:war). Tagumpay! Ang panimulang pahina ay inilunsad. Ngayon mag-click sa pindutang "Magsimulang magtrabaho kasama ang database". Ang aming JSP page na index.jsp ay bubuo ng kahilingan sa GET na ipoproseso ng server. Ang server ay bubuo ng tugon at ibabalik ito sa amin sa anyo ng isang listahan ng lahat ng umiiral na mga gumagamit (kung, siyempre, sila ay nasa database). At narito sila! Subukan nating tanggalin ang isa sa mga user: Gumagana rin ito! Kaya isinulat namin ang aming unang aplikasyon gamit ang mga servlet. Tulad ng nakikita mo, ang lahat ay naging hindi napakahirap :) Bilang araling-bahay, maaari mong, halimbawa, ibalik ang pag-andar ng pagtatrabaho sa mga kotse mula sa nakaraang artikulo sa application. Yung. lumikha ng isang hiwalay na pahina ng servlet at jsp para sa mga kotse at turuan ang aming application na magpakita ng isang listahan ng mga kotse ng gumagamit, magdagdag ng mga bagong kotse sa kanya, pati na rin i-edit at tanggalin ang mga ito. Ang PS Servlets at JSP ay medyo sinaunang teknolohiya, at sa Internet madalas kang makakahanap ng mga komento sa diwa ng "sino ang nangangailangan ng basurang ito?" Ang sagot ay medyo simple - ito ay kinakailangan lalo na sa mga taong gagana sa mga tunay na proyekto, kung saan ito ay lubos na posible na magkakaroon ng maraming code na nakasulat gamit ang mga ito. At ang paglalagari ng "mga lumang bagay" sa isang bagong bagay, nang hindi nauunawaan kung paano ito gumagana, ay isang kasiyahan pa rin :) Para sa mas masusing pag-aaral ng paksa ng JSP at mga servlet, maaari mong gamitin ang aklat na " Head First Servlets and JSP" (sa Ingles lang). Ito ay isinulat ng parehong mga may-akda bilang ang sikat na super-libro na "Head First Java", na para sa marami ay maaaring maging garantiya ng kalidad :) Sana ay kapaki-pakinabang ang artikulong ito sa mga mambabasa! Kung gusto mong makakita ng mga bagong artikulo, huwag kalimutang suportahan ang may-akda sa kompetisyon sa pamamagitan ng "I-like" siya. O mas mabuti pa - "I like it very much" :) Salamat sa iyong pansin, at good luck sa iyong pag-aaral!