პროგრამების შექმნა Java-ში Servlets-ის დახმარებით. ჯავა. HTTP პროტოკოლი და WEB Java servlet და ვებ კონტეინერი

გოლოვნა / დამატებითი ფუნქციონირება

რა არის სერლეტები? სერვლეტები, სერვერები, მოდულები HTTP და FTP მოთხოვნების დასამუშავებლად, პორტალების გამოძახებისთვის (ვებ კარიბჭე).

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

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

მცირე დიაგრამა აჩვენებს მოთხოვნის (მოთხოვნის) და პასუხების (პასუხის) გადაცემას სერვერსა და სერლეტებს შორის. ქიას სქემამე წარმოვადგენ HTTP სერვერის მუშაობას, რომელიც შეიძლება შეიცავდეს JSP გვერდებს და ორ რესურსს "/sample1" და "/sample2", ამ ორი სერვლეტის დამუშავებისთვის - "Sample1 Servlet" და "Sample2 Servlet" ჩანს.

Rozberemo pokrokovo ისინი, რომლებიც ასახავს პატარას:

  1. კლიენტი მოდის სერვერზე
  2. სერვერი აგზავნის მოთხოვნას ძირითად სერვლეტზე ("ძირითადი სერვლეტი")
  3. ძირითადი სერვლეტმა დაკარგა URI რესურსს
    • თუ URI მიუთითებს "/sample1", ის ითხოვს მეტი(ცვლილების გარეშე) გადაეცემა "Sample1 Servlet" სერვლეტს, რომელიც იგზავნება და მუშავდება მოთხოვნით
    • თუ URI მიუთითებს "/sample2-ზე", სერვერი აგზავნის მოთხოვნას "Sample2 Servlet" სერვლეტზე.
    • სხვა შემთხვევაში მოთხოვნა გადაეცემა "JSP Servlet" მოდულს
  4. სერვლეტი, რომელზეც გადაეცა კონტროლი, ამუშავებს მონაცემებს, ქმნის პასუხს (პასუხს), რის შემდეგაც პასუხი იძულებულია დაბრუნდეს საბაზისო სერვლეტში.
  5. საბაზისო სერვლეტი, ნუ დაამუშავებთ მონაცემებს უკან, დაუყოვნებლივ გაუგზავნეთ სერვერს
  6. სერვერი ხედავს კლიენტის მონაცემებს

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

Servlet ინტერფეისი

შეუთავსეთ ყველა ეს მოდული, რომლებიც ერთმანეთის ირგვლივ სუნიან, რათა დაეხმაროს javax.servlet.Servlet ინტერფეისს

მოდით შევხედოთ ამ ინტერფეისს. ახალს აქვს სულ 5 მეთოდი:

საჯარო void init(ServletConfig config) ავრცელებს ServletException ეს მეთოდი გამოძახებულია სერვლეტის ინფორმირებისთვის მათ შესახებ, რომლებიც შედის კლიენტის მოთხოვნის სერვისის მოდულში. კონფიგურაციის პარამეტრი აფართოებს javax.servlet.ServletConfig ინტერფეისს, რომელიც შეიცავს ინფორმაციას სერვერის შესახებ, სერვლეტის სახელს, ძირითად პარამეტრებს და სხვა სიკეთეებს. javax.servlet.ServletConfig ინტერფეისი იქნება განხილული ცოტა შემდგომ. მიღებულია, რომ ფუნქციის გამოძახების შემდეგ, სერვლეტი ყურადღებით ინახავს კონფიგურაციას ცვლილებაში და იხილეთ სხვა მეთოდის დასახმარებლად: საჯარო ServletConfig getServletConfig() შექმნა, სხვა ინფორმაცია სერლეტის შესახებ, რომელსაც შეუძლია მიაღწიოს საჯარო სიმებიანი getServletInfo() ზარი

მოთხოვნის დამუშავება და დამუშავების შედეგის აღება ფუნქცია

საჯარო ბათილობის სერვისი (ServletRequest მოთხოვნა, ServletResponse პასუხი) აგზავნის ServletException, java.io.IOException ამ ფუნქციაში, ორი ინსტრუმენტი გადაეცემა კოდს მონაცემების დასამუშავებლად: ერთი არის ამ ტიპის სერვერების მოსაძიებლად, მეორე არის რედაქტირებისთვის. სერლეტ რობოტის შედეგი. როგორც ჩანს, მოთხოვნის და პასუხის პარამეტრები გამოყოფს javax.servlet.ServletRequest და javax.servlet.ServletResponse ინტერფეისებს.

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

Public void death() რომელიც ამთავრებს ყველა ოპერაციას servlet ობიექტზე.

ServletConfig ინტერფეისი

4 მეთოდი, რომელთა სახელები თავისთავად საუბრობს, ქმნის javax.servlet.ServletConfig ინტერფეისის არსს:

საჯარო სტრიქონი getServletName() საჯარო ServletContext getServletContext() საჯარო სტრიქონი getInitParameter(სტრიქონის სახელი) java.util.Enumeration getInitParameterNames()

ვფიქრობ, ყველა ფუნქციის აღიარება იყო გონივრული, კრიმინალი

Public ServletContext getServletContext() ეს მეთოდი რთავს იმავე ძირითად ინსტრუმენტს სერვერთან მუშაობისთვის:

ServletContext ინტერფეისი

ServletContext - ინტერფეისი, რომელიც უზრუნველყოფს წვდომას შემდეგ ძირითად ფუნქციებზე:

საჯარო ობიექტი getAttribute(სტრიქონის სახელი) public java.util.Enumeration getAttributeNames() public void setAttribute(სტრიქონის სახელი, ობიექტის ობიექტი) public void removeAttribute(სტრიქონის სახელი) Chotiri მეთოდები ატრიბუტებთან მუშაობისთვის. ატრიბუტების როლი vikonuє არის თუ არა რომელიმე კლასის ობიექტი. ამ ფუნქციების მეტა არის გადაკვეთა სხვადასხვა ობიექტების არასავალდებულო სერლეტებს შორის. public String getInitParameter(string name) java.util.Enumeration getInitParameterNames() წვდომა პარამეტრებზე, როგორიცაა სერვერის გაშვება. აქ შეგიძლიათ იპოვოთ ჰოსტის სახელი, პორტი და სხვა პორტის ნომრები. public int getMajorVersion() public int getMinorVersion() შეამოწმეთ Servlet API-ის ვერსია. public String getMimeType(String ფაილი) აბრუნებს ფაილის MIME ასოციაციის ტიპს, გადადის შეცვლილ ფაილში მითითებულზე. გამოიცანით, როგორ მოხდა MIME-ის მიღება SimpleWEBServer პროგრამიდან და შეაფასეთ ეფექტურობა! public java.util.Set getResourcePaths() java.net.URL getResource(string path) აგზავნის java.net.MalformedURLException საჯარო InputStream getResourceAsStream(სტრიქონის ბილიკი) გადააქციეთ ბილიკები სერვერისთვის ხელმისაწვდომ რესურსებზე და თავად რესურსები URL-ს და გამოიყურებოდეს როგორც მონაცემთა ნაკადები. public RequestDispatcher getRequestDispatcher(გზა) საჯარო მოთხოვნის დისპეჩერი getNamedDispatcher(სახელი) RequestDispatcher არის ინსტრუმენტი სხვა რესურსის მოთხოვნისთვის. ეს ფუნქციები საჭიროა ამ რესურსებისთვის ხელსაწყოს ობიექტის შესარჩევად. ასე რომ, ვთქვათ, სერვლეტის კორპუსიდან "sample1" სერვლეტზე მოთხოვნების გადამისამართებისთვის შეგიძლიათ ეს გააკეთოთ: getServletConfig().getServletContext().getNamedDispatcher("sample1").forward(მოთხოვნა, პასუხი);

ზოგადად, RequestDispatcher კლასი მოიცავს მხოლოდ ორ მეთოდს:

საჯარო ბათილად გადამისამართება (ServletRequest მოთხოვნა, ServletResponse პასუხი) აგდებს ServletException, java.io.IOException საჯარო void მოიცავს (ServletRequest მოთხოვნა, ServletResponse პასუხი) აგდებს ServletException, java.io.IOException მაგალითად, servlet 1-ს აქვს კიდევ ერთი სიტყვა "ტესტი 1", შემდეგ ის მოუწოდებს მოიცავს ორს, რომელსაც აქვს სხვა სიტყვა "test 2". Servlet 2 უბრალოდ იყენებს სიტყვას "და". რობოტი სერვლეტ 1-ის შედეგია სტრიქონი "ტესტი 1 და ტესტი 2". საჯარო void log (string msg) სერვერის ჟურნალში ჩაწერა. საჯარო void ჟურნალი (სტრიქონის შეტყობინება, Throwable dropable) მიუთითეთ დამნაშავე და ფრაზა, რომელიც ჩაიწერება ჟურნალში სროლის წაშლის შემდეგ. public String getRealPath(string path) თარგმნეთ ბილიკის ტიპი "/index.html" to "http://host/contextPath/index.html" public String getServerInfo() დააბრუნეთ სერვერის სახელი. Public ServletContext getContext(String uripath) ეს მეთოდი საშუალებას იძლევა ServletContext გაცვალოს ერთი და იგივე სერვერის სხვადასხვა რესურსებს შორის. public String getServletContextName() ჩართეთ სერვლეტის სახელი, რომლის ობიექტი ეკუთვნის ServletContect ინტერფეისს.

ServletRequest ინტერფეისი

ServletRequest ინტერფეისი არის ინსტრუმენტი HTTP მოთხოვნიდან პარამეტრების მოსაძიებლად. ამ ინტერფეისს შეიძლება ჰქონდეს მეთოდები, რომლებიც იდენტურია ServletContext-ისთვის მიცემული სახელისა:

საჯარო ობიექტი getAttribute(სტრიქონის სახელი) public java.util.Enumeration getAttributeNames() public void setAttribute(სტრიქონის სახელი, ობიექტი o) public void removeAttribute(java.lang.String name) საჯარო სტრიქონი getServerName() საჯარო მოთხოვნაDispatcher getRequest

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

საჯარო სტრიქონი getCharacterEncoding() public void setCharacterEncoding(String env) java.io.UnsupportedEncodingException მუშაობა სიმბოლოების კოდირებით HTTP სათაურის ველებზე. ფუნქციები ადგენს CGI შეყვანის დეკოდირების მეთოდს პირველადი სიმბოლოს %NN ფორმიდან. მაგალითად, ზოგიერთი სტანდარტი არის KOI8-R, windows-1251 ან UTF-8 აუცილებელია კირიული სიმბოლოების გასაშიფრად. public int getContentLength() public String getContentType() კითხულობს "Content-Length", "Content-Type" ველებს HTTP მოთხოვნიდან. public jString getParameter(string name) public java.util.Enumeration getParameterNames() public string getParameterValues(string name) public java.util.Map getParameterMap() ფუნქციები ამ მნიშვნელობიდან HTTP სათაურის ველის მისაღებად. საჯარო ServletInputStream getInputStream() აგდებს java.io.IOException public java.io.BufferedReader getReader() აგდებს java.io.IOException Reader zastosovuetsya კითხვისთვის ტექსტური ინფორმაცია- vin ავტომატურად გაშიფვრავს რიგებს იმავე გზით მითითებულ სიმბოლოებამდე. პატივისცემა! J2EE ვერსია 1.3-ს აქვს შეცდომა: სიმბოლოს %25-ის გაშიფვრისას (% სიმბოლო Post and Get მოთხოვნაში), Reader ხედავს შეწყალებას (შენიშვნების ხარვეზს Tomcat 4 და Resign სერვერებზე). შესაძლებელია, რომ მსგავსი ხარვეზის გამოყენება სხვა სიმბოლოებთანაც იყოს შესაძლებელი. public String getProtocol() მიიღეთ პროტოკოლის HTTP ვერსია მოთხოვნისთვის (მაგალითად, "HTTP/1.1"). public String getScheme() ჩართეთ სქემის სახელი. მაგალითად, "http", "https" ან "ftp". public int getServerPort() public string getRemoteAddr() public string getRemoteHost() საჯარო ლოგიკური isSecure() სერვერის პორტი, კლიენტის IP მისამართი, კლიენტის ჰოსტის სახელი და საიდუმლო რაოდენობა (HTTPS პროტოკოლზე) public java.util.Locale getLo java.util .Enumeration getLocales() იმ დოკუმენტის ლოკალიზაცია, რომელიც მოსალოდნელია კლიენტის მიერ ("Accept-Language" ველის დამუშავების შედეგი)

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 ჩართეთ გამომავალი ნაკადი სერვლეტისთვის. Tsey potik vikoristovuetsya, მაგალითად, სანახავად ბინარული ფაილები. ტექსტური მონაცემების ჩვენება შესაძლებელია java.io.Writer-ის დახმარებით: public java.io.PrintWriter getWriter() აგდებს java.io.IOException ეს მეთოდი ავტომატურად გარდაქმნის სტრიქონებს getCharacterEncoding() და getLocale() მეთოდებით მითითებულ სიმბოლოებში. საჯარო void setContentLength(int len) ეს მეთოდი ადგენს HTTP სათაურის ველის მნიშვნელობას "Content-Length" საჯარო void setContentType(string type) მეთოდი დოკუმენტში MIME ტიპის იძულებით. HTTP სათაურის ველი "Content-Type". საჯარო void setBufferSize(int size) public int getBufferSize() public void flushBuffer() აგდებს java.io.IOException საჯარო void resetBuffer() სწორედ იმით, რომ მონაცემთა ბუფერირება ხდება. ეს ნიშნავს, რომ ამ მონაცემების მომდევნო ნაწილს კლიენტი მხოლოდ ბუფერის შევსების შემდეგ ნახავს. მითითებული მეთოდები საშუალებას გაძლევთ, სურვილისამებრ, დააყენოთ რედაქტირების ბუფერის ზომა, ამოიღოთ რედაქტირების ბუფერი, განახორციელოთ რედაქტირება კლიენტის ბუფერში მონაცემთა ბუფერის შემოწმების გარეშე და ასევე გაასუფთავოთ მონაცემთა ბუფერი. public boolean isCommitted() ეს მეთოდი შეიძლება გამოყენებულ იქნას ენსიგნის მოსაძიებლად, რომელიც უკვე გაიგზავნა კლიენტს. დროშა დადებითი იქნება, რადგან HTTP სათაური უკვე გაგზავნილია. public void reset() მიუხედავად იმისა, რომ HTTP სათაური ჯერ არ არის კონტროლირებადი, ეს მეთოდი "გადააბრუნებს" HTTP სათაურს "დახურულ" მნიშვნელობამდე.

სერვლეტის ტიპები

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

ყველა ამ კლასის საფუძველია აბსტრაქტული კლასი javax.servlet.GenericServlet:

საჯარო აბსტრაქტული კლასი GenericServlet ახორციელებს Servlet, ServletConfig, java.io.Serializable

როგორც მინიჭებული კლასიდან ჩანს, Servlet და ServletConfig ინტერფეისების ყველა მეთოდის გამოყენება შესაძლებელია. მეთოდით არ ხორციელდება

საჯარო აბსტრაქტული ბათილობის სერვისი (ServletRequest req, ServletResponse res) ავრცელებს ServletException, java.io.IOException, რომელიც აბსტრაქტულია.

ამ კლასის საფუძველზე შეიქმნა კიდევ ერთი აბსტრაქტული კლასი - javax.servlet.http.HttpServlet:

საჯარო აბსტრაქტული კლასი HttpServlet აფართოებს GenericServlet ახორციელებს java.io.Serializable

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

დაცული ბათილად Dodelete (httpservletrequest req, httpservletresponse resp) აგდებს servletexception, java.io.ioexception დაცული ბათილიანი დოგეტი (httpservletrequest req,questrequestrequestrequestrequestrequestrequestrequestrequestrequestrequestreques, HttpServletRequest , ServletR esponse res) აგდებს ServletException, java.io.IOException სხვადასხვა სერვისის (ServletRequest req, ServletResponse res) ვარიანტები HTTP DELETE და GET სხვადასხვა მეთოდებისთვის PUT და TRACEG. HttpServletRequest და HttpServletResponse კლასების შექმნის სათაური, რომლებიც შედის HttpServlet პაკეტში javax.servlet.http დაცულია long getLastModified(HttpServletRequest req) ეს მეთოდი საათობრივად აქცევს HTTP-ის მნიშვნელობას vin-ის აღება ველიდან "D" ჰკითხეთ უფროსს. თუ ველი არ არის ნაჩვენები, გადაუხვიეთ -1.

შესაძლებელია HttpServletRequest და HttpServletResponse ინტერფეისების გარჩევა. სუნი არის ServletRequest და ServletResponse-ის უარყოფითი მხარე.

HttpServletRequest creme მეთოდები, რომლებიც ამცირებენ ServletRequest ტიპებს, შეიძლება იყოს მსგავსი მეთოდები:

Cookie getCookies() აბრუნებს კლიენტის მიერ სერვერზე გაგზავნილ ქუქიების კომპლექტს.

Cookie კლასი, რომელიც ეკუთვნის იმავე javax.servlet.http პაკეტს, შეიძლება შეიცავდეს ყველა ინფორმაციას ქუქიების შესახებ. ამ კლასის ყველაზე მნიშვნელოვანი მეთოდები

Int getMaxAge() სტრიქონი getName() სტრიქონი getValue() როგორც ჩანს, რამდენჯერ დაკარგა ქუქი-ფაილმა სიცოცხლე, ამ ქუქი-ფაილს აქვს ეს მნიშვნელობა. ასევე ქუქი (სტრიქონის სახელი, სტრიქონის მნიშვნელობა) void setValue (String newValue) void setMaxAge (int expiry) ქუქი-ფაილის დასაყენებლად, დააყენეთ მისი მაქსიმალური ასაკობრივი მნიშვნელობა. long getDateHeader (სტრიქონის სახელი) დააბრუნეთ თარიღი HTTP სათაურიდან, ასეც არის. int getIntHeader(java.lang.String name) აბრუნებს HTTP მოთხოვნის სათაურიდან დასახელებული ველის რიცხვით მნიშვნელობას String getMethod() აბრუნებს HTTP მოთხოვნის მეთოდს. სტრიქონი getQueryString() სტრიქონი getRequestURI() StringBuffer getRequestURL() აბრუნებს სტრიქონს, რომელიც უნდა მოიძებნოს დოკუმენტის URL-ში სიმბოლოს "?", დოკუმენტის URI და ამ URL-ის შემდეგ. HttpSession getSession() HttpSession getSession(ლოგიკური შექმნა) ლოგიკური isRequestedSessionIdFromURL() ლოგიკური isRequestedSessionIdValid() ფუნქციები. დაუშვით პრაქტიკა გადაცემის ისეთი ყველაზე მნიშვნელოვანი მექანიზმით, როგორიცაა სეანსი.

სესიები აუცილებელია იმისათვის, რომ ძნელად მიღებული მონაცემები გვერდიდან მეორეზე გადავიტანოთ. მაგალითად, koristuvach გადადით გვერდზე (1), გამოქვითეთ მონაცემები მხარისთვის (2) და ეს დაზოგავს მეტ მეტყველებას მხარისთვის (3).

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

თქვენ უბრალოდ შეგიძლიათ სხვაგვარად შეიმუშაოთ - დაამარცხეთ სესიების მექანიზმი. ამ სამუშაოს მექანიზმი ასეთია: მონაცემები, გაგზავნა შეტყობინება, სერვერის შენახვა okremu ფაილში - სესიის ფაილები. ამ ფაილში ყველა სამუშაო შესრულდება მონაცემების შესაცვლელად. კლიენტს შეუძლია ნახოს "სესიის გასაღები" (იგივე Session key, იგივე Sesseion ID) - უნიკალური ინდიკატორი ფაილისთვის, რომელსაც შეუძლია შური იძიოს ამ კორისტუვაჩისთვის. ახლა, იმისათვის, რომ აიღოს ყველა მონაცემი ნებისმიერი კლიენტისგან, სერვერმა უნდა იცოდეს მხოლოდ სესიის გასაღები. ამის პრიზი არის მისი გამარჯვების სიმტკიცე და სიჩქარე.

ღერძი და ყველა ძირითადი გზა HttpServletRequest ინტერფეისისთვის. ახალი სიაიხილეთ Java Servlet API დოკუმენტაცია მეთოდებისთვის.

ახლა HttpServletRequest ინტერფეისის შესახებ. მთავარი vіdminnіst klаіv, yakі razdіlyаyat tsey interfes, yоmu, scho vіdіvatsya v_drazu. ამავდროულად, განიხილება HTTP-დან ყველა მონაცემის შედგენა. მისი გადატვირთვა მოხდება მხოლოდ HttpServlet.service() სამუშაოს დასრულების შემდეგ.

ასე რომ, მეთოდების შესახებ:

Void addHeader(string name, string value) void addIntHeader(string name, int მნიშვნელობა) void addDateHeader(string name, long date) HTTP სათაურში პარამეტრების დამატების მეთოდი. დანარჩენი მეთოდი ადგენს "თარიღის" პარამეტრს. void addCookie(Cookie ქუქი) სათაურში ქუქი-ფაილის დამატების მეთოდი შეიცავს Header(სტრიქონის სახელი) საშუალებას გაძლევთ იცოდეთ რა უნდა იყოს მნიშვნელობის პარამეტრის სათაური. სიმებიანი encodeURL(სტრიქონის url) სტრიქონი encodeRedirectURL(სტრიქონის url) პირველი მეთოდია სიმბოლოების დაშიფვრა %NN-ის ჩანაცვლების დახმარებით. იგივე ზარის მოკვლის კიდევ ერთი მეთოდია void sendRedirect(string location) void setStatus(int sc) void sendError(int sc) void sendError(int sc, String msg) პირველი არის შემობრუნების კოდის დაყენება, დანარჩენი ორი არის გაგზავნეთ გაფრთხილება შეწყალების შესახებ. ინტერფეისში შესაძლებელია შემდეგი შესვენების დაყენება sc პარამეტრისთვის, რომელიც ემთხვევა HTTP პროტოკოლის შემობრუნების კოდებს: (303) SC_NOT_MODIFIED - სტატუსის კოდი (401) SC_UN - სტატუსის კოდი (404) SC_METHOD_NOT_ALLOWED - სტატუსის კოდი (405) SC_PTCE_NOT_ - სტატუსის კოდი (406) SC_PROXY_AUTHENTICATION_REQUIRED - სტატუსის კოდი (407) SC_REQUEST_TIMEOUT - სტატუსის კოდი (408) SC_CONFLICT - სტატუსი (409) SC_GONE - სტატუსის კოდი (410) SC_LECTION_REQUIRED - სტატუსის კოდი (411) SC_PRECONDITIONITION_FAILED - სტატუსის კოდი (412) კოდი (413) SC_REQUEST_URI_TOO_LONG - სტატუსის კოდი (414) SC_UNSUPPORTED_MEDIA_TYPE - სტატუსის კოდი (415) SC_REQUESTED_RANGE_NOT_SATISFIABLE - სტატუსის კოდი ( 416) სტატუსის კოდი ( 416) SC_EXPECTATION_ScTus-Code (416). ოდა (501) SC_BAD_GATEWAY - სტატუსის კოდი (502) SC_SERVICE_UNAVAILABLE - სტატუსის კოდი (503) SC_GATEWAY_TIMEOUT - სტატუსის კოდი (504) SC_HTTP_VERSION_NOT_SUPPORTED - სტატუსის კოდი (505)

Axis და ყველაფერი, რისი თქმაც შეგიძლიათ HttpServletResponse-ის შესახებ

სერვლეტების გამოყენება WEB დანამატებში

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

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

ჯავას იმპორტი. იო.*; javax-ის იმპორტი. სერლეტ.*; javax-ის იმპორტი. სერვლეტი. http.*; ჯავას იმპორტი. გამოყენება. zip.*; // servlet ერთად HttpServlet backbackსაჯარო კლასი ZipServlet აფართოებს HttpServlet( // ფუნქცია GET მეთოდის დასამუშავებლადსაჯარო void doGet (HttpServletRequest მოთხოვნა, HttpServletResponse პასუხი) აგდებს ServletException, IOException ( // დაადგინეთ, რომ მხარე არის HTML დოკუმენტიპასუხი. setContentType("ტექსტი/html"); // აიღეთ "Accept-Encoding" პარამეტრი HTTP სათაურიდანსიმებიანი კოდირება=მოთხოვნა. getHeader ("Accept Encoding"); // აიღეთ პარამეტრი "encoding" - დოკუმენტის კოდირების დაყენებამდესიმებიანი encodeFlag=მოთხოვნა. getParameter ("კოდირება"); // Kudi displaytimemo PrintWriter out; // ისევე, როგორც მოთხოვნაზე "Accept-Encoding" ველითუ (შიფრები != null) ( // ეს ველი ასევე უნდა შეიცავდეს "gzip" მნიშვნელობას, მაგრამ კოდირება ჯერ არ არის დაყენებული, if ((შიფრები. indexOf("gzip" ) != - 1 ) &&! encodeFlag. უდრის ("არცერთი") )) ( // ისინი, სადაც ჩვენ შევალთ, იქნება ერთისთვის და წაიღეთ ტექსტი დახმარებისთვის GZIP out = new PrintWriter(new GZIPOutputStream(response. getOutputStream()) , false); // და დააყენეთ დროშა ბრაუზერისთვის, რომ დოკუმენტი გაფუჭდებაპასუხი. setHeader ("შინაარსის კოდირება", "gzip"); ) else out = პასუხი. getWriter(); ) სხვა // თორემ შეკუმშვის გარეშე შევძლებთ ცხოვრებასგარეთ = პასუხი. getWriter(); გარეთ. println ("ეს ტესტია!!!"); // დაწერეთ დოკუმენტის ძირითადი ნაწილიგარეთ. close(); // რომ zakryvaemo vysnovok. //ყველაფერი, სამუშაოს დასრულების შემდეგ, დოკუმენტი გაიგზავნება } }

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

ჯავას იმპორტი. იო.*; javax-ის იმპორტი. სერლეტ.*; // პროგრამა ახორციელებს Servlet ინტერფეისსკლასი DoloadServlet ახორციელებს Servlet-ს ( ServletConfig კონფიგურაცია; // ServletConfig ობიექტი საჯარო DoloadServlet() () // არაფრის კეთება // კონფიგურაციის შენახვა ინიციალიზაციისასსაჯარო void init (ServletConfig კონფიგურაცია) აგდებს ServletException ( this.config = config;) // იხილეთ დაზოგვის კონფიგურაციასაჯარო ServletConfig getServletConfig() ( დაბრუნების კონფიგურაცია;) // ინფორმაცია სერლეტის შესახებსაჯარო სტრიქონი getServletInfo() ( დააბრუნეთ "DoloadServlet" ;) საჯარო void განადგურება () () // არაფრის კეთება // მოთხოვნა მოთხოვნასაჯარო void სერვისი (ServletRequest მოთხოვნა, ServletResponse პასუხი) აგდებს ServletException, java. io. IO გამონაკლისი ( // ჩვენ არ ვითხოვთ დახმარებას, უბრალოდ დაუყოვნებლივ // HTTP სათაურის შექმნა:სტრიქონის თავი = ​​"HTTP/1.0 200 OK\n" + + "სერვერი: DoloadServlet\n" + "შინაარსის ტიპი: ტექსტი/html; სიმბოლოების ნაკრები=UTF-8\n"+ "დაკავშირება: Keep Alive\n" + "შინაარსის კოდირება: მრავალნაწილიანი/შერეული\n"+ "Transfer-Encoding: chunked" + "Pragma: no-cache\n\n" ; // ახლა დაამატეთ პოსტის მონაცემები // ამ კონდახისთვის - 20 ტეგი "
გადატანილი რიგიდან for (int i = 0; i< 20 ; i++ ) head = head + "
\n" ; // წაიყვანე ბავშვი ServletOutputStream os=პასუხი. getOutputStream(); // ჩაწერეთ იქ სათაური და განათავსეთ მონაცემები os. ბეჭდვა (თავი); // დაამარცხე ყველაფერი, რაც დაწერილია ბუფერში კლიენტის წინაშეპასუხი. flushBuffer(); // დაიწყეთ ახალი რიგების დამატება: // qi რიგები ასე გამოიყურება: რიგის ნომერი, შემდეგ "
\n" // ტყავის ახალი მწკრივი ჩნდება ყოველ 3 წამში int i = 0; ხოლო (მართალია)( // ლიჩნიკის ნამატიმე++; // ჩაწერეთ ოს სტრიქონი. print("" + i+ "
\n"); // ფლეშ ბუფერული პასუხი. flushBuffer(); // გაყინეთ პოტიკი 3 წამითსცადე (ძილი (3000 );) დაჭერა (გამონაკლისი ე)() ) )

დაკარგულია იმის თქმა, რომ servlet მექანიზმი უფრო პლასტიკურია და საშუალებას გაძლევთ შექმნათ ისეთი გამოსვლები, რადგან მათ შეუძლიათ გამოიყენონ გარე WEB სერვერის ჩაწერა (როგორიცაა, მაგალითად, რეზიუმეს სერლეტის შემთხვევაში). რობოტული სერლეტის მინუსი არის პირველი გაშვების დაბალი სიჩქარე (სერვლეტი უბრალოდ შედგენილია JIT აპარატის მიერ), მეხსიერების მაღალი დაკარგვა და Java-ში ყველა პროგრამის წარუმატებლობა - მწკრივებთან მუშაობის დაბალი სიჩქარე. დანარჩენი გარემო მოძველებულია სერლეტ რობოტებით, რომლებიც იღებენ ტექსტურ მონაცემებს POST მოთხოვნაოჰ. POST მოთხოვნილია HttpServlet-დან 50 კბ ზომით HttpServletRequest.getReader-ის დახმარებით ანალიზისას () შეუძლია სერვერის რობოტის პარალიზება რამდენიმე hvilin-ისთვის. იგივე ეხება სხვა java პროგრამებს.

ორ პატარა მაგალითს მოგიყვან:

// მოცემული მწკრივის სტრიქონის ტექსტი // კონდახი 1 // იპოვნეთ რობოტი ზედიზედ String-ისთვის დამატებითი "+" ოპერაციისთვისსიმებიანი ტესტი1 = ""; for (int i = 0; i< text. length(); i++ ) test1 += text. charAt(i); // კონდახი 2 // იპოვნეთ რობოტი ზედიზედ დამატებითი ბუფერისთვის char buf = ახალი char [ტექსტი. სიგრძე()]; for (int i = 0; i< text. length(); i++ ) buf[ i] = text. charAt(i); String sample2 = new String(buf);

თუ იღებთ პატარა სტრიქონებს - 2-3 კბ-მდე, მაშინ რობოტის აპლიკაციაში მონაცემები არ არის მნიშვნელოვანი, თუ ტექსტის მწკრივს იღებთ 10 კბ ზომით, მაშინ პირველ ეტაპზე პროგრამა მნიშვნელოვნად იმუშავებს მწკრივთან. მეტი. ეს არის java-ს თავისებურება და є String კლასის ფუნქციების განხორციელების პრობლემა. ასე რომ, თუ გსურთ დაწეროთ შვედური სერვლეტი, იყავით უნიკალური გრძელი რიგები String კლასის დასახმარებლად, მაგალითად, მონიშნეთ StringBuffer კლასი. ეს წინსვლა ჩვენამდე უნდა განხორციელდეს მანამ, სანამ დიდი ტექსტები არ მოიხსნება მინდვრებიდან და არ დამუშავდება ლოკალური ფაილები (მაგალითად, სტუმრების წიგნის ტექსტური მონაცემთა ბაზის შემთხვევაში, დიდი რაოდენობის მითითებით).

კიდევ ერთი პრობლემაა WEB სისტემის მრავალდავალება. არ დაგავიწყდეთ, რომ თქვენს სერლეტებს შეუძლიათ მოითხოვონ კორისტუვაჩის ფრაქცია ერთდროულად. ხშირად მონაცემთა სინქრონიზაციის პრობლემებს, მონაცემთა გაცვლას ერთი და იმავე სერლეტის სხვადასხვა დათვლის ძაფებს შორის ადანაშაულებენ, ხოლო ყველაზე გავრცელებული პრობლემაა ფაილებზე და სისტემის სხვა დასახელების რესურსებზე სინქრონული წვდომის პრობლემა. მაგალითად, ერთმა პროგრამამ გახსნა ფაილი წასაკითხად და ზოგჯერ ცდილობს იქ ჩაწერას. შედეგად, სხვა პროგრამა ან ხსნის ბრალს, ან ამოწმებს, სანამ ფაილი გამოიძახება ჩასაწერად. ზიმთან ბმულზე მსურს თქვენი პატივისცემა დაგიბრუნოთ: არ დატბოროთ თქვენს უკან უყვირი ნაკადულები და დახურეთ ნაკადები, რადგან მხოლოდ ისინი იყო საჭირო. Potik, ცხადია, მოგვიანებით ავტომატურად იხურება, მაგრამ ეს მხოლოდ ერთხელ მოხდება, თუ "smіttyar" მოხვდება ახალზე და ამავდროულად, სხვა პროგრამას არ აქვს წვდომა ჩასაწერ ფაილზე.

გარდა მრავალდავალებების შესრულებისა, მინდა აღვნიშნო, რომ დამატებითი მეთოდებისთვის "Object getAttribute(String name)" და "void setAttribute(String name, Object object)" ServletContext ინტერფეისისთვის, შეგიძლიათ გაცვალოთ სერვერები და მონაცემები, მათ შორის, სინქრონიზებულია.

Servlets (Servlets) - tse java-პროგრამები, yakі vykonuyutsya ვებ-პროგრამების სერვერის მხარეს. ისევე როგორც აპლეტები დინამიურად აფართოებენ ვებ ბრაუზერის ფუნქციონირებას, სერლეტები დინამიურად აფართოებენ ვებ სერვერის ფუნქციონირებას. თუ სერლეტებს შეუძლიათ ზარის მომსახურება, stinks გამოიძახება ვებ სერვერების გაფართოებისთვის. ასეთი პროგრამებისთვის Java Servlet ტექნოლოგია განსაზღვრავს HTTP-ს სპეციფიკურ სერვლეტ კლასს. javax.servlet და javax.servlet.http პაკეტები უზრუნველყოფს ინტერფეისებს და კლასებს სერლეტების შესაქმნელად.

  • როგორია ვებ პროექტის სტრუქტურა?

  • რა არის სერლეტის კონტეინერი? სერვლეტის სასიცოცხლო ციკლი.

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

  • რა არის სერლეტის კონტეინერის განმარტება, ფუნქციონირება?

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

  • რა განსხვავებაა sendRedirect() და forward()-ს შორის?

JSP ვიკისთვის, forward() მეთოდი არის ყველაზე ძვირი გზა, JSP ზარისთვის sendRedirect() მეთოდი აბსოლუტური გზაა. Vіdminnіst tsikh methodіv vіd scho z მეთოდი forward() უკვე გადაცემულია მთავარი ობიექტის მოთხოვნის მოთხოვნა, და გაგზავნა sendRedirect() მეთოდზე ქმნის ახალ მოთხოვნას. დარჩენილი პერიოდის განმავლობაში ინფორმაცია უნდა გადაეცეს სხვა ობიექტებს. მანამდე, forward() მეთოდი უფრო ჭკვიანია.

  • რა იცით ფილტრის სერლეტის შესახებ?

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

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

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

  • void init(FilterConfig config) აგდებს ServletException;
  • void განადგურება();
  • void doFilter (ServletRequest მოთხოვნა, ServletResponse პასუხი, FilterChain ჯაჭვი) აგდებს IOException, ServletException;

გამოიძახება init() მეთოდი, შეკეთდება პირველი ქვედა ფილტრი და განახლდება ახალი კონფიგურაციის ფილტრის ობიექტი. doFilter მეთოდი პირდაპირ არღვევს ფილტრის მუშაობას. ამგვარად, სერვერი იძახებს init()-ს ერთხელ რობოტში ფილტრის გასაშვებად, შემდეგ კი რამდენჯერმე გამოიძახებს doFilter()-ს, რამდენი მოთხოვნა დაიშლება შეფერხების გარეშე. ეს ფილტრი. მას შემდეგ, რაც ფილტრი დაასრულებს მუშაობას, გამოიძახება death() მეთოდი.

  • რა საჭიროა სმენის აპარატები სერლეტებში?

ამ სესიის კონტექსტის მოსმენისას - ce კლასი, yakі-ს შეუძლია მიჰყვეს მას, თუ რომელიმე სესიის კონტექსტი იყო ინიციალიზებული, ან თუ ეს იყო ერთი საათი, თუ სუნი შეიძლება გაფუჭებულიყო, და თუ ატრიბუტები დაემატა და ჩანს სესიის კონტექსტში. Servlet 2.4 აფართოებს მსმენელის შეკითხვის მოდელს, რათა მოგცემთ მიუთითოთ, თუ როგორ იქმნება და ახშობს მოთხოვნები და როგორ დაემატება და ამოიღება ატრიბუტები servlet-დან. Servlet 2.4 ამატებს ამ კლასს:

  • ServletRequestListener
  • ServletRequestEvent
  • ServletRequestAttributeListener
  • ServletRequestAttributeEvent

  • როგორ მივიღოთ ბრალი, მოიგოთ სხვა სერვლეტით დანამატიდან?

თუ ბრაუზერმა მხოლოდ HTML-ზე მეტი იცის, მაშინ თუ servlet-ის კონტეინერის ვიკი პროგრამა აალდება და ქმნის HTML პასუხს. ეს ჰგავს იმას, რაც გამოიყენება შეწყალების კოდებისთვის kshtalt 404, 403 და ასე შემდეგ. Servlet API მინიშნებას აძლევს მასტერ სერლეტებს ციტირებისა და შეწყალების დასამუშავებლად, რაც შეგვიძლია დავაყენოთ ბუნდოვანების აღმწერში. ასეთი სერლეტების მთავარი ამოცანაა შეწყალების ან ბრალის მიღება და კორისტუვაჩოვისთვის HTML-ის გაგების გაგზავნა. მაგალითად, შეგიძლიათ მისცეთ ძალა თავის მხარე, ასევე შეწყალების შესახებ ზოგიერთი დეტალის აღწერა.

  • რა არის ხორხის აღმწერი?

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

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

  • როგორ განვახორციელოთ სერლეტის გაშვება პროგრამის გაშვებით?

სერვლეტის კონტეინერმა უნდა გაუშვას სერვლეტი კლიენტის პირველივე მოთხოვნით, წინააღმდეგ შემთხვევაში აუცილებელია სერვლეტის გაშვება პროგრამის დაწყებისთანავე (მაგალითად, როგორც ნაყარი სერლეტი, ის დიდი ხნით ჩაირთვება). რისთვისაც აუცილებელია აღწერზე load-on-startup ელემენტის არჩევა (ან loadOnStartup ანოტაცია), რაც მოითხოვს სერლეტის ჩართვისას გაშვებისას.

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

  • რა არის ServletConfig ობიექტი?

javax.servlet.ServletConfig ინტერფეისი შექმნილია კონფიგურაციის ინფორმაციის გადასაცემად servlet-ისთვის. servlet skin-ს შეუძლია ServletConfig ობიექტის მასპინძლობა, რომელიც ქმნის რაიმე სახის servlet კონტეინერის მაგალითს. კონფიგურაციაში პარამეტრების დასაყენებლად, არჩეულია init პარამეტრები web.xml-ში (ან WebInitParam ანოტაციებში). ამ servlet-ის ServletConfig ობიექტის მისაღებად, მიღებულია getServletConfig() მეთოდი.

  • რა არის ServletContext ობიექტი?

javax.servlet.ServletContext ინტერფეისი განსაზღვრავს უამრავ მეთოდს, როგორიცაა servlet-ის ხრიკი, სერვლეტის კონტეინერთან კომუნიკაციისთვის, მაგალითად, აიღეთ ფაილის MIME ტიპი, გაგზავნეთ მოთხოვნა ან ჩაწერეთ ჟურნალის ფაილში. ServletContext ობიექტი უნიკალურია და ხელმისაწვდომია პროგრამის ყველა ვებ სერვერისთვის. ჩვენ შეგვიძლია მოვიგოთ ServletContext ობიექტი, თუ გვჭირდება წვდომა ერთ ან მეტ სერლეტზე ვებ პროგრამის პარამეტრების ინიციალიზაციისთვის. რომელი გამარჯვებული ელემენტისთვის web.xml-ზე. ServletContext ობიექტის მოძიება შესაძლებელია getServletContext() დამხმარე მეთოდით ServletConfig ინტერფეისში.

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

ServletContext აფართოებს Servlet 3-ის სპეციფიკაციას და აძლევს პროგრამას პროგრამას მოსმენა და ფილტრაცია. ასევე, ამ ინტერფეისს აქვს ანონიმური მეთოდები, მაგალითად getMimeType(), getResourceAsStream() და ა.შ.

  • რატომ აქვს მნიშვნელობა ServletContext და ServletConfig?

ქვემოთ მოცემულია უფლებამოსილების აქტი:

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

  • ServletResponse ინტერფეისი.

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

  • ServletRequest ინტერფეისი.

ServletRequest ინტერფეისი არის ინსტრუმენტი HTTP მოთხოვნიდან პარამეტრების მოსაძიებლად. ამ ინტერფეისს შეიძლება ჰქონდეს მეთოდები, რომლებიც იდენტურია ServletContext-ის სახელის.

  • რა არის მოთხოვნის დისპეჩერი?

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

  • void forward(ServletRequest var1, ServletResponse var2) - გაგზავნეთ მოთხოვნა სერვლეტიდან სხვა რესურსზე (servlet, JSP ან HTML ფაილი) სერვერზე.
  • void include(ServletRequest var1, ServletResponse var2) - მოიცავს რესურსის შინაარსს (servlet, JSP ან HTML მხარე) ხედში.

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

  • როგორ შეგიძლიათ შექმნათ ჩიხი სერვლეტზე?

ჩიხი შეიძლება მოიხსნას ზარის დაწკაპუნების მეთოდზე მარყუჟების დანერგვით, მაგალითად, doPost() მეთოდის გამოძახებით doGet() მეთოდიდან და doGet() მეთოდის გამოძახებით doPost() მეთოდიდან.

  • როგორ ავიღოთ სერვერზე სერვლეტის მისამართი?

სერვერზე რეალური სერვერის ბილიკის მისაღებად, შეგიძლიათ გადაუგრიხოთ შემდეგი კონსტრუქცია: getServletContext().getRealPath(request.getServletPath()).

  • როგორ ამოიღოთ ინფორმაცია სერვერის შესახებ servlet-დან?

სერვერის შესახებ ინფორმაციის მოძიება შესაძლებელია ServletContext დამხმარედან getServerInfo() დამხმარე მეთოდიდან. ტობტო. getServletContext().getServerInfo().

  • როგორ ავიღოთ კლიენტის IP მისამართი სერვერზე?

შეასწორეთ request.getRemoteAddr() კლიენტის ip-ის მისაღებად სერვლეტში.

  • რა იცით სერლეტების შეფუთვის კლასების შესახებ?

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

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

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

WEB სერვერი არსებითად სიმღერის კონტეინერია, რაც საინტერესოა სერვლეტი"და, vykonuє їх, і, შედეგის გათვალისწინებით, დაამარცხა კლიენტი.

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

შენი შებოჭილობისა და გნუჩკის მეშვეობით, სერვლეტითქვენ შეგიძლიათ მნიშვნელოვანი როლი შეასრულოთ სისტემის არქიტექტურაში. მათ შეუძლიათ გააუმჯობესონ განაცხადის პროცესი, აღიარებული ინდუსტრიული დონისთვის, იმუშაონ კლიენტისთვის პროქსი სერვერად და გააუმჯობესონ შუალედური დონის ფუნქციონირება, დაამატონ ახალი პროტოკოლები და სხვა ფუნქციები. შუალედური riven vikonu სერვერი ფუნქციონირებს dodatkіv ე.წ. სამი მდინარის სისტემა კლიენტ-სერვერს და ცვლის "მსუბუქ" კლიენტებს შორის, როგორიცაა ვებ-ბრაუზერი, რომელიც dzherelom danich.

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

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

ტიმჩასოვო და სწრაფი სერვლეტი"და

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

Servlet სასიცოცხლო ციკლი, javax.servlet.Servlet

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

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

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

და ორი დამატებითი მეთოდი:

  • getServletConfig()
  • getServletInfo()

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

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

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

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

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

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

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

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

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

Servlet vivantage,struct() მეთოდი

მეთოდი განადგურება ()მოითხოვს ყველა რესურსის მოწოდებას (მაგალითად, ფაილების გახსნარომ მონაცემთა ბაზის ჩანაწერი) სერვლეტის ვივანტაჟამდე. ეს მეთოდი შეიძლება ცარიელი იყოს, რადგან არ არის აუცილებელი რაიმე საბოლოო ოპერაციის დასრულება. ვიკი მეთოდის წინ განადგურება ()სერვერი ამოწმებს ან ყველა სერვისის ოპერაციის დასრულებას, ან სიმღერის საათის დასრულებას. ცე ნიშნავს, რომ მეთოდი განადგურება ()შესაძლოა buti vyklikaniya pіd საათი vykonannya იყოს-ნებისმიერი ტრივიალური მეთოდი მომსახურება ().

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

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

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

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

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

ServletRequest ინტერფეისი

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

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

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

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

getAttribute () დაატრიალეთ მითითებული ატრიბუტის მნიშვნელობა მოთხოვნაზე.
getContentLength() როზმირ ზაპიტუ, როგორც ჩანს.
getContentType() შეცვალეთ ტიპი MIME-ზე.
getInputStream() დაატრიალეთ InputStream, რათა წაიკითხოთ ორმაგი მონაცემები სხეულისგან მოთხოვნამდე.
GetParameterNames() დაატრიალეთ რიგების მასივი ყველა პარამეტრის სახელებით.
getParameterValues() დაატრიალეთ მინიჭებული პარამეტრის მასივის მნიშვნელობა.
getProtocol() გადაიყვანეთ პროტოკოლი ამ ვერსიაზე, რომ სწორად მიიღოთ იგი /..
getReader () დაატრიალეთ BufferedReader ტექსტის შესაცვლელად მოთხოვნით.
getRealPath () გადაუხვიეთ რეალური გზა დანიშნული ვირტუალური ბილიკისთვის.
getRemoteAddr() კლიენტის IP მისამართები, რომლებიც მის მიერ იყო მოთხოვნილი.
getRemoteHost() Іm'ya მასპინძელი კლიენტის მანქანა, რომელიც nad_slav ეს მოთხოვნა.
getScheme () დაატრიალეთ სქემა, რომელიც შედის ამ მოთხოვნის URL-ში (მაგალითად, https, http, ftp და ა.შ.).
getServerName() სერვერის ჰოსტის სახელი, რომელმაც მიიღო მოთხოვნა.
getServerPort () გადააბრუნეთ ნომერი პორტზე, რომელიც გამარჯვებულია ამ მოთხოვნის გაუქმებისთვის.

ServletResponse ინტერფეისი

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

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

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

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

getOutputStream მეთოდი აქცევს გამომავალ ნაკადს სერვლეტისთვის. Tsey potіk vykoristovuєtsya, მაგალითად, vyvedennya ბინარული ფაილები. ტექსტური მონაცემების მოძიება შესაძლებელია 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 ხედებისთვის.

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

JNI სერვლეტში

რამდენიმე ვარიანტისთვის შეიძლება დაგჭირდეთ WEB დანამატის JNI ვერსია. JNI გამოყენების მაგალითი სერვლეტის ხედებისთვის.

JMS servlet შეტყობინება

სერლეტს შეიძლება ჰქონდეს შეთავაზებები გაცვლისთვის JMS povіdomlennya mіzh პროგრამები. Servlet პროფესიული ინსტრუმენტი JMS კონტეინერირებული JBoss ხედების გასააქტიურებლად და წასაკითხად.

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

Java პროგრამების შექმნა Servlets-ის დახმარებით

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

Pratsiyuemo მეტი zovnіshnіm vglyad

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

Axis პირველი JSP ფაილი:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> რეგისტრაცია

რეგისტრაცია

$ (დარღვევა).

რედაქტორების არჩევანი

© 2022 androidas.ru - ყველაფერი Android-ის შესახებ