എന്തുകൊണ്ട് ജാവ പഠിക്കണം, അത് എങ്ങനെ ഫലപ്രദമായി ചെയ്യാം. Yandex റിപ്പോർട്ട്

ജാവ മറ്റ് ജനപ്രിയ ഭാഷകളിൽ നിന്ന് എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു? എന്തുകൊണ്ടാണ് ജാവ ആദ്യമായി പഠിക്കേണ്ട ഭാഷ? ആദ്യം മുതൽ ജാവ പഠിക്കാനും മറ്റ് ഭാഷകളിൽ പ്രോഗ്രാമിംഗ് കഴിവുകൾ പ്രയോഗിക്കാനും സഹായിക്കുന്ന ഒരു പ്ലാൻ നമുക്ക് സൃഷ്ടിക്കാം. ജാവയിൽ പ്രൊഡക്ഷൻ കോഡ് സൃഷ്ടിക്കുന്നതും മറ്റ് ഭാഷകളിൽ വികസിപ്പിക്കുന്നതും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ പട്ടികപ്പെടുത്താം. ഭാവിയിൽ പങ്കെടുക്കുന്നവർക്കായി ഒരു മീറ്റിംഗിൽ മിഖായേൽ സറ്റെപ്യാക്കിൻ ഈ റിപ്പോർട്ട് വായിച്ചു ഇന്റേൺഷിപ്പുകൾ Yandex ഉം മറ്റ് തുടക്ക ഡെവലപ്പർമാരും - Java Junior meetup.

- എല്ലാവർക്കും ഹലോ, എന്റെ പേര് മിഷ. ഞാൻ Yandex.Market-ൽ നിന്നുള്ള ഒരു ഡവലപ്പറാണ്, എന്തുകൊണ്ടാണ് ജാവ പഠിക്കേണ്ടതെന്നും അത് എങ്ങനെ ഫലപ്രദമായി ചെയ്യാമെന്നും ഇന്ന് ഞാൻ നിങ്ങളോട് പറയും. നിങ്ങൾക്ക് ന്യായമായ ഒരു ചോദ്യം ചോദിച്ചേക്കാം: ഞാൻ എന്തിനാണ് ഈ കഥ പറയുന്നത്, അല്ലാതെ വർഷങ്ങളോളം പരിചയമുള്ള ശക്തരായ ഡെവലപ്പർമാരല്ലേ? ഏകദേശം ഒന്നര വർഷം മുമ്പ് ഞാൻ ഈയിടെ ജാവ പഠിച്ചു എന്നതാണ് വസ്തുത, അതിനാൽ അത് എങ്ങനെയാണെന്നും എന്തൊക്കെ അപകടങ്ങളുണ്ടെന്നും ഞാൻ ഇപ്പോഴും ഓർക്കുന്നു.

ഒരു വർഷം മുമ്പ് എനിക്ക് Yandex.Market-ൽ ഇന്റേൺഷിപ്പ് ലഭിച്ചു. ഞാൻ ബെറുവിന്റെ ബാക്കെൻഡ് വികസിപ്പിച്ചെടുത്തു, മാർക്കറ്റിനായി തന്നെ, നിങ്ങൾ അത് ഉപയോഗിച്ചിരിക്കാം. ഇപ്പോൾ ഞാൻ അവിടെ ജോലി തുടരുന്നു, മറ്റൊരു ടീമിൽ. ബിസിനസ്സ് പങ്കാളികൾക്കായി Yandex.Market-നായി ഞങ്ങൾ ഒരു വിശകലന പ്ലാറ്റ്ഫോം സൃഷ്ടിക്കുന്നു.

നമുക്ക് തുടങ്ങാം. പ്രായോഗിക വീക്ഷണകോണിൽ നിന്ന് ജാവ പഠിക്കുന്നത് എന്തുകൊണ്ട്? ജാവ വളരെ പ്രശസ്തമായ ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയാണ് എന്നതാണ് വസ്തുത. ഇതിന് വളരെ വലിയ ഒരു സമൂഹമുണ്ട്.

ഉദാഹരണത്തിന്, പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ജനപ്രീതിയുടെ ജനപ്രിയ സൂചികയായ അത്തരമൊരു TIOBE സൂചികയുണ്ട്, ജാവ അവിടെ ഒന്നാം സ്ഥാനത്താണ്. കൂടാതെ, തൊഴിൽ സൈറ്റുകളിൽ, മിക്ക ഒഴിവുകളും ജാവയെ കുറിച്ചുള്ളതാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചേക്കാം, അതായത്, ജാവയിൽ വികസിപ്പിക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഒരു ജോലി കണ്ടെത്താനാകും.

കമ്മ്യൂണിറ്റി വളരെ വലുതായതിനാൽ, നിങ്ങളുടെ ഏത് ചോദ്യത്തിനും ചില സ്റ്റാക്ക് ഓവർഫ്ലോയിലോ മറ്റ് സൈറ്റുകളിലോ ഉത്തരം കണ്ടെത്തും. കൂടാതെ, ജാവയിൽ വികസിപ്പിക്കുമ്പോൾ, നിങ്ങൾ യഥാർത്ഥത്തിൽ JVM-ൽ കോഡ് എഴുതുകയാണ്, അതിനാൽ നിങ്ങൾക്ക് JVM ഉപയോഗിക്കുന്ന കോട്ലിൻ, സ്കാല, മറ്റ് ഭാഷകൾ എന്നിവയിലേക്ക് എളുപ്പത്തിൽ മാറാനാകും.

പ്രത്യയശാസ്ത്രപരമായ വീക്ഷണകോണിൽ നിന്ന് ജാവയിൽ എന്താണ് നല്ലത്? വ്യത്യസ്ത പ്രോഗ്രാമിംഗ് ഭാഷകളുണ്ട്. അവർ വ്യത്യസ്ത പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു, നിങ്ങൾക്കറിയാം. ഉദാഹരണത്തിന്, പെട്ടെന്നുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് ഒറ്റവരി സ്ക്രിപ്റ്റുകൾ എഴുതുന്നതിന് പൈത്തൺ മികച്ചതാണ്.

പ്ലസ് സൈഡിൽ, നിങ്ങൾക്ക് എക്സിക്യൂട്ടബിൾ കോഡ് പൂർണ്ണമായി നിയന്ത്രിക്കാനാകും. ഉദാഹരണത്തിന്, ഞങ്ങൾക്ക് കാറുകൾ ഉണ്ട്, Yandex ഡ്രൈവർലെസ്സ് കാറുകൾ, അവരുടെ കോഡ് പ്ലസ്സിൽ എഴുതിയിരിക്കുന്നു. എന്തുകൊണ്ട്? ജാവയ്ക്ക് അത്തരമൊരു കാര്യമുണ്ട് - ഗാർബേജ് കളക്ടർ. ഇത് അനാവശ്യ വസ്തുക്കളുടെ റാം മായ്‌ക്കുന്നു. ഈ കാര്യം സ്വയമേവ ആരംഭിക്കുകയും ലോകത്തെ തടയുകയും ചെയ്യുന്നു, അതായത്, ഇത് പ്രോഗ്രാമിന്റെ ബാക്കി ഭാഗങ്ങൾ നിർത്തി ഒബ്‌ജക്റ്റുകളെ എണ്ണാൻ പോകുന്നു, ഒബ്‌ജക്റ്റുകളുടെ മെമ്മറി ക്ലിയർ ചെയ്യുന്നു. ഡ്രോണിൽ ഇത്തരമൊരു സംഗതി പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ അത് തണുപ്പല്ല. നിങ്ങളുടെ ഡ്രോൺ നേരെ ഓടും, ഈ നിമിഷം അതിന്റെ മെമ്മറി മായ്‌ക്കുക, റോഡിലേക്ക് നോക്കുകയേ വേണ്ട. അതിനാൽ, ഡ്രോൺ പ്രോസിൽ എഴുതിയിരിക്കുന്നു.

ജാവ എന്ത് പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു? വർഷങ്ങളായി ഡസൻ കണക്കിന് അല്ലെങ്കിൽ നൂറുകണക്കിന് ആളുകൾ എഴുതിയ വലിയ പ്രോഗ്രാമുകൾ വികസിപ്പിക്കുന്നതിനുള്ള ഒരു ഭാഷയാണിത്. പ്രത്യേകിച്ച്, Yandex.Market-ൽ ധാരാളം ബാക്കെൻഡ് ജാവയിൽ എഴുതിയിരിക്കുന്നു. ഞങ്ങൾക്ക് നിരവധി നഗരങ്ങളിൽ വിതരണം ചെയ്ത ഒരു ടീം ഉണ്ട്, ഓരോന്നിലും പത്ത് പേർ. കൂടാതെ കോഡ് പരിപാലിക്കാൻ എളുപ്പമാണ്, ഇത് പത്ത് വർഷമോ അതിൽ കൂടുതലോ പിന്തുണയ്ക്കുന്നു, അതേ സമയം പുതിയ ആളുകൾ വന്ന് ഈ കോഡ് മനസ്സിലാക്കുന്നു.

ഒരു ഭാഷയ്ക്ക് എന്ത് സ്വഭാവസവിശേഷതകൾ ഉണ്ടായിരിക്കണം, അതിലൂടെ അതിലെ കോഡ് എളുപ്പത്തിൽ പിന്തുണയ്ക്കുകയും അത് വലിയ ടീമുകളിൽ എളുപ്പത്തിൽ വികസിപ്പിക്കുകയും ചെയ്യും. ഒന്നാമതായി, ഇത് വായിക്കാവുന്ന കോഡ് ആയിരിക്കണം, കൂടാതെ സങ്കീർണ്ണമായ വാസ്തുവിദ്യാ പരിഹാരങ്ങൾ നടപ്പിലാക്കുന്നത് എളുപ്പമായിരിക്കണം. അതായത്, ഹൈ-ലെവൽ അബ്‌സ്ട്രാക്ഷനുകൾ എഴുതുന്നത് എളുപ്പമായിരിക്കണം, ഇതൊക്കെയാണ് ജാവ നമുക്ക് നൽകുന്നത്. ഇതൊരു ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ഭാഷയാണ്. ഉയർന്ന തലത്തിലുള്ള സംഗ്രഹങ്ങളും സങ്കീർണ്ണമായ വാസ്തുവിദ്യകളും നടപ്പിലാക്കുന്നത് വളരെ എളുപ്പമാണ്.

ജാവയ്‌ക്കായി ധാരാളം ചട്ടക്കൂടുകളും ലൈബ്രറികളും ഉണ്ട്, കാരണം ഭാഷയ്ക്ക് 15 വർഷത്തിലേറെ പഴക്കമുണ്ട്. ഈ സമയത്ത്, എഴുതാൻ കഴിയുന്നതെല്ലാം അതിൽ എഴുതിയിരുന്നു, അതിനാൽ നിങ്ങൾക്ക് ആവശ്യമുള്ള എല്ലാത്തിനും ടൺ കണക്കിന് ലൈബ്രറികൾ ഉണ്ട്.

എന്റെ അഭിപ്രായത്തിൽ, ഒരു തുടക്ക JA കളിക്കാരന് എന്ത് അടിസ്ഥാന കഴിവുകൾ ഉണ്ടായിരിക്കണം? ഒന്നാമതായി, ഇത് ജാവ കോർ ഭാഷയെക്കുറിച്ചുള്ള അറിവാണ്. അടുത്തത് ഒരുതരം ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ചട്ടക്കൂടാണ്. അടുത്ത സ്പീക്കർ കിറിൽ ഇതിനെക്കുറിച്ച് കൂടുതൽ വിശദമായി സംസാരിക്കും. ഞാൻ അധികം ആഴത്തിൽ പോകില്ല. അടുത്തത് വാസ്തുവിദ്യയും ഡിസൈൻ പാറ്റേണുകളും ആണ്. വലിയ ആപ്ലിക്കേഷനുകൾ എഴുതുന്നതിന് വാസ്തുവിദ്യാപരമായി മനോഹരമായ കോഡ് എഴുതാൻ നമുക്ക് കഴിയണം. ഡാറ്റാബേസുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഒരുതരം SQL അല്ലെങ്കിൽ ORM ആണ് ഇത്. ബാക്കെൻഡിന് ഇത് കൂടുതൽ ബാധകമാണ്.

പോകൂ! ജാവ കോർ. ഞാൻ ശരിക്കും അമേരിക്കയെ ഇവിടെ കണ്ടെത്തുകയില്ല-നിങ്ങൾക്ക് ഭാഷ തന്നെ അറിയേണ്ടതുണ്ട്. നിങ്ങൾ ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങൾ. ഒന്നാമതായി, ജാവ സമീപ വർഷങ്ങളിൽ ധാരാളം പതിപ്പുകൾ പുറത്തിറക്കി, അതായത്, 2014-2015 ൽ ഏഴാമത്തേത് പുറത്തിറങ്ങി, തുടർന്ന് എട്ടാം, ഒമ്പത്, പത്താം, ധാരാളം പുതിയ പതിപ്പുകൾ, കൂടാതെ അവയിൽ ധാരാളം പുതിയ രസകരമായ കാര്യങ്ങൾ അവതരിപ്പിച്ചു. , ഉദാഹരണത്തിന്, Java Stream API , lambda, മുതലായവ. പ്രൊഡക്ഷൻ കോഡിൽ ഉപയോഗിക്കുന്ന വളരെ രസകരവും പുതുമയുള്ളതും രസകരവുമായ കാര്യങ്ങൾ, അഭിമുഖങ്ങളിൽ അവർ ചോദിക്കുന്നതും നിങ്ങൾ അറിയേണ്ടതുമായ കാര്യങ്ങൾ. അതിനാൽ, നിങ്ങൾ ജാവ-4 ലൈബ്രറിയിലെ ഷെൽഫിൽ നിന്ന് ഒരു പുസ്തകം എടുത്ത് പഠിക്കാൻ പോകരുത്. ഇതാണ് ഞങ്ങളുടെ പ്ലാൻ: ഞങ്ങൾ Java-8 അല്ലെങ്കിൽ ഉയർന്നത് പഠിക്കുന്നു.

Stream API, var മുതലായ പുതുമകളിൽ ഞങ്ങൾ വളരെ ശ്രദ്ധ ചെലുത്തുന്നു. അഭിമുഖങ്ങൾക്കിടയിൽ അവ ചോദിക്കുകയും നിർമ്മാണത്തിൽ നിരന്തരം ഉപയോഗിക്കുകയും ചെയ്യുന്നു. അതായത്, സ്ട്രീം API ലൂപ്പുകളേക്കാൾ വളരെ തണുത്തതാണ്, പൊതുവേ, വളരെ രസകരമായ ഒരു കാര്യം. ശ്രദ്ധിക്കുന്നത് ഉറപ്പാക്കുക.

കൂടാതെ ആവർത്തനങ്ങൾ, ഒഴിവാക്കലുകൾ തുടങ്ങി എല്ലാത്തരം കാര്യങ്ങളും ഉണ്ട്. നിങ്ങൾ സ്വയം ചില ചെറിയ കോഡ് എഴുതുന്നിടത്തോളം കാലം നിങ്ങൾക്ക് അപ്രധാനമെന്ന് തോന്നുന്ന കാര്യങ്ങൾ. നിങ്ങൾക്ക് ഈ ഒഴിവാക്കലുകൾ ആവശ്യമില്ല, ആർക്കെങ്കിലും അവ ആവശ്യമാണ്? എന്നാൽ അഭിമുഖങ്ങളിൽ അവരോട് തീർച്ചയായും ചോദിക്കും, അവ തീർച്ചയായും നിർമ്മാണത്തിൽ നിങ്ങൾക്ക് ഉപയോഗപ്രദമാകും. പൊതുവേ, നിങ്ങൾ ഒഴിവാക്കലുകൾ, ആവർത്തനങ്ങൾ, മറ്റ് കാര്യങ്ങൾ എന്നിവയിൽ ശ്രദ്ധിക്കണം.

ഡാറ്റ ഘടനകൾ. നിങ്ങൾക്ക് ഘടനകളില്ലാതെ പോകാൻ കഴിയില്ല, പക്ഷേ സെറ്റുകൾ, നിഘണ്ടുക്കൾ, ഷീറ്റുകൾ എന്നിവ ഉണ്ടെന്ന് നിങ്ങൾക്കറിയില്ലെങ്കിൽ അത് വളരെ മികച്ചതായിരിക്കും. കൂടാതെ ഘടനകളുടെ വ്യത്യസ്ത നിർവ്വഹണങ്ങളും. ഉദാഹരണത്തിന്, ജാവയിലെ അതേ നിഘണ്ടുവിന് ഹാഷ്മാപ്പും ട്രീമാപ്പും ഉൾപ്പെടെ നിരവധി നിർവ്വഹണങ്ങളുണ്ട്. അവയ്ക്ക് വ്യത്യസ്ത അസിംപ്റ്റോട്ടിക്കുകൾ ഉണ്ട്, അവ അകത്ത് വ്യത്യസ്തമായി ക്രമീകരിച്ചിരിക്കുന്നു. അവ എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നുവെന്നും എപ്പോൾ ഉപയോഗിക്കണമെന്നും നിങ്ങൾ അറിയേണ്ടതുണ്ട്.

ഈ ഡാറ്റ ഘടനകൾ ആന്തരികമായി എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾക്കറിയാമെങ്കിൽ അത് വളരെ രസകരമായിരിക്കും. അതായത്, അവരുടെ അസിംപ്റ്റോട്ടിക്കുകൾ അറിയുന്നത് എളുപ്പമല്ല - പന്തയം എത്രത്തോളം പ്രവർത്തിക്കുന്നു, പാസ് എത്രനേരം പ്രവർത്തിക്കുന്നു, എന്നാൽ ഉള്ളിലെ ഘടന എങ്ങനെ പ്രവർത്തിക്കുന്നു - ഉദാഹരണത്തിന്, ഹാഷ്മാപ്പിലെ ഒരു ബക്കറ്റ് എന്താണ്.

മരങ്ങളിലും ഗ്രാഫുകളിലും ശ്രദ്ധിക്കുന്നത് മൂല്യവത്താണ്. പ്രൊഡക്ഷൻ കോഡിൽ ഇവ വളരെ സാധാരണമല്ലാത്ത കാര്യങ്ങളാണ്, പക്ഷേ അഭിമുഖങ്ങളിൽ അവ ഇഷ്ടപ്പെടുന്നു. അതനുസരിച്ച്, നിങ്ങൾക്ക് മരങ്ങൾ, ഗ്രാഫുകൾ വീതിയിലും ആഴത്തിലും സഞ്ചരിക്കാൻ കഴിയണം. ഇവയെല്ലാം ലളിതമായ അൽഗോരിതങ്ങളാണ്.

ലൈബ്രറികൾ, മൾട്ടി-ക്ലാസ് കോഡ് എന്നിവ ഉപയോഗിച്ച് സങ്കീർണ്ണമായ ഏതെങ്കിലും വലിയ കോഡ് എഴുതാൻ തുടങ്ങുമ്പോൾ, സിസ്റ്റങ്ങൾ നിർമ്മിക്കാതെയും ഡിപൻഡൻസികൾ പരിഹരിക്കാതെയും നിങ്ങൾക്ക് ബുദ്ധിമുട്ടാണെന്ന് നിങ്ങൾ മനസ്സിലാക്കും. ഇവ പ്രാഥമികമായി മാവൻ, ഗ്രേഡിൽ എന്നിവയാണ്. നിങ്ങളുടെ പ്രോജക്റ്റിലേക്ക് ഒരു വരിയിൽ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു. അതായത്, നിങ്ങൾ ഒരു വരി xml എഴുതുകയും പ്രോജക്റ്റിലേക്ക് ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുകയും ചെയ്യുന്നു. വലിയ സംവിധാനങ്ങൾ. അവ ഏകദേശം സമാനമാണ്, ഒന്നുകിൽ ഒന്ന് ഉപയോഗിക്കുക - മാവൻ അല്ലെങ്കിൽ ഗ്രേഡിൽ.

അടുത്തത് - ചില തരത്തിലുള്ള പതിപ്പ് നിയന്ത്രണ സംവിധാനം. ഞാൻ Git ശുപാർശചെയ്യുന്നു, കാരണം ഇത് ജനപ്രിയമാണ് കൂടാതെ ടൺ കണക്കിന് ട്യൂട്ടോറിയലുകൾ ഉണ്ട്. മിക്കവാറും എല്ലാവരും Git ഉപയോഗിക്കുന്നു, ഇത് ഒരു രസകരമായ കാര്യമാണ്, നിങ്ങൾക്ക് ഇത് കൂടാതെ ജീവിക്കാൻ കഴിയില്ല.

ഒപ്പം ഒരുതരം വികസന അന്തരീക്ഷവും. ഞാൻ IntelliJ ഐഡിയ ശുപാർശ ചെയ്യുന്നു. ഇത് വികസന പ്രക്രിയയെ വളരെയധികം വേഗത്തിലാക്കുന്നു, നിങ്ങളെ വളരെയധികം സഹായിക്കുന്നു, നിങ്ങൾക്കായി എല്ലാ ബോയിലർ പ്ലേറ്റ് കോഡും എഴുതുന്നു, പൊതുവേ, ഇത് രസകരമാണ്.

സ്ലൈഡിൽ നിന്നുള്ള ലിങ്കുകൾ: SQLZOO, ഹബ്രാപോസ്റ്റ്

SQL. പിന്നണിക്കാരെ കുറിച്ച് കുറച്ച്. ഇവിടെ യഥാർത്ഥത്തിൽ രസകരമായ ഒരു കേസ് ഉണ്ടായിരുന്നു. എന്റെ രണ്ടാമത്തെ ഇന്റേൺഷിപ്പ് ഇന്റർവ്യൂവിന് രണ്ട് ദിവസം മുമ്പ്, ഒരു എച്ച്ആർ പെൺകുട്ടി എന്നെ വിളിച്ചു, രണ്ട് ദിവസത്തിനുള്ളിൽ അവർ എന്നോട് SQL, HTTP എന്നിവയെക്കുറിച്ച് ചോദിക്കുമെന്ന് പറഞ്ഞു, എനിക്ക് അത് പഠിക്കേണ്ടതുണ്ട്. SQL അല്ലെങ്കിൽ HTTP എന്നിവയെ കുറിച്ച് എനിക്ക് ഒന്നും അറിയില്ലായിരുന്നു. ഞാൻ ഈ രസകരമായ സൈറ്റ് കണ്ടെത്തി - SQLZOO. 12 മണിക്കൂറിനുള്ളിൽ ഞാൻ അതിൽ SQL പഠിച്ചു, അതായത്, SQL വാക്യഘടന, SELECT ചോദ്യങ്ങൾ എങ്ങനെ എഴുതാം, JOIN മുതലായവ. വളരെ രസകരമായ സൈറ്റ്, ഞാൻ ഇത് വളരെ ശുപാർശ ചെയ്യുന്നു. വാസ്തവത്തിൽ, 12 മണിക്കൂറിനുള്ളിൽ എനിക്കറിയാവുന്നതിന്റെ 90% ഞാൻ പഠിച്ചു.

കൂടാതെ ഡാറ്റാബേസ് ആർക്കിടെക്ചർ അറിയുന്നതും വളരെ നല്ലതാണ്. ഇവ എല്ലാത്തരം കീകൾ, സൂചികകൾ, നോർമലൈസേഷൻ എന്നിവയാണ്. ഹബ്രെയിൽ ഇതിനെക്കുറിച്ച് ഒരു പരമ്പര തന്നെയുണ്ട്.

ജാവയിൽ, SQL കൂടാതെ, JPA പോലുള്ള ഒബ്ജക്റ്റ്-റിലേഷണൽ മാപ്പിംഗ് സിസ്റ്റങ്ങളും ഉണ്ട്. കുറച്ച് കോഡ് ഉണ്ട്. ആദ്യ രീതിയിൽ ചില SQL കോഡ് ഉണ്ട് - info.users ൽ നിന്ന് ഐഡി പേര് തിരഞ്ഞെടുക്കുക. ഉപയോക്താക്കളുടെ ഡാറ്റാബേസിൽ നിന്ന്, പട്ടികയിൽ നിന്ന്, അവരുടെ ഐഡികളും പേരുകളും ലഭിക്കും.

അടുത്തതായി, ഒരു വസ്തുവിനെ അടിത്തറയിൽ നിന്ന് ഒരു ജാവ ഒബ്‌ജക്റ്റാക്കി മാറ്റുന്ന ഒരു പ്രത്യേക മാപ്പർ ഉണ്ട്. ഈ കോഡ് യഥാർത്ഥത്തിൽ നടപ്പിലാക്കുന്ന മൂന്നാമത്തെ രീതി ചുവടെയുണ്ട്. JPA ഉപയോഗിച്ച് ഒരു വരി ഉപയോഗിച്ച് ഇതെല്ലാം മാറ്റിസ്ഥാപിക്കാം, അത് ചുവടെ എഴുതിയിരിക്കുന്നു. ഇത് ഒരേ കാര്യം ചെയ്യുന്നു - എല്ലാം ByIdIn കണ്ടെത്തുക. അതായത്, രീതിയുടെ പേരിനെ അടിസ്ഥാനമാക്കി, അത് നിങ്ങൾക്കായി ഒരു SQL അന്വേഷണം സൃഷ്ടിക്കുന്നു.

വളരെ രസകരമായ കാര്യം. ഞാൻ തന്നെ, എനിക്ക് SQL അറിയാത്തപ്പോൾ, JPA ഉപയോഗിച്ചു. പൊതുവേ, ശ്രദ്ധിക്കുക. SQL പഠിക്കാൻ നിങ്ങൾക്ക് മടിയാണെങ്കിൽ, അത് ഒരു ദുരന്തമാണ്. കൂടാതെ, പൊതുവേ, തീ!

സ്പ്രിംഗ്. സ്പ്രിംഗ് ചട്ടക്കൂട് പോലെയുള്ള ഒരു സംഗതിയെക്കുറിച്ച് ആരാണ് കേട്ടിട്ടുള്ളത്? നിങ്ങളിൽ എത്ര പേരുണ്ടെന്ന് നിങ്ങൾ കാണുന്നുണ്ടോ? കാരണമില്ലാതെയല്ല. ഓരോ സെക്കൻഡ് ജാവ ബാക്കെൻഡ് ഒഴിവുകളുടെയും ആവശ്യകതകളിൽ സ്പ്രിംഗ് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. അതില്ലാതെ, ഒരു വലിയ വികസനത്തിൽ ഒരിടത്തും ഇല്ല. എന്താണ് വസന്തം? ഒന്നാമതായി, ഇതൊരു ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ചട്ടക്കൂടാണ്. ഇതിനെ കുറിച്ചും പറയും അടുത്ത സ്പീക്കർ. എന്നാൽ ചുരുക്കത്തിൽ, ചില ക്ലാസുകളുടെ ഡിപൻഡൻസികൾ മറ്റുള്ളവരിലേക്ക് ഇറക്കുമതി ചെയ്യുന്നത് എളുപ്പമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു കാര്യമാണിത്. അതായത്, ആശ്രിതത്വങ്ങളെക്കുറിച്ചുള്ള അറിവ് ലളിതമാക്കുന്നു.

ഒരു ബട്ടൺ ഉപയോഗിച്ച് നിങ്ങളുടെ സെർവർ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന സ്പ്രിംഗിന്റെ ഒരു ഭാഗമാണ് സ്പ്രിംഗ് ബൂട്ട്. നിങ്ങൾ THID-ലേക്ക് പോയി, രണ്ട് ബട്ടണുകൾ അമർത്തുക, ഇപ്പോൾ നിങ്ങളുടെ സെർവർ ആപ്ലിക്കേഷൻ ലോക്കൽ ഹോസ്റ്റ് 8080-ൽ പ്രവർത്തിക്കുന്നു. അതായത്, നിങ്ങൾ ഇതുവരെ കോഡിന്റെ ഒരു വരി പോലും എഴുതിയിട്ടില്ല, പക്ഷേ ഇത് ഇതിനകം പ്രവർത്തിക്കുന്നു. വളരെ രസകരമായ കാര്യം. സ്വന്തമായി എന്തെങ്കിലും എഴുതിയാൽ തീ!

വസന്തം വളരെ വലിയ ചട്ടക്കൂടാണ്. ഇത് നിങ്ങളുടെ സെർവർ ആപ്ലിക്കേഷൻ എടുക്കുക മാത്രമല്ല ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ പരിഹരിക്കുകയും ചെയ്യുന്നു. REST API രീതികൾ സൃഷ്ടിക്കുന്നത് ഉൾപ്പെടെ ഒരു കൂട്ടം കാര്യങ്ങൾ ചെയ്യാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. അതായത്, നിങ്ങൾ ചില മെത്തേഡ് എഴുതുകയും അതിൽ ഗെറ്റ് മാപ്പിംഗ് വ്യാഖ്യാനം അറ്റാച്ചുചെയ്യുകയും ചെയ്തു. ഇപ്പോൾ നിങ്ങൾക്ക് ലോക്കൽഹോസ്റ്റിൽ ഹലോ വേൾഡ് എഴുതുന്ന ചില രീതികൾ ഉണ്ട്. രണ്ട് വരി കോഡ്, അത് പ്രവർത്തിക്കുന്നു. അടിപൊളി സാധനം.

സ്പ്രിംഗ് എഴുത്ത് പരീക്ഷകൾ എളുപ്പമാക്കുന്നു. വലിയ വികസനത്തിൽ പരീക്ഷിക്കാതെ ഒരു വഴിയുമില്ല. കോഡ് പരിശോധിക്കേണ്ടതുണ്ട്. ഈ ആവശ്യത്തിനായി, Java ന് ഒരു രസകരമായ ലൈബ്രറി ഉണ്ട് JUnit 5. കൂടാതെ JUnit പൊതുവെ, എന്നാൽ ഏറ്റവും പുതിയ പതിപ്പ് അഞ്ചാമത്തേതാണ്. പരിശോധനയ്‌ക്കായി എല്ലാം ഉണ്ട്, എല്ലാത്തരം അവകാശവാദങ്ങളും മറ്റ് കാര്യങ്ങളും.

ഒപ്പം ആകർഷകമായ മോക്കിറ്റോ ചട്ടക്കൂടുമുണ്ട്. നിങ്ങൾ പരീക്ഷിക്കാൻ ആഗ്രഹിക്കുന്ന ചില പ്രവർത്തനങ്ങളുണ്ടെന്ന് സങ്കൽപ്പിക്കുക. ഫംഗ്‌ഷണാലിറ്റി ഒരുപാട് കാര്യങ്ങൾ ചെയ്യുന്നു, മധ്യത്തിൽ എവിടെയോ, ഇത് നിങ്ങളുടെ ഐഡി ഉപയോഗിച്ച് VKontakte-ലേക്ക് ലോഗിൻ ചെയ്യുന്നു, ഉദാഹരണത്തിന്, VKontakte ഉപയോക്താവിന്റെ ആദ്യ, അവസാന നാമം ഐഡിയിൽ നിന്ന് സ്വീകരിക്കുന്നു. നിങ്ങൾ ഒരുപക്ഷേ ടെസ്റ്റുകളിൽ VKontakte ഉൾപ്പെടുത്തില്ല, അത് വിചിത്രമാണ്. എന്നാൽ നിങ്ങൾ പ്രവർത്തനക്ഷമത പരിശോധിക്കേണ്ടതുണ്ട്, അതിനാൽ നിങ്ങൾ മോക്കിറ്റോ ഉപയോഗിച്ച് ഈ ക്ലാസ് ഉണ്ടാക്കി, മോക്ക് ഇറ്റ്, ഇത് അനുകരിക്കുക.

അത്തരത്തിലുള്ള ഒരു ഐഡിയുമായി ഈ ക്ലാസിലേക്ക് ഒരു അഭ്യർത്ഥന വരുമ്പോൾ, അത് ചില അവസാന നാമം നൽകുന്നു, ഉദാഹരണത്തിന്, വാസ്യ പപ്കിൻ. അത് പ്രവർത്തിക്കുകയും ചെയ്യും. അതായത്, മോക്ക് വൺ ക്ലാസിനായുള്ള എല്ലാ പ്രവർത്തനങ്ങളും നിങ്ങൾ പരിശോധിക്കും. വളരെ രസകരമായ കാര്യം.

സ്ലൈഡിൽ നിന്നുള്ള ലിങ്ക്

ഡിസൈൻ പാറ്റേണുകൾ. അത് എന്താണ്? വികസനത്തിൽ ഉണ്ടാകുന്ന സാധാരണ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനുള്ള ടെംപ്ലേറ്റുകളാണ് ഇവ. വികസനത്തിൽ, സമാനമായതോ സമാനമായതോ ആയ പ്രശ്നങ്ങൾ പലപ്പോഴും ഉയർന്നുവരുന്നു, എങ്ങനെയെങ്കിലും നന്നായി പരിഹരിക്കുന്നതാണ് നല്ലത്. അതിനാൽ, ഈ പ്രശ്നങ്ങൾ എങ്ങനെ പരിഹരിക്കാം എന്നതിനെക്കുറിച്ചുള്ള മികച്ച രീതികളും ചില ടെംപ്ലേറ്റുകളും ആളുകൾ കൊണ്ടുവന്നു.

ഏറ്റവും ജനപ്രിയമായ പാറ്റേണുകളുള്ള ഒരു വെബ്സൈറ്റ് ഉണ്ട് - refactoring.guru, നിങ്ങൾക്ക് അത് വായിക്കാം, എന്തൊക്കെ പാറ്റേണുകൾ ഉണ്ടെന്ന് കണ്ടെത്താം, ഒരു കൂട്ടം സിദ്ധാന്തം വായിക്കുക. ഇത് പ്രായോഗികമായി ഉപയോഗശൂന്യമാണ് എന്നതാണ് പ്രശ്നം. വാസ്തവത്തിൽ, പരിശീലനമില്ലാത്ത പാറ്റേണുകൾ പ്രത്യേകിച്ച് ഉപയോഗപ്രദമല്ല.

സിംഗിൾടോൺ അല്ലെങ്കിൽ ബിൽഡർ പോലുള്ള ചില പാറ്റേണുകളെ കുറിച്ച് നിങ്ങൾ കേൾക്കും. ആരാണ് ഈ വാക്കുകൾ കേട്ടത്? ഒരുപാട് ആളുകൾ. നിങ്ങൾക്ക് സ്വയം നടപ്പിലാക്കാൻ കഴിയുന്ന അത്തരം ലളിതമായ പാറ്റേണുകൾ ഉണ്ട്. എന്നാൽ മിക്ക പാറ്റേണുകളും: തന്ത്രം, ഫാക്ടറി, മുൻഭാഗം - അവ എവിടെ പ്രയോഗിക്കണമെന്ന് വ്യക്തമല്ല.

മറ്റേതെങ്കിലും വ്യക്തിയുടെ കോഡിൽ ഈ പാറ്റേൺ പ്രയോഗിക്കുന്ന ഒരു സ്ഥലം നിങ്ങൾ പ്രായോഗികമായി കാണുന്നതുവരെ, നിങ്ങൾക്കത് സ്വയം പ്രയോഗിക്കാൻ കഴിയില്ല. അതിനാൽ, പാറ്റേണുകൾക്കൊപ്പം പരിശീലനം വളരെ പ്രധാനമാണ്. refactoring.guru-ൽ അവരെക്കുറിച്ച് വായിക്കുന്നത് വളരെ സഹായകരമല്ല, പക്ഷേ ഇത് തീർച്ചയായും മൂല്യവത്താണ്.

എന്തുകൊണ്ട് പാറ്റേണുകൾ ആവശ്യമാണ്? നിങ്ങൾക്ക് ഒരു നിശ്ചിത ഉപയോക്തൃ ക്ലാസ് ഉണ്ടെന്ന് പറയാം. അതിന് ഒരു ഐഡിയും പേരും ഉണ്ട്. ഓരോ ഉപയോക്താവിനും ഒരു ഐഡിയും പേരും ഉണ്ടായിരിക്കണം. മുകളിൽ ഇടത് ക്ലാസ് മുറിയാണ്.

ഉപയോക്താവിനെ സമാരംഭിക്കാനുള്ള വഴികൾ എന്തൊക്കെയാണ്? രണ്ട് ഓപ്ഷനുകൾ ഉണ്ട് - ഒന്നുകിൽ ഒരു കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ ഒരു സെറ്റർ. രണ്ട് സമീപനങ്ങളുടെയും ദോഷങ്ങൾ എന്തൊക്കെയാണ്?

കൺസ്ട്രക്റ്റർ. പുതിയ ഉപയോക്താവ് (7, "ബോണ്ട്"), ശരി. ഇപ്പോൾ നമുക്ക് ഒരു ഉപയോക്തൃ ക്ലാസ് ഇല്ലെന്ന് പറയാം, എന്നാൽ ഏഴ് സംഖ്യാ ഫീൽഡുകളുള്ള വേറെ ചിലത്. നിങ്ങൾക്ക് തുടർച്ചയായി ഏഴ് നമ്പറുകൾ അടങ്ങിയ ഒരു കൺസ്ട്രക്റ്റർ ഉണ്ടായിരിക്കും. ഈ നമ്പരുകൾ ഏതൊക്കെയാണെന്നും അവയിൽ ഏതൊക്കെ വസ്‌തുക്കളുടേതാണെന്നും വ്യക്തമല്ല. ഡിസൈനർ മഹാനല്ല.

രണ്ടാമത്തെ ഓപ്ഷൻ സെറ്റർ ആണ്. നിങ്ങൾ വ്യക്തമായി എഴുതുന്നു: setId(7), setName("Bond"). ഏത് മേഖലയുടേതാണ് സ്വത്ത് എന്ന് നിങ്ങൾ മനസ്സിലാക്കുന്നു. പക്ഷേ സെറ്ററിന് ഒരു പ്രശ്നമുണ്ട്. ഒന്നാമതായി, എന്തെങ്കിലും അസൈൻ ചെയ്യാൻ നിങ്ങൾ മറന്നേക്കാം, രണ്ടാമതായി, നിങ്ങളുടെ ഒബ്ജക്റ്റ് മാറ്റാവുന്നതായി മാറുന്നു. ഇത് ത്രെഡ് സുരക്ഷിതമല്ല കൂടാതെ കോഡിന്റെ വായനാക്ഷമത ചെറുതായി കുറയ്ക്കുന്നു. അതുകൊണ്ടാണ് ആളുകൾ ഒരു രസകരമായ പാറ്റേൺ കൊണ്ടുവന്നത് - ബിൽഡർ.

ഇത് എന്തിനെക്കുറിച്ചാണ്? രണ്ട് സമീപനങ്ങളുടെയും ഗുണങ്ങൾ-സെറ്റർ, കൺസ്ട്രക്റ്റർ-ഒന്നിൽ സംയോജിപ്പിക്കാൻ ശ്രമിക്കാം. ഞങ്ങൾ ഒരു പ്രത്യേക ഒബ്‌ജക്റ്റ് നിർമ്മിക്കുന്നു, ബിൽഡർ, അതിൽ ഐഡിയും നെയിം ഫീൽഡുകളും ഉണ്ടായിരിക്കും, അത് സെറ്ററിനെ അടിസ്ഥാനമാക്കി നിർമ്മിച്ചതാണ്, കൂടാതെ എല്ലാ പാരാമീറ്ററുകളുമുള്ള ഒരു പുതിയ ഉപയോക്താവിനെ നിങ്ങൾക്ക് തിരികെ നൽകുന്ന ഒരു ബിൽഡ് രീതി ഉണ്ടായിരിക്കും. നമുക്ക് ഒരു മാറ്റമില്ലാത്ത വസ്തുവും ഒരു സെറ്ററും ലഭിക്കും. അടിപൊളി!

എന്തൊക്കെയാണ് പ്രശ്നങ്ങൾ? ഇവിടെ നമുക്ക് ക്ലാസിക് ബിൽഡർ ഉണ്ട്. ചില ഫീൽഡിൽ പരിശോധിക്കാൻ നമുക്ക് ഇപ്പോഴും മറക്കാൻ കഴിയും എന്നതാണ് പ്രശ്നം. ഐഡി സന്ദർശിക്കാൻ ഞങ്ങൾ മറന്നുപോയെങ്കിൽ, ഈ സാഹചര്യത്തിൽ ബിൽഡറിൽ അത് പൂജ്യമായി ആരംഭിക്കുന്നു, കാരണം int തരം അസാധുവാണ്. നമ്മൾ "ബോണ്ട്" എന്ന പേര് ഉണ്ടാക്കുകയും ഐഡി ഓഫീസ് സന്ദർശിക്കാൻ മറക്കുകയും ചെയ്താൽ, "0" എന്ന ഐഡിയും "ബോണ്ട്" എന്ന പേരും ഉള്ള ഒരു പുതിയ ഉപയോക്താവ് നമുക്കുണ്ടാകും. തണുത്തതല്ല.

ഇതിനെ ചെറുക്കാൻ ശ്രമിക്കാം. ബിൽഡറിൽ നമ്മൾ int എന്നത് int ആയി മാറ്റും, അങ്ങനെ അത് അസാധുവാകും. ഇപ്പോൾ എല്ലാം ഗംഭീരമാണ്.

"ബോണ്ട്" എന്ന പേരിൽ ഒരു ഉപയോക്താവിനെ സൃഷ്‌ടിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ, അവന്റെ ഐഡി ഇടാൻ മറന്നാൽ, ഞങ്ങൾക്ക് ഒരു നൾ പോയിന്റർ ഒഴിവാക്കൽ ലഭിക്കും, കാരണം ഐഡി അസാധുവായതല്ല, കൂടാതെ ബിൽഡറിന് ഒരു നൾ, പ്രത്യേകമായി പോയിന്റർ ഒഴിവാക്കൽ ഉണ്ട്.

പക്ഷേ ഒരു പേര് ഇടാൻ ഞങ്ങൾക്ക് ഇപ്പോഴും മറക്കാൻ കഴിയും, അതിനാൽ ഞങ്ങൾ ഒബ്‌ജക്റ്റ് റീപ്ലേ അസാധുവായി സജ്ജമാക്കുന്നു. ഇപ്പോൾ, ബിൽഡറിൽ നിന്ന് നമ്മുടെ ഒബ്ജക്റ്റ് നിർമ്മിക്കുമ്പോൾ, അത് ഫീൽഡ് അസാധുവാണോ എന്ന് പരിശോധിക്കുന്നു. അതുമാത്രമല്ല.

അവസാനത്തെ ഉദാഹരണം നോക്കാം. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ എങ്ങനെയെങ്കിലും ഐഡി റൺടൈമിൽ അസാധുവാക്കിയാൽ, നിങ്ങൾ അത് ചെയ്തുവെന്ന് ഉടനടി അറിയുന്നത് വളരെ മികച്ചതായിരിക്കും, നിങ്ങൾ ഇപ്പോൾ ഒരു തെറ്റ് ചെയ്യുന്നത് രസകരമല്ല.

നിങ്ങൾ ഒരു പിശക് വരുത്തേണ്ടത് ഉപയോക്തൃ സൃഷ്‌ടിയുടെ നിമിഷത്തിലല്ല, മറിച്ച് നിങ്ങൾ ഐഡിയിലേക്ക് ശൂന്യമാക്കുമ്പോൾ. അതിനാൽ, ബിൽഡറിൽ ഞങ്ങൾ സെറ്റർ ഇന്റിജറിനെ int ആയി മാറ്റും, കൂടാതെ അവർ അസാധുവാക്കിയതായി അദ്ദേഹം ഉടൻ തന്നെ സത്യം ചെയ്യും.

ചുരുക്കത്തിൽ, എന്താണ് കാര്യം? ലളിതമായ ഒരു ബിൽഡർ പാറ്റേൺ ഉണ്ട്, എന്നാൽ അതിന്റെ നിർവ്വഹണത്തിന് പോലും ചില സൂക്ഷ്മതകളുണ്ട്, അതിനാൽ പാറ്റേണുകളുടെ വ്യത്യസ്ത നിർവ്വഹണങ്ങൾ നോക്കുന്നത് വളരെ രസകരമാണ്. ഓരോ പാറ്റേണിനും ഡസൻ കണക്കിന് നടപ്പിലാക്കലുകൾ ഉണ്ട്. ഇതെല്ലാം വളരെ രസകരമാണ്.

പ്രൊഡക്ഷൻ കോഡിൽ ബിൽഡർ എങ്ങനെ എഴുതാം? ഇതാ ഞങ്ങളുടെ ഉപയോക്താവ്. ലോംബോക്ക് ലൈബ്രറിയിൽ നിന്ന് ഞങ്ങൾ ഒരു ബിൽഡർ റൊട്ടേഷൻ അറ്റാച്ചുചെയ്യുന്നു, അത് തന്നെ നമുക്കായി ഒരു ബിൽഡർ സൃഷ്ടിക്കുന്നു. അതായത്, ഞങ്ങൾ ഒരു കോഡും എഴുതുന്നില്ല, എന്നാൽ ഈ ക്ലാസിന് ഒരു ബിൽഡർ ഉണ്ടെന്ന് ജാവ ഇതിനകം കരുതുന്നു, നമുക്ക് അതിനെ ഇങ്ങനെ വിളിക്കാം.

ബോയിലർ പ്ലേറ്റ് എഴുതുന്നത് ഒഴിവാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു രസകരമായ ലൈബ്രറിയായ ലോംബോക്ക് ഉൾപ്പെടെ മിക്കവാറും എല്ലാത്തിനും ജാവയ്ക്ക് ലൈബ്രറികൾ ഉണ്ടെന്ന് ഞാൻ ഇതിനകം പറഞ്ഞിട്ടുണ്ട്. ബിൽഡർ, നേടുക.

പാറ്റേണുകൾ ആർക്കിടെക്ചറൽ ആകാം - ഒരു ക്ലാസുമായി മാത്രമല്ല, മൊത്തത്തിലുള്ള സിസ്റ്റവുമായി ബന്ധപ്പെട്ടതാണ്. സിസ്റ്റം രൂപകൽപ്പനയിൽ അത്തരമൊരു രസകരമായ തത്വമുണ്ട്: ഏക ഉത്തരവാദിത്ത തത്വം. അവൻ എന്തിനെക്കുറിച്ചാണ് സംസാരിക്കുന്നത്? ഓരോ ക്ലാസും അതിന്റേതായ ചില പ്രവർത്തനങ്ങൾക്ക് ഉത്തരവാദികളായിരിക്കണം എന്നതാണ് വസ്തുത. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾക്ക് ഉപയോക്താക്കളുമായി ആശയവിനിമയം നടത്തുന്ന ഒരു കൺട്രോളർ ഉണ്ട്, JSON ഒബ്‌ജക്‌റ്റുകൾ. JSON ഒബ്‌ജക്റ്റുകളെ ജാവ ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുന്ന മോഡലുകളാക്കി മാറ്റുന്ന ഫേയ്‌ഡ് ഉണ്ട്. ഈ മോഡലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്ന സങ്കീർണ്ണമായ ലോജിക് ഉള്ള ഒരു സേവനമുണ്ട്. ഈ മോഡലുകളെ ഡാറ്റാബേസിൽ ഉൾപ്പെടുത്തി ഡാറ്റാബേസിൽ നിന്ന് വീണ്ടെടുക്കുന്ന ഒരു ഡാറ്റ ആക്സസ് ഒബ്ജക്റ്റ് ഉണ്ട്. കൂടാതെ ഡാറ്റാബേസ് തന്നെയുണ്ട്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഇതെല്ലാം ഒരു ക്ലാസിലല്ല, ഞങ്ങൾ അഞ്ച് വ്യത്യസ്ത ക്ലാസുകൾ നിർമ്മിക്കുന്നു, അത് മറ്റൊരു പാറ്റേൺ ആണ്.

നിങ്ങൾ ജാവ കൂടുതലോ കുറവോ പഠിച്ചുകഴിഞ്ഞാൽ, ഒരു ഡാറ്റാബേസ് ഉള്ള നിങ്ങളുടെ സ്വന്തം പ്രോജക്റ്റ് എഴുതുന്നതും മറ്റ് API-കൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതും REST API ക്ലയന്റുകൾക്ക് നിങ്ങളുടെ സെർവർ ആപ്ലിക്കേഷൻ വെളിപ്പെടുത്തുന്നതും വളരെ നല്ലതാണ്. ഇത് നിങ്ങളുടെ ബയോഡാറ്റയിലേക്ക് ചേർക്കുന്നത് ഒരു വലിയ കാര്യമായിരിക്കും, ഇത് നിങ്ങളുടെ വിദ്യാഭ്യാസത്തിന് ഒരു മികച്ച അവസാനമായിരിക്കും. ഇതുപയോഗിച്ച് നിങ്ങൾക്ക് പോയി ജോലി നേടാം.

എന്റെ സെർവർ ആപ്ലിക്കേഷന്റെ ഒരു ഉദാഹരണം ഇതാ. എന്റെ രണ്ടാം വർഷത്തിൽ, ഞാൻ ആൺകുട്ടികളുമായി ഒരു ടേം പേപ്പർ എഴുതി. പരിപാടികൾ സംഘടിപ്പിക്കുന്നതിനായി മൊബൈൽ ആപ്ലിക്കേഷൻ എഴുതുകയായിരുന്നു ഇവർ. അവിടെ, ഉപയോക്താക്കൾക്ക് VKontakte വഴി ലോഗിൻ ചെയ്യാനും മാപ്പിൽ പോയിന്റുകൾ സ്ഥാപിക്കാനും ഇവന്റുകൾ സൃഷ്ടിക്കാനും സുഹൃത്തുക്കളെ അവരിലേക്ക് ക്ഷണിക്കാനും ഇവന്റുകളുടെ ചിത്രങ്ങൾ സംരക്ഷിക്കാനും കഴിയും.

പദ്ധതിയിൽ ഞാൻ എന്താണ് ചെയ്തത്? SQL ഉപയോഗിക്കാതെ സ്പ്രിംഗ് ബൂട്ടിൽ ഒരു സെർവർ ആപ്ലിക്കേഷൻ എഴുതി. എനിക്ക് അവനെ അറിയില്ലായിരുന്നു, ഞാൻ JPA ഉപയോഗിച്ചു. അതിന് എന്ത് ചെയ്യാൻ കഴിയും? OAuth-2 വഴി VK-ലേക്ക് ലോഗിൻ ചെയ്യുക. ഉപയോക്താവിന്റെ ടോക്കൺ എടുക്കുക, അതിനൊപ്പം VK- ലേക്ക് പോകുക, ഇത് ഒരു യഥാർത്ഥ ഉപയോക്താവാണോ എന്ന് പരിശോധിക്കുക. VKontakte വഴി ഉപയോക്താക്കളെക്കുറിച്ചുള്ള വിവരങ്ങൾ സ്വീകരിക്കുക. JPA വഴിയും ഒരു ഡാറ്റാബേസിൽ വിവരങ്ങൾ സംരക്ഷിക്കാൻ ഇതിന് കഴിഞ്ഞു. കമ്പ്യൂട്ടർ മെമ്മറിയിൽ ചിത്രങ്ങളും മറ്റ് ഫയലുകളും സമർത്ഥമായി സംരക്ഷിക്കുക, ഡാറ്റാബേസിൽ അവയിലേക്കുള്ള ലിങ്കുകൾ സംരക്ഷിക്കുക. ഡാറ്റാബേസിൽ CLOB ഒബ്‌ജക്‌റ്റുകൾ ഉണ്ടെന്ന് ആ സമയത്ത് എനിക്ക് അറിയില്ലായിരുന്നു, അതിനാൽ ഞാൻ ഇത് ഈ രീതിയിൽ ചെയ്തു. ഉപയോക്താക്കൾക്കും ക്ലയന്റ് ആപ്ലിക്കേഷനുകൾക്കുമായി ഒരു REST API ഉണ്ടായിരുന്നു. അടിസ്ഥാന പ്രവർത്തനക്ഷമതയ്ക്കായി യൂണിറ്റ് ടെസ്റ്റുകളും ഉണ്ടായിരുന്നു.

[…] ജാവയെക്കുറിച്ചുള്ള എന്റെ വിജയകരമായ പഠനത്തിന്റെ ഒരു ചെറിയ ഉദാഹരണം. സർവ്വകലാശാലയിലെ എന്റെ ആദ്യ വർഷത്തിൽ, എന്നെ C# പഠിപ്പിക്കുകയും OOP പ്രോഗ്രാമിംഗിനെക്കുറിച്ച് ഒരു ധാരണ നൽകുകയും ചെയ്തു - ക്ലാസുകൾ, ഇന്റർഫേസുകൾ, അമൂർത്തീകരണം എന്നിവ എന്തൊക്കെയാണ്, എന്തുകൊണ്ട് അവ ആവശ്യമാണ്. അത് എന്നെ ഒരുപാട് സഹായിച്ചു. ഇത് കൂടാതെ, ജാവ പഠിക്കുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്; ക്ലാസുകൾ ആവശ്യമായി വരുന്നത് എന്തുകൊണ്ടാണെന്ന് വ്യക്തമല്ല.

സർവ്വകലാശാലയിലെ എന്റെ രണ്ടാം വർഷത്തിൽ, അവർ വീണ്ടും ജാവ കോർ പഠിപ്പിച്ചു, പക്ഷേ ഞാൻ അവിടെ നിർത്തിയില്ല, ഞാൻ തന്നെ സ്പ്രിംഗ് പഠിക്കാൻ പോയി ഒരു കോഴ്‌സ് പേപ്പർ എഴുതി, ഞാൻ മുകളിൽ സൂചിപ്പിച്ച എന്റെ പ്രോജക്റ്റ്. ഇതിനെല്ലാം പുറമേ, ഞാൻ Yandex-ൽ ഒരു ഇന്റേൺഷിപ്പിന് പോയി, ഒരു അഭിമുഖം പാസായി, Yandex.Market-ൽ പ്രവേശിച്ചു. അവിടെ ഞാൻ ബെറുവിനായി ബാക്കെൻഡ് എഴുതി, ഇതാണ് ഞങ്ങളുടെ മാർക്കറ്റ്, Yandex.Market-ന് തന്നെ.

അതിനുശേഷം, ആറുമാസം മുമ്പ്, ഞാൻ അതേ മാർക്കറ്റിലെ മറ്റൊരു ടീമിലേക്ക് മാറ്റി. ബിസിനസ്സ് പങ്കാളികൾക്കായി ഞങ്ങൾ അനലിറ്റിക്‌സ് ചെയ്യുന്നു. ഞങ്ങൾ അനലിറ്റിക്കൽ പ്ലാറ്റ്‌ഫോമിലാണ്, ഞങ്ങൾ മൂന്ന് പേർ ബാക്കെൻഡിൽ ഉണ്ട്, അതിനാൽ പ്രോജക്റ്റിൽ എനിക്ക് വലിയ സ്വാധീനമുണ്ട്. ഇത് വളരെ രസകരമാണ്, യഥാർത്ഥത്തിൽ. അതായത്, ഞങ്ങൾ യഥാർത്ഥത്തിൽ മാർക്കറ്റിൽ ഡാറ്റ നൽകുന്നു - എന്ത് വിൽപ്പനയാണ്, ഏത് വിഭാഗങ്ങളിൽ, ഏത് മോഡലുകളിൽ, ബിസിനസ്സ് പങ്കാളികൾക്കായി, വലിയ അറിയപ്പെടുന്ന കമ്പനികൾ. ഞങ്ങൾ മൂന്ന് പേർ മാത്രമേയുള്ളൂ, ഞങ്ങൾ ഈ കോഡ് എഴുതുന്നു, ഇത് വളരെ രസകരമാണ്.

നന്ദി! ഉപയോഗപ്രദമായ ലിങ്കുകൾ:
- "ജാവ 8. തുടക്കക്കാരുടെ ഗൈഡ്".
- ഡാറ്റ ഘടനകൾ.
- SQLZOO.
- ഡാറ്റാബേസ് നോർമലൈസേഷൻ.
- ഡിസൈൻ പാറ്റേണുകൾ.
- ഡിസൈൻ പാറ്റേണുകൾ.
- കോഡ് വൃത്തിയാക്കുക.
- ഫലപ്രദമായ ജാവ.

അവലംബം: www.habr.com