Ang JSP o Java Server Pages ay isang teknolohiya ng Java na nagbibigay-daan sa iyong lumikha ng mga dynamic na web page para sa mga Java application. Sa artikulong ito ay pag-uusapan natin nang mas detalyado kung ano ang JSP, talakayin ang ilan sa mga kakayahan ng teknolohiyang ito, tingnan ang istruktura ng mga pahina ng JSP, at subukan din na tingnan kung ano ang Mga Java Server Page na ito. Ngunit una, pag-usapan natin ang mga benepisyo at kahalagahan ng JSP. Pinapayagan ng JSP ang developer na:
tumanggap ng data mula sa isang web page sa Java code;
magpadala ng data mula sa Java code sa isang web page;
isulat ang Java code nang direkta sa loob ng html (gayunpaman, hindi mo dapat abusuhin ito).
Ang pangangailangan para sa kaalaman sa JSP ay maaaring masuri nang lubos para sa ilang kadahilanan:
Ang JSP ay isa sa mga pangunahing teknolohiya sa web ng Java;
Ang JSP ay malawakang ginagamit sa karamihan ng mga kumpanya at proyekto;
Walang putol na isinasama ang JSP sa mga Java servlet sa loob ng isang servlet container.
Kahulugan ng JSP
Narito ang isang kahulugan mula sa Wikipedia: Ang JSP (JavaServer Pages) ay isang teknolohiyang nagbibigay-daan sa mga web developer na lumikha ng nilalaman na may parehong static at dynamic na mga bahagi. Ang JSP page ay naglalaman ng dalawang uri ng text: static source data, na maaaring nasa isa sa mga text format na HTML, SVG, WML, o XML, at JSP na mga elemento, na bumubuo ng dynamic na content. Bilang karagdagan, maaaring gamitin ang mga library ng tag ng JSP, pati na rin ang Expression Language (EL) upang i-embed ang Java code sa static na nilalaman ng mga pahina ng JSP. Ang JSP page code ay isinalin sa servlet Java code gamit ang Jasper JSP page compiler, at pagkatapos ay pinagsama-sama sa Java Virtual Machine (JVM) bytecode. Ang mga lalagyan ng Servlet na may kakayahang magsagawa ng mga pahina ng JSP ay nakasulat sa wikang Java na independyente sa platform. Ang teknolohiya ng JSP ay isang platform-independent, portable at madaling mapalawak na teknolohiya para sa pagbuo ng mga web application.
Istraktura ng pahina ng JSP
Sa pangkalahatan, ang JSP ay tumutukoy sa mga dynamic na web page kung saan ang dynamic na bahagi ay nabuo gamit ang Java, at ang static na bahagi ay nabuo gamit ang mga markup language, kadalasang HTML. Ang nasabing page ay isang text na dokumento na may extension na .jsp, na nakasulat sa isa sa mga markup language (gaya ng HTML, SVG, WML at XML), na may interspersed na mga elemento ng JSP (o JSP tag). Ang mga tag na ito ay naglalaman ng mga tawag sa server code (data) at nagsasagawa rin ng ilang kalkulasyon. Ang mga file na ito ay pinoproseso sa server, bilang isang resulta kung saan ang lahat ng mga JSP tag ay na-convert sa mga html tag, at ang output ay isang regular na html na pahina. Ang diagram sa ibaba ay nagpapakita ng isang diagram ng istraktura ng isang JSP page at ang pakikipag-ugnayan nito sa server. Isang halimbawa ng isang simpleng pahina ng JSP:
<html><body><p> ${2+2} равно 4</p></body></html>
Sa halimbawang ito, ang isang expression ng JSP na nakasulat sa isang espesyal na wika, Expression Language (EL), ay "naka-embed" sa loob ng html code . Nagbibigay ito ng mahalagang mekanismo para sa pakikipag-ugnayan sa pagitan ng layer ng pagtatanghal (mga web page) at ng layer ng logic ng negosyo ng application (Java code). Tulad ng makikita mo mula sa halimbawa, ang expression ng JSP ay nakapaloob sa mga kulot na brace, na may nangungunang dollar sign - ${...}. Lahat ng nasa loob ng curly braces ay sinusuri sa server, at ang resulta ng expression na ito ay ibinibigay sa html, sa lugar kung saan orihinal na tinukoy ang expression ng JSP. Pagkatapos iproseso ang lahat ng mga tag, magiging ganito ang page:
<html><body><p>4 равно 4</p></body></html>
Pag-install at pagpapatakbo ng servlet container
Dahil ang JSP code ay isinalin sa Java servlet code, kailangan nating kumuha ng ilang uri ng servlet container sa isang lugar upang mapag-usapan natin kung paano gumagana ang JSP. Kung hindi, kung walang lalagyan, hindi gagana ang JSP. Ngunit una, tingnan natin ang kahulugan ng isang lalagyan ng servlet. Ang servlet container ay isang programa na isang server na nagbibigay ng suporta sa system para sa mga servlet at tinitiyak ang kanilang life cycle alinsunod sa mga panuntunang tinukoy sa mga detalye. Maaari itong gumana bilang isang ganap na independiyenteng web server, maging isang tagapagbigay ng pahina para sa isa pang web server, o isama sa isang Java EE application server. Ang isa sa mga pinakasikat na lalagyan ng servlet ay ang Apache Tomcat. Ito ay nagkakahalaga ng pagbanggit na ang Tomcat ay hindi isang ganap na Java EE application server. Gayunpaman, para sa mahahalagang pangangailangan ng mga servlet at JSP na pahina, ang server ng Tomcat ay higit pa sa sapat. Simulan natin ang pag-install. Maaari mong i-download ang Tomcat mula sa opisyal na pahina . Para sa Windows OS maaari mong i-install ang Tomcat tulad ng sumusunod:
I-download ang 32-bit/64-bit Windows Service Installer.
Patakbuhin natin ang file.
Susunod, sundin ang karaniwang pamamaraan ng pag-install:
Huwag kalimutang suriin ang checkbox ng Mga Halimbawa sa kaukulang window ng installer:
at tukuyin ang landas sa paunang naka-install na JRE:
Pagkatapos ng pag-install, ilunsad ang Tomcat at buksan ang browser. Pumunta sa http://localhost:8080/ .
Kung nakikita mo ang panimulang pahina ng Tomcat, nangangahulugan ito na matagumpay ang pag-install at tumatakbo ang server. Upang simulan at ihinto ang Tomcat nang manu-mano, maaari mong patakbuhin ang isa sa dalawang executable na file sa direktoryo ng bin. Ito ay matatagpuan sa loob ng direktoryo kung saan naka-install ang Tomcat:
Mga demo application. Nakatagong mga bagay
Tingnan natin ang ilang feature ng JSP na kumikilos. Isa na rito ang pag-access sa tinatawag na hidden objects ( Implicit Objects ). Ito ay mga bagay na maaaring ma-access gamit ang Expression Language (EL). Ang mga halimbawa ng naturang mga bagay ay ang mga header ng HTTP o mga parameter ng URL. Ibunyag natin (o i-refresh ang ating memorya) kung ano ang mga parameter ng URL. Ang halimbawa sa ibaba ay nagpapakita ng isang URL na may mga parameter. Ang mga parameter ay naka-bold: http://example.net/foo/bar ?param1=value1¶m2=value2&a=1&name=Tom Ang mga parameter ay palaging nagsisimula sa tandang pananong (?). Sinusundan ito ng pangalan ng parameter, na sinusundan ng pantay na tanda - ang halaga ng parameter ay tinutukoy. Maaaring may ilan o isang parameter. Kung mayroong higit sa isa, ang bawat pares ng pangalan-halaga ay pinaghihiwalay ng isang ampersand character (&). Sa halimbawa sa itaas, maraming mga parameter at ang kanilang mga halaga ay tinukoy:
Pangalan ng parameter
Halaga ng parameter
param1
halaga1
param2
halaga2
a
1
pangalan
Tom
Tingnan natin kung paano mo maa-access ang mga nakatagong bagay sa JSP, kasama ang mga parameter ng URL. Upang gawin ito, ilunsad ang Tomcat at buksan ang browser sa pahinang http://localhost:8080/ Pagkatapos ay pumunta sa pahina ng Mga Halimbawa: Pagkatapos ay sundan ang link Mga Halimbawa ng JSP: Sa pahina ng mga halimbawa sundan ang link na Implicit Objects -> Ipatupad: Dito page na makikita mo ang isang halimbawa ng paggamit ng mga nakatagong bagay. Sa ibaba ay isang screenshot ng page na may mga detalyadong paliwanag: Subukang baguhin ang value ng parameter foogamit ang kaukulang field sa page, pagkatapos ay mapansin na nagbago din ang value ng parameter na ito sa address bar. Ang ipinakita na pahina ay walang gaanong pag-andar, ngunit ito ay isang magandang sanggunian na maaari mong i-refer sa hinaharap kapag kailangan mong i-access ang isang partikular na nakatagong bagay. Ang pahinang ito ay naglalaman ng isang listahan ng mga nakatagong bagay na maaaring ma-access. At sa ibaba, sa talahanayan, ipinakita kung paano mo maa-access ang isang partikular na bagay.
Mga function ng JSP
Ngayon, bumalik tayo sa nakaraang pahina at tingnan ang source code ng pahina ng "mga nakatagong bagay": Narito ito:
<%@page contentType="text/html; charset=UTF-8"%><%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%><html><head><title>JSP 2.0ExpressionLanguage-ImplicitObjects</title></head><body><h1>JSP 2.0ExpressionLanguage-ImplicitObjects</h1><hr>This example illustrates some of the implicit objects available
in the ExpressionLanguage. The following implicit objects are
available (not all illustrated here):<ul><li>pageContext - the PageContext object</li><li>pageScope - a Map that maps page-scoped attribute names totheir values</li><li>requestScope - a Map that maps request-scoped attribute names
totheir values</li><li>sessionScope - a Map that maps session-scoped attribute names
totheir values</li><li>applicationScope - a Map that maps application-scoped attribute
names totheir values</li><li>param - a Map that maps parameter names toa single String
parameter value</li><li>paramValues - a Map that maps parameter names toaString[] of
all values for that parameter</li><li>header - a Map that maps header names toa single String
header value</li><li>headerValues - a Map that maps header names toaString[] of
all values for that header</li><li>initParam - a Map that maps context initialization parameter
names totheirString parameter value</li><li>cookie - a Map that maps cookie names toa single Cookie object.</li></ul><blockquote><u><b>ChangeParameter</b></u><form action="implicit-objects.jsp" method="GET">
foo =<input type="text" name="foo" value="${fn:escapeXml(param["foo"])}"><input type="submit"></form><br><code><table border="1"><thead><td><b>EL Expression</b></td><td><b>Result</b></td></thead><tr><td>\${param.foo}</td><td>${fn:escapeXml(param["foo"])}</td></tr><tr><td>\${param["foo"]}</td><td>${fn:escapeXml(param["foo"])}</td></tr><tr><td>\${header["host"]}</td><td>${fn:escapeXml(header["host"])}</td></tr><tr><td>\${header["accept"]}</td><td>${fn:escapeXml(header["accept"])}</td></tr><tr><td>\${header["user-agent"]}</td><td>${fn:escapeXml(header["user-agent"])}</td></tr></table></code></blockquote></body></html>
Kung pamilyar ka sa HTML, dapat na malinaw sa iyo ang source code ng page. Bigyang-pansin ang mga linyang ito:
Dito makikita natin ang mga html tag <tr>at <td>. Ang mga tag ay sinusundan ng <td>mga JSP tag, na nakabalot sa mga kulot na brace ${ }. Gayunpaman, pansinin kung paano inilalabas ang halaga ng parameter ng URL foo:
${fn:escapeXml(param["foo"])}
Ang halaga ay output sa pamamagitan ng paggamit ng isang JSP function fn:escapeXml(). Ang mga function ng JSP ay naglalaman ng ilang functionality na maaaring magamit muli. Sa kasong ito, ito ay XML escaping. Ang teknolohiya ng JSP ay nagbibigay ng malawak na hanay ng mga function na mapagpipilian, pati na rin ang kakayahang lumikha ng sarili mong mga function. Upang gumamit ng isang function sa isang JSP, dapat mong i-import ang naaangkop na library kung saan ang function ay tinukoy sa JSP file.
I-tag ang mga aklatan
Tingnan natin ang isa pang linya ng source code (pangalawang linya) sa itaas:
Ito ay kung paano ini-import ang mga library ng tag. Ang syntax ay intuitive. Tinukoy namin ang ilang bagay:
taglib(tag library - tag library);
url, kung saan matatagpuan ang library na ito;
isang prefix (sa kasong ito fn) kung saan posible na tawagan ang mga function na tinukoy sa library na ito.
Sa halimbawa sa itaas, tiningnan namin ang mga function ng pag-import. Sa partikular, sa aming halimbawa, na-import namin ang library ng JSTL (JSP Standard Tag Library). Ang JSTL ay isang karaniwang tag library na naglalaman ng isang set ng iba't ibang mga library na kasama ng bawat servlet at pagpapatupad ng JSP, kasama ang Tomcat. Ang isa pang sikat na tag library ay core, na maaaring i-import tulad nito:
<%@ taglib uri ="http://java.sun.com/jsp/jstl/core" prefix ="c"%>
Tulad ng fn, ang notasyon cay opsyonal at karaniwang tinatanggap. Ang pagtatalaga na ito ay matatagpuan halos saanman kung saan ginagamit ang mga aklatang ito. Narito ang isang halimbawa ng isang function mula sa pangunahing library:
<c:out value ="${'<div>'}"/>
Ilalabas lang ng function na ito ang tag <div>. Ginagawa na ng function na ito ang XML escaping. Ang function na ito ay mahalaga mula sa isang punto ng seguridad, dahil sa pamamagitan ng pag-output ng halaga ng mga variable nang direkta, sa pamamagitan ng ${variable}, binubuksan namin ang pinto sa script injection.
Pag-edit ng JSP
Ngayon, armado ng bagong kaalaman, subukan nating gumawa ng mga pagbabago sa demo application sa loob ng Tomcat. Para magawa ito, makikita natin ang source code ng page na ito sa loob ng folder kung saan naka-install ang servlet container na ito. Ang file na ito ay matatagpuan sa sumusunod na address: ...\Apache Software Foundation\Tomcat 9.0\webapps\examps\jsp\jsp2\el Pagkatapos ay buksan ang file na implicit-objects.jsp sa anumang text editor Idagdag ang import ng core library , at pagkatapos ay gamitin ito Maglabas tayo ng ilang teksto: Ngayon, i-refresh natin ang pahina ng mga nakatagong bagay at tingnan ang mga pagbabagong ginawa:
Mga resulta
Kaya, mababaw nating sinuri ang teknolohiya tulad ng JSP. Tinalakay namin:
ano ang JSP;
istraktura ng pahina ng JSP;
pamamaraan para sa pag-install at pagpapatakbo ng lalagyan ng servlet ng Tomcat;
demo application para sa pag-access ng mga nakatagong bagay, na kasama sa pakete ng pamamahagi ng server ng Tomcat;
Mga function ng JSP at mga library ng tag.
Anong susunod?
Upang ma-secure ang materyal maaari mong:
Ulitin ang lahat ng inilarawan sa artikulong ito.
Isaalang-alang ang iba pang mga demo application na kasama sa server ng Tomcat.
Isang halimbawa ng isang simpleng pahina ng JSP:
Ito ay nagkakahalaga ng pagbanggit na ang Tomcat ay hindi isang ganap na Java EE application server. Gayunpaman, para sa mahahalagang pangangailangan ng mga servlet at JSP na pahina, ang server ng Tomcat ay higit pa sa sapat. Simulan natin ang pag-install. Maaari mong i-download ang Tomcat mula sa opisyal na pahina . Para sa Windows OS maaari mong i-install ang Tomcat tulad ng sumusunod:
Pagkatapos ay sundan ang link Mga Halimbawa ng JSP: 
Sa pahina ng mga halimbawa sundan ang link na Implicit Objects -> Ipatupad: 
Dito page na makikita mo ang isang halimbawa ng paggamit ng mga nakatagong bagay. Sa ibaba ay isang screenshot ng page na may mga detalyadong paliwanag: 
Subukang baguhin ang value ng parameter 
Narito ito:
Ngayon, i-refresh natin ang pahina ng mga nakatagong bagay at tingnan ang mga pagbabagong ginawa: 
GO TO FULL VERSION