Déployer l'API de repos de nodejs-Questions et réponses frontales-php.cn

À l’ère d’Internet d’aujourd’hui, il est essentiel de créer des services back-end efficaces et rapides. NodeJS excelle dans ce domaine, permettant de créer rapidement et facilement des services Web efficaces. L'API REST est également une méthode très populaire pour créer des services Web dans l'industrie Internet actuelle. Il peut réduire considérablement la quantité de code, simplifier la gestion des ports et présente de nombreux avantages. Dans cet article, nous apprendrons comment déployer rapidement l'API REST à l'aide de NodeJS et ExpressJS.

Préparation de l'environnement

Avant de commencer, nous devons mettre en place un environnement :

Un éditeur de texte (VS Code est recommandé)
Node.js (télécharger et installer depuis le site officiel)
Postman (outil de test , peut être téléchargé sur le site officiel) et installer)

Initialisez le projet

Tout d'abord, nous ouvrons le terminal et créons un nouveau répertoire de projet :

mkdir project-name
cd project-name

Copier après la connexion

Ensuite, nous utilisons npm init pour créez un nouveau package : npm init 创建一个新的 package：

npm init

Copier après la connexion

npm init 将会要求你输入一些基本信息，例如作者名，项目名称，版本等。一些默认的设置是可以直接使用的，只需修改一些你自己的信息即可。

接下来，我们将需要安装以下几个依赖：

npm install express body-parser cors —save

Copier après la connexion

Express是我们用于构建REST API的框架。
body-parser是一个中间件，用于解析POST请求和JSON数据。
Cors是一个插件，允许Web应用程序在另一个域上启用 CORS（跨域资源共享）

创建服务

现在，让我们来创建一个名为app.js的新文件，这将是我们的 NodeJS REST API 服务的起点。我们可以借助 Express 框架来构建这个服务：

const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')
const app = express()

const port = 3000

app.use(cors())

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json())

app.listen(port, () => {
  console.log(`Server running on port ${port}`)
})

Copier après la connexion

在上面的代码段中，我们导入 Express，body-parser 和 cors。我们还使用了监听端口 3000 的app.listen()方法。最后，我们通过app.use()方法启用 cors 和 body-parser 的中间件。

创建路由

下一步将是创建路由，这是实现我们 REST API 服务所必需的。路由可以理解为请求进入服务后，服务应该如何响应的规则集合。

我们可以在项目根目录下创建一个routes文件夹，并在其中创建index.js文件，并添加以下内容：

const express = require('express')
const router = express.Router()

router.get('/posts', (req, res) => {
  res.status(200).send('All posts')
})

module.exports = router;

Copier après la connexion

在上述代码中，我们创建了一个新的路由，并在该路由上创建了一个/posts的GET请求。该请求将返回一个状态码为200和文本“All posts”。

接下来，我们将启用该路由。我们回到app.js文件并添加以下内容：

const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')
const app = express()

const postRoutes = require('./routes/index');
const port = 3000

app.use(cors())

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json())

app.use('/api', postRoutes);

app.listen(port, () => {
  console.log(`Server running on port ${port}`)
})

Copier après la connexion

在上述代码中，我们导入了定义在routes/index.js的路由，并使用app.use('/api', postRoutes)方法将路由应用于我们的 REST API 服务中。然后，在localhost:3000/api/posts呼叫GET请求时，它应该返回“All posts”。

数据库连接

当然，在真正的项目中我们需要请求和获取的数据是会被放在数据库中存储的，所以我们需要在此处讨论如何使用NodeJS连接数据库。

我们将使用 MongoDB 作为我们的数据库，同时使用mongoose来连接它。我们可以在命令行中运行以下命令来安装 mongoose：

npm install mongoose --save

Copier après la connexion

接下来，让我们来创建一个models文件夹，并在其中添加一个新文件post.js，以描述一个简单的数据模型。

const mongoose = require('mongoose');

const postSchema = new mongoose.Schema({
  title: { type: String, required: true },
  content: { type: String, required: true },
  author: { type: String, required: true },
}, { timestamps: true });

module.exports = mongoose.model('Post', postSchema);

Copier après la connexion

在上面的代码中，我们定义了一个名为Post的模型，以定义我们的数据，并且在创建它时使用了 timestamps 选项。

现在，我们要使用 Mongoose 连接本地 MongoDB 数据库。可以在app.js文件中添加以下内容：

const mongoose = require('mongoose');
const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')

const postRoutes = require('./routes/index');
const PORT = process.env.PORT || 3000;

const app = express();

app.use(cors());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

mongoose.connect('mongodb://localhost/posts', { useNewUrlParser: true, useUnifiedTopology: true });
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'MongoDB connection error:'));
db.once('open', function() {
    console.log('Successfully connected to MongoDB!');
})

app.use('/api', postRoutes);

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Copier après la connexion

以上代码的数据库URL设置为mongodb://localhost/posts，这表示数据库名为posts，并位于我们的本地MongoDB实例中。我们还使用了Mongoose端口的默认端口（27017）。需要注意的是，Mongoose已经被弃用的代码已经修复，所以我们必须使用useUnifiedTopology选项。

实现路由

我们已经在服务器中设置了路由，并且可以成功连接我们的数据库。接下来，我们要配置更多的路由，以处理 POST 请求并从我们的数据库中获取数据。

首先，我们在我们的路由中添加一个新的 POST 请求，并从请求体中提取出标题、内容、作者以及其他必要的信息。并将数据存储到数据库中。在这里，我们将假设在数据库中名为“posts”，并且通过Post模型本身来创建一个MongoDB文档。

const express = require('express');
const router = express.Router();
const Post = require('../models/post.js');

router.get('/posts', (req, res) => {
  Post.find()
  .then(data => res.json(data))
  .catch(err => res.status(400).json(`Error: ${err}`));
});

router.get('/posts/:id', (req, res) => {
  Post.findById(req.params.id)
  .then(data => res.json(data))
  .catch(err => res.status(400).json(`Error: ${err}`));
});

router.post('/posts', (req, res) => {
  const newPost = new Post(req.body);
  newPost.save()
  .then(() => res.json('Post added!'))
  .catch(err => res.status(400).json(`Error: ${err}`));
});

module.exports = router;

Copier après la connexion

顶部的代码中，我们首先导入了我们的模型文件，并创建所有需要的路由GET或POST请求。 GET请求使用Post.find()从MongoDB数据库中提取所有数据库条目，而我们的POST请求使用newPost.save()rrreee

npm init vous demandera de saisir quelques informations de base, telles que le nom de l'auteur, le nom du projet, la version, etc. Certains paramètres par défaut peuvent être utilisés directement, il suffit de modifier certaines de vos propres informations. 🎜🎜Ensuite, nous devrons installer les dépendances suivantes : 🎜rrreee

🎜Express est le framework que nous utilisons pour créer des API REST. 🎜🎜body-parser est un middleware pour analyser les requêtes POST et les données JSON. 🎜🎜Cors est un plugin qui permet aux applications Web d'activer CORS (Cross-Origin Resource Sharing) sur un autre domaine 🎜🎜Créer un service🎜🎜Maintenant, créons un fichier appelé

app.js, ce sera le point de départ de notre service API REST NodeJS. Nous pouvons créer ce service à l'aide du framework Express : 🎜rrreee🎜Dans l'extrait de code ci-dessus, nous importons Express, body-parser et cors. Nous utilisons également la méthode <code>app.listen()

qui écoute sur le port 3000. Enfin, nous activons le middleware cors et body-parser via la méthode app.use(). 🎜🎜Création de routes🎜🎜La prochaine étape consistera à créer des routes, nécessaires à la mise en œuvre de notre service API REST. Le routage peut être compris comme un ensemble de règles définissant la façon dont le service doit répondre après qu'une demande entre dans le service. 🎜🎜Nous pouvons créer un dossier routes dans le répertoire racine du projet et y créer le fichier index.js et ajouter le contenu suivant : 🎜rrreee🎜Dans le code ci-dessus, nous créons une nouvelle route et créons une requête GET pour /posts sur la route. La requête renverra un code d'état de 200 et le texte "Tous les messages". 🎜🎜Ensuite, nous activerons l'itinéraire. Nous revenons au fichier app.js et ajoutons ce qui suit : 🎜rrreee🎜Dans le code ci-dessus, nous importons les routes définies dans routes/index.js et utilisons app.use('/api', postRoutes) applique des routes à notre service API REST. Ensuite, lors de l'appel d'une requête GET sur localhost:3000/api/posts, elle doit renvoyer "Tous les messages". 🎜🎜Connexion à la base de données🎜🎜Bien sûr, dans un projet réel, les données que nous devons demander et obtenir seront stockées dans la base de données, nous devons donc discuter ici de la façon d'utiliser NodeJS pour nous connecter à la base de données. 🎜🎜Nous utiliserons MongoDB comme base de données et utiliserons mongoose pour nous y connecter. Nous pouvons installer Mongoose en exécutant la commande suivante dans la ligne de commande : 🎜rrreee🎜 Ensuite, créons un dossier models et ajoutons un nouveau fichier

post.js dans le code> pour décrire un modèle de données simple. 🎜rrreee🎜Dans le code ci-dessus, nous avons défini un modèle appelé <code>Post

pour définir nos données et utilisé l'option d'horodatage lors de sa création. 🎜🎜Maintenant, nous allons utiliser Mongoose pour nous connecter à la base de données MongoDB locale. Vous pouvez ajouter le contenu suivant dans le fichier app.js : 🎜rrreee🎜L'URL de la base de données du code ci-dessus est définie sur mongodb://localhost/posts, ce qui signifie le nom de la base de données est posts et se trouve dans notre instance MongoDB locale. Nous avons également utilisé le port par défaut (27017) pour le port Mongoose. Notez que le code obsolète dans Mongoose a été corrigé, nous devons donc utiliser l'option useUnifiedTopology. 🎜🎜Mise en œuvre du routage🎜🎜Nous avons configuré le routage sur le serveur et pouvons nous connecter avec succès à notre base de données. Ensuite, nous configurerons davantage de routes pour gérer les requêtes POST et obtenir des données de notre base de données. 🎜🎜Tout d'abord, nous ajoutons une nouvelle requête POST à notre itinéraire et extrayons le titre, le contenu, l'auteur et d'autres informations nécessaires du corps de la requête. et stockez les données dans la base de données. Ici, nous supposerons que nous avons un document MongoDB nommé "posts" dans la base de données et créerons un document MongoDB à partir du modèle Post lui-même. 🎜rrreee🎜Dans le code en haut, nous importons d'abord notre fichier modèle et créons toutes les routes nécessaires pour acheminer les requêtes GET ou POST. La requête GET utilise Post.find() pour extraire toutes les entrées de la base de données MongoDB, tandis que notre requête POST utilise newPost.save() pour stocker les nouvelles données dans le tableau de base de données. 🎜

Utilisez Postman pour tester

Après avoir terminé les étapes ci-dessus, vous pouvez utiliser Postman pour tester notre API REST.

Tout d'abord, nous essayons de récupérer les données à l'aide d'une requête GET. Nous pouvons récupérer toutes les publications en accédant à http://localhost:3000/posts. http://localhost:3000/posts来检索所有的文章。

接下来，我们尝试使用POST请求创建新数据，我们可以通过访问http://localhost:3000/posts并在请求的主体中添加一个新的JSON数据体来创建新文章。

最后，我们还可以使用GET请求检索单个条目，我们可以通过访问http://localhost:3000/posts/:id

Ensuite, nous essayons de créer de nouvelles données à l'aide d'une requête POST, ce que nous pouvons faire en visitant http://localhost:3000/posts et en en ajoutant une nouvelle dans le corps du corps de données JSON de la requête pour créer de nouveaux articles.

Enfin, nous pouvons également récupérer une seule entrée à l'aide d'une requête GET. Nous pouvons récupérer l'ID fourni en accédant à http://localhost:3000/posts/:id Single. article. #🎜🎜##🎜🎜#Avec ces étapes simples, nous pouvons implémenter une simple API REST et nous connecter à la base de données MongoDB. Bien sûr, il existe de nombreuses autres opérations qui peuvent continuer à améliorer cette API, telles que des opérations telles que la mise à jour et la suppression d'entrées, mais nous vous recommandons d'essayer d'écrire ces fonctions vous-même pour mieux comprendre le processus. #🎜🎜#

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!