Go HTTP Middleware വിശദീകരിക്കുന്നു
ഓരോ ഹാൻഡ്ലറിലും (handler) ഒരേ കോഡ് തന്നെ കോപ്പി ചെയ്ത് പേസ്റ്റ് ചെയ്യുന്നത് നിർത്തുക.
നിങ്ങൾക്ക് ഓതന്റിക്കേഷൻ (authentication) പരിശോധിക്കാനോ, റിക്വസ്റ്റ് ഡ്യൂറേഷൻ (request duration) ലോഗ് ചെയ്യാനോ, അല്ലെങ്കിൽ ഓരോ റിക്വസ്റ്റിലും ഒരു യുണീക് ഐഡി (unique ID) ചേർക്കാനോ ആവശ്യമുണ്ടെങ്കിൽ, ആ ലോജിക് നിങ്ങളുടെ ബിസിനസ്സ് ഹാൻഡ്ലറുകൾക്കുള്ളിൽ തന്നെ എഴുതരുത്. നിങ്ങൾക്ക് 20 ഹാൻഡ്ലറുകൾ ഉണ്ടെങ്കിൽ, നിങ്ങളുടെ ഓത്ത് ലോജിക് (auth logic) മാറുമ്പോൾ 20 സ്ഥലങ്ങളിൽ മാറ്റം വരുത്തേണ്ടി വരും. ഇത് മെയിന്റനൻസ് (maintenance) തലയിൽ വലിയൊരു ഭാരമായി മാറും.
മിഡിൽവെയർ (Middleware) ഇതിന് പരിഹാരം കാണുന്നു. നിങ്ങൾ ആ ലോജിക് ഒരിക്കൽ മാത്രം എഴുതുന്നു. നിങ്ങളുടെ ഹാൻഡ്ലറുകളെ ഇത് പൊതിയുന്നു (wrap). പിന്നീട് നിങ്ങൾ അത് വീണ്ടും മാറ്റേണ്ടി വരില്ല.
എന്താണ് മിഡിൽവെയർ (Middleware)?
Go-യിൽ, മിഡിൽവെയർ എന്നത് താഴെ പറയുന്നവ ചെയ്യുന്ന ഒരു ഫങ്ക്ഷനാണ്: • ഒരു http.Handler സ്വീകരിക്കുന്നു. • പുതിയൊരു http.Handler തിരികെ നൽകുന്നു. • ഒറിജിനൽ ഹാൻഡ്ലർ പ്രവർത്തിക്കുന്നതിന് മുൻപോ ശേഷമോ ചില കാര്യങ്ങൾ ചെയ്യുന്നു.
ഇതിനെ ഒരു ഉള്ളി പോലെ കരുതുക. ഓരോ പാളിയും അടുത്ത പാളിയെ പൊതിഞ്ഞുനിൽക്കുന്നു. റിക്വസ്റ്റ് ഉള്ളിലേക്ക് വരുമ്പോൾ ഓരോ പാളികളിലൂടെയും കടന്നുപോകുന്നു. റെസ്പോൺസ് (response) പുറത്തേക്ക് പോകുമ്പോഴും ഓരോ പാളികളിലൂടെയും കടന്നുപോകുന്നു.
നിങ്ങൾ പഠിക്കാൻ പോകുന്നത്:
• http.Handler ഇന്റർഫേസിന്റെ (interface) അടിസ്ഥാനം. • എങ്ങനെ പൂജ്യത്തിൽ നിന്ന് ഒരു കസ്റ്റം മിഡിൽവെയർ നിർമ്മിക്കാം. • എങ്ങനെ ഒന്നിലധികം പാളികളെ (layers) പരസ്പരം ബന്ധിപ്പിക്കാം (chain). • context ഉപയോഗിച്ച് എങ്ങനെ ഡാറ്റ ചെയിനിലൂടെ കൈമാറാം. • ഓർഡറിംഗ് (ordering), പാനിക് റിക്കവറി (panic recovery) തുടങ്ങിയ അഡ്വാൻസ്ഡ് ടിപ്പുകൾ.
പ്രധാന കാര്യങ്ങൾ:
• ക്രമം (Order) പ്രധാനമാണ്. ഒരു മിഡിൽവെയർ context-ൽ ഒരു വാല്യൂ സെറ്റ് ചെയ്യുന്നുണ്ടെങ്കിൽ, ചെയിനിലെ അടുത്ത മിഡിൽവെയർ അത് വായിക്കുന്നതാകണം. നിങ്ങൾ അവ പരസ്പരം മാറ്റിയാൽ, ഡാറ്റ ലഭിക്കില്ല (empty ആയിരിക്കും).
• നേരത്തെ തന്നെ എറർ കണ്ടെത്തിയാൽ ഉടൻ തന്നെ return ചെയ്യുക. നിങ്ങൾക്ക് ഒരു എറർ കണ്ടെത്തി http.Error അയച്ചാൽ, ഉടൻ തന്നെ return വിളിക്കുക. ഒരു എറർ അയച്ചതിന് ശേഷം നിങ്ങൾ next.ServeHTTP വിളിച്ചാൽ, നിങ്ങളുടെ സെർവർ പാനിക് (panic) ആകും.
• context കീകൾക്കായി കസ്റ്റം ടൈപ്പുകൾ (custom types) ഉപയോഗിക്കുക. കീകൾക്കായി വെറും സ്ട്രിംഗുകൾ (strings) ഉപയോഗിക്കരുത്. ഇത് വ്യത്യസ്ത പാക്കേജുകൾ പരസ്പരം ഡാറ്റ ഓവർറൈറ്റ് ചെയ്യുന്നത് തടയുന്നു.
• ഡാറ്റ ശേഖരിക്കാൻ ഒരു റാപ്പർ (wrapper) ഉപയോഗിക്കുക. സ്റ്റാൻഡേർഡ് http.ResponseWriter ഉപയോഗിച്ച് സ്റ്റാറ്റസ് കോഡ് (status code) എഴുതിക്കഴിഞ്ഞാൽ അത് വീണ്ടും വായിക്കാൻ കഴിയില്ല. അതിനാൽ, ലോഗുകൾക്കായി അത് തടഞ്ഞുനിർത്തി (intercept) സേവ് ചെയ്യാൻ നിങ്ങൾ ഒരു കസ്റ്റം സ്ട്രക്ചർ (custom struct) നിർമ്മിക്കേണ്ടതുണ്ട്.
ഈ പാറ്റേണുകൾ പഠിച്ചുകൊണ്ട് നിങ്ങളുടെ Go HTTP സെർവറുകൾക്കായി ശക്തമായ ഒരു അടിത്തറ പാകുക.