ფაილი შეიცავს მარტივ HTML-ს რამდენიმე დამატებით. ეს არის JSP-ის სილამაზე JSTL-თან და JEL-თან ერთად. ყურადღება მიაქციეთ, რამდენად ადვილია ვალიდაციის შეცდომების შემოწმება სტანდარტული ტეგების გამოყენებით, როგორიცაა<с:if>და .

რეგისტრაციის ფორმის სამოქმედო ატრიბუტი მიუთითებს შემდეგ URL-ზე: $(pageContext.request.contextPath)/processcustomer . ეს ნიშნავს, რომ ყოველ ჯერზე, როცა კლიენტი ცდილობს დარეგისტრირებას, მონაცემები გადაეგზავნება პროცესის მომხმარებელს, განურჩევლად URL-ისა, სადაც ფორმა ხელმისაწვდომია. ეს მიიღწევა JSP ფაილიდან ხელმისაწვდომი ობიექტების ფუნქციონირებით, როგორიცაა მოთხოვნა.

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

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

Გმადლობთ რეგისტრაციისთვის!

თქვენი შეყვანილი მონაცემები:

სახელი:$ (სახელი)

გვარი:$ (გვარი)

ელფოსტა:$(ელფოსტა)

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

ჩვენ ვწერთ კონტროლერს

სერვლეტის დაწერა, რომელსაც შეუძლია მონაცემების მიღება რეგისტრაციის ფორმიდან, ისეთივე მარტივია, როგორც მსხლის დაბომბვა. ჩვენ მხოლოდ უნდა დავწეროთ HttpServlet კლასის ქვეკლასი და დანერგოთ მისი doGet() ან doPost() მეთოდები (ან ორივე, საჭიროების შემთხვევაში). ამ შემთხვევაში, servlet ურთიერთქმედებს POST მოთხოვნიდან მოსულ მონაცემებთან.

აი, როგორ გამოიყურება:

@WebServlet(სახელი = "CustomerController", urlPatterns = "/processcustomer") საჯარო კლასი CustomerController ავრცელებს HttpServlet ( @Override protected void doPost(HttpServletRequest მოთხოვნა, HttpServletResponse response) აგზავნის Servlet.Request. .setAsRequestAttributes(მოთხოვნა); სიის დარღვევები = customer.validate(); if (!violations.isEmpty()) ( request.setAttribute("დარღვევები", დარღვევები); ) სტრიქონი url = defineUrl(დარღვევები); request.getRequestDispatcher(url ).forward(მოთხოვნა, პასუხი); ) private String defineUrl(List დარღვევები) ( if (!violations.isEmpty()) ( return "/"; ) else ( return "/WEB-INF/views/customerinfo.jsp"; ) ) კერძო სტატიკური კლასი RequestCustomer ( კერძო საბოლოო სტრიქონის სახელი; პირადი საბოლოო სტრიქონის გვარი; პირადი საბოლოო სტრიქონის ელფოსტა; პირადი მოთხოვნა კლიენტი (სტრიქონის სახელი, სტრიქონის გვარი, სტრიქონის ელფოსტა) ( this.firstName = firstName; this.lastName = გვარი; this.email = ელ. ) საჯარო სტატიკური RequestCustomer fromRequestParameters(HttpServletRequest მოთხოვნა) ( დააბრუნეთ ახალი RequestCustomer(request.getParameter("სახელი"), request.getParameter("გვარი"), request.getParameter("email")); ) public void setAsRequettRequestpstAtributor ( request.setAttribute ("სახელი", სახელი); request.setAttribute ("გვარი", გვარი); request.setAttribute("ელ.ფოსტა", ელფოსტა); ) საჯარო სია validate() ( სიის დარღვევები = ახალი ArrayList<>(); if (!StringValidator.validate(firstName)) ( დარღვევები.add("სახელი სავალდებულო ველია"); ) if (!StringValidator.validate(lastName)) ( დარღვევები.add("გვარი სავალდებულო ველია") ; ) if ( !EmailValidator.validate(email)) ( დარღვევები.add("ელ.ფოსტა უნდა იყოს კარგად ჩამოყალიბებული"); ) დააბრუნოს დარღვევები; ))))

პირველი, რაც აქ უნდა შეამჩნიოთ, არის @WebServlet (სახელი ="CustomerController", urlPatterns = "/processcustomer") ანოტაციის გამოყენება. ის ეუბნება servlet კონტეინერს გამოიყენოს CustomerController კლასი HTTP მოთხოვნების დასამუშავებლად /processcustomer-ისთვის. იგივე ეფექტის მიღწევა შესაძლებელია servlet-ის რუკების დირექტივების დამატებით web.xml-ზე, როგორიცაა , მაგრამ რადგან ჩვენ ვიყენებთ Servlet Specification 3.1, არ გვჭირდება ამ მეთოდის გამოყენება.

აქ ჩვენ დავასახელეთ servlet CustomerController, რადგან მიჩნეულია კარგ პრაქტიკად გამოიყენოს servlet კლასის სახელი @WebServlet ანოტაციის სახელის ატრიბუტის მნიშვნელობად. წინააღმდეგ შემთხვევაში, ზოგიერთი კონტეინერი ვერ ემთხვევა, რაც გამოიწვევს 404 შეცდომას.

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

Validators არის მარტივი კლასები, რომლებიც ამოწმებენ გარკვეულ თვისებებს, როგორიცაა ცარიელია თუ არა ელ. ფოსტა ელფოსტას. ავტორის GitLab-ზე შეგიძლიათ ნახოთ მათი განხორციელება.

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

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

აპლიკაციის გაშვება

აპლიკაციის გასაშვებად, თქვენ უნდა შეასრულოთ შემდეგი ნაბიჯები:

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

დასკვნა

ასე რომ, თქვენ შეიძინეთ ყველა ის უნარი, რაც გჭირდებათ თქვენი საკუთარი Java ვებ აპლიკაციის შესაქმნელად რთული ჩარჩოების გამოყენების გარეშე. ყველაფერი რაც თქვენ გჭირდებათ არის Servlet API, ტექნოლოგია, როგორიცაა JSP რენდერისთვის და ჩაშენებული ჯავის საშუალებები. მშვენიერია, არა?

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

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

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

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

Servlet ვებ აპლიკაციების არქიტექტურაში

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

Servlet როგორც პროქსი

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

დროებითი და მუდმივი სერვლეტი"ს

Servlets შეიძლება დაიწყოს და შეჩერდეს ყველა კლიენტის მოთხოვნით. მათი გაშვება ასევე შესაძლებელია ვებ სერვერის გაშვებისას და არსებობს მის გაჩერებამდე. დროებითი სერვლეტი"s იტვირთება მოთხოვნით და გვთავაზობს კარგ გზას სერვერის რესურსების შესანახად იშვიათად გამოყენებული ფუნქციებისთვის. მუდმივი სერლეტები იტვირთება, როდესაც ვებ სერვერი იწყება და გრძელდება მის გაჩერებამდე. Servlets დაინსტალირებულია როგორც მუდმივი გაფართოებები სერვერზე, თუ დაწყების ღირებულებაა. ისინი ძალიან მაღალია (მაგ. მონაცემთა ბაზასთან კავშირის დამყარება), თუ ისინი გვთავაზობენ მუდმივ ფუნქციონირებას სერვერის მხარეს (მაგ. RMI სერვისი), ან იმ შემთხვევებში, როდესაც მათ უნდა უპასუხონ კლიენტის მოთხოვნებს რაც შეიძლება სწრაფად. არ არსებობს კონკრეტული კოდი, რომელიც მინიჭებაა. სერვლეტი"მაგრამ მუდმივი ან დროებითი; ეს არის ვებ სერვერის დაყენების ფუნქცია.

Servlet lifecycle, javax.servlet.Servlet

Servlets მუშაობს ვებ სერვერის პლატფორმაზე, როგორც იგივე პროცესის ნაწილი, როგორც თავად ვებ სერვერი. ვებ სერვერი პასუხისმგებელია თითოეული სერვლეტის ინსტანციის ინიციალიზაციაზე, გამოძახებაზე და განადგურებაზე. ვებ სერვერი ურთიერთქმედებს სერლეტთან მარტივი ინტერფეისის საშუალებით: javax.servlet.servlet.

javax.servlet.Servlet ინტერფეისი მოიცავს სამ ძირითად მეთოდს:

• მასში()
• მომსახურება ()
• განადგურება ()

და ორი დამხმარე მეთოდი:

• getServletConfig()
• getServletInfo ()

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

Servlet ინიციალიზაცია, init() მეთოდი

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

გარანტირებულია, რომ მეთოდი მასში()დასრულდება სერვლეტზე ნებისმიერი სხვა ზარის წინ, როგორიცაა მეთოდის გამოძახება მომსახურება (). გაითვალისწინე მასში()გამოიძახება მხოლოდ ერთხელ; ის არ გამოიძახება მანამ, სანამ სერვლეტი არ განიტვირთება და შემდეგ ისევ არ ჩაიტვირთება სერვერის მიერ.

მეთოდი მასში()იღებს ერთ არგუმენტს - მითითებას ობიექტზე ServletConfig, რომელიც შეიცავს არგუმენტებს სერლეტის ინიციალიზაციისთვის. ამ ობიექტს აქვს მეთოდი getServletContext(), რომელიც აბრუნებს ობიექტს ServletContext A, რომელიც შეიცავს ინფორმაციას servlet გარემოს შესახებ.

Servlet core, service() მეთოდი

მეთოდი მომსახურება ()არის სერლეტის გული. კლიენტის თითოეული მოთხოვნა იწვევს ერთი მეთოდის გამოძახებას მომსახურება (). ეს მეთოდი კითხულობს მოთხოვნას და ქმნის საპასუხო შეტყობინებას მისი ორი არგუმენტის ServletRequest და ServletResponse გამოყენებით:

ამრიგად, კლიენტიდან სერვლეტზე ინფორმაციის გადაცემის ორი გზა არსებობს. პირველი არის მოთხოვნის პარამეტრებში მნიშვნელობების გადაცემა. პარამეტრების მნიშვნელობები შეიძლება ჩასმული იყოს URL-ში. კლიენტიდან სერვლეტზე ინფორმაციის გადაცემის მეორე გზა არის InputStream (ან Reader) მეშვეობით.

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

Servlet-ის გადმოტვირთვა, destroy() მეთოდი

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

მნიშვნელოვანია მეთოდის ფორმალიზება განადგურება ()ისე, რომ თავიდან აიცილოს საჭირო რესურსების დახურვა ყველა გამოძახებამდე მომსახურება ()არ დასრულდება.

Servlet კონფიგურაცია, getServletConfig() მეთოდი

მეთოდი getServletConfig()აბრუნებს მითითებას ობიექტზე, რომელიც ახორციელებს ინტერფეისს ServletConfig. ეს ობიექტი უზრუნველყოფს წვდომას სერვლეტის კონფიგურაციის ინფორმაციაზე, ე.ი. წვდომა servlet ინიციალიზაციის პარამეტრებზე და servlet კონტექსტის ობიექტზე ServletContext, რომელიც იძლევა წვდომას სერლეტზე და მის გარემოზე.

Servlet info, getServletInfo() მეთოდი

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

ServletRequest ინტერფეისი

ServletRequest აწვდის კლიენტის ინფორმაციას HTTP მოთხოვნის პარამეტრების შესახებ servlet-ს, ე.ი. უზრუნველყოფს მონაცემებს პარამეტრის სახელისა და მნიშვნელობების, ატრიბუტებისა და შეყვანის ნაკადის ჩათვლით. ეს ინფორმაცია გადაეცემა მეთოდს მომსახურება ().

შემდეგი სერლეტის მაგალითიგვიჩვენებს, თუ როგორ უნდა მიიღოთ ინფორმაცია პარამეტრიდან მოთხოვნამეთოდი მომსახურება ():

BufferedReader მკითხველი; სიმებიანი param1; სიმებიანი param2; საჯარო ბათილი სერვისი (ServletRequest მოთხოვნა, ServletResponse პასუხი) ( reader = request.getReader(); param1 = request.getParameter ("პირველი"); param2 = request.getParameter ("მეორე"); )

დამატებითი ინფორმაცია მოთხოვნის შესახებ ხელმისაწვდომია სერვლეტისთვის მეთოდების საშუალებით, ძირითადი მათგანი ჩამოთვლილია შემდეგ ცხრილში:

ServletResponse ინტერფეისი

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

საჯარო java.lang.String getCharacterEncoding() public void setLocale(java.util.Locale loc) public java.util.Locale getLocale()

პირველი მეთოდი აბრუნებს MIME კოდირების ტიპს (მაგალითად, UTF8), რომელშიც ნაჩვენები იქნება ინფორმაცია. მეორე ორი მეთოდი ასევე მუშაობს charset-თან. ისინი მიუთითებენ დოკუმენტში გამოყენებული ენაზე (მაგალითად - რუსული).

Public ServletOutputStream getOutputStream() აგდებს java.io.IOException

getOutputStream მეთოდი აბრუნებს სერვლეტის გამომავალ ნაკადს. ეს ნაკადი გამოიყენება, მაგალითად, ორობითი ფაილების გამოსატანად. ტექსტური მონაცემების გამოტანა შესაძლებელია java.io.Writer-ის გამოყენებით:

საჯარო java.io.PrintWriter getWriter() აგდებს java.io.IOException

getWriter() მეთოდი ავტომატურად გარდაქმნის სტრიქონებს getCharacterEncoding() და getLocale() მეთოდებში მითითებულ სიმბოლოებში.

საჯარო void setContentLength(int len)

setContentLength მეთოდი ადგენს HTTP სათაურის ველის მნიშვნელობას "Content-Length"

საჯარო void setContentType (სტრიქონის ტიპი)

setContentType მეთოდი გამოიყენება დოკუმენტის MIME კონტენტის ტიპის გასაგზავნად. HTTP სათაურის ველი "Content-Type".

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

საჯარო void setBufferSize(int size) public int getBufferSize() public void flushBuffer() აგდებს java.io.IOException საჯარო void resetBuffer()

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

საჯარო ლოგიკური isCommitted()

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

საჯარო void reset()

თუ HTTP სათაური ჯერ არ არის გაგზავნილი, მაშინ გადატვირთვის მეთოდი „გადააბრუნებს“ HTTP სათაურს ნაგულისხმევ მნიშვნელობებზე.

JFreeChart დიაგრამები Servlets-ში

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

Servlet გრაფიკული ბიბლიოთეკით Chart.js

JNI სერვლეტში

ზოგიერთ შემთხვევაში, შეიძლება დაგჭირდეთ JNI-ის გამოყენება WEB აპლიკაციაში. წარმოდგენილია JNI სერვლეტებში გამოყენების მაგალითი.

JMS შეტყობინებები სერვლეტში

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

Java Servlet არის სერვერის მხარეს პროგრამა დაწერილი ამავე სახელწოდების პროგრამირების ენაზე, რომელიც იღებს სიგნალებს კლიენტისგან და აგზავნის პასუხებს მასზე. ეს არის ძირითადი ელემენტი, რომელიც აყალიბებს ტიპიურ Java EE-ს, გარდა JSP, EJB, XML და სხვა დაკავშირებული ტექნოლოგიებისა. აპლიკაცია შეიძლება შეფუთული იყოს WAR (Web AR chive) ფაილში ვებ სერვერზე განსათავსებლად. სერვერს, რომელსაც შეუძლია Java servlet-ის გაშვება, ეწოდება კონტეინერი. პროგრამას, რომელიც მუშაობს ასეთ სერვერზე, შეუძლია შექმნას დინამიური ვებ გვერდები.

Java Servlet საფუძვლები

ყველაზე პოპულარული და ფართოდ გამოყენებული კონტეინერებია Tomcat და JBoss. ტექნიკურად, Servlet არის ნორმალური Java კლასი, რომელსაც აქვს გაფართოება საერთო კლიენტის/სერვერის პროტოკოლისთვის, ან HTTP. პრაქტიკაში, ის გამოიყენება მოთხოვნების დასამუშავებლად, შესაბამისად HttpServlet GET და POST გადაფარვის საშუალებით. Java Servlet კონტეინერი უზრუნველყოფს Http.ServletRequest და Http.ServletResponse, რომლებიც მოთხოვნა-პასუხის ობიექტებია. და ჩვეულებრივ გამოიყენება JSP-თან ერთად დინამიური შინაარსის შესაქმნელად.

ტიპიური მოდელის სცენარი:

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

ფილტრებით შესასრულებელი საერთო ამოცანები:

ფილტრები შედის და კონფიგურირებულია განლაგების აღწერის ფაილში (web.xml). Servlets და ფილტრები არ იციან ერთმანეთის შესახებ, ასე რომ თქვენ შეგიძლიათ დაამატოთ ან ამოიღოთ ფილტრი უბრალოდ web.xml-ის რედაქტირებით. მისაღებია გქონდეთ მრავალი ფილტრი ერთი რესურსისთვის, ან ჯაჭვის ფილტრები web.xml-ისთვის, ან Java Servlet ფილტრების გაშვება javax.servlet.Filter ინტერფეისის დანერგვით.

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

ძირითადი ფუნქციები:

დინამიური ვებ გვერდების საჭიროება

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

ბევრ მომხმარებელს აქვს გამოცდილი Java ტექნოლოგიის გამოყენება CGI-ზე დაფუძნებული ვებ სერვისების შესაქმნელად, მაგრამ Java Servlets უფრო ეფექტური, მძლავრი, მარტივი გამოსაყენებელი და ნაკლებად ძვირია, ვიდრე ტრადიციული CGI ალტერნატივები.

Java Servlets-ის უპირატესობები:

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

თქვენი ქვაბი ირჩევს ჯავას

თავად Oracle-ის თქმით, დღეს ვირტუალურია ჯავას მანქანადაინსტალირებულია სამ მილიარდზე მეტ მოწყობილობაზე. და ეს არ არის მხოლოდ კომპიუტერები და სმარტფონები, არამედ კამერები, ტელევიზორები, Blue-ray ფლეერები, პრინტერები, SIM ბარათები, ბანკომატები და მანქანებიც კი. ეს სია სტაბილურად გაიზრდება და მასთან ერთად სამუშაო შეთავაზებები Java პროგრამისტებისთვის. ახლაც ჯავის პროგრამისტების ვაკანსიების რაოდენობა დანარჩენს აჭარბებს. კომპანიები კი მზად არიან გადაიხადონ უფრო და უფრო მეტი, ბრაკონიერობენ თანამშრომლებს და აწყობენ უფრო ხელსაყრელ სამუშაო პირობებს.

და რატომ არის ის კარგი?

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

აბა, დავიწყოთ

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

მონაცემთა ტიპები შეიძლება დაიყოს ორ ჯგუფად: მარტივი (int, long, char და ასე შემდეგ) და ობიექტის ტიპები: კლასები, ინტერფეისები, მასივები. მარტივი ტიპები ყოველთვის და ყველგან არის ფიქსირებული განზომილების. მაგალითად, ნებისმიერ არქიტექტურაზე და ნებისმიერ მოწყობილობაზე, int იკავებს მეხსიერების ოთხ ბაიტს. ეს საკმაოდ მოსახერხებელია გამოთვლებისთვის. მონაცემთა მასივი შეიცავს სპეციალურ სიგრძე ატრიბუტს, რომელიც ინახავს მასივის ზომას, რისთვისაც განსაკუთრებული მადლობა დეველოპერებს. სხვადასხვა ტიპის მონაცემები სხვადასხვა გზით გადაეცემა მეთოდებს. მარტივი ტიპები ყოველთვის გადადის მნიშვნელობით. ობიექტი - ყოველთვის მითითებით მეხსიერების შესანახად. ეს ნიშნავს, რომ თუ ჩვენ გადავცემთ int a = 10-ს და შევცვლით მის მნიშვნელობას 5-ზე გამოძახებულ მეთოდში, მაშინ a კვლავ იქნება 10 ორიგინალურ მეთოდში, მაგრამ თუ შევცვლით ობიექტის თვისებას, ის შეიცვლება ორიგინალურ მეთოდში, როგორც კარგად.

გაიხსენე მეხსიერება

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

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

ბევრი პროგრამისტი, როდესაც ისინი გადადიან Java-ზე და სწავლობენ მეხსიერების ავტომატური გაწმენდის შესახებ, იწყებენ ობიექტების შექმნას უზარმაზარი რაოდენობით, იმ იმედით, რომ ეს ყველაფერი თავისთავად გაიწმინდება. იმავდროულად, ნაგვის შემგროვებელი მანქანას ჰგავს, რომელსაც შეუძლია მხოლოდ სახლის მახლობლად ურნაში გადაყრილი ნაგვის აყვანა. თუ აღარ გჭირდებათ გარკვეული მონაცემები, არ უნდა შეინახოთ ისინი ყოველი შემთხვევისთვის, როგორც ძველი ღია ბარათების გროვა - მიანიჭეთ null მონაცემთა მაჩვენებელს, დაეხმარეთ დამლაგებელს გაწმენდაში :). ასევე კარგი პრაქტიკაა სიის გასუფთავება, თუ ის აღარ გჭირდებათ. დაიმახსოვრე, ობიექტი ინახება მეხსიერებაში მანამ, სანამ მასზე მითითებები იქნება კოდში. მაშინაც კი, თუ თქვენი პროგრამა მუშაობს 16 გიგაბაიტიან მეხსიერებაზე და არ ემუქრება მეხსიერების გაფუჭება, ის უფრო და უფრო მოუხერხებელი და ნელი გახდება გამოყენებული მეხსიერების ჭარბი რაოდენობით. 99% მომხმარებელთა საჩივრების ნელი Java პროგრამების გამო არაეფექტიანად დაწერილი საწყისი კოდი. თუ თქვენ გჭირდებათ მუდმივად შექმნათ ობიექტები, რომლებიც გამოიყენება სწრაფად და აღარ არის საჭირო, მაგალითად, ბევრი პატარა შეტყობინება, განიხილეთ აუზის შექმნა, რომელიც შეინახავს უამრავ მაგალითს განმეორებითი გამოყენებისთვის. გახსოვდეთ, ობიექტის შექმნა და წაშლა ძვირადღირებული ოპერაციაა.

იმუშავეთ, ბატონებო.

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

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

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

• https://developer.foursquare.com/docs/users/checkins - მომხმარებლების მიერ მონახულებული ადგილები. სამწუხაროდ, ამჟამად ის მხარდაჭერილია მხოლოდ პროგრამაში რეგისტრირებული მომხმარებლისთვის და არის ჭორები, რომ დანერგვის შეზღუდვის გამო, ასე დარჩება;
• https://developer.foursquare.com/docs/checkins/recent - ადგილები, რომლებსაც სტუმრობენ რეგისტრირებული მომხმარებლის მეგობრები. თუ ცოტას ითამაშებ ამ ფუნქციით, მაშინ გამოდის სამწუხარო ფაქტი: თითოეულ მეგობარს უბრუნდება ზუსტად ერთი ადგილი - ბოლო ადგილი, სადაც მან საკუთარი თავი შეამოწმა.

Foursquare API-ს გამოსაყენებლად, თქვენ უნდა დაარეგისტრიროთ ჩვენი მომავალი აპლიკაცია, გადადით ამ მისამართზე: https://ru.foursquare.com/developers/register და შეავსეთ ველები (დიახ, თქვენ ასევე მოგიწევთ დარეგისტრირება თავად foursquare-ში, მაგრამ შენ ეს მშვენივრად შეგიძლია ჩემს გარეშე).

მნიშვნელოვანი ველებიდან აქ შეიძლება აღინიშნოს მხოლოდ „აპლიკაციის სახელი“, „ჩამოტვირთვა / მისასალმებელი გვერდის url“ (შეიყვანეთ აქ თვითნებური ვებ მისამართი) და „გადამისამართების URI(s)“ - ეს არის მისამართი, რომელზეც სერვერი გამოგვიგზავნის. რეგისტრაციის შემდეგ. ჩვენ შევიყვანთ სასურველ მნიშვნელობას აქ მოგვიანებით, მაგრამ ამ დროისთვის შეგიძლიათ უბრალოდ შეიყვანოთ ნებისმიერი ვებ მისამართი. დააჭირეთ "შენახვას" და ჩვენი ტრეკერის აპლიკაცია წარმატებით დარეგისტრირდა.

ღრუბლებში ავდივართ

კაპიტანი აშკარა გადმოგვცემს, რომ ნებისმიერ სერვერულ აპლიკაციას სჭირდება სერვერი სამუშაოდ. სერვერის დამოუკიდებლად ამაღლება არის ბუასილი, ამიტომ ჩვენ გამოვიყენებთ ღრუბლოვან გადაწყვეტილებებს, რომლებიც ახლა პოპულარულია. ღრუბელი დაფინანსებული იქნება Google Corporation-ის მიერ, რადგან მათი Google App Engine უფასოა, საკმაოდ მარტივი დასაყენებლად და გამოსაყენებლად. დასაწყებად, გადადით აქ და ჩამოტვირთეთ Google App Engine SDK Java-სთვის.

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

მოდით ავირჩიოთ ახალი Java პროექტი. მოდით ვუწოდოთ მას nsa_tracker.

შემდეგ ჩანართზე, მარცხნივ მონიშნეთ Web Application და Google App Engine და მიუთითეთ გზა ადრე ჩამოტვირთული და გაუფუჭებული App Engine SDK-მდე.

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

ჩვენ ვიწყებთ ძებნას

ამრიგად, ჩვენ გვაქვს პროექტის საქაღალდე, რომელიც შეიცავს src საქაღალდეს. ეს არის სადაც ჩვენ დავაყენებთ წყაროს კოდს. წყაროები ჯავაში დაჯგუფებულია პაკეტების მიხედვით. პაკეტი არის საქაღალდე დისკზე. პაკეტები საჭიროა იმისათვის, რომ ყველა წყარო გროვად კი არ გადაყაროთ, არამედ განცალკევოთ ისინი, ლოგიკის პრინციპებით ხელმძღვანელობით. მაგალითად, მომხმარებლის ინტერფეისთან დაკავშირებული კოდი ლოგიკურად განთავსდება ui პაკეტში, ქსელის ურთიერთქმედებები ქსელის პაკეტში. ეს მნიშვნელოვნად უწყობს ხელს პროექტის შემდგომ განვითარებას და მხარდაჭერას. ისტორიულად პრაქტიკა იყო პაკეტის სტრუქტურის დაწყება კომპანიის სახელით, რასაც მოჰყვება პროგრამის სახელი. ეს დაგეხმარებათ მომავალში ადვილად ამოიცნოთ ჩვენი წყაროები იმავე წყაროებს შორის. ჩვენი პროგრამისთვის ჩვენ შევქმნით org.nsa.tracker პაკეტს. მასში ჩვენ შევქმნით კლასებს.

Servlets გამოიყენება სერვერზე მომხმარებლის მოთხოვნების დასამუშავებლად. servlet არის კლასი, რომელიც ჩვეულებრივ მემკვიდრეობით იღებს HttpServlet-ს და მუშაობს მოთხოვნა-პასუხის საფუძველზე. ყველაფერი რაც საჭიროა არის doGet მეთოდის უგულებელყოფა. მომხმარებლის მოთხოვნით, ჩვენ უნდა შეხვიდეთ ოთხკუთხედში, ჩატვირთოთ მეგობრების რეგისტრირების სია და გადამისამართოთ მოთხოვნა რუკის გვერდზე.

Foursquare API-სთან მუშაობისთვის ჩვენ გამოვიყენებთ უფასო foursquare-api-java ბიბლიოთეკას, რომლის აღებაც შესაძლებელია აქედან. Java ბიბლიოთეკა არის ZIP არქივი jar გაფართოებით, რომელიც შეიცავს შედგენილ Java კლასებს, რომლებიც ახორციელებენ გარკვეულ ფუნქციებს. ავტორიზაციისთვის გვჭირდება ClientId და ClientSecret, რომლებიც მიღებულია განაცხადის ოთხკუთხედში რეგისტრაციის ეტაპზე. ვინაიდან ეს პარამეტრები არ იცვლება პროგრამის შესრულებისას, ჩვენ მათ ვაცხადებთ მუდმივებად.

პირადი სტატიკური საბოლოო სტრიქონი CLIENT_ID = "FAKE_CLIENT_ID"; პირადი სტატიკური საბოლოო სტრიქონი CLIENT_SECRET = "FAKE_CLIENT_SECRET";

საბოლოო ნიშნავს, რომ ამ ცვლადს მინიჭებული აქვს საბოლოო მნიშვნელობა, რომლის შეცვლა შეუძლებელია. Static ცვლადს ხელმისაწვდომს ხდის მოცემული კლასის ყველა ინსტანციისთვის. ავტორიზაციის მაგალითის გამოყენებით foursquare-api-java ბიბლიოთეკიდან, ჩვენ ვიღებთ შემდეგ კოდს:

დაცული void doGet(HttpServletRequest req, HttpServletResponse resp) ისვრის ServletException, IOException ( FoursquareApi foursquareApi = new FoursquareApi(CLIENT_ID, CLIENT_SECRET, CALLBACK_URL =CALLBACK_URL); გადადით რეგისტრაციის გვერდზე resp.sendRedirect(foursquareApi.getAuthenticationUrl()); ) else (სცადეთ ( foursquareApi.authenticateCode(code); // რეგისტრაცია წარმატებულია, მონაცემების ატვირთვა შედეგი შედეგი = foursquareApi.checkinsRecent("0.0,0.0", 100, 0ლ); ) catch (FoursquareApiException e) ( e.printStackTrace(); ) ) )

ყურადღება მიაქციეთ "ისვრის ServletException, IOException" მეთოდის დეკლარაციაში. ეს ხაზი ნიშნავს, რომ მეთოდს შეუძლია პოტენციურად ჩამოაგდოს ერთ-ერთი გამონაკლისი. ჯავაში გამონაკლისი არის ობიექტი, რომელიც მიანიშნებს, რომ გამონაკლისი მოხდა. ისინი შემოწმებადი და შეუმოწმებელია. მონიშნული გამონაკლისები უნდა დამუშავდეს კოდის მიმდებარე ნაწილის მიერ try-catch ბლოკით, ან გადაეცეს ზემოთ. მონიშნული გამონაკლისები, როგორც წესი, არ განიხილება, რადგან ისინი წარმოიქმნება მაშინ, როდესაც პროგრამას არ შეუძლია მისი მდგომარეობის აღდგენა. ამ მეთოდით, ჩვენ ვმუშაობთ მხოლოდ FoursquareApiException.

როდესაც ვებ სერვერი იღებს მოთხოვნას აპლიკაციის შესახებ, ის იყენებს განლაგების აღწერს, რათა შეესაბამებოდეს მოთხოვნის URL კოდს, რომელიც უნდა ამუშავებდეს მოთხოვნას. განლაგების აღმწერი არის XML ფაილი, რომელსაც ეწოდება web.xml. მოდით დავამატოთ თვალთვალის სერლეტის აღწერა.

სიმღერა org.nsa.tracker.TrackerServlet სიმღერა /ტრეკი

ახლა /track-ის მოთხოვნა დამუშავდება ჩვენი სერვლეტის მიერ, სახელად TrackerServlet. თქვენ შეგიძლიათ დააყენოთ Callback Url პარამეტრი სწორ მნიშვნელობაზე http://localhost:8080/track.

შედეგების საჩვენებლად შეგიძლიათ გამოიყენოთ Static Maps API, რომელიც მოწოდებულია იმავე Google-ის კორპორაციის მიერ (https://developers.google.com/maps/documentation/staticmaps/). ჩვენი servlet გამოიმუშავებს მარტივ HTML გვერდს და დააბრუნებს მას მომხმარებლის მოთხოვნის საპასუხოდ.

StringBuilder sb = ახალი StringBuilder(" "); sb.append(" "); sb.append("

"); ინდექსი = 1; for (Checkin checkin: result.getResult()) (sb.append(" ").append(index++).append(" - ").append(checkin.getUser().getFirstName()) .append(" ").append(checkin.getUser().getLastName()).append(""); ) sb.append("

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

ბაიტი resultBytes = sb.toString().getBytes("utf-8"); resp.setContentLength(resultBytes.length); resp.getOutputStream().write(resultBytes);

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

Რა არის შემდეგი?

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

მაგრამ იმედია მოვახერხე მთავარი: დაგარწმუნოთ, რომ ჯავა მარტივი და მაგარია. გნახავ ერთ თვეში!

წიგნები Java პროგრამისტისთვის

გირჩევთ, ენის სწავლა დაიწყოთ წიგნით „ჯავა. ჯავა: დამწყებთათვის სახელმძღვანელო ჰერბერტ შილდტი. შემდეგი დონე არის "ჯავა. სრული სახელმძღვანელო” მისგან და შეგიძლიათ გაიგოთ მეტი სერლეტების შესახებ ბრიუს უ. პერის მიერ Java Servlet და JSP Cookbook-ში.