Node.js ನಲ್ಲಿ AsyncLocalStorage ಮೂಲಕ ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ ನಿರ್ವಹಣೆಯಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ ಪಡೆಯಿರಿ. ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್ ಅನ್ನು ನಿವಾರಿಸಿ ಮತ್ತು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಸ್ವಚ್ಛ ಹಾಗೂ ಹೆಚ್ಚು ಗಮನಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುವುದು: ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ನ ಆಳವಾದ ಅವಲೋಕನ
ಆಧುನಿಕ ಸರ್ವರ್-ಸೈಡ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಜಗತ್ತಿನಲ್ಲಿ, ಸ್ಟೇಟ್ (ಸ್ಥಿತಿ) ನಿರ್ವಹಣೆ ಒಂದು ಮೂಲಭೂತ ಸವಾಲಾಗಿದೆ. Node.js ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಅದರ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್, ನಾನ್-ಬ್ಲಾಕಿಂಗ್, ಅಸಿಂಕ್ರೊನಸ್ ಸ್ವಭಾವದಿಂದ ಈ ಸವಾಲು ಮತ್ತಷ್ಟು ಹೆಚ್ಚಾಗುತ್ತದೆ. ಈ ಮಾದರಿಯು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ, I/O-ಬೌಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಇದು ಒಂದು ವಿಶಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ: ಮಿಡಲ್‌ವೇರ್‌ನಿಂದ ಹಿಡಿದು ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿಗಳು ಮತ್ತು ಥರ್ಡ್-ಪಾರ್ಟಿ API ಕಾಲ್‌ಗಳವರೆಗೆ, ವಿವಿಧ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಮೂಲಕ ಹಾದುಹೋಗುವಾಗ ಒಂದು ನಿರ್ದಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್‌ನ ಕಾಂಟೆಕ್ಸ್ಟ್ (ಸಂದರ್ಭ) ಅನ್ನು ನೀವು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತೀರಿ? ಒಬ್ಬ ಬಳಕೆದಾರರ ರಿಕ್ವೆಸ್ಟ್‌ನ ಡೇಟಾ ಇನ್ನೊಬ್ಬರ ರಿಕ್ವೆಸ್ಟ್‌ಗೆ ಸೋರಿಕೆಯಾಗದಂತೆ ನೀವು ಹೇಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೀರಿ?
ವರ್ಷಗಳಿಂದ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮುದಾಯವು ಈ ಸಮಸ್ಯೆಯೊಂದಿಗೆ ಹೋರಾಡುತ್ತಿತ್ತು, ಆಗಾಗ್ಗೆ 'ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್' ನಂತಹ ತೊಡಕಿನ ಮಾದರಿಗಳನ್ನು ಆಶ್ರಯಿಸುತ್ತಿತ್ತು - ಅಂದರೆ, ಬಳಕೆದಾರರ ಐಡಿ ಅಥವಾ ಟ್ರೇಸ್ ಐಡಿಯಂತಹ ರಿಕ್ವೆಸ್ಟ್-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಕಾಲ್ ಚೈನ್‌ನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಫಂಕ್ಷನ್‌ಗೂ ರವಾನಿಸುವುದು. ಈ ವಿಧಾನವು ಕೋಡ್ ಅನ್ನು ಗೊಂದಲಮಯವಾಗಿಸುತ್ತದೆ, ಮಾಡ್ಯೂಲ್‌ಗಳ ನಡುವೆ ಬಿಗಿಯಾದ ಕಪ್ಲಿಂಗ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ನಿರಂತರ ದುಃಸ್ವಪ್ನವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.
ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್, ಈ ದೀರ್ಘಕಾಲದ ಸಮಸ್ಯೆಗೆ ಒಂದು ದೃಢವಾದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುವ ಪರಿಕಲ್ಪನೆ. Node.js ನಲ್ಲಿ ಸ್ಥಿರವಾದ AsyncLocalStorage API ಯ ಪರಿಚಯದೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು ಈಗ ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸೊಗಸಾಗಿ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಯುತ, ಅಂತರ್ನಿರ್ಮಿತ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಹೊಂದಿದ್ದಾರೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯು ನಿಮ್ಮನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಜಗತ್ತಿನಲ್ಲಿ ಒಂದು ಸಮಗ್ರ ಪ್ರಯಾಣಕ್ಕೆ ಕರೆದೊಯ್ಯುತ್ತದೆ, ಸಮಸ್ಯೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ, ಪರಿಹಾರವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ ಮತ್ತು ಜಾಗತಿಕ ಬಳಕೆದಾರರಿಗಾಗಿ ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ಗಮನಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಪ್ರಾಯೋಗಿಕ, ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಕೋರ್ ಸವಾಲು: ಕನ್‌ಕರೆಂಟ್, ಅಸಿಂಕ್ರೊನಸ್ ಜಗತ್ತಿನಲ್ಲಿ ಸ್ಟೇಟ್
ಪರಿಹಾರವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನಾವು ಮೊದಲು ಸಮಸ್ಯೆಯ ಆಳವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. Node.js ಸರ್ವರ್ ಸಾವಿರಾರು ಕನ್‌ಕರೆಂಟ್ ರಿಕ್ವೆಸ್ಟ್‌ಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ. ರಿಕ್ವೆಸ್ಟ್ A ಬಂದಾಗ, Node.js ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು, ನಂತರ ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿ ಪೂರ್ಣಗೊಳ್ಳಲು ಕಾಯಲು ವಿರಾಮಗೊಳಿಸಬಹುದು. ಅದು ಕಾಯುತ್ತಿರುವಾಗ, ಅದು ರಿಕ್ವೆಸ್ಟ್ B ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದರ ಮೇಲೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ರಿಕ್ವೆಸ್ಟ್ A ಗಾಗಿ ಡೇಟಾಬೇಸ್ ಫಲಿತಾಂಶ ಬಂದ ನಂತರ, Node.js ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಪುನರಾರಂಭಿಸುತ್ತದೆ. ಈ ನಿರಂತರ ಕಾಂಟೆಕ್ಸ್ಟ್ ಸ್ವಿಚಿಂಗ್ ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯ ಹಿಂದಿನ ಮ್ಯಾಜಿಕ್ ಆಗಿದೆ, ಆದರೆ ಇದು ಸಾಂಪ್ರದಾಯಿಕ ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ತಂತ್ರಗಳನ್ನು ಹಾಳುಮಾಡುತ್ತದೆ.
ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್‌ಗಳು ಏಕೆ ವಿಫಲವಾಗುತ್ತವೆ
ಒಬ್ಬ ಅನನುಭವಿ ಡೆವಲಪರ್‌ನ ಮೊದಲ ಪ್ರವೃತ್ತಿ ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸುವುದು ಆಗಿರಬಹುದು. ಉದಾಹರಣೆಗೆ:
let currentUser; // ಒಂದು ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್
// ಬಳಕೆದಾರರನ್ನು ಸೆಟ್ ಮಾಡಲು ಮಿಡಲ್‌ವೇರ್
app.use((req, res, next) => {
currentUser = await getUserFromDb(req.headers.authorization);
next();
});
// ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಆಳವಾಗಿರುವ ಒಂದು ಸರ್ವಿಸ್ ಫಂಕ್ಷನ್
function logActivity() {
console.log(`Activity for user: ${currentUser.id}`);
}
ಕನ್‌ಕರೆಂಟ್ ಪರಿಸರದಲ್ಲಿ ಇದು ಒಂದು ವಿನಾಶಕಾರಿ ವಿನ್ಯಾಸ ದೋಷವಾಗಿದೆ. ರಿಕ್ವೆಸ್ಟ್ A currentUser ಅನ್ನು ಸೆಟ್ ಮಾಡಿ ನಂತರ ಒಂದು ಅಸಿಂಕ್ ಕಾರ್ಯಾಚರಣೆಗಾಗಿ ಕಾಯುತ್ತಿದ್ದರೆ, ರಿಕ್ವೆಸ್ಟ್ B ಬಂದು, ರಿಕ್ವೆಸ್ಟ್ A ಮುಗಿಯುವ ಮೊದಲೇ currentUser ಅನ್ನು ಓವರ್‌ರೈಟ್ ಮಾಡಬಹುದು. ರಿಕ್ವೆಸ್ಟ್ A ಪುನರಾರಂಭಗೊಂಡಾಗ, ಅದು ತಪ್ಪಾಗಿ ರಿಕ್ವೆಸ್ಟ್ B ಯ ಡೇಟಾವನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಅನಿರೀಕ್ಷಿತ ಬಗ್‌ಗಳು, ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರ, ಮತ್ತು ಭದ್ರತಾ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್‌ಗಳು ರಿಕ್ವೆಸ್ಟ್-ಸೇಫ್ ಅಲ್ಲ.
ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್‌ನ ನೋವು
ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾದ, ಮತ್ತು ಸುರಕ್ಷಿತವಾದ, ಪರಿಹಾರವೆಂದರೆ "ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್" ಅಥವಾ "ಪ್ಯಾರಾಮೀಟರ್ ಪಾಸಿಂಗ್". ಇದರಲ್ಲಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಅಗತ್ಯವಿರುವ ಪ್ರತಿಯೊಂದು ಫಂಕ್ಷನ್‌ಗೆ ಒಂದು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸಲಾಗುತ್ತದೆ.
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಲಾಗಿಂಗ್‌ಗಾಗಿ ಒಂದು ವಿಶಿಷ್ಟ traceId ಮತ್ತು ದೃಢೀಕರಣಕ್ಕಾಗಿ user ಆಬ್ಜೆಕ್ಟ್ ಬೇಕು ಎಂದು ಭಾವಿಸೋಣ.
ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್‌ನ ಉದಾಹರಣೆ:
// 1. ಎಂಟ್ರಿ ಪಾಯಿಂಟ್: ಮಿಡಲ್‌ವೇರ್
app.use((req, res, next) => {
const traceId = generateTraceId();
const user = { id: 'user-123', locale: 'en-GB' };
const requestContext = { traceId, user };
processOrder(requestContext, req.body.orderId);
});
// 2. ಬಿಸಿನೆಸ್ ಲಾಜಿಕ್ ಲೇಯರ್
function processOrder(context, orderId) {
log('Processing order', context);
const orderDetails = getOrderDetails(context, orderId);
// ... ಹೆಚ್ಚಿನ ಲಾಜಿಕ್
}
// 3. ಡೇಟಾ ಆಕ್ಸೆಸ್ ಲೇಯರ್
function getOrderDetails(context, orderId) {
log(`Fetching order ${orderId}`, context);
return db.query('SELECT * FROM orders WHERE id = ?', orderId);
}
// 4. ಯುಟಿಲಿಟಿ ಲೇಯರ್
function log(message, context) {
console.log(`[${context.traceId}] [User: ${context.user.id}] - ${message}`);
}
ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕನ್‌ಕರೆನ್ಸಿ ಸಮಸ್ಯೆಗಳಿಂದ ಸುರಕ್ಷಿತವಾಗಿದೆ, ಆದರೆ ಇದರಲ್ಲಿ ಗಮನಾರ್ಹ ಅನಾನುಕೂಲತೆಗಳಿವೆ:
- ಕೋಡ್ ಗೊಂದಲ:
contextಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಎಲ್ಲೆಡೆ ರವಾನಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ನೇರವಾಗಿ ಬಳಸದ ಆದರೆ ತಾನು ಕರೆಯುವ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಅದನ್ನು ರವಾನಿಸಬೇಕಾದ ಫಂಕ್ಷನ್‌ಗಳ ಮೂಲಕವೂ ಸಹ. - ಬಿಗಿಯಾದ ಕಪ್ಲಿಂಗ್: ಪ್ರತಿಯೊಂದು ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್ ಈಗ
contextಆಬ್ಜೆಕ್ಟ್‌ನ ಆಕಾರಕ್ಕೆ ಜೋಡಿಸಲ್ಪಟ್ಟಿದೆ. ನೀವು ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗೆ ಹೊಸ ಡೇಟಾವನ್ನು ಸೇರಿಸಬೇಕಾದರೆ (ಉದಾಹರಣೆಗೆ, A/B ಟೆಸ್ಟಿಂಗ್ ಫ್ಲ್ಯಾಗ್), ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ಡಜನ್‌ಗಟ್ಟಲೆ ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್‌ಗಳನ್ನು ನೀವು ಮಾರ್ಪಡಿಸಬೇಕಾಗಬಹುದು. - ಕಡಿಮೆ ಓದಬಲ್ಲತೆ: ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ರವಾನಿಸುವ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್‌ನಿಂದ ಫಂಕ್ಷನ್‌ನ ಪ್ರಾಥಮಿಕ ಉದ್ದೇಶವು ಮಸುಕಾಗಬಹುದು.
- ನಿರ್ವಹಣಾ ಹೊರೆ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಒಂದು ಬೇಸರದ ಮತ್ತು ದೋಷಪೂರಿತ ಪ್ರಕ್ರಿಯೆಯಾಗುತ್ತದೆ.
ನಮಗೆ ಉತ್ತಮವಾದ ಮಾರ್ಗ ಬೇಕಿತ್ತು. ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸದೆ, ರಿಕ್ವೆಸ್ಟ್-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ, ಆ ರಿಕ್ವೆಸ್ಟ್‌ನ ಅಸಿಂಕ್ರೊನಸ್ ಕಾಲ್ ಚೈನ್‌ನೊಳಗಿನ ಎಲ್ಲಿಂದಲಾದರೂ ಪ್ರವೇಶಿಸಬಹುದಾದ "ಮಾಂತ್ರಿಕ" ಕಂಟೇನರ್ ಹೊಂದುವ ಮಾರ್ಗ.
`AsyncLocalStorage` ಪರಿಚಯ: ಆಧುನಿಕ ಪರಿಹಾರ
AsyncLocalStorage ಕ್ಲಾಸ್, Node.js v13.10.0 ರಿಂದ ಸ್ಥಿರವಾದ ಫೀಚರ್, ಈ ಸಮಸ್ಯೆಗೆ ಅಧಿಕೃತ ಉತ್ತರವಾಗಿದೆ. ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಎಂಟ್ರಿ ಪಾಯಿಂಟ್‌ನಿಂದ ಪ್ರಾರಂಭವಾದ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಪೂರ್ಣ ಸರಣಿಯಾದ್ಯಂತ ಉಳಿಯುವ ಪ್ರತ್ಯೇಕ ಸ್ಟೋರೇಜ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ನೀವು ಇದನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಸಿಂಕ್ರೊನಸ್, ಈವೆಂಟ್-ಡ್ರಿವನ್ ಜಗತ್ತಿಗೆ "ಥ್ರೆಡ್-ಲೋಕಲ್ ಸ್ಟೋರೇಜ್" ನ ಒಂದು ರೂಪವೆಂದು ಯೋಚಿಸಬಹುದು. ನೀವು AsyncLocalStorage ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಆ ಹಂತದಿಂದ ಕರೆಯಲ್ಪಡುವ ಯಾವುದೇ ಫಂಕ್ಷನ್ - ಸಿಂಕ್ರೊನಸ್, ಕಾಲ್‌ಬ್ಯಾಕ್-ಆಧಾರಿತ, ಅಥವಾ ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ - ಆ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
ಕೋರ್ API ಪರಿಕಲ್ಪನೆಗಳು
API ಗಮನಾರ್ಹವಾಗಿ ಸರಳ ಮತ್ತು ಶಕ್ತಿಯುತವಾಗಿದೆ. ಇದು ಮೂರು ಪ್ರಮುಖ ಮೆಥಡ್‌ಗಳ ಸುತ್ತ ಸುತ್ತುತ್ತದೆ:
new AsyncLocalStorage(): ಸ್ಟೋರ್‌ನ ಹೊಸ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತಿ ಪ್ರಕಾರದ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗೆ (ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ HTTP ರಿಕ್ವೆಸ್ಟ್‌ಗಳಿಗೆ ಒಂದು) ಒಂದು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಹಂಚಿಕೊಳ್ಳುತ್ತೀರಿ.als.run(store, callback): ಇದು ಮುಖ್ಯವಾದದ್ದು. ಇದು ಒಂದು ಫಂಕ್ಷನ್ (callback) ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೊಸ ಅಸಿಂಕ್ರೊನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್,store, ಆ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ನೀವು ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡಲು ಬಯಸುವ ಡೇಟಾ. ಅಸಿಂಕ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಸೇರಿದಂತೆ,callbackಒಳಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಯಾವುದೇ ಕೋಡ್ ಈstoreಅನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.als.getStore(): ಈ ಮೆಥಡ್ ಅನ್ನು ಪ್ರಸ್ತುತ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಿಂದ ಡೇಟಾವನ್ನು (store) ಹಿಂಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ.run()ನಿಂದ ಸ್ಥಾಪಿತವಾದ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ಹೊರಗೆ ಕರೆದರೆ, ಇದುundefinedಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
ಪ್ರಾಯೋಗಿಕ ಅನುಷ್ಠಾನ: ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿ
ನಮ್ಮ ಹಿಂದಿನ ಪ್ರಾಪ್-ಡ್ರಿಲ್ಲಿಂಗ್ ಉದಾಹರಣೆಯನ್ನು AsyncLocalStorage ಬಳಸಿ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡೋಣ. ನಾವು ಸಾಮಾನ್ಯ Express.js ಸರ್ವರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದರೆ ಈ ತತ್ವವು ಯಾವುದೇ Node.js ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗೆ ಅಥವಾ ಸ್ಥಳೀಯ http ಮಾಡ್ಯೂಲ್‌ಗೆ ಒಂದೇ ಆಗಿರುತ್ತದೆ.
ಹಂತ 1: ಕೇಂದ್ರೀಯ `AsyncLocalStorage` ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸಿ
ನಿಮ್ಮ ಸ್ಟೋರ್‌ನ ಒಂದೇ, ಹಂಚಿದ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಬಳಸಲು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ. asyncContext.js ಎಂಬ ಫೈಲ್ ಅನ್ನು ರಚಿಸೋಣ.
// asyncContext.js
import { AsyncLocalStorage } from 'async_hooks';
export const requestContextStore = new AsyncLocalStorage();
ಹಂತ 2: ಮಿಡಲ್‌ವೇರ್‌ನೊಂದಿಗೆ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ
ರಿಕ್ವೆಸ್ಟ್‌ನ ಜೀವನಚಕ್ರದ ಆರಂಭದಲ್ಲಿಯೇ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸೂಕ್ತವಾದ ಸ್ಥಳವಾಗಿದೆ. ಮಿಡಲ್‌ವೇರ್ ಇದಕ್ಕೆ ಪರಿಪೂರ್ಣವಾಗಿದೆ. ನಾವು ನಮ್ಮ ರಿಕ್ವೆಸ್ಟ್-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಉಳಿದ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಲಾಜಿಕ್ ಅನ್ನು als.run() ಒಳಗೆ ಸುತ್ತುತ್ತೇವೆ.
// server.js
import express from 'express';
import { requestContextStore } from './asyncContext.js';
import { v4 as uuidv4 } from 'uuid'; // ವಿಶಿಷ್ಟವಾದ traceId ಅನ್ನು ರಚಿಸಲು
const app = express();
// ಮ್ಯಾಜಿಕ್ ಮಿಡಲ್‌ವೇರ್
app.use((req, res, next) => {
const traceId = req.headers['x-request-id'] || uuidv4();
const user = { id: 'user-123', locale: 'en-GB' }; // ನಿಜವಾದ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ಇದು auth ಮಿಡಲ್‌ವೇರ್‌ನಿಂದ ಬರುತ್ತದೆ
const store = { traceId, user };
// ಈ ರಿಕ್ವೆಸ್ಟ್‌ಗಾಗಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ
requestContextStore.run(store, () => {
next();
});
});
// ... ನಿಮ್ಮ ರೂಟ್‌ಗಳು ಮತ್ತು ಇತರ ಮಿಡಲ್‌ವೇರ್‌ಗಳು ಇಲ್ಲಿ ಬರುತ್ತವೆ
ಈ ಮಿಡಲ್‌ವೇರ್‌ನಲ್ಲಿ, ಪ್ರತಿ ಒಳಬರುವ ರಿಕ್ವೆಸ್ಟ್‌ಗಾಗಿ, ನಾವು traceId ಮತ್ತು user ಅನ್ನು ಒಳಗೊಂಡಿರುವ store ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು requestContextStore.run(store, ...) ಅನ್ನು ಕರೆಯುತ್ತೇವೆ. ಒಳಗಿರುವ next() ಕಾಲ್, ಈ ನಿರ್ದಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್‌ಗಾಗಿ ಎಲ್ಲಾ ನಂತರದ ಮಿಡಲ್‌ವೇರ್‌ಗಳು ಮತ್ತು ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಈ ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನೊಳಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಹಂತ 3: ಎಲ್ಲಿಯಾದರೂ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿ, ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್ ಇಲ್ಲದೆ
ಈಗ, ನಮ್ಮ ಇತರ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಮೂಲಾಗ್ರವಾಗಿ ಸರಳಗೊಳಿಸಬಹುದು. ಅವರಿಗೆ ಇನ್ನು ಮುಂದೆ context ಪ್ಯಾರಾಮೀಟರ್ ಅಗತ್ಯವಿಲ್ಲ. ಅವರು ನಮ್ಮ requestContextStore ಅನ್ನು ಸರಳವಾಗಿ ಇಂಪೋರ್ಟ್ ಮಾಡಿ getStore() ಅನ್ನು ಕರೆಯಬಹುದು.
ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಿದ ಲಾಗಿಂಗ್ ಯುಟಿಲಿಟಿ:
// logger.js
import { requestContextStore } from './asyncContext.js';
export function log(message) {
const context = requestContextStore.getStore();
if (context) {
const { traceId, user } = context;
console.log(`[${traceId}] [User: ${user.id}] - ${message}`);
} else {
// ರಿಕ್ವೆಸ್ಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ಹೊರಗಿನ ಲಾಗ್‌ಗಳಿಗಾಗಿ ಫಾಲ್‌ಬ್ಯಾಕ್
console.log(`[NO_CONTEXT] - ${message}`);
}
}
ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಿದ ಬಿಸಿನೆಸ್ ಮತ್ತು ಡೇಟಾ ಲೇಯರ್‌ಗಳು:
// orderService.js
import { log } from './logger.js';
import * as db from './database.js';
export function processOrder(orderId) {
log('Processing order'); // ಕಾಂಟೆಕ್ಸ್ಟ್ ಅಗತ್ಯವಿಲ್ಲ!
const orderDetails = getOrderDetails(orderId);
// ... ಹೆಚ್ಚಿನ ಲಾಜಿಕ್
}
function getOrderDetails(orderId) {
log(`Fetching order ${orderId}`); // ಲಾಗರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
return db.query('SELECT * FROM orders WHERE id = ?', orderId);
}
ವ್ಯತ್ಯಾಸವು ಹಗಲು ಮತ್ತು ರಾತ್ರಿಯಷ್ಟಿದೆ. ಕೋಡ್ ನಾಟಕೀಯವಾಗಿ ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ಓದಬಲ್ಲದು, ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ರಚನೆಯಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಡಿಕಪಲ್ ಆಗಿದೆ. ನಮ್ಮ ಲಾಗಿಂಗ್ ಯುಟಿಲಿಟಿ, ಬಿಸಿನೆಸ್ ಲಾಜಿಕ್, ಮತ್ತು ಡೇಟಾ ಆಕ್ಸೆಸ್ ಲೇಯರ್‌ಗಳು ಈಗ ಶುದ್ಧವಾಗಿವೆ ಮತ್ತು ತಮ್ಮ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕೃತವಾಗಿವೆ. ನಾವು ನಮ್ಮ ರಿಕ್ವೆಸ್ಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗೆ ಹೊಸ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸಬೇಕಾದರೆ, ಅದನ್ನು ರಚಿಸುವ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಮಾತ್ರ ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ. ಬೇರೆ ಯಾವುದೇ ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್ ಅನ್ನು ಮುಟ್ಟುವ ಅಗತ್ಯವಿಲ್ಲ.
ಸುಧಾರಿತ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನ
ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಕೇವಲ ಲಾಗಿಂಗ್‌ಗಾಗಿ ಅಲ್ಲ. ಇದು ಅತ್ಯಾಧುನಿಕ, ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅಗತ್ಯವಾದ ವಿವಿಧ ಶಕ್ತಿಯುತ ಮಾದರಿಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುತ್ತದೆ.
1. ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಅಬ್ಸರ್ವಬಿಲಿಟಿ
ಮೈಕ್ರೋಸರ್ವಿಸಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿ, ಒಬ್ಬ ಬಳಕೆದಾರನ ಕ್ರಿಯೆಯು ಬಹು ಸೇವೆಗಳಾದ್ಯಂತ ರಿಕ್ವೆಸ್ಟ್‌ಗಳ ಸರಣಿಯನ್ನು ಪ್ರಚೋದಿಸಬಹುದು. ಸಮಸ್ಯೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು, ನೀವು ಈ ಸಂಪೂರ್ಣ ಪ್ರಯಾಣವನ್ನು ಟ್ರೇಸ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗಬೇಕು. AsyncLocalStorage ಆಧುನಿಕ ಟ್ರೇಸಿಂಗ್‌ನ ಮೂಲಾಧಾರವಾಗಿದೆ. ನಿಮ್ಮ API ಗೇಟ್‌ವೇಗೆ ಬರುವ ರಿಕ್ವೆಸ್ಟ್‌ಗೆ ಒಂದು ವಿಶಿಷ್ಟ traceId ಅನ್ನು ನಿಯೋಜಿಸಬಹುದು. ಈ ಐಡಿಯನ್ನು ನಂತರ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಸೇವೆಗಳಿಗೆ ಯಾವುದೇ ಹೊರಹೋಗುವ API ಕಾಲ್‌ಗಳಲ್ಲಿ (ಉದಾಹರಣೆಗೆ, HTTP ಹೆಡರ್ ಆಗಿ) ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಸೇವೆಯು ಇದನ್ನೇ ಮಾಡುತ್ತದೆ, ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪ್ರಸಾರ ಮಾಡುತ್ತದೆ. ಕೇಂದ್ರೀಕೃತ ಲಾಗಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ನಂತರ ಈ ಲಾಗ್‌ಗಳನ್ನು ಸೇವಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಸಿಸ್ಟಮ್‌ನಾದ್ಯಂತ ರಿಕ್ವೆಸ್ಟ್‌ನ ಎಂಡ್-ಟು-ಎಂಡ್ ಫ್ಲೋವನ್ನು ಪುನರ್ನಿರ್ಮಿಸಬಹುದು.
2. ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಮತ್ತು ಸ್ಥಳೀಕರಣ (l10n)
ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ, ದಿನಾಂಕಗಳು, ಸಮಯಗಳು, ಸಂಖ್ಯೆಗಳು, ಮತ್ತು ಕರೆನ್ಸಿಗಳನ್ನು ಬಳಕೆದಾರರ ಸ್ಥಳೀಯ ಸ್ವರೂಪದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸುವುದು ನಿರ್ಣಾಯಕ. ನೀವು ಬಳಕೆದಾರರ ಲೊಕೇಲ್ (ಉದಾ., 'fr-FR', 'ja-JP', 'en-US') ಅನ್ನು ಅವರ ರಿಕ್ವೆಸ್ಟ್ ಹೆಡರ್‌ಗಳಿಂದ ಅಥವಾ ಬಳಕೆದಾರರ ಪ್ರೊಫೈಲ್‌ನಿಂದ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗೆ ಸಂಗ್ರಹಿಸಬಹುದು.
// ಕರೆನ್ಸಿಯನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಒಂದು ಯುಟಿಲಿಟಿ
import { requestContextStore } from './asyncContext.js';
function formatCurrency(amount, currencyCode) {
const context = requestContextStore.getStore();
const locale = context?.user?.locale || 'en-US'; // ಡೀಫಾಲ್ಟ್‌ಗೆ ಫಾಲ್‌ಬ್ಯಾಕ್
return new Intl.NumberFormat(locale, {
style: 'currency',
currency: currencyCode,
}).format(amount);
}
// ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಆಳವಾಗಿ ಬಳಕೆ
const priceString = formatCurrency(199.99, 'EUR'); // ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬಳಕೆದಾರರ ಲೊಕೇಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ
ಇದು locale ವೇರಿಯಬಲ್ ಅನ್ನು ಎಲ್ಲೆಡೆ ರವಾನಿಸದೆ ಸ್ಥಿರವಾದ ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ.
3. ಡೇಟಾಬೇಸ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್
ಒಂದು ರಿಕ್ವೆಸ್ಟ್ ಬಹು ಡೇಟಾಬೇಸ್ ರೈಟ್‌ಗಳನ್ನು ಮಾಡಬೇಕಾದಾಗ ಮತ್ತು ಅವೆಲ್ಲವೂ ಒಟ್ಟಿಗೆ ಯಶಸ್ವಿಯಾಗಬೇಕು ಅಥವಾ ವಿಫಲವಾಗಬೇಕು, ನಿಮಗೆ ಒಂದು ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಬೇಕು. ನೀವು ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನ ಆರಂಭದಲ್ಲಿ ಒಂದು ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು, ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಕ್ಲೈಂಟ್ ಅನ್ನು ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು, ಮತ್ತು ನಂತರ ಆ ರಿಕ್ವೆಸ್ಟ್‌ನೊಳಗಿನ ಎಲ್ಲಾ ನಂತರದ ಡೇಟಾಬೇಸ್ ಕಾಲ್‌ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅದೇ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಕ್ಲೈಂಟ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. ಹ್ಯಾಂಡ್ಲರ್‌ನ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಫಲಿತಾಂಶವನ್ನು ಆಧರಿಸಿ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಕಮಿಟ್ ಅಥವಾ ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡಬಹುದು.
4. ಫೀಚರ್ ಟಾಗಲಿಂಗ್ ಮತ್ತು A/B ಟೆಸ್ಟಿಂಗ್
ರಿಕ್ವೆಸ್ಟ್‌ನ ಆರಂಭದಲ್ಲಿ ಒಬ್ಬ ಬಳಕೆದಾರನು ಯಾವ ಫೀಚರ್ ಫ್ಲ್ಯಾಗ್‌ಗಳಿಗೆ ಅಥವಾ A/B ಟೆಸ್ಟ್ ಗುಂಪುಗಳಿಗೆ ಸೇರಿದ್ದಾನೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬಹುದು ಮತ್ತು ಈ ಮಾಹಿತಿಯನ್ನು ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು. API ಲೇಯರ್‌ನಿಂದ ರೆಂಡರಿಂಗ್ ಲೇಯರ್‌ವರೆಗೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿವಿಧ ಭಾಗಗಳು ನಂತರ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿ ಯಾವ ಫೀಚರ್‌ನ ಆವೃತ್ತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಅಥವಾ ಯಾವ UI ಅನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು ಎಂದು ನಿರ್ಧರಿಸಬಹುದು, ಸಂಕೀರ್ಣ ಪ್ಯಾರಾಮೀಟರ್ ಪಾಸಿಂಗ್ ಇಲ್ಲದೆ ವೈಯಕ್ತಿಕಗೊಳಿಸಿದ ಅನುಭವವನ್ನು ಸೃಷ್ಟಿಸಬಹುದು.
ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ಒಂದು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಯೆಂದರೆ: ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್ ಏನು? Node.js ಕೋರ್ ತಂಡವು AsyncLocalStorage ಅನ್ನು ಹೆಚ್ಚು ದಕ್ಷವಾಗಿಸಲು ಗಮನಾರ್ಹ ಪ್ರಯತ್ನವನ್ನು ಹೂಡಿದೆ. ಇದು C++-ಮಟ್ಟದ async_hooks API ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ ಮತ್ತು V8 ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಂಜಿನ್‌ನೊಂದಿಗೆ ಆಳವಾಗಿ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಿದೆ. ಹೆಚ್ಚಿನ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮವು ನಗಣ್ಯವಾಗಿದೆ ಮತ್ತು ಕೋಡ್ ಗುಣಮಟ್ಟ ಮತ್ತು ನಿರ್ವಹಣೆಯಲ್ಲಿನ ಬೃಹತ್ ಲಾಭಗಳಿಂದ ಮೀರಿದೆ.
ಅದನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ:
- ಸಿಂಗಲ್ಟನ್ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಬಳಸಿ: ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ತೋರಿಸಿದಂತೆ, ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ರಿಕ್ವೆಸ್ಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗಾಗಿ ಒಂದೇ, ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡಿದ
AsyncLocalStorageಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸಿ. - ಎಂಟ್ರಿ ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ:
als.run()ಅನ್ನು ಕರೆಯಲು ಯಾವಾಗಲೂ ಉನ್ನತ-ಮಟ್ಟದ ಮಿಡಲ್‌ವೇರ್ ಅಥವಾ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನ ಆರಂಭವನ್ನು ಬಳಸಿ. ಇದು ನಿಮ್ಮ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗೆ ಸ್ಪಷ್ಟ ಮತ್ತು ಊಹಿಸಬಹುದಾದ ಗಡಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. - ಸ್ಟೋರ್ ಅನ್ನು ಬದಲಾಯಿಸಲಾಗದಂತೆ ಪರಿಗಣಿಸಿ: ಸ್ಟೋರ್ ಆಬ್ಜೆಕ್ಟ್ ಸ್ವತಃ ಮ್ಯೂಟಬಲ್ ಆಗಿದ್ದರೂ, ಅದನ್ನು ಇಮ್ಯೂಟಬಲ್ ಎಂದು ಪರಿಗಣಿಸುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸ. ನೀವು ರಿಕ್ವೆಸ್ಟ್ ಮಧ್ಯದಲ್ಲಿ ಡೇಟಾವನ್ನು ಸೇರಿಸಬೇಕಾದರೆ, ಮತ್ತೊಂದು
run()ಕಾಲ್‌ನೊಂದಿಗೆ ನೆಸ್ಟೆಡ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ರಚಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವಚ್ಛವಾಗಿರುತ್ತದೆ, ಆದರೂ ಇದು ಹೆಚ್ಚು ಸುಧಾರಿತ ಮಾದರಿಯಾಗಿದೆ. - ಕಾಂಟೆಕ್ಸ್ಟ್ ಇಲ್ಲದ ಪ್ರಕರಣಗಳನ್ನು ನಿಭಾಯಿಸಿ: ನಮ್ಮ ಲಾಗರ್‌ನಲ್ಲಿ ತೋರಿಸಿದಂತೆ, ನಿಮ್ಮ ಯುಟಿಲಿಟಿಗಳು ಯಾವಾಗಲೂ
getStore()undefinedಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಬೇಕು. ಇದು ರಿಕ್ವೆಸ್ಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ಹೊರಗೆ, ಉದಾಹರಣೆಗೆ ಹಿನ್ನೆಲೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಾರಂಭದ ಸಮಯದಲ್ಲಿ ರನ್ ಮಾಡಿದಾಗಲೂ ಸಲೀಸಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. - ದೋಷ ನಿರ್ವಹಣೆ ಸರಳವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್
Promiseಚೈನ್‌ಗಳು,.then()/.catch()/.finally()ಬ್ಲಾಕ್‌ಗಳು, ಮತ್ತುtry/catchಜೊತೆಗಿನasync/awaitಮೂಲಕ ಸರಿಯಾಗಿ ಪ್ರಸಾರವಾಗುತ್ತದೆ. ನೀವು ಏನನ್ನೂ ವಿಶೇಷವಾಗಿ ಮಾಡಬೇಕಾಗಿಲ್ಲ; ಒಂದು ದೋಷ ಎಸೆಯಲ್ಪಟ್ಟರೆ, ನಿಮ್ಮ ದೋಷ ನಿರ್ವಹಣಾ ಲಾಜಿಕ್‌ನಲ್ಲಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಲಭ್ಯವಿರುತ್ತದೆ.
ತೀರ್ಮಾನ: Node.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಒಂದು ಹೊಸ ಯುಗ
AsyncLocalStorage ಕೇವಲ ಒಂದು ಅನುಕೂಲಕರ ಯುಟಿಲಿಟಿಗಿಂತ ಹೆಚ್ಚಾಗಿದೆ; ಇದು ಸರ್ವರ್-ಸೈಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ಗೆ ಒಂದು ಮಾದರಿ ಬದಲಾವಣೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ಕನ್‌ಕರೆಂಟ್ ಪರಿಸರದಲ್ಲಿ ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ದೀರ್ಘಕಾಲದ ಸಮಸ್ಯೆಗೆ ಸ್ವಚ್ಛ, ದೃಢ, ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯುಳ್ಳ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಈ API ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು:
- ಪ್ರಾಪ್ ಡ್ರಿಲ್ಲಿಂಗ್ ಅನ್ನು ನಿವಾರಿಸಬಹುದು: ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ಕೇಂದ್ರೀಕೃತ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬರೆಯಿರಿ.
- ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಡಿಕಪಲ್ ಮಾಡಿ: ಅವಲಂಬನೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಸುಲಭಗೊಳಿಸಿ.
- ಅಬ್ಸರ್ವಬಿಲಿಟಿಯನ್ನು ಹೆಚ್ಚಿಸಿ: ಶಕ್ತಿಯುತ ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಚುವಲ್ ಲಾಗಿಂಗ್ ಅನ್ನು ಸುಲಭವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಿ.
- ಅತ್ಯಾಧುನಿಕ ಫೀಚರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಿ: ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಮತ್ತು ಅಂತರರಾಷ್ಟ್ರೀಕರಣದಂತಹ ಸಂಕೀರ್ಣ ಮಾದರಿಗಳನ್ನು ಸರಳಗೊಳಿಸಿ.
Node.js ನಲ್ಲಿ ಆಧುನಿಕ, ಸ್ಕೇಲೆಬಲ್, ಮತ್ತು ಜಾಗತಿಕ-ಅರಿವಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವುದು ಇನ್ನು ಮುಂದೆ ಐಚ್ಛಿಕವಲ್ಲ - ಇದು ಒಂದು ಅತ್ಯಗತ್ಯ ಕೌಶಲ್ಯವಾಗಿದೆ. ಹಳೆಯ ಮಾದರಿಗಳನ್ನು ಮೀರಿ AsyncLocalStorage ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದಕ್ಷವಾದ ಮಾತ್ರವಲ್ಲದೆ, ಆಳವಾಗಿ ಹೆಚ್ಚು ಸೊಗಸಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು.