🖖🏻 🤮 🐾 मूल Node.JS एक्सप्रेस का उपयोग कर आवेदन 🤧 🆚 🌡️

सभी को नमस्कार।
मैं एक्सप्रेस के उपयोग से एक मूल नोड.जेएस एप्लिकेशन बनाने के तरीके के बारे में एक लेख की तलाश कर रहा था, अधिक सटीक रूप से, एक परियोजना की मूल संरचना क्या होनी चाहिए, लेकिन मेरे लिए समान कुछ भी नहीं मिला।
इसलिए, मैंने अपना खुद का लिखने का फैसला किया, उसी तरह समझाने के लिए कि मैं यह कैसे करूं और यह कैसे दिखना चाहिए।

कट के तहत विवरण। ध्यान से। पाठ और कोड के बहुत सारे।

शुरू करने से पहले, मैं यह नोट करना चाहता हूं कि यह मेरा पहला लेख है। शायद मैं कुछ को ध्यान में नहीं रखूंगा, या इसके विपरीत, मैं कुछ पर अधिक ध्यान केंद्रित करूंगा, मैं लेख पर सुधार और स्पष्टीकरण के साथ-साथ दृष्टिकोण पर भी आभारी रहूंगा।

कार्य निम्नानुसार था: एक मूल एप्लिकेशन बनाने के लिए जो अनुरोधों को संसाधित कर सकता है और सही पृष्ठों को प्रदर्शित कर सकता है, या अनुरोधों के सही उत्तर दे सकता है।

So. आइए आवेदन के अंदर उपयोग किए जाने वाले मॉड्यूल से शुरू करें:

express -  ,   http- mongoose - ,     MongoDB mongodb - native-driver    MongoDB  connect-mongo -    express  session node-uuid -      (   -) async -      ,  Promise ejs-locals -  ,     nconf -       ( config.json) string -      ,      ,  html    validator -   winston -

प्रत्येक मॉड्यूल को कमांड का उपयोग करके स्थापित किया जा सकता है:
npm स्थापित करें << मॉड्यूल_name >> -save

- अन्य मशीनों पर एप्लिकेशन की आगे तैनाती के लिए निर्भरता (पैकेज.जसन) में मॉड्यूल को बचाने के लिए सेव की आवश्यकता है।

आवेदन की संरचना इस प्रकार है:

  /config config.json index.js /middleware checkAuth.js errorHandler.js index.js /models user.js /public /*JS, CSS, HTML static files*/ /routes authentication.js error.js index.js main.js register.js /utils index.js log.js mongoose.js validate.js /views index.ejs manage.js package.json server.js

अब, वास्तव में, मैं समझाऊंगा कि प्रत्येक निर्देशिका और उसकी लिपियों का नमक क्या है।
आइए सबसे महत्वपूर्ण स्क्रिप्ट के साथ शुरू करें जो हमारे पूरे आवेदन को आरंभ करता है।

server.js

 var express = require('express'), http = require('http'), app = express(), middleware = require('./middleware')(app, express), config = require('./config'), log = require('./utils/log')(app, module); http.createServer(app).listen(config.get('port'), function(){ log.info('Express server listening on port ' + config.get('port')); });

Server.js में हम एपेक्स्रेस ऐप बनाते हैं, मिडिलवेयर मॉड्यूल को कनेक्ट करते हैं, जिसमें सभी आवश्यक मिडलवेयर एप्लिकेशन जुड़े होते हैं।
अगला, हम एक सर्वर बनाते हैं जो सभी निर्दिष्ट कनेक्शनों को कॉन्फ़िगर में निर्दिष्ट पोर्ट के माध्यम से संसाधित करेगा।

package.json

 { "name": "test_express_app", "version": "0.0.1", "private": true, "scripts": { "start": "node server.js" }, "dependencies": { "express": "~3.4.6", "mongoose": "~3.8.1", "node-uuid": "~1.4.1", "nconf": "~0.6.9", "winston": "~0.7.2", "async": "~0.2.9", "mongodb": "~1.3.22", "ejs-locals": "~1.0.2", "connect-mongo": "~0.4.0", "validator": "~2.0.0", "string": "~1.7.0" } }

इसमें परियोजना के बारे में सभी आवश्यक जानकारी, साथ ही सभी आवश्यक पैकेज शामिल हैं।

manage.js

 var mongoose = require('./utils/mongoose'), async = require('async'), User = require('./models/user'), log = require('./utils/log')(null, module), config = require('./config'); function openConnection(cb) { mongoose.connection.on('open', function () { log.info('connected to database ' + config.get('db:name')); cb(); }); } function dropDatabase(cb) { var db = mongoose.connection.db; db.dropDatabase(function () { log.info('dropped database ' + config.get('db:name')); cb(); }); } function createBaseUser(cb) { var admin = new User({ username: 'admin', password: config.get('project:admin:password'), email: config.get('project:admin:email'), role: 1 }); admin.save(function () { log.info('created database ' + config.get('db:name')); log.info('created base admin user'); cb(); }); } function ensureIndexes(cb) { async.each(Object.keys(mongoose.models), function (model, callback) { mongoose.models[model].ensureIndexes(callback); }, function () { log.info('indexes ensured completely'); cb(); }); } function closeConnection() { mongoose.disconnect(); log.info('disconnected'); } async.series( [ openConnection, dropDatabase, createBaseUser, ensureIndexes ], closeConnection );

डेटाबेस को प्रारंभ करना आवश्यक है, डिफ़ॉल्ट जानकारी भरना जिसके साथ सर्वर संचालित होगा।

config

config.json

 { "port": 3000, "db": { "connection": "mongodb://localhost", "name": "db_name", "options": { "server": { "socketOptions": { "keepAlive": 1 } } } }, "session": { "secret": "secret_key", "key": "cid", "cookie": { "path": "/", "httpOnly": true, "maxAge": null } } }

index.js

 var nconf = require('nconf'); var path = require('path'); nconf.argv() .env() .file({file: path.join(__dirname, 'config.json')}); module.exports = nconf;

Config.js फ़ाइल में डेटाबेस से जुड़ने के लिए सेटिंग्स और साथ ही सत्र सेटिंग्स के बारे में जानकारी होती है।
कॉन्फ़िगरेशन के साथ काम करने के लिए, nconf पैकेज का उपयोग किया जाता है , जो आपको गेट और सेटर के माध्यम से सेटिंग्स ऑब्जेक्ट को हेरफेर करने की अनुमति देता है। आप प्रतीक के माध्यम से नेस्टेड वस्तुओं का उपयोग भी कर सकते हैं ::

 config.get('session:secret'); config.get('session:cookie:path');

मिडलवेयर

 module.exports = function (app, express) { var ejs = require('ejs-locals'), path = require('path'), config = require('../config'), mongoose = require('../utils/mongoose'), MongoStore = require('connect-mongo')(express), router = require('../routes'), errorHandler = require('./errorHandler')(app, express), checkAuth = require('./checkAuth'); /** * Page Rendering * */ app.engine('html', ejs); app.engine('ejs', ejs); app.set('views', path.join(__dirname, '../views')); app.set('view engine', 'ejs'); /** * Favicon * */ app.use(express.favicon('public/images/favicon.ico')); /** * Logger * */ if (app.get('env') == 'development') { app.use(express.logger('dev')); } /** * Session * */ app.use(express.bodyParser()); app.use(express.cookieParser()); app.use(express.session({ secret: config.get('session:secret'), key: config.get('session:key'), cookie: config.get('session:cookie'), store: new MongoStore({mongoose_connection: mongoose.connection}) })); /** * Authorization Access * */ app.use(checkAuth); /** * Routing * */ app.use(app.router); router(app); /** * Public directory * */ app.use(express.static(path.join(__dirname, '../public'))); app.use("/public", express.static(path.join(__dirname, '../public'))); /** * Error handing * */ app.use(errorHandler); };

इस प्रकार, हम सर्वर कोड के मुख्य भाग को बंद किए बिना सभी मिडलवेयर को कनेक्ट करेंगे, हो सकता है कि एप्लिकेशन के लिखे जाने पर इसे विस्तारित करना होगा।

मैं यह भी नोट करना चाहता हूं - एररहैंडलर मिडलवेयर को सर्वर की त्रुटियों से निपटने, और एरर पेज को प्रदर्शित करने के लिए बनाया गया है

errorHandler

 var config = require('../config'); var sendHttpError = function (error, res) { res.status(error.status); if (res.req.xhr) { res.json(error); } else { res.render('error', { error: { status: error.status, message: error.message, stack: config.get('debug') ? error.stack : '' }, project: config.get('project') }); } }; module.exports = function (app, express) { var log = require('../utils/log')(app, module), HttpError = require('../error').HttpError; return function(err, req, res, next) { if (typeof err === 'number') { err = new HttpError(err); } if (err instanceof HttpError) { sendHttpError(err, res); } else { if (app.get('env') === 'development') { express.errorHandler()(err, req, res, next); } else { log.error(err); err = new HttpError(500); sendHttpError(err, res); } } }; };

मैं मिडलवेयर चेकऑथ को भी नोट करना चाहता हूं

 var HttpError = require('../error').HttpError; module.exports = function (req, res, next) { if (!req.session.user) { return next(new HttpError(401, "You are not authorized!")); } next(); };

जो सत्र की उपस्थिति के लिए अनुरोधों की जांच करेगा और, यदि यह अनुपस्थित है, तो एक त्रुटि फेंक देगा। इसका उपयोग वैश्विक मिडलवेयर के रूप में किया जा सकता है, या आप एक विशिष्ट विधि निर्दिष्ट कर सकते हैं जहाँ इसका उपयोग किया जाएगा:

 app.get('/user-info', checkAuth, function (req, res, next) { //do your staff });

मॉडल

Mongoose की मदद से हम डेटा के साथ काम करने के लिए अपने खुद के मॉडल बनाएंगे। एक उदाहरण मॉडल इस तरह दिख सकता है:

 var crypto = require('crypto'), mongoose = require('../utils/mongoose'), Schema = mongoose.Schema, async = require('async'); var User = new Schema({ username: { type: String, unique: true, required: true }, hashedPassword: { type: String, required: true }, salt: { type: String, required: true } }); User.methods.encryptPassword = function (password) { return crypto.createHmac('sha1', this.salt).update(password).digest('hex'); }; User.virtual('password') .set(function (password) { this._plainPassword = password; this.salt = Math.random() + ''; this.hashedPassword = this.encryptPassword(password); }) .get(function () { return this._plainPassword; }); User.methods.checkPassword = function (password) { return this.encryptPassword(password) === this.hashedPassword; }; module.exports = mongoose.model('User', User);

सार्वजनिक

इस निर्देशिका में सभी स्क्रिप्ट और सीएसएस फाइलें होंगी जो बाहर से सुलभ हैं। यह विकल्प निम्नलिखित सेटिंग्स का उपयोग करके लागू किया गया है:

 /** * Public directory * */ app.use(express.static(path.join(__dirname, '../public'))); app.use("/public", express.static(path.join(__dirname, '../public')));

मार्गों

शायद सबसे दिलचस्प। इस निर्देशिका में, हम एक मॉड्यूल की घोषणा करते हैं जो रूटिंग के लिए जिम्मेदार होगा। index.js फ़ाइल

 var main = require('./main'), register = require('./register'), authentication = require('./authentication'), error = require('./error'); module.exports = function (app) { app.get('/', main.home); app.post('/register', register.requestRegistration); app.get('/users', authentication.users); app.get('/users/:id', authentication.user); app.get('*', error['404']); };

यहाँ हम केवल हमारे मार्गों की घोषणा करते हैं, और बस अन्य मॉड्यूल को निष्पादन सौंपते हैं। उदाहरण के लिए, मार्ग "/" :

 /** * Method: GET * URI: / * */ exports.home = function(req, res, next) { res.render('index'); };

वास्तव में बस इतना ही। ऐसे में आधार एप्लीकेशन कैसे काम करेगा। सत्र का समर्थन करने के लिए, हम संबंधित मिडलवेयर को शामिल करते हैं। हम उदाहरण के लिए, विशेष रूप से सत्यापन और पंजीकरण में उपयोगकर्ता से जुड़े सभी व्यावसायिक तर्क को मॉडल / user.js पर स्थानांतरित करते हैं।

पुनश्च:
इस लेख को लिखने में, सूचना का उपयोग आई। कांटोर के स्क्रेंकोस्ट से किया गया था। पेंचकस से लिंक करें।
MongoDB पर पाठ्यक्रमों से जानकारी का उपयोग भी किया

मूल Node.JS एक्सप्रेस का उपयोग कर आवेदन