JavaRush /Java Blog /Random-TL /Paglikha ng isang simpleng web application gamit ang mga ...

Antas

Киев

28 February 2021
42 views
0 comments

Paglikha ng isang simpleng web application gamit ang mga servlet at jsp (bahagi 1)

Antas ng kaalaman na kinakailangan upang maunawaan ang artikulo: higit pa o hindi gaanong naunawaan mo na ang Java Core at gusto mong tingnan ang mga teknolohiya ng JavaEE at web programming. Ito ang pinakamahalaga kung kasalukuyan mong pinag-aaralan ang Java Collections quest, na sumasaklaw sa mga paksang malapit sa artikulo. Paglikha ng isang simpleng web application gamit ang mga servlet at jsp (bahagi 1) - 1

Ang materyal na ito ay isang lohikal na pagpapatuloy ng aking artikulo Paglikha ng isang simpleng proyekto sa web sa IntelliJ Idea Enterprise . Sa loob nito ipinakita ko kung paano lumikha ng isang gumaganang template ng proyekto sa web. Sa pagkakataong ito ipapakita ko sa iyo kung paano gumawa ng simple ngunit magandang web application gamit ang Java Servlet API at JavaServer Pages API na mga teknolohiya. Ang aming aplikasyon ay magkakaroon ng home page na may dalawang link:

sa pahina ng pagdaragdag ng user;
sa page ng view ng listahan ng user.

Gagamitin ko pa rin ang IntelliJ Idea Enterprise Edition, Apache Maven (magsama lang ng ilang dependencies), at Apache Tomcat. Sa dulo, "palamutihan" namin ang aming application gamit ang W3.CSS framework . Ipagpalagay namin na sa sandaling mayroon ka nang walang laman na proyekto, na bubuuin namin dito. Kung hindi, basahin ang unang artikulo at gawin ito. Tatagal lang ng ilang minuto :)

Kaunti tungkol sa istraktura ng hinaharap na aplikasyon

Ang aming pangunahing pahina ( / ) ay ang pinakakaraniwang static na html na pahina na may header at dalawang link/button:

magdagdag ng bagong user (ipapadala sa /add );
tingnan ang listahan ng mga user (ipinapadala sa /list ).

Ang Tomcat ay kukuha ng mga kahilingan sa mga address na ito at ipapadala ang mga ito sa isa sa dalawang servlet na gagawin namin (isalarawan namin ang pagmamapa sa web.xml file ). At ang mga servlet, sa turn, ay magpoproseso ng mga kahilingan, maghahanda ng data (o i-save ito kung may idinagdag na user), at maglilipat ng kontrol sa kaukulang mga jsp file, na "magbibigay" ng resulta. Iimbak namin ang data sa pinakakaraniwang listahan (Listahan).

Gumawa tayo ng static na home page

Kung mayroon kang index.jsp sa iyong web folder , tanggalin ito. Sa halip, sa folder na ito gagawa kami ng isang simpleng html file na tinatawag na index.html :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My super project!</title>
</head>
<body>
    <!-- header -->
    <div>
        <h1>Super app!<//h1>
    </div>

    <div>       <!-- content -->
        <div>    <!-- buttons holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>

Walang kumplikado dito. Sa pamagat ipinapahiwatig namin ang pamagat ng aming pahina. Sa katawan ng page mayroon kaming dalawang pangunahing div: header (header) at content (content). Sa nilalaman mayroon kaming isang may hawak para sa aming mga pindutan, at aktwal na dalawang mga pindutan na, kapag na-click, ay ipinapadala sa naaangkop na mga address. Maaari mong patakbuhin ang proyekto at makita kung ano ang hitsura nito ngayon. Kung magki-click ka sa mga button, magbubukas ang mga page na may 404 error dahil wala pa kaming mga ito. Ngunit ito ay nagpapahiwatig na ang mga pindutan ay gumagana. Hayaan akong tandaan na hindi ito ang pinaka-unibersal na opsyon, dahil kung bigla mong na-disable ang JavaScript, ang mga button na ito ay walang silbi sa browser. Ngunit ipagpalagay namin na walang nag-disable ng JavaScript :). Malinaw na maaaring gamitin ang mga simpleng link, ngunit mas gusto ko ang mga pindutan. Ginagawa mo kung ano ang gusto mo. At huwag tingnan ang katotohanan na sa aking mga halimbawa ay magkakaroon ng maraming mga div . Pagkatapos ay pupunuin namin ang mga ito ng mga estilo, at ang lahat ay magiging mas maganda :).

Lumikha ng mga jsp file upang i-render ang resulta

Sa parehong web directory , gagawa kami ng folder kung saan ilalagay namin ang aming mga jsp file . Tinawag ko itong mga view, at muli, maaari kang mag-improvise. Sa folder na ito gagawa kami ng dalawang jsp file:

add.jsp — pahina para sa pagdaragdag ng mga user;
list.jsp - pahina para sa pagpapakita ng listahan ng mga user.

Bigyan natin sila ng naaangkop na mga heading ng pahina. Isang bagay tulad ng "Magdagdag ng bagong user" at "Listahan ng mga user", at hahayaan muna namin ito sa ngayon.

Gumawa tayo ng dalawang servlet

Tatanggapin at ipoproseso ng mga Servlet ang mga kahilingan na ipapasa sa kanila ng Tomcat. Sa src/main/java na folder gagawa kami ng app package , na maglalaman ng aming mga source. Doon ay magkakaroon tayo ng iba't ibang mga pakete. Samakatuwid, upang ang mga paketeng ito ay hindi nilikha sa loob ng bawat isa, gumawa tayo ng ilang klase sa pakete ng app (pagkatapos ay tanggalin ito). Ngayon gumawa tayo ng tatlong magkakaibang package sa app package:

entity - ito ay kung saan ang aming mga entidad ay magsisinungaling (ang klase mismo, na maglalarawan sa mga bagay ng gumagamit);
modelo - ang aming modelo ay narito (higit pa tungkol dito sa ibang pagkakataon);
servlets - mabuti, narito ang aming mga servlet.

Pagkatapos nito, maaari mong ligtas na alisin ang klase na iyon mula sa package ng app (kung ginawa mo ito, siyempre). Gumawa tayo ng dalawang klase sa servlets package:

AddServlet - magpoproseso ng mga kahilingang natanggap sa /add ;
ListServlet - magpoproseso ng mga kahilingang natanggap sa /list .

Pagkonekta ng mga dependency sa Maven

Tomcat bersyon 9.* nagpapatupad ng Servlet bersyon 4.0 at JavaServer Pages bersyon 2.3 mga detalye. Ito ay nakasulat sa opisyal na dokumentasyon ng Tomcat 9 sa unang talata sa pangalawang linya. Nangangahulugan ito na kung ikaw, tulad ko, ay gumagamit ng bersyong ito ng Tomcat, kung gayon ang code na isinusulat at ipinapadala namin para tumakbo ay gagamit nang eksakto sa mga tinukoy na bersyon. Ngunit nais naming magkaroon ng mga pagtutukoy na ito sa aming proyekto, upang ang aming code na gumagamit ng mga ito ay matagumpay na mag-compile. At para dito kailangan naming i-load ang mga ito sa aming proyekto. Dito sumagip si Maven.

Ang pangkalahatang tuntunin ay ito: kung kailangan mong ikonekta ang isang bagay sa iyong proyekto gamit ang Maven:

pumunta sa website ng repositoryo ng Maven;
hanapin doon ang library na kailangan mo at ang bersyon na kailangan mo;
makukuha mo ang dependency code na kailangang ipasok sa iyong pom.xml;
ipasok! :)

Kaya simulan na natin. Una, maghanda tayo ng pom file . Sa isang lugar pagkatapos ng /version ngunit bago /project , ipasok ang sumusunod:

<dependencies>

</dependencies>

Kaya, ipinahiwatig namin na sa loob ng mga tag na ito ay ililista namin ang mga dependency na kailangan namin. Ngayon pumunta sa mvnrepository.com , magkakaroon ng field ng paghahanap sa itaas. Una, ipasok ang servlet sa paghahanap. Ang unang resulta, kung saan mayroong higit sa pitong libong gamit, ay nababagay sa amin. Naaalala namin na kailangan namin ng bersyon 4.0 (para sa Tomcat 9; para sa iba pang mga bersyon, ang mga mas lumang pagpapatupad ay maaaring angkop). Ito ay isang medyo kamakailang bersyon, kaya walang maraming gamit, ngunit ito ang kailangan namin. Magbubukas ang isang pahina kung saan makukuha mo ang code para sa dependency na ito para sa iba't ibang mga manager ng package at maaari mo lang itong i-download. Ngunit dahil gusto naming ikonekta ito gamit ang Maven, pipiliin namin ang code sa tab na Maven. Kinopya at i-paste namin sa aming pom file sa loob ng seksyong dependencies. Kung may lalabas na notification sa kanang sulok sa ibaba ng IDEA na nagtatanong kung gusto naming i-enable ang auto-import, sumasang-ayon kami. Kung hindi mo sinasadyang tumanggi, pumunta sa "Mga Setting" at manual na paganahin ang auto-import: Mga Setting (Ctrl + Alt + S) -> Build, Execution, Deployment -> Maven -> Importing Papanatilihin nito ang pom file at mga configuration file ng IDEA para dito proyekto sa sync. Ngayon, gamit ang parehong prinsipyo, hahanapin at ikonekta natin ang bersyon 2.3 ng JavaServer Pages (ipasok ang jsp sa paghahanap). At dahil kinuha na natin ang Maven, sabihin natin kaagad na sumusunod ang ating mga source sa Java 8 syntax, at kailangan nilang i-compile sa bytecode ng parehong bersyon. Pagkatapos ng lahat ng manipulasyong ito, magiging ganito ang hitsura ng aming 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>ru.javarush.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compile.source>
        <maven.compiler.target>1.8</maven.compile.target>
    </properties>

    <dependencies>
        <!-- Servlet API 4.0 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- JavaServer Pages API 2.3 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

Ang paggawa ng aming mga servlet ay mga tunay na servlet

Sa puntong ito, ang pares ng mga servlet na ginawa namin ay talagang mga regular na klase lamang. Wala silang anumang functionality. Ngunit ngayon ay naikonekta na namin ang Servlet API sa aming proyekto, at, kung gayon, maaari kaming gumamit ng mga klase mula doon. Upang gawing "totoo" na mga servlet ang aming mga servlet, kailangan lang naming mamana ang mga ito mula sa klase ng HttpServlet .

Pagmamapa o paghahati

Ngayon ay maganda na kahit papaano sabihin sa Tomcat upang ang mga kahilingan mula sa /add ay mapangasiwaan ng aming AddServlet servlet , at samakatuwid ang mga kahilingan mula sa /list ay pinangangasiwaan ng ListServlet servlet . Ang prosesong ito ay tinatawag na pagmamapa . Ginagawa ito sa web.xml file ayon sa prinsipyong ito:

una naming inilalarawan ang servlet (nagbibigay kami ng ilang pangalan at ipinapahiwatig ang landas sa klase mismo);
pagkatapos ay ibibigkis namin ang servlet na ito sa isang tiyak na address (ipinapahiwatig namin ang pangalan ng servlet na kakabigay lang namin at ipahiwatig ang address kung saan dapat ipadala ang mga kahilingan sa servlet na ito).

Ilarawan natin ang servlet:

<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>

Ngayon itali namin ito sa address:

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

Tulad ng nakikita mo, ang servlet-name ay pareho sa parehong mga kaso. Dahil dito, alam ng Tomcat na kung dumating ang isang kahilingan sa /add address , kailangan itong maipasa sa app.servlets.AddServlet servlet . Ginagawa namin ang parehong sa pangalawang servlet. Bilang resulta, ang aming web.xml ay may tinatayang sumusunod na nilalaman:

<?xml version="1.0" encoding="UTF-8"?>
<web-app 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"
         version="3.1">

    <!-- add servlet -->
    <servlet>
        <servlet-name>add</servlet-name>
        <servlet-class>app.servlets.AddServlet</servlet-class>
    </servlet>

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

    <!-- list servlet -->
    <servlet>
        <servlet-name>list</servlet-name>
        <servlet-class>app.servlets.ListServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>list</servlet-name>
        <url-pattern>/list</url-pattern>
    </servlet-mapping>
</web-app>

Sa pamamagitan ng paraan, hindi kami gumawa ng markup para sa pangunahing pahina dito (sa / ). Ang katotohanan ay sa kasong ito hindi natin ito kailangan. Ang aming home page ay isang simpleng html file na nagpapakita lamang ng dalawang pindutan. Walang dynamic na nilalaman, kaya walang saysay para sa amin na lumikha ng isang hiwalay na servlet para dito, kung saan ang mga kahilingan mula sa address / ay ipapadala , at kung saan ay walang gagawin maliban sa paglipat ng pagpapatupad sa ilang jsp (na kailangan ding maging nilikha), na iguguhit Kung mayroon lamang tayong dalawang pindutan. Hindi namin ito kailangan; masaya kami sa isang static na mapagkukunan. Kapag nakatanggap ang Tomcat ng isang kahilingan, susuriin nito na walang isang solong servlet na maaaring magproseso ng kahilingan sa naturang address, at pagkatapos ay makikita nito na sa address na ito ay mayroon talagang isang handa na html file , na matagumpay nitong ipapadala . Maaari naming patakbuhin muli ang aming application (i-restart ang server o muling i-deploy, ayon sa gusto mo) at siguraduhin na ang pangunahing pahina ay nai-render, walang nasira, kapag nag-click kami sa mga pindutan, nangyayari ang mga transition, ngunit sa ngayon ay mayroon ding error. nakasulat. Sa pamamagitan ng paraan, kung dati ay nagkaroon kami ng 404 error, ngayon ay mayroon na kaming 405. Ibig sabihin, gumana ang pagmamapa, natagpuan ang mga servlet, ngunit wala silang anumang angkop na paraan upang iproseso ang kahilingan. Kung sa yugtong ito ay nakakakuha ka pa rin ng 404 na error, bagama't ang lahat ay nagawa nang tama, marahil ay dapat mong iwasto ang configuration ng deployment sa ideya. Upang gawin ito, kailangan mong pumunta sa I-edit ang mga pagsasaayos (sa tuktok malapit sa pindutan ng pagsisimula), pumunta sa tab na Deployment sa kanang bahagi ng window at siguraduhin na sa konteksto ng Application ito ay ipinahiwatig lamang /

Isang maikling lyrical digression: ano ang nangyayari "sa ilalim ng talukbong"?

Marahil ay naisip mo na kung paano gumagana ang aming application sa Tomcat? Anong nangyayari diyan? At nasaan ang pangunahing() na pamamaraan ? Sa sandaling i-type mo ang localhost:8080 sa iyong browser at pumunta sa address na ito, magpapadala ang browser ng kahilingan sa address na ito sa pamamagitan ng http protocol . Sana ay alam mo na na ang mga kahilingan ay maaaring may iba't ibang "uri", ang pinakasikat ay GET at POST . Bawat kahilingan ay dapat may kasagutan. Inaasahan ng kahilingan ng GET na bilang tugon ay bibigyan ito ng isang yari na html code , na ibabalik sa browser, at magandang papalitan ng browser ang code na ito ng lahat ng uri ng mga titik, button, at form. Ang kahilingan ng POST ay medyo mas kawili-wili, dahil nagdadala din ito ng ilang impormasyon kasama nito. Halimbawa, sa form ng pagpaparehistro o awtorisasyon ng user, inilagay mo ang iyong data at na-click ang “ipadala”. Sa sandaling ito, isang POST na kahilingan ang ipinadala sa server kasama ang iyong personal na impormasyon sa loob. Tinanggap ng server ang impormasyong ito, pinroseso ito at ibinalik ang ilang uri ng tugon (halimbawa, isang html na pahina kasama ang iyong profile). Ang pangunahing pagkakaiba sa pagitan ng mga ito ay ang mga kahilingan sa GET ay inilaan lamang upang makatanggap ng data mula sa server, habang ang mga kahilingan sa POST ay may dalang ilang impormasyon sa kanila, at ang data sa server ay maaaring magbago (halimbawa, kapag nag-upload ka ng iyong larawan sa server, ito lilipad sa kahilingan ng POST at idaragdag ito ng server sa database, ibig sabihin, may magaganap na pagbabago. Ngayon, bumalik tayo sa Tomcat. Kapag nakatanggap ito ng ilang kahilingan mula sa kliyente, tinitingnan nito ang address. Hinahanap ang data nito sa tingnan kung mayroong angkop na servlet, na magpoproseso ng mga kahilingan sa ganoong address (o isang handa na mapagkukunan na maibabalik kaagad). na may tugon na 404. Kung nakahanap ito ng angkop na servlet, na "nakaupo" sa address na ito, tinitingnan nito kung anong uri ng kahilingan ang natanggap nito (GET, POST, o iba pa), at pagkatapos ay tatanungin ang servlet kung mayroon itong paraan na Maaaring pangasiwaan ang ganitong uri ng kahilingan. Kung sinabi ng servlet, na hindi nito maproseso ang ganitong uri, tutugon ang Tomcat sa kliyente gamit ang code 405. Ito ang nangyari sa amin. Ngunit kung ang isang angkop na servlet ay natagpuan, at ito ay may angkop na pamamaraan, ang Tomcat ay lumilikha ng isang bagay ng servlet na ito, pinapatakbo ito sa isang bagong thread ( thread ), na nagpapahintulot sa servlet na gumana sa isang hiwalay na thread, at ang Tomcat ay patuloy na gumana nang higit pa sa sarili nitong pagtanggap at pagpapadala ng mga kahilingan. Bilang karagdagan, ang Tomcat ay lumilikha ng dalawa pang bagay: ang isa sa uri ng HttpServletRequest (sa madaling sabi ay tatawagin ko itong isang kahilingan sa hinaharap), at ang pangalawa sa uri ng HttpServletResponse(Tatawagin ko itong sagot). Sa unang bagay ay inilalagay nito ang lahat ng data na natanggap nito sa isang kahilingan mula sa kliyente, upang ang lahat ng data na iyon ay maaaring makuha mula sa bagay na ito. Buweno, pagkatapos ng lahat ng ito, ipinapasa nito ang dalawang bagay na ito sa naaangkop na paraan ng servlet na tumatakbo sa isang hiwalay na thread. Sa sandaling matapos ng servlet ang trabaho nito at may handa nang ipadalang tugon sa kliyente, magtataas ito ng bandila sa Tomcat, na nagsasabing, "Tapos na ako, handa na ang lahat." Tinatanggap ng Tomcat ang tugon at ipinadala ito sa kliyente. Ito ay nagpapahintulot sa Tomcat na tumanggap ng mga kahilingan at magpadala ng mga tugon nang walang pagkaantala, habang ang lahat ng gawain ay ginagawa ng mga servlet na tumatakbo sa magkahiwalay na mga thread. Alinsunod dito, kapag nagsusulat kami ng servlet code, tinutukoy namin ang gawaing isasagawa. At oo, maaari mong isipin na ang pangunahing() na pamamaraan ay nasa Tomcat mismo (oo, ito ay nakasulat sa Java), at kapag tayo ay "nagsisimula" ng Tomcat, ang main().

Nahuli namin ang mga pamamaraan ng GET na may mga servlet at nagpapadala ng mga simpleng tugon

Sa ngayon, ang aming mga servlet ay walang angkop na pamamaraan (GET), kaya ibinalik sa amin ng Tomcat ang isang 405 error. Gawin natin ang mga ito! Ang HttpServlet class , kung saan namin minana ang aming mga servlet, ay tumutukoy sa iba't ibang pamamaraan. Upang magtakda ng ilang code para sa mga pamamaraan, i-override lang namin ang mga ito. Sa kasong ito, kailangan nating i-override ang doGet() na pamamaraan sa parehong mga servlet.

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

}

Tulad ng nakikita mo, ang pamamaraang ito ay tumatanggap ng dalawang bagay: req (kahilingan) at resp (tugon). Ito ang mismong mga bagay na gagawin at i-populate ng Tomcat para sa amin kapag tinawag nito ang naaangkop na pamamaraan sa servlet na ito. Una, gawin natin ang pinakasimpleng mga sagot. Upang gawin ito, kunin ang resp object at kumuha mula dito ng isang PrintWriter object , na maaaring magamit upang bumuo ng mga tugon. Well, gamit ito ay magpi-print kami ng ilang simpleng string.

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("Method GET from AddServlet");
}

Gagawin namin ang isang bagay na katulad sa ListServlet servlet , pagkatapos nito ay sisimulan naming muli ang aming server. Tulad ng nakikita mo, gumagana ang lahat! Kapag nag-click ka sa mga button, magbubukas ang mga pahina gamit ang text na "naitala" namin sa PrintWriter . Ang aming jsp na inihanda namin para sa pagbuo ng mga pahina na may mga sagot ay hindi ginagamit sa anumang paraan. Ito ay dahil ang pagpapatupad ay hindi umabot sa kanila. Ang serverlet mismo ay bumubuo na ngayon ng tugon at tinatapos ang trabaho nito, na nagsenyas kay Tomcat na mayroon itong tugon na handa para sa kliyente. Kinukuha lang ng Tomcat ang tugon na ito at ibinabalik ito sa kliyente. Inilipat namin ang kontrol mula sa mga servlet patungo sa jsp. Baguhin natin ang code ng aming mga pamamaraan sa ganitong paraan:

nakakakuha kami mula sa object ng kahilingan ng object ng request manager, kung saan ipinapasa namin ang jsp address ng page kung saan gusto naming ilipat ang kontrol;
gamit ang natanggap na bagay, inililipat namin ang kontrol sa tinukoy na pahina ng jsp , at huwag kalimutang ilakip doon ang kahilingan at tugon na mga bagay na natanggap namin mula sa Tomcat.

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}

Sa katawan ng jsp pages (sa loob ng body tag) maaari tayong sumulat ng isang bagay upang malinaw nating makita kung aling pahina ang ipinapakita. Pagkatapos nito, i-restart namin ang server at suriin. Ang mga pindutan sa pangunahing pahina ay pinindot, ang mga pahina ay binuksan, na nangangahulugang ang mga kahilingan ay ipinadala sa mga servlet, pagkatapos kung saan ang kontrol ay inilipat sa mga pahina ng jsp, na nai-render na. Iyon lang. Sa susunod na bahagi ng artikulo ay haharapin namin ang pag-andar ng aming aplikasyon.

Ano pa ang dapat basahin:

Paglikha ng isang simpleng proyekto sa web sa IntelliJ Idea Enterprise. Hakbang-hakbang, na may mga larawan

Ang chat ko

Mga komento

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION