JavaServer Pages (JSP) არის სტანდარტული Java გაფართოება, რომელიც განისაზღვრება servlet გაფართოებების თავზე. JSP-ის მიზანია გააადვილოს დინამიური ვებ გვერდების შექმნა და მართვა.

როგორც უკვე აღვნიშნეთ, Tomcat-ის უფასო განხორციელება jakarta.apache.org-დან ავტომატურად უჭერს მხარს JSP-ს.

JSP საშუალებას გაძლევთ დააკავშიროთ HTML ვებ გვერდები ჯავის კოდის ნაწილებთან ერთ დოკუმენტში. ჯავის კოდი გარშემორტყმულია სპეციალური ტეგებით, რომლებიც ეუბნებიან JSP კონტეინერს, რომ მან უნდა გამოიყენოს კოდი ერთი დოკუმენტის ან მისი ნაწილის შესაქმნელად. JSP-ის უპირატესობა ის არის, რომ თქვენ შეგიძლიათ შეიცავდეთ ერთ დოკუმენტს, რომელიც წარმოადგენს როგორც გვერდს, ასევე მასში შემავალ ჯავის კოდს.

მინუსი არის ის, რომ ვინც ინახავს JSP გვერდს, უნდა ჰქონდეს გამოცდილება როგორც HTML-ში, ასევე Java-ში (თუმცა, ვიზუალური JSP გვერდის შემქმნელები, სავარაუდოდ, დროთა განმავლობაში გახდება ხელმისაწვდომი).

როდესაც JSP პირველად იტვირთება, ის იტვირთება JSP კონტეინერით (რომელიც ჩვეულებრივ ასოცირდება ან არის ვებ სერვერის ნაწილი), შემდეგ სერლეტის კოდი, რომელიც აუცილებლად არის მონიშნული JSP ტეგებით, ავტომატურად გენერირებული, კომპილირებული და ჩატვირთულია სერვლეტის კონტეინერში. HTML გვერდის სტატიკური ნაწილი კეთდება String ტიპის სტატიკური ობიექტის write() მეთოდზე გადაცემით. დინამიური ნაწილი პირდაპირ შედის სერვლეტში.

JSP გვერდის სტრუქტურა არის რაღაც სერვლეტსა და HTML გვერდს შორის. JSP ტეგები იწყება და მთავრდება კუთხური ფრჩხილით, ისევე როგორც HTML კოდი, მაგრამ ტეგები ასევე შეიცავს პროცენტულ ნიშნებს, ამიტომ ყველა JSP ტეგი იწერება ასე:

წამყვანი პროცენტის ნიშანი შეიძლება მოჰყვეს სხვა სიმბოლოებს, რომლებიც განსაზღვრავენ ტეგში JSP კოდის ზუსტ ტიპს.

აქ არის ძალიან მარტივი JSP მაგალითი, რომელიც იყენებს Java ბიბლიოთეკის სტანდარტულ ზარს მიმდინარე დროის მილიწამებში მისაღებად, რომელიც შემდეგ იყოფა 1000-ზე, რომ მიიღოთ დრო წამებში. JSP გამონათქვამიდან (<%=), результат вычислений преобразуется в строку, а затем поместится в сгенерированную Web страницу:

//:! c15:jsp:ShowSeconds.jsp< html >< body > < H1 >დრო წამებში არის:<%= System . currentTimeMillis ()/ 1000 %> ///:~

ამ წიგნის JSP მაგალითებში, ძახილის ნიშანი პირველ "კომენტარის სტრიქონში" ნიშნავს, რომ პირველი და ბოლო სტრიქონები არ იქნება ჩართული კოდის რეალურ ფაილში, რომელიც მოთავსებულია ამ წიგნის წყაროს კოდის ხეში.

როდესაც კლიენტი აკეთებს მოთხოვნას JSP გვერდზე, ვებ სერვერი უნდა იყოს კონფიგურირებული, რათა გაგზავნოს მოთხოვნა JSP კონტეინერში, რომელიც შემდეგ მოიცავს გვერდს. როგორც უკვე აღვნიშნეთ, პირველად გვერდზე წვდომისას, გვერდზე მითითებული კომპონენტები გენერირდება და ერთი ან მეტი სერლეტი შედგენილია JSP კონტეინერის მიერ. ზემოთ მოყვანილ მაგალითში, სერვლეტი შეიცავდა კოდს HTTPServletResponse ობიექტის კონფიგურაციისთვის, რომელიც აწარმოებს PrintWriter ობიექტს (რომელიც ყოველთვის გამოძახებულია) და შემდეგ ააქტიურებს დროებს ძალიან მოკლე განცხადებით, მაგრამ საშუალო HTML პროგრამისტს/ვებ დიზაინერს არ აქვს წერის გამოცდილება. ასეთი კოდი.

იმპლიციტური ობიექტები

Servlets მოიცავს კლასებს, რომლებიც უზრუნველყოფენ მოსახერხებელ უტილიტებს, როგორიცაა HttpServletRequest, HttpServletResponse, Session და ა.შ. ამ კლასების ობიექტები ჩაშენებულია JSP სპეციფიკაციაში და ავტომატურად ხელმისაწვდომია თქვენს JSP-ში გამოსაყენებლად დამატებითი ხაზების კოდის დაწერის გარეშე. იმპლიციტური JSP ობიექტები დეტალურად არის ჩამოთვლილი ქვემოთ მოცემულ ცხრილში.

იმპლიციტური ცვლადები	ტიპი (javax.servlet)	აღწერა	ფარგლები
მოთხოვნა	HttpServletRequest-ის პროტოკოლზე დამოკიდებული ქვეტიპი	მოთხოვნა, რომლითაც სამსახურმა დარეკა.	მოთხოვნა
პასუხი	HttpServletResponse-ის პროტოკოლზე დამოკიდებული ქვეტიპი	პასუხი მოთხოვნაზე.	გვერდი
გვერდიკონტექსტი	jsp.PageContext	გვერდის კონტექსტი, რომელიც ასახავს იმპლემენტაციაზე დამოკიდებულ შესაძლებლობებს და უზრუნველყოფს ამ JSP-ზე მოხერხებულ მეთოდებსა და სახელთა სივრცის წვდომას.	გვერდი
სესია	პროტოკოლზე დამოკიდებული ქვეტიპი http.HttpSession	კლიენტის მოთხოვნისთვის შექმნილი სესიის ობიექტი.	სესია
იხილეთ სესიის ობიექტი servlet-ისთვის.	განაცხადი	servlet კონტექსტი მიღებული servlet კონფიგურაციის ობიექტიდან (მაგ. getServletConfig(), getContext().	აპლიკაცია
გარეთ	jsp.JspWriter	ობიექტი, რომელიც წერს გამომავალ ნაკადს.	გვერდი
კონფიგურაცია	ServletConfig	ServletConfig ამ JSP-სთვის.	გვერდი
გვერდი	java.lang.ობიექტი	ამ გვერდის იმპლემენტაციის კლასის მაგალითი, რომელიც ამუშავებს მიმდინარე მოთხოვნას.	გვერდი

თითოეული ობიექტის ხილვადობის არეალი შეიძლება მნიშვნელოვნად განსხვავდებოდეს.

მაგალითად, სესიის ობიექტს აქვს გვერდის ფარგლები, რადგან მას შეუძლია მრავალი კლიენტის მოთხოვნა და გვერდი მოიცავდეს. აპლიკაციის ობიექტს შეუძლია მომსახურება გაუწიოს JSP გვერდების ჯგუფს, რომლებიც ერთად წარმოადგენს ვებ აპლიკაციას.

JSP დირექტივები

<% @ directive { attr = "value" }* %>

დირექტივები არის შეტყობინებები JSP კონტეინერში და აღინიშნება "@" სიმბოლოთი:

<% @ page language = "java" %>

დირექტივები არაფერს აგზავნის გამომავალ ნაკადში, მაგრამ ისინი მნიშვნელოვანია თქვენი JSP გვერდის ატრიბუტებისა და JSP კონტეინერის დამოკიდებულების დასაყენებლად. მაგალითად, ხაზი:

იტყობინება, რომ JSP გვერდის შიგნით გამოყენებული სკრიპტირების ენა არის Java.

<% @ page session = "true" import =" java . util .*" %>

სინამდვილეში, JSP სპეციფიკაცია აღწერს მხოლოდ სკრიპტირების სემანტიკას ენის ატრიბუტების ექვივალენტური "Java". ამ დირექტივის მიზანია JSP ტექნოლოგიაში მოქნილობის შექმნა. მომავალში, თუ აირჩევთ სხვა ენას, ვთქვათ Python (კარგი არჩევანი სკრიპტირებისთვის), მაშინ ასეთ ენას უნდა ჰქონდეს Java Run-time Environment-ის მხარდაჭერა, რომელიც გამოავლენს Java ტექნოლოგიის ობიექტის მოდელს სკრიპტირების გარემოსთვის, განსაკუთრებით იმპლიციტური ცვლადებისთვის. ზემოთ განსაზღვრული JavaBeans თვისებები და საჯარო მეთოდები.

იმპორტის ატრიბუტი აღწერს ტიპებს, რომლებიც ხელმისაწვდომია სკრიპტირების გარემოსთვის. ეს ატრიბუტი გამოიყენება ისევე, როგორც Java პროგრამირების ენაში, ანუ იმპორტის განცხადებების მძიმით გამოყოფილი სია. ეს სია იმპორტირებულია გვერდის თარგმნილი JSP განხორციელებით და ხელმისაწვდომია სკრიპტირების გარემოსთვის. კიდევ ერთხელ ვთქვათ, რომ ეს ამჟამად მხოლოდ განსაზღვრულია, თუ ენის დირექტივის მნიშვნელობა არის "java".

JSP სკრიპტის ელემენტები

მას შემდეგ რაც გამოიყენებთ დირექტივებს სკრიპტირების გარემოს დასაყენებლად, შეგიძლიათ გამოიყენოთ სკრიპტირების ელემენტები. JSP 1.1 აქვს სამი სკრიპტის ენის ელემენტი - დეკლარაცია, სკრიპტი და გამოხატვა. დეკლარაციები აცხადებენ ელემენტებს, სკრიპლეტები განცხადებების ფრაგმენტებია, გამონათქვამები კი სრული ენობრივი გამონათქვამებია. JSP-ში სკრიპტის ყველა ელემენტი იწყება "<%". Синтаксис каждого из них:

<%! declaration %> <% scriptlet %> <%= expression %>

სივრცეები შემდეგ "<%!", "<%", "<%=" и перед "%>"არ არის საჭირო.

ყველა ეს ტეგი დაფუძნებულია XML-ზე; შეიძლება ითქვას, რომ JSP გვერდი შეიძლება აისახოს XML დოკუმენტში. ზემოთ მოცემული სკრიპტის ელემენტების ექვივალენტური სინტაქსი შეიძლება იყოს:

< jsp : declaration >დეკლარაცია < jsp : scriptlet >სკრიპტი < jsp : expression >გამოხატულება

გარდა ამისა, არსებობს ორი სახის კომენტარი:

<%-- jsp comment --%>

პირველი ფორმა საშუალებას გაძლევთ დაამატოთ კომენტარები JSP წყაროს კოდზე, რომელიც არ გამოჩნდება რაიმე ფორმით კლიენტისთვის გაგზავნილ HTML გვერდზე. რა თქმა უნდა, კომენტარების მეორე ფორმა არ არის JSP სპეციფიკური - ეს არის ჩვეულებრივი HTML კომენტარი. საინტერესო ის არის, რომ თქვენ შეგიძლიათ ჩადოთ JSP კოდი HTML კომენტარში და შედეგი გამოჩნდება მიღებულ გვერდზე.

დეკლარაციები გამოიყენება ცვლადებისა და მეთოდების გამოსაცხადებლად სკრიპტირების ენაზე (ამჟამად მხოლოდ Java-ში), რომელიც გამოიყენება JSP გვერდზე.

დეკლარაცია უნდა იყოს ჯავის სრული გამონათქვამი და არ შეუძლია გამომავალი ნაკადის რაიმე გამომავალი. ქვემოთ მოცემულ მაგალითში Hello.jsp, loadTime, loadDate და hitCount ცვლადების დეკლარაციები არის ჯავის სრული გამონათქვამები, რომლებიც აცხადებენ და ინიციალიზებენ ახალ ცვლადებს.<%-- //:! c15:jsp:გამარჯობა.jsp%> <%-- ეს JSP კომენტარი არ გამოჩნდება გენერირებულ html-ში --%> <%@ page import="java.util.*" %> <%-- ეს არის JSP დირექტივა: --%> <% ! long loadTime = System.currentTimeMillis (); Date loadDate = new Date (); int hitCount = 0 ; %> <%-- ეს განცხადება: --%>

შემდეგი რამდენიმე სტრიქონი წარმოქმნილ html-ში ჩასმული JSP გამონათქვამების შედეგია; ნიშანი "=" მიუთითებს JSP გამოხატულებაზე --<%= loadDate %>

ეს გვერდი ჩაიტვირთა<%= new Date () %>

გამარჯობა, სამყარო! ეს არის<%= new Object () %>

აქ არის ობიექტი:<%= (System.currentTimeMillis ()- loadTime )/ 1000 %>ეს გვერდი გაშენდა

წამი<%= ++ hitCount %>გვერდი შემოწმდა<%= loadDate %>

<%-- ჯერ მას შემდეგ%> <% System.out.println ("Goodbye" ); out.println ("Cheerio" ); %> ///:~

ამ პროგრამის გაშვებისას დაინახავთ, რომ loadTime, loadDate და hitCount ცვლადები ინახავენ თავიანთ მნიშვნელობებს გვერდის დარტყმებს შორის, ამიტომ ისინი აშკარად ველებია და არა ლოკალური ცვლადები.

მაგალითის ბოლოს არის სკრიპტი, რომელიც წერს "მშვიდობით" ვებ სერვერის კონსოლს და "Cheerio" იმპლიციტურ JspWriter გამომავალ ობიექტს. სკრიპტი შეიძლება შეიცავდეს კოდის ნებისმიერ ფრაგმენტს, რომელიც არის Java-ის მოქმედი ინსტრუქციები. სკრიპლეტები შესრულებულია მოთხოვნის დამუშავების დროს. როდესაც მოცემულ JSP-ში ყველა სკრიპტის ფრაგმენტი გაერთიანებულია JSP-ის გვერდზე გამოჩენის თანმიმდევრობით, მათ უნდა წარმოადგინონ Java პროგრამირების ენისთვის დამახასიათებელი მოქმედი ინსტრუქცია. გამოიტანს თუ არა სკრიპტი გამომავალ ნაკადს, დამოკიდებულია მხოლოდ სკრიპლეტის კოდზე. თქვენ უნდა იცოდეთ, რომ სკრიპლეტს შეუძლია გავლენა მოახდინოს მისთვის ხილულ ობიექტებზე.

JSP გამონათქვამები შეგიძლიათ იხილოთ HTML-თან შერეული Hello.jsp-ის შუა განყოფილებაში.

გამონათქვამები უნდა იყოს ჯავის სრული ინსტრუქციები, რომლებიც ფასდება, გარდაიქმნება სტრიქონად და იგზავნება გამოსავალზე. თუ განცხადების შედეგი ვერ გადაიქცევა სტრიქონად, ClassCastException იქნება ჩაგდებული.

ველების და მნიშვნელობების ამოღება

შემდეგი მაგალითი მსგავსია ადრე მოყვანილი სერვლეტების განყოფილებაში. გვერდის პირველად ჩვენებისას ის აღმოაჩენს, რომ არ გაქვთ ველები და აბრუნებს გვერდს, რომელიც შეიცავს ფორმას იგივე კოდის გამოყენებით, როგორც სერლეტის მაგალითში, მაგრამ JSP ფორმატში. როდესაც თქვენ წარადგენთ ფორმას შევსებული ველებით იმავე JSP URL-ზე, გვერდი ამოიცნობს ველებს და აჩვენებს მათ. მეორე შეიცავს ამ გვერდის საპასუხო კოდს ერთ ფაილში, რაც ამარტივებს შექმნას და შენარჩუნებას.<%-- //:! c15:jsp:DisplayFormData.jsp%> <%-- მონაცემების ამოღება HTML ფორმიდან. --%> <%@ page import="java.util.*" %>

ეს JSP ასევე ქმნის ფორმას. --

<% Enumeration flds = request.getParameterNames (); if (! flds.hasMoreElements ()) { // Нет полей %>

<% for (int i = 0 ; i < 10 ; i ++) { %>DisplayFormData<%= i %> :
<% } %>

<% } else { while (flds.hasMoreElements ()) { String field = (String ) flds.nextElement (); String value = request.getParameter (field ); %>

<%= field %> = <%= value %>

<% } } %>

///:~

გაგზავნა

ამ მაგალითში ყველაზე საინტერესო ის არის, რომ ის აჩვენებს, თუ როგორ შეიძლება სკრიპლეტის კოდის შერევა HTML კოდში მაშინაც კი, როდესაც HTML გენერირდება Java მარყუჟის შიგნით. ეს განსაკუთრებით სასარგებლოა ნებისმიერი სახის ფორმების შესაქმნელად, რომლებიც სხვაგვარად საჭიროებს თქვენგან დუბლიკატი HTML კოდის ჩასმას.

სერვლეტებისა და JSP-ების HTML დოკუმენტაციის დათვალიერებისას, თქვენ ნახავთ შესაძლებლობას, რომელიც აცნობებს ინფორმაციას ამჟამად გაშვებული servlet-ის ან JSP-ის შესახებ.

შემდეგი მაგალითი აჩვენებს ამ მონაცემებს.<%-- //:! c15:jsp:PageContext.jsp%> <%-- გვერდის კონტექსტის ატრიბუტების ნახვა--%> <%@ page import="java.util.*" %> გაითვალისწინეთ, რომ თქვენ შეგიძლიათ შეიტანოთ ნებისმიერი რაოდენობის კოდი სკრიპლეტის ტეგებში --<%= config.getServletName () %>
Servlet სახელი:<% out.print (application.getMajorVersion () + "." + application.getMinorVersion ()); %>
<% session.setAttribute ("My dog" , "Ralph" ); for (int scope = 1 ; scope <= 4 ; scope ++) { %>

Servlet კონტეინერი მხარს უჭერს servlet ვერსიას:<%= scope %>

<% Enumeration e = ფარგლები: pageContext.getAttributeNamesInScope

(ფარგლები); while (e.hasMoreElements()) (out.println("\t

" ); } } %>

///:~

" + e.nextElement() +"

ეს მაგალითი ასევე გვიჩვენებს inline HTML-ის გამოყენებას და ჩაწერას, რათა შედეგად შეიქმნას HTML გვერდი.

პირველი ინფორმაცია აწარმოებს სერვლეტის სახელს, რომელიც, სავარაუდოდ, იქნება მხოლოდ "JSP", მაგრამ ეს დამოკიდებულია თქვენს განხორციელებაზე.

თქვენ ასევე შეგიძლიათ განსაზღვროთ servlet კონტეინერის მიმდინარე ვერსია განაცხადის ობიექტის გამოყენებით. და ბოლოს, სესიის ატრიბუტის დაყენების შემდეგ, "ატრიბუტების სახელები" ნაჩვენებია ნორმალურ ფარგლებში. როგორც წესი, თქვენ არ იყენებთ ფარგლებს JSP-ების უმეტესობაში; ისინი აქ ნაჩვენებია უბრალოდ ამ მაგალითისთვის ინტერესის დასამატებლად.

არსებობს სამი სფეროს ატრიბუტი: გვერდის ფარგლები (ფარგლები 1), მოთხოვნის ფარგლები (ფარგლები 2), სესიის ფარგლები (ფარგლები 3 - აქ მხოლოდ ერთი ელემენტია ხელმისაწვდომი არის "ჩემი ძაღლი", დამატებულია მარყუჟის წინ) და სპექტის განაცხადი (ფარგლები 4) , ეფუძნება ServletContext ობიექტს. თითოეულ Java მანქანაში არის ერთი ServletContext თითო "ვებ აპლიკაციაში". ("ვებ აპლიკაცია" არის სერვერების URL-ების კონკრეტული ქვეჯგუფის ქვეშ დაყენებული სერვერტებისა და კონტენტის კოლექცია, როგორიცაა /catalog. ისინი დაინსტალირებულია კონფიგურაციის ფაილის გამოყენებით.) აპლიკაციის ველში ნახავთ ობიექტებს, რომლებიც წარმოადგენენ ბილიკებს სამუშაო დირექტორია და დროებითი დირექტორია კატალოგი.<%-- სესიის მანიპულირება JSP-ში%>

სესიები დაინერგა წინა განყოფილებაში სერლეტების შესახებ და ასევე ხელმისაწვდომია JSP-ში. შემდეგი მაგალითები განიხილავს სესიის ობიექტებს და საშუალებას გაძლევთ მანიპულიროთ სესიის გაუქმებამდე დროის სიგრძით.<%= session.getId () %>

//:! c15:jsp:SessionObject.jsp<%= session.getCreationTime () %>

სესიის ობიექტის მნიშვნელობების მიღება და დაყენება --<%= () %>

<% სესიის ID:(5 ); %>

ეს სესია შეიქმნა ქ<%= ძველი MaxInactiveInterval =() %>

session.setMaxInactiveInterval

ახალი MaxInactiveInterval=<%= session.getAttribute ("My dog" ) %>

<%-- session.getMaxInactiveInterval%> <% session.setAttribute ("My dog" , new String ("Ralph" )); %>

თუ სესიის ობიექტი "ჩემი ძაღლი" კვლავ ირგვლივ არის, ეს მნიშვნელობა არ იქნება ნული:<%= session.getAttribute ("My dog" ) %>

<%-- ნახეთ თუ არა "ჩემი ძაღლი" სხვა ფორმაში...%>

< /FORM>

///:~

სესიის ობიექტი მოწოდებულია ნაგულისხმევად, ამიტომ ის ხელმისაწვდომია დამატებითი კოდის გარეშე. getID(), getCreationTime() და getMaxInactiveInterval() ზარები გამოიყენება ამ სესიის ობიექტის შესახებ ინფორმაციის საჩვენებლად.

როდესაც პირველად მიიღებთ ამ სესიას, ნახავთ, რომ MaxInactiveInterval არის მაგალითად 1800 წამი (30 წუთი). ეს დამოკიდებულია თქვენი JSP/servlet კონტეინერის კონფიგურაციაზე. MaxInactiveInterval მცირდება 5 წამამდე, რათა უფრო საინტერესო გახდეს.

თუ გადატვირთავთ გვერდს 5 წამის დასრულებამდე, ნახავთ:

სესიის მნიშვნელობა "ჩემი ძაღლისთვის" = რალფი

მაგრამ თუ დაელოდებით უფრო მეტ ინტერვალს, მაშინ "რალფი" გახდება ნული.

იმის სანახავად, თუ როგორ ხდება სესიის ინფორმაციის გადატანა სხვა გვერდებზე და რომ ნახოთ სესიის ობიექტის ბათილად ცნობის ეფექტი მისი ვადის ამოწურვასთან შედარებით, იქმნება ორი ახალი გვერდი. პირველი (ხელმისაწვდომია SessionObject.jsp ღილაკზე „გაუქმების“ დაწკაპუნებით) კითხულობს სესიის ინფორმაციას და შემდეგ აშკარად არღვევს სესიას:<%-- //:! c15:jsp:SessionObject2.jsp%>

სესიები დაინერგა წინა განყოფილებაში სერლეტების შესახებ და ასევე ხელმისაწვდომია JSP-ში. შემდეგი მაგალითები განიხილავს სესიის ობიექტებს და საშუალებას გაძლევთ მანიპულიროთ სესიის გაუქმებამდე დროის სიგრძით.<%= session.getId () %>

სესიის ობიექტი გადატანილია --<%= session.getValue ("My dog" ) %>

<% session.invalidate (); %>

///:~

სესიის მნიშვნელობა "ჩემი ძაღლისთვის"

ამის ექსპერიმენტისთვის განაახლეთ SessionObject.jsp, შემდეგ დაუყოვნებლივ დააწკაპუნეთ ღილაკზე „გაუქმება“ SessionObject2.jsp გვერდზე გადასასვლელად. ამ დროს თქვენ კვლავ დაინახავთ "Ralph"-ს და ამის შემდეგ დაუყოვნებლივ (სანამ 5 წამის ინტერვალი გაივლის), განაახლეთ SessionObject2.jsp, რომ ნახოთ, რომ სესია წარმატებით გაუქმდა და "Ralph" გაქრა.

თუ დაბრუნდებით SessionObject.jsp-ზე, განაახლეთ გვერდი ისე, რომ კვლავ გქონდეთ 5 წამიანი ინტერვალი, შემდეგ დააწკაპუნეთ ღილაკზე "Keep Around", თქვენ გადაგიყვანთ შემდეგ SessionObject3.jsp გვერდზე, რომელიც არ არღვევს სესიას:<%-- //:! c15:jsp:SessionObject3.jsp%>

სესიები დაინერგა წინა განყოფილებაში სერლეტების შესახებ და ასევე ხელმისაწვდომია JSP-ში. შემდეგი მაგალითები განიხილავს სესიის ობიექტებს და საშუალებას გაძლევთ მანიპულიროთ სესიის გაუქმებამდე დროის სიგრძით.<%= session.getId () %>

სესიის ობიექტი გადატანილია --<%= session.getValue ("My dog" ) %>

///:~

დაბრუნება

ვინაიდან ეს გვერდი არ არღვევს სესიას, "Ralph" დარჩება ყოველი გვერდის განახლების დროს, სანამ განახლებებს შორის 5 წამის ინტერვალი არ გაივლის. ის დიდად არ განსხვავდება ტომაგოჩის სათამაშოსგან - სანამ რალფთან თამაშობთ, ის იქ იქნება, წინააღმდეგ შემთხვევაში გაქრება.

ქუქიები დაინერგა წინა განყოფილებაში სერლეტების შესახებ. კიდევ ერთხელ, JSP-ის სიზუსტე აადვილებს ქუქიების დამუშავებას, ვიდრე სერლეტების გამოყენებას. შემდეგი მაგალითი გვიჩვენებს ამას მოთხოვნაში მოტანილი ქუქიების მოძიებით, მაქსიმალური ასაკის წაკითხვით და შეცვლით (ვადის გასვლის თარიღი) და ახალი ქუქი-ფაილის მიმაგრებით პასუხის მოთხოვნაზე:

//:! c15:jsp:Cookies.jsp<%-- ეს პროგრამა განსხვავებულად იქცევა სხვადასხვა ბრაუზერში! --%>

სესიები დაინერგა წინა განყოფილებაში სერლეტების შესახებ და ასევე ხელმისაწვდომია JSP-ში. შემდეგი მაგალითები განიხილავს სესიის ობიექტებს და საშუალებას გაძლევთ მანიპულიროთ სესიის გაუქმებამდე დროის სიგრძით.<%= session.getId () %>

<% Cookie cookies = request.getCookies (); for (int i = 0 ; i < cookies.length ; i ++) { %>ქუქი-ფაილის სახელი:<%= cookies [ i ]. getName () %>
ღირებულება:<%= cookies [ i ]. getValue () %>
სიბერის მაქსიმალური ასაკი წამებში:<%= cookies [ i ]. getMaxAge () %>
<% cookies [ i ]. setMaxAge (5 ); %>ახალი მაქსიმალური ასაკი წამებში:<%= cookies [ i ]. getMaxAge () %>
<% } %> <% ! int count = 0 ; int dcount = 0 ; %> <% response.addCookie (new Cookie ("Bob" + count ++, "Dog" + dcount ++)); %>

///:~

ვინაიდან თითოეული ბრაუზერი განსხვავებულად ინახავს ქუქი-ფაილებს, თქვენ შეიძლება ნახოთ განსხვავებული ქცევა სხვადასხვა ბრაუზერში (დარწმუნებული არ არის, მაგრამ ეს შეიძლება იყოს გარკვეული ხარვეზი, რომელიც შეიძლება გამოსწორდეს სანამ ამას წაიკითხავთ). თქვენ ასევე შეგიძლიათ მიიღოთ განსხვავებული შედეგები, თუ გამოხვალთ თქვენი ბრაუზერიდან და გაუშვით მას, ვიდრე სხვა გვერდს ეწვიეთ და შემდეგ დაბრუნდებით Cookies.jsp-ზე. გაითვალისწინეთ, რომ სესიის ობიექტის გამოყენება უფრო მიზანშეწონილია, ვიდრე უშუალოდ ქუქიების გამოყენება.

სესიის ID-ის ჩვენების შემდეგ, ქუქიების მასივის თითოეული ქუქი, რომელიც მოჰყვა მოთხოვნის ობიექტს, გამოჩნდება გვერდზე მის მაქსიმალურ ასაკთან ერთად. მაქსიმალური ასაკი იცვლება და კვლავ გამოჩნდება ახალი მნიშვნელობის შესამოწმებლად, შემდეგ პასუხს ემატება ახალი ქუქი. თუმცა, თქვენს ბრაუზერს შეუძლია უგულებელყოს ეს მაქსიმალური ასაკი; ღირს ამ პროგრამით თამაში და მაქსიმალური ასაკობრივი მნიშვნელობის შეცვლა სხვადასხვა ბრაუზერში ქცევის სანახავად.

დასკვნა JSP-ის შესახებ

ეს განყოფილება მხოლოდ JSP-ის სწრაფი მიმოხილვაა და თუნდაც ის, რაც აქ არის დაფარული (ერთად რასაც შეიტყობთ Java-ს შესახებ წიგნის დანარჩენ ნაწილში და HTML-ის ცოდნასთან ერთად), შეგიძლიათ დაიწყოთ რთული ვებ გვერდების წერა. JSP. JSP სინტაქსი არ არის იდუმალი ან რთული, ასე რომ, თუ გესმით, რა არის წარმოდგენილი ამ განყოფილებაში, მზად ხართ იყოთ პროდუქტიული JSP-ით. შეგიძლიათ მეტი ინფორმაცია მოიძიოთ უმეტეს სერვლეტ წიგნებში ან java.sun.com-ზე.

განსაკუთრებით მოსახერხებელია JSP-ზე წვდომა მაშინაც კი, თუ თქვენი მიზანი მხოლოდ სერლეტების შექმნაა. თქვენ აღმოაჩენთ, რომ თუ თქვენ გაქვთ შეკითხვა სერვლეტის ფუნქციის ქცევასთან დაკავშირებით, პასუხის მისაღებად JSP-ში ტესტის პროგრამის დაწერა ბევრად უფრო ადვილი და სწრაფია, ვიდრე სერლეტის დაწერა. მოხერხებულობის ნაწილი არის ის, რომ თქვენ უნდა დაწეროთ ნაკლები კოდი და შეგიძლიათ შეურიოთ რენდერირებული HTML ჯავის კოდს, მაგრამ ეს უპირატესობა განსაკუთრებით ნათელი ხდება, როდესაც ხედავთ, რომ JSP კონტეინერი ამუშავებს JSP-ის ყველა ხელახლა კომპილაციას და გადატვირთვას თქვენთვის ნებისმიერ დროს, წყაროს კოდი. ცვლილებები .

თუმცა, JSP-ის საშინელება ის არის, რომ თქვენ უნდა გაითვალისწინოთ, რომ JSP-ის შექმნა მოითხოვს უფრო დიდ უნარს, ვიდრე უბრალოდ Java-ში პროგრამირება ან უბრალოდ ვებ გვერდების შექმნა. ასევე, გატეხილი JSP-ის გამართვა არც ისე ადვილია, როგორც Java პროგრამით, რადგან (დღესდღეობით) შეცდომის შეტყობინებები უფრო ბუნდოვანია. ეს უნდა შეიცვალოს განვითარების სისტემების გაუმჯობესებასთან ერთად, მაგრამ ჩვენ ასევე შეიძლება დავინახოთ Java-სა და ვებ-ზე დაფუძნებული სხვა ტექნოლოგიები, რომლებიც უკეთესად შეეფერება ვებ-გვერდების დიზაინერების უნარებს.

სავარჯიშოები

1. შექმენით JSP გვერდი, რომელიც ბეჭდავს ტექსტის სტრიქონს ტეგის გამოყენებით

   .

2. დააყენეთ ამ ტექსტის ფერი შემთხვევითად JSP გვერდზე ჩაშენებული კოდის გამოყენებით. თუ არ გაქვთ არსებული JSP კონტეინერი, უნდა ჩამოტვირთოთ, დააინსტალიროთ და გაუშვათ Tomcat-დან jakarta.apache.org
3. შეცვალეთ მაქსიმალური ასაკობრივი მნიშვნელობა Cookies.jsp-ში და დააკვირდით ქცევას სხვადასხვა ბრაუზერში. ასევე გაითვალისწინეთ განსხვავება გვერდის ხელახლა მონახულებასა და ბრაუზერის ატვირთვას/ჩამოტვირთვას შორის. თუ არ გაქვთ არსებული JSP კონტეინერი, თქვენ უნდა ჩამოტვირთოთ, დააინსტალიროთ და გაუშვათ Tomcat-დან jakarta.apache.org, რომ შეძლოთ JSP-ის გაშვება.

შექმენით JSP ერთი ველით, რომელიც საშუალებას აძლევს მომხმარებელს შეიყვანოს სესიის ვადის გასვლის დრო და მეორე ველი, რომელიც შეიცავს სესიაში შენახულ მონაცემებს. გაგზავნის ღილაკი განაახლებს გვერდს და იღებს მიმდინარე სესიის ვადის გასვლის დროს და სესიის მონაცემებს და შემდეგ ათავსებს მას, როგორც ნაგულისხმევ მნიშვნელობას ზემოთ მოცემულ ველებში. თუ არ გაქვთ არსებული JSP კონტეინერი, თქვენ უნდა ჩამოტვირთოთ, დააინსტალიროთ და გაუშვათ Tomcat-დან jakarta.apache.org, რომ შეძლოთ JSP-ის გაშვება.

JSP ტექნოლოგია ჯავის ტექნოლოგიის ოჯახის ნაწილია. JSP გვერდები: შედგენილია სერლეტებად და შეუძლია გამოიძახოს JavaBeans Components (Beans) ან Enterprise JavaBeans Components (საწარმო ლობიო) სერვერზე დამუშავების შესასრულებლად. ამრიგად, JSP ტექნოლოგია არის ვებ აპლიკაციის მასშტაბური არქიტექტურის ძირითადი კომპონენტი.

პასუხი: JavaServer Faces ტექნოლოგია არის ჩარჩო ვებ აპლიკაციებისთვის მომხმარებლის ინტერფეისების შესაქმნელად. JavaServer Faces ტექნოლოგია მოიცავს:

API-ების ნაკრები: კომპონენტების მომხმარებლის ინტერფეისის წარდგენისა და მათი მდგომარეობის მართვისთვის, მოვლენების დამუშავებისა და შეყვანის ვალიდაციისთვის, გვერდის ნავიგაციის განსაზღვრისთვის და ინტერნაციონალიზაციისა და ხელმისაწვდომობის მხარდაჭერისთვის.

მორგებული JavaServer Pages (JSP) თეგების ბიბლიოთეკა JSP გვერდზე JavaServer Faces ინტერფეისის გამოხატვისთვის.

JSP არის სპეციალიზებული სერვლეტი.

JSF არის ტეგების ნაკრები, რომელიც შეგიძლიათ გამოიყენოთ JSP-ით.

ბრაუზერის/კლიენტის პერსპექტივიდან

JSP და JSF ჰგავს ერთმანეთს, რადგან განაცხადის მოთხოვნების მიხედვით, JSP უფრო შესაფერისია შეკითხვებზე დაფუძნებული აპლიკაციებისთვის.

JSF შექმნილია უფრო მდიდარი მოვლენებზე დაფუძნებული ვებ აპლიკაციებისთვის. მე ვხედავ მოვლენას უფრო მარცვლოვანად ვიდრე მოთხოვნა/პასუხი.

სერვერის თვალსაზრისით

JSP გვერდი გარდაიქმნება სერვლეტად და აქვს მინიმალური ქცევა.

JSF გვერდი გარდაიქმნება კომპონენტების ხედ (სპეციალიზებული FacesServlet-ის მიერ) და იგი მიჰყვება სპეციფიკაციით განსაზღვრულ კომპონენტის სასიცოცხლო ციკლს.

სერვლეტები:

Java Servlet API საშუალებას აძლევს Java დეველოპერებს დაწერონ სერვერის კოდი დინამიური ვებ შინაარსის მიწოდებისთვის. სხვა საკუთრების ვებ სერვერის API-ების მსგავსად, Java Servlet API გთავაზობთ გაუმჯობესებულ შესრულებას CGI-სთან შედარებით; თუმცა, მას აქვს რამდენიმე ძირითადი დამატებითი უპირატესობა. მას შემდეგ, რაც servlets კოდირებული იყო Java-ში, ისინი უზრუნველყოფენ ობიექტზე ორიენტირებულ (OO) მიდგომას და, რაც მთავარია, შეუძლიათ ნებისმიერ პლატფორმაზე გაშვება. ამრიგად, კოდი იყო პორტატული ნებისმიერი ჰოსტისთვის, რომელიც მხარს უჭერდა Java-ს. Servlets-მა დიდი წვლილი შეიტანა Java-ს პოპულარობაში, რადგან ის გახდა ფართოდ გამოყენებული ტექნოლოგია სერვერის მხარეს ვებ აპლიკაციების შესაქმნელად.

JSP აგებულია სერლეტების თავზე და უზრუნველყოფს უფრო მარტივ, გვერდებზე დაფუძნებულ გადაწყვეტას ვებ მომხმარებლის ინტერფეისებისთვის დინამიური HTML შინაარსის დიდი რაოდენობით შესაქმნელად. JavaServer Pages საშუალებას აძლევს ვებ დეველოპერებს და დიზაინერებს მარტივად დაარედაქტირონ HTML გვერდები სპეციალური ტეგებით Java დინამიური ნაწილისთვის. JavaServer Pages მუშაობს სპეციალური servlet-ით, რომელიც ცნობილია როგორც JSP კონტეინერი, რომელიც დაინსტალირებულია ვებ სერვერზე და ამუშავებს JSP გვერდის ნახვის ყველა მოთხოვნას. JSP კონტეინერი თარგმნის მოთხოვნილ JSP-ს სერვლეტ კოდში, რომელიც შემდეგ შედგენილია და სრულდება დაუყოვნებლივ. იგივე გვერდის შემდგომი მოთხოვნები უბრალოდ გამოიძახებს გვერდის შესრულების სერვლეტს. თუ სერვერზე JSP-ში ცვლილება განხორციელდება, მისი ნახვის მოთხოვნა გამოიწვევს სხვა თარგმნას, კომპილაციას და გადატვირთვას Runtime servlet-ის.

JavaServer Faces არის სტანდარტული ჯავის ჩარჩო ვებ აპლიკაციებისთვის მომხმარებლის ინტერფეისების შესაქმნელად. რაც მთავარია, ის ამარტივებს მომხმარებლის ინტერფეისის შემუშავებას, რომელიც ხშირად არის ვებ აპლიკაციების შემუშავების ერთ-ერთი ყველაზე რთული და დამღლელი ნაწილი.
მიუხედავად იმისა, რომ შესაძლებელია მომხმარებლის ინტერფეისების შექმნა ძირითადი Java ვებ ტექნოლოგიების გამოყენებით (როგორიცაა Java servlets და JavaServer გვერდები) საწარმოს აპლიკაციების განვითარების ვებსაიტებისთვის შექმნილი ყოვლისმომცველი ჩარჩოს გარეშე, ამ ძირითად ტექნოლოგიებს ხშირად შეიძლება მოჰყვეს განვითარებისა და ტექნიკური პრობლემები. რაც მთავარია, როდესაც დეველოპერები მიაღწევენ წარმოების ხარისხის გადაწყვეტას, JSF-ის მიერ მოგვარებული პრობლემების იგივე ნაკრები მოგვარდება არასტანდარტული გზით. JavaServer Faces შექმნილია ჯავის ვებ აპლიკაციებისთვის მომხმარებლის ინტერფეისების განვითარების გასამარტივებლად შემდეგი გზებით:
ის უზრუნველყოფს კომპონენტზე დაფუძნებულ, კლიენტზე დამოუკიდებელ მიდგომას ვებ მომხმარებლის ინტერფეისების შესაქმნელად, რაც აუმჯობესებს დეველოპერის პროდუქტიულობას და მარტივად გამოყენებას.
ეს აადვილებს აპლიკაციის მონაცემებზე წვდომას და მართვას ვებ მომხმარებლის ინტერფეისიდან.
ის ავტომატურად მართავს UI მდგომარეობას მრავალ მოთხოვნასა და მრავალ კლიენტს შორის მარტივი და შეუმჩნეველი გზით.
ის უზრუნველყოფს განვითარების ჩარჩოს, რომელიც მეგობრულია დეველოპერების მრავალფეროვანი აუდიტორიისთვის, სხვადასხვა უნარების კომპლექტით.
იგი აღწერს არქიტექტურული ნიმუშების სტანდარტულ კომპლექტს ვებ აპლიკაციებისთვის.

ასევე არის სიტუაციები, როდესაც შეიძლება დაგჭირდეთ JSP-ის მხარდაჭერა JSF-ზე. განაცხადის ბუნება უნდა იყოს გადამწყვეტი ფაქტორი ტექნოლოგიის შერჩევისთვის.

თუ თქვენ გაქვთ მდიდარი GUI ინტერაქცია და ბევრი Java სკრიპტირება გჭირდებათ, მაშინ შეგიძლიათ გამოიყენოთ JSF. ძირითადად, თუ თქვენი GUI არქიტექტურა არის კომპონენტზე დაფუძნებული, ორიენტირებული და თუნდაც Swing-ის მსგავსად, მაშინ JSF საუკეთესოა.

თუ განაცხადი არის მარტივი ფორმის წარდგენა, რომელიც არ საჭიროებს დიდ ინტერაქციას GUI, მაშინ JSP შეიძლება კარგად მოიქცეს, თუ ახალი ტექნოლოგიის სწავლა ზედმეტია და რთული სტრუქტურა არ არის საჭირო.

Java სერვერის გვერდები (JSP)არის Java ტექნოლოგია, რომელიც საშუალებას აძლევს ვებ დეველოპერებს და დიზაინერებს სწრაფად განავითარონ და ადვილად შეინარჩუნონ ინფორმაცია მდიდარი, დინამიური ვებ გვერდები, რომლებიც იყენებენ არსებულ ბიზნეს სისტემებს. JSP ტექნოლოგია აშორებს მომხმარებლის ინტერფეისს კონტენტის გენერირებისგან, რაც დიზაინერებს საშუალებას აძლევს შეცვალონ გვერდის საერთო განლაგება ძირითადი დინამიური შინაარსის შეცვლის გარეშე.

ფაცელეტებიარის პირველი არა JSP გვერდის დეკლარაციის ენა, რომელიც შექმნილია JSF (ჯავა სერვერის სახეები),რომელიც უზრუნველყოფდა დეველოპერებს JSFუფრო მარტივი და ძლიერი პროგრამირების მოდელი JSP-თან შედარებით. ის წყვეტს JSP-ში არსებულ სხვადასხვა პრობლემებს ვებ აპლიკაციების განვითარებისთვის.

აქ არის ცხრილი, რომელიც ადარებს სკრიპტებისა და სახეების მახასიათებლებს:

Jsp-ს ასევე აქვს მშობლიური servlet კოდი, რომელიც არ საჭიროებს რაიმე გარე კომპილაციას, რომელიც მას შეუძლია პირდაპირ გაუშვას. ცვლილებები ძალაში შევა jsp-ში პირდაპირ ბრაუზერში.

სერლეტი უნდა იყოს კომპილირებული (ანუ მას ექნება განსაზღვრული კლასის შექმნა)

Jsf არის MVC Framework view კომპონენტი

JSP არის View MVC (Model View Controller) კომპონენტი. კონტროლერი იღებს შემოსულ მოთხოვნას და გადასცემს მას მოდელს, რომელიც შეიძლება იყოს ლობიო, რომელიც უზრუნველყოფს მონაცემთა ბაზაში წვდომას. შემდეგ JSP აფორმატებს გამომავალს HTML, CSS და JavaScript-ის გამოყენებით და შემდეგ შედეგი უბრუნდება მთხოვნელს.

JSP: ნიშნავს HTML + Java კოდს:

JSP-ს აქვს საკუთარი სიცოცხლის ციკლი jsp_init() jsp_service() jsp_destroy

პირველი მოთხოვნის შემდეგ JSP გარდაიქმნება .java ფაილად. ჩვენ ვიყენებთ სამი ტიპის ტეგს. 1.) უსკრიპტოდ

აქ დეველოპერს შეუძლია განაცხადოს ყველა ის რამ, რაც დეველოპერს სურს თან წაიღოს.

2.) გამოხატვის ტეგი

აქ დეველოპერს შეუძლია გამოიყენოს ბეჭდვით დაკავშირებული ზოგიერთი მონაცემი

აქ დეველოპერს შეუძლია გამოაცხადოს მეთოდთან დაკავშირებული ზოგიერთი მონაცემი.

სერვლეტი:

სერვილს აქვს საკუთარი სიცოცხლის ციკლი.

Init() service() destroy()

პირველი მოთხოვნის კონტეინერის შემდეგ მონაცემები წაიკითხება web.xml ფაილიდან, შემდეგ მისალმების შემდეგ გამოჩნდება padding.
ახლა მოქმედების შესრულების შემდეგ ის მოძებნის URL-ს და ამ პროცესის შემდეგ მოძებნის იქ კონკრეტულ სერვლეტს. ჩატარდება სარემონტო ოპერაცია.

როგორც წინა სტატიაში ვნახეთ, servlets საშუალებას გვაძლევს მივიღოთ მოთხოვნები კლიენტისგან, გავაკეთოთ გარკვეული სამუშაო და გამოვაჩინოთ შედეგები ეკრანზე. იმ მომენტამდე, როდესაც საჭირო იქნება გამომავალი ეკრანზე ჩვენება, სერვლეტი კარგად მუშაობს. თქვენ შეგიძლიათ მასში ჩასვათ საკმაოდ რთული ლოგიკა, დარეკოთ მონაცემთა ბაზაში და ბევრი, ბევრად მეტი, რაც საჭიროა აპლიკაციისთვის. მაგრამ თავად სერლეტის შიგნით ეკრანზე გამოტანა ძალიან მოუხერხებელია. ჩვენს მაგალითში ჩვენ შემოვიფარგლებით უკიდურესად მარტივი გადაწყვეტით. რა მოგიწევთ, თუ კომპლექსური დიზაინის იდეები გექნებათ? ნაკლებად სავარაუდოა, რომ ვებ დიზაინერმა შეძლოს იმის გაგება, თუ როგორ გამოიტანოს გამოსავალი ჩვენს სერლეტში. და როდესაც მას სურს განახორციელოს თავისი დიზაინის იდეები, მას მოუწევს პროგრამისტთან მისვლა და დიზაინის შესაცვლელად სერლეტის კოდის შეცვლა. ამის ხელახლა შედგენა დასჭირდება, საჭირო იქნება ჭკვიანი ალგორითმების გამომუშავება არა მხოლოდ სურათების, არამედ JavaScript-ის საჩვენებლად. უბრალოდ კოშმარი.
ყველა გონიერი დეველოპერისთვის ნათელია, რომ განსხვავებული გადაწყვეტა უნდა იქნას გამოყენებული. ყველაზე აშკარაა ისეთი მექანიზმის გამომუშავება, რომელიც დავალებას ორ კომპონენტად გაყოფს: ერთი ნაწილი ამუშავებს მოთხოვნას, ცვლის მონაცემებს, აგროვებს მონაცემებს, ათავსებს გარკვეულ პაკეტში და გადასცემს მეორე ნაწილს, რომელიც აკეთებს. მხოლოდ ერთი რამ - აჩვენებს ამ მონაცემებს.
ასე მივედით ჩვენ უკვე ნაცნობ შაბლონამდე - Model-View-Controller (MVC). ვებ აპლიკაციების შემთხვევაში, კონტროლერი ხდება servlet, მონაცემთა პაკეტი, რომელიც ჩვენ შევქმენით, ხდება მოდელი. მაგრამ JSP - Java Server Pages - შესანიშნავია პრეზენტაციის როლისთვის (View).
ამ სტატიაში ჩვენ მივცემთ ზოგად მიმოხილვას ამ ტექნოლოგიის შესახებ. და ჩვენ გავაგრძელებთ "ადამიანური რესურსების დეპარტამენტს" შემდეგ სტატიაში, სადაც ჩვენ შეგვიძლია დაუყოვნებლივ გამოვიყენოთ ნაცნობი ტექნოლოგიები - servlets და JSP.
JSP-ის მთავარი იდეა ძალიან მარტივია - გვერდი თავისთავად არის შაბლონი უკვე მომზადებული HTML ტეგებით, რომელთა შორისაც საჭიროა საჭირო მონაცემების ჩასმა. რაღაც მსგავსი (ეს მხოლოდ დიაგრამაა)

<% String name = request.getParameter("name"); if (name == null || name.length() == 0) { %>გამარჯობა, სამყარო!<% } else { %>გამარჯობა, სამყარო! მე ვარ<%= name%> <% } %>

< html > < head > < title > გამარჯობა მსოფლიო ნიმუში < / title > < / head > < body > < h1 > სტრიქონის სახელი = მოთხოვნა. getParameter ("სახელი"); თუ (სახელი == null || სახელი . სიგრძე () == 0 ) ( გამარჯობა, სამყარო! <% } else { გამარჯობა, სამყარო! მე "მ<%= name %> < / h1 > < / body > < / html >

როგორც ხედავთ, ჩვენი HTML ფაილი არის HTML ტეგებისა და ჯავის კოდის ნაზავი. არსებითად, JSP გარდაიქმნება სერვლეტად პირველად მასზე წვდომისას და მუშაობს როგორც servlet. ამის გაგება ძალიან მნიშვნელოვანია. JSP არ არის ისეთი გვერდი, როგორიც HTML გვერდი - მნიშვნელოვანია, რომ ახალმა პროგრამისტმა ნათლად გაიგოს, რომ ეს არის კიდევ ერთი სერვლეტი - თქვენ უბრალოდ არ გჭირდებათ მისი გამოსავლის დაპროგრამება.<%» и здесь вам можно написать любой код, который будет нужен.
შეგიძლიათ უბრალოდ დახატოთ. და ჩადეთ მონაცემები სწორ ადგილებში. მაგრამ იმიტომ თუ JSP გვერდი რაღაცნაირად წააგავს HTML-ს, ეს აშკარად გაუადვილდება დიზაინერს. და კიდევ ერთხელ მკაცრად ვეუბნები დამწყებთათვის - JSP არის SERVLET. მისი მომზადება ყველა მონაცემით ხდება სერვერზე. აქ არის ჩასმული ყველა მონაცემი. ხოლო მომხმარებელი ბრაუზერში იღებს მზა HTML გვერდს, რომელსაც არ აქვს JAVA-ს ნიშნები. შესაძლოა, რაიმე სახის აპლეტი - მაგრამ ეს სრულიად განსხვავებული ტექნოლოგიაა. უბრალოდ მოსახერხებელია JSP-ის გამოყენება - თქვენ აკეთებთ მონაცემთა მიღების ლოგიკას ერთ სერვლეტში (რომელიც არ ჰგავს JSP-ს) ​​და შემდეგ გადასცემთ მონაცემებს სხვა სერვერზე (ამჯერად JSP-ის სახით), რომლის ამოცანაა დახატოს HTML გვერდი ამ მონაცემების გამოყენებით. თქვენ უბრალოდ არ გჭირდებათ ამდენი დახატვა. გარდა ამისა, თქვენ არ გჭირდებათ JSP კლასების ხელახლა შედგენა. თქვენ უბრალოდ შეგიძლიათ შეცვალოთ JSP უფრო თანამედროვეთ და ის ავტომატურად ისევ შედგენილი იქნება. რაც ზოგადად საკმაოდ მოსახერხებელია - თქვენ უბრალოდ დააკოპირეთ საჭირო გვერდი ძველის ნაცვლად. როგორც ხედავთ, ჯავის კოდი ჩასმულია კუთხის ფრჩხილებში პროცენტის ნიშნით "
როგორც ხედავთ, ჩვენი კოდი ამოწმებს მოთხოვნაში სახელის პარამეტრის არსებობას (request.getParameter("სახელი")) და თუ ის არსებობს, მაშინ გამოჩნდება ერთი შეტყობინება. წინააღმდეგ შემთხვევაში, ჩვენ ვიხილავთ წარწერის „შემოკლებულ“ ვერსიას.

მოთხოვნა
ცოტა მეტი ინფორმაცია - JSP-ს აქვს რამდენიმე წინასწარ განსაზღვრული ობიექტი. იმათ. ისინი უნდა იქნას აღქმული, როგორც მზა ობიექტები, რომელთა გამოყენება შესაძლებელია. ეს არის მოთხოვნა, პასუხი, გამოსვლა, სესია, აპლიკაცია, კონფიგურაცია, გვერდის კონტექსტი და გვერდი. მათ მოკლე მიმოხილვას გავაკეთებ, შესაძლოა, ჯერჯერობით არც ისე საინტერესო იყოს და არც იყოს გასაგები. მაგრამ ყოველი შემთხვევისთვის.

პასუხი
ეს არის HttpServletResponse ობიექტი, რომელიც დაკავშირებულია კლიენტის მოთხოვნაზე პასუხთან. გაითვალისწინეთ, რომ იმის გამო, რომ გამომავალი ნაკადი (იხ. ქვემოთ) ბუფერულია, შესაძლებელია HTTP სტატუსის კოდებისა და პასუხების სათაურების შეცვლა, მიუხედავად იმისა, რომ ეს არ იქნება დაშვებული ნორმალურ სერლეტში, სანამ გარკვეული გამომავალი მონაცემები უკვე გაეგზავნა კლიენტს. .

გარეთ
ეს არის PrintWriter ობიექტი, რომელიც გამოიყენება კლიენტისთვის გამოსავლის გასაგზავნად. თუმცა, იმისათვის, რომ პასუხის ობიექტი (იხ. წინა განყოფილება) სასარგებლო იყოს, თქვენ უნდა გამოიყენოთ PrintWriter-ის ბუფერული ვარიანტი, JspWriter. გახსოვდეთ, რომ შეგიძლიათ შეცვალოთ ბუფერის ზომა და გამორთოთ ბუფერირებაც კი გვერდის დირექტივის ბუფერული ატრიბუტის მნიშვნელობის შეცვლით. ასევე გაითვალისწინეთ, რომ out გამოიყენება თითქმის ექსკლუზიურად სკრიპლეტების მიერ, რადგან JSP გამონათქვამები ავტომატურად მოთავსებულია გამომავალ ნაკადში, რაც გამორიცხავს ცალსახად გამოძახების აუცილებლობას.

სესია
ეს არის HttpSession ობიექტი, რომელიც დაკავშირებულია მოთხოვნასთან. სესიები იქმნება ავტომატურად და ეს ცვლადი არსებობს მაშინაც კი, თუ არ არის მითითება შემომავალ სესიებზე. ერთადერთი გამონაკლისი არის, როდესაც გამორთავთ სესიების გამოყენებას გვერდის დირექტივის სესიის ატრიბუტის გამოყენებით. ამ შემთხვევაში, სესიის ცვლადზე მითითებები იწვევს შეცდომებს JSP გვერდის სერვლეტში თარგმნისას.

განაცხადი
ეს არის ServletContext ტიპის ობიექტი, რომელიც მიღებულია getServletConfig().getContext() მეთოდის გამოყენებით.

კონფიგურაცია
ეს არის ServletConfig ობიექტი მიმდინარე გვერდისთვის.

გვერდიკონტექსტი
JSP წარმოგიდგენთ ახალ PageContext კლასს სანდბოქსის სერვერისთვის სპეციფიკური ფუნქციებისთვის, როგორიცაა უფრო ეფექტური JspWriters. იდეა ისაა, რომ თუ თქვენ მათ წვდებით ამ კლასის მეშვეობით და არა უშუალოდ, თქვენი კოდი შეიძლება იმუშაოს "რეგულარულ" servlet/JSP ძრავებზე.

გვერდი
არსებითად ამის სინონიმია და არ არის საჭირო Java-სთან მუშაობისას. ეს ცვლადი შეიქმნა მომავლისთვის, როდესაც Java-ს გარდა სხვა სკრიპტირების ენები გახდება ხელმისაწვდომი.

მოდით შევხედოთ ჩვენს შემოქმედებას მოქმედებაში. თქვენ შეგიძლიათ შეადგინოთ ჩვენი servlet ბრძანებით

javac –cp .;servlet-api.jar Students\web\*.java

ამის შემდეგ, მოდით განვათავსოთ ჩვენი HelloWorldServlet კლასი დირექტორიაში \webapps\studentsApp\WEB-INF\students\web\. და hello.jsp ფაილი ჩვენი აპლიკაციის root დირექტორიაში არის \webapps\studentsApp.
ახლა ჩვენი დირექტორიას ხე გარკვეულწილად მარტივია (ჩვენ არ ვიყენებთ ზოგიერთ კლასს)

WEB-INF კლასების სტუდენტების ვებ -HelloWorldServlet.class -web.xml -hello.jsp

< strong >WEB-INF კლასები სტუდენტები HelloWorldServlet. კლასი ვებ. xml გამარჯობა. jsp< / strong >

უკვე ცნობილი web.xml ფაილი ზუსტად ისე გამოიყურება, როგორც წინა ნაწილში

გამარჯობა გამარჯობა /გამარჯობა

< ! DOCTYPE web - app PUBLIC "-//Sun Microsystems, Inc.//DTD ვებ აპლიკაცია 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"> < web - app > < servlet > < servlet - name >გამარჯობა< / servlet - name > < servlet - class >სტუდენტები. ვებ. HelloWorldServlet< / servlet - class > < / servlet > < servlet - mapping > < servlet - name >გამარჯობა< / servlet - name > < url - pattern >/გამარჯობა< / url - pattern > < / servlet - mapping > < / web - app >

გაუშვით Tomcat და შემდეგ სცადეთ დარეკოთ ჩვენი აპლიკაცია URL-ით
http://localhost:8080/studentsApp/hello

თუ გსურთ ჩემი სახელის ნახვა, გამოიყენეთ ეს URL
http://localhost:8080/studentsApp/hello?name=ანტონ
შეგიძლიათ მოგვიანებით შეცვალოთ თქვენი სახელი :)

მორგებული ტეგი

ახლა ჩვენ შეგვიძლია ცოტა ღრმად ჩავუღრმავდეთ JSP-ს. როგორც თქვენ უკვე შენიშნეთ, JSP არის Java კოდისა და HTML ტეგების ნაზავი. პრეზენტაციის ლოგიკის სირთულის მატებასთან ერთად (და JSP გამოიყენება ზუსტად როგორც პრეზენტაცია - მაგრამ პრეზენტაციას შეიძლება ჰქონდეს საკმაოდ დახვეწილი ლოგიკა - ფერები, შრიფტები და ა.შ.), გვერდი მეტ-ნაკლებად გასაგები HTML-დან იქცევა „საზღვაო სტილში“. მაკარონი”. დიზაინერი კი ვეღარაფერს გაიგებს. JSP-ში ლოგიკის სრულად მოშორება, სავარაუდოდ, შეუძლებელია, მაგრამ როგორმე „გაასუფთავეთ“ კოდი და გამოიყენეთ უფრო მოსახერხებელი ხელსაწყოები - ასეთი გამოსავალი არსებობს. და მას CustomTags ჰქვია. არსებითად, ეს არის JSP დიზაინის გამარტივება, რომლის მიღწევაც მინდოდა.

მოდით შევხედოთ მარტივ მაგალითს, თუ როგორ შეგიძლიათ დაწეროთ და გამოიყენოთ თქვენი საკუთარი ტეგი. ამისათვის ჩვენ გვჭირდება სამი ნაბიჯი:

1. დაწერეთ TLD ფაილი (Tag Library Definition) – ტეგების ბიბლიოთეკის აღწერის ფაილი.
2. დაწერეთ კლასი თავად ტეგის განსახორციელებლად
3. სწორი HTML ფაილი

ასე რომ. TLD ფაილს აქვს .tld გაფართოება და ჩვეულებრივ განლაგებულია WEB-INF დირექტორიაში თქვენი განაცხადის დირექტორიაში. მიუხედავად იმისა, რომ ის შეიძლება განთავსდეს სხვაში. თუ თქვენ გაქვთ ბევრი ასეთი ფაილი, მაშინ შეგიძლიათ მათ ცალკე დირექტორია მიაწოდოთ. აქ არის ჩვენი ვერსია hello.tld.

1.0 1.2 ტეგების ნიმუშის ბიბლიოთეკა /SimpleTagLibrary ტეგის მაგალითი HelloWorld-ისთვის გამარჯობა Students.web.tag.HelloTag ცარიელი Hello World Tag მაგალითი სახელი ყალბი მართალია

< taglib xmlns = "http://java.sun.com/xml/ns/j2ee" xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xsi: schemaLocation = "http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" ვერსია = "2.0" > < tlib - version > 1.0 < / tlib - version > < jsp - version > 1.2 < / jsp - version > < short - name >ტეგების ნიმუშის ბიბლიოთეკა< / short - name > < uri >/SimpleTagLibrary< / uri > < description > ტეგის მაგალითი HelloWorld-ისთვის < / description > < tag > < name >გამარჯობა< / name > < tag - class >სტუდენტები. ვებ. ტეგი. HelloTag< / tag - class > < body - content >ცარიელი< / body - content > < description > Hello World Tag მაგალითი < / description > < attribute > < name >სახელი< / name > < required >ყალბი< / required > < rtexprvalue >მართალია< / rtexprvalue > < / attribute > < / tag > < / taglib >

როგორც თქვენ ალბათ შენიშნეთ აღწერილობიდან, ტეგი არის HelloTag კლასი. სწორედ ის არის პასუხისმგებელი ინფორმაციის ჩვენებაზე. მოდი დავწეროთ.

პაკეტი სტუდენტები.ვებ.ტეგი; იმპორტი java.io.IOException; იმპორტი javax.servlet.jsp.JspException; იმპორტი javax.servlet.jsp.JspTagException; იმპორტი javax.servlet.jsp.tagest.TagSupport; საჯარო საბოლოო კლასი HelloTag ავრცელებს TagSupport-ს ( პირადი სტრიქონის სახელი = null; საჯარო int doStartTag() აგდებს JspException (სცადეთ (თუ (სახელი == null) ( pageContext.getOut().write("Hello, World!"); ) else ( pageContext.getOut().write("Hello, World! I"m" + name); ) ) catch (IOException ioe) (writ new JspTagException(ioe.getMessage()); ) return SKIP_BODY; ) public String getName() ( დაბრუნების სახელი; ) საჯარო void setName (სტრიქონის სახელი) ( this.name = name; ) public void release () ( super.release (); name = null; ) )

პაკეტის სტუდენტები. ვებ. ტეგი ; ჯავას იმპორტი. io. IOException; javax-ის იმპორტი. სერვლეტი. jsp. JspException; javax-ის იმპორტი. სერვლეტი. jsp. JspTagException; javax-ის იმპორტი. სერვლეტი. jsp. თეგეტექსტი. TagSupport ; საჯარო საბოლოო კლასი HelloTag აფართოებს TagSupport ( პირადი სტრიქონის სახელი = null ; საჯარო int doStartTag() აგდებს JspException ( სცადე ( თუ (სახელი == null) ( გვერდიკონტექსტი. getOut (). დაწერე ("გამარჯობა, სამყარო!"); ) სხვა ( გვერდიკონტექსტი. getOut (). დაწერე ("გამარჯობა, სამყარო! მე" + სახელი ); ) დაჭერა (IOException ioe) ( გადაყარეთ ახალი JspTagException(ioe. getMessage()); დაბრუნება SKIP_BODY ; საჯარო სტრიქონი getName()( დაბრუნების სახელი; საჯარო void setName (სტრიქონის სახელი) ( ეს. სახელი = სახელი ; საჯარო void გამოშვება() ( სუპერ. გამოშვება(); სახელი= null; } }

ჩვენი სერლეტის და ახალი ტეგის ასაწყობად, ჩვენ გვჭირდება უფრო რთული ხაზი

javac –cp .;servlet-api.jar;jsp-api.jar Students\web\*.java Students\web\tag\*.java

ახალი jsp-api.jar ბიბლიოთეკა შეგიძლიათ იხილოთ იმავე ადგილას, როგორც servlet_api.jar - \საერთო\lib. ახლა, ჩვენი ტეგი აპლიკაციასთან დასაკავშირებლად, უნდა დავარეგისტრიროთ ჩვენი ბიბლიოთეკა web.xml ფაილში

მოგესალმებით სტუდენტურ პერსონალში მოგესალმებით სტუდენტურ პერსონალში გამარჯობა სტუდენტები.ვებგვერდი.HelloWorldServlet გამარჯობა /გამარჯობა http://www.someurl.ru /WEB-INF/hello.tld

xmlვერსია= "1.0" კოდირება= "ISO-8859-1"?> < ვებ- აპლიკაცია> < ჩვენება- სახელი> მოგესალმებითრომსტუდენტებიპერსონალი< / ჩვენება- სახელი>

JSP (Java სერვერის გვერდები)არის ტექნოლოგია, რომელიც საშუალებას გაძლევთ ჩასვათ Java კოდი, ისევე როგორც EL (გამოხატვის ენა) სტატიკურ გვერდის შინაარსში) და საშუალებას აძლევს ვებ დეველოპერებს დინამიურად გენერირება HTML, XML და სხვა ვებ გვერდები. JSP არის J2EE ბიზნეს აპლიკაციების შექმნის ერთიანი ტექნოლოგიის განუყოფელი ნაწილი.

JSP შეიძლება შესრულდეს თითქმის ნებისმიერ ვებ სერვერზე, რადგან ეს ტექნოლოგია დაფუძნებულია Java პროგრამირების ენაზე, რომელიც დამოუკიდებელია პლატფორმაზე. Java სერვერის გვერდები მხარს უჭერს HTML ტეგებს, Javascript ტეგებს და ტეგების საკუთარ კომპლექტს.

JSP - საშუალებას გაძლევთ გამოყოთ გვერდის დინამიური ნაწილი სტატიკურიდან. ეს ტექნოლოგია გულისხმობს ჯავის კოდის გვერდზე ჩასმას. ჩვენ არ განვიხილავთ ამ ვარიანტს JSP-ის გამოსაყენებლად, რადგან ეს ტექნოლოგია მოძველებული და არასრულყოფილია. მიზეზი მარტივია: დეველოპერები და დიზაინერები, რომლებიც ავითარებენ გვერდის გარეგნობას, შესაძლოა ყოველთვის არ იცნობდნენ Java-ს და ამან შეიძლება გამოიწვიოს დამატებითი სირთულეები ვებ აპლიკაციების რედაქტირების ან შენარჩუნებისას.

Java კოდის ჩასმის ნაცვლად, ახლა გამოიყენება jstl ტეგების ბიბლიოთეკა, ან Javascript უფრო მოწინავეებისთვის. ჩვენ განვიხილავთ მაგალითს jstl ტეგებით. ეს არის ძალიან მოსახერხებელი ბიბლიოთეკა, რომელსაც აქვს თითქმის ყველა ის ფუნქცია, რაც საჭიროა დინამიური გვერდების შექმნისას. თუ რაიმე კონკრეტული გჭირდებათ, ყოველთვის შეგიძლიათ დაწეროთ თქვენი საკუთარი ტეგი და ჩასვათ მისი შინაარსი გვერდზე.

JSP-ს თავიდანვე ნაწილობრივ უკვე ვიცნობთ. JSP გვერდის ძირითადი ნაწილია HTML, რომელშიც ჩასმულია დინამიური შინაარსის ტეგები.

JSP გვერდის მაგალითი

ძალიან საჭირო ცოდნა, რომელსაც ჩვენ გამოვიყენებთ, არის JSP დირექტივა.

JSP დირექტივა არის შეტყობინება, რომელიც გვერდს შეუძლია გაუგზავნოს შესაბამის კონტეინერში, სადაც მითითებულია რა უნდა გააკეთოს. დირექტივის სინტაქსი:<% @ атрибут = «значение» %>

არსებობს სამი ძირითადი ტიპის დირექტივები:

1. გვერდი (გამოიყენება კლასების იმპორტისთვის);
2. მოიცავს (გაძლევს შესაძლებლობას ჩაწერო ფაილი servlet კლასში JSP ფაილის სერვლეტში თარგმნისას);
3. taglib ( საშუალებას გაძლევთ დააკავშიროთ ტეგების ბიბლიოთეკა).

ვინაიდან ჩვენ არ ჩავსვამთ კოდს გვერდზე, მოდით გადავხედოთ ბოლო ორ დირექტივას.

მაგალითად, გვაქვს გვერდები, რომლებსაც ექნებათ ერთი და იგივე ზედა და ქვედა. ძალიან გავრცელებული შაბლონი, რომელშიც ქვედა და სათაური ერთნაირია ყველა გვერდისთვის. იმისათვის, რომ ამ გვერდების კოდი არ ჩაწეროთ თითოეულ JSP ფაილში, შეგიძლიათ ჩაწეროთ მათი კოდი ცალკეულ ფაილებში და შემდეგ დააკავშიროთ ის ჩვენთვის საჭირო ადგილას, ჩათვლით დირექტივის გამოყენებით.

ფაილების ადგილმდებარეობა პროექტში:

ზემოთ მოცემულ კოდში შეგიძლიათ იხილოთ taglib დირექტივის გამოყენება. მისი დახმარებით დავაკავშირეთ jstl ტეგების ბიბლიოთეკა. ამ დირექტივის გამოყენებით შეგიძლიათ დააკავშიროთ თქვენი საკუთარი ტეგების ბიბლიოთეკა:<%@ taglib uri=»/WEB-INF/mylib.tld» prefix=»test» %>.

გაითვალისწინეთ, რომ მნიშვნელოვანი taglib ატრიბუტია პრეფიქსი.ეს აუცილებელი ატრიბუტია. პრეფიქსის გამოყენებით შეგიძლიათ დარეკოთ ბიბლიოთეკა კოდით. თქვენ შეგიძლიათ აირჩიოთ ნებისმიერი პრეფიქსის სახელი. სხვათა შორის, აქ არის jstl ტეგების რეალური გამოყენება:

< c: forEach items= "$(ანგარიშები)" var = "ანგარიში" >

< tr align= "center" >

< td>$ (ანგარიშის ნომერი)

< td>$ (ანგარიში. ბალანსი)

< td>< c: if test= "${!account.isBlocked}" >$(statusActive)

< c: if test= "${account.isBlocked}" >$(სტატუსები დაბლოკილია)

< td>< c: if test= "${!account.isBlocked}" >

< a href= "?command=blockaccount&accountId=$(account.accountId)"> $ (ბლოკი)

< td>< a href= "?command=showinfo&accountId=$(account.accountId)"> $( showInfo )

ზემოთ მოცემული კოდი გვიჩვენებს სიის ყველა ელემენტის გამომავალს. როგორ გადავიტანეთ იგი გვერდზე, განხილული იქნება შემდეგ სტატიებში. მისი სინტაქსია:

$(პუნქტი)

ეს არის გვერდითი ზოლის კოდი, რომელიც იყო ჩართული ზემოთ. როგორც ხედავთ, ფილიალები აქ გამოიყენება მხოლოდ იმ ინფორმაციის საჩვენებლად, რომელიც ხელმისაწვდომია გარკვეული ტიპის მომხმარებლისთვის.

სინტაქსი:
a უდრის b

უმჯობესია გაითვალისწინოთ jstl ტეგები რეალური პროექტის წერისას, რადგან მე ვერ ვხედავ აზრს ყველა მოქმედების ყველა სინტაქსის სწავლაში და დამახსოვრებაში. ზემოთ მოცემული კოდი უნდა იყოს მხოლოდ მაგალითი იმისა, თუ როგორ გამოიყენება ეს. არაფრის დამახსოვრება არ არის საჭირო. როდესაც წერთ კოდს, მაშინ მიმართეთ ამ სინტაქსს.

სხვათა შორის, პროექტის კოდი, საიდანაც აღებულია ეს კოდი, მდებარეობს აქ: https://github.com/caligula95/payment-systemapp

მე გამოვაქვეყნე პროექტი heroku-ზე: https://payment-systemapp.herokuapp.com/ - აქ უფასო ანგარიშია გამოყენებული, ამიტომ პირველი მოთხოვნისთვის უნდა დაელოდო რამდენიმე წუთს პროექტის დაწყებას.