नोड.जेएस और एक्सप्रेस के साथ एक REST API बनाएं:एक डेटाबेस कनेक्ट करना
पहले ट्यूटोरियल में, RESTful API को समझना, हमने सीखा कि REST आर्किटेक्चर क्या है, HTTP रिक्वेस्ट मेथड और रिस्पॉन्स क्या हैं, और RESTful API एंडपॉइंट को कैसे समझें। दूसरे ट्यूटोरियल में, एक्सप्रेस एपीआई सर्वर कैसे सेट करें, हमने सीखा कि नोड के बिल्ट-इन http दोनों के साथ सर्वर कैसे बनाया जाता है। मॉड्यूल और एक्सप्रेस फ्रेमवर्क, और हमारे द्वारा बनाए गए ऐप को विभिन्न यूआरएल एंडपॉइंट्स पर कैसे रूट किया जाए।
वर्तमान में, हम उपयोगकर्ता जानकारी को JSON फ़ीड के रूप में प्रदर्शित करने के लिए स्थिर डेटा का उपयोग कर रहे हैं जब API समापन बिंदु GET के साथ मारा जाता है गुजारिश। इस ट्यूटोरियल में, हम सभी डेटा को स्टोर करने के लिए एक MySQL डेटाबेस सेट करने जा रहे हैं, हमारे Node.js ऐप से डेटाबेस से कनेक्ट करें, और एपीआई को GET का उपयोग करने दें। , POST , PUT , और DELETE एक पूर्ण एपीआई बनाने के तरीके।
इंस्टॉलेशन
इस बिंदु तक, हमने किसी भी डेटा को स्टोर या हेरफेर करने के लिए डेटाबेस का उपयोग नहीं किया है, इसलिए हम एक को सेट करने जा रहे हैं। यह ट्यूटोरियल MySQL का उपयोग करेगा, और यदि आपके कंप्यूटर पर पहले से ही MySQL स्थापित है, तो आप अगले चरण पर जाने के लिए तैयार होंगे।
यदि आपके पास MySQL स्थापित नहीं है, तो आप macOS और Windows के लिए MAMP डाउनलोड कर सकते हैं, जो एक मुफ़्त, स्थानीय सर्वर वातावरण और डेटाबेस प्रदान करता है। एक बार जब आप इसे डाउनलोड कर लें, तो प्रोग्राम खोलें और सर्वर प्रारंभ करें . पर क्लिक करें MySQL प्रारंभ करने के लिए।
MySQL को स्वयं सेट करने के अलावा, हम चाहते हैं कि GUI सॉफ़्टवेयर डेटाबेस और तालिकाओं को देखे। Mac के लिए, SequelPro डाउनलोड करें, और Windows के लिए SQLyog डाउनलोड करें। एक बार जब आप MySQL डाउनलोड और चालू कर लेते हैं, तो आप localhost से कनेक्ट करने के लिए SequelPro या SQLyog का उपयोग कर सकते हैं। उपयोगकर्ता नाम के साथ root और पासवर्ड root पोर्ट पर 3306 ।
एक बार सब कुछ यहां सेट हो जाने के बाद, हम अपने एपीआई के लिए डेटाबेस स्थापित करने के लिए आगे बढ़ सकते हैं।
डेटाबेस सेट करना
अपने डेटाबेस देखने वाले सॉफ़्टवेयर में, एक नया डेटाबेस जोड़ें और इसे api कहें . सुनिश्चित करें कि MySQL चल रहा है, या आप localhost से कनेक्ट नहीं कर पाएंगे ।
जब आपके पास api . हो डेटाबेस बनाया, उसमें ले जाएँ और एक नई तालिका बनाने के लिए निम्न क्वेरी चलाएँ।
CREATE TABLE `users` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(30) DEFAULT '', `email` varchar(50) DEFAULT '', PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
यह SQL क्वेरी हमारे users . की संरचना बनाएगी टेबल। प्रत्येक उपयोगकर्ता के पास एक ऑटो-इंक्रीमेंटिंग आईडी, एक नाम और एक ईमेल पता होगा।
हम डेटाबेस को उसी डेटा से भी भर सकते हैं जिसे हम वर्तमान में एक स्थिर JSON सरणी के माध्यम से INSERT चलाकर प्रदर्शित कर रहे हैं। क्वेरी।
INSERT INTO users (name, email)
VALUES ('Richard Hendricks', '[email protected]'),
('Bertram Gilfoyle', '[email protected]');
id . इनपुट करने की कोई आवश्यकता नहीं है क्षेत्र, क्योंकि यह स्वतः वृद्धिशील है। इस बिंदु पर, हमारे पास हमारी तालिका की संरचना के साथ-साथ काम करने के लिए कुछ नमूना डेटा भी है।
MySQL से कनेक्ट हो रहा है
हमारे ऐप में वापस, हमें डेटा के साथ काम करना शुरू करने के लिए Node.js से MySQL से कनेक्ट करना होगा। इससे पहले, हमने mysql . स्थापित किया था npm मॉड्यूल, और अब हम इसका उपयोग करने जा रहे हैं।
डेटा . नामक एक नई निर्देशिका बनाएं और एक config.js बनाएं फ़ाइल।
हम mysql . की आवश्यकता के साथ शुरुआत करेंगे data/config.js . में मॉड्यूल ।
const mysql = require('mysql');
आइए एक config बनाएं ऑब्जेक्ट जिसमें होस्ट, उपयोगकर्ता, पासवर्ड और डेटाबेस होता है। यह api . का संदर्भ लेना चाहिए डेटाबेस हमने बनाया है और डिफ़ॉल्ट लोकलहोस्ट सेटिंग्स का उपयोग करते हैं।
// Set database connection credentials
const config = {
host: 'localhost',
user: 'root',
password: 'root',
database: 'api',
};
दक्षता के लिए, हम एक MySQL पूल बनाने जा रहे हैं, जो हमें कई कनेक्शनों को मैन्युअल रूप से खोलने और बंद करने के बजाय एक साथ कई कनेक्शनों का उपयोग करने की अनुमति देता है।
// Create a MySQL pool const pool = mysql.createPool(config);
अंत में, हम MySQL पूल को निर्यात करेंगे ताकि ऐप इसका उपयोग कर सके।
// Export the pool module.exports = pool;
आप हमारे GitHub रेपो में पूर्ण डेटाबेस कॉन्फ़िगरेशन फ़ाइल देख सकते हैं।
अब जब हम MySQL से जुड़ रहे हैं और हमारी सेटिंग्स पूरी हो गई हैं, तो हम API से डेटाबेस के साथ इंटरैक्ट करने के लिए आगे बढ़ सकते हैं।
MySQL से API डेटा प्राप्त करना
वर्तमान में, हमारे routes.js फ़ाइल मैन्युअल रूप से उपयोगकर्ताओं की JSON सरणी बना रही है, जो इस तरह दिखती है।
const users = [{ ...
चूंकि अब हम स्थिर डेटा का उपयोग नहीं करने जा रहे हैं, हम उस संपूर्ण सरणी को हटा सकते हैं और इसे अपने MySQL पूल के लिंक से बदल सकते हैं।
// Load the MySQL pool connection
const pool = require('../data/config');
पहले, GET /users . के लिए पथ स्थिर users sending भेज रहा था जानकारी। हमारा अद्यतन कोड इसके बजाय उस डेटा के लिए डेटाबेस को क्वेरी करने जा रहा है। हम SELECT . के लिए SQL क्वेरी का उपयोग करने जा रहे हैं सभी users . से तालिका, जो इस तरह दिखती है।
SELECT * FROM users
यहाँ हमारे नए /users pool.query() . का उपयोग करके मार्ग प्राप्त करें जैसा दिखेगा विधि।
// Display all users
app.get('/users', (request, response) => {
pool.query('SELECT * FROM users', (error, result) => {
if (error) throw error;
response.send(result);
});
});
यहां, हम SELECT चला रहे हैं क्वेरी और फिर परिणाम को JSON के रूप में क्लाइंट को /users . के माध्यम से भेजना समापन बिंदु यदि आप सर्वर को पुनरारंभ करते हैं और /users . पर नेविगेट करते हैं पृष्ठ, आपको पहले जैसा ही डेटा दिखाई देगा, लेकिन अब यह गतिशील है।
URL पैरामीटर का उपयोग करना
अब तक, हमारे अंतिम बिंदु स्थिर पथ रहे हैं—या तो / रूट या /users —लेकिन क्या होगा जब हम केवल एक विशिष्ट उपयोगकर्ता के बारे में डेटा देखना चाहते हैं? हमें एक परिवर्तनीय समापन बिंदु का उपयोग करने की आवश्यकता होगी।
हमारे उपयोगकर्ताओं के लिए, हम प्रत्येक व्यक्तिगत उपयोगकर्ता के बारे में उनकी विशिष्ट आईडी के आधार पर जानकारी प्राप्त करना चाह सकते हैं। ऐसा करने के लिए, हम एक कोलन का उपयोग करेंगे (: ) यह दर्शाने के लिए कि यह एक मार्ग पैरामीटर है।
// Display a single user by ID
app.get('/users/:id', (request, response) => {
...
});
});
हम इस पथ के लिए पैरामीटर को request.params . के साथ पुनः प्राप्त कर सकते हैं संपत्ति। चूँकि हमारा नाम id . है , इस तरह हम इसका उल्लेख करेंगे।
const id = request.params.id;
अब हम एक WHERE जोड़ देंगे हमारे SELECT . का खंड केवल निर्दिष्ट id . वाले परिणाम प्राप्त करने के लिए कथन .
हम ? का उपयोग करेंगे एसक्यूएल इंजेक्शन से बचने के लिए प्लेसहोल्डर के रूप में और एक पैरामीटर के रूप में आईडी को पास करने के बजाय, एक समेकित स्ट्रिंग बनाने के बजाय, जो कम सुरक्षित होगा।
pool.query('SELECT * FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send(result);
});
हमारे व्यक्तिगत उपयोगकर्ता संसाधन का पूरा कोड अब इस तरह दिखता है:
// Display a single user by ID
app.get('/users/:id', (request, response) => {
const id = request.params.id;
pool.query('SELECT * FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send(result);
});
});
अब आप सर्वर को पुनरारंभ कर सकते हैं और https://localhost/users/2 . पर नेविगेट कर सकते हैं केवल गिलफॉय के लिए जानकारी देखने के लिए। अगर आपको कोई त्रुटि मिलती है जैसे Cannot GET /users/2 , इसका मतलब है कि आपको सर्वर को पुनरारंभ करने की आवश्यकता है।
इस URL पर जाने से एक ही परिणाम वापस आना चाहिए।
[{
id: 2,
name: "Bertram Gilfoyle",
email: "[email protected]"
}]
यदि आप यही देखते हैं, तो बधाई हो:आपने सफलतापूर्वक एक गतिशील मार्ग पैरामीटर सेट कर लिया है!
पोस्ट अनुरोध भेजना
अब तक, हम जो कुछ भी करते रहे हैं उसमें GET का उपयोग किया गया है अनुरोध। ये अनुरोध सुरक्षित हैं, जिसका अर्थ है कि वे सर्वर की स्थिति को नहीं बदलते हैं। हम केवल JSON डेटा देख रहे हैं।
अब हम एक POST . का उपयोग करके API को वास्तव में गतिशील बनाना शुरू करने जा रहे हैं नया डेटा जोड़ने का अनुरोध।
मैंने पहले अंडरस्टैंडिंग आरईएसटी लेख में उल्लेख किया था कि हम क्रियाओं का उपयोग नहीं करते हैं जैसे add या DELETE कार्रवाई करने के लिए URL में। डेटाबेस में एक नया उपयोगकर्ता जोड़ने के लिए, हम POST . करेंगे हम उन्हें उसी URL से देखते हैं, जिससे हम उन्हें देखते हैं, लेकिन इसके लिए बस एक अलग मार्ग निर्धारित करते हैं।
// Add a new user
app.post('/users', (request, response) => {
...
});
जोड़ें
ध्यान दें कि हम app.post() . का उपयोग कर रहे हैं इसके बजाय app.get() अब।
चूंकि हम पढ़ने के बजाय बना रहे हैं, हम एक INSERT . का उपयोग करेंगे यहां क्वेरी करें, जैसा कि हमने डेटाबेस के प्रारंभ में किया था। हम संपूर्ण request.body भेज देंगे SQL क्वेरी के माध्यम से।
pool.query('INSERT INTO users SET ?', request.body, (error, result) => {
if (error) throw error;
हम प्रतिक्रिया की स्थिति को 201 . के रूप में भी निर्दिष्ट करने जा रहे हैं , जिसका अर्थ है Created . अंतिम सम्मिलित आइटम की आईडी प्राप्त करने के लिए, हम insertId का उपयोग करेंगे संपत्ति।
response.status(201).send(`User added with ID: ${result.insertId}`);
हमारा पूरा POST प्राप्त कोड इस तरह दिखेगा।
// Add a new user
app.post('/users', (request, response) => {
pool.query('INSERT INTO users SET ?', request.body, (error, result) => {
if (error) throw error;
response.status(201).send(`User added with ID: ${result.insertId}`);
});
});
अब हम एक POST भेज सकते हैं के माध्यम से अनुरोध करें। अधिकांश समय जब आप POST . भेजते हैं अनुरोध, आप इसे वेब फॉर्म के माध्यम से कर रहे हैं। हम इस लेख के अंत तक सीखेंगे कि इसे कैसे सेट किया जाए, लेकिन परीक्षण भेजने का सबसे तेज़ और आसान तरीका POST कर्ल के साथ है, -d (--data) . का उपयोग कर झंडा।
हम curl -d चलाएंगे , उसके बाद एक क्वेरी स्ट्रिंग जिसमें सभी कुंजी/मान जोड़े और अनुरोध समापन बिंदु शामिल हैं।
curl -d "name=Dinesh Chugtai&[email protected]" http://localhost:3002/users
एक बार जब आप इस अनुरोध को भेज देते हैं, तो आपको सर्वर से प्रतिक्रिया मिलनी चाहिए।
User added with ID: 3
यदि आप http://localhost/users पर नेविगेट करते हैं , आप सूची में जोड़ी गई नवीनतम प्रविष्टि देखेंगे।
एक PUT अनुरोध भेजना
POST नया उपयोगकर्ता जोड़ने के लिए उपयोगी है, लेकिन हम PUT . का उपयोग करना चाहेंगे मौजूदा उपयोगकर्ता को संशोधित करने के लिए। PUT निष्क्रिय है, जिसका अर्थ है कि आप एक ही अनुरोध को कई बार भेज सकते हैं और केवल एक ही क्रिया की जाएगी। यह POST . से अलग है , क्योंकि यदि हम अपना नया उपयोगकर्ता अनुरोध एक से अधिक बार भेजते हैं, तो यह नए उपयोगकर्ता बनाता रहेगा।
हमारे एपीआई के लिए, हम सेट करने जा रहे हैं PUT किसी एकल उपयोगकर्ता को संपादित करने में सक्षम होने के लिए, इसलिए हम :id . का उपयोग करने जा रहे हैं इस बार मार्ग पैरामीटर।
आइए एक UPDATE बनाएं क्वेरी करें और सुनिश्चित करें कि यह केवल WHERE . के साथ अनुरोधित आईडी पर लागू होता है खंड। हम दो ? का उपयोग कर रहे हैं प्लेसहोल्डर, और हमारे द्वारा पास किए गए मान क्रमिक क्रम में जाएंगे।
// Update an existing user
app.put('/users/:id', (request, response) => {
const id = request.params.id;
pool.query('UPDATE users SET ? WHERE id = ?', [request.body, id], (error, result) => {
if (error) throw error;
response.send('User updated successfully.');
});
});
हमारे परीक्षण के लिए, हम उपयोगकर्ता को संपादित करेंगे 2 और ईमेल पते को [email protected] से [email protected] पर अपडेट करें। हम [-X (--request)] . के साथ फिर से कर्ल का उपयोग कर सकते हैं ध्वज, स्पष्ट रूप से निर्दिष्ट करने के लिए कि हम एक पुट अनुरोध भेज रहे हैं।
curl -X PUT -d "name=Bertram Gilfoyle" -d "[email protected]" http://localhost:3002/users/2
अनुरोध भेजने से पहले सर्वर को पुनरारंभ करना सुनिश्चित करें, अन्यथा आपको Cannot PUT /users/2 नहीं मिलेगा त्रुटि।
आपको यह देखना चाहिए:
User updated successfully.
आईडी के साथ उपयोगकर्ता डेटा 2 अब अपडेट किया जाना चाहिए।
एक DELETE अनुरोध भेजना
एपीआई की सीआरयूडी कार्यक्षमता को पूरा करने का हमारा अंतिम कार्य उपयोगकर्ता को डेटाबेस से हटाने का विकल्प बनाना है। यह अनुरोध DELETE . का उपयोग करेगा SQL क्वेरी WHERE . के साथ , और यह रूट पैरामीटर द्वारा निर्दिष्ट एक व्यक्तिगत उपयोगकर्ता को हटा देगा।
// Delete a user
app.delete('/users/:id', (request, response) => {
const id = request.params.id;
pool.query('DELETE FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send('User deleted.');
});
});
हम -X . का उपयोग कर सकते हैं फिर से कर्ल के माध्यम से हटाने के लिए भेजने के लिए। आइए हमारे द्वारा बनाए गए नवीनतम उपयोगकर्ता को हटा दें।
curl -X DELETE http://localhost:3002/users/3
आपको सफलता का संदेश दिखाई देगा।
User deleted.
http://localhost:3002 पर नेविगेट करें , और आप देखेंगे कि अब केवल दो उपयोगकर्ता हैं।
बधाई हो! इस बिंदु पर, एपीआई पूरा हो गया है। routes.js . का पूरा कोड देखने के लिए GitHub रेपो पर जाएं ।
request के माध्यम से अनुरोध भेजना मॉड्यूल
इस लेख की शुरुआत में, हमने चार निर्भरताएँ स्थापित कीं, और उनमें से एक थी request मापांक। कर्ल अनुरोधों का उपयोग करने के बजाय, आप सभी डेटा के साथ एक नई फ़ाइल बना सकते हैं और इसे भेज सकते हैं। मैं post.js . नामक एक फ़ाइल बनाऊंगा जो POST . के माध्यम से एक नया उपयोगकर्ता बनाएगा ।
const request = require('request');
const json = {
"name": "Dinesh Chugtai",
"email": "[email protected]",
};
request.post({
url: 'http://localhost:3002/users',
body: json,
json: true,
}, function (error, response, body) {
console.log(body);
});
हम इसे node post.js . का उपयोग करके कॉल कर सकते हैं सर्वर के चलने के दौरान एक नई टर्मिनल विंडो में, और यह कर्ल का उपयोग करने जैसा ही प्रभाव डालेगा। अगर कुछ कर्ल के साथ काम नहीं कर रहा है, तो request मॉड्यूल उपयोगी है क्योंकि हम त्रुटि, प्रतिक्रिया और मुख्य भाग देख सकते हैं।
वेब फ़ॉर्म के ज़रिए अनुरोध भेजना
आमतौर पर, POST और अन्य HTTP विधियाँ जो सर्वर की स्थिति को बदल देती हैं, उन्हें HTML प्रपत्रों का उपयोग करके भेजा जाता है। इस बहुत ही सरल उदाहरण में, हम एक index.html . बना सकते हैं कहीं भी फ़ाइल करें, और नाम और ईमेल पते के लिए एक फ़ील्ड बनाएं। प्रपत्र की क्रिया संसाधन को इंगित करेगी, इस मामले में http//localhost:3002/users , और हम विधि को POST . के रूप में निर्दिष्ट करेंगे ।
बनाएं index.html और इसमें निम्न कोड जोड़ें:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Node.js Express REST API</title>
</head>
<body>
<form action="http://localhost:3002/users" method="post">
<label for="name">Name</label>
<input type="text" name="name">
<label for="email">Email</label>
<input type="email" name="email">
<input type="submit">
</form>
</body>
</html>
इस स्थिर HTML फ़ाइल को अपने ब्राउज़र में खोलें, इसे भरें, और सर्वर के टर्मिनल में चलने के दौरान इसे भेजें। आपको User added with ID: 4 . की प्रतिक्रिया देखनी चाहिए , और आपको उपयोगकर्ताओं की नई सूची देखने में सक्षम होना चाहिए।
