𝗚𝗼 𝗛𝗧𝗧𝗣 𝗠𝗶𝗱𝗱𝗹𝗲𝘄𝗮𝗿𝗲 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱
ಪ್ರತಿ ಹ್ಯಾಂಡ್ಲರ್ಗೆ (handler) ಒಂದೇ ಕೋಡ್ ಅನ್ನು ಕಾಪಿ ಮತ್ತು ಪೇಸ್ಟ್ ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸಿ.
ನೀವು ಅಥೆಂಟಿಕೇಶನ್ (authentication) ಪರಿಶೀಲಿಸಬೇಕಾದರೆ, ರಿಕ್ವೆಸ್ಟ್ ಅವಧಿಯನ್ನು (request duration) ಲಾಗ್ ಮಾಡಬೇಕಾದರೆ ಅಥವಾ ಪ್ರತಿ ರಿಕ್ವೆಸ್ಟ್ಗೆ ವಿಶಿಷ್ಟ ID ಅನ್ನು ಸೇರಿಸಬೇಕಾದರೆ, ಆ ಲಾಜಿಕ್ ಅನ್ನು ನಿಮ್ಮ ಬಿಸಿನೆಸ್ ಹ್ಯಾಂಡ್ಲರ್ಗಳ ಒಳಗೆ ಬರೆಯಬೇಡಿ. ನಿಮ್ಮ ಬಳಿ 20 ಹ್ಯಾಂಡ್ಲರ್ಗಳಿದ್ದರೆ, ಅಥೆಂಟಿಕೇಶನ್ ಲಾಜಿಕ್ ಬದಲಾದಾಗ ನೀವು 20 ಕಡೆ ಅಪ್ಡೇಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದು ನಿರ್ವಹಣೆಯ ದೃಷ್ಟಿಯಿಂದ ದೊಡ್ಡ ತಲೆನೋವು (maintenance nightmare).
Middleware ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ನೀವು ಲಾಜಿಕ್ ಅನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಬರೆಯುತ್ತೀರಿ. ನಿಮ್ಮ ಹ್ಯಾಂಡ್ಲರ್ಗಳನ್ನು ನೀವು ಸುತ್ತುವರಿಯುತ್ತೀರಿ (wrap). ನಂತರ ನೀವು ಅದನ್ನು ಮತ್ತೆ ಮುಟ್ಟುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.
𝗪𝗵𝗮𝘁 𝗶𝘀 𝗠𝗶𝗱𝗱𝗹𝗲𝘄𝗮𝗿𝗲?
Go ನಲ್ಲಿ, middleware ಎಂಬುದು ಒಂದು ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಅದು: • http.Handler ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. • ಹೊಸ http.Handler ಅನ್ನು ಮರಳಿಸುತ್ತದೆ. • ಮೂಲ ಹ್ಯಾಂಡ್ಲರ್ ಚಲಿಸುವ ಮೊದಲು ಅಥವಾ ನಂತರ ಕ್ರಮಗಳನ್ನು (actions) ನಿರ್ವಹಿಸುತ್ತದೆ.
ಇದನ್ನು ಒಂದು ಉಳ್ಳಿಕಾಯಿಯಂತೆ (onion) ಭಾವಿಸಿ. ಪ್ರತಿ ಪದರವು ಮುಂದಿನ ಪದರವನ್ನು ಸುತ್ತುವರಿಯುತ್ತದೆ. ರಿಕ್ವೆಸ್ಟ್ ಒಳಗೆ ಬರುವಾಗ ಪ್ರತಿ ಪದರವನ್ನು ದಾಟುತ್ತದೆ. ರೆಸ್ಪಾನ್ಸ್ (response) ಹೊರಗೆ ಹೋಗುವಾಗ ಪ್ರತಿ ಪದರವನ್ನು ದಾಟುತ್ತದೆ.
𝗪𝗵𝗮𝘁 𝘆𝗼𝘂 𝘄𝗶𝗹𝗹 𝗹𝗲𝗮𝗿𝗻:
• http.Handler ಇಂಟರ್ಫೇಸ್ನ ಅಡಿಪಾಯ. • ಮೊದಲಿನಿಂದම (from scratch) ಕಸ್ಟಮ್ middleware ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು. • ಅನೇಕ ಪದರಗಳನ್ನು ಒಟ್ಟಿಗೆ ಹೇಗೆ ಜೋಡಿಸುವುದು (chain). • context ಬಳಸಿ ಚೈನ್ ಮೂಲಕ ಡೇಟಾವನ್ನು ಹೇಗೆ ವರ್ಗಾಯಿಸುವುದು. • ಆರ್ಡರಿಂಗ್ (ordering) ಮತ್ತು ಪ್ಯಾನಿಕ್ ರಿಕವರಿ (panic recovery) ನಂತಹ ಸುಧಾರಿತ ಸಲಹೆಗಳು.
𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀:
• ಕ್ರಮ (Order) ಮುಖ್ಯವಾಗುತ್ತದೆ. ಒಂದು middleware context ನಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಸೆಟ್ ಮಾಡಿದರೆ, ಚೈನ್ನಲ್ಲಿರುವ ಮುಂದಿನ middleware ಅದನ್ನು ಓದಬೇಕಾಗುತ್ತದೆ. ನೀವು ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಿದರೆ, ಡೇಟಾ ಖಾಲಿಯಾಗಿರುತ್ತದೆ.
• ಮುಂಚಿತವಾಗಿ ಹೊರಬರುವಾಗ (early exit) ಯಾವಾಗಲೂ return ಬಳಸಿ. ನೀವು ದೋಷವನ್ನು (error) ಪತ್ತೆಹಚ್ಚಿ http.Error ಅನ್ನು ಕಳುಹಿಸಿದರೆ, ತಕ್ಷಣವೇ return ಕರೆಯಿರಿ. ದೋಷವನ್ನು ಕಳುಹಿಸಿದ ನಂತರ ನೀವು next.ServeHTTP ಅನ್ನು ಕರೆಯಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ನಿಮ್ಮ ಸರ್ವರ್ ಪ್ಯಾನಿಕ್ (panic) ಆಗುತ್ತದೆ.
• context ಕೀಸ್ಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ಟೈಪ್ಗಳನ್ನು ಬಳಸಿ. ಕೀಸ್ಗಳಿಗಾಗಿ ಸಾಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು (plain strings) ಬಳಸಬೇಡಿ. ಇದು ವಿವಿಧ ಪ್ಯಾಕೇಜ್ಗಳು ಪರಸ್ಪರ ಡೇಟಾವನ್ನು ಅಳಿಸಿಹಾಕದಂತೆ ತಡೆಯುತ್ತದೆ.
• ಡೇಟಾವನ್ನು ಸೆರೆಹಿಡಿಯಲು (capture) ಒಂದು wrapper ಬಳಸಿ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ http.ResponseWriter ಬರೆದ ನಂತರ ಸ್ಟೇಟಸ್ ಕೋಡ್ ಅನ್ನು ಓದಲು ನಿಮಗೆ ಅನುಮತಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಲಾಗ್ಗಳಿಗಾಗಿ ಅದನ್ನು ಅಡ್ಡಗಟ್ಟಲು (intercept) ಮತ್ತು ಉಳಿಸಲು ನೀವು ಕಸ್ಟಮ್ struct ಅನ್ನು ರಚಿಸಬೇಕು.
ಈ ಮಾದರಿಗಳನ್ನು (patterns) ಕಲಿಯುವ ಮೂಲಕ ನಿಮ್ಮ Go HTTP ಸರ್ವರ್ಗಳಿಗಾಗಿ ಒಂದು ಭದ್ರವಾದ ಅಡಿಪಾಯವನ್ನು ನಿರ್ಮಿಸಿ.