Home > Article > Web Front-end > Deploy nodejs rest api
In today's Internet era, building efficient and fast back-end services is essential. NodeJS excels in this area, making it fast and easy to build efficient web services. REST API is also a very popular method of building web services in today's Internet industry. It can greatly reduce the amount of code, simplify port handling, and has many benefits. In this article, we will learn how to quickly deploy REST API using NodeJS and ExpressJS.
Before we start, we need to set up an environment:
First, we open the terminal and create a New project directory:
mkdir project-name cd project-name
Then, we use npm init
to create a new package:
npm init
npm init
You will be asked to enter Some basic information, such as author name, project name, version, etc. Some default settings can be used directly, just modify some of your own information.
Next, we will need to install the following dependencies:
npm install express body-parser cors —save
Now, let’s do Create a new file called app.js
, this will be the starting point for our NodeJS REST API service. We can build this service with the help of the Express framework:
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}`) })
In the above code snippet, we import Express, body-parser and cors. We also used the app.listen()
method that listens on port 3000. Finally, we enable the cors and body-parser middleware through the app.use()
method.
The next step will be to create routes, which are required to implement our REST API service. Routing can be understood as a set of rules for how the service should respond after a request enters the service.
We can create a routes
folder in the project root directory, create the index.js
file in it, and add the following content:
const express = require('express') const router = express.Router() router.get('/posts', (req, res) => { res.status(200).send('All posts') }) module.exports = router;
In the above code, we create a new route and create a GET request for /posts
on the route. The request will return a status code of 200 and the text "All posts".
Next, we will enable the route. We go back to the app.js
file and add the following:
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}`) })
In the above code, we import the route defined in routes/index.js
and Use the app.use('/api', postRoutes)
method to apply routes to our REST API service. Then, when calling a GET request at localhost:3000/api/posts
, it should return "All posts".
Of course, in a real project, the data we need to request and obtain will be stored in the database, so we need to discuss here how to use NodeJS to connect to the database .
We will use MongoDB as our database and mongoose
to connect to it. We can install mongoose by running the following command in the command line:
npm install mongoose --save
Next, let’s create a models
folder and add a new file in it post. js
to describe a simple data model.
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);
In the above code, we defined a model called Post
to define our data and used the timestamps option when creating it.
Now, we are going to use Mongoose to connect to the local MongoDB database. You can add the following content in the app.js
file:
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}`); });
The database URL of the above code is set to mongodb://localhost/posts
, which means that the database name is posts
and is located in our local MongoDB instance. We also used the default port (27017) for the Mongoose port. Note that the deprecated code in Mongoose has been fixed, so we have to use the useUnifiedTopology option.
We have set up routing in the server and can successfully connect to our database. Next, we'll configure more routes to handle POST requests and get data from our database.
First, we add a new POST request to our route and extract the title, content, author, and other necessary information from the request body. and store the data into the database. Here, we will create a MongoDB document assuming a database named "posts" and passing the Post
model itself.
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;
In the code at the top, we first import our model file and create all the required routes for GET or POST requests. The GET request uses Post.find()
to extract all database entries from the MongoDB database, while our POST request uses newPost.save()
to store new data into the database table.
After completing the above steps, you can use Postman to test our REST API.
First, we try to retrieve data using a GET request. We can retrieve all posts by accessing http://localhost:3000/posts
.
Next, we try to create new data using a POST request. We can do this by visiting http://localhost:3000/posts
and adding a new JSON data body in the body of the request. to create a new article.
Finally, we can also retrieve a single entry using a GET request. We can retrieve a single post provided by the ID by accessing http://localhost:3000/posts/:id
.
With these simple steps, we can implement a simple REST API and connect to the MongoDB database. Of course, there are many other operations that can continue to improve this API, such as operations such as updating and deleting entries, but we recommend that you try to write these functions yourself to gain a deeper understanding of the process.
The above is the detailed content of Deploy nodejs rest api. For more information, please follow other related articles on the PHP Chinese website!