നിങ്ങളുടെ സോഫ്റ്റ്വെയർ ഇതിനകം തന്നെ നിലവിലുണ്ട്, പക്ഷേ പ്ലാറ്റ്ഫോം വിപുലീകരിക്കുന്നതിന് നിങ്ങളുടെ സാങ്കേതിക ഉപയോക്താക്കളെ പ്രാപ്തമാക്കുന്നതിന് നിങ്ങൾക്ക് കൂടുതൽ ഫലപ്രദമായ ഒരു രീതി ആവശ്യമാണ്.
OSGi മിക്ക ജാവ ഡെവലപ്പർമാർക്കും സുപരിചിതമാണെങ്കിലും, നിങ്ങളുടെ ഉൽപ്പന്നത്തിലേക്ക് ഇത് സംയോജിപ്പിക്കുന്നത് ഒരു ബുദ്ധിമുട്ടുള്ള കാര്യമായി തോന്നിയേക്കാം. OSGi-യുടെ കൃത്യമായ പ്രവർത്തനങ്ങളെക്കുറിച്ചുള്ള വ്യക്തതയില്ലാത്തത് മുന്നോട്ടുള്ള പാതയെ കൂടുതൽ കുഴപ്പത്തിലാക്കുന്നു.
അവർ പരീക്ഷിക്കാൻ ആഗ്രഹിക്കുന്ന എന്തിനും വിരുദ്ധമായി, OSGi യ്ക്ക് വിശാലമായ കടലിലൂടെ നിരവധി ജാവ ഡെവലപ്പർമാരുടെ അടുത്തേക്ക് പോകാൻ ശ്രമിക്കുന്നതായി തോന്നുന്നു.
ഈ ലേഖനം നിങ്ങളെ OSGi ഫെലിക്സ് സ്പ്രിംഗ് ട്യൂട്ടോറിയലിലേക്ക് ഒരു നേരായ പ്രോഗ്രാം ഉപയോഗിച്ച് പരിചയപ്പെടുത്തുകയും അതിന്റെ ഗുണങ്ങളും മറ്റ് പ്രധാന വിശദാംശങ്ങളിലൂടെയും കടന്നുപോകുകയും ചെയ്യും.
അപ്പോൾ എന്താണ് OSGi?
മൊഡ്യൂളുകളും ഘടകങ്ങളും സൃഷ്ടിക്കുന്നതും വിതരണം ചെയ്യുന്നതും OSGi (ഓപ്പൺ സർവീസ് ഗേറ്റ്വേ ഇനിഷ്യേറ്റീവ്) എന്നറിയപ്പെടുന്ന ജാവ ചട്ടക്കൂട് വഴി സാധ്യമാക്കുന്നു.
ഇത് ഫംഗ്ഷൻ എൻക്യാപ്സുലേഷനും ലൂസ് കപ്ലിംഗും ഊന്നിപ്പറയുന്നു, ഇത് ഡെവലപ്പർമാർക്ക് നിരവധി നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, സോഴ്സ് കോഡുകൾക്കിടയിൽ എളുപ്പത്തിൽ കൈമാറ്റം ചെയ്യാവുന്ന മോഡുലാർ ഫംഗ്ഷണാലിറ്റിയും അവസാനിക്കാത്ത ഡിപൻഡൻസികൾ ആവശ്യമില്ലാത്ത ടെസ്റ്റിംഗും ഉൾപ്പെടെ.
OSGi എങ്ങനെയാണ് പ്രവർത്തിക്കുന്നത്?
OSGi എന്ന് വിളിക്കപ്പെടുന്ന ഒരു കൂട്ടം സ്പെസിഫിക്കേഷനുകൾ ഉപയോഗിച്ചാണ് ജാവയ്ക്കുള്ള ഒരു ഡൈനാമിക് ഘടക സംവിധാനം നിർവചിച്ചിരിക്കുന്നത്. ഈ സ്പെസിഫിക്കേഷനുകൾ ഒരു വികസന സമീപനം പ്രാപ്തമാക്കുന്നു, അവിടെ ഒരു ആപ്ലിക്കേഷൻ നിരവധി ഭാഗങ്ങളിൽ നിന്ന് നിർമ്മിക്കുകയും ബണ്ടിലുകളായി പാക്കേജുചെയ്യുകയും ചെയ്യുന്നു.
ആശയവിനിമയത്തിനായി ഈ ഘടകങ്ങൾ പ്രാദേശികവും നെറ്റ്വർക്ക് അധിഷ്ഠിതവുമായ സേവനങ്ങൾ ഉപയോഗിക്കുന്നു. പ്രോഗ്രാമിന്റെ കോർ കോഡ് സാധ്യമായത്ര ഒതുക്കമുള്ളതാക്കുക എന്നതാണ് ലക്ഷ്യം. ഈ കോഡും നിരവധി ഘടകങ്ങളും തമ്മിൽ ഹൈ കപ്ലിംഗ് സാധ്യമാണ്.
ആപ്ലിക്കേഷന്റെ പുനരുപയോഗിക്കാവുന്ന കെട്ടിട ഘടകങ്ങളെ ഘടകങ്ങൾ എന്ന് വിളിക്കുന്നു. നിങ്ങളുടെ ഇ-കൊമേഴ്സ് വെബ്സൈറ്റിനുള്ള ഷോപ്പിംഗ് കാർട്ട് അല്ലെങ്കിൽ നിങ്ങളുടെ സ്റ്റാഫ് മാനേജ്മെന്റ് സിസ്റ്റത്തിനുള്ള പേറോൾ ആപ്ലിക്കേഷൻ പോലുള്ള ഫീച്ചറുകളെ കുറിച്ച് ചിന്തിക്കുക.
മറ്റ് ഘടകങ്ങളിൽ നിന്ന് അവയുടെ നിർവ്വഹണങ്ങൾ മറയ്ക്കാനും അവയ്ക്ക് ആവശ്യമായ ഡാറ്റ സേവനങ്ങൾ വഴി മാത്രം നൽകാനും ഘടകങ്ങൾക്ക് OSGi ഉപയോഗിക്കാനാകും.
ഘടകാംശങ്ങൾക്ക് ആക്സസ് ഉണ്ടാകാൻ പാടില്ലാത്ത ഡാറ്റ അവിചാരിതമായി മാറ്റുന്നതിൽ നിന്ന് ഇത് തടയുകയും ഡിപൻഡൻസികൾ നിയന്ത്രിക്കുകയും ചെയ്യുന്നു.
ഒരു OSGi ആപ്ലിക്കേഷനിലെ ഘടകങ്ങൾ തമ്മിലുള്ള എല്ലാ കണക്ഷനുകളും ഒരു അനുയോജ്യമായ ലോകത്തിലെ സേവനങ്ങളിലൂടെയാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ഒരു ജാവ പാക്കേജിൽ സേവനങ്ങൾക്കായി വ്യക്തമാക്കിയ API അടങ്ങിയിരിക്കുന്നു.
സേവന ദാതാക്കളും ഉപഭോക്താക്കളും തമ്മിലുള്ള സഹകരണത്തിന് API നിർമ്മിക്കുന്ന ക്ലാസുകളുടെയും/അല്ലെങ്കിൽ ഇന്റർഫേസുകളുടെയും ഉപയോഗം ആവശ്യമാണ്.
എല്ലാ OSGi ഘടകങ്ങളും ഒരുമിച്ച് ബണ്ടിലുകളായി പാക്കേജുചെയ്തിരിക്കുന്നു, അവയിൽ ഓരോന്നിനും പ്രവർത്തിക്കാൻ ആവശ്യമായ ഉറവിടങ്ങൾ ഉൾപ്പെടുന്നു. പരിസ്ഥിതിയിൽ നിന്ന് അവർക്ക് എന്താണ് വേണ്ടതെന്നും അവയ്ക്ക് എന്ത് കഴിവുണ്ട് എന്നതിനെക്കുറിച്ചും ബണ്ടിലുകൾ വളരെ വ്യക്തമാണ്.
ആനുകൂല്യങ്ങൾ
- OSGi ആപ്ലിക്കേഷനുകൾക്ക് ബാഹ്യ ബണ്ടിൽ റിപ്പോസിറ്ററികളിലേക്ക് ആക്സസ് ഉണ്ട്.
- ചട്ടക്കൂട് മൊഡ്യൂൾ തലത്തിൽ സേവന-അധിഷ്ഠിത രൂപകൽപ്പന അനുവദിക്കുന്നു.
- മൂന്നാം കക്ഷി ലൈബ്രറികൾ സ്റ്റാൻഡേർഡൈസ് ചെയ്യുന്നതിനും സംയോജിപ്പിക്കുന്നത് എളുപ്പമാക്കുന്നതിനും പുറമെ ആപ്ലിക്കേഷൻ ബണ്ടിലുകളുടെ പതിപ്പുകളും ഡിപൻഡൻസികളും നിയന്ത്രിക്കുന്നത് ഇത് സാധ്യമാക്കുന്നു.
- ആപ്ലിക്കേഷനുകൾ മാറുന്ന ഡിമാൻഡുകൾക്ക് കൂടുതൽ അനുയോജ്യവും കൂടുതൽ പോർട്ടബിൾ ആയതും പുനർനിർമ്മാണത്തിന് വേഗമേറിയതുമാണ്.
- A വെബ് അപ്ലിക്കേഷൻ Java EE പ്രോഗ്രാമിംഗ് മോഡലുമായുള്ള ചട്ടക്കൂടിന്റെ സംയോജനത്തിന് നന്ദി, ചലനാത്മകമായ ആയുഷ്കാലത്തോടെയുള്ള പതിപ്പ് OSGi ബണ്ടിലുകളുടെ ഒരു ഗ്രൂപ്പായി വിന്യസിക്കാൻ കഴിയും.
- ആപ്ലിക്കേഷന്റെ ഭാഗമായി ഒരു മൂന്നാം കക്ഷി ലൈബ്രറിയായി ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുപകരം, ആപ്ലിക്കേഷൻ സെർവർ റൺടൈമിന്റെ ഭാഗമായി നൽകിയിട്ടുള്ള സ്റ്റാൻഡേർഡ് രൂപത്തിൽ സ്പ്രിംഗ് ഫ്രെയിംവർക്കിന്റെ ഡിക്ലറേറ്റീവ് അസംബ്ലിയും സ്ട്രീംലൈൻഡ് യൂണിറ്റ് ടെസ്റ്റിംഗും ഫ്രെയിംവർക്ക് നൽകുന്നു.
- ഡൈനാമിക് ലൈഫ് സൈക്കിളുകളുള്ള നിരവധി പതിപ്പ് ബണ്ടിലുകൾ കൊണ്ട് നിർമ്മിച്ച കോർപ്പറേറ്റ് ആപ്ലിക്കേഷനുകൾക്ക്, ചട്ടക്കൂട് ഒറ്റപ്പെടൽ വാഗ്ദാനം ചെയ്യുന്നു.
- നിരവധി ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്ന പൊതുവായതും പതിപ്പിച്ചതുമായ ബണ്ടിലുകൾ സംഭരിക്കാൻ കഴിയുന്ന ഒരു സംയോജിത ബണ്ടിൽ ശേഖരം ഇതിൽ അടങ്ങിയിരിക്കുന്നു, ഇത് ഓരോ ആപ്ലിക്കേഷനെയും പങ്കിട്ട ഓരോ ലൈബ്രറിയുടെയും പ്രത്യേക പകർപ്പ് വിന്യസിക്കുന്നതിൽ നിന്ന് തടയുന്നു.
OSGi ഫെലിക്സ് സ്പ്രിംഗ് ഉപയോഗിച്ച് ആരംഭിക്കുന്നു
വിഭവങ്ങൾ നേടുന്നു
അപ്പാച്ചെ കരാഫിന്റെ ഏറ്റവും പുതിയ പതിപ്പ് ഡൗൺലോഡ് ചെയ്യുന്നതിലൂടെ ഈ സൈറ്റ്, നമുക്ക് ഞങ്ങളുടെ OSGi സാഹസികത ആരംഭിക്കാം.
OSGi സ്പെസിഫിക്കേഷന്റെ അപ്പാച്ചെ നടപ്പിലാക്കുന്ന അപ്പാച്ചെ ഫെലിക്സിനെ അടിസ്ഥാനമാക്കി, അപ്പാച്ചെ കരാഫ് OSGi അടിസ്ഥാനമാക്കിയുള്ള ആപ്ലിക്കേഷനുകൾക്കായി ഒരു പ്ലാറ്റ്ഫോം നൽകുന്നു.
പ്ലാറ്റ്ഫോമുമായി ആശയവിനിമയം നടത്താൻ ഞങ്ങളെ പ്രാപ്തമാക്കുന്ന ഒരു കമാൻഡ് ലൈൻ ഇന്റർഫേസ് പോലുള്ള, OSGi-യുമായി സ്വയം പരിചയപ്പെടാൻ ഞങ്ങളെ സഹായിക്കുന്ന വിവിധ സഹായകരമായ സവിശേഷതകൾ കരാഫ് ഫെലിക്സിന് മുകളിൽ നൽകുന്നു.
ബണ്ടിലുകൾക്കുള്ള എൻട്രി പോയിന്റ്
ഒരു OSGi പരിതസ്ഥിതിയിൽ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് ഒരു ആപ്ലിക്കേഷൻ OSGi ബണ്ടിൽ ആയി പാക്കേജ് ചെയ്തിരിക്കണം. കൂടാതെ, ആപ്ലിക്കേഷൻ എൻട്രി പോയിന്റ് വ്യക്തമാക്കണം; ഇത് സാധാരണ പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ (സ്ട്രിംഗ്[] ആർഗ്സ്) ഫംഗ്ഷനല്ല.
അതിനാൽ നമുക്ക് ഒരു "" സൃഷ്ടിച്ചുകൊണ്ട് ആരംഭിക്കാംഹലോ വേൾഡ്OSGi അടിസ്ഥാനമാക്കിയുള്ള ആപ്ലിക്കേഷൻ.
ഒരു അടിസ്ഥാന OSGi API ഡിപൻഡൻസി സ്ഥാപിച്ചുകൊണ്ട് ഞങ്ങൾ ആരംഭിക്കുന്നു:
OSGi റൺടൈമിന് ഡിപൻഡൻസിയിലേക്ക് ആക്സസ് ഉണ്ടായിരിക്കും, അതിനാൽ ബണ്ടിൽ അത് ഉൾക്കൊള്ളേണ്ടതില്ല. അതിനാൽ, ഇത് വിതരണം ചെയ്തതായി അടയാളപ്പെടുത്തിയിരിക്കുന്നു.
ഇനി നമുക്ക് നേരായ HelloWorld ക്ലാസ് സൃഷ്ടിക്കാം:
ബണ്ടിലുകൾക്കുള്ള എൻട്രി പോയിന്റുകളായി പ്രവർത്തിക്കുന്ന ക്ലാസുകൾ OSGi നൽകുന്ന BundleActivator ഇന്റർഫേസ് നടപ്പിലാക്കണം.
ഈ ക്ലാസ് അടങ്ങുന്ന ബണ്ടിൽ സമാരംഭിക്കുമ്പോൾ, OSGi പ്ലാറ്റ്ഫോം സ്റ്റാർട്ട്() ഫംഗ്ഷനെ വിളിക്കുന്നു. മറുവശത്ത്, ബണ്ടിൽ നിർത്തുന്നതിന് തൊട്ടുമുമ്പ്, സ്റ്റോപ്പ് () എന്ന ഫംഗ്ഷൻ വിളിക്കുന്നു.
ഓരോ ബണ്ടിലിനും ഒരു ബണ്ടിൽ ആക്റ്റിവേറ്റർ മാത്രമേ ഉണ്ടാകൂ എന്ന കാര്യം മറക്കരുത്. നൽകിയിരിക്കുന്ന BundleContext ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് രണ്ട് വഴികൾക്കും OSGi റൺടൈമുമായി ആശയവിനിമയം നടത്താനാകും.
ഒരു ബണ്ടിൽ സൃഷ്ടിക്കുന്നു
ആവശ്യമായ മാറ്റങ്ങൾ വരുത്തിക്കൊണ്ട് pom.xml ഒരു യഥാർത്ഥ OSGi ബണ്ടിൽ ആക്കുക.
ഒരു ബണ്ടിൽ ഉൽപ്പാദിപ്പിക്കുക എന്നതാണ് ഞങ്ങളുടെ ലക്ഷ്യം എന്ന് നമ്മൾ ആദ്യം വ്യക്തമായി പ്രകടിപ്പിക്കണം.
തുടർന്ന്, അപ്പാച്ചെ ഫെലിക്സ് കമ്മ്യൂണിറ്റിയുടെ കടപ്പാടോടെ, HelloWorld ക്ലാസ് ഒരു OSGi ബണ്ടിലായി പാക്കേജ് ചെയ്യാൻ ഞങ്ങൾ maven-bundle-plugin ഉപയോഗിക്കുന്നു:
ബണ്ടിലിന്റെ MANIFEST ഫയലിൽ ഉൾപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്ന OSGi തലക്കെട്ടുകളുടെ മൂല്യങ്ങൾ നിർദ്ദേശ വിഭാഗത്തിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്.
ബണ്ടിൽ-ആക്റ്റിവേറ്റർ എന്നത് ബണ്ടിൽ ആക്റ്റിവേറ്റർ സൊല്യൂഷന്റെ ശരിയായ യോഗ്യതയുള്ള പേരാണ്, അത് ബണ്ടിൽ ആരംഭിക്കുന്നതിനും നിർത്തുന്നതിനും ഉപയോഗിക്കും. ഇത് ഇപ്പോൾ സൃഷ്ടിച്ച ക്ലാസുമായി പൊരുത്തപ്പെടുന്നു.
ഇതൊരു OSGi ഹെഡർ അല്ലെങ്കിലും, സ്വകാര്യ-പാക്കേജ് തലക്കെട്ട്, പാക്കേജ് ബണ്ടിലിലേക്ക് ചേർക്കാൻ പ്ലഗിനിനോട് നിർദ്ദേശിക്കുന്നു, എന്നാൽ മറ്റ് പ്ലഗിനുകൾക്ക് അത് ആക്സസ് ചെയ്യാൻ കഴിയുന്നതല്ല. ബണ്ടിൽ സൃഷ്ടിക്കാൻ mvn ഇൻസ്റ്റാൾ കമാൻഡ് ഉപയോഗിക്കണം.
ബണ്ടിൽ ഇൻസ്റ്റാൾ ചെയ്യുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു
ഈ കമാൻഡ് പ്രവർത്തിപ്പിച്ച് നമുക്ക് കരാഫ് ആരംഭിക്കാം:
ഇവിടെ "KARAF HOME" എന്നത് കരാഫ് സജ്ജീകരിച്ചിരിക്കുന്ന ഫോൾഡറിനെ സൂചിപ്പിക്കുന്നു. കരാഫ് കൺസോൾ പ്രോംപ്റ്റ് ദൃശ്യമാകുമ്പോൾ ബണ്ടിൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ നമുക്ക് ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കാം:
പ്രാദേശിക മാവെൻ ശേഖരം ഉപയോഗിക്കുന്നത് എങ്ങനെയാണ് കരാഫിനോട് ബണ്ടിൽ ലോഡ് ചെയ്യാൻ പറയുന്നത്.
ബണ്ടിലിന്റെ സംഖ്യാ ഐഡി തിരികെ നൽകി, കരാഫ് അത് എഴുതുന്നു. മുമ്പ് എത്ര ബണ്ടിലുകൾ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട് എന്നതിനെ ആശ്രയിച്ച് ഈ ഐഡി വ്യത്യാസപ്പെടാം. ബണ്ടിൽ ഇപ്പോൾ വിജയകരമായി ഇൻസ്റ്റാൾ ചെയ്തു, അത് സമാരംഭിക്കാനുള്ള കമാൻഡ് ഇപ്രകാരമാണ്:
നിങ്ങൾ പാക്കേജ് സമാരംഭിക്കുമ്പോൾ, "ഹലോ വേൾഡ് ബൈ ജയ്" പ്രദർശിപ്പിക്കുന്നു. നമുക്ക് ഇപ്പോൾ ഇത് ഉപയോഗിച്ച് ബണ്ടിൽ നിർത്താനും നീക്കംചെയ്യാനും കഴിയും:
കൺസോൾ "ഗുഡ്ബൈ വേൾഡ് ബൈ ജെയ്" എന്ന് പ്രദർശിപ്പിക്കുന്നു.
തീരുമാനം
OSGi ഉപയോഗിച്ച് പ്രധാന പ്രോഗ്രാമിന്റെ മറ്റ് ഘടകങ്ങളിൽ നിന്ന് സുരക്ഷിതവും ഒറ്റപ്പെട്ടതുമായ ഒരു വെബ് ആപ്ലിക്കേഷനിലേക്ക് ഡവലപ്പർമാർക്ക് എളുപ്പത്തിൽ പുതിയ പ്രവർത്തനം ചേർക്കാൻ കഴിയും.
ഈ പോസ്റ്റിൽ OSGi-യെ കുറിച്ച് ഞങ്ങൾ പഠിച്ചു, അത് എങ്ങനെ പ്രവർത്തിക്കുന്നു, അതിന്റെ ഗുണങ്ങൾ, ഒരു നേരായ പ്രോഗ്രാം എന്നിവ ഉൾപ്പെടുന്നു. നിങ്ങളുടെ സ്വന്തം ആപ്ലിക്കേഷനിൽ OSGi സംയോജിപ്പിക്കുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല.
സന്തോഷകരമായ കോഡിംഗ്!
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക