Comment créer rapidement un serveur API avec Node.js ?

Node.js peut être intimidant pour les débutants, avec sa structure flexible et son manque de spécifications strictes qui le font paraître complexe. [Recommandation du didacticiel vidéo : tutoriel node js]

Ce didacticiel est un guide rapide de Node.js, du framework Express et de MongoDB, axé sur le routage REST de base et l'interaction de base avec les bases de données. Vous allez créer un modèle de framework API simple qui pourra ensuite être utilisé dans n'importe quelle application.

Ce tutoriel s'adresse à  : vous devez avoir une compréhension de base de l'API REST et des opérations CRUD, ainsi que des connaissances de base en JavaScript. J'utilise ES6 (principalement des fonctions fléchées), mais ce n'est pas très compliqué.

Dans ce tutoriel, nous allons créer le squelette backend d'une application de prise de notes Web - similaire à Google Keep, capable d'effectuer les quatre opérations CRUD : créer, lire, mises à jour et suppressions .

Configuration

Si Node n'est pas installé, voir ici.

Créez un nouveau répertoire, exécutez npm init, puis suivez les instructions et nommez votre application « notable » (ou quelque chose d'autre qui pourrait vous plaire).

npm init

Une fois terminé, il y aura un fichier package.json dans votre répertoire. Vous pouvez commencer à installer les dépendances requises pour votre projet.

Nous utiliserons Express comme framework, MongoDB comme base de données et un package appelé body-parser pour nous aider avec les requêtes JSON.

npm install --save express mongodb@2.2.16 body-parser

Je recommande également fortement d'installer Nodemon en tant que dépendance de développement. Il s'agit d'un petit package très simple qui redémarre automatiquement le serveur lorsqu'un fichier est modifié.

Si vous exécutez :

npm install --save-dev nodemon

puis ajoutez le script suivant à package.json :

// package.json
  "scripts": {
    "dev": "nodemon server.js"
  },

Fullpackage.json Cela devrait ressembler à ceci :

// package.json
{
  "name": "notable",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "dev": "nodemon server.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "body-parser": "^1.15.2",
    "express": "^4.14.0",
    "mongodb": "^2.2.16"
  },
  "devDependencies": {
    "nodemon": "^1.11.0"
  }
}

Vous pouvez maintenant créer le fichier server.js et construire l'API.

Notre serveur

commence par importer toutes les dépendances dans server.js.

// server.js
const express        = require('express');
const MongoClient    = require('mongodb').MongoClient;
const bodyParser     = require('body-parser');
const app            = express();

Nous utiliserons MongoClient pour interagir avec la base de données. L'application est également initialisée en tant qu'instance du framework Express.

La dernière chose à faire est de dire à votre programme de commencer à écouter les requêtes.

Vous pouvez spécifier un port et commencer à écouter comme ceci :

// server.js
const port = 8000;
app.listen(port, () => {
  console.log('We are live on ' + port);
});

Maintenant, si vous exécutez npm run dev (ou node server.js , si Nodemon n'est pas installé), vous devriez voir l'invite "Nous sommes en direct sur le port 8000" dans le terminal.

Votre serveur a été démarré. Mais il ne peut encore rien faire.

Réparons cela ensuite.

Routages CRUD

Pour cet exemple, vous souhaitez créer 4 itinéraires : créer une note, lire une note, mettre à jour une note et supprimer une note.

Cela vous donnera une idée de la façon de créer presque n'importe quel itinéraire de base à l'aide de Node.

Cependant, pour tester votre API, vous devez également simuler les requêtes du client. Pour ce faire, nous utiliserons une excellente application appelée Postman. Il vous permet de faire des requêtes HTTP simples avec des en-têtes et des paramètres personnalisés.

Installez Postman et commençons à configurer le routage.

Structure du projet

La plupart des didacticiels Node.js (et de nombreux exemples concrets) regroupent toutes les routes dans un seul gros fichier routes.js. Cela me met un peu mal à l'aise. En revanche, diviser les fichiers dans des dossiers séparés améliore la lisibilité et facilite la gestion des applications volumineuses.

Bien que nous ne fassions pas d'applications à grande échelle pour le moment, nous pouvons toujours le faire. Créez le répertoire suivant : un dossier app, qui contient un dossier routes, qui contient les fichiers index.js et note_routes.js.

mkdir app
cd app
mkdir routes
cd routes
touch index.js
touch note_routes.js

Ces répertoires peuvent sembler excessifs pour votre simple petit programme, mais il est toujours logique de bien faire les choses dès le début.

Votre premier itinéraire

Commençons par le C dans CRUD. Comment créeriez-vous une note ?

Eh bien, avant de commencer, vous devez d'abord poser les bases. Dans Express, la route est contenue dans une fonction qui prend l'instance Express et la base de données comme paramètres.

Comme ceci :

// routes/note_routes.js
module.exports = function(app, db) {
};

Ensuite, vous pouvez exporter cette fonction via index.js :

// routes/index.js
const noteRoutes = require('./note_routes');
module.exports = function(app, db) {
  noteRoutes(app, db);
  // Other route groups could go here, in the future
};

puis l'importer pour l'utiliser dans server Utilisé dans .js :

// server.js
const express        = require('express');
const MongoClient    = require('mongodb').MongoClient;
const bodyParser     = require('body-parser');
const app            = express();
const port = 8000;
require('./app/routes')(app, {});
app.listen(port, () => {
  console.log('We are live on ' + port);
});

Veuillez noter que puisque la base de données n'a pas encore été configurée, transmettez simplement un objet vide.

D'accord, Maintenant vous pouvez créer votre propre itinéraire CREATE.

La syntaxe est simple :

// note_routes.js
module.exports = function(app, db) {
  app.post('/notes', (req, res) => {
    // You'll create your note here.
    res.send('Hello')
  });
};

Lorsque l'application reçoit une requête post pour le chemin '/notes', elle exécutera le code à l'intérieur du rappel - la requête objet (contient les paramètres de requête ou JSON) et l'objet de réponse.

Vous pouvez utiliser Postman pour envoyer une requête POST à ​​localhost:8000/notes pour tester.

你应该得到回复：'Hello'。

太好了！你创建了第一个真正的路由。

下一步是在你的请求中添加一些参数并在 API 中处理它们，最后添加到你的数据库中。

请求参数

在 Postman 中，在选择 x-www-form-urlencoded 单选按钮后，转到 Body 选项卡并添加一些键值对。

这会将编码后的表单数据添加到你的请求中，你可以使用 API ??处理该请求。

你可以去尝试更多的设置项。

现在在你的 note_routes.js 中，让我们输出 body 的内容。

// note_routes.js
module.exports = function(app, db) {
  app.post('/notes', (req, res) => {
    console.log(req.body)
    res.send('Hello')
  });
};

用 Postman 发送请求，你会看到……undefined。

不幸的是，Express 无法自行处理 URL 编码的表单。虽然你确实安装了这个 body-parser 包......

// server.
const express        = require('express');
const MongoClient    = require('mongodb').MongoClient;
const bodyParser     = require('body-parser');
const app            = express();
const port = 8000;
app.use(bodyParser.urlencoded({ extended: true }));
require('./app/routes')(app, {});
app.listen(port, () => {
  console.log('We are live on ' + port);
});

Now you should see the body as an object in the terminal.
现在你应该将 body 视为终端中的对象。

{ title: 'My Note Title', body: 'What a great note.' }

第一个路由的最后一步：设置数据库，然后添加数据。

最简单方法是通过 mLab 设置 Mongo 数据库的：它是最小的而且是免费的，设置的速度非常快。

创建帐户和 MongoDB 部署后，将用户的用户名和密码添加到数据库：

然后复制这里第二个 URL：

在项目根目录的目录配置中，创建一个db.js文件。

mkdir config 
cd config
touch db.js

在里面，添加刚才的URL：

module.exports = {
  url : YOUR URL HERE
};

别忘了把你的用户名和密码（来自数据库用户的密码，而不是你的 mLab 帐户）添加到URL中。 （如果你要将此项目提交到 Github 上，请确保包含 .gitignore 文件 像这样, ，不要与任何人分享你的密码。）

现在在你的 server.js 中，可以用 MongoClient 连接到数据库了，使用它来包装你的应用程序设置：

// server.js
const express        = require('express');
const MongoClient    = require('mongodb').MongoClient;
const bodyParser     = require('body-parser');
const db             = require('./config/db');
const app            = express();
const port = 8000;
app.use(bodyParser.urlencoded({ extended: true }));
MongoClient.connect(db.url, (err, database) => {
  if (err) return console.log(err)
  require('./app/routes')(app, database);
  app.listen(port, () => {
    console.log('We are live on ' + port);
  });               
})

如果你用的是最新版本的 MongoDB（3.0+），请将其修改为：

// server.js
const express        = require('express');
const MongoClient    = require('mongodb').MongoClient;
const bodyParser     = require('body-parser');
const db             = require('./config/db');
const app            = express();
const port = 8000;
app.use(bodyParser.urlencoded({ extended: true }));
MongoClient.connect(db.url, (err, database) => {
  if (err) return console.log(err)
                      
  // Make sure you add the database name and not the collection name
  const database = database.db("note-api")
  require('./app/routes')(app, database);
  app.listen(port, () => {
    console.log('We are live on ' + port);
  });               
})

这是你的基础架构的最后一个设置！

添加到你的数据库

MongoDB将数据存储在 collections 中。在你的项目中，你希望将笔记存储在一个名为 notes 的 collection 中。

由于将数据库作为路径中的 db 参数传入，因此可以像这样访问它：

db.collection('notes')

创建笔记就像在集合上调用 insert 一样简单：

const note = { text: req.body.body, title: req.body.title}
  db.collection('notes').insert(note, (err, results) => {
}

插入完成后（或由于某种原因失败），要么返回错误或反回新创建的笔记对象。这是完整的 note_routes.js 代码：

// note_routes.js
module.exports = function(app, db) {
  const collection = 
  app.post('/notes', (req, res) => {
    const note = { text: req.body.body, title: req.body.title };
    db.collection('notes').insert(note, (err, result) => {
      if (err) { 
        res.send({ 'error': 'An error has occurred' }); 
      } else {
        res.send(result.ops[0]);
      }
    });
  });
};

试试看！使用 Postman 发送 x-www-form-urlencoded POST 请求，在 Body 选项卡下设置 title 和 body。

响应应如下所示：

如果你登录mLab，你还应该能够在数据库中看到创建的笔记。

READ 路由

现在可以稍微加快步伐。

假设你希望通过导航到 localhost:8000/notes/{id} 来获取刚创建的笔记。这是链接应该是localhost:8000/notes/585182bd42ac5b07a9755ea3。（如果你没有得到其中笔记的 ID，可以通过检查 mLab 或创建一个新的笔记）。

以下是 note_routes.js 中的内容：

// note_routes.js
module.exports = function(app, db) {
  app.get('/notes/:id', (req, res) => {
    
  });
  app.post('/notes', (req, res) => {
    const note = { text: req.body.body, title: req.body.title };
    db.collection('notes').insert(note, (err, result) => {
      if (err) { 
        res.send({ 'error': 'An error has occurred' }); 
      } else {
        res.send(result.ops[0]);
      }
    });
  });
};

就像以前一样，你将在数据库 collection 中调用一个方法。在这里，它被恰当地命名为 findOne。

// note_routes.js
module.exports = function(app, db) {
  app.get('/notes/:id', (req, res) => {
    const details = { '_id': <ID GOES HERE> };
    db.collection(&#39;notes&#39;).findOne(details, (err, item) => {
      if (err) {
        res.send({'error':'An error has occurred'});
      } else {
        res.send(item);
      }
    });
  });
app.post('/notes', (req, res) => {
    const note = { text: req.body.body, title: req.body.title };
    db.collection(&#39;notes&#39;).insert(note, (err, result) => {
      if (err) { 
        res.send({ 'error': 'An error has occurred' }); 
      } else {
        res.send(result.ops[0]);
      }
    });
  });
};

你可以通过 req.params.id 从 URL 参数中获取 id。但是，如果你试图将字符串插入上面的 <ID GOES HERE> 位置，它将无法正常工作。

MongoDB 不仅要求 ID 为字符串，还要求 ID 是一个对象，它们被之为 ObjectID。

别担心，这很容易解决。这是完整的代码：

// note_routes.js
var ObjectID = require('mongodb').ObjectID;
module.exports = function(app, db) {
  app.get('/notes/:id', (req, res) => {
    const id = req.params.id;
    const details = { '_id': new ObjectID(id) };
    db.collection('notes').findOne(details, (err, item) => {
      if (err) {
        res.send({'error':'An error has occurred'});
      } else {
        res.send(item);
      } 
    });
  });
app.post('/notes', (req, res) => {
    const note = { text: req.body.body, title: req.body.title };
    db.collection('notes').insert(note, (err, result) => {
      if (err) { 
        res.send({ 'error': 'An error has occurred' }); 
      } else {
        res.send(result.ops[0]);
      }
    });
  });
};

尝试使用一个笔记 ID，它应如下所示：

DELETE 路由

实际上删除对象与查找对象几乎相同。你只需用 remove 函数替换 findOne 即可。这是完整的代码：

// note_routes.js
// ...
  app.delete('/notes/:id', (req, res) => {
    const id = req.params.id;
    const details = { '_id': new ObjectID(id) };
    db.collection('notes').remove(details, (err, item) => {
      if (err) {
        res.send({'error':'An error has occurred'});
      } else {
        res.send('Note ' + id + ' deleted!');
      } 
    });
  });
// ...

UPDATE 路由

最后一个！ PUT 方法基本上是 READ 和 CREATE 的混合体。你找到该对象，然后更新它。如果刚才你删除了数据库中唯一的笔记，那就再创建一个！

代码：

// note_routes.js
// ...
  app.put('/notes/:id', (req, res) => {
    const id = req.params.id;
    const details = { '_id': new ObjectID(id) };
    const note = { text: req.body.body, title: req.body.title };
    db.collection('notes').update(details, note, (err, result) => {
      if (err) {
          res.send({'error':'An error has occurred'});
      } else {
          res.send(note);
      } 
    });
  });
// ...

现在你可以更新任何笔记，如下所示：

请注意这些代码还不完美 —— 比如你没有提供正文或标题，PUT 请求将会使数据库中的笔记上的那些字段无效。

API 完成

就这么简单！你完成了可以进行 CRUD 操作的 Node API。

本教程的目的是让你熟悉 Express、Node 和 MongoDB —— 你可以用简单的程序作为进军更复杂项目的跳板。

将来我将会编写系列教程，用不同的语言和框架创建更简单的API。如果你有兴趣，请点击关注！

更多编程相关知识，可访问：编程教学！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!