വെബ് സേവനങ്ങൾ സംഘടിപ്പിക്കുന്നു
തൊപ്പികൾ ജൂലൈ 23, 2013 01:09 pm
PHP-യിൽ ഒരു SOAP ക്ലയന്റ്-സെർവർ ആപ്ലിക്കേഷൻ എഴുതുന്നു
- PHP
- ട്യൂട്ടോറിയൽ
എല്ലാവർക്കും ഹായ്!
അടുത്തിടെ ഞാൻ വെബ് സേവനങ്ങളുടെ വികസനത്തിൽ ഏർപ്പെട്ടിട്ടുണ്ട്. എന്നാൽ ഇന്ന് വിഷയം എന്നെക്കുറിച്ചല്ല, SOAP 1.2 പ്രോട്ടോക്കോളിനെ അടിസ്ഥാനമാക്കി നമുക്ക് എങ്ങനെ സ്വന്തം XML വെബ് സേവനം എഴുതാം എന്നതിനെക്കുറിച്ചാണ്.
വിഷയം വായിച്ചതിനുശേഷം, നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാൻ കഴിയുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു:
- ഒരു വെബ് ആപ്ലിക്കേഷന്റെ സ്വന്തം സെർവർ നടപ്പിലാക്കൽ എഴുതുക;
- ഒരു വെബ് ആപ്ലിക്കേഷന്റെ നിങ്ങളുടെ സ്വന്തം ക്ലയന്റ് നടപ്പിലാക്കൽ എഴുതുക;
- നിങ്ങളുടെ സ്വന്തം വെബ് സേവന വിവരണം (WSDL) എഴുതുക;
- ക്ലയന്റ് സെർവറിലേക്ക് ഒരേ തരത്തിലുള്ള ഡാറ്റയുടെ അറേകൾ അയയ്ക്കുക.
1 പ്രശ്ന പ്രസ്താവന
1.1 അതിർത്തികൾ
തുടക്കത്തിൽ, വിഷയത്തിന്റെ അവസാനത്തിൽ ഞങ്ങൾ കൈവരിക്കുന്ന ഫലം കൈകാര്യം ചെയ്യാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. മുകളിൽ പ്രഖ്യാപിച്ചതുപോലെ, ഞങ്ങൾ എസ്എംഎസ് സന്ദേശങ്ങൾ അയയ്‌ക്കുന്നതിന് ഒരു സേവനം എഴുതും, കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, SOAP പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് വ്യത്യസ്ത ഉറവിടങ്ങളിൽ നിന്ന് ഞങ്ങൾക്ക് സന്ദേശങ്ങൾ ലഭിക്കും. അതിനുശേഷം, അവർ ഏത് രൂപത്തിലാണ് സെർവറിലേക്ക് വരുന്നത് എന്ന് ഞങ്ങൾ പരിഗണിക്കും. നിർഭാഗ്യവശാൽ, ദാതാവിന് കൂടുതൽ അയയ്‌ക്കുന്നതിനായി സന്ദേശങ്ങൾ ക്യൂവിൽ നിർത്തുന്ന പ്രക്രിയ പല കാരണങ്ങളാൽ ഈ പോസ്റ്റിന്റെ പരിധിക്കപ്പുറമാണ്.
1.2 ഏത് ഡാറ്റ മാറ്റും?
ശരി, ഞങ്ങൾക്ക് പരിധികളുണ്ട്! സെർവറും ക്ലയന്റും തമ്മിൽ എന്ത് ഡാറ്റയാണ് നമ്മൾ കൈമാറേണ്ടതെന്ന് തീരുമാനിക്കുക എന്നതാണ് അടുത്ത ഘട്ടം ചെയ്യേണ്ടത്. ഈ വിഷയത്തിൽ, വളരെക്കാലം ബുദ്ധിമാനായിരിക്കരുതെന്ന് ഞാൻ നിർദ്ദേശിക്കുന്നു, കൂടാതെ നിങ്ങൾക്കായി പ്രധാന ചോദ്യങ്ങൾക്ക് ഉടനടി ഉത്തരം നൽകുക:- ഒരു സബ്‌സ്‌ക്രൈബർക്ക് ഒരു SMS സന്ദേശം അയയ്‌ക്കുന്നതിന് സെർവറിലേക്ക് ഏറ്റവും കുറഞ്ഞ ഡാറ്റ എന്താണ് അയയ്ക്കേണ്ടത്?
- ക്ലയന്റിന്റെ ആവശ്യങ്ങൾ നിറവേറ്റുന്നതിനായി സെർവറിൽ നിന്ന് അയയ്‌ക്കേണ്ട ഏറ്റവും കുറഞ്ഞ ഡാറ്റ എത്രയാണ്?
- മൊബൈൽ ഫോൺ നമ്പർ, കൂടാതെ
- SMS ടെക്സ്റ്റ്.
- SMS സന്ദേശം അയച്ച തീയതി.
- സന്ദേശ തരം.
എന്നിട്ടും, ഞാൻ ഒരു കാര്യം മറന്നു! ഞങ്ങൾ കുറച്ചുകൂടി പ്രതിഫലിപ്പിക്കുകയാണെങ്കിൽ, ക്ലയന്റിന് ഒരു സമയം സെർവറിലേക്ക് ഒരു SMS സന്ദേശം അല്ലെങ്കിൽ അവയിൽ ഒരു നിശ്ചിത എണ്ണം അയയ്ക്കാൻ കഴിയുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു ഡാറ്റ പാക്കറ്റിൽ ഒന്ന് മുതൽ അനന്തമായ സന്ദേശങ്ങൾ വരെ ഉണ്ടാകാം.
തൽഫലമായി, ഒരു SMS സന്ദേശം അയയ്‌ക്കുന്നതിന്, ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഡാറ്റ ആവശ്യമാണ്:
- സെൽഫോൺ നമ്പർ,
- എസ്എംഎസ് ടെക്സ്റ്റ്,
- ഒരു വരിക്കാരന് SMS സന്ദേശം അയക്കുന്ന സമയം,
- സന്ദേശ തരം.
ഞങ്ങൾ ആദ്യ ചോദ്യത്തിന് ഉത്തരം നൽകി, ഇപ്പോൾ രണ്ടാമത്തെ ചോദ്യത്തിന് ഉത്തരം നൽകേണ്ടത് ആവശ്യമാണ്. ഒരുപക്ഷേ ഞാൻ എന്നെത്തന്നെ കുറച്ച് വഞ്ചിക്കാൻ അനുവദിക്കും. അതിനാൽ, സെർവറിൽ നിന്ന് ഞങ്ങൾ ബൂളിയൻ ഡാറ്റ മാത്രമേ അയയ്ക്കൂ, അതിന്റെ മൂല്യത്തിന് ഇനിപ്പറയുന്ന അർത്ഥമുണ്ട്:
- ശരി - പാക്കറ്റ് വിജയകരമായി സെർവറിലെത്തി, ആധികാരികത ഉറപ്പാക്കി, എസ്എംഎസ് ദാതാവിന് അയയ്‌ക്കുന്നതിനായി ക്യൂവിലാണ്
- തെറ്റ് - മറ്റെല്ലാ സാഹചര്യങ്ങളിലും
ഇത് പ്രശ്ന പ്രസ്താവനയുടെ വിവരണം അവസാനിപ്പിക്കുന്നു! അവസാനമായി, നമുക്ക് ഏറ്റവും രസകരമായ ഭാഗത്തേക്ക് ഇറങ്ങാം - ഈ സോപ്പ് ഏത് തരത്തിലുള്ള വിചിത്രമായ മൃഗമാണെന്ന് ഞങ്ങൾ കണ്ടെത്തും!
2 എന്താണ് സോപ്പ്?
പൊതുവേ, ആദ്യം SOAP എന്താണെന്നതിനെക്കുറിച്ച് ഒന്നും എഴുതാൻ ഞാൻ പദ്ധതിയിട്ടിരുന്നില്ല, കൂടാതെ ആവശ്യമായ സ്പെസിഫിക്കേഷനുകളും വിക്കിപീഡിയയിലേക്കുള്ള ലിങ്കുകളും ഉള്ള w3.org സൈറ്റിലേക്കുള്ള ലിങ്കുകളിലേക്ക് എന്നെത്തന്നെ പരിമിതപ്പെടുത്താൻ ഞാൻ ആഗ്രഹിച്ചു. എന്നാൽ അവസാനം ഈ പ്രോട്ടോക്കോളിനെക്കുറിച്ച് ഒരു ചെറിയ റഫറൻസ് എഴുതാൻ ഞാൻ തീരുമാനിച്ചു.ഈ ഡാറ്റാ എക്സ്ചേഞ്ച് പ്രോട്ടോക്കോൾ RPC (റിമോട്ട് പ്രൊസീജ്യർ കോൾ) മാതൃകയെ അടിസ്ഥാനമാക്കിയുള്ള പ്രോട്ടോക്കോളുകളുടെ ഒരു ഉപവിഭാഗത്തിൽ പെട്ടതാണ് എന്ന വസ്തുതയോടെ ഞാൻ എന്റെ കഥ ആരംഭിക്കും, ഇതിന്റെ ആന്റിപോഡ് REST (പ്രാതിനിധ്യ സംസ്ഥാന കൈമാറ്റം, പ്രതിനിധി സംസ്ഥാന കൈമാറ്റം) . വിക്കിപീഡിയയിൽ നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കാം, ലേഖനങ്ങളിലേക്കുള്ള ലിങ്കുകൾ വിഷയത്തിന്റെ അവസാനത്തിലാണ്. ഈ ലേഖനങ്ങളിൽ നിന്ന്, ഞങ്ങൾ ഇനിപ്പറയുന്നവ മനസ്സിലാക്കേണ്ടതുണ്ട്: “ആർപിസി സമീപനം വളരെയധികം രീതികളും സങ്കീർണ്ണമായ പ്രോട്ടോക്കോളും ഉപയോഗിച്ച് ചെറിയ അളവിലുള്ള നെറ്റ്‌വർക്ക് ഉറവിടങ്ങൾ ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു REST സമീപനത്തിലൂടെ, രീതികളുടെ എണ്ണവും പ്രോട്ടോക്കോളിന്റെ സങ്കീർണ്ണതയും വളരെ പരിമിതമാണ്, ഇത് ധാരാളം വ്യക്തിഗത വിഭവങ്ങളിലേക്ക് നയിച്ചേക്കാം. അതായത്, ഞങ്ങളുമായി ബന്ധപ്പെട്ട്, ഇതിനർത്ഥം, ആർപിസി സമീപനത്തിന്റെ കാര്യത്തിൽ, സൈറ്റിന് എല്ലായ്പ്പോഴും സേവനത്തിലേക്ക് ഒരു ഇൻപുട്ട് (ലിങ്ക്) ഉണ്ടായിരിക്കുമെന്നും ഡാറ്റയ്‌ക്കൊപ്പം ഞങ്ങൾ കൈമാറുന്ന ഇൻകമിംഗ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഏത് നടപടിക്രമമാണ് വിളിക്കേണ്ടത്. ഞങ്ങളുടെ REST സമീപനത്തിലൂടെ സൈറ്റിന് നിരവധി ഇൻപുട്ടുകൾ (ലിങ്കുകൾ) ഉണ്ട്, അവയിൽ ഓരോന്നും ചില ഡാറ്റ മാത്രം സ്വീകരിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു. ഈ സമീപനങ്ങളിലെ വ്യത്യാസം എങ്ങനെ വിശദീകരിക്കാമെന്ന് വായിക്കുന്ന ഒരാൾക്ക് അറിയാമെങ്കിൽ, അഭിപ്രായങ്ങളിൽ എഴുതുന്നത് ഉറപ്പാക്കുക!
SOAP നെക്കുറിച്ച് നമ്മൾ അറിയേണ്ട അടുത്ത കാര്യം, ഈ പ്രോട്ടോക്കോൾ ഒരു ഗതാഗതമായി ഒരേ XML ഉപയോഗിക്കുന്നു എന്നതാണ്, അത് ഒരു വശത്ത് വളരെ നല്ലതാണ്, കാരണം. ഞങ്ങളുടെ ആയുധപ്പുരയിൽ ഉടനടി ഈ മാർക്ക്അപ്പ് ഭാഷയെ അടിസ്ഥാനമാക്കിയുള്ള സാങ്കേതികവിദ്യകളുടെ മുഴുവൻ ശക്തിയും ഉൾപ്പെടുന്നു, അതായത് XML-Schema - ഒരു XML പ്രമാണത്തിന്റെ ഘടന വിവരിക്കുന്നതിനുള്ള ഒരു ഭാഷ (വിക്കിപീഡിയയ്ക്ക് നന്ദി!), ഇത് സെർവറിൽ എത്തുന്ന ഡാറ്റയുടെ സ്വയമേവ മൂല്യനിർണ്ണയം അനുവദിക്കുന്നു. ക്ലയന്റുകളിൽ നിന്ന്.
അതിനാൽ, വിദൂര നടപടിക്രമ കോൾ നടപ്പിലാക്കാൻ ഉപയോഗിക്കുന്ന പ്രോട്ടോക്കോളാണ് SOAP എന്നും അത് ഒരു ഗതാഗതമായി XML ഉപയോഗിക്കുന്നുവെന്നും ഇപ്പോൾ നമുക്കറിയാം! നിങ്ങൾ വിക്കിപീഡിയയിലെ ലേഖനം വായിക്കുകയാണെങ്കിൽ, അവിടെ നിന്ന് നിങ്ങൾക്ക് ഇത് ഏത് ആപ്ലിക്കേഷൻ ലെയർ പ്രോട്ടോക്കോളിലും ഉപയോഗിക്കാമെന്നും, കൂടാതെ HTTP-യുമായി ജോടിയാക്കരുതെന്നും മനസ്സിലാക്കാം (നിർഭാഗ്യവശാൽ, ഈ വിഷയത്തിൽ ഞങ്ങൾ HTTP-യെക്കാൾ SOAP മാത്രമേ പരിഗണിക്കൂ). പിന്നെ ഇതിലെല്ലാം എനിക്ക് ഏറ്റവും ഇഷ്ടം എന്താണെന്ന് അറിയാമോ? ഊഹങ്ങൾ ഇല്ലെങ്കിൽ, ഞാൻ നിങ്ങൾക്ക് ഒരു സൂചന തരാം - സോപ്പ്!... എന്തായാലും ഊഹങ്ങൾ ഇല്ലേ?... നിങ്ങൾ തീർച്ചയായും വിക്കിപീഡിയയിലെ ലേഖനം വായിച്ചിട്ടുണ്ടോ?... പൊതുവേ, ഞാൻ നിങ്ങളെ കൂടുതൽ പീഡിപ്പിക്കില്ല. അതിനാൽ, ഞാൻ ഉടൻ തന്നെ ഉത്തരത്തിലേക്ക് നീങ്ങും: "SOAP (ഇംഗ്ലീഷിൽ നിന്ന്. ലളിതമായ ഒബ്ജക്റ്റ് ആക്സസ് പ്രോട്ടോക്കോൾ - ഒരു ലളിതമാണ്. പ്രോട്ടോക്കോൾവസ്തുക്കളിലേക്കുള്ള പ്രവേശനം; സ്പെസിഫിക്കേഷൻ 1.2 വരെ)". ഈ വരിയുടെ ഹൈലൈറ്റ് ഇറ്റാലിക്സിലാണ്! ഇതിൽ നിന്നെല്ലാം നിങ്ങൾ എന്ത് നിഗമനങ്ങളാണ് എടുത്തതെന്ന് എനിക്കറിയില്ല, പക്ഷേ ഞാൻ ഇനിപ്പറയുന്നവ കാണുന്നു - ഈ പ്രോട്ടോക്കോൾ ഒരു തരത്തിലും "ലളിതമായ" എന്ന് വിളിക്കാൻ കഴിയാത്തതിനാൽ (പ്രത്യക്ഷമായും w3 ഇതിനോട് യോജിക്കുന്നു), തുടർന്ന് പതിപ്പ് 1.2 മുതൽ അത് അവസാനിച്ചു. ഡീക്രിപ്റ്റ് ചെയ്തു! അത് സോപ്പ് എന്നറിയപ്പെട്ടു, വെറും സോപ്പും കാലഘട്ടവും.
ശരി, ഞാൻ നിങ്ങളോട് ക്ഷമ ചോദിക്കുന്നു, അൽപ്പം വശത്തേക്ക് തെന്നിമാറി. ഞാൻ നേരത്തെ എഴുതിയതുപോലെ, XML ഒരു ഗതാഗതമായി ഉപയോഗിക്കുന്നു, കൂടാതെ ക്ലയന്റിനും സെർവറിനുമിടയിൽ പ്രവർത്തിക്കുന്ന പാക്കറ്റുകളെ SOAP എൻവലപ്പുകൾ എന്ന് വിളിക്കുന്നു. കവറിന്റെ പൊതുവായ ഘടന ഞങ്ങൾ പരിഗണിക്കുകയാണെങ്കിൽ, അത് നിങ്ങൾക്ക് വളരെ പരിചിതമാണെന്ന് തോന്നും, കാരണം ഒരു HTML പേജിന്റെ ഘടനയോട് സാമ്യമുണ്ട്. ഇതിന് ഒരു പ്രധാന വിഭാഗമുണ്ട് - പൊതിയുക, വിഭാഗങ്ങൾ ഉൾപ്പെടുന്നു തലക്കെട്ട്ഒപ്പം ശരീരം, അഥവാ തെറ്റ്. എ.ടി ശരീരംഡാറ്റ കൈമാറ്റം ചെയ്യപ്പെടുന്നു, അത് എൻവലപ്പിന്റെ നിർബന്ധിത വിഭാഗമാണ് തലക്കെട്ട്ഓപ്ഷണൽ ആണ്. എ.ടി തലക്കെട്ട്അംഗീകാരം കൈമാറാൻ കഴിയും, അല്ലെങ്കിൽ വെബ് സേവന നടപടിക്രമങ്ങളുടെ ഇൻപുട്ട് ഡാറ്റയുമായി നേരിട്ട് ബന്ധമില്ലാത്ത മറ്റേതെങ്കിലും ഡാറ്റ. പ്രൊഫ തെറ്റ്എന്തെങ്കിലും പിശകുകൾ ഉണ്ടായാൽ അത് സെർവറിൽ നിന്ന് ക്ലയന്റിലേക്ക് വരുന്നു എന്നതൊഴിച്ചാൽ പ്രത്യേകമായി ഒന്നും പറയാനില്ല. 
ഇവിടെയാണ് SOAP പ്രോട്ടോക്കോളിനെക്കുറിച്ചുള്ള എന്റെ അവലോകന സ്റ്റോറി അവസാനിക്കുന്നത് (ഞങ്ങളുടെ ക്ലയന്റും സെർവറും ഒടുവിൽ അവയെ എങ്ങനെ പ്രവർത്തിപ്പിക്കാമെന്ന് മനസിലാക്കുമ്പോൾ ഞങ്ങൾ എൻവലപ്പുകളും അവയുടെ ഘടനയും കൂടുതൽ വിശദമായി പരിശോധിക്കും) കൂടാതെ പുതിയതൊന്ന് ആരംഭിക്കുന്നു - ഒരു SOAP കമ്പാനിയനെ കുറിച്ച് വിളിച്ചു WSDL(വെബ് സേവന വിവരണ ഭാഷ). അതെ, അതെ, ഈ പ്രോട്ടോക്കോളിൽ ഞങ്ങളുടെ സ്വന്തം API എടുത്ത് നടപ്പിലാക്കാനുള്ള ശ്രമത്തിൽ നിന്ന് നമ്മളിൽ ഭൂരിഭാഗവും ഭയപ്പെടുത്തുന്നത് ഇതാണ്. തൽഫലമായി, ഞങ്ങൾ സാധാരണയായി ഞങ്ങളുടെ ചക്രം ഒരു ഗതാഗതമായി JSON ഉപയോഗിച്ച് പുനർനിർമ്മിക്കുന്നു. അപ്പോൾ, എന്താണ് WSDL? XML (c) വിക്കിപീഡിയ ഭാഷയെ അടിസ്ഥാനമാക്കി വെബ് സേവനങ്ങൾ വിവരിക്കുന്നതിനും അവ ആക്സസ് ചെയ്യുന്നതിനുമുള്ള ഒരു ഭാഷയാണ് WSDL. ഈ നിർവചനത്തിൽ നിന്ന് ഈ സാങ്കേതികവിദ്യയുടെ മുഴുവൻ പവിത്രമായ അർത്ഥവും നിങ്ങൾക്ക് വ്യക്തമാകുന്നില്ലെങ്കിൽ, ഞാൻ അത് എന്റെ സ്വന്തം വാക്കുകളിൽ വിവരിക്കാൻ ശ്രമിക്കും!
സെർവറുമായി സാധാരണയായി ആശയവിനിമയം നടത്താൻ ഞങ്ങളുടെ ക്ലയന്റുകളെ അനുവദിക്കുന്നതിനാണ് WSDL രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഇത് ചെയ്യുന്നതിന്, "*.wsdl" വിപുലീകരണത്തോടുകൂടിയ ഫയലിൽ ഇനിപ്പറയുന്ന വിവരങ്ങൾ വിവരിച്ചിരിക്കുന്നു:
- ഏതൊക്കെ നെയിംസ്പേസുകളാണ് ഉപയോഗിച്ചത്,
- എന്ത് ഡാറ്റ സ്കീമുകളാണ് ഉപയോഗിച്ചത്,
- ക്ലയന്റുകളിൽ നിന്ന് ഏത് തരത്തിലുള്ള സന്ദേശങ്ങളാണ് വെബ് സേവനം പ്രതീക്ഷിക്കുന്നത്,
- ഏത് ഡാറ്റ ഏത് വെബ് സേവന നടപടിക്രമങ്ങളിൽ പെടുന്നു,
- വെബ് സേവനത്തിൽ എന്ത് നടപടിക്രമങ്ങൾ അടങ്ങിയിരിക്കുന്നു,
- ക്ലയന്റ് വെബ് സേവന നടപടിക്രമങ്ങളെ എങ്ങനെ വിളിക്കണം,
- ഏത് വിലാസത്തിലേക്കാണ് ക്ലയന്റ് കോളുകൾ അയയ്ക്കേണ്ടത്.
3 XML സ്കീമയുടെ ആമുഖം
സോപ്പ് എന്താണെന്നും അതിനുള്ളിൽ എന്താണെന്നും ഇപ്പോൾ ഞങ്ങൾക്ക് ധാരാളം കാര്യങ്ങൾ അറിയാം, കൂടാതെ അതിനെ ചുറ്റിപ്പറ്റിയുള്ള സാങ്കേതികവിദ്യയുടെ ഒരു അവലോകനം നമുക്കുണ്ട്. ഒന്നാമതായി, ഒരു ക്ലയന്റും സെർവറും തമ്മിലുള്ള ആശയവിനിമയ രീതിയാണ് SOAP എന്നതിനാൽ, XML മാർക്ക്അപ്പ് ഭാഷ അതിനുള്ള ഗതാഗതമായി ഉപയോഗിക്കുന്നു, XML സ്കീമകളിലൂടെ ഓട്ടോമാറ്റിക് ഡാറ്റ മൂല്യനിർണ്ണയം എങ്ങനെ സംഭവിക്കുന്നുവെന്ന് ഈ വിഭാഗത്തിൽ നമുക്ക് മനസ്സിലാക്കാം.ഞങ്ങൾ പ്രോസസ്സ് ചെയ്യാൻ പോകുന്ന ഡാറ്റയുടെ ഘടന വിവരിക്കുക എന്നതാണ് സ്കീമയുടെ പ്രധാന ദൌത്യം. XML സ്കീമകളിലെ എല്ലാ ഡാറ്റയും വിഭജിച്ചിരിക്കുന്നു ലളിതമായ(സ്കെയിലർ) കൂടാതെ സങ്കീർണ്ണമായ(ഘടനകൾ) തരങ്ങൾ. ലളിതമായ തരങ്ങളിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:
- ലൈൻ,
- നമ്പർ,
- ബൂലിയൻ,
- തീയതി.
ഞങ്ങളുടെ എസ്എംഎസ് സന്ദേശത്തിനായി ദൂരെ പോയി ഒരു എക്സ്എംഎൽ സ്കീമ എഴുതരുതെന്ന് ഞാൻ നിർദ്ദേശിക്കുന്നു! sms സന്ദേശത്തിന്റെ xml വിവരണം ചുവടെ:
ഞങ്ങളുടെ സങ്കീർണ്ണമായ തരം സ്കീമ ഇതുപോലെ കാണപ്പെടും:
ഈ എൻട്രി ഇങ്ങനെ വായിക്കുന്നു: ഞങ്ങൾക്ക് ഒരു വേരിയബിൾ ഉണ്ട് " സന്ദേശം"തരം" സന്ദേശം"കൂടാതെ ഒരു സങ്കീർണ്ണ തരം ഉണ്ട്" സന്ദേശം", ഒരു ക്രമാനുഗതമായ മൂലകങ്ങൾ അടങ്ങുന്ന " ഫോൺ» തരം സ്ട്രിംഗ്, « വാചകം» തരം സ്ട്രിംഗ്, « തീയതി» തരം തീയതി സമയം, « തരം» തരം ദശാംശം. ഈ തരങ്ങൾ ലളിതവും സ്കീമ നിർവചനത്തിൽ ഇതിനകം നിർവചിച്ചിട്ടുള്ളതുമാണ്. അഭിനന്ദനങ്ങൾ! ഞങ്ങൾ ഞങ്ങളുടെ ആദ്യ XML സ്കീമ എഴുതിയിരിക്കുന്നു!
മൂലകങ്ങളുടെ അർത്ഥം എന്ന് ഞാൻ കരുതുന്നു " ഘടകം" ഒപ്പം " സങ്കീർണ്ണ തരം» എല്ലാം നിങ്ങൾക്ക് കൂടുതലോ കുറവോ വ്യക്തമായിരിക്കുന്നു, അതിനാൽ ഞങ്ങൾ ഇനി അവയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കില്ല, ഉടൻ തന്നെ കമ്പോസർ ഘടകത്തിലേക്ക് മാറുക « ക്രമം". ഞങ്ങൾ കമ്പോസിറ്റർ ഘടകം ഉപയോഗിക്കുമ്പോൾ " ക്രമം» അതിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഘടകങ്ങൾ എല്ലായ്പ്പോഴും സ്കീമിൽ വ്യക്തമാക്കിയ ക്രമത്തിലായിരിക്കണം, കൂടാതെ അവയെല്ലാം നിർബന്ധമാണെന്നും ഞങ്ങൾ നിങ്ങളെ അറിയിക്കുന്നു. എന്നാൽ നിരാശപ്പെടരുത്! XML സ്കീമയിൽ രണ്ട് കമ്പോസർ ഘടകങ്ങൾ കൂടി ഉണ്ട്: തിരഞ്ഞെടുപ്പ്" ഒപ്പം " എല്ലാം". കമ്പോസർ തിരഞ്ഞെടുപ്പ്" അതിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ഘടകങ്ങളിൽ ഒന്ന് ഉണ്ടായിരിക്കണമെന്ന് സൂചിപ്പിക്കുന്നു, കൂടാതെ കമ്പോസർ " എല്ലാം»- ലിസ്റ്റുചെയ്ത ഘടകങ്ങളുടെ ഏതെങ്കിലും സംയോജനം.
നിങ്ങൾ ഓർക്കുന്നതുപോലെ, വിഷയത്തിന്റെ ആദ്യ വിഭാഗത്തിൽ, എസ്എംഎസ് സന്ദേശങ്ങളുടെ ഒന്നിൽ നിന്ന് അനന്തതയിലേക്ക് പാക്കേജ് കൈമാറാൻ കഴിയുമെന്ന് ഞങ്ങൾ സമ്മതിച്ചു. അതിനാൽ, XML സ്കീമയിൽ അത്തരം ഡാറ്റ എങ്ങനെയാണ് പ്രഖ്യാപിക്കുന്നതെന്ന് മനസിലാക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. പൊതുവായ പാക്കേജ് ഘടന ഇതുപോലെയാകാം:
അത്തരമൊരു സങ്കീർണ്ണ തരത്തിനായുള്ള സ്കീമ ഇതുപോലെ കാണപ്പെടും:
ആദ്യത്തെ ബ്ലോക്കിൽ സങ്കീർണ്ണമായ തരത്തിന്റെ പരിചിതമായ പ്രഖ്യാപനം അടങ്ങിയിരിക്കുന്നു. സന്ദേശം". നിങ്ങൾ ശ്രദ്ധിച്ചാൽ, ഓരോ ലളിതമായ തരത്തിലും ഉൾപ്പെടുത്തിയിട്ടുണ്ട് " സന്ദേശം", പുതിയ യോഗ്യതാ ആട്രിബ്യൂട്ടുകൾ ചേർത്തു" ചെറിയ സംഭവിക്കുന്നു" ഒപ്പം " പരമാവധി സംഭവിക്കുന്നു". പേരിൽ നിന്ന് ഊഹിക്കാൻ പ്രയാസമില്ലാത്തതിനാൽ, ആദ്യത്തേത് ( ചെറിയ സംഭവിക്കുന്നു) നൽകിയിരിക്കുന്ന ശ്രേണിയിൽ "ടൈപ്പിന്റെ ഒരു ഘടകമെങ്കിലും ഉണ്ടായിരിക്കണം" എന്ന് സൂചിപ്പിക്കുന്നു. ഫോൺ», « വാചകം», « തീയതി" ഒപ്പം " തരം”, അടുത്ത സമയത്ത് ( പരമാവധി സംഭവിക്കുന്നു) ആട്രിബ്യൂട്ട് നമ്മുടെ ക്രമത്തിൽ അത്തരം ഒരു ഘടകം ഉണ്ടെന്ന് നമ്മോട് പ്രഖ്യാപിക്കുന്നു. തൽഫലമായി, ഏതെങ്കിലും ഡാറ്റയ്‌ക്കായി ഞങ്ങളുടെ സ്കീമകൾ എഴുതുമ്പോൾ, അവ എങ്ങനെ കോൺഫിഗർ ചെയ്യണമെന്നതിനുള്ള ഏറ്റവും വിശാലമായ ചോയ്‌സ് ഞങ്ങൾ നൽകുന്നു!
സ്കീമയുടെ രണ്ടാമത്തെ ബ്ലോക്ക് ഘടകം പ്രഖ്യാപിക്കുന്നു " സന്ദേശപട്ടിക"തരം" സന്ദേശ പട്ടിക". അത് വ്യക്തമാണ് " സന്ദേശ പട്ടിക' കുറഞ്ഞത് ഒരു ഘടകമെങ്കിലും ഉൾപ്പെടുന്ന ഒരു സങ്കീർണ്ണ തരമാണ് ' സന്ദേശം”, എന്നാൽ അത്തരം മൂലകങ്ങളുടെ പരമാവധി എണ്ണം പരിമിതമല്ല!
4 നിങ്ങളുടെ WSDL എഴുതുന്നു
WSDL ഞങ്ങളുടെ വെബ് സേവനമാണെന്ന് നിങ്ങൾ ഓർക്കുന്നുണ്ടോ? നിങ്ങൾ ഓർക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു! നമ്മൾ ഇത് എഴുതുമ്പോൾ, ഞങ്ങളുടെ ചെറിയ വെബ് സേവനം അതിൽ ഒഴുകും. അതിനാൽ വഞ്ചിക്കരുതെന്ന് ഞാൻ നിർദ്ദേശിക്കുന്നു.പൊതുവേ, എല്ലാം ഞങ്ങൾക്ക് ശരിയായി പ്രവർത്തിക്കുന്നതിന്, ക്ലയന്റിലേക്ക് ശരിയായ MIME തരമുള്ള ഒരു WSDL ഫയൽ കൈമാറേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങളുടെ വെബ് സെർവർ അതിനനുസരിച്ച് കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്, അതായത്, *.wsdl എക്സ്റ്റൻഷനുള്ള ഫയലുകൾക്കായി ഇനിപ്പറയുന്ന വരിയിലേക്ക് MIME തരം സജ്ജമാക്കുക:
അപ്ലിക്കേഷൻ/wsdl+xml
എന്നാൽ പ്രായോഗികമായി, ഞാൻ സാധാരണയായി PHP വഴി HTTP തലക്കെട്ട് അയയ്ക്കുന്നു " ടെക്സ്റ്റ്/എക്സ്എംഎൽ»:
തലക്കെട്ട്("ഉള്ളടക്ക-തരം: വാചകം/xml; charset=utf-8");
എല്ലാം നന്നായി പ്രവർത്തിച്ചു!
ഞാൻ ഉടൻ തന്നെ നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകാൻ ആഗ്രഹിക്കുന്നു, ഞങ്ങളുടെ ലളിതമായ വെബ് സേവനത്തിന് ശ്രദ്ധേയമായ ഒരു വിവരണം ഉണ്ടായിരിക്കും, അതിനാൽ പരിഭ്രാന്തരാകരുത്, കാരണം. വാചകത്തിന്റെ ഭൂരിഭാഗവും വെള്ളം നിർബന്ധമാണ്, ഒരിക്കൽ എഴുതിയാൽ അത് ഒരു വെബ് സേവനത്തിൽ നിന്ന് മറ്റൊന്നിലേക്ക് നിരന്തരം പകർത്താനാകും!
WSDL XML ആയതിനാൽ, ആദ്യ വരിയിൽ തന്നെ നിങ്ങൾ അതിനെക്കുറിച്ച് നേരിട്ട് എഴുതേണ്ടതുണ്ട്. ഒരു ഫയലിന്റെ റൂട്ട് എലമെന്റിന് എപ്പോഴും പേരിടണം " നിർവചനങ്ങൾ»:
സാധാരണയായി, WSDL 4-5 പ്രധാന ബ്ലോക്കുകൾ ഉൾക്കൊള്ളുന്നു. ആദ്യ ബ്ലോക്ക് ഒരു വെബ് സേവനത്തിന്റെ നിർവചനമാണ്, അല്ലെങ്കിൽ മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു എൻട്രി പോയിന്റ്.
ഞങ്ങൾക്ക് ഒരു സേവനം ഉണ്ടെന്ന് ഇവിടെ പറയുന്നു - " എസ്എംഎസ് സേവനം". തത്വത്തിൽ, WSDL ഫയലിലെ എല്ലാ പേരുകളും നിങ്ങൾ ആഗ്രഹിക്കുന്നതെന്തും മാറ്റാൻ കഴിയും, കാരണം അവർ ഒരു പങ്കും വഹിക്കുന്നില്ല.
അതിനുശേഷം, ഞങ്ങളുടെ വെബ് സേവനത്തിൽ ഞങ്ങൾ അത് പ്രഖ്യാപിക്കുന്നു " എസ്എംഎസ് സേവനം"ഒരു എൻട്രി പോയിന്റ് ("പോർട്ട്") ഉണ്ട്, അതിനെ "" എന്ന് വിളിക്കുന്നു എസ്എംഎസ് സർവീസ് പോർട്ട്". ഈ എൻട്രി പോയിന്റിലേക്കാണ് ക്ലയന്റുകളിൽ നിന്നുള്ള എല്ലാ അഭ്യർത്ഥനകളും സെർവറിലേക്ക് അയയ്ക്കുന്നത്. ഞങ്ങൾ മൂലകത്തിൽ വ്യക്തമാക്കുന്നു " വിലാസം»അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്ന ഒരു ഹാൻഡ്‌ലർ ഫയലിലേക്കുള്ള ലിങ്ക്.
ഞങ്ങൾ ഒരു വെബ് സേവനം നിർവചിച്ച് അതിനായി ഒരു എൻട്രി പോയിന്റ് വ്യക്തമാക്കിയ ശേഷം, ഞങ്ങൾ അതിനോട് പിന്തുണയുള്ള നടപടിക്രമങ്ങൾ ബന്ധിപ്പിക്കേണ്ടതുണ്ട്:
ഇത് ചെയ്യുന്നതിന്, ഏത് പ്രവർത്തനങ്ങളും ഏത് രൂപത്തിലാണ് y എന്ന് വിളിക്കേണ്ടതെന്നും ഇത് പട്ടികപ്പെടുത്തുന്നു. ആ. തുറമുഖത്തിന് എസ്എംഎസ് സർവീസ് പോർട്ട്"ഒരു ബൈൻഡിംഗ്" എന്ന് പേരിട്ടിരിക്കുന്നു എസ്എംഎസ് സർവീസ് ബൈൻഡിംഗ്", ഇതിൽ കോൾ തരം ഉണ്ട്" ആർപിസി”, HTTP എന്നിവ ട്രാൻസ്ഫർ പ്രോട്ടോക്കോളായി ഉപയോഗിക്കുന്നു (ഗതാഗതം). അതിനാൽ, ഞങ്ങൾ HTTP വഴി ഒരു RPC കോൾ ചെയ്യുമെന്ന് ഞങ്ങൾ ഇവിടെ സൂചിപ്പിച്ചു. അതിനുശേഷം, ഏത് നടപടിക്രമങ്ങളാണ് ഞങ്ങൾ വിവരിക്കുന്നത് ( ഓപ്പറേഷൻ) വെബ് സേവനത്തിൽ പിന്തുണയ്ക്കുന്നു. ഞങ്ങൾ ഒരു നടപടിക്രമത്തെ മാത്രമേ പിന്തുണയ്ക്കൂ - " എസ്എംഎസ് അയയ്ക്കുക". ഈ നടപടിക്രമത്തിലൂടെ, ഞങ്ങളുടെ അത്ഭുതകരമായ സന്ദേശങ്ങൾ സെർവറിലേക്ക് അയയ്ക്കും! നടപടിക്രമം പ്രഖ്യാപിച്ച ശേഷം, ഏത് രൂപത്തിലാണ് ഡാറ്റ കൈമാറ്റം ചെയ്യപ്പെടുകയെന്ന് സൂചിപ്പിക്കേണ്ടത് ആവശ്യമാണ്. ഈ സാഹചര്യത്തിൽ, സാധാരണ SOAP എൻവലപ്പുകൾ ഉപയോഗിക്കുമെന്ന് വ്യക്തമാക്കിയിട്ടുണ്ട്.
അതിനുശേഷം, ഞങ്ങൾ സന്ദേശങ്ങളുമായി നടപടിക്രമം ബന്ധിപ്പിക്കേണ്ടതുണ്ട്:
ഇത് ചെയ്യുന്നതിന്, ഞങ്ങളുടെ ബൈൻഡിംഗ് ("ബൈൻഡിംഗ്") തരം " എന്ന് ഞങ്ങൾ വ്യക്തമാക്കുന്നു SmsServicePortType"ഒപ്പം മൂലകത്തിലും" പോർട്ട്ടൈപ്പ്»ഒരേ തരത്തിലുള്ള പേരിൽ, സന്ദേശങ്ങളിലേക്കുള്ള നടപടിക്രമങ്ങളുടെ ബൈൻഡിംഗ് വ്യക്തമാക്കുക. അതിനാൽ, ഇൻകമിംഗ് സന്ദേശം (ക്ലയന്റിൽ നിന്ന് സെർവറിലേക്ക്) വിളിക്കപ്പെടും " sendSmsRequest", ഔട്ട്ഗോയിംഗ് (സെർവറിൽ നിന്ന് ക്ലയന്റിലേക്ക്)" sendSmsResponse". WSDL-ലെ എല്ലാ പേരുകളെയും പോലെ, ഇൻകമിംഗ്, ഔട്ട്ഗോയിംഗ് സന്ദേശങ്ങളുടെ പേരുകൾ ഏകപക്ഷീയമാണ്.
ഇപ്പോൾ നമുക്ക് സന്ദേശങ്ങൾ സ്വയം വിവരിക്കേണ്ടതുണ്ട്, അതായത്. ഇൻകമിംഗ്, ഔട്ട്ഗോയിംഗ്:
ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഘടകങ്ങൾ ചേർക്കുന്നു " സന്ദേശം"പേരുകൾക്കൊപ്പം" sendSmsRequest" ഒപ്പം " sendSmsResponse"യഥാക്രമം. അവയിൽ, ഇൻപുട്ടിലേക്ക് ഒരു എൻവലപ്പ് വരണമെന്ന് ഞങ്ങൾ സൂചിപ്പിക്കുന്നു, അതിന്റെ ഘടന ഡാറ്റ തരവുമായി പൊരുത്തപ്പെടുന്നു " അഭ്യർത്ഥിക്കുക". അതിനുശേഷം, ഡാറ്റ തരം അടങ്ങുന്ന ഒരു എൻവലപ്പ് സെർവറിൽ നിന്ന് തിരികെ നൽകും - " പ്രതികരണം».
ഇപ്പോൾ നമുക്ക് കുറച്ച് മാത്രമേ ചെയ്യാനുള്ളൂ - ഈ തരത്തിലുള്ള ഒരു വിവരണം ഞങ്ങളുടെ WSDL ഫയലിലേക്ക് ചേർക്കുക! ഇൻകമിംഗ്, ഔട്ട്ഗോയിംഗ് ഡാറ്റയെ WSDL എങ്ങനെ വിവരിക്കുന്നുവെന്ന് നിങ്ങൾ കരുതുന്നു? നിങ്ങൾ വളരെക്കാലമായി എല്ലാം മനസ്സിലാക്കുകയും XML സ്കീമകളുടെ സഹായത്തോടെ സ്വയം പറയുകയും ചെയ്തുവെന്ന് ഞാൻ കരുതുന്നു! നിങ്ങൾ തികച്ചും ശരിയായിരിക്കും!
നിങ്ങൾക്ക് ഞങ്ങളെ അഭിനന്ദിക്കാം! ഞങ്ങളുടെ ആദ്യത്തെ WSDL എഴുതിയിരിക്കുന്നു! ഞങ്ങളുടെ ലക്ഷ്യം കൈവരിക്കുന്നതിന് ഞങ്ങൾ ഒരു പടി കൂടി അടുത്തിരിക്കുന്നു.
അടുത്തതായി, ഞങ്ങളുടെ സ്വന്തം ഡിസ്ട്രിബ്യൂഡ് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിന് PHP എന്താണ് നൽകുന്നത് എന്ന് ഞങ്ങൾ കൈകാര്യം ചെയ്യും.
5 ഞങ്ങളുടെ ആദ്യത്തെ SOAP സെർവർ
PHP-യിൽ ഒരു SOAP സെർവർ സൃഷ്ടിക്കാൻ, ഞങ്ങൾ ബിൽറ്റ്-ഇൻ SoapServer ക്ലാസ് ഉപയോഗിക്കുമെന്ന് ഞാൻ നേരത്തെ എഴുതിയിരുന്നു. എല്ലാ തുടർന്നുള്ള പ്രവർത്തനങ്ങളും എന്റേത് പോലെ സംഭവിക്കുന്നതിന്, നിങ്ങളുടെ PHP അൽപ്പം മാറ്റേണ്ടതുണ്ട്. കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, നിങ്ങൾ "php-soap" വിപുലീകരണം ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്. നിങ്ങളുടെ വെബ് സെർവറിൽ ഇത് എങ്ങനെ സ്ഥാപിക്കാം എന്നത് ഔദ്യോഗിക PHP വെബ്സൈറ്റിൽ വായിക്കുന്നതാണ് നല്ലത് (റഫറൻസുകൾ കാണുക).എല്ലാം ഇൻസ്റ്റാൾ ചെയ്ത് കോൺഫിഗർ ചെയ്ത ശേഷം, ഞങ്ങൾ ഫയൽ സൃഷ്ടിക്കേണ്ടതുണ്ട് " smsservice.php» ഇനിപ്പറയുന്ന ഉള്ളടക്കത്തോടൊപ്പം:
setClass("SoapSmsGateWay"); //സെർവർ ആരംഭിക്കുക $server->handle();
“ini_set” ഫംഗ്‌ഷനുള്ള ലൈനിന് മുകളിലുള്ളത്, വിശദീകരിക്കേണ്ട ആവശ്യമില്ലെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. കാരണം സെർവറിൽ നിന്ന് ക്ലയന്റിലേക്ക് ഞങ്ങൾ അയയ്‌ക്കുന്ന HTTP തലക്കെട്ടുകൾ ഇത് നിർവചിക്കുകയും പരിസ്ഥിതി ക്രമീകരിക്കുകയും ചെയ്യുന്നു. "ini_set" ലൈനിൽ, ഞങ്ങൾ WSDL ഫയലിന്റെ കാഷിംഗ് അപ്രാപ്തമാക്കുന്നു, അതിലൂടെ ഞങ്ങളുടെ മാറ്റങ്ങൾ ക്ലയന്റിൽ ഉടനടി പ്രാബല്യത്തിൽ വരും.
ഇപ്പോൾ ഞങ്ങൾ സെർവറിലേക്ക് വരുന്നു! നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, മുഴുവൻ SOAP സെർവറും മൂന്ന് വരികൾ മാത്രം! ആദ്യ വരിയിൽ, ഞങ്ങൾ SoapServer ഒബ്ജക്റ്റിന്റെ ഒരു പുതിയ ഉദാഹരണം സൃഷ്ടിക്കുകയും ഞങ്ങളുടെ WSDL വെബ് സേവന വിവരണത്തിന്റെ വിലാസം അതിന്റെ കൺസ്‌ട്രക്‌ടർക്ക് കൈമാറുകയും ചെയ്യുന്നു. ഇപ്പോൾ ഞങ്ങൾക്കറിയാം, അത് പറയുന്ന പേരുള്ള ഒരു ഫയലിൽ ഹോസ്റ്റിംഗ് റൂട്ടിൽ സ്ഥിതിചെയ്യുമെന്ന്. smsservice.wsdl.php". രണ്ടാമത്തെ വരിയിൽ, ക്ലയന്റിൽ നിന്ന് ലഭിച്ച എൻവലപ്പ് പ്രോസസ്സ് ചെയ്യുന്നതിനും പ്രതികരണം സഹിതം എൻവലപ്പ് തിരികെ നൽകുന്നതിനും ഏത് ക്ലാസ് വലിക്കണമെന്ന് ഞങ്ങൾ SOAP സെർവറിനോട് പറയുന്നു. നിങ്ങൾ ഊഹിച്ചതുപോലെ, ഞങ്ങളുടെ ഒരേയൊരു രീതി വിവരിക്കുന്നത് ഈ ക്ലാസിലാണ്. എസ്എംഎസ് അയയ്ക്കുക. മൂന്നാമത്തെ വരിയിൽ ഞങ്ങൾ സെർവർ ആരംഭിക്കുന്നു! എല്ലാം, ഞങ്ങളുടെ സെർവർ തയ്യാറാണ്! അതോടൊപ്പം ഞാൻ ഞങ്ങളെ എല്ലാവരെയും അഭിനന്ദിക്കുന്നു!
ഇപ്പോൾ നമ്മൾ ഒരു WSDL ഫയൽ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ഒന്നുകിൽ മുമ്പത്തെ വിഭാഗത്തിൽ നിന്ന് അതിന്റെ ഉള്ളടക്കങ്ങൾ പകർത്താം, അല്ലെങ്കിൽ സ്വാതന്ത്ര്യം എടുത്ത് അൽപ്പം "ടെംപ്ലേറ്റ്" ചെയ്യാം:
";
?>
ഈ ഘട്ടത്തിൽ, തത്ഫലമായുണ്ടാകുന്ന സെർവർ ഞങ്ങൾക്ക് പൂർണ്ണമായും അനുയോജ്യമാകും, കാരണം. അതിലേക്ക് വരുന്ന എൻവലപ്പുകൾ നമുക്ക് ലോഗ് ചെയ്യാനും തുടർന്ന് ഇൻകമിംഗ് ഡാറ്റ ശാന്തമായി വിശകലനം ചെയ്യാനും കഴിയും. സെർവറിൽ എന്തെങ്കിലും ലഭിക്കണമെങ്കിൽ, ഞങ്ങൾക്ക് ഒരു ക്ലയന്റ് ആവശ്യമാണ്. അതിനാൽ നമുക്ക് അവരുമായി മുന്നോട്ട് പോകാം!
വഴിയിൽ 6 SOAP ക്ലയന്റ്
ഒന്നാമതായി, ഞങ്ങൾ ക്ലയന്റ് എഴുതുന്ന ഒരു ഫയൽ സൃഷ്ടിക്കേണ്ടതുണ്ട്. പതിവുപോലെ, ഞങ്ങൾ അത് ഹോസ്റ്റിന്റെ റൂട്ടിൽ സൃഷ്ടിച്ച് അതിനെ വിളിക്കും " client.php”, ഉള്ളിൽ ഞങ്ങൾ ഇനിപ്പറയുന്നവ എഴുതുന്നു: മെസേജ് ലിസ്റ്റ് = പുതിയ മെസേജ് ലിസ്റ്റ്(); $req->messageList->സന്ദേശം = പുതിയ സന്ദേശം(); $req->messageList->message->ഫോൺ = "79871234567"; $req->messageList->message->text = "ടെസ്റ്റ് സന്ദേശം 1"; $req->messageList->message->date = "2013-07-21T15:00:00.26"; $req->messageList->message->type = 15; $client = പുതിയ SoapClient("http://($_SERVER["HTTP_HOST"])/smsservice.wsdl.php", അറേ("soap_version" => SOAP_1_2)); var_dump($client->sendSms($req));
നമുക്ക് നമ്മുടെ വസ്തുക്കളെ വിവരിക്കാം. ഞങ്ങൾ WSDL എഴുതിയപ്പോൾ, സെർവറിലേക്ക് പ്രവേശിക്കുന്ന എൻവലപ്പിനായി മൂന്ന് എന്റിറ്റികൾ അതിൽ വിവരിച്ചിട്ടുണ്ട്: അഭ്യർത്ഥിക്കുക, സന്ദേശ പട്ടികഒപ്പം സന്ദേശം. അതനുസരിച്ച്, ക്ലാസുകൾ അഭ്യർത്ഥിക്കുക, സന്ദേശ പട്ടികഒപ്പം സന്ദേശംനമ്മുടെ PHP സ്ക്രിപ്റ്റിലെ ഈ എന്റിറ്റികളുടെ പ്രതിഫലനങ്ങളാണ്.
ഒബ്‌ജക്‌റ്റുകൾ നിർവചിച്ച ശേഷം, നമ്മൾ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കേണ്ടതുണ്ട് ( $req), അത് സെർവറിലേക്ക് അയയ്ക്കും. അപ്പോൾ ഞങ്ങൾക്കായി ഏറ്റവും പ്രിയപ്പെട്ട രണ്ട് വരികൾ വരൂ! ഞങ്ങളുടെ SOAP ക്ലയന്റ്! വിശ്വസിച്ചാലും ഇല്ലെങ്കിലും, ഞങ്ങളുടെ സെർവറിന് ക്ലയന്റിൽ നിന്ന് സന്ദേശങ്ങൾ പകരാൻ തുടങ്ങാനും ഞങ്ങളുടെ സെർവറിന് അവ വിജയകരമായി സ്വീകരിക്കാനും പ്രോസസ്സ് ചെയ്യാനും ഇത് മതിയാകും! അവയിൽ ആദ്യത്തേതിൽ, ഞങ്ങൾ SoapClient ക്ലാസിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കുകയും WSDL ഫയലിന്റെ സ്ഥാനത്തിന്റെ വിലാസം അതിന്റെ കൺസ്‌ട്രക്‌ടർക്ക് കൈമാറുകയും SOAP പ്രോട്ടോക്കോൾ പതിപ്പ് 1.2 ഉപയോഗിച്ച് ഞങ്ങൾ പ്രവർത്തിക്കുമെന്ന് പാരാമീറ്ററുകളിൽ വ്യക്തമായി സൂചിപ്പിക്കുകയും ചെയ്യുന്നു. അടുത്ത വരിയിൽ ഞങ്ങൾ രീതി വിളിക്കുന്നു എസ്എംഎസ് അയയ്ക്കുകവസ്തു $ക്ലയന്റ്ഉടൻ ബ്രൗസറിൽ ഫലം പ്രദർശിപ്പിക്കുക.
നമുക്ക് അത് പ്രവർത്തിപ്പിച്ച് ഒടുവിൽ എന്താണ് ലഭിച്ചത് എന്ന് നോക്കാം!
സെർവറിൽ നിന്ന് എനിക്ക് ഇനിപ്പറയുന്ന വസ്തു ലഭിച്ചു:
ഒബ്ജക്റ്റ്(stdClass) പൊതു "സ്റ്റാറ്റസ്" => ബൂളിയൻ ശരി
ഇത് അതിശയകരമാണ്, കാരണം. ഞങ്ങളുടെ സെർവർ പ്രവർത്തിക്കുന്നുണ്ടെന്നും അത് പ്രവർത്തിക്കുന്നുവെന്നും മാത്രമല്ല, ക്ലയന്റിലേക്ക് ചില മൂല്യങ്ങൾ തിരികെ നൽകാമെന്നും ഇപ്പോൾ ഞങ്ങൾക്കറിയാം!
ഇനി നമുക്ക് സെർവർ സൈഡിൽ കരുതലോടെ സൂക്ഷിക്കുന്ന ലോഗ് നോക്കാം! അതിന്റെ ആദ്യ ഭാഗത്ത്, സെർവറിൽ പ്രവേശിച്ച അസംസ്കൃത ഡാറ്റ ഞങ്ങൾ കാണുന്നു:
ഇതാണ് കവർ. അത് എങ്ങനെയുണ്ടെന്ന് ഇപ്പോൾ നിങ്ങൾക്കറിയാം! എന്നാൽ അതിനെ നിരന്തരം അഭിനന്ദിക്കുന്നതിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടാകാൻ സാധ്യതയില്ല, അതിനാൽ ലോഗ് ഫയലിൽ നിന്ന് ഒബ്ജക്റ്റ് ഡീസിയലൈസ് ചെയ്ത് എല്ലാം ശരിയാണോ എന്ന് നോക്കാം:
ഒബ്ജക്റ്റ്(stdClass) പൊതു "messageList" => ഒബ്ജക്റ്റ് (stdClass) പൊതു "സന്ദേശം" => ഒബ്ജക്റ്റ് (stdClass) പൊതു "ഫോൺ" => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 1 " (നീളം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2013-07-21T15:00:00.26" (ദൈർഘ്യം=22) പൊതു "തരം" => സ്ട്രിംഗ് "15" (ദൈർഘ്യം=2)
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഒബ്ജക്റ്റ് ശരിയായി ഡിസീരിയലൈസ് ചെയ്തു, അതിലൂടെ ഞങ്ങൾ എല്ലാവരെയും അഭിനന്ദിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു! അടുത്തതായി, കൂടുതൽ രസകരമായ എന്തെങ്കിലും ഞങ്ങളെ കാത്തിരിക്കുന്നു! അതായത്, ഞങ്ങൾ ക്ലയന്റ് സെർവറിലേക്ക് അയയ്ക്കുന്നത് ഒരു എസ്എംഎസ് സന്ദേശമല്ല, ഒരു മുഴുവൻ പായ്ക്കാണ് (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, മൂന്ന് മുഴുവനും)!
7 സങ്കീർണ്ണമായ വസ്തുക്കൾ അയയ്ക്കുന്നു
ഒരു പാക്കേജിൽ എങ്ങനെ ഒരു കൂട്ടം സന്ദേശങ്ങൾ സെർവറിലേക്ക് അയക്കാം എന്ന് നമുക്ക് ചിന്തിക്കാം? മെസേജ് ലിസ്റ്റ് എലമെന്റിനുള്ളിൽ ഒരു അറേ ഓർഗനൈസ് ചെയ്യുന്നതായിരിക്കും ഒരുപക്ഷേ ഏറ്റവും എളുപ്പമുള്ള മാർഗം! നമുക്ക് ഇതുചെയ്യാം:// സെർവറിലേക്ക് അയയ്ക്കാൻ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുക $req = പുതിയ അഭ്യർത്ഥന(); $req->messageList = പുതിയ MessageList(); $msg1 = പുതിയ സന്ദേശം(); $msg1->ഫോൺ = "79871234567"; $msg1->വാചകം = "ടെസ്റ്റ് സന്ദേശം 1"; $msg1->തീയതി = "2013-07-21T15:00:00.26"; $msg1->തരം = 15; $msg2 = പുതിയ സന്ദേശം(); $msg2->ഫോൺ = "79871234567"; $msg2->വാചകം = "ടെസ്റ്റ് സന്ദേശം 2"; $msg2->തീയതി = "2014-08-22T16:01:10"; $msg2->തരം = 16; $msg3 = പുതിയ സന്ദേശം(); $msg3->ഫോൺ = "79871234567"; $msg3->വാചകം = "ടെസ്റ്റ് സന്ദേശം 3"; $msg3->തീയതി = "2014-08-22T16:01:10"; $msg3->തരം = 17; $req->messageList->സന്ദേശം = $msg1; $req->messageList->message = $msg2; $req->messageList->message = $msg3;
ഇനിപ്പറയുന്ന പാക്കറ്റ് ക്ലയന്റിൽ നിന്നാണ് വന്നതെന്ന് ഞങ്ങളുടെ ലോഗുകൾ കാണിക്കുന്നു:
എന്ത് വിഡ്ഢിത്തം, നിങ്ങൾ പറയുന്നു? നിങ്ങൾ ഒരർത്ഥത്തിൽ ശരിയായിരിക്കും, കാരണം. ക്ലയന്റിൽ നിന്ന് വിട്ടുപോയ ഒബ്ജക്റ്റ് ഏതാണെന്ന് ഞങ്ങൾ മനസ്സിലാക്കിയതുപോലെ, അത് ഞങ്ങളുടെ സെർവറിലേക്ക് ഒരു കവറിന്റെ രൂപത്തിൽ അതേ രൂപത്തിൽ വന്നു. ശരിയാണ്, എസ്എംഎസ് സന്ദേശങ്ങൾ ഞങ്ങൾക്ക് ആവശ്യമുള്ള രീതിയിൽ XML-ൽ സീരിയലൈസ് ചെയ്തിട്ടില്ല - അവ ഘടകങ്ങളിൽ പൊതിഞ്ഞിരിക്കണം സന്ദേശം, അകത്തല്ല സ്ട്രക്റ്റ്. ഇനി ഇത്തരമൊരു വസ്തു ഏത് രൂപത്തിലാണ് രീതിയിലേക്ക് വരുന്നത് എന്ന് നോക്കാം എസ്എംഎസ് അയയ്ക്കുക:
ഒബ്ജക്റ്റ്(stdClass) പൊതു "messageList" => ഒബ്ജക്റ്റ് (stdClass) പൊതു "സന്ദേശം" => ഒബ്ജക്റ്റ് (stdClass) പൊതു "ഘടന" => അറേ (size=3) 0 => object(stdClass) പൊതു "ഫോൺ" => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു "വാചകം" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 1" (ദൈർഘ്യം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2013-07-21T15:00:00.26" (ദൈർഘ്യം=22) പൊതു " തരം 37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2014-08-22T16:01:10" (ദൈർഘ്യം=19) പൊതു "തരം" => സ്ട്രിംഗ് "16" (ദൈർഘ്യം=2) 2 => ഒബ്ജക്റ്റ്(stdClass) പൊതു "ഫോൺ " => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 3" (ദൈർഘ്യം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2014-08-22T16:01:10" (ദൈർഘ്യം= 19) പൊതു "തരം" => സ്ട്രിംഗ് "17" (ദൈർഘ്യം=2)
ഈ അറിവ് നമുക്ക് എന്താണ് നൽകുന്നത്? ഞങ്ങൾ തിരഞ്ഞെടുത്ത പാത ശരിയല്ല എന്നതും ചോദ്യത്തിന് ഞങ്ങൾക്ക് ഉത്തരം ലഭിച്ചിട്ടില്ലെന്നും മാത്രം - "സെർവറിൽ ശരിയായ ഡാറ്റ ഘടന എങ്ങനെ ലഭിക്കും?". എന്നാൽ നിരാശപ്പെടരുതെന്ന് ഞാൻ നിർദ്ദേശിക്കുന്നു, ഞങ്ങളുടെ അറേ തരത്തിലേക്ക് കാസ്റ്റ് ചെയ്യാൻ ശ്രമിക്കുക ഒരു വസ്തു:
$req->messageList->message = (object)$req->messageList->message;
ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾക്ക് മറ്റൊരു എൻവലപ്പ് ലഭിക്കും:
രീതിയിലേക്ക് വന്നു എസ്എംഎസ് അയയ്ക്കുകവസ്തുവിന് ഇനിപ്പറയുന്ന ഘടനയുണ്ട്:
ഒബ്ജക്റ്റ്(stdClass) പൊതു "messageList" => ഒബ്ജക്റ്റ് (stdClass) പൊതു "സന്ദേശം" => ഒബ്ജക്റ്റ്(stdClass) പൊതു "BOGUS" => അറേ (size=3) 0 => object(stdClass) പൊതു "ഫോൺ" => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു "വാചകം" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 1" (ദൈർഘ്യം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2013-07-21T15:00:00.26" (ദൈർഘ്യം=22) പൊതു " തരം 37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2014-08-22T16:01:10" (ദൈർഘ്യം=19) പൊതു "തരം" => സ്ട്രിംഗ് "16" (ദൈർഘ്യം=2) 2 => ഒബ്ജക്റ്റ്(stdClass) പൊതു "ഫോൺ " => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 3" (ദൈർഘ്യം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2014-08-22T16:01:10" (ദൈർഘ്യം= 19) പൊതു "തരം" => സ്ട്രിംഗ് "17" (ദൈർഘ്യം=2)
എന്നെ സംബന്ധിച്ചിടത്തോളം, “നിബന്ധനകളുടെ സ്ഥലങ്ങളിലെ മാറ്റത്തിൽ നിന്ന്, തുക മാറില്ല” (സി). എന്ത് വ്യാജം, എന്ത് സ്ട്രക്റ്റ്ഞങ്ങൾ ഇതുവരെ ലക്ഷ്യത്തിലെത്തിയിട്ടില്ല! അത് നേടിയെടുക്കാൻ, മനസ്സിലാക്കാൻ കഴിയാത്ത ഈ പേരുകൾക്ക് പകരം, നമ്മുടെ നാട്ടുകാരനാണെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട് സന്ദേശം. എന്നാൽ ഇത് എങ്ങനെ നേടാം, രചയിതാവിന് ഇതുവരെ അറിയില്ല. അതിനാൽ, നമുക്ക് ചെയ്യാൻ കഴിയുന്ന ഒരേയൊരു കാര്യം അധിക കണ്ടെയ്നർ ഒഴിവാക്കുക എന്നതാണ്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, പകരം ഞങ്ങൾ അത് ഉറപ്പാക്കും സന്ദേശംആയി വ്യാജം! ഇത് ചെയ്യുന്നതിന്, ഒബ്ജക്റ്റ് ഇനിപ്പറയുന്ന രീതിയിൽ മാറ്റുക:
// സെർവറിലേക്ക് അയയ്ക്കാൻ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുക $req = പുതിയ അഭ്യർത്ഥന(); $msg1 = പുതിയ സന്ദേശം(); $msg1->ഫോൺ = "79871234567"; $msg1->വാചകം = "ടെസ്റ്റ് സന്ദേശം 1"; $msg1->തീയതി = "2013-07-21T15:00:00.26"; $msg1->തരം = 15; $msg2 = പുതിയ സന്ദേശം(); $msg2->ഫോൺ = "79871234567"; $msg2->വാചകം = "ടെസ്റ്റ് സന്ദേശം 2"; $msg2->തീയതി = "2014-08-22T16:01:10"; $msg2->തരം = 16; $msg3 = പുതിയ സന്ദേശം(); $msg3->ഫോൺ = "79871234567"; $msg3->വാചകം = "ടെസ്റ്റ് സന്ദേശം 3"; $msg3->തീയതി = "2014-08-22T16:01:10"; $msg3->തരം = 17; $req->messageList = $msg1; $req->messageList = $msg2; $req->messageList = $msg3; $req->messageList = (object)$req->messageList;
നമുക്ക് ഭാഗ്യം ലഭിക്കുകയും സ്കീമിൽ നിന്ന് ശരിയായ പേര് വരികയും ചെയ്താലോ? ഇത് ചെയ്യുന്നതിന്, വന്ന എൻവലപ്പ് നോക്കാം:
അതെ, അത്ഭുതം സംഭവിച്ചില്ല! വ്യാജം- ഞങ്ങൾ വിജയിക്കില്ല! വന്നു എസ്എംഎസ് അയയ്ക്കുകഈ കേസിലെ ഒബ്ജക്റ്റ് ഇതുപോലെ കാണപ്പെടും:
ഒബ്ജക്റ്റ്(stdClass) പൊതു "messageList" => ഒബ്ജക്റ്റ് (stdClass) പൊതു "BOGUS" => അറേ (വലിപ്പം=3) 0 => ഒബ്ജക്റ്റ്(stdClass) പൊതു "ഫോൺ" => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു " വാചകം =2) 1 => ഒബ്ജക്റ്റ്(stdClass) പൊതു "ഫോൺ" => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം=11) പൊതു "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 2" (ദൈർഘ്യം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് " 2014-08-22T16:01:10" (ദൈർഘ്യം=19) പൊതു "തരം" => സ്ട്രിംഗ് "16" (നീളം=2) 2 => ഒബ്ജക്റ്റ്(stdClass) പൊതു "ഫോൺ" => സ്ട്രിംഗ് "79871234567" (ദൈർഘ്യം= 11) പൊതു "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ടെസ്റ്റ് സന്ദേശം 3" (ദൈർഘ്യം=37) പൊതു "തീയതി" => സ്ട്രിംഗ് "2014-08-22T16:01:10" (ദൈർഘ്യം=19) പൊതു "തരം" => സ്ട്രിംഗ് " 17" (നീളം=2)
അവർ പറയുന്നതുപോലെ - "ഏതാണ്ട്"! ഈ (അല്പം ദുഃഖകരമായ) കുറിപ്പിൽ, നിശബ്ദമായി ഞങ്ങൾക്കായി ചില നിഗമനങ്ങളിൽ എത്തിച്ചേരാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു.
8 ഉപസംഹാരം
ഒടുവിൽ ഞങ്ങൾ ഇവിടെ എത്തി! നിങ്ങൾക്ക് ഇപ്പോൾ എന്തുചെയ്യാനാകുമെന്ന് നമുക്ക് തീരുമാനിക്കാം:- നിങ്ങളുടെ വെബ് സേവനത്തിന് ആവശ്യമായ WSDL ഫയൽ നിങ്ങൾക്ക് എഴുതാം;
- SOAP പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് സെർവറുമായി ആശയവിനിമയം നടത്താൻ കഴിയുന്ന പ്രശ്‌നങ്ങളൊന്നുമില്ലാതെ നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം ക്ലയന്റ് എഴുതാൻ കഴിയും;
- SOAP വഴി പുറം ലോകവുമായി ആശയവിനിമയം നടത്തുന്ന നിങ്ങളുടെ സ്വന്തം സെർവർ നിങ്ങൾക്ക് എഴുതാം;
- നിങ്ങളുടെ ക്ലയന്റിൽനിന്ന് (ചില നിയന്ത്രണങ്ങളോടെ) നിങ്ങൾക്ക് ഒരേ തരത്തിലുള്ള ഒബ്ജക്റ്റുകളുടെ അറേകൾ സെർവറിലേക്ക് അയയ്ക്കാൻ കഴിയും.
- നേറ്റീവ് ക്ലാസ് SoapClient ന് XML-ൽ ഒരേ തരത്തിലുള്ള ഡാറ്റാ ഘടനകളെ എങ്ങനെ ശരിയായി സീരിയലൈസ് ചെയ്യാമെന്ന് അറിയില്ല;
- XML-ലേക്ക് ഒരു അറേ സീരിയലൈസ് ചെയ്യുമ്പോൾ, അത് പേരുള്ള ഒരു അധിക ഘടകം സൃഷ്ടിക്കുന്നു സ്ട്രക്റ്റ്;
- XML-ലേക്ക് ഒരു ഒബ്ജക്റ്റ് സീരിയൽ ചെയ്യുമ്പോൾ, അത് പേരുള്ള ഒരു അധിക ഘടകം സൃഷ്ടിക്കുന്നു വ്യാജം;
- വ്യാജംതിന്മ കുറവാണ് സ്ട്രക്റ്റ്എൻവലപ്പ് കൂടുതൽ കോംപാക്ട് ആയതിനാൽ (എൻവലപ്പിന്റെ എക്സ്എംഎൽ ഹെഡറിൽ അധിക നെയിംസ്പേസുകളൊന്നും ചേർത്തിട്ടില്ല);
- നിർഭാഗ്യവശാൽ, SoapServer ക്ലാസ് ഞങ്ങളുടെ XML സ്കീമ ഉപയോഗിച്ച് എൻവലപ്പ് ഡാറ്റ സ്വയമേവ സാധൂകരിക്കുന്നില്ല (ഒരുപക്ഷേ മറ്റ് സെർവറുകളും ഇല്ലായിരിക്കാം).
എന്താണ് സോപ്പ്?
SOAP എന്നാൽ സിമ്പിൾ ഒബ്ജക്റ്റ് ആക്സസ് പ്രോട്ടോക്കോൾ (സിമ്പിൾ ഒബ്ജക്റ്റ് ആക്സസ് പ്രോട്ടോക്കോൾ) ആണ്. ലേഖനം വായിച്ചതിനുശേഷം നിങ്ങൾ ആശയക്കുഴപ്പത്തിലാകുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു: "എന്താണ് ഈ വിചിത്രമായ പേര്?"
SOAP അതിന്റെ നിലവിലെ രൂപത്തിൽ ഒരു നെറ്റ്‌വർക്കിലൂടെയുള്ള റിമോട്ട് പ്രൊസീജർ കോളിംഗ് (RPC) രീതിയാണ്. (അതെ, XML ആയി ഡോക്യുമെന്റുകൾ കൈമാറാനും ഇത് ഉപയോഗിക്കുന്നു, പക്ഷേ ഞങ്ങൾ അത് ഇപ്പോൾ ഒഴിവാക്കും.)
നമുക്ക് അത് കണ്ടുപിടിക്കാം. തന്നിരിക്കുന്ന ടിക്കറിന് (സ്റ്റോക്ക് ചിഹ്നം) സ്റ്റോക്ക് ഉദ്ധരണി നൽകുന്ന ഒരു സേവനം നിങ്ങൾക്കുണ്ടെന്ന് സങ്കൽപ്പിക്കുക. ഇത് നാസ്ഡാക്ക് സൈറ്റിലേക്ക് ഡാറ്റ അയയ്ക്കുകയും തിരികെ നൽകിയ HTML അടിസ്ഥാനമാക്കി ആവശ്യമുള്ള ഫലം സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. കൂടാതെ, മറ്റ് ഡെവലപ്പർമാരെ അവരുടെ ആപ്ലിക്കേഷനുകൾക്കുള്ളിൽ ഇത് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നതിന്, നിങ്ങൾ ഈ സേവനം ഇന്റർനെറ്റ് വഴി ഉദ്ധരണികളെക്കുറിച്ചുള്ള വിവരങ്ങൾ കണ്ടെത്തുന്ന ഒരു ഘടകമാക്കി മാറ്റുന്നു. ഒരു ദിവസം നാസ്ഡാക്ക് അവരുടെ പേജുകളുടെ ലേഔട്ട് മാറ്റുന്നത് വരെ ഇത് മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു. നിങ്ങൾ ഘടകത്തിന്റെ മുഴുവൻ ലോജിക്കും അവലോകനം ചെയ്യുകയും അത് ഉപയോഗിക്കുന്ന എല്ലാ ഡവലപ്പർമാർക്കും അപ്‌ഡേറ്റുകൾ അയയ്ക്കുകയും വേണം. കൂടാതെ, അവർ അവരുടെ എല്ലാ ഉപയോക്താക്കൾക്കും അപ്‌ഡേറ്റുകൾ അയയ്‌ക്കേണ്ടതുണ്ട്. ഇത് കൂടുതലോ കുറവോ പതിവായി സംഭവിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ സഹ ഡെവലപ്പർമാർക്കിടയിൽ നിങ്ങൾക്ക് ധാരാളം ശത്രുക്കളെ ഉണ്ടാക്കാം. പ്രോഗ്രാമർമാരുമായി, നിങ്ങൾക്കറിയാവുന്നതുപോലെ, തമാശകൾ മോശമാണ്. നാളെ ഓഫീസ് ഷ്രെഡറിൽ നിന്ന് നിങ്ങളുടെ പ്രിയപ്പെട്ട പൂച്ചയുടെ ചിത്രം ലഭിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല, അല്ലേ?
എന്തുചെയ്യും? നമുക്ക് നോക്കാം... നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ഒരു ടിക്കർ (തരം സ്ട്രിംഗ്) ഇൻപുട്ടായി എടുക്കുകയും ഒരു സ്റ്റോക്ക് ഉദ്ധരണി (ഫ്ളോട്ട് അല്ലെങ്കിൽ ഇരട്ടി) നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നൽകുക മാത്രമാണ്. അതിനാൽ നിങ്ങളുടെ ഡെവലപ്പർമാരെ വെബിലൂടെ ഈ ഫംഗ്ഷൻ വിളിക്കാൻ അനുവദിക്കുന്നത് എളുപ്പമല്ലേ? മികച്ചത്! ഇത് എനിക്കും ഒരു വാർത്തയാണ്, വർഷങ്ങളായി ഇത് ചെയ്യുന്ന COM ഉം കോർബയും ജാവയും ഉണ്ട് ... എന്താണ് ശരി, എന്നാൽ ഈ രീതികൾ കുറവുകളല്ല. റിമോട്ട് COM കോൺഫിഗറേഷൻ നിസ്സാരമല്ല. കൂടാതെ, നിങ്ങൾ ഫയർവാളിൽ നിരവധി പോർട്ടുകൾ തുറക്കേണ്ടതുണ്ട്, അതിനാൽ നിങ്ങൾക്ക് സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർക്ക് മതിയായ ബിയർ ലാഭിക്കാൻ കഴിയില്ല. അതെ, വിൻഡോസ് ഒഴികെയുള്ള എല്ലാ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെയും ഉപയോക്താക്കളെ കുറിച്ച് നിങ്ങൾ മറക്കണം. എന്നാൽ എല്ലാത്തിനുമുപരി, ലിനക്സ് ഉപയോക്താക്കളും ചിലപ്പോൾ എക്സ്ചേഞ്ചിൽ താൽപ്പര്യപ്പെടുന്നു.
ലിനക്സ് ഉപയോക്താക്കൾ DCOM ഉപയോഗിക്കുകയാണെങ്കിൽ എല്ലാം നഷ്‌ടമാകില്ല, കൂടുതൽ ഇവിടെ: http://www.idevresource.com/com/library/res/articles/comonlinux.asp.
കോർബയെയും ജാവയെയും കുറിച്ച് എനിക്ക് കൂടുതൽ പറയാൻ കഴിയില്ല, അതിനാൽ ഒരു വ്യായാമമെന്ന നിലയിൽ ഈ സമീപനങ്ങളിലെ ദോഷങ്ങൾ കണ്ടെത്താൻ വായനക്കാർക്ക് നിർദ്ദേശിക്കുന്നു.
അത്തരമൊരു റിമോട്ട് കോളും ഫലം നൽകുന്ന ഫോമും വിവരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു മാനദണ്ഡമാണ് SOAP. അതിനാൽ, നെറ്റ്‌വർക്കിൽ ലഭ്യമായ ഒരു ആപ്ലിക്കേഷനിൽ നിങ്ങളുടെ ഫംഗ്ഷൻ ഹോസ്റ്റുചെയ്യുകയും SOAP പാക്കറ്റുകളുടെ രൂപത്തിൽ കോളുകൾ സ്വീകരിക്കുകയും വേണം. അതിനുശേഷം, നിങ്ങൾ ഇൻപുട്ട് സാധൂകരിക്കുകയും നിങ്ങളുടെ പ്രവർത്തനം പ്രവർത്തിപ്പിക്കുകയും ഒരു പുതിയ SOAP പാക്കേജിൽ ഫലം നൽകുകയും ചെയ്യുന്നു. മുഴുവൻ പ്രക്രിയയും HTTP-യിൽ പ്രവർത്തിക്കാൻ കഴിയും, അതിനാൽ നിങ്ങൾ ഫയർവാളിൽ ഒരു കൂട്ടം പോർട്ടുകൾ തുറക്കേണ്ടതില്ല. ഇത് ലളിതമാണോ?
ഈ ലേഖനം എന്തിനെക്കുറിച്ചാണ്
അഗ്നി സോഫ്‌റ്റ്‌വെയറിൽ ഞങ്ങൾ എഴുതുന്ന സോപ്പിനെക്കുറിച്ചുള്ള ലേഖനങ്ങളുടെ പരമ്പരയിലെ ആദ്യത്തേതാണ് ഇത്. ഈ ലേഖനത്തിൽ, SOAP എന്താണെന്നും ഒരു SOAP സെർവറുമായി ആശയവിനിമയം നടത്തുന്ന ഒരു ആപ്ലിക്കേഷൻ എങ്ങനെ എഴുതാമെന്നും നിങ്ങൾക്ക് ഒരു ആശയം നൽകാൻ ഞാൻ ശ്രമിക്കും.സോപ്പും XML
SOAP ഇപ്പോഴും നിങ്ങൾക്ക് ലളിതമാണെന്ന് തോന്നുന്നുവെങ്കിൽ, നമുക്ക് XML ചേർക്കാം. ഇപ്പോൾ, ഒരു ഫംഗ്ഷൻ നാമത്തിനും പാരാമീറ്ററുകൾക്കും പകരം, നിങ്ങളെ ആശയക്കുഴപ്പത്തിലാക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നതുപോലെ, ഞങ്ങൾക്ക് വളരെ സങ്കീർണ്ണമായ ഒരു XML എൻവലപ്പ് ലഭിക്കുന്നു. പക്ഷേ പേടിക്കേണ്ട. ഇനിയും വരാനുണ്ട്, SOAP-ന്റെ സങ്കീർണ്ണത മനസ്സിലാക്കാൻ നിങ്ങൾ മുഴുവൻ ചിത്രവും കാണേണ്ടതുണ്ട്.XML എന്താണെന്ന് നിങ്ങൾക്ക് അറിയില്ലെങ്കിൽ, ആദ്യം എന്റെ XML ലേഖനം ഇവിടെ വായിക്കുക: http://www.agnisoft.com/white_papers/xml_delphi.asp.
എല്ലാ SOAP പാക്കറ്റുകളും XML ഫോർമാറ്റിലാണ്. എന്താണ് ഇതിനർത്ഥം? നമുക്ക് കാണാം. ഈ ഫംഗ്ഷൻ നോക്കുക (പാസ്കൽ):
ഫംഗ്ഷൻ GetStockQuote(ചിഹ്നം: സ്ട്രിംഗ്) : ഇരട്ട; മികച്ചതായി തോന്നുന്നു, പക്ഷേ പ്രശ്നം അത് പാസ്കലാണ്. ഒരു ജാവ ഡെവലപ്പർക്ക് ഈ ലളിതമായ നിർവചനത്തിന്റെ ഉപയോഗം എന്താണ്? അതോ VB യുടെ കൂടെ ജോലി ചെയ്യുന്ന ഒരാൾക്ക് വേണ്ടിയോ? VB പ്രോഗ്രാമർമാർക്ക് പോലും എല്ലാവർക്കും മനസ്സിലാകുന്ന എന്തെങ്കിലും ഞങ്ങൾക്ക് ആവശ്യമാണ്. അതിനാൽ അവർക്ക് ഒരേ വിവരങ്ങൾ അടങ്ങിയ XML നൽകുക (പാരാമീറ്ററുകൾ, സ്റ്റോക്ക് ഉദ്ധരണികൾ മുതലായവ). നിങ്ങൾ ഒരു SOAP പാക്കേജ് സൃഷ്ടിക്കുന്നു, അത് നിങ്ങളുടെ ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു കോൾ ആണ്, അത് XML-ൽ പൊതിഞ്ഞ് ഏത് പ്ലാറ്റ്‌ഫോമിലെയും ഏത് ആപ്ലിക്കേഷനും അത് മനസ്സിലാക്കാൻ കഴിയും. ഇനി നമ്മുടെ SOAP കോൾ എങ്ങനെയുണ്ടെന്ന് നോക്കാം:
xmlns:xsd="http://www.w3.org/1999/XMLSchema">
വിജ്ഞാനപ്രദം, അല്ലേ? നമ്മുടെ കൺമുന്നിൽ സോപ്പ് ലളിതമാക്കുകയാണ്. ശരി, തമാശകൾ മാറ്റിവെക്കുക. ഈ SOAP കോൾ എങ്ങനെ മനസ്സിലാക്കാമെന്ന് ഇപ്പോൾ ഞാൻ നിങ്ങളോട് വിശദീകരിക്കാൻ ശ്രമിക്കും.
ടാഗ് ഡീക്രിപ്ഷൻ
നിങ്ങളുടെ ശ്രദ്ധ ആകർഷിക്കുന്ന ആദ്യത്തെ ടാഗ്അടുത്ത ടാഗ്
ലിസ്റ്റിലെ അടുത്ത ടാഗ് − ആണ്
നെയിംസ്‌പെയ്‌സിനെക്കുറിച്ചുള്ള ഒരു സൈഡ് നോട്ട്: ഒരു എക്സ്എംഎൽ ടാഗിന് യോഗ്യത നേടാൻ നെയിംസ്പേസ് നിങ്ങളെ അനുവദിക്കുന്നു. നിങ്ങൾക്ക്, ഉദാഹരണത്തിന്, ഒരേ പേരിലുള്ള രണ്ട് വേരിയബിളുകൾ ഒരേ പ്രൊസീജിയറിൽ ഉണ്ടാകാൻ കഴിയില്ല, എന്നാൽ അവ രണ്ട് വ്യത്യസ്ത നടപടിക്രമങ്ങളിലാണെങ്കിൽ, ഒരു പ്രശ്നവുമില്ല. അങ്ങനെ, ഒരു നടപടിക്രമം ഒരു നെയിംസ്പേസ് ആണ്, കാരണം അതിലെ എല്ലാ പേരുകളും അദ്വിതീയമാണ്. അതുപോലെ, XML ടാഗുകൾ നെയിംസ്‌പെയ്‌സുകളിൽ സ്‌കോപ്പ് ചെയ്‌തിരിക്കുന്നു, അതിനാൽ ഒരു നെയിംസ്‌പെയ്‌സും ടാഗ് നാമവും നൽകിയാൽ, ഒരാൾക്ക് അത് അദ്വിതീയമായി തിരിച്ചറിയാൻ കഴിയും. നമ്മുടെ NS1 നെ ഇമിറ്റേറ്ററുകളിൽ നിന്ന് വേർതിരിച്ചറിയാൻ ഞങ്ങൾ ഒരു നെയിംസ്പേസിനെ ഒരു URI ആയി നിർവ്വചിക്കും. മുകളിലുള്ള ഉദാഹരണത്തിൽ, NS1 എന്നത് urn:xmethods-quotes-ലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഒരു അപരനാമമാണ്.
എൻകോഡിംഗ് സ്റ്റൈൽ ആട്രിബ്യൂട്ടും ശ്രദ്ധിക്കുക - ഈ ആട്രിബ്യൂട്ട് SOAP കോൾ എങ്ങനെ സീരിയലൈസ് ചെയ്യപ്പെടുന്നു എന്ന് വ്യക്തമാക്കുന്നു.
ടാഗിനുള്ളിൽ
xsi:type="xsd:string"
XML തരങ്ങളെ നിർവചിക്കുന്നത് ഇങ്ങനെയാണ്. (സാങ്കേതികവിദ്യയെക്കുറിച്ച് സാമാന്യവൽക്കരിക്കുമ്പോൾ "ഏകദേശം" എന്ന വാക്ക് ഞാൻ എത്ര സമർത്ഥമായി ഉപയോഗിച്ചുവെന്നത് ശ്രദ്ധിക്കുക, ലേഖനം പ്രസിദ്ധീകരിച്ചു കഴിഞ്ഞാൽ അത് മാറിയേക്കാം.) ഇത് കൃത്യമായി എന്താണ് അർത്ഥമാക്കുന്നത്: xsi നെയിംസ്പേസിൽ നിർവചിച്ചിരിക്കുന്ന തരം, ടാഗിൽ നിർവചിച്ചിരിക്കുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കുന്നു
ടാഗിനുള്ളിൽ
ശരി, അവസാനം, മാന്യരായ ആളുകളെപ്പോലെ, ഞങ്ങൾ എല്ലാ ടാഗുകളും അടച്ചു.
അതിനാൽ SOAP സെർവറിലേക്കുള്ള കോൾ നിർവചിക്കുന്ന SOAP പാക്കേജ് ഞങ്ങൾ കണ്ടെത്തി. കൂടാതെ SOAP സെർവർ, XML പാഴ്‌സറുകളും ഒരു ചുവന്ന ബട്ടണും MIR സ്‌പേസ് സ്റ്റേഷനും ഉപയോഗിച്ച് ഈ കോൾ ഡീകോഡ് ചെയ്യുകയും നിങ്ങൾക്ക് ഒരു സ്റ്റോക്ക് ഉദ്ധരണി ആവശ്യമാണെന്ന് നിർണ്ണയിക്കുകയും ചെയ്യുന്നു. ഇത് ഉടനടി ആവശ്യമായ ഉദ്ധരണി കണ്ടെത്തി ഈ ഫോമിൽ നിങ്ങൾക്ക് തിരികെ നൽകും:
ഒട്ടുമിക്ക വാണിജ്യ സെർവറുകളും, ഏത് കറൻസിയിലാണ്, അവസാനത്തെ ഓഹരി ഏത് വിലയ്ക്കാണ് വാങ്ങിയത് തുടങ്ങിയ കൂടുതൽ വിവരങ്ങൾ തിരികെ നൽകും. ഓഹരി വില, ഒരുപക്ഷേ, കൂടുതൽ കൃത്യമായിരിക്കും.
ഇതുവഴി SOAP സെർവർ എന്താണ് പ്രതീക്ഷിക്കുന്നതെന്നും അത് എന്ത് തിരികെ നൽകുമെന്നും ഞങ്ങൾക്കറിയാം. അപ്പോൾ നിങ്ങൾ എങ്ങനെയാണ് ഈ വിവരങ്ങൾ അയയ്ക്കുന്നത്? ഏത് ഗതാഗതവും ഉപയോഗിക്കാം. ഏറ്റവും കൂടുതൽ പ്രകാശിപ്പിക്കുന്നത് HTTP ആണ്. HTTP-യുടെ വിശദാംശങ്ങളിലേക്ക് ഞാൻ കടക്കില്ല, അറിയാത്തവർക്കായി, നിങ്ങൾ സന്ദർശിക്കുന്ന സൈറ്റുകളുമായി ആശയവിനിമയം നടത്താൻ നിങ്ങളുടെ ബ്രൗസർ ഉപയോഗിക്കുന്നത് ഇതാണ്.
ആവശ്യമുള്ള HTTP അഭ്യർത്ഥന ഇതുപോലെയായിരിക്കും:
POST /StockQuote HTTP/1.1
ഹോസ്റ്റ്: www.stockquoteserver.com
ഉള്ളടക്ക ദൈർഘ്യം: nnnn
SOAPAction: "Some-URI"
സോപ്പ് അഭ്യർത്ഥന പാക്കറ്റ് ഇവിടെയുണ്ട്... ശ്രദ്ധിക്കേണ്ട മറ്റൊരു കാര്യം SOAPAction തലക്കെട്ടാണ്. ഈ തലക്കെട്ട് അഭ്യർത്ഥനയുടെ ഉദ്ദേശ്യത്തെ സൂചിപ്പിക്കുന്നു, അത് ആവശ്യമാണ്. ഓരോ SOAP സെർവറിനും പരിധിയില്ലാത്ത ഫംഗ്‌ഷനുകൾ ഉണ്ടായിരിക്കാം കൂടാതെ ഏത് ഫംഗ്‌ഷനാണ് വിളിക്കുന്നതെന്ന് നിർണ്ണയിക്കാൻ SOAPAction തലക്കെട്ട് ഉപയോഗിക്കാനും കഴിയും. ഫയർവാളുകൾക്കും മൾട്ടിപ്ലക്സറുകൾക്കും ഈ തലക്കെട്ടിനെ അടിസ്ഥാനമാക്കി ഉള്ളടക്കം ഫിൽട്ടർ ചെയ്യാനാകും.
HTTP സെർവറിൽ നിന്നുള്ള SOAP പ്രതികരണം ഇതുപോലെ കാണപ്പെടും:
HTTP/1.1 200 ശരി
ഉള്ളടക്ക-തരം: വാചകം/xml; charset="utf-8"
ഉള്ളടക്ക ദൈർഘ്യം: nnnn
സോപ്പ് റെസ്‌പോൺസ് പാക്കറ്റ് ഇവിടെ... എന്തുകൊണ്ട് HTTP? ഒന്നാമതായി, നെറ്റ്‌വർക്ക് അഡ്മിനിസ്ട്രേറ്റർമാർ SOAP കോളുകൾക്കായി ധാരാളം പ്രത്യേക പോർട്ടുകൾ തുറക്കേണ്ടതില്ല... വെബ് സെർവറിന് കോളുകൾ സമാധാനപരമായി കൈകാര്യം ചെയ്യാൻ കഴിയും, കാരണം ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നതിന് പോർട്ട് 80 സാധാരണയായി എല്ലാവർക്കും തുറന്നിരിക്കും. CGI, ISAPI, മറ്റ് നേറ്റീവ് മൊഡ്യൂളുകൾ എന്നിവ ഉപയോഗിക്കുന്ന വെബ് സെർവറുകളുടെ വിപുലീകരണമാണ് മറ്റൊരു നേട്ടം. മറ്റ് വെബ് ഉള്ളടക്കങ്ങളെ ബാധിക്കാതെ തന്നെ SOAP അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്ന ഒരു മൊഡ്യൂൾ എഴുതാൻ ഈ വിപുലീകരണം നിങ്ങളെ അനുവദിക്കുന്നു.
അത്രയേയുള്ളൂ
ഈ ലേഖനം സോപ്പിനെക്കുറിച്ച് കുറച്ച് വെളിച്ചം വീശാൻ സഹായിച്ചിട്ടുണ്ടെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. നിങ്ങൾ ഇപ്പോഴും ഇവിടെയുണ്ടെങ്കിൽ, ഈ വിഷയത്തെക്കുറിച്ച് കൂടുതൽ വായിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, രചയിതാവിന്റെ സൈറ്റ് സന്ദർശിക്കുക: http://www.agnisoft.com/soap
ഗാനരചന ഭാഗം.
പുറത്ത് നിന്ന് ലഭ്യമാകേണ്ട ഒരു പ്രത്യേക സംവിധാനം നിങ്ങൾ നടപ്പിലാക്കി അല്ലെങ്കിൽ നടപ്പിലാക്കുകയാണെന്ന് സങ്കൽപ്പിക്കുക. ആ. നിങ്ങൾ ആശയവിനിമയം നടത്തേണ്ട ഒരു പ്രത്യേക സെർവർ ഉണ്ട്. ഉദാഹരണത്തിന് ഒരു വെബ് സെർവർ.
ഈ സെർവറിന് നിരവധി പ്രവർത്തനങ്ങൾ നടത്താനും ഡാറ്റാബേസിൽ പ്രവർത്തിക്കാനും മറ്റ് സെർവറുകളിലേക്ക് ചില മൂന്നാം കക്ഷി അഭ്യർത്ഥനകൾ നടത്താനും ചില കണക്കുകൂട്ടലുകൾ നടത്താനും കഴിയും. അവന്റെ അറിയപ്പെടുന്ന സാഹചര്യത്തിനനുസരിച്ച് ജീവിക്കുകയും ഒരുപക്ഷേ വികസിപ്പിക്കുകയും ചെയ്യുക (അതായത്, ഡെവലപ്പർമാരുടെ സാഹചര്യം അനുസരിച്ച്). ഒരു വ്യക്തിക്ക് അത്തരം ഒരു സെർവറുമായി ആശയവിനിമയം നടത്തുന്നത് രസകരമല്ല, കാരണം ചിത്രങ്ങളും മറ്റ് ഉപയോക്തൃ-സൗഹൃദ ഉള്ളടക്കവും ഉള്ള മനോഹരമായ പേജുകൾ നൽകാൻ അയാൾക്ക് കഴിയണമെന്നില്ല / ആഗ്രഹിക്കുന്നില്ല. ഇത് എഴുതുകയും പ്രവർത്തിക്കുകയും പ്രവർത്തിക്കുകയും അതിനുള്ള അഭ്യർത്ഥനകൾ നൽകുകയും ചെയ്യുന്നു, അവ മനുഷ്യർക്ക് വായിക്കാൻ കഴിയുന്നതാണെന്ന് ശ്രദ്ധിക്കാതെ, ക്ലയന്റ് അവ സ്വയം കൈകാര്യം ചെയ്യും.
മറ്റ് സിസ്റ്റങ്ങൾക്ക്, ഈ സെർവർ ആക്സസ് ചെയ്യുന്നത്, ഈ സെർവറിൽ നിന്ന് ലഭിച്ച ഡാറ്റ അവരുടെ സ്വന്തം വിവേചനാധികാരത്തിൽ ഇതിനകം തന്നെ വിനിയോഗിക്കാൻ കഴിയും - പ്രോസസ്സ് ചെയ്യുക, ശേഖരിക്കുക, അവരുടെ ക്ലയന്റുകൾക്ക് വിതരണം ചെയ്യുക തുടങ്ങിയവ.
ശരി, അത്തരം സെർവറുകളുമായി ആശയവിനിമയം നടത്തുന്നതിനുള്ള ഓപ്ഷനുകളിലൊന്ന് 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"); soap.AddUser(NewUser);
ധാരാളം ദോഷങ്ങളുമുണ്ട്:
- യുക്തിരഹിതമായി വലിയ സന്ദേശ വലുപ്പം. ശരി, ഇവിടെ xml ന്റെ സ്വഭാവം തന്നെ ഫോർമാറ്റ് അനാവശ്യമാണ്, കൂടുതൽ ടാഗുകൾ, കൂടുതൽ ഉപയോഗശൂന്യമായ വിവരങ്ങൾ. പ്ലസ് സോപ്പ് അതിന്റെ ആവർത്തനം കൂട്ടുന്നു. ഇൻട്രാനെറ്റ് സിസ്റ്റങ്ങൾക്കായി, ട്രാഫിക് പ്രശ്നം ഇന്റർനെറ്റിനേക്കാൾ നിശിതമാണ്, അതിനാൽ പ്രാദേശിക നെറ്റ്‌വർക്കുകൾക്കുള്ള സോപ്പിന് ഡിമാൻഡ് കൂടുതലാണ്, പ്രത്യേകിച്ചും, ഷെയർപോയിന്റിന് ഒരു സോപ്പ് വെബ് സേവനമുണ്ട്, അത് നിങ്ങൾക്ക് വിജയത്തോടെ ആശയവിനിമയം നടത്താം (ചില പരിമിതികളും).
- വെബ് സേവന വിവരണത്തിന്റെ യാന്ത്രിക മാറ്റം എല്ലാ ക്ലയന്റുകളേയും തകർക്കും. ശരി, ഇത് ഏത് സിസ്റ്റത്തിനും പോലെയാണ്, അതിനാൽ പഴയ രീതികളുമായുള്ള പിന്നോക്ക അനുയോജ്യത പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ, എല്ലാം വീഴും ...
- ഒരു മൈനസ് അല്ല, ഒരു പോരായ്മ. എല്ലാ രീതി കോൾ പ്രവർത്തനങ്ങളും ആറ്റോമിക് ആയിരിക്കണം. ഉദാഹരണത്തിന്, ഒരു സബ്ഡിയിൽ പ്രവർത്തിക്കുമ്പോൾ, നമുക്ക് ഒരു ഇടപാട് ആരംഭിക്കാം, നിരവധി ചോദ്യങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യാം, തുടർന്ന് റോൾബാക്ക് അല്ലെങ്കിൽ കമ്മിറ്റ് ചെയ്യാം. സോപ്പിൽ ഇടപാടുകളൊന്നുമില്ല. ഒരു അഭ്യർത്ഥന, ഒരു പ്രതികരണം, സംഭാഷണം അവസാനിച്ചു.
- സെർവർ വശത്തുള്ളതിന്റെ വിവരണം കൈകാര്യം ചെയ്യുന്നത് (എല്ലാം ഞാൻ ശരിയായി വിവരിച്ചിട്ടുണ്ടോ?), ക്ലയന്റിലുള്ളത് (എനിക്ക് ഇവിടെ എന്താണ് എഴുതിയത്?) വളരെ ബുദ്ധിമുട്ടാണ്. എനിക്ക് ക്ലയന്റ് വശവുമായി ഇടപഴകുകയും ഡാറ്റ തെറ്റായി വിവരിച്ചതായി സെർവർ പ്രോഗ്രാമറെ ബോധ്യപ്പെടുത്തുകയും ചെയ്യേണ്ടി വന്ന നിരവധി തവണ ഉണ്ടായിട്ടുണ്ട്, പക്ഷേ അവയിൽ ഒന്നും അദ്ദേഹത്തിന് മനസ്സിലാക്കാൻ കഴിഞ്ഞില്ല, കാരണം ഓട്ടോമാറ്റിക് ജനറേഷനും അവനും അങ്ങനെ ചെയ്യരുത്, ഇത് സോഫ്റ്റ്‌വെയറിന്റെ കാര്യമാണ്. പിശക് സ്വാഭാവികമായും രീതിയുടെ കോഡിലായിരുന്നു, പ്രോഗ്രാമർ അത് കണ്ടില്ല.
- വെബ് സേവനങ്ങളുടെ ഡെവലപ്പർമാർ ഈ വെബ് സേവനങ്ങൾ ഉപയോഗിക്കുന്ന ആളുകളിൽ നിന്ന് വളരെ അകലെയാണെന്ന് പ്രാക്ടീസ് കാണിക്കുന്നു. ഏതെങ്കിലും അഭ്യർത്ഥനയ്‌ക്ക് മറുപടിയായി (പുറത്തുനിന്ന് സാധുവായത്), "പിശക് 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 ഉള്ളടക്ക-തരം: വാചകം/xml; charset=utf-8 ഉള്ളടക്ക-ദൈർഘ്യം: ദൈർഘ്യം SOAPAction: "http://webservices.belavia.by/GetAirportsList"
ഉത്തരം ഇതായിരിക്കും:
HTTP/1.1 200 ശരി തീയതി: തിങ്കൾ, 30 സെപ്റ്റംബർ 2013 00:06:44 GMT സെർവർ: Microsoft-IIS/6.0 X-Powered-By: ASP.NET X-AspNet-Version: 4.0.30319 Cache-Control: private, max -age=0 ഉള്ളടക്ക-തരം: വാചകം/xml; charset=utf-8 ഉള്ളടക്ക-ദൈർഘ്യം: 2940
ZY മുമ്പ്, Aeroflot വെബ് സേവനം തുറന്നിരുന്നു, എന്നാൽ 1C 8ku-ൽ സോപ്പിനുള്ള പിന്തുണ ചേർത്തതിന് ശേഷം, ഒരു കൂട്ടം 1c ബീറ്റ ടെസ്റ്ററുകൾ അത് വിജയകരമായി ഇൻസ്റ്റാൾ ചെയ്തു. ഇപ്പോൾ അവിടെ എന്തോ മാറ്റം വന്നിട്ടുണ്ട് (എനിക്ക് വിലാസം അറിയില്ല, നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ തിരയാം).
ZZY നിരാകരണം. വീട്ടുതലത്തിൽ സംസാരിച്ചു. നിങ്ങൾക്ക് കുടിക്കാം.
പൊതുവേ, ഇന്ന് സാധാരണ XML ഡാറ്റാ എക്സ്ചേഞ്ച് പ്രോട്ടോക്കോളുകൾ ഉണ്ട്:
- XML-RPC- നിങ്ങൾ ഒരു പാക്കറ്റ് കൈമാറുകയും സെർവറിലെ ഏത് രീതിയാണ് നിങ്ങൾ വിളിക്കേണ്ടതെന്ന് വ്യക്തമാക്കുകയും ചെയ്യുക.
- വിശ്രമിക്കുക- സെർവറിൽ ചില വസ്തുക്കൾ ഉണ്ട്. ഓരോ വസ്തുവിനും ചില ഐഡന്റിഫയറുകൾ ഉണ്ട്. ഓരോ ഘടകത്തിനും അതിന്റേതായ url ഉണ്ട്. ഏതെങ്കിലും ഘടകം ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയും: തിരുകുക, ഇല്ലാതാക്കുക, അപ്ഡേറ്റ് ചെയ്യുക, തിരഞ്ഞെടുക്കുക. നിങ്ങൾ സെർവറിലേക്ക് ആവശ്യമുള്ള അഭ്യർത്ഥന അയയ്ക്കുക (ഉദാഹരണത്തിന്, അത്തരം ഒരു ഘടകം ചേർക്കുക). ക്ലയന്റ്-സെർവർ എക്സ്ചേഞ്ച് JSON അല്ലെങ്കിൽ XML അടിസ്ഥാനമാക്കിയുള്ളതാണ്.
SOAP RPC (സർവീസ് ഓറിയന്റഡ് ആർക്കിടെക്ചർ, പരസ്പരം ഇടപഴകുന്ന ലൂസ്ലി കപ്പിൾഡ് സേവനങ്ങളുടെ ഒരു കൂട്ടം) അടിസ്ഥാനമാക്കിയുള്ളതാണ്. RPC യുടെ പ്രധാന നേട്ടം നെറ്റ്‌വർക്ക് റിസോഴ്‌സുകളുടെ ചെറിയ അളവും (എൻട്രി പോയിന്റുകൾ) ഉൾപ്പെട്ടിരിക്കുന്ന നിരവധി രീതികളുമാണ്. ഈ നേട്ടം ഉണ്ടായിരുന്നിട്ടും, RPC കാലഹരണപ്പെട്ട ഒരു പ്രോട്ടോക്കോൾ ആണ്, അതിന് നിരവധി ദോഷങ്ങളുമുണ്ട്:
- നിങ്ങൾക്ക് XML-RPC സന്ദേശം സാധൂകരിക്കാൻ കഴിയില്ല. XML-ൽ സ്കീമകൾ (ഡാറ്റ മൂല്യനിർണ്ണയ രീതികൾ) സ്റ്റാൻഡേർഡ് ചെയ്യുന്നതിനുമുമ്പ് പഴയ പ്രോട്ടോക്കോൾ സൃഷ്ടിച്ചു. ആ. സെർവർ അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നു, ഈ അഭ്യർത്ഥനകൾ അതിനുള്ളതാണെന്നും ഡാറ്റ പൊരുത്തമില്ലാത്തതാണെന്നും അത് ഉറപ്പാക്കണം. XML-RPC-യിൽ, ഇതിനായി ഡാറ്റ തരങ്ങൾ പ്രഖ്യാപിക്കപ്പെടുന്നു, പക്ഷേ ഇതൊരു ഡാറ്റാ തരം പരിശോധനയാണ്, കൂടാതെ ഡാറ്റാ സ്ഥിരത പരിശോധിക്കില്ല (ആവശ്യമായ എല്ലാ പാരാമീറ്ററുകളുമുള്ള ഒരു ഘടന നിങ്ങൾക്ക് ലഭിച്ചുവെന്ന്).
- നിങ്ങൾക്ക് സംയോജിത സന്ദേശങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയില്ല.
- നിങ്ങൾക്ക് സ്ഥലവും സമയവും ഉപയോഗിക്കാൻ കഴിയില്ല (ആർപിസി സൃഷ്ടിച്ചതിന് ശേഷം പ്രത്യക്ഷപ്പെട്ടു).
- നിങ്ങൾക്ക് സന്ദേശം വികസിപ്പിക്കാൻ കഴിയില്ല, അതായത്. അധിക വിവരങ്ങൾ ചേർക്കുക.
ഈ പോരായ്മകളെല്ലാം XML സ്കീമയിൽ പരിഹരിച്ചു. XML ഡോക്യുമെന്റ് വിവരിക്കുന്നതിനുള്ള വ്യവസായ നിലവാരമാണിത്. ആ. അനിയന്ത്രിതമായ ഡാറ്റ മോഡലിംഗ് ചെയ്യുന്നതിനുള്ള ഒരു മാർഗമാണിത്. ഒരു XML സ്കീമയ്ക്ക് ഒരു മോഡൽ (ഘടകങ്ങളും ആട്രിബ്യൂട്ടുകളും അവയുടെ ഘടനയും തമ്മിലുള്ള ബന്ധങ്ങൾ), ഡാറ്റ തരങ്ങൾ (ഡാറ്റ തരങ്ങളുടെ സ്വഭാവം), പദാവലി (ഘടകങ്ങളുടെയും ആട്രിബ്യൂട്ടുകളുടെയും പേരുകൾ) എന്നിവ വിവരിക്കാൻ കഴിയും.
XML-RPC യുടെ എല്ലാ പോരായ്മകളെയും അടിസ്ഥാനമാക്കി, അവർ SOAP പ്രോട്ടോക്കോൾ സൃഷ്ടിച്ചു.
സോപ്പ്(സിംലി ഒബ്ജക്റ്റ് ആക്സസ് പ്രോട്ടോക്കോൾ) - ഒരു ഒബ്ജക്റ്റ് ആക്സസ് ചെയ്യുന്നതിനുള്ള പ്രോട്ടോക്കോൾ (എൻട്രി പോയിന്റ്). വിതരണം ചെയ്ത ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള പ്രധാന വ്യവസായ നിലവാരമാണ് ഇന്ന്.
ഇത് XML-RPC ഭാഷയുടെ വിപുലീകരണമാണ്. ആ. ഇത് തത്വത്തിൽ നിർമ്മിച്ചതാണ്: 1 എൻട്രി പോയിന്റും ഏതെങ്കിലും രീതികളും. ഗതാഗതത്തിന്റെ കാര്യത്തിൽ പ്രോട്ടോക്കോൾ തന്നെ (ഡാറ്റ കൈമാറുന്നതെങ്ങനെ) വിശാലമായ തിരഞ്ഞെടുപ്പ് നൽകുന്നു: SMTP, FTP, HTTP, MSMQ.
XML വെബ് സേവനങ്ങൾ (XML വെബ് സേവനങ്ങൾ) നടപ്പിലാക്കുന്നതിന്റെ ഹൃദയഭാഗത്താണ് SOAP. പഠിക്കാൻ പ്രയാസമാണ് എന്നതാണ് സോപ്പിന്റെ പോരായ്മ.
ക്ലയന്റും സെർവറും തമ്മിലുള്ള സന്ദേശങ്ങളുടെ കൈമാറ്റത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് SOAP (സമന്വയമായും അസമന്വിതമായും). ഓരോ സന്ദേശവും ഡാറ്റയെക്കുറിച്ചുള്ള വിവരങ്ങൾ വഹിക്കുന്നു (എന്ത് ഡാറ്റയാണ് കൈമാറ്റം ചെയ്യപ്പെടുന്നത്/സ്വീകരിക്കുന്നത്). XML സ്കീമകൾ ഉപയോഗിച്ച് സന്ദേശത്തിന്റെ മുഴുവൻ ഘടനയും SOAP മുൻകൂട്ടി വിവരിക്കുന്നു: സന്ദേശത്തിൽ എന്തായിരിക്കണം, അത് എങ്ങനെ കൈമാറും. സെർവർ അറിയാതെ തന്നെ അവിടെ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസ്സിലാക്കാൻ ഇത് സാധ്യമാക്കുന്നു, കൂടാതെ ഈ സന്ദേശം തനിക്കുള്ളതാണോ എന്ന് പരിശോധിക്കാൻ സെർവറിനെ അനുവദിക്കുന്നു.
XML സ്കീമ
ഒരു സ്കീമയുടെ ഉദ്ദേശ്യം ഡാറ്റ ഘടന വിവരിക്കുക എന്നതാണ്, അതായത്. നമുക്കുള്ളത്. എല്ലാ ഡാറ്റയും ലളിതവും സങ്കീർണ്ണവുമായ തരങ്ങളായി തിരിച്ചിരിക്കുന്നു (സ്കെയിലറുകളും ഘടനകളും). ഒരു ലളിതമായ തരം (സ്ട്രിംഗ്, നമ്പർ, ബൂളിയൻ, തീയതി) ഒരിക്കലും ഉള്ളിൽ ഒന്നും അടങ്ങിയിരിക്കില്ല. ഒരു ഘടനയിൽ (വസ്തു) ഗുണങ്ങൾ അടങ്ങിയിരിക്കാം.
അടിസ്ഥാന സോപ്പ് പ്രവർത്തനങ്ങൾ
- ലളിതമായ ക്ലയന്റ്-സെർവർ വിവര കൈമാറ്റം മാത്രമല്ല. എന്നാൽ സെർവറിന്റെ ഓട്ടോമാറ്റിക് തിരിച്ചറിയലും ഈ സെർവറിനായുള്ള തിരയലും, അതായത്. ക്ലയന്റിന് സെർവറിനെ കുറിച്ച് ഒന്നും അറിയില്ലായിരിക്കാം. ആ. ക്ലയന്റ് ആദ്യം ഒരു സെർവറിനായി തിരയുന്നു, അനുയോജ്യമായ സേവനങ്ങൾ കണ്ടെത്തുന്നു, ഏതൊക്കെ രീതികളാണുള്ളത്, സെർവറിൽ എന്താണ് ഉള്ളതെന്ന് മനസിലാക്കുകയും അതിലേക്ക് ഒരു കോൾ ചെയ്യുകയും ചെയ്യുന്നു.
- സെർവർ അതിന്റെ വിവരങ്ങൾ പ്രസിദ്ധീകരിക്കുന്നു (സ്ഥാനം, അത് ഏത് രീതികൾ പിന്തുണയ്ക്കുന്നു) അതുവഴി ക്ലയന്റിന് ഈ സെർവർ കണ്ടെത്താനാകും. UDDI ഡയറക്‌ടറിയിലാണ് പ്രസിദ്ധീകരണം നടക്കുന്നത്.
SOAP സന്ദേശങ്ങളുടെ ഘടന:
- SOAP എൻവലപ്പ് (എൻവലപ്പ്) - ഇതിൽ മുഴുവൻ സന്ദേശവും ഉൾപ്പെടുന്നു. ഒരു തലക്കെട്ടും ശരീരവും ഉൾക്കൊള്ളുന്നു.
- SOAP തലക്കെട്ട് (തലക്കെട്ട്) - അധിക വിവരങ്ങൾ (അംഗീകാരം, ഉദാഹരണത്തിന്).
- SOAP ബോഡി (ശരീരം) - സന്ദേശം തന്നെ.
- SOAP തകരാർ (പിശക്) - സെർവറിൽ നിന്ന് ക്ലയന്റിലേക്ക് പിശകുകൾ കൈമാറുന്നതിനുള്ള ഒരു മാർഗം.
WSDL
WSDL(വെബ് സേവനങ്ങളുടെ വിവരണ ഭാഷ) - വെബ് സേവന വിവരണ ഭാഷ. SOAP ൽ ഉപയോഗിക്കുന്നു. ഇത് എല്ലാം വിവരിക്കുന്ന ഒരു തരം രേഖയാണ്: ഏതൊക്കെ നെയിംസ്‌പേസുകൾ ഉപയോഗിച്ചു, ഏത് ഡാറ്റാ സ്‌കീമുകൾ ഉപയോഗിച്ചു, സെർവർ ക്ലയന്റിൽ നിന്ന് ഏത് തരത്തിലുള്ള സന്ദേശങ്ങളാണ് പ്രതീക്ഷിക്കുന്നത്, ഏതൊക്കെ എൻവലപ്പുകൾ ഏത് രീതിയിലാണ്, ഏത് രീതികളാണ് പൊതുവെ നിലനിൽക്കുന്നത്, ഏത് വിലാസത്തിലേക്ക് അയയ്ക്കണം, തുടങ്ങിയവ. യഥാർത്ഥത്തിൽ, WSDL ഒരു വെബ് സേവനമാണ്. ക്ലയന്റ് ഈ പ്രമാണത്തിന്റെ ഉള്ളടക്കങ്ങൾ പഠിക്കാൻ മതിയാകും, സെർവറിനെക്കുറിച്ച് അദ്ദേഹത്തിന് ഇതിനകം തന്നെ അറിയാം.
ഏതൊരു സെർവറും WSDL പ്രസിദ്ധീകരിക്കണം.
WSDL ബ്ലോക്കുകൾ ഉൾക്കൊള്ളുന്നു:
- സേവനത്തിന്റെ നിർവചനം തന്നെ, അതായത്. പ്രവേശന പോയിന്റ്, പോർട്ട് വ്യക്തമാക്കിയിരിക്കുന്നു.
- രീതി ഫോർമാറ്റ്. എൻട്രി പോയിന്റ് പ്രവർത്തനങ്ങളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, അതായത്. ഏത് രീതികളാണ് ഇത് പിന്തുണയ്ക്കുന്നത്. കോളിന്റെ തരം, പ്രക്ഷേപണ രീതി എന്നിവ സൂചിപ്പിക്കുക. ഓരോ രീതിയിലും, ഒരു വിശദീകരണമുണ്ട് - ഏത് രൂപത്തിലാണ് ഡാറ്റ കൈമാറ്റം ചെയ്യപ്പെടുന്നത് - സോപ്പ് രൂപത്തിൽ.
- ഒരു സന്ദേശവുമായി ബന്ധിപ്പിക്കുന്ന രീതികൾ.
- സന്ദേശങ്ങളുടെ വിവരണം തന്നെ.
നിരാകരണം:ഈ വിഷയത്തിൽ ധാരാളം ലേഖനങ്ങൾ എഴുതിയിട്ടുണ്ട്, നിങ്ങൾ തീർച്ചയായും ഊഹിച്ചതുപോലെ, ഇത് മറ്റൊന്നാണ്. ഒരുപക്ഷേ നിങ്ങൾ അതിൽ നിന്ന് പുതിയ എന്തെങ്കിലും പഠിക്കും, എന്നാൽ നിങ്ങൾക്ക് സ്വന്തമായി ഗൂഗിൾ ചെയ്യാൻ കഴിയാത്ത അതീവരഹസ്യമായ ഒന്നും ഇവിടെ വിവരിച്ചിട്ടില്ല. വ്യക്തിപരമായ അനുഭവത്തിൽ നിന്നുള്ള കുറിപ്പുകൾ മാത്രം.
ആമുഖം
ഒരു മൂന്നാം കക്ഷി വെബ് സേവനം ഉള്ളപ്പോൾ മാത്രം ഞങ്ങൾ സാഹചര്യം പരിഗണിക്കും, കൂടാതെ ഡാറ്റ എക്സ്ചേഞ്ച് സ്ഥാപിക്കുക എന്നതാണ് ചുമതല.
സേവനത്തിന്റെ ഘടന ഫയലിൽ വിവരിച്ചിരിക്കുന്നു WSDL(eng. വെബ് സേവനങ്ങളുടെ വിവരണ ഭാഷ)
വെബ് സേവനത്തിലേക്കുള്ള എൻട്രി പോയിന്റ് സ്ഥിതി ചെയ്യുന്ന ഒരു ലിങ്ക് വഴിയാണ് ഫയൽ മിക്കപ്പോഴും ആക്സസ് ചെയ്യപ്പെടുന്നത്. ഒഴിവാക്കലുകൾ ഉള്ളതിനാൽ ഞാൻ "മിക്കപ്പോഴും" എഴുതി. ഉദാഹരണത്തിന്, ഒരു SAP-അധിഷ്ഠിത വെബ് സേവനം ഒരു wsdl പ്രസിദ്ധീകരിക്കില്ല, ആപ്ലിക്കേഷനിൽ നിന്ന് മാത്രമേ അത് വീണ്ടെടുക്കാൻ കഴിയൂ.
അതിനാൽ, ഞങ്ങൾക്ക് വെബ് സേവനം, ലോഗിൻ, പാസ്‌വേഡ് എന്നിവയുടെ ഒരു വിവരണം ഉണ്ട്. നമുക്ക് ബന്ധിപ്പിക്കാം.
// ServiceNamespace URL ന്റെ ക്രമീകരണങ്ങൾ നിർവ്വചിക്കുക = "http://Somesite.ru"; ഉപയോക്തൃനാമം = "ടെസ്റ്റ് യൂസർ"; പാസ്‌വേഡ് = "q1w2e3"; LocationWSDL = "https://Somesite.ru/WebService/Some?wsdl"; ServiceName = "SomeServiceName"; ConnectionPointName = "SomeService_Port"; // ഒരു SSL കണക്ഷൻ സൃഷ്ടിക്കുക = പുതിയ SecureConnectionOpenSSL(); WSDdefinition = പുതിയ WSDdefinition(LocationWSDL,SSL); WSProxy = പുതിയ WSProxy (WSDefinition, ServiceNamespace URL, ServiceName, ConnectionPointName, SSL); WSProxy.User = ഉപയോക്തൃനാമം; WSProxy.Password = പാസ്‌വേഡ്;
മികച്ചത്! ഞങ്ങൾ വെബ് സേവനവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു! സിദ്ധാന്തത്തിൽ, ഇത് ഏത് എക്സ്ചേഞ്ച് ഓപ്ഷന്റെയും അടിസ്ഥാനമാണ്, കാരണം ഇത് സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു ഡാറ്റ ഘടന ഒബ്ജക്റ്റ് wsdl അടിസ്ഥാനമാക്കി, അത്തരമൊരു വസ്തുവിനൊപ്പം പ്രവർത്തിക്കുന്നത് സന്തോഷകരമാണ്.
SoapUI നമുക്ക് നൽകുന്ന XML പരിഗണിക്കുക
ഇനി നമുക്ക് അത് പ്രോഗ്രാമാറ്റിക് ആയി വിവരിക്കാം
// ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിച്ച് അതിൽ ഡാറ്റ പൂരിപ്പിക്കുക OwnXDTOFactory = WSDefinition.XDTOFactory; റൂട്ട് ടൈപ്പ് = സ്വന്തം ഫാക്ടറിXDTO.Type(URLServiceNamespace, "സമർപ്പണം"); RootObject = OwnFactoryXDTO.Create(RootType); RootObject.ID = "4356"; ClientType = OwnFactoryXDTO.Type(URLServiceNamespace, "CUSTOMER"); ClientObject = OwnFactoryXDTO.Create(ClientType); ClientObject.CLIENT_ID = "121212"; ClientObject.SEX = "M"; // എഫ് - സ്ത്രീ, എം - പുരുഷ ക്ലയന്റ് ഒബ്ജക്റ്റ്.CLIENT_BIRTHDAY = "19900111"; // കസ്റ്റമർ കാറുകൾ ഓട്ടോടൈപ്പ് = CustomFactoryXDTO.Type(URLServiceNamespace, "CARS"); AutoObject = OwnFactoryXDTO.Create(AutoType); AutoObject.CLASS = "Mercedes"; 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-നുള്ളിൽ ചില ടാഗുകൾ പ്രിഫിക്‌സ് ചെയ്യുന്നതുമായി പൊരുത്തപ്പെടുന്നില്ല. അത്തരം സന്ദർഭങ്ങളിൽ, നിങ്ങൾ സോപ്പ് സ്വമേധയാ ശേഖരിക്കണം. ശുദ്ധമായ 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; ഫലം = WSProxy.AddCustomers(XML String);
ഡിഫോൾട്ടായി 1s ചേർക്കുന്ന നെയിംസ്പേസ് നിങ്ങൾ നീക്കം ചെയ്യുന്നില്ലെങ്കിൽ, അത് വെറും 5 കോഡുകളേക്കാൾ കൂടുതലായി മാറിയിരിക്കുന്നു. മിക്കപ്പോഴും, ഞങ്ങൾ ഒരു ഫംഗ്ഷനിൽ xml പരിവർത്തനം പൊതിയുന്നു, കാരണം ഞങ്ങൾ സാധാരണയായി ഒന്നിലധികം രീതികൾ വിളിക്കുന്നു.
പാചകരീതി 3. നേറ്റീവ് HTTP അഭ്യർത്ഥന വഴി അയയ്ക്കുക.
സോപ്പ് സ്ട്രിംഗ് = "ഈ ഓപ്ഷനിൽ, ഞങ്ങൾ സ്വമേധയാ സോപ്പ് നിർമ്മിക്കേണ്ടതുണ്ട്. സാരാംശത്തിൽ, ഞങ്ങൾ പാചകക്കുറിപ്പ് 2-ൽ നിന്നുള്ള xml ഒരു സോപ്പ് റാപ്പറിൽ പൊതിയുന്നു, അവിടെ, വെബ് സേവനത്തിന്റെ ആവശ്യകതയെ ആശ്രയിച്ച്, ഞങ്ങളുടെ സോപ്പ് നമ്മുടെ ഹൃദയത്തിന്റെ ഉള്ളടക്കത്തിലേക്ക് മാറ്റാം.
അടുത്തതായി, ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് ഞങ്ങൾ തലക്കെട്ടുകൾ വിവരിക്കുന്നു. ചില സേവനങ്ങൾ തലക്കെട്ടുകളില്ലാതെ ഞങ്ങളുടെ അഭ്യർത്ഥന എളുപ്പത്തിൽ ചവയ്ക്കും, ഇവിടെ നിങ്ങൾ ഒരു പ്രത്യേക കേസ് നോക്കേണ്ടതുണ്ട്. ഏതൊക്കെ തലക്കെട്ടുകളാണ് നിർദ്ദേശിക്കേണ്ടതെന്ന് നിങ്ങൾക്കറിയില്ലെങ്കിൽ, റോ ടാബിലേക്ക് മാറിക്കൊണ്ട് SoapUI-ലെ അഭ്യർത്ഥന നോക്കുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗം.
Base64 സ്ട്രിംഗ് ലഭിക്കുന്നതിനുള്ള ഫംഗ്ഷൻ ഇതുപോലെ കാണപ്പെടുന്നു (പീപ്പ്):
ഫംഗ്ഷൻ GetBase64AuthorizationHeader(Username, Password) FileEncoding = TextEncoding.UTF8; TempFile = GetTemporaryFileName(); റെക്കോർഡ് = പുതിയ ടെക്സ്റ്റ് റൈറ്റ് (താൽക്കാലിക ഫയൽ, ഫയൽ എൻകോഡിംഗ്); എഴുതുക.എഴുതുക(ഉപയോക്തൃനാമം+":"+പാസ്‌വേഡ്); രേഖപ്പെടുത്തുക.അടയ്ക്കുക(); BinData = പുതിയ BinaryData(TempFile); ഫലം = Base64String(DvData); ഫയലുകൾ ഇല്ലാതാക്കുക (ടെംപ്ഫയൽ); ഫലം = ശരാശരി(ഫലം,5); റിട്ടേൺ ഫലം; എൻഡ്ഫംഗ്ഷനുകൾ
ഒരു പ്രധാന പോയിന്റുണ്ട്. HTTPConnection-ൽ പ്രവർത്തിക്കുമ്പോൾ, "http://", "https://" എന്നീ പ്രോട്ടോക്കോളുകൾ വ്യക്തമാക്കാതെ വിലാസം വ്യക്തമാക്കുക, അല്ലാത്തപക്ഷം നിങ്ങൾ ഒരു അവ്യക്തമായ പിശകിനായി സമയം പാഴാക്കും.
പാചകരീതി 4. WinHttpRequest വഴി അയയ്ക്കുന്നു
WinHttp = പുതിയ 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 സ്ട്രിംഗ്); WinHttp.WaitForResponse(15); XMLResponse = WinHttp.ResponseText();ഇവിടെ, യഥാർത്ഥത്തിൽ, മുമ്പത്തെ പതിപ്പിലെ പോലെ തന്നെ, പക്ഷേ ഞങ്ങൾ ഒരു COMObject-മായി പ്രവർത്തിക്കുന്നു. പ്രോട്ടോക്കോൾ സഹിതം ഞങ്ങൾ കണക്ഷൻ സ്ട്രിംഗ് പൂർണ്ണമായി വ്യക്തമാക്കുന്നു. SSL സർട്ടിഫിക്കറ്റുകളിലെ പിശകുകൾ അവഗണിക്കുന്നതിന് ഫ്ലാഗുകളിൽ മാത്രം പ്രത്യേക ശ്രദ്ധ നൽകണം. ഞങ്ങൾ SSL വഴി പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ അവ ആവശ്യമാണ്, എന്നാൽ ഒരു നിർദ്ദിഷ്ട സർട്ടിഫിക്കറ്റ് ഇല്ലാതെ, ഈ ഓപ്ഷനിൽ ഒരു പുതിയ സുരക്ഷിത കണക്ഷൻ സൃഷ്ടിക്കുന്നത് സാധ്യമല്ലാത്തതിനാൽ (അല്ലെങ്കിൽ എങ്ങനെയെന്ന് എനിക്കറിയില്ല). ബാക്കിയുള്ള മെക്കാനിസം മുമ്പത്തേതിന് സമാനമാണ്.
കൂടാതെ, "WinHttp.WinHttpRequest.5.1" കൂടാതെ, നിങ്ങൾക്ക് "Microsoft.XMLHTTP", "Msxml2.XMLHTTP", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP.6 പെട്ടെന്ന് എടുക്കുന്നില്ലെങ്കിൽ" എന്നിവ ഉപയോഗിക്കാം. WinHttp-ൽ ഓഫ്. രീതികൾ ഏതാണ്ട് സമാനമാണ്, പരാമീറ്ററുകളുടെ എണ്ണം മാത്രം വ്യത്യസ്തമാണ്. ഈ ഓപ്ഷനുകളിലൊന്ന് 1c HTTPRequest ഒബ്‌ജക്‌റ്റിനുള്ളിൽ വയർ ചെയ്‌തതാണെന്ന് ഞാൻ സംശയിക്കുന്നു.
ഇപ്പോൾ, ഇവയെല്ലാം എന്റെ പക്കലുള്ള പാചകക്കുറിപ്പുകളാണ്. ഞാൻ പുതിയവയെ കണ്ടാൽ, ഞാൻ തീർച്ചയായും ലേഖനത്തിന് അനുബന്ധമായി നൽകും.
ഫലം പ്രോസസ്സിംഗ്
പാചകക്കുറിപ്പ് 1 ൽ, ഞങ്ങൾ മിക്കപ്പോഴും ഒരു റെഡിമെയ്ഡ് XDTO ഒബ്ജക്റ്റ് നേടുകയും ഒരു ഘടനയായി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. മറ്റെല്ലാ സാഹചര്യങ്ങളിലും, നിങ്ങൾക്ക് xml പ്രതികരണം XDTO ആയി പരിവർത്തനം ചെയ്യാൻ കഴിയും
Result.StatusCode = 200 ആണെങ്കിൽ XMLReader = New XMLReader; ReadingXML.SetString(Result.GetBodyAsString()); ResponseObject = OwnFactoryXDTO.ReadXML(ReadingXML); റിപ്പോർട്ട് (ObjectResponse.Body.Response.RESPONSE_ID); റിപ്പോർട്ട് (ObjectResponse.Body.Response.RESPONSE_TEXT); EndIf;
ഇവിടെ എല്ലാം ലളിതമാണ്.
ഒരു നിഗമനത്തിന് പകരം
1. SoapUI പ്രോഗ്രാം ഉപയോഗിച്ച് വെബ് സേവനങ്ങളുമായി പ്രവർത്തിക്കാൻ ആരംഭിക്കുക. അത്തരം ജോലികൾക്കായി ഇത് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു കൂടാതെ ഒരു പ്രത്യേക സേവനം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് വേഗത്തിൽ മനസ്സിലാക്കാൻ നിങ്ങളെ അനുവദിക്കും. പഠിക്കാൻ ഒരു ലേഖനമുണ്ട്
2. സുരക്ഷിതമല്ലാത്ത ഒരു http ചാനൽ വഴിയാണ് നിങ്ങൾ ഒരു സേവനവുമായി കൈമാറ്റം ചെയ്യുന്നതെങ്കിൽ, നിങ്ങളുടെ സന്ദേശങ്ങളിൽ കൃത്യമായി 1s എന്താണ് അയയ്ക്കുന്നത് എന്ന ചോദ്യം ഉയർന്നുവരുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് Wireshark, Fiddler, തുടങ്ങിയ ട്രാഫിക് സ്‌നിഫറുകൾ ഉപയോഗിക്കാം. നിങ്ങൾ ഒരു ssl കണക്ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ മാത്രമേ പ്രശ്നം ഉണ്ടാകൂ.
3. എന്നിരുന്നാലും, വെബ് സേവനം https വഴി ആശയവിനിമയം നടത്തുകയാണെങ്കിൽ, ഞങ്ങൾ ഒരു റിമോട്ട് മെഷീനിൽ Nginx സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുന്നു (ഏതെങ്കിലും, ഏറ്റവും പ്രധാനമായി, സ്വന്തമായി അല്ല), അത് ഞങ്ങൾ ബന്ധപ്പെടും, കൂടാതെ അത് എല്ലാം പാക്ക് ചെയ്യും https അത് ശരിയായ സ്ഥലത്തേക്ക് അയയ്ക്കുക (റിവേഴ്സ് പ്രോക്സി ) കൂടാതെ സ്റ്റാൻഡേർഡ് കോൺഫിഗറിലേക്ക് ചേർക്കുക:
സെർവർ (ശ്രവിക്കുക 0.0.0.0:8080; server_name MyServer; ലൊക്കേഷൻ ~ .* ( proxy_pass https://Somesite.ru:8001; proxy_set_header Host $host; proxy_set_header ഓതറൈസേഷൻ "അടിസ്ഥാനം
5. പ്രാമാണീകരണത്തിൽ കുക്കികളുടെ ഉപയോഗം ഉൾപ്പെടുന്നുവെങ്കിൽ, ഇനിപ്പറയുന്നവ കണ്ടെത്തി
പി.എസ്. നിങ്ങൾക്ക് ചോദ്യങ്ങളുണ്ടെങ്കിൽ, കോഡ് മെച്ചപ്പെടുത്തുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ, വിവരിച്ചതിൽ നിന്ന് വ്യത്യസ്തമായ നിങ്ങളുടെ സ്വന്തം പാചകക്കുറിപ്പുകൾ ഉണ്ടെങ്കിൽ, നിങ്ങൾ പിശകുകൾ കണ്ടെത്തുന്നു അല്ലെങ്കിൽ രചയിതാവ് "തെറ്റ്" ആണെന്നും അദ്ദേഹം "1 സെഷനിൽ ഉൾപ്പെടുന്നില്ല" എന്നും കരുതുന്നുവെങ്കിൽ, അഭിപ്രായങ്ങൾ എഴുതുക, ഞങ്ങൾ ചർച്ച ചെയ്യും എല്ലാം.