In data interaction, the front end will initiate an ajax request. The request method is as follows:\
$.ajax({ type:'post', // Request mode type url:'http://127.0.0.1:8080/user ', / / the api interface address corresponding to the request data:{name:'zs'}, //Submitted data success:function(res){ // Callback function requested console.log(res) } })
The back-end api will respond to the front-end request as follows:
const express = require('express') //Import express server module const mysql = require('mysql') //Import mysql database module const cors = require('cors') //Import cross domain modules const app = express() // Instantiate a server object const db = mysql.createPool({ //Create a database connection instance object host: '127.0.0.1',//Address to connect to the database user: 'root', // Login account name to connect to the database password: 'admin123', //Password to connect to the database database: 'my_db_01', //Name of the connection database }) app.use(express.urlencoded({extended:false})) // Mounting data transcoding Middleware app.use(cors()) // Mount cross domain Middleware app.post('/user',(req,res)=>{ // Listen to the post request whose api interface is / user (compared with js click event listening) db.query('update user set ? where id = ?',[req.body,req.body.id),(err,data)=>{ //Fill the fields in the query statement by splicing? In the placeholder, multiple fields need to be written in an array in order. The data sent by the client will be mounted in the body attribute of req and can be obtained through req.body. In addition, req.query obtains the request field of get request if(err){return res.send({ //If the database connection fails, you need to prompt the user status:1, // 0 and 1 have no specific requirements, but personal settings represent success or failure message:err.message })} if(data.affectedRows != 1){ res.send({ //If the returned affected value of the database parameter is not 1 when operating the database, it indicates that the operation has failed and the user needs to be prompted status:1, message:'request was aborted' }) } res.send({ //After eliminating all possible failures, the server response value for successful completion is sent to the client status:0, message:'Request succeeded' }) }) }) app.listen(8080,()=>{ //Start the server console.log('Start successful') }) //So far, a simple server api interface has been written. In fact, there are many places that can be improved and optimized. Some, such as local middleware for format verification, modular processing, etc., are not used, but it is enough to explain the principle of front-end and back-end interaction
Summary: after learning this part of knowledge, I found that the original post request and get request do not necessarily represent writing data to the server and requesting data from the server. Their specific functions are determined according to the operation methods written therein, and the decision-making method of using them is what data to submit to the server, For example, is it the data of req.body or the request field of req.query.
The client submits the data to the server. After processing, the server returns the response value to the client through res.send(). The client receives and returns the response value through the res parameter of the success function
Attached:
1. For the res.send() part with high repetition, a unified processing middleware can be mounted in the js module for final integration operation (temporarily called app.js). The code is as follows:
app.use(function (req, res, next) { //The next callback function unique to ordinary middleware is used to realize data flow to the next middleware or route res.cc = function (err, status = 1) {// status = 0 means success; status = 1 means failure; By default, the value of status is set to 1 to facilitate failure handling res.send({ // state status, // State description to determine whether err is an error object or a string message: err instanceof Error ? err.message : err, }) } next() })
Note: this method is to attach a method named cc to res, where the formal parameter err represents the message content returned by res.send(), and status represents the status code. There are three main methods:
(1) res.send(err). In the if(err) {} statement to judge whether the database connection is successful, err passes in an error object, so status: 1 and message: err.message are output through res.cc()
(2) res.send('Send failed '). In the if (data. Affectedrows! = 1) {} statement, the output is status: 1 and message:' send failed '
(3) res.send('processing succeeded ', 0). In res.cc(), the output is status:0,message:' sending succeeded '
In this way, the code of routing processing function is simplified
2. Use of token
(1) In the js file of the login module, write the following code:
const jwt = require('jsonwebtoken')// Import the JSON webtoken package to generate the Token string const config = require('../config') //Import a configuration file dedicated to sharing encryption and resolving and restoring token keys outward //There is only one line of code: module.exports = {jwtSecretKey:'aaa'} const tokenStr = jwt.sign(user, config.jwtSecretKey, { //Generate token string expiresIn: '10h', // The valid period of the token is 10 hours }) res.send({ // The code here cannot be replaced by res.cc() because there are multiple token parameters status: 0, message: 'Login succeeded!', token: 'Bearer ' + tokenStr, // In order to facilitate the client to use Token, the prefix Bearer is directly spliced on the server }) ///The above is the code of the login module js file
(2) In the integration module app.js, the corresponding parsing middleware needs to be mounted before registering the route
The code is as follows:
const config = require('./config')// Import profile const expressJWT = require('express-jwt')// Middleware for parsing token app.use(expressJWT({ secret: config.jwtSecretKey }).unless({ path: [/^\/api\//]}) / / use. Unless ({path: [/ ^ \ / API \ / /]}) to specify which interfaces do not require Token authentication
(3) In the error level middleware of app.js, you need to capture the error of token authentication failure to avoid collapse caused by authentication failure
app.use(function (err, req, res, next) {// Error Middleware // Code for other error capture is omitted here if (err.name === 'UnauthorizedError') return res.cc('Identity authentication failed!') // Error capturing authentication failure })
3. In the actual development, it also includes the local middleware module for format verification and the bcryptjs module for storing the garbled code after converting the user password to the encrypted state into the database, which will not be listed here