Ang iyong unang application gamit ang Java servlets

Kumusta, lahat! Magiging pamilyar ka sa mga servlet bilang pangunahing konsepto ng web development, at makakasulat ka ng isang simpleng application na gumagamit ng mga ito. Upang maiwasan ang mga hindi kinakailangang aksyon, hindi kami magsisimula sa simula. Patuloy kaming magtatrabaho sa aming aplikasyon mula sa aking nakaraang artikulo tungkol sa Hibernate . Ngunit dahil nagsisimula pa lang tayong maging pamilyar sa mga servlet, inalis ko ang lahat ng nauugnay sa klase ng Auto mula sa application at iniwan lamang ang klase ng User at mga aksyon na kinasasangkutan nito. Ang proyekto ay gagawing ganito: Kaya, mga servlet! Ang Wikipedia ay nagsasaad: "Ang Java servlet ay isang Java software component na nagpapalawak ng mga kakayahan ng isang server. Bagama't ang mga servlet ay maaaring tumugon sa maraming uri ng mga kahilingan, sila ay karaniwang nagpapatupad ng mga web container para sa pagho-host ng mga web application sa mga web server at sa gayon ay kwalipikado bilang isang server- side servlet web API." Ito ay eksaktong totoo. Dito, sa unang pagkakataon, makikita natin ang konsepto ng isang "arkitektura ng application ng client-server." Ito ay medyo simple sa core nito. Ina-access ng kliyente ang server sa pamamagitan ng pagpapadala ng kahilingan sa HTTP. Binubuo ng server ang kinakailangang data (halimbawa, kinukuha ito mula sa isang database) at ibinabalik ito sa kliyente. Ang pinakasimpleng halimbawa ay kapag na-click mo ang pindutan ng "Mga Kaibigan" sa isang partikular na social network, sa gayon nagpapadala ng isang kahilingan sa server. Ina-update 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, kaya kung hindi mo pa ito nakatagpo, mas mabuti para sa iyo na basahin ang tungkol sa mga ito sa ibang lugar, halimbawa,dito . Ang aming layunin ay: Gumawa ng CRUD application gamit ang mga servlet. Ang application ay dapat na makalikha, magbasa, mag-update, at magtanggal ng mga user mula sa database gamit ang isang servlet na nagpoproseso ng mga kahilingan sa HTTP. Magagawa na ito ng aming aplikasyon mula sa artikulong Hibernate, ngunit direktang kinokontrol ito mula sa Java code, mas tiyak, mula sa pangunahing() na pamamaraan. Sa pagkakataong ito, ang kliyente ang magpapadala ng mga kahilingan, ibig sabihin, ikaw :) Ang unang bagay na kailangan naming gawin ay magdagdag ng mga bagong dependency 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. Ang library ng tag ng JSTL. 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 pamamahala ng servlet ay pinangangasiwaan ng lalagyan ng servlet. Sa aming kaso, gagamitin namin ang Apache Tomcat. Ito ay medyo sikat — malamang na narinig mo na ang tungkol dito :) Ang servlet life cycle 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 makapaghatid ng mga kahilingan ang servlet. Sa buong ikot ng buhay, ang init() na pamamaraan ay tinatawag na isang beses lamang.
2. Ibigay ang 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 ipinapadala ito sa naaangkop na paraan para sa pagproseso. Ang servlet developer ay dapat magbigay ng mga pagpapatupad para sa mga pamamaraang ito. Kung may dumating na kahilingan para sa isang handler na hindi ipinatupad, ang pamamaraan ng parent na klase ay tinatawag at kadalasang nagtatapos sa pagbabalik ng error sa humiling.


3. Kung kailangang tanggalin ng lalagyan ang servlet, tinatawag nito ang destroy() na paraan, na nag-aalis ng servlet sa operasyon. Tulad ng init() na pamamaraan, ang pamamaraang ito ay tinatawag ding isang beses sa buong servlet cycle.

Ang aming servlet ay mukhang medyo simple:

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: doPost(), doGet(), doPut() at doDelete(). Hinahayaan nila kaming lumikha, magbasa, mag-update at magtanggal ng mga user. Ang mga pamamaraan ay tumatanggap ng mga instance ng javax.servlet.http.HttpServletRequest at javax.servlet.http.HttpServletResponse na mga klase bilang input, ibig sabihin, mga kahilingang ipinadala sa server at mga tugon na natanggap ng kliyente. Sa panloob, tinatawag ng mga pamamaraan ang mga nauugnay na pamamaraan ng klase ng UserService, at ang isang tugon para sa kliyente ay nabuo at na-redirect sa /users URL. Halimbawa, sa paraan ng doGet(), nakakakuha kami ng listahan ng lahat ng user. Susunod, gumawa kami ng object ng RequestDispatcher, na nagbibigay-daan sa amin na isama ang mga object sa isang kahilingan sa HTTP at i-redirect ito sa isang partikular na mapagkukunan (halimbawa, sa isang pahina ng JSP ng kliyente). Sa pamamaraang doPut() (na nag-a-update ng data ng user), pinoproseso namin ang isang kahilingan sa HTTP, i-extract ang id, pangalan, at mga parameter ng edad, hanapin ang user na may tinukoy na id, italaga dito ang pangalan at edad na nasa kahilingan, at ibinalik sa pahina ng /users. Ngunit para gumana nang tama ang lahat ng mga pamamaraang ito, kailangan nating i-configure ang servlet. Upang gawin ito, 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 medyo intuitive, ngunit suriin natin ang mga ito sa pagkakasunud-sunod. <welcome-file-list> - Ang panimulang pahina ng JSP ay ipinahiwatig, na unang bubuksan kapag nagsimula ang aplikasyon. Sa aming kaso, ito ay index.jsp. <servlet> - Pagpaparehistro ng aming UserSimpleServlet class bilang isang servlet. <servlet-mapping> - isang napakahalagang tag. Tinutukoy nito ang mga URL na ipoproseso ng servlet. Sa aming kaso, ito ay lahat ng mga URL, kaya ipinapahiwatig lang namin ang "/". Ngunit kung mayroon kaming application na kinasasangkutan ng mga user at kanilang mga sasakyan (autos), maaari kaming lumikha ng pangalawang servlet (SimpleAutoServlet). Kung gayon ang pagmamapa ng servlet ng user ay magiging "/users" (ibig sabihin, mga kahilingan tungkol sa mga user), at ang pagmamapa ng auto servlet ay magiging "/autos". At panghuli, <filter>. Sa panloob, tinutukoy nito ang isang instance ng org. springframework.web.filter.HiddenHttpMethodFilter class. Ang artikulong ito ay hindi tungkol sa Spring, kaya hindi ko ito ilalarawan nang detalyado. Sasabihin ko lang na ito ay naka-bolted sa aming application bilang isang karagdagang tampok. Ang bagay ay gagamitin namin ang mga pahina ng JSP upang likhain ang 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 <form/> HTML tags. Ngunit ang HTTP GET at POST na mga kahilingan lamang ang maaaring gamitin para sa pagpapadala ng data mula sa isang <form/>. Sa madaling salita, 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 isang opsyon para sa amin. Sa prinsipyo, ito ay medyo normal at madaling ipatupad, ngunit hinahayaan tayo ng klase ng HiddenHttpMethodFilter na gamitin ang mga ito. Sa ganitong paraan, mas malinaw na makikita ng mambabasa ang pagkakaiba sa pagitan ng mga operasyon sa application. Sa wakas, magpatuloy 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>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>

Ang pahina ng JSP (JavaServer Page) ay naglalaman ng dalawang uri ng text: static na source data na maaaring i-format bilang text (HTML, SVG, WML, o XML), at mga elemento ng JSP na ginagamit upang bumuo ng dynamic na content. Upang matulungan kang maunawaan kung ano ang JSP page, kinopya ko ang isang sipi mula sa isang napakagandang artikulo. "Sa pangkalahatan, sa unang pagkakataong hihilingin ang isang JSP, ito ay nagiging isang servlet at nagpapatakbo bilang isang servlet. Ito ay napakahalagang maunawaan. Ang isang pahina ng JSP ay HINDI tulad ng isang HTML na pahina — ang isang nagsisimulang programmer ay dapat na malinaw na maunawaan na ito ay isa pang servlet — kaya lang hindi mo kailangang magsulat na magprograma kung paano ito ipinapakita. Maari lamang itong iguhit. At magdagdag ng data kung kinakailangan. Ngunit dahil ang isang pahina ng JSP ay nakapagpapaalaala sa HTML, malinaw na mas madali itong mahahanap ng isang taga-disenyo. At muli LUBOS na bigyang-diin sa mga nagsisimula,ang JSP page ay isang SERVLET. Ito ay nabuo, kabilang ang pagdaragdag ng lahat ng data, sa server. Ito ay kung saan ang lahat ng data ay ipinasok. At sa browser, nakukuha ng user ang tapos na HTML page, na walang mga palatandaan ng Java." Makatitiyak ka na ang isang JSP page ay talagang isang servlet, dahil ang bawat page ay may pamamaraan na kailangang isagawa. Halimbawa, index Isinasaad ng .jsp na kapag nag-click ka sa button na "Start working with the database", ang get method ay isasagawa (method = "get"). Ang addUser.jsp page, na responsable sa paglikha ng mga bagong user, ay nagsasagawa ng post method (pamamaraan = "post") kapag na-click mo ang pindutan ng pag-save. Ang natitirang bahagi ng pahina ng JSP ay binubuo ng regular na static na HTML markup, kaya hindi na namin ito pag-uusapan. Iyan ay isang paksa para sa isa pang artikulo at marami tungkol dito paksa sa Internet. Kaya, kami' nilikha mo ang aming application! Ngayon ay kailangan nating subukan ito sa aksyon! Para magawa ito, kailangan namin ang Apache Tomcat servlet container na binanggit sa itaas. Maaari mong i-download ang lalagyanmula 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 "Lokal ng Tomcat Server". Sa tab na "Server ng Application", tukuyin ang landas sa folder ng Tomcat Susunod, pumunta sa tab na "Deployment". Dito, iko-configure namin ang deployment ng aming application sa lokal na server. Pindutin ang "+", piliin ang "Artifact" -> YourProjectName:war (buuin namin ang application sa isang war file). At iyan tungkol sa sums up! Sa pahina ng "Server", makikita mo na tatakbo ang aming application sa http://localhost:8080/. I-save ang configuration at bigyan ito ng isang pangalan (tinatawag ko ang aking config na "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). Matapos makumpleto ang pagbuo, patakbuhin ang application at maghintay. Tagumpay! Ang panimulang pahina ay inilunsad. Ngayon ay i-click namin ang "Start working with the database" button. Ang aming 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 (ipagpalagay na mayroong mga gumagamit sa database, siyempre). At nandiyan sila! Na mayroon ka nito! Isinulat mo ang iyong unang aplikasyon gamit ang mga Java servlet. Hindi naman masama iyon, di ba? :) Para sa takdang-aralin, maaari mong ibalik ang paggana ng kotse mula sa nakaraang artikulo. Sa madaling salita, lumikha ng isang hiwalay na pahina ng servlet at JSP para sa mga kotse, at turuan ang application kung paano ilista ang mga kotse ng isang user, magdagdag ng mga bagong kotse sa isang user, at i-edit at tanggalin ang mga ito. Ang PS Servlets at JavaServer Pages ay mga sinaunang teknolohiya. Sa Internet, madalas kang makakahanap ng mga komento tulad ng "Sino ang nangangailangan ng lumang basurang ito?" Ang sagot ay medyo simple: pangunahin ang mga taong gagana sa mga tunay na proyekto, kung saan maaari silang makatagpo ng maraming code na gumagamit ng mga teknolohiyang ito. At kahit na hindi nauunawaan kung paano ito gumagana, masaya pa rin na putulin ang "lumang basura" sa isang bagong bagay :) Para sa mas masusing pag-aaral ng JSP at mga servlet, maaari kang sumangguni sa aklat na "Head First Servlets and JSP ". Ito ay isinulat ng parehong mga may-akda bilang ang sikat na super libro na "Head First Java", na marami ang kukuha bilang garantiya ng kalidad :) Sana ay nakatulong ang artikulong ito! Salamat sa iyong pansin, at good luck sa pag-aaral!