ინტერნეტის განვითარებასთან ერთად გაჩნდა საჭიროება განაწილებული აპლიკაციების შექმნა. კომპიუტერზე დაინსტალირებული აპლიკაციები ჩვეულებრივ იყენებენ მასზე განთავსებული ბიბლიოთეკებს. ერთი ბიბლიოთეკის გამოყენება შესაძლებელია რამდენიმე პროგრამით. შესაძლებელია თუ არა ბიბლიოთეკების ანალოგების მასპინძლობა ინტერნეტში, რათა სხვადასხვა საიტებმა შეძლონ მათი დარეკვა? გამოდის კი.
კომპანიები თავიანთ გვერდებზე აწვდიან მრავალფეროვან ინფორმაციას. მაგალითად, მისი ვებგვერდიდან http://www.Ford.com, კომპანია Ford აქვეყნებს ინფორმაციას მოდელებისა და ფასების შესახებ. ამ კომპანიის დილერს სურს ჰქონდეს ეს ინფორმაცია მათ ვებსაიტზე. ვებ სერვისი მომხმარებელს აძლევს საშუალებას მოიძიოს ინფორმაცია პროვაიდერის საიტიდან. მომხმარებლის საიტი აჩვენებს ამ ინფორმაციას თავის გვერდებზე. ამ ინფორმაციის გენერირების კოდი იწერება ერთხელ, მაგრამ შეიძლება გამოიყენოს ბევრი მომხმარებელი. მონაცემები წარმოდგენილია უბრალო ტექსტში, ამიტომ მათი გამოყენება შესაძლებელია პლატფორმის მიუხედავად.
ვებ სერვისები ფართოდ გამოიყენება როგორც დესკტოპში, ასევე ინტერნეტ აპლიკაციებში. ისინი თავისთავად არ არიან აპლიკაციები, არამედ აპლიკაციების მონაცემთა წყაროები. მათ აკლიათ მომხმარებლის ინტერფეისი. ვებ სერვისები არ უნდა იქნას გამოყენებული ინტერნეტში - ისინი შეიძლება იყვნენ პროექტის ნაწილი, რომელშიც ისინი გამოიყენება.
ვებ სერვისები არის ფუნქციები და მონაცემები, რომლებიც უზრუნველყოფილია გარე აპლიკაციების გამოსაყენებლად, რომლებიც ურთიერთქმედებენ სერვისებთან სტანდარტული პროტოკოლებისა და მონაცემთა ფორმატების მეშვეობით. ვებ სერვისები სრულიად დამოუკიდებელია განხორციელების ენისა და პლატფორმისგან. ვებ სერვისების ტექნოლოგია არის Microsoft-ის პროგრამირების მოდელის ქვაკუთხედი. NET.
Ეს არის შემდგომი განვითარება კომპონენტის პროგრამირება CORBA და DCOM. თუმცა, ასეთი კომპონენტების გამოსაყენებლად აუცილებელია მათი რეგისტრაცია მომხმარებლის სისტემაში. ეს არ არის საჭირო ვებ სერვისებისთვის. კომპონენტები კარგად მუშაობს ადგილობრივ ქსელებზე. HTTP პროტოკოლი არ არის შესაფერისი დისტანციური პროცედურის ზარებისთვის (RPC). თუნდაც ერთი და იგივე ორგანიზაციაში, განსხვავებული Ოპერატიული სისტემა, რომელსაც შეუძლია მხოლოდ HTTP-ზე კომუნიკაცია.
განხორციელდა რამდენიმე მცდელობა, შეექმნათ საკომუნიკაციო ენა ჰეტეროგენულ სისტემებს შორის - DCOM, CORBA, RMI, IIOP. მათ არ მიიღეს ზოგადი მიმღებლობა, რადგან თითოეული დაწინაურდა სხვადასხვა მწარმოებლის მიერ და, შესაბამისად, მიბმული იყო კონკრეტული მწარმოებლის ტექნოლოგიაზე. არავის სურდა სხვისი სტანდარტის მიღება. ამ დილემის გადასაჭრელად, რამდენიმე კომპანია შეთანხმდნენ, რომ შეემუშავებინათ გამყიდველისგან დამოუკიდებელი სტანდარტი HTTP-ზე შეტყობინებების გაგზავნისთვის. 2000 წლის მაისში IBM, Microsoft, HP, Lotus, SAP, UserLand და სხვები მიმართეს W3C-ს და წამოაყენეს SOAP, როგორც კანდიდატი ასეთი სტანდარტისთვის. SOAP-მა მოახდინა რევოლუცია აპლიკაციების განვითარებაში ორი ინტერნეტ სტანდარტის, HTTP და XML-ის შერწყმით.
საპონი
XML-ზე დაფუძნებული SOAP პროტოკოლი გამოიყენება ვებ სერვისებთან ურთიერთობისთვის. შესაძლებელი იქნებოდა მხოლოდ XML-ის გამოყენება, მაგრამ ეს ძალიან თავისუფალი ფორმატია, რომელშიც თითოეული დოკუმენტი რეალურად ქმნის საკუთარ ენას. საპონიარის კონვენცია XML დოკუმენტის ფორმატის, მასში გარკვეული ელემენტების და სახელების სივრცის არსებობის შესახებ.
SOAP საშუალებას გაძლევთ გამოაქვეყნოთ და მოიხმაროთ მონაცემთა რთული სტრუქტურები, როგორიცაა DataSet. ამავე დროს, ადვილია სწავლა. Მოქმედი ვერსიასაპონი-1.2.
SOAP არის მარტივი ობიექტზე წვდომის პროტოკოლი. SOAP შექმნილია იმისთვის, რომ აპლიკაციებს გაუადვილოს HTTP-ზე კომუნიკაცია. ეს არის სპეციალური პლატფორმისგან დამოუკიდებელი ინტერნეტ შეტყობინებების ფორმატი. SOAP შეტყობინება მხოლოდ ჩვეულებრივი XML დოკუმენტია. სტანდარტული
ლირიკული ნაწილი.
წარმოიდგინეთ, რომ თქვენ დანერგეთ ან ახორციელებთ გარკვეულ სისტემას, რომელიც ხელმისაწვდომი უნდა იყოს გარედან. იმათ. არის გარკვეული სერვერი, რომელთანაც გჭირდებათ კომუნიკაცია. მაგალითად ვებ სერვერი.
ამ სერვერს შეუძლია შეასრულოს მრავალი მოქმედება, იმუშაოს მონაცემთა ბაზასთან, შეასრულოს მესამე მხარის მოთხოვნები სხვა სერვერებზე, გააკეთოს გარკვეული გამოთვლები და ა.შ. იცხოვროს და შესაძლოა განვითარდეს მისი ცნობილი სცენარის მიხედვით (ანუ დეველოპერების სცენარის მიხედვით). ადამიანისთვის საინტერესო არ არის ასეთ სერვერთან ურთიერთობა, რადგან მას არ შეუძლია/არ სურდეს ლამაზი გვერდების მიცემა სურათებით და სხვა მომხმარებლისთვის მოსახერხებელი შინაარსით. ის იწერება და მუშაობს იმისთვის, რომ მუშაობს და გასცემს მონაცემებს მასზე მოთხოვნებზე, ისე რომ არ აინტერესებს, რომ ისინი ადამიანისათვის იკითხება, კლიენტი თავად გაუმკლავდება მათ.
სხვა სისტემებს, რომლებიც წვდებიან ამ სერვერზე, უკვე შეუძლიათ ამ სერვერიდან მიღებული მონაცემების განკარგვა საკუთარი შეხედულებისამებრ - დამუშავება, დაგროვება, კლიენტებისთვის გაცემა და ა.შ.
კარგად, ასეთ სერვერებთან კომუნიკაციის ერთ-ერთი ვარიანტია SOAP. SOAP XML შეტყობინებების პროტოკოლი.
პრაქტიკული ნაწილი.
ვებ სერვისი (ეს არის ის, რასაც სერვერი უზრუნველყოფს და რასაც კლიენტები იყენებენ) შესაძლებელს ხდის სერვერთან კომუნიკაციას კარგად სტრუქტურირებული შეტყობინებებით. ფაქტია, რომ ვებ სერვისი არ იღებს მონაცემებს. ნებისმიერი შეტყობინება, რომელიც არ ემთხვევა წესებს, დაბრუნდება ვებ სერვისის მიერ შეცდომით. შეცდომა, სხვათა შორის, ასევე იქნება xml-ის სახით, მკაფიო სტრუქტურით (რაც არ შეიძლება ითქვას ჭეშმარიტი შეტყობინების ტექსტზე).
WSDL (ვებ სერვისების აღწერის ენა). წესები, რომლითაც შედგენილია შეტყობინებები ვებ სერვისისთვის, ანალოგიურად არის აღწერილი xml-ის გამოყენებითდა ასევე აქვს მკაფიო სტრუქტურა. იმათ. თუ ვებ სერვისი უზრუნველყოფს მეთოდის გამოძახების შესაძლებლობას, მან უნდა მისცეს კლიენტებს იმის გარკვევის საშუალებას, თუ რა პარამეტრები გამოიყენება ამ მეთოდისთვის. თუ ვებ სერვისი პარამეტრად მოელის სტრიქონს Method1 მეთოდისთვის და სტრიქონს უნდა ერქვას Param1, მაშინ ეს წესები მითითებული იქნება ვებ სერვისის აღწერაში.
არა მხოლოდ მარტივი ტიპები, არამედ ობიექტები, ობიექტების კოლექციები შეიძლება გადავიდეს პარამეტრებად. ობიექტის აღწერა მცირდება ობიექტის თითოეული კომპონენტის აღწერამდე. თუ ობიექტი შედგება რამდენიმე ველისგან, მაშინ აღწერილია თითოეული ველი, რა ტიპი აქვს მას, სახელი (რა არის შესაძლო მნიშვნელობები). ველები შეიძლება იყოს რთული ტიპისაც და ასე შემდეგ, სანამ ტიპების აღწერა არ დასრულდება მარტივით - სტრიქონი, ლოგიკური, რიცხვი, თარიღი... თუმცა ზოგიერთი კონკრეტული ტიპი შეიძლება მარტივი აღმოჩნდეს, მნიშვნელოვანია, რომ კლიენტებს შეუძლიათ გაიგონ, რა ღირებულებები შეიძლება შეიცავდეს მათ.
კლიენტებისთვის საკმარისია იცოდეთ ვებ სერვისის url, wsdl ყოველთვის ახლოს იქნება, რომლითაც შეგიძლიათ მიიღოთ წარმოდგენა იმ მეთოდებზე და მათ პარამეტრებზე, რომლებსაც ეს ვებ სერვისი გვაწვდის.
რა უპირატესობა აქვს ყველა ამ ზარს და სასტვენს:
- უმეტეს სისტემებში, მეთოდებისა და ტიპების გამოცხადება ხდება ავტომატური რეჟიმი. იმათ. ეს საკმარისია სერვერზე პროგრამისტმა თქვას ამ მეთოდითშეიძლება დარეკვა ვებ სერვისის საშუალებით და wsdl აღწერა ავტომატურად გენერირებული იქნება.
ავტომატური ვალიდაცია.
- xml ვალიდაცია. xml კარგად უნდა იყოს ჩამოყალიბებული. არასწორი xml - მყისიერად შეცდომა კლიენტისთვის, მიეცით მას გაერკვია.
- სქემის დადასტურება. xml უნდა ჰქონდეს გარკვეული სტრუქტურა. xml არ ემთხვევა სქემას - დაუყოვნებლივ შეცდომა კლიენტს, დაე, გაერკვია.
- მონაცემთა ვალიდაცია ხორციელდება საპნის სერვერის მიერ, რათა მონაცემთა ტიპები და შეზღუდვები ემთხვეოდეს აღწერილობას.
- ავტორიზაცია და ავთენტიფიკაცია შეიძლება განხორციელდეს ცალკე მეთოდი. მშობლიურად. ან http ავტორიზაციის გამოყენებით.
- ვებ სერვისებს შეუძლიათ იმუშაონ როგორც საპნის პროტოკოლზე, ასევე http-ზე, ანუ მისაღებად მოთხოვნის საშუალებით. ანუ, თუ მარტივი მონაცემები (სტრუქტურის გარეშე) გამოიყენება პარამეტრებად, მაშინ შეგიძლიათ უბრალოდ დარეკოთ ჩვეულებრივი მიღება www.site.com/users.asmx/GetUser?Name=Vasia ან პოსტი. თუმცა, ეს ყოველთვის და ყველგან არ არის.
- ... იხილეთ ვიკიპედია
აღწერა, რომელსაც აქვს მკაფიო სტრუქტურა, იკითხება ნებისმიერი საპნის კლიენტისთვის. იმათ. როგორიც არ უნდა იყოს ვებ სერვისი, კლიენტი მიხვდება, რა მონაცემებს იღებს ვებ სერვისი. ამ აღწერის მიხედვით, კლიენტს შეუძლია ააგოს ობიექტების კლასების საკუთარი შიდა სტრუქტურა, ე.წ. სავალდებულო" და. შედეგად, პროგრამისტმა, რომელიც იყენებს ვებ სერვისს, უნდა დაწეროს მსგავსი რამ (ფსევდოკოდი):
NewUser:=TSoapUser.Create("Vasya","Pupkin","admin"); საპონი.AddUser(NewUser);
ასევე ბევრი უარყოფითი მხარეა:
- შეტყობინებების უსაფუძვლოდ დიდი ზომა. აქ, xml-ის ბუნება ისეთია, რომ ფორმატი ზედმეტია, რაც მეტი ტეგია, მით მეტია უსარგებლო ინფორმაცია. პლუს საპონი მატებს მის სიჭარბეს. ინტრანეტის სისტემებისთვის ტრაფიკის საკითხი ნაკლებად მწვავეა, ვიდრე ინტერნეტისთვის, ამიტომ საპონი ლოკალური ქსელებიუფრო მოთხოვნადი, კერძოდ, Sharepoint-ს აქვს საპნის ვებ სერვისი, რომელთანაც შეგიძლიათ წარმატებით დაუკავშირდეთ (და გარკვეული შეზღუდვები).
- ვებ სერვისის აღწერილობის ავტომატურმა ცვლილებამ შეიძლება დაარღვიოს ყველა კლიენტი. ისე, როგორც ნებისმიერი სისტემისთვის, ასე რომ, თუ ძველ მეთოდებთან უკანა თავსებადობა არ არის მხარდაჭერილი, ყველაფერი დაიშლება ...
- არა მინუსი, არამედ მინუსი. ყველა მეთოდის ზარის მოქმედება უნდა იყოს ატომური. მაგალითად, subd-თან მუშაობისას, შეგვიძლია დავიწყოთ ტრანზაქცია, შევასრულოთ რამდენიმე მოთხოვნა, შემდეგ დავაბრუნოთ ან დავასრულოთ. საპნის ტრანზაქცია არ არის. ერთი თხოვნა, ერთი პასუხი, საუბარი დასრულდა.
- სერვერის მხარეს არსებულის აღწერილობასთან (ყველაფერი სწორად არის აღწერილი ჩემ მიერ?), რა არის კლიენტზე (რა მომწერეს აქ?) შეიძლება საკმაოდ რთული იყოს. რამდენჯერმე მომიწია კლიენტის მხარესთან გამკლავება და სერვერის პროგრამისტის დარწმუნება, რომ მან არასწორად აღწერა მონაცემები, მაგრამ მათში ვერაფერი გაიგო, რადგან ავტომატური გენერაცია და ის, როგორც იქნა, არ უნდა, ეს არის პროგრამული უზრუნველყოფის საკითხი. და შეცდომა ბუნებრივად იყო მეთოდის კოდში, პროგრამისტმა უბრალოდ ვერ დაინახა იგი.
- პრაქტიკა გვიჩვენებს, რომ ვებ სერვისების დეველოპერები საშინლად შორს არიან იმ ადამიანებისგან, რომლებიც იყენებენ ამ ვებ სერვისებს. ნებისმიერი მოთხოვნის საპასუხოდ (მოქმედი გარედან), შეიძლება დადგეს გაუგებარი შეცდომა "Error 5. ყველაფერი ცუდია". ეს ყველაფერი დეველოპერების სინდისზეა დამოკიდებული :)
- დარწმუნებული ვარ არაფერი მახსოვდა...
მაგალითად, არის ღია გავრცელების ვებ სერვისი:
- http://86.57.245.235/TimeTable/Service.asmx - შესვლის წერტილი, ასევე არის მეთოდების ტექსტური აღწერა მესამე მხარის დეველოპერებისთვის.
- http://86.57.245.235/TimeTable/Service.asmx?WSDL - მიღებული და დაბრუნებული მონაცემების მეთოდებისა და ტიპების wsdl აღწერა.
- http://86.57.245.235/TimeTable/Service.asmx?op=GetAirportsList - კონკრეტული მეთოდის აღწერა xml მოთხოვნის ტიპისა და xml პასუხის მაგალითით.
თქვენ შეგიძლიათ ხელით შექმნათ და გაგზავნოთ მოთხოვნა, როგორიცაა:
POST /TimeTable/Service.asmx HTTP/1.1 ჰოსტი: 86.57.245.235 კონტენტის ტიპი: text/xml; charset=utf-8 კონტენტი-სიგრძე: სიგრძე SOAPAction: "http://webservices.belavia.by/GetAirportsList"
პასუხი იქნება:
HTTP/1.1 200 OK თარიღი: ორშაბათი, 30 სექტემბერი 2013 00:06:44 GMT სერვერი: Microsoft-IIS/6.0 X-Powered-By: ASP.NET X-AspNet-ვერსია: 4.0.30319 Cache-Control: კერძო, მაქს. -age=0 Content-Type: text/xml; charset=utf-8 კონტენტი-სიგრძე: 2940
ZY ადრე აეროფლოტის ვებ სერვისი გაიხსნა, მაგრამ მას შემდეგ, რაც 1C-მა დაამატა საპნის მხარდაჭერა 8ku-ში, 1c ბეტა ტესტერების ჯგუფმა წარმატებით დააინსტალირა იგი. ახლა იქ რაღაც შეიცვალა (მისამართი არ ვიცი, დაინტერესების შემთხვევაში შეგიძლიათ მოძებნოთ).
ZZY პასუხისმგებლობის უარყოფა. მან ისაუბრა საყოფაცხოვრებო დონეზე. შეგიძლიათ დალიოთ.
პასუხისმგებლობის უარყოფა:ამ თემაზე ბევრი სტატია დაიწერა და, როგორც თქვენ, რა თქმა უნდა, მიხვდით, ეს კიდევ ერთია. შესაძლოა, მისგან რაიმე ახალს ისწავლით, მაგრამ საიდუმლო არაფერი, რაც დამოუკიდებლად Google-ში ვერ მოიძიეთ, აქ არ არის აღწერილი. მხოლოდ შენიშვნები პირადი გამოცდილებიდან.
შესავალი
ჩვენ განვიხილავთ მხოლოდ იმ სიტუაციას, როდესაც არსებობს მესამე მხარის ვებ სერვისი და ამოცანაა მონაცემთა გაცვლის დამყარება.
სერვისის სტრუქტურა აღწერილია ფაილში WSDL(ინგლ. ვებ სერვისების აღწერის ენა)
ფაილზე ყველაზე ხშირად წვდომა ხდება ბმულის საშუალებით, სადაც მდებარეობს თავად ვებ სერვისის შესასვლელი წერტილი. "ყველაზე ხშირად" დავწერე, რადგან არის გამონაკლისები. მაგალითად, SAP-ზე დაფუძნებული ვებ სერვისი არ აქვეყნებს wsdl-ს და მისი ამოღება შესაძლებელია მხოლოდ თავად აპლიკაციიდან.
ასე რომ, ჩვენ გვაქვს ვებ სერვისის აღწერა, შესვლა, პაროლი. მოდით დავაკავშიროთ.
// განსაზღვრეთ ServiceNamespace URL-ის პარამეტრები = "http://Somesite.ru"; მომხმარებლის სახელი = "TestUser"; პაროლი = "q1w2e3"; LocationWSDL = "https://Somesite.ru/WebService/Some?wsdl"; ServiceName = "SomeServiceName"; ConnectionPointName = "SomeService_Port"; // SSL კავშირის შექმნა = New SecureConnectionOpenSSL(); WSDfinition = New WSD Definition(LocationWSDL,SSL); WSProxy = ახალი WSPProxy (WSD Definition, ServiceNamespace URL, ServiceName, ConnectionPointName, SSL); WSProxy.User = მომხმარებლის სახელი; WSProxy.Password = პაროლი;
კარგად! ჩვენ დავუკავშირდით ვებ სერვისს! თეორიულად, ეს არის ნებისმიერი გაცვლის ვარიანტის საფუძველი, რადგან ის საშუალებას გაძლევთ შექმნათ მონაცემთა სტრუქტურის ობიექტი wsdl-ზე დაფუძნებული და ასეთ ობიექტთან მუშაობა სიამოვნებაა.
განვიხილოთ XML, რომელსაც SoapUI გვაძლევს
ახლა მოდით აღვწეროთ იგი პროგრამულად
// შექმენით ობიექტი და შეავსეთ იგი მონაცემებით OwnXDTOFactory = WSDefinition.XDTOFactory; RootType = OwnFactoryXDTO.Type (URLServiceNamespace, "SUBMISSION"); RootObject = OwnFactoryXDTO.Create(RootType); RootObject.ID = "4356"; ClientType = OwnFactoryXDTO.Type (URLServiceNamespace, "CUSTOMER"); ClientObject = OwnFactoryXDTO.Create(ClientType); ClientObject.CLIENT_ID = "121212"; ClientObject.SEX = "M"; // F - ქალი, M - მამაკაცი ClientObject.CLIENT_BIRTHDAY = "19900111"; // Customer Cars AutoType = CustomFactoryXDTO.Type(URLServiceNamespace, "CARS"); AutoObject = OwnFactoryXDTO.Create(AutoType); AutoObject.CLASS = "მერსედესი"; AutoObject.MODEL = "GLS"; ClientObject.CARS.Add(AutoObject); AutoObject = OwnFactoryXDTO.Create(AutoType); AutoObject.CLASS = "აუდი"; AutoObject.MODEL = "TT"; ClientObject.CARS.Add(AutoObject); RootObject.CUSTOMER.Add(ClientObject);
მონაცემები წარმატებით დასრულდა. ახლა ჩვენ უნდა გავაგზავნოთ ისინი.
სწორედ ამ მომენტში ჩნდება მრავალი ნიუანსი. შევეცადოთ განვიხილოთ თითოეული.
რეცეპტი 1. მთელი XDTO ობიექტის გაგზავნა
შედეგი = WSProxy.AddCustomers(RootObject);
რჩება მხოლოდ იმ შედეგის დამუშავება, რომელიც სერვისმა დაგვიბრუნდა და ეგაა. დამეთანხმებით, რომ ეს ძალიან მოსახერხებელია!
მაგრამ პრაქტიკაში ეს ყოველთვის ასე არ არის. მაგალითად, 1c არ ერწყმის xml-ში გარკვეული ტეგების პრეფიქსირებას, როდესაც root ტეგის სახელთა სივრცე განსხვავდება ბავშვის ტეგებისგან. ასეთ შემთხვევებში საპონი ხელით უნდა შეაგროვოთ. მე ასევე მომიწია ვებ სერვისებთან გამკლავება, რომლებიც პარამეტრად სუფთა xml-ს ელიან. სიგიჟე, მაგრამ მაინც არც ისე რთულია ამის გაკეთება.
რეცეპტი 2. პარამეტრის სახით სუფთა xml გაგზავნა
XMLRecordParameters = NewXMLRecordParameters("UTF-8", "1.0", True); MyXML = ახალი XMLWriter; MyXML.SetString(XMLRecordParameters); MyXML.WriteDeclarationXML(); CustomXDTOFactory.WriteXML(MyXML, RootObject); StringXML = MyXML.Close(); თუ DeleteNamespaceDescription მაშინ AttemptFirstTagInString = StrGetString(XMLString,2); RootTagName = RootObject.Type().Name; XMLString = StrReplace(XMLString, FirstTagInString, "<"+ИмяКорневогоТэга+">"); გამონაკლისი //ErrorDescription() EndTry; EndIf; Result = WSProxy.AddCustomers(XML String);
თუ არ წაშლით სახელთა სივრცეს, რომელსაც 1s დაამატებს ნაგულისხმევად, მაშინ ის კოდის მხოლოდ 5 სტრიქონზე მეტი გახდა. უმეტეს შემთხვევაში, მე xml ტრანსფორმაციას ვახვევ ფუნქციაში, რადგან ჩვენ ჩვეულებრივ ვუწოდებთ ერთზე მეტ მეთოდს.
რეცეპტი 3. გაგზავნეთ მშობლიური HTTP მოთხოვნის საშუალებით.
საპნის სტრიქონი = "ამ ვარიანტში საპნის ხელით დამზადება მოგვიწევს. არსებითად, ჩვენ უბრალოდ ვახვევთ xml რეცეპტი 2-დან საპნის შესაფუთში, სადაც, ვებ სერვისის მოთხოვნებიდან გამომდინარე, ჩვენ შეგვიძლია შევცვალოთ ჩვენი საპონი ჩვენი გულისთვის.
შემდეგი, ჩვენ აღვწერთ სათაურებს დოკუმენტაციის მიხედვით. ზოგიერთი სერვისი ადვილად დაღეჭავს ჩვენს მოთხოვნას სათაურის გარეშე, აქ თქვენ უნდა გადახედოთ კონკრეტულ შემთხვევას. თუ არ იცით რა სათაურები დაწეროთ, მაშინ უმარტივესი გზაა მოთხოვნის ნახვა SoapUI-ში RAW ჩანართზე გადასვლით.
Base64 სტრიქონის მიღების ფუნქცია ასე გამოიყურება (მოხილული):
ფუნქცია GetBase64AuthorizationHeader(მომხმარებლის სახელი, პაროლი) FileEncoding = TextEncoding.UTF8; TempFile = GetTemporaryFileName(); ჩანაწერი = New TextWrite (TemporaryFile, FileEncoding); Write.Write(მომხმარებლის სახელი+":"+პაროლი); ჩანაწერი.Close(); BinData = New BinaryData (TempFile); შედეგი = Base64String (DvData); DeleteFiles (TempFile); შედეგი = საშუალო (შედეგი,5); დაბრუნების შედეგი; ბოლო ფუნქციები
არის მნიშვნელოვანი წერტილი. HTTPConnection-თან მუშაობისას მიუთითეთ მისამართი "http://" და "https://" პროტოკოლების მითითების გარეშე, წინააღმდეგ შემთხვევაში თქვენ რისკავთ დროის დაკარგვას გაურკვეველი შეცდომის მოსაძებნად.
რეცეპტი 4. გაგზავნა WinHttpRequest-ით
WinHttp = New COMObject ("WinHttp.WinHttpRequest.5.1"); WinHttp.Option(2"UTF-8"); WinHttp.Option(4, 13056); //intSslErrorIgnoreFlag WinHttp.Option(6, true); //blnEnableRedirects WinHttp.Option(12, true); //blnEnableHttpsToHttpRedirects WinHttp.Open("POST", "https://Somesite.ru/WebService/Some/GetCustomer", 0); WinHttp.SetRequestHeader("შინაარსის ტიპი", "ტექსტი/xml"); WinHttp.SetCredentials(მომხმარებლის სახელი, პაროლი, 0); WinHttp.Send(SOAP String); WinHttp.WaitForResponse(15); XMLResponse = WinHttp.ResponseText();აქ, ფაქტობრივად, იგივეა, რაც წინა ვერსიაში, მაგრამ ჩვენ ვმუშაობთ COMObject-თან. ჩვენ ვაზუსტებთ კავშირის სტრიქონს სრულად პროტოკოლთან ერთად. განსაკუთრებული ყურადღება უნდა მიექცეს მხოლოდ დროშებს SSL სერთიფიკატებში შეცდომების იგნორირებაზე. ისინი საჭიროა, თუ ჩვენ ვმუშაობთ SSL-ზე, მაგრამ კონკრეტული სერთიფიკატის გარეშე, რადგან ამ პარამეტრში ახალი უსაფრთხო კავშირის შექმნა შეუძლებელია (ან არ ვიცი როგორ). დანარჩენი მექანიზმი წინა მსგავსია.
გარდა ამისა, გარდა "WinHttp.WinHttpRequest.5.1", შეგიძლიათ გამოიყენოთ "Microsoft.XMLHTTP", "Msxml2.XMLHTTP", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP.6.0", თუ ის მოულოდნელად არ მიიღებს გამორთულია WinHttp-ზე. მეთოდები თითქმის იგივეა, მხოლოდ პარამეტრების რაოდენობა განსხვავებულია. მე ვეჭვობ, რომ ამ ვარიანტებიდან ერთ-ერთი ჩართულია 1c HTTPRequest ობიექტის შიგნით.
ამ დროისთვის, ეს არის ყველა რეცეპტი, რაც მე მაქვს. თუ ახალს წავაწყდი, აუცილებლად დავამატებ სტატიას.
შედეგის დამუშავება
რეცეპტში 1, ჩვენ ყველაზე ხშირად ვიღებთ მზა XDTO ობიექტს და ვმუშაობთ მასზე, როგორც სტრუქტურაში. ყველა სხვა შემთხვევაში, თქვენ შეგიძლიათ გადაიყვანოთ xml პასუხი XDTO-ზე
თუ Result.StatusCode = 200 მაშინ XMLReader = ახალი XMLReader; ReadingXML.SetString(Result.GetBodyAsString()); ResponseObject = OwnFactoryXDTO.ReadXML(ReadingXML); ანგარიში (ObjectResponse.Body.Response.RESPONSE_ID); ანგარიში (ObjectResponse.Body.Response.RESPONSE_TEXT); Დაასრულე თუ;
აქ ყველაფერი მარტივია.
დასკვნის ნაცვლად
1. დაიწყეთ ვებ სერვისებთან მუშაობა SoapUI პროგრამით. ის შექმნილია ასეთი სამუშაოსთვის და საშუალებას მოგცემთ სწრაფად გაიგოთ, როგორ მუშაობს კონკრეტული სერვისი. სასწავლი სტატიაა
2. თუ თქვენ ურთიერთობთ სერვისთან არასაიმედო http არხის საშუალებით და ჩნდება კითხვა, თუ რას აგზავნის 1s თქვენს შეტყობინებებში, მაშინ შეგიძლიათ გამოიყენოთ ტრაფიკის სნაიფერი, როგორიცაა Wireshark, Fiddler და სხვა. პრობლემა წარმოიქმნება მხოლოდ იმ შემთხვევაში, თუ იყენებთ ssl კავშირს.
3. თუ, მიუხედავად ამისა, ვებ სერვისი აკავშირებს https-ის საშუალებით, მაშინ ჩვენ ვაყენებთ Nginx სერვერს დისტანციურ მანქანაზე (ნებისმიერი, რაც მთავარია, არა საკუთარ თავზე), რომელსაც ჩვენ დავუკავშირდებით და ის, თავის მხრივ, შეფუთავს ყველაფერს. https და გაგზავნეთ საჭირო ადგილას (საპირისპირო პროქსი ) და დაამატეთ სტანდარტულ კონფიგურაციას:
სერვერი ( მოსმენა 0.0.0.0:8080; სერვერის სახელი MyServer; მდებარეობა ~ .* ( proxy_pass https://Somesite.ru:8001; proxy_set_header Host $host; proxy_set_header ავტორიზაცია "ძირითადი
5. თუ ავთენტიფიკაცია მოიცავს ქუქიების გამოყენებას, მაშინ ნაპოვნია შემდეგი
P.S. თუ თქვენ გაქვთ შეკითხვები, წინადადებები კოდის გასაუმჯობესებლად, გაქვთ საკუთარი რეცეპტები, რომლებიც განსხვავდება აღწერილისგან, აღმოაჩენთ შეცდომებს ან ფიქრობთ, რომ ავტორი "არასწორია" და ის "არ ეკუთვნის 1-ს", დაწერეთ კომენტარები და განვიხილავთ ყველაფერი.
თემის სათაური ნამდვილად კითხვის ნიშანია, რადგან მე თვითონ არ ვიცი რა არის და პირველად ვეცდები ამ სტატიის ფარგლებში ვიმუშაო. ერთადერთი, რისი გარანტიაც შემიძლია, არის ის, რომ ქვემოთ მოცემული კოდი იმუშავებს, თუმცა, ჩემი ფრაზები იქნება მხოლოდ ვარაუდები და გამოცნობები იმის შესახებ, თუ როგორ მესმის ეს ყველაფერი. ასე რომ წავიდეთ...
შესავალი
ჩვენ უნდა დავიწყოთ იმით, რისთვის შეიქმნა ვებ სერვისების კონცეფცია. ამ კონცეფციის გაჩენის დროისთვის მსოფლიოში უკვე არსებობდა ტექნოლოგიები, რომლებიც საშუალებას აძლევდნენ აპლიკაციებს ურთიერთქმედონ მანძილზე, სადაც ერთ პროგრამას შეეძლო რაიმე მეთოდის გამოძახება სხვა პროგრამაში, რომელიც შემდეგ შეიძლება გაშვებულიყო სხვა ქალაქში ან თუნდაც ქვეყანაში მდებარე კომპიუტერზე. ეს ყველაფერი შემოკლებით არის RPC (Remote Procedure Calling - დისტანციური პროცედურის ზარი). მაგალითები მოიცავს CORBA ტექნოლოგიებს, ხოლო ჯავისთვის - RMI (Remote Method Invoking - დისტანციური მეთოდის გამოძახება). და მათში ყველაფერი კარგად ჩანს, განსაკუთრებით CORBA-ში, რადგან შეგიძლიათ მასთან მუშაობა ნებისმიერ პროგრამირების ენაზე, მაგრამ რაღაც მაინც აკლდა. მე მჯერა, რომ CORBA-ს მინუსი არის ის, რომ ის მუშაობს ზოგიერთი საკუთარი გზით ქსელის პროტოკოლებიჩვეულებრივი HTTP-ის ნაცვლად, რომელიც გაივლის ნებისმიერ ფაიერვოლს. ვებ სერვისის იდეა იყო ისეთი RPC-ის შექმნა, რომელიც გადაიტანებოდა HTTP პაკეტებში. ასე დაიწყო სტანდარტის შემუშავება. რა არის ამ სტანდარტის ძირითადი ცნებები:- საპონი. დისტანციური პროცედურის დარეკვამდე, თქვენ უნდა აღწეროთ ეს ზარი XML ფაილი e SOAP ფორმატი. SOAP არის მხოლოდ ერთი მრავალი XML მარკირება, რომელიც გამოიყენება ვებ სერვისებში. ყველაფერი, რისი გაგზავნა გვსურს სადმე HTTP-ის საშუალებით, ჯერ გადაიქცევა XML SOAP-ის აღწერაში, შემდეგ გადადის HTTP პაკეტში და იგზავნება სხვა კომპიუტერზე ქსელში TCP/IP-ის საშუალებით.
- WSDL. არის ვებ სერვისი, ე.ი. პროგრამა, რომლის მეთოდები შეიძლება დისტანციურად გამოიძახოთ. მაგრამ სტანდარტი მოითხოვს, რომ აღწერილობა დაერთოს ამ პროგრამას, რომელშიც ნათქვამია, რომ ”დიახ, თქვენ არ შემცდარხართ - ეს ნამდვილად ვებ სერვისია და შეგიძლიათ მისგან დარეკოთ ამა თუ იმ მეთოდებს”. ეს აღწერა წარმოდგენილია სხვა XML ფაილით, რომელსაც აქვს განსხვავებული ფორმატი, კერძოდ WSDL. იმათ. WSDL არის მხოლოდ XML ფაილი, რომელიც აღწერს ვებ სერვისს და სხვა არაფერი.
ზოგადი მიდგომა
ვებ სერვისებს ყოველთვის ჰყავს კლიენტი და სერვერი. სერვერი არის ჩვენი ვებ სერვისი და მას ზოგჯერ უწოდებენ საბოლოო წერტილს (როგორიცაა ბოლო წერტილი, სადაც აღწევს SOAP შეტყობინებები კლიენტიდან). ჩვენ უნდა გავაკეთოთ შემდეგი:- აღწერეთ ჩვენი ვებ სერვისის ინტერფეისი
- განახორციელეთ ეს ინტერფეისი
- დაიწყეთ ჩვენი ვებ სერვისი
- დაწერეთ კლიენტი და დისტანციურად დარეკეთ ვებ სერვისის სასურველ მეთოდზე
სერვერი
გაუშვით IDEA და შექმენით ახალი პროექტი შექმენით ახალი პროექტი. მიუთითეთ სახელი hellowebserviceდა დააჭირეთ ღილაკს შემდეგი, შემდეგ ღილაკი დასრულება. საქაღალდეში srcშექმენით პაკეტი en.javarush.ws. ამ პაკეტში ჩვენ შევქმნით HelloWebService ინტერფეისს: პაკეტი ru. ჯავარუშ. ws; // ეს არის ანოტაციები, ე.ი. ჩვენი კლასებისა და მეთოდების აღსანიშნავად, // რაც შეეხება ვებ სერვისის ტექნოლოგიას javax-ის იმპორტი. jws. ვებმეთოდი; javax-ის იმპორტი. jws. ვებსერვისი; javax-ის იმპორტი. jws. საპონი. საპნის შეკვრა; // ჩვენ ვამბობთ, რომ ჩვენი ინტერფეისი იმუშავებს როგორც ვებ სერვისი@WebService // ამბობენ, რომ ვებ სერვისი გამოყენებული იქნება მეთოდების გამოსაძახებლად@SOAPBinding(style = SOAPBinding.Style.RPC) საჯარო ინტერფეისი HelloWebService( // ამბობენ, რომ ეს მეთოდი შეიძლება დისტანციურად დარეკოთ@WebMethod საჯარო სტრიქონი getHelloString(სტრიქონის სახელი) ; ) ამ კოდში WebService და WebMethod კლასები არის ეგრეთ წოდებული ანოტაციები და არაფერს აკეთებენ გარდა ჩვენი ინტერფეისის და მისი მეთოდის ვებ სერვისის მონიშვნისა. იგივე ეხება SOAPBinding კლასს. ერთადერთი განსხვავება ისაა, რომ SOAPBinding არის ანოტაცია პარამეტრებით. AT ამ საქმესსტილის პარამეტრი გამოიყენება მნიშვნელობით, რომელიც მიუთითებს იმაზე, რომ ვებ სერვისი იმუშავებს არა დოკუმენტური შეტყობინებების საშუალებით, არამედ როგორც კლასიკური RPC, ე.ი. მეთოდის დასაძახებლად. მოდით განვახორციელოთ ჩვენი ინტერფეისის ლოგიკა და შევქმნათ HelloWebServiceImpl კლასი ჩვენს პაკეტში. სხვათა შორის, აღვნიშნავ, რომ კლასი, რომელიც მთავრდება Impl-ით, არის კონვენცია ჯავაში, რომლის მიხედვითაც ინტერფეისების დანერგვა ასე არის დანიშნული (Impl - სიტყვიდან განხორციელება, ე.ი. განხორციელება). ეს არ არის მოთხოვნა და თავისუფლად შეგიძლიათ დაასახელოთ კლასს რაც გინდათ, მაგრამ კარგი მანერები ამას მოითხოვს: პაკეტი ru. ჯავარუშ. ws; // იგივე ანოტაცია, როგორც ინტერფეისის აღწერილობისთვის, javax-ის იმპორტი. jws. ვებსერვისი; // მაგრამ აქ ის გამოიყენება endpointInterface პარამეტრით, // ჩვენი ვებ სერვისის ინტერფეისის კლასის სრული სახელის მითითებით@WebService(endpointInterface= "en.javarush.ws.HelloWebService") საჯარო კლასი HelloWebServiceImpl ახორციელებს HelloWebService ( @Override public String getHelloString (სტრიქონის სახელი) ( // უბრალოდ მიუბრუნდი მისალმებასდაბრუნება "გამარჯობა, " + სახელი + "!" ; ) ) გავუშვათ ჩვენი ვებ სერვისი, როგორც დამოუკიდებელი სერვერი, ე.ი. Tomcat-ის და აპლიკაციის სერვერების მონაწილეობის გარეშე (ეს ცალკე განხილვის თემაა). ამისათვის საქაღალდეში არსებული პროექტის სტრუქტურაში srcშევქმნათ პაკეტი ru.javarush.endpoint და მასში შევქმნით HelloWebServicePublisher კლასს მეთოდით main:pack ru. ჯავარუშ. საბოლოო წერტილი; // კლასი ვებ სერვერის დასაწყებად ვებ სერვისებით javax-ის იმპორტი. xml. ws. საბოლოო წერტილი; // ჩვენი ვებ სერვისის კლასიიმპორტი en. ჯავარუშ. ws. hellowebserviceimpl; საჯარო კლასი HelloWebServicePublisher (public static void main (String. . . args)( // ვებ სერვერის გაშვება პორტზე 1986 წ // და პირველ არგუმენტში მითითებულ მისამართზე, // დაიწყეთ მეორე არგუმენტში გადაცემული ვებ სერვისისაბოლოო წერტილი. გამოქვეყნება ( "http://localhost:1986/wss/hello"ახალი HelloWebServiceImpl ()); ) ) ახლა გაუშვით ეს კლასი დაწკაპუნებით Shift + F10. არაფერი გამოჩნდება კონსოლში, მაგრამ სერვერი მუშაობს. ამის გადამოწმება შეგიძლიათ თქვენს ბრაუზერში http://localhost:1986/wss/hello?wsdl აკრეფით. გახსნილი გვერდი, ერთის მხრივ, ადასტურებს, რომ ჩვენ გვაქვს ვებ სერვერი (http://) გაშვებული 1986 წლის პორტზე ჩვენს კომპიუტერზე (localhost) და, მეორე მხრივ, აჩვენებს ჩვენი ვებ სერვისის WSDL აღწერას. თუ აპლიკაციას შეწყვეტთ, აღწერა მიუწვდომელი გახდება, ისევე როგორც თავად ვებ სერვისი, ამიტომ ჩვენ ამას არ გავაკეთებთ, არამედ გადავალთ კლიენტის წერაზე.დამკვეთი
პროექტის საქაღალდეში srcშევქმნათ პაკეტი ru.javarush.client და მასში HelloWebServiceClient კლასი ძირითადი მეთოდით: პაკეტი ru. ჯავარუშ. კლიენტი; // საჭიროა wsdl აღწერილობის მისაღებად და მისი მეშვეობით // მიაღწიეთ თავად ვებ სერვისსჯავას იმპორტი. ბადე. URL; // ასეთი გამონაკლისი მოხდება URL ობიექტთან მუშაობისასჯავას იმპორტი. ბადე. არასწორიURLEგამონაკლისი; // კლასები xml-ის გასაანალიზებლად wsdl აღწერილობით // და მიაღწიეთ მასში სერვისის ტეგს javax-ის იმპორტი. xml. სახელთა სივრცე. Qname; javax-ის იმპორტი. xml. ws. მომსახურება; // ჩვენი ვებ სერვისის ინტერფეისი (მეტი გვჭირდება)იმპორტი en. ჯავარუშ. ws. hellowebservice; საჯარო კლასი HelloWebServiceClient( public static void main(String args) ისვრის MalformedURLException( // შექმენით ბმული wsdl აღწერილობაში url= ახალი url ( "http://localhost:1986/wss/hello?wsdl") ; // ჩვენ ვუყურებთ შემდეგი კონსტრუქტორის პარამეტრებს პირველივე WSDL აღწერილობის ტეგში - განმარტებები // შეხედეთ 1 არგუმენტს targetNamespace ატრიბუტში // მე-2 არგუმენტი იხილეთ სახელის ატრიბუტში QName qname = new QName ("http://ws.site/" , "HelloWebServiceImplService" ); // ახლა ჩვენ შეგვიძლია მივაღწიოთ სერვისის ტეგს wsdl აღწერილობაში, სერვის სერვისი= მომსახურება. შექმნა (url, qname) ; // და შემდეგ მასში ჩადგმულ პორტის ტეგს, ასე რომ // მიიღეთ მითითება ჩვენგან დაშორებულ ვებ სერვისის ობიექტზე HelloWebService გამარჯობა = სერვისი. getPort(HelloWebService.class); // ჰორი! ახლა შეგიძლიათ დარეკოთ დისტანციური მეთოდითსისტემა. გარეთ. println(გამარჯობა. getHelloString("JavaRush") ); ) ) მე ვაძლევდი მაქსიმუმ კომენტარს ჩამონათვალში არსებულ კოდზე. დასამატებელი არაფერი მაქვს, ასე რომ გაუშვით (Shift + F10). ჩვენ უნდა ვნახოთ ტექსტი კონსოლში: გამარჯობა, JavaRush! თუ არ გინახავთ, მაშინ ალბათ დაგავიწყდათ ვებ სერვისის გაშვება.დასკვნა
ამ თემაში წარმოდგენილი იყო მოკლე ექსკურსია ვებ სერვისებში. კიდევ ერთხელ, ბევრი რამ, რაც დავწერე, არის ჩემი ვარაუდი იმის შესახებ, თუ როგორ მუშაობს და, შესაბამისად, არ უნდა ვენდო ძალიან. მადლობელი ვიქნები, თუ მცოდნე ხალხიგამოვასწორებ, რადგან მერე რაღაცას ვისწავლი. UPD.ალექსეი ბოიკო
SOAP და XML ვებ სერვისები .Net-ში
XML ვებ სერვისები გთავაზობთ თავსებადობისა და თავსებადობის დონეს ოპერაციულ სისტემებთან მიმართებაში,
პლატფორმები და ენები, რომლებიც ადრე უბრალოდ მიუწვდომელი იყო.
ენდრიუ ტროელსენი (მაიკროსოფტის MVP-ის ყველაზე ღირებული პროფესიონალი)
თუ ჯერ არ გიმუშავიათ XML ვებ სერვისებთან, ალბათ გსმენიათ სიტყვა "SOAP". დროა გავუმკლავდეთ ამ ცნებებს.
შესავალი
თუ გაინტერესებთ ინტერნეტი ან უფრო მცირე ქსელები, დიდი შანსია, ადრე თუ გვიან შეგხვდეთ XML ვებ სერვისები. XML ვებ სერვისი უფრო მეტია, ვიდრე უბრალოდ ვებ აპლიკაცია, რომელსაც შეუძლია ინფორმაციის ჩვენება ბრაუზერში. პირიქით, ეს არის დისტანციური ტექნოლოგია, რომელიც საშუალებას გაძლევთ გამოიძახოთ ქსელში ობიექტის მეთოდები და თვისებები სტანდარტული HTTP მოთხოვნების გამოყენებით.
პრაქტიკაში, ეს ნიშნავს, რომ ასეთი სერვისის კლიენტებს შეუძლიათ დაიწერონ სხვადასხვა ენაზე და სხვადასხვა ოპერაციული სისტემისთვის.
როგორც საინფორმაციო „ტრანსპორტი“ სერვისსა და კლიენტს შორის, შეგიძლიათ გამოიყენოთ GET ან POST HTTP მეთოდები.
და თქვენ შეგიძლიათ "დააწესოთ" სხვა პროტოკოლი თავზე - SOAP (Simple Object Access Protocol). ეს ჩვეულებრივ კეთდება, რადგან ამ შემთხვევაში შესაძლებელია რთული ტიპების (მათ შორის მომხმარებლის მიერ განსაზღვრული) გადაცემა. და კლასიკური GET და POST მეთოდები მხარს უჭერს მხოლოდ სიებს, მარტივ მასივებს და სტრიქონებს.
SOAP კომუნიკაციის მაგალითი
SOAP შეტყობინება არის XML დოკუმენტი, რომელიც მოთავსებულია HTTP მოთხოვნის სხეულში.
ჩამონათვალი 1. SOAP შეტყობინების სტრუქტურა
კლიენტსა და სერვისს შორის ურთიერთქმედება შემდეგია:
- კლიენტი აყალიბებს SOAP მოთხოვნას და აგზავნის სერვისს;
- მომსახურება ჩართულია დისტანციური კომპიუტერიახორციელებს პროცედურას და აგზავნის SOAP პასუხს.
მაგალითად, SOAP მოთხოვნა დისტანციური XML ვებ სერვისის HelloWorld() მეთოდის გამოძახებით შეიძლება ასე გამოიყურებოდეს:
ჩამონათვალი 2. SOAP მოთხოვნის ნიმუში
HelloWorld() მეთოდი, როგორც მოსალოდნელი იყო, აბრუნებს სტრიქონს "Hello world!":
ჩამონათვალი 3. საპნის პასუხის ნიმუში
Xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
XML ვებ სერვისის შექმნა .NET 2.0-ში
შეგიძლიათ შექმნათ სერვისი სხვადასხვა გზები, გამოვიყენებთ Visual Studio 2005. დააწკაპუნეთ "ფაილი -> ახალი -> ვებ საიტი", გახსნილ ფანჯარაში აირჩიეთ "ASP.NET web Service". შექმნისას მითითებულ მისამართზე ნახავთ შემდეგ ფაილებს და დირექტორიას (იხ. სურ. 1).
პრინციპში, სერვისი შეიძლება შეიცავდეს მხოლოდ ერთ *.asmx ფაილს. (*.asmx გაფართოება გამოიყენება .Net ვებ სერვისების აღსანიშნავად.) ამ შემთხვევაში, ეს ასე არ არის, შეხედეთ Service.asmx ფაილის შიგთავსს:
ჩამონათვალი 4. Service.asmx განსაზღვრავს გარე ფაილიმხარდაჭერა
<%@ WebService Language="C#" CodeBehind="~/App_Code/Service.cs" class="Service" %>
CodeBehind ატრიბუტი განსაზღვრავს გარე ფაილს, რომელიც მდებარეობს App_Code საქაღალდეში, რომელიც შეიცავს პროგრამის კოდს, რომელიც ახორციელებს HelloWorld() მეთოდს:
ჩამონათვალი 5. Service.cs ფაილი, რომელიც ახორციელებს HelloWorld() მეთოდს
სისტემის გამოყენებით;
System.Web-ის გამოყენებით;
System.Web.Services-ის გამოყენებით;
საჯარო სამსახური ()
დაბრუნება "Hello World";
შესაძლებელია ერთი Service.asmx ფაილის შექმნა მხარდაჭერის კოდის გარეშე, რომელსაც აქვს იგივე ფუნქციონირება:
ჩამონათვალი 6. Service.asmx გარე მხარდაჭერის კოდის გარეშე
<%@ WebService Language="C#" class="Service" %>
სისტემის გამოყენებით;
System.Web-ის გამოყენებით;
System.Web.Services-ის გამოყენებით;
System.Web.Services.Protocols-ის გამოყენებით;
საჯარო კლასის სერვისი: System.Web.Services.WebService
საჯარო სამსახური ()
საჯარო სტრიქონი HelloWorld() (
დაბრუნება "Hello World";
ჩვენ ეს არ გვჭირდება და არც გავაკეთებთ.
როგორც ხედავთ, ჩვენი ვებ სერვისის ერთი მეთოდი მონიშნულია ატრიბუტით, რომელიც აცნობებს ASP.NET გაშვების დროს, რომ ეს მეთოდი ხელმისაწვდომია შემომავალი HTTP მოთხოვნებისთვის. წევრები, რომლებიც არ არის მონიშნული ამ ატრიბუტით, არ იქნებიან ხელმისაწვდომი კლიენტის პროგრამებისთვის.
ასეთი მარტივი სერვისი საკმაოდ შესაფერისია ჩვენი ექსპერიმენტებისთვის, რჩება მხოლოდ მისი გამოქვეყნება.
XML ვებ სერვისის გამოქვეყნება IIS-ის გამოყენებით
საუბარი იქნება არა ინტერნეტში გამოქვეყნებაზე, არამედ ლოკალურ კომპიუტერზე ჩვენი სერვისის შესამოწმებლად პირობების შექმნაზე.
პირველი, დააინსტალირეთ IIS (ინტერნეტ ინფორმაციის სერვერი). ამისათვის გახსენით "პროგრამების დამატება ან წაშლა" ფანჯარა და აირჩიეთ "ინსტალაცია ვინდოუსის კომპონენტები". (Ზოგიერთი ვინდოუსის ვერსიებიარ საჭიროებს IIS-ის დაყენებას, როგორიცაა Windows XP Home Edition.)
Შენიშვნა: IIS სერვერიუმჯობესია დააინსტალიროთ .Net Framework-ზე ადრე, წინააღმდეგ შემთხვევაში მოგიწევთ IIS-ის კონფიგურაცია .Net აპლიკაციების მხარდასაჭერად უტილიტის გაშვებით. ბრძანების ხაზი aspnet_regiis.exe (/i დროშით).
შექმენით ვირტუალური დირექტორია. თუ იყენებთ Windows XP Pro-ს, გადადით "Control Panel -> Administrative Tools -> Internet Information Services". ფანჯარაში, რომელიც იხსნება, აირჩიეთ "მოქმედება -> შექმნა -> ვირტუალური დირექტორია".
ვირტუალური დირექტორიის შექმნის ოსტატი დაიწყება. მიუთითეთ Soap1, როგორც მეტსახელი და დააყენეთ გზა იმ დირექტორიაში, სადაც გსურთ სერვისის განთავსება, მაგალითად C:\Soap1. ახლა დააკოპირეთ ჩვენი ვებ სერვისის შინაარსი იქ.
ჩაწერეთ http://localhost/soap1/Service.asmx თქვენი ბრაუზერის მისამართების ზოლში და თქვენ უნდა ნახოთ სერვისის ტესტის გვერდი (იხ. სურათი 2).
SOAP შეტყობინებების ნახვა
სატესტო გვერდი არ იძლევა SOAP შეტყობინებების გაგზავნას და წაკითხვას. ამ მიზეზით, თქვენ მოგიწევთ გამოიყენოთ მესამე მხარის განვითარება, გირჩევთ გამოიყენოთ soapUI. (ეს არის უფასო პროდუქტი, რომელიც ხელმისაწვდომია http://www.soapui.org.)
მას შემდეგ, რაც soapUI დაინსტალირდება, შექმენით ახალი პროექტი სახელწოდებით soap1 და დატოვეთ საწყისი WSDL ველი ცარიელი (იხ. სურათი 3).
დააწკაპუნეთ ახლად შექმნილ პროექტზე მარჯვენა ღილაკით და აირჩიეთ "დაამატე WSDL URL-დან". დიალოგურ ფანჯარაში, რომელიც იხსნება, შეიყვანეთ http://localhost/soap1/Service.asmx?wsdl. ახლა ჩვენ გვაქვს შესაძლებლობა გავუგზავნოთ SOAP მოთხოვნები ჩვენს სერვისს და ვნახოთ მიღებული პასუხები. (მოთხოვნები ავტომატურად გენერირებული იქნება soapUI-ის მიერ.)
რა არის ეს WSDL? WSDL დოკუმენტი აღწერს, თუ როგორ შეუძლიათ კლიენტებს ვებ სერვისთან ურთიერთობა. მასში აღწერილია, თუ რომელი სერვისის მეთოდებია ხელმისაწვდომი გარე ზარისთვის, რა პარამეტრებს იღებენ და რას აბრუნებენ, ასევე სხვა ინფორმაციას, რომელიც აუცილებელია დისტანციური მუშაობისთვის. ასეთი დოკუმენტის შედგენა შესაძლებელია ხელით, ან მისი გენერაცია მიანდოთ სერვერს, ამისთვის საკმარისია *.asmx ფაილზე მითითებულ URL-ზე ?wsdl სუფიქსის დამატება.
ჩვენი სერვისისთვის WSDL დოკუმენტის სანახავად, თქვენს ბრაუზერში შეიყვანეთ http://localhost/soap1/Service.asmx?wsdl. ინფორმაცია ამ დოკუმენტიდან გამოიყენება soapUI-ის მიერ SOAP მოთხოვნების ავტომატურად გენერირებისთვის.
საპნის გაფართოებები
როგორც თქვენ შენიშნეთ, XML ვებ სერვისის შესაქმნელად (კლიენტის მსგავსად) არ უნდა ინერვიულოთ SOAP შეტყობინებების ფორმაზე. საკმარისია სასურველი მეთოდების ატრიბუტით მონიშვნა და ASP.NET runtime თავად შეადგენს სასურველი ფორმატის პაკეტებს.
ნახ. სურათი 4 გვიჩვენებს ვებ სერვისის მოთხოვნას და პასუხს, რომელიც მიღებულია soapUI პროგრამის გამოყენებით.
კიდევ გავიმეოროთ. მოთხოვნა გენერირდება soapUI - სერვისისთვის რეალური კლიენტების შექმნისას ასევე არ გჭირდებათ SOAP პაკეტების ხელით ფორმატირება. ჩვენ ასევე უშუალოდ არ მიგვიღია მონაწილეობა სერვისის პასუხის შექმნაში. ეს ყველაფერი ავტომატურად ხდება.
თუმცა, სავარაუდოა, რომ თქვენ თავად დაგჭირდებათ ამ პაკეტების შეცვლა. მაგალითად, გადაცემული მონაცემების შეკუმშვა ან დაშიფვრა. ეს არის SOAP Extensions-ის მიზანი.
SOAP Extensions არის მექანიზმი, რომელიც საშუალებას გაძლევთ თვითნებურად შეცვალოთ მიღებული და გაგზავნილი SOAP შეტყობინებები.
SOAP შეტყობინების გზა
პროგრამირების დასაწყებად, ჩვენ უნდა გავითვალისწინოთ გზა, რომელსაც SOAP შეტყობინება გადის მის მიღებამდე და შესაბამისი მეთოდით დამუშავებამდე (იხ. სურათი 5).
SOAP შეტყობინება შეიძლება ჩაითვალოს XML დოკუმენტად, რომელიც აღწერს ქსელში გადაცემულ ობიექტს. სანამ ამ გზით გადაცემული ობიექტი გამოიყენებოდეს, ის უნდა აღდგეს (ან, თუ გსურთ, აწყობილი) ამ აღწერილობიდან. XML სერიალიზატორი ემსახურება ამ მიზანს.
შემომავალი პაკეტების დესერიალიზება ხდება (ობიექტის აღდგენა XML აღწერილობიდან), ხოლო გაგზავნილი პაკეტები სერიულირდება (ობიექტის XML აღწერილობის შექმნა).
ნახ. სურათი 5 გვიჩვენებს ოთხ წერტილს (BeforeSerialize, AfterDeserialize, BeforeDeserialize, AfterSerialize), სადაც ჩვენ შეგვიძლია ჩავჭრათ SOAP შეტყობინება SOAP Extensions-ის გამოყენებით. შეცვალეთ იგი და გააგზავნეთ.
SOAP გაფართოების დანერგვა
პირველი, მოდით განვსაზღვროთ დავალება: ვთქვათ, გვინდა შევცვალოთ ვებ სერვისის მიერ გამოგზავნილი SOAP პაკეტები, როგორც ნაჩვენებია სიაში 7:
ჩამონათვალი 7. "ძველი" და ახალი XML ვებ სერვისის პასუხები
Xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
Xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> შიფრული ტექსტი
SOAP Extension-ის განხორციელების სამოქმედო გეგმა:
- ჩვენ ვქმნით dll-ს კლასით, რომელიც მემკვიდრეობით იღებს SoapExtension-ს.
- ჩვენ ვამატებთ bin საქაღალდეს ჩვენს ვებ სერვისს და ვდებთ იქ შექმნილ dll-ს.
- დაამატეთ web.config ფაილი სერვისს და შეიტანეთ მასში საჭირო ცვლილებები.
bin საქაღალდის და web.config ფაილის როლი მოგვიანებით იქნება განხილული.
DLL-ის შექმნა SOAP Extension-ით
შექმენით ახალი "კლასების ბიბლიოთეკა" პროექტი სახელწოდებით SoapExtensionLib. ამ პროექტს დასჭირდება მხოლოდ ერთი კლასის დანერგვა, რომელიც შეასრულებს ჩვენთვის საჭირო SOAP პაკეტების ცვლილებებს. ეს კლასი უნდა იყოს მიღებული SoapExtension კლასიდან.
ჩამონათვალი 8. კლასის შექმნა, რომელიც მემკვიდრეობით მიიღებს SoapExtension-ს
სისტემის გამოყენებით;
System.Web.Services-ის გამოყენებით;
System.Web.Services.Protocols-ის გამოყენებით;
System.IO-ს გამოყენებით;
System.Net-ის გამოყენებით;
System.Xml-ის გამოყენებით;
თითოეული SOAP Extension პარამეტრად იღებს ნაკადს, რომელიც შეიცავს ქსელში გადაცემულ ობიექტს (სერიალიზაციამდე ან მის შემდეგ). და უნდა დააბრუნოს ნაკადი.
SOAP Extension შეიძლება მივიჩნიოთ, როგორც "გვერდითი ზოლი", რომელიც შეიძლება განთავსდეს 2-ზე ნაჩვენები ოთხივე წერტილში (BeforeSerialize, AfterDeserialize, BeforeDeserialize, AfterSerialize). 5. თითოეულ წერტილში შეიძლება იყოს ნებისმიერი რაოდენობის ასეთი „ჩანართები“ (იხ. სურ. 6).
ამ ნაკადების მისაღებად გამოიყენეთ ChainStream მეთოდი.
ჩამონათვალი 9. ChainStream მეთოდის დანერგვა
საჯარო კლასის TraceExtension: SoapExtension
Stream wireStream;
სტრიმი appStream;
// მეთოდი, როგორც შეყვანის პარამეტრი
// იღებს ნაკადს, რომელიც შეიცავს გადაცემულ ობიექტს
საზოგადოებრივი უგულებელყოფა Stream ChainStream (ნაკადის ნაკადი)
WireStream = ნაკადი;
AppStream = new MemoryStream();
დააბრუნეთ appStream;
…
BeforeDeserialize წერტილში, wireStream შეიცავს ქსელიდან მიღებულ SOAP მოთხოვნას. ეს SOAP მოთხოვნა უნდა გადაეცეს აპლიკაციის ნაკადს (appStream ნაკადი).
ხოლო AfterSerialize წერტილში თქვენ უნდა გადასცეთ wireStream-ს ქსელში გაგზავნილი SOAP პასუხი, რომელიც განთავსდება appStream-ში.
ოთხივე წერტილში ძაფებთან მუშაობისთვის, თქვენ უნდა განახორციელოთ ProcessMessage მეთოდი.
ჩამონათვალი 10. ProcessMessage მეთოდის დანერგვა, რომელიც არ ცვლის SOAP შეტყობინებებს
// ProcessMessage, რომელიც აკეთებს სავალდებულო ასლს
// ნაკადი ორ წერტილში (BeforeDeserialize და AfterSerialize)
გადართვა (შეტყობინება. ეტაპი)
// წერტილში BeforeDeserialize უნდა გაიაროს
// SOAP მოთხოვნა ქსელის ნაკადიდან (wireStream)
// აპლიკაციის ნაკადში (appStream)
Case SoapMessageStage.BeforeDeserialize:
კოპირება (wireStream, appStream);
AppStream.Position = 0;
შესვენება;
// პუნქტში AfterSerialize უნდა გაიაროს
// SOAP პასუხი აპლიკაციის ძაფიდან ქსელის ძაფამდე
AppStream.Position = 0;
შესვენება;
void ასლი (სტრიმინგი-დან, ნაკადი-მდე)
TextReader reader = new StreamReader(from);
TextWriter writer = new StreamWriter(to);
Writer.WriteLine(reader.ReadToEnd());
Writer.Flush();
ჩამონათვალი 10 შეიძლება იქნას მიღებული, როგორც ცარიელი შემდგომი ექსპერიმენტებისთვის. ProcessMessage მეთოდის ამ განხორციელებას აზრი არ აქვს - გამავალი SOAP პასუხი არანაირად არ იცვლება. გამოვასწოროთ ეს:
ჩამონათვალი 11. ProcessMessage მეთოდის დანერგვა, რომელიც ცვლის SOAP პასუხს
საჯარო უგულებელყოფა void ProcessMessage (SoapMessage message)
გადართვა (შეტყობინება. ეტაპი)
Case SoapMessageStage.AfterSerialize:
WriteOutput (მესიჯი);
შესვენება;
// კოდის ნაწილი სივრცის დაზოგვის მიზნით
// გადაწერეთ SOAP პასუხი
საჯარო void WriteOutput (SoapMessage შეტყობინება)
AppStream.Position = 0;
// შექმენით XML დოკუმენტი ნაკადიდან
XmlDocument დოკუმენტი = new XmlDocument();
Document.Load(appStream);
// XPath-ის გამოსაყენებლად, თქვენ უნდა განსაზღვროთ
// NamespaceManager
XmlNamespaceManager nsmgr = new XmlNamespaceManager(document.NameTable);
Nsmgr.AddNamespace("საპონი", "http://schemas.xmlsoap.org/soap/envelope/");
XmlNode ResultNode = document.SelectSingleNode("//soap:Body", nsmgr);
// შეცვალოს კვანძის შინაარსი
ResultNode.InnerText = "შიფრული ტექსტი";
// გაასუფთავეთ ნაკადი და დაწერეთ მასზე ახალი SOAP პასუხი
AppStream.SetLength(0);
AppStream.Position = 0;
Document.Save(appStream);
// საჭირო მოქმედება
// გაიარეთ SOAP პასუხი აპლიკაციის ნაკადიდან (appStream)
// ქსელის ნაკადში (wireStream)
AppStream.Position = 0;
კოპირება (appStream, wireStream);
შემდეგი, ჩვენ უნდა განვსაზღვროთ ორი მეთოდი (რომელთაგან ერთი გადატვირთულია, ანუ შეიძლება გამოვიძახოთ პარამეტრების სხვადასხვა ნაკრებით), რომლებიც ჩვენს შემთხვევაში არ არის საჭირო. თუმცა, ისინი უნდა განვსაზღვროთ SoapExtension კლასიდან მემკვიდრეობის წესების მიხედვით.
ჩამონათვალი 12. სხვა სავალდებულო მეთოდები
// სამკვიდრო წესით უნდა
// განსაზღვრეთ ეს მეთოდები, მაგრამ ჩვენ მათ არანაირად არ ვიყენებთ
საჯარო გადაფარვის ობიექტი?
GetInitializer (LogicalMethodInfo methodInfo, SoapExtensionAttribute ატრიბუტი)
დაბრუნება null;
საჯარო გადაფარვის ობიექტი GetInitializer (ტიპი WebServiceType)
დაბრუნება null;
საჯარო გადაფარვა void Initialize (ობიექტის ინიციალატორი)
დაბრუნების;
ყველაფერი, ჩვენ ვადგენთ პროექტს. ჩვენ საბოლოოდ მივიღეთ SOAP Extension dll. SoapExtensionLib.dll-ის სრული ჩამონათვალი ხელმისაწვდომია ჟურნალის ვებსაიტზე წყაროს კოდის განყოფილებაში.
ვებ სერვისის კონფიგურაცია SOAP Extension-თან მუშაობისთვის
კვლავ გახსენით ჩვენი XML ვებ სერვისის პროექტი Visual Studio-ით. დააწკაპუნეთ "WebSite -> Add Reference" და აირჩიეთ SoapExtensionLib.dll, რომელიც ადრე შექმენით.
Bin საქაღალდე ავტომატურად დაემატება პროექტს. Bin საქაღალდეში მდებარე *.dll ფაილებს ავტომატურად მიმართავენ აპლიკაცია.
ახლა ჩადეთ Web.Config ფაილი ვებ სერვისის დირექტორიაში შემდეგი შინაარსით:
ჩამონათვალი 13. Web.Config ფაილი
პრიორიტეტი = "1" ჯგუფი = "0" />
ახლა ჩვენი სერვისის სტრუქტურა გამოიყურება ისე, როგორც ნაჩვენებია ნახ. 7. Web.Config ფაილის გამოყენებით ვაცნობთ ASP.NET გარემოს, რომ დავამატეთ XML Soap Extension ვებ სერვისს, რომელიც დანერგილია SoapExtensionLi.dll ფაილში მდებარე TraceExtension კლასში. ჩამონათვალი 14. WebServices განყოფილება Web.Config ფაილში პრიორიტეტი = "1" ჯგუფი = "0" />
როგორც უკვე იცით, შეგიძლიათ გააკეთოთ მრავალი SOAP Extension, და ნაკადი, რომელიც ატარებს გადაცემულ ობიექტს (სერიალიზაციამდე ან მის შემდეგ) გაივლის თითოეულ მათგანს. თანმიმდევრობა, რომლითაც ნაკადი გადის სხვადასხვა SOAP გაფართოებებს, მითითებულია პრიორიტეტისა და ჯგუფის ატრიბუტების გამოყენებით. აღსანიშნავია, რომ Web.Config-ის ამ გზით კონფიგურაციით ჩვენ ვაცნობებთ გარემოს, რომ ჩვენი SOAP Extension გამოიძახება ატრიბუტით მონიშნული სერვისის თითოეული მეთოდისთვის. შესაძლებელია შექმნათ თქვენი საკუთარი ატრიბუტი და მონიშნოთ მხოლოდ ის მეთოდები, რისთვისაც გჭირდებათ SOAP Extension-ის გამოძახება. ჩამონათვალი 15. მორგებული ატრიბუტის მაგალითი საჯარო სტრიქონი HelloWorld() ( დაბრუნება "Hello World"; ამისათვის დაამატეთ SoapExtensionAttribute-დან მემკვიდრეობით მიღებული კლასი SoapExtensionLi.dll-ს (იხ. სურათი 8). დასკვნა ეს სტატია ასახავს XML ვებ სერვისების აშენებისა და ფუნქციონირების ძირითად პუნქტებს .Net პლატფორმაზე. ვიმედოვნებ, რომ წარმოდგენილი მასალა სავსებით საკმარისი იქნება, რათა საჭიროების შემთხვევაში თემის უფრო ღრმად შესწავლა შეძლოთ. კონტაქტში
