Wie kann man mit Node.js schnell einen API-Server erstellen?

Node.js kann für Anfänger einschüchternd sein, da seine flexible Struktur und das Fehlen strenger Spezifikationen es komplex erscheinen lassen. [Empfehlung für ein Video-Tutorial: node js-Tutorial]

Dieses Tutorial ist eine Kurzanleitung zu Node.js, dem Express-Framework und MongoDB und konzentriert sich auf grundlegendes REST-Routing und grundlegende Datenbankinteraktion. Sie erstellen eine einfache API-Framework-Vorlage, die dann in jeder Anwendung verwendet werden kann.

Dieses Tutorial ist für : Sie sollten über ein grundlegendes Verständnis der REST-API- und CRUD-Operationen sowie grundlegende JavaScript-Kenntnisse verfügen. Ich verwende ES6 (hauptsächlich Pfeilfunktionen), aber es ist nicht sehr kompliziert.

In diesem Tutorial erstellen wir das Backend-Skelett einer Web-Notizanwendung – ähnlich Google Keep, die alle vier CRUD-Vorgänge ausführen kann: Erstellen, Lesen, Aktualisieren und Löschen.

Konfiguration

Wenn Sie Node nicht installiert haben, sehen Sie sich hier um.

Erstellen Sie ein neues Verzeichnis, führen Sie npm init aus, befolgen Sie dann die Anweisungen und nennen Sie Ihre Anwendung „bemerkenswert“ (oder einen anderen Namen, der Ihnen gefallen könnte).

npm init

Sobald der Vorgang abgeschlossen ist, befindet sich in Ihrem Verzeichnis eine Datei package.json. Sie können mit der Installation der für Ihr Projekt erforderlichen Abhängigkeiten beginnen.

Wir werden Express als unser Framework, MongoDB als unsere Datenbank und ein Paket namens body-parser verwenden, um die Verarbeitung von JSON-Anfragen zu unterstützen.

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

Ich empfehle außerdem dringend, Nodemon als Entwicklerabhängigkeit zu installieren. Dabei handelt es sich um ein sehr einfaches kleines Paket, das den Server automatisch neu startet, wenn eine Datei geändert wird.

Wenn Sie Folgendes ausführen:

npm install --save-dev nodemon

, fügen Sie dann das folgende Skript zu package.json hinzu:

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

Das vollständige package.json sollte wie folgt aussehen:

// 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"
  }
}

Jetzt können Sie server.js erstellen Datei und erstellen Sie die API.

Unser Server

beginnt mit dem Import aller Abhängigkeiten in server.js.

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

Wir werden MongoClient verwenden, um mit der Datenbank zu interagieren. Die App wird auch als Instanz des Express-Frameworks initialisiert.

Als letztes müssen Sie Ihrem Programm mitteilen, dass es auf Anfragen zuhörenbeginnen soll.

Sie können einen Port angeben und wie folgt mit dem Abhören beginnen:

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

Wenn Sie nun npm run dev (oder node server.js, wenn Sie Nodemon nicht installiert haben) ausführen, sollten Sie im Terminal sehen Aufforderung „Wir sind live auf Port 8000“.

Ihr Server wurde gestartet. Aber es kann noch nichts machen.

Lassen Sie uns als nächstes dieses Problem lösen.

CRUD-Routen

Für dieses Beispiel möchten Sie 4 Routen erstellen: Notiz erstellen, Notiz lesen, Notiz aktualisieren und Notiz löschen.

Dadurch erhalten Sie eine Vorstellung davon, wie Sie mit Node fast jede grundlegende Route erstellen können.

Um Ihre API zu testen, müssen Sie jedoch auch den Client nachahmen, um Anfragen zu stellen. Dazu verwenden wir eine hervorragende App namens Postman. Es ermöglicht Ihnen, einfache HTTP-Anfragen mit benutzerdefinierten Headern und Parametern zu stellen.

Installieren Sie Postman und beginnen Sie mit der Einrichtung des Routings.

Projektstruktur

Die meisten Node.js-Tutorials (und viele Beispiele aus der Praxis) fassen alle Routen in einer großen routes.js-Datei zusammen. Das ist mir etwas unangenehm. Im Gegensatz dazu verbessert die Aufteilung von Dateien in separate Ordner die Lesbarkeit und erleichtert die Verwaltung großer Anwendungen.

Obwohl es sich bei dem, was wir tun, nicht um eine groß angelegte Anwendung handelt, können wir dies dennoch tun. Erstellen Sie das folgende Verzeichnis: einen app-Ordner mit einem Routenordner darin, der die Dateien index.js und note_routes.js enthält.

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

Diese Verzeichnisse mögen für Ihr einfaches kleines Programm übertrieben erscheinen, aber es ist immer sinnvoll, es von Anfang an richtig zu machen.

Deine erste Route

Beginnen wir mit dem C in CRUD. Wie würden Sie eine Notiz erstellen?

Bevor Sie also beginnen, müssen Sie zunächst den Grundstein legen. In Express ist die Route in einer Funktion enthalten, die die Express-Instanz und die Datenbank als Parameter verwendet.

So:

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

Sie können diese Funktion dann über index.js exportieren:

// 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
};

und sie dann zur Verwendung in server.js importieren:

// 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);
});

Bitte beachten Sie, dass die Datenbank nicht eingerichtet ist Übergeben Sie also einfach ein leeres Objekt.

Okay, jetzt können Sie Ihre eigene CREATE-Route erstellen.

Die Syntax ist einfach:

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

Wenn die Anwendung eine post-Anfrage an den Pfad „/notes“ empfängt, führt sie den Code im Rückruf aus – das Anfrageobjekt (das die Parameter der Anfrage oder JSON enthält) und das Antwortobjekt.

Sie können Postman verwenden, um zum Testen eine POST-Anfrage an localhost:8000/notes zu senden.

你应该得到回复：'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':  };
    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]);
      }
    });
  });
};

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

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。如果你有兴趣，请点击关注！

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

Das obige ist der detaillierte Inhalt vonWie kann man mit Node.js schnell einen API-Server erstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!