توهان جي پهرين ايپليڪيشن جاوا servlets استعمال ڪندي

سڀني کي سلام! توهان ويب ڊولپمينٽ جي بنيادي تصور جي طور تي servlets سان واقف ٿي ويندا، ۽ توهان هڪ سادي ايپليڪيشن لکڻ جي قابل هوندا جيڪا انهن کي استعمال ڪندي. غير ضروري ڪمن کان بچڻ لاءِ، اسين شروع کان شروع نه ڪنداسين. اسان Hibernate بابت منهنجي پوئين آرٽيڪل مان اسان جي ايپليڪيشن تي ڪم جاري رکنداسين . پر جيئن ته اسان صرف servlets سان واقف ٿيڻ شروع ڪري رهيا آهيون، مون ايپليڪيشن مان آٽو ڪلاس سان لاڳاپيل هر شيء کي هٽائي ڇڏيو آهي ۽ صرف يوزر ڪلاس ۽ ان ۾ شامل عملن کي ڇڏي ڏنو آهي. پروجيڪٽ هن طرح ترتيب ڏني ويندي: پوء، servlets! Wikipedia چوي ٿو: "A Java servlet هڪ جاوا سافٽ ويئر جزو آهي جيڪو سرور جي صلاحيتن کي وڌائيندو آهي. جيتوڻيڪ servlets ڪيترن ئي قسمن جي درخواستن جو جواب ڏئي سگھن ٿا، اهي عام طور تي ويب سرور تي ويب ايپليڪيشنن کي ميزباني ڪرڻ لاء ويب ڪنٽينرز کي لاڳو ڪندا آهن ۽ اهڙيء طرح هڪ سرور جي حيثيت سان قابليت حاصل ڪن ٿا. side servlet web API." هي بلڪل سچ آهي. هتي، پهريون ڀيرو، اسان "ڪلائنٽ-سرور ايپليڪيشن آرڪيٽيڪچر" جي تصور ۾ اچي رهيا آهيون. اهو ان جي بنياد تي بلڪل سادو آهي. ڪلائنٽ هڪ HTTP درخواست موڪلڻ سان سرور تائين رسائي ڪري ٿو. سرور ضروري ڊيٽا ٺاهي ٿو (مثال طور، ان کي ڊيٽابيس مان آڻيندو) ۽ ان کي ڪلائنٽ ڏانهن موٽائي ٿو. سڀ کان آسان مثال آھي جڏھن توھان ڪلڪ ڪريو "دوست" بٽڻ تي ھڪڙي خاص سماجي نيٽ ورڪ تي، اھڙيء طرح سرور ڏانھن ھڪڙي درخواست موڪلي. سرور ڊيٽابيس ۾ توهان جي دوستن جي لسٽ کي اپڊيٽ ڪري ٿو ۽ ان کي توهان ڏانهن واپس ڪري ٿو (ڪلائنٽ). HTTP درخواستن جي فهرست ڪافي وڏي آھي، تنھنڪري جيڪڏھن توھان انھن کي اڳي ڪڏھن به نه ڏٺو آھي، ته اھو بھتر ٿيندو توھان لاءِ انھن جي باري ۾ پڙھو ٻي جاءِ تي، مثال طور، ھتي . اسان جو مقصد آھي: ھڪ CRUD ايپليڪيشن ٺاھيو servlets استعمال ڪندي. ايپليڪيشن کي ڊيٽابيس مان صارفين کي ٺاهڻ، پڙهڻ، تازه ڪاري ڪرڻ ۽ حذف ڪرڻ جي قابل هجڻ گهرجي سرورٽ استعمال ڪندي جيڪو HTTP درخواستن تي عمل ڪري ٿو. اسان جي درخواست Hibernate آرٽيڪل کان اڳ ۾ ئي ڪري سگهي ٿي، پر اهو سڌو سنئون جاوا ڪوڊ مان ڪنٽرول ڪيو ويو، وڌيڪ واضح طور تي، مکيه () طريقي کان. هن ڀيري، اهو ڪلائنٽ آهي جيڪو درخواستون موڪليندو، يعني توهان :) پهرين شيء جيڪا اسان کي ڪرڻ جي ضرورت آهي اسان جي pom.xml فائل ۾ نئين انحصار شامل ڪرڻ آهي.

<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 انحصار شامل ڪيو:

1. javax.servlet-api لائبريري پاڻ
2. JSTL ٽيگ لائبريري. انهي کي ڪلائنٽ سائڊ ٺاهڻ جي ضرورت پوندي، يعني JSP صفحا
3. بهار-WebMVC. اسان کي هڪ بهار ڪلاس جي ضرورت پوندي، جنهن بابت اسين ٿوري دير بعد ڳالهائينداسين.

سروليٽ جو انتظام سروليٽ ڪنٽينر طرفان سنڀاليو ويندو آهي. اسان جي صورت ۾، اسان استعمال ڪنداسين Apache Tomcat. اهو تمام گهڻو مشهور آهي - توهان شايد اڳ ۾ ئي ان جي باري ۾ ٻڌو آهي :) servlet زندگي چڪر هيٺين مرحلن تي مشتمل آهي:

1. جيڪڏهن ڪنٽينر ۾ ڪو به سروليٽ نه آهي:
   
   • سروليٽ ڪلاس ڪنٽينر ذريعي لوڊ ڪيو ويندو آهي.
   • ڪنٽينر servlet ڪلاس جو هڪ مثال ٺاهي ٿو.
   • ڪنٽينر سڏي ٿو init() طريقو. اهو طريقو servlet کي شروع ڪري ٿو ۽ پهريون سڏيو ويندو آهي، ان کان اڳ جو سرورٽ درخواستن جي خدمت ڪري سگهي ٿو. سڄي زندگي جي چڪر ۾، init() طريقو صرف هڪ ڀيرو سڏيو ويندو آهي.
2. ڪسٽمر جي درخواست جي خدمت. هر درخواست تي عمل ڪيو ويندو آهي پنهنجي الڳ سلسلي تي. ڪنٽينر سڏي ٿو service() طريقو هر درخواست لاءِ. اهو طريقو ايندڙ درخواست جي قسم کي طئي ڪري ٿو ۽ ان کي پروسيسنگ لاء مناسب طريقي سان موڪلي ٿو. servlet ڊولپر کي لازمي طور تي انهن طريقن تي عمل درآمد ڪرڻ گهرجي. جيڪڏهن هڪ درخواست هڪ هينڊلر لاءِ اچي ٿي جنهن تي عمل نه ڪيو ويو آهي، والدين طبقي جو طريقو سڏيو ويندو آهي ۽ عام طور تي درخواست ڪندڙ کي غلطي موٽائيندي ختم ٿي ويندي آهي.


3. جيڪڏهن ڪنٽينر کي سرورٽ کي هٽائڻ جي ضرورت آهي، اهو سڏي ٿو تباهي () طريقو، جيڪو سرورٽ کي آپريشن مان ڪڍي ٿو. init() طريقي وانگر، هي طريقو پڻ سڏيو ويندو آهي هڪ ڀيرو سڄي servlet چڪر دوران.

اسان جو 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");
    }
}

جئين توهان ڏسي سگهو ٿا، ان ۾ شامل آهي init() طريقو، جيڪو مٿي بيان ڪيو ويو آهي، ۽ 4 طريقن کي لاڳو ڪري ٿو جيڪي چار HTTP درخواستن سان ٺهڪندڙ آهن: doPost()، doGet()، doPut() ۽ doDelete(). اهي اسان کي صارفين ٺاهڻ، پڙهڻ، تازه ڪاري ۽ حذف ڪرڻ جي اجازت ڏين ٿا. طريقا javax.servlet.http.HttpServletRequest ۽ javax.servlet.http.HttpServletResponse ڪلاس جا مثال ان پٽ طور قبول ڪن ٿا، يعني سرور ڏانهن موڪليل درخواستون ۽ ڪلائنٽ پاران مليل جواب. اندروني طور تي، طريقا استعمال ڪندڙ سروس ڪلاس جي لاڳاپيل طريقن کي سڏين ٿا، ۽ ڪلائنٽ لاء هڪ جواب پيدا ڪيو ويو آهي ۽ /users URL ڏانهن منتقل ڪيو ويو آهي. مثال طور، doGet() طريقي ۾، اسان سڀني صارفين جي فهرست حاصل ڪندا آهيون. اڳيون، اسان ھڪڙو RequestDispatcher اعتراض ٺاھيو آھي، جيڪو اسان کي ھڪڙي HTTP درخواست ۾ شيون شامل ڪرڻ جي اجازت ڏئي ٿو ۽ ان کي ھڪڙي خاص وسيلن ڏانھن (مثال طور، ھڪڙو کلائنٽ JSP صفحي ڏانھن) ڏانھن منتقل ڪرڻ جي اجازت ڏئي ٿو. doPut() طريقي ۾ (جيڪو صارف جي ڊيٽا کي تازه ڪاري ڪري ٿو)، اسان هڪ HTTP درخواست تي عمل ڪريون ٿا، id، نالو، ۽ عمر جي پيٽرولن کي ڪڍيو، مخصوص id سان استعمال ڪندڙ کي ڳولھيو، ان کي نالو ۽ عمر تفويض ڪريو جيڪو درخواست ۾ آھي، ۽ واپسي. /users صفحي ڏانهن. پر انهن سڀني طريقن لاءِ صحيح ڪم ڪرڻ لاءِ، اسان کي servlet ترتيب ڏيڻ جي ضرورت آهي. ائين ڪرڻ لاءِ، اسان WEB-INF فولڊر ۾ web.xml فائل استعمال ڪريون ٿا.

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

هن فائل ۾ سڀئي ٽيگ بلڪل غير معمولي آهن، پر اچو ته انهن جي ترتيب سان وڃو. <welcome-file-list> - JSP شروعاتي صفحو ظاهر ڪيو ويو آهي، جيڪو پهريون ڀيرو کوليو ويندو جڏهن ايپليڪيشن شروع ٿيندي. اسان جي حالت ۾، هي آهي index.jsp. <servlet> - اسان جي UserSimpleServlet ڪلاس جي رجسٽريشن بطور سروليٽ. <servlet-mapping> - هڪ تمام اهم ٽيگ. اهو بيان ڪري ٿو URLs جيڪي پروسيس ڪيا ويندا servlet. اسان جي حالت ۾، اهو سڀ URLs آهي، تنهنڪري اسان صرف "/" کي اشارو ڪندا آهيون. پر جيڪڏهن اسان وٽ هڪ ايپليڪيشن هجي جنهن ۾ صارفين ۽ انهن جون ڪارون (آٽوز) شامل هجن، ته پوءِ اسان هڪ ٻيو سروليٽ (SimpleAutoServlet) ٺاهي سگهون ٿا. پوءِ يوزر servlet جي ميپنگ ٿيندي "/users" (يعني صارفين جي باري ۾ درخواستون)، ۽ آٽو servlet جي ميپنگ "/autos" ٿيندي. ۽ آخرڪار، <فلٽر>. اندروني طور تي، اهو org.springframework.web.filter.HiddenHttpMethodFilter ڪلاس جو هڪ مثال بيان ڪري ٿو. هي مضمون بهار جي باري ۾ نه آهي، تنهنڪري مان ان کي تفصيل سان بيان نه ڪندس. مان صرف ايترو چوندس ته اهو اسان جي ايپليڪيشن تي صرف هڪ اضافي خصوصيت جي طور تي شامل ڪيو ويو آهي. شيء اها آهي ته اسان استعمال ڪرڻ وارا آهيون JSP صفحا ڪلائنٽ سائڊ ٺاهڻ لاءِ. اسان جي ڊيٽا صفحي تي ڏيکاري ويندي ٽيبل جي طور تي صارفين جي فهرست سان. JSP صفحن جي اندر، <form/> HTML ٽيگ استعمال ڪيا ويندا. پر صرف HTTP GET ۽ POST درخواستون استعمال ڪري سگھجن ٿيون ڊيٽا موڪلڻ لاءِ <form/>. ٻين لفظن ۾، سڀني ٽن عملن لاء - تازه ڪاري ڪرڻ، حذف ڪرڻ، ۽ صارف ٺاهڻ - اسان کي صرف پوسٽ درخواستون استعمال ڪرڻو پوندو. PUT ۽ DELETE درخواستن کي استعمال ڪرڻ اسان لاءِ اختيار نه هوندو. اصول ۾، اهو بلڪل عام ۽ لاڳو ڪرڻ آسان آهي، پر HiddenHttpMethodFilter ڪلاس اسان کي انهن کي استعمال ڪرڻ جي اجازت ڏئي ٿو. هن طريقي سان، پڙهندڙ وڌيڪ واضح طور تي ايپليڪيشن ۾ عملن جي وچ ۾ فرق ڏسي سگهندا. آخرڪار، اچو ته ڪلائنٽ طرف اڳتي وڌو. اهو پنج 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>

هڪ JSP (JavaServer صفحو) صفحو ٻن قسمن جي ٽيڪسٽ تي مشتمل آهي: جامد ماخذ ڊيٽا جيڪا فارميٽ ٿي سگهي ٿي ٽيڪسٽ (HTML، SVG، WML، يا XML)، ۽ JSP عناصر جيڪي متحرڪ مواد ٺاهڻ لاءِ استعمال ڪيا ويندا آهن. توھان کي سمجھڻ ۾ مدد ڪرڻ لاءِ ته JSP صفحو ڇا آھي، مون ھڪڙي سٺي مضمون مان ھڪڙو پاسو نقل ڪيو آھي. "بنيادي طور تي، پهريون ڀيرو هڪ JSP درخواست ڪئي وئي آهي، اهو هڪ servlet ۾ بدلجي ٿو ۽ هڪ servlet طور ڪم ڪري ٿو. اهو سمجهڻ تمام ضروري آهي. هڪ JSP صفحو هڪ HTML صفحي وانگر نه آهي - هڪ شروعاتي پروگرامر کي واضح طور تي سمجهڻ گهرجي ته هي هڪ ٻيو سرور آهي. - اهو صرف اهو آهي ته توهان کي پروگرام ڪرڻ جي ضرورت ناهي ته اهو ڪيئن ڏيکاريو ويو آهي. اهو آساني سان ٺاهي سگهجي ٿو. ۽ جتي ضروري هجي ڊيٽا شامل ڪريو. پر ڇاڪاڻ ته JSP صفحو HTML جي ياد ڏياريندو آهي، هڪ ڊزائنر کي اهو آسان بڻائي سگهندو. ۽ هڪ ڀيرو ٻيهر شروعات ڪندڙن لاءِ زور سان زور ڀريو، JSP صفحو ھڪ SERVLET آھي . اھو ٺاھيو ويو آھي، بشمول سمورو ڊيٽا شامل ڪرڻ، سرور تي. ھيءُ آھي جتي سمورو ڊيٽا داخل ڪيو ويندو آھي. ۽ برائوزر ۾، صارف کي مڪمل ٿيل HTML صفحو ملندو آھي، جنھن ۾ جاوا جا نشان نه آهن." توهان پڪ ڪري سگهو ٿا ته هڪ JSP صفحو واقعي هڪ سروليٽ آهي، ڇاڪاڻ ته هر صفحي ۾ هڪ طريقو آهي جنهن کي عمل ڪرڻ جي ضرورت آهي. مثال طور، index.jsp اهو ظاهر ڪري ٿو ته جڏهن توهان "ڊيٽابيس سان ڪم ڪرڻ شروع ڪريو" بٽڻ تي ڪلڪ ڪندا، حاصل ڪرڻ جو طريقو عمل ڪيو ويندو (طريقو = "حاصل"). addUser.jsp صفحو، جيڪو نون صارفين ٺاهڻ جو ذميوار آهي، پوسٽ جو طريقو (طريقو = "پوسٽ") تي ​​عمل ڪري ٿو جڏهن توهان محفوظ ڪريو بٽڻ تي ڪلڪ ڪريو. باقي JSP صفحو باقاعده جامد HTML مارڪ اپ مان ٺهيل آهي، تنهنڪري اسان ان تي نه رهنداسين. اهو هڪ ٻئي مضمون لاء هڪ موضوع آهي ۽ انٽرنيٽ تي هن موضوع تي ڪافي آهن. تنهن ڪري، اسان اسان جي ايپليڪيشن ٺاهي آهي! هاڻي اسان کي ان کي عمل ۾ جانچڻ جي ضرورت آهي! هن کي ڪرڻ لاء، اسان کي مٿي ذڪر ڪيل Apache Tomcat servlet ڪنٽينر جي ضرورت آهي. توھان ڪنٽينر کي سرڪاري ويب سائيٽ تان ڊائون لوڊ ڪري سگھو ٿا (مان ورجن 8 استعمال ڪريو). اڳيون، اسان کي Tomcat ذريعي اسان جي ايپليڪيشن کي هلائڻ لاء IDEA ۾ ترتيب ڏيڻ جي ضرورت آهي. هن کي ڪرڻ لاء، کوليو "ترتيبات ۾ تبديلي آڻيو" ٽئب، هڪ نئين ترتيب ٺاهي، ۽ "Tomcat Server Local" چونڊيو. "ايپليڪيشن سرور" ٽئب تي، Tomcat فولڊر ڏانهن رستو بيان ڪريو اڳيون، "تعميرات" ٽئب ڏانھن وڃو. هتي، اسان مقامي سرور تي اسان جي ايپليڪيشن جي ترتيب کي ترتيب ڏيو. "+" کي دٻايو، "آرٽيفڪٽ" چونڊيو -> YourProjectName: war (اسان ايپليڪيشن کي جنگ واري فائل ۾ ٺاهينداسين). ۽ ان جي باري ۾ sums up! "سرور" صفحي تي، توھان ڏسي سگھو ٿا ته اسان جي ايپليڪيشن ھلندي http://localhost:8080/. ترتيب محفوظ ڪريو ۽ ان کي نالو ڏيو (مان پنھنجي ترتيب کي "ٽامي" سڏيان ٿو). اڳيون، IDEA ۾ Maven ٽئب تي (ساڄي پاسي)، اسان جنگ واري پلگ ان کي استعمال ڪنداسين اسان جي منصوبي کي جنگ جي فائل ۾ تعمير ڪرڻ لاء (پلگ ان -> جنگ -> جنگ: جنگ). تعمير مڪمل ٿيڻ کان پوء، ايپليڪيشن کي هلائي ۽ انتظار ڪريو. ڪاميابي! شروعاتي صفحو شروع ڪيو ويو. ھاڻي اسان ڪلڪ ڪيو "ڊيٽابيس سان ڪم ڪرڻ شروع ڪريو" بٽڻ. اسان جي index.jsp هڪ GET درخواست ٺاهي ويندي جيڪا سرور طرفان پروسيس ڪئي ويندي. سرور هڪ جواب پيدا ڪندو ۽ ان کي اسان کي سڀني موجوده استعمال ڪندڙن جي فهرست جي صورت ۾ واپس ڪندو (فرض ڪيو ته ڊيٽابيس ۾ صارف موجود آهن، يقينا). ۽ اتي اهي آهن! ته اتي توهان وٽ آهي! توھان پنھنجي پھرين ايپليڪيشن Java servlets استعمال ڪندي لکي. اهو ايترو خراب نه هو، ڇا اهو هو؟ :) گهر جي ڪم لاءِ، توهان اڳئين مضمون مان ڪار جي ڪارڪردگي بحال ڪري سگهو ٿا . ٻين لفظن ۾، ڪارن لاءِ الڳ servlet ۽ JSP صفحا ٺاھيو، ۽ ايپليڪيشن کي سيکاريو ته ڪيئن صارف جي ڪارن کي لسٽ ڪجي، نئين ڪارن کي استعمال ڪندڙ ۾ شامل ڪجي، ۽ انھن کي ايڊٽ ڪري ختم ڪجي. PS Servlets ۽ JavaServer صفحا بلڪه قديم ٽيڪنالاجيون آهن. انٽرنيٽ تي، توهان اڪثر تبصرا ڳولي سگهو ٿا جهڙوڪ "ڪنهن کي هن پراڻي ردي جي ضرورت آهي؟" جواب بلڪل سادو آهي: خاص طور تي اهي ماڻهو جيڪي حقيقي منصوبن تي ڪم ڪندا، جتي انهن کي شايد ممڪن طور تي تمام گهڻو ڪوڊ ملي سگهي ٿو جيڪي اهي ٽيڪنالاجيون استعمال ڪندا آهن. ۽ جيتوڻيڪ اهو سمجھڻ کان سواءِ ته اهو ڪيئن ڪم ڪري ٿو، اهو اڃا به مزو آهي ته ”پراڻي ردي“ کي نئين شيءِ ۾ ڪٽيو :) JSP ۽ servlets جي وڌيڪ تفصيلي مطالعي لاءِ، توهان ڪتاب ڏانهن رجوع ڪري سگهو ٿا ” هيڊ فرسٽ سروليٽس ۽ جي ايس پي“ . اهو انهن ئي ليکڪن طرفان مشهور سپر ڪتاب ”هيڊ فرسٽ جاوا“ لکيو ويو هو، جنهن کي ڪيترائي معيار جي ضمانت طور وٺندا :) مون کي اميد آهي ته هي مضمون مددگار ثابت ٿيو آهي! توهان جي توجه جي مهرباني، ۽ سکڻ ۾ سٺي قسمت!