精华内容
下载资源
问答
  • Ajax实现前后端数据交互(nodejs构建后端接口
    千次阅读 多人点赞
    2019-07-09 22:20:01

    navicat

    创建数据库
    create database 数据库名;
    创建数据表
    语法: create table 表名 (字段名 varchar(20), 字段名 CHAR(1));
    例如: create table peo (username varchar(20), sex varchar(20));
    添加数据
    往表中插入记录:
    语法: insert into 表名 values (“字段一对应值”,“字段二对应值”,…);
    insert into peo values (“张三”,“男”);
    insert into peo values (“李四”,“女”);
    insert into peo values (“王五”,“男”);
    查询数据
    select*from 表名
    修改数据
    update 表名 sex 字段名1=值1,[ 字段名2=值2,…] [ WHERE 条件表达式 ]
    删除数据
    delete from 表名 where

    链接数据库流程
    1.安装mysql模块 : cnpm install mysql
    2.在文件中导入mysql模块 : var mysql = require(‘mysql’);
    3.使用mysql对象的createConnection方法链接数据库

    var mysql = require('mysql'); //导入mysql模块
    var connection = mysql.createConnection({
    host : '127.0.0.1', //数据库地址
    user : 'root', //数据库用户名
    password : 'admin', //数据库密码
    database : 'logs_manager' //数据库名
    });
    connection.connect(); //启动链接
    //打印出来是一个数据库链接对象,包含了数据库的各种信息
    //与我们操作数据库的相关方法
    console.info(connection) ;
    

    查询数据库信息
    方法:connection.query(sql,function (err, result) {});
    Sql:表示要传入的操作数据库测sql语句
    Function(){}:表示操作返回查询结果的回调函数

    var sql = 'select * from peo where username="ww"';//像数据库查询
    var sql = 'update peo set sex ="nvhai" where username="ww"';//像数据库修改
    var sql = 'insert into peo values("ww","woman","19")';//添加
    var sql = 'delete from peo where username = "ls"';//删除
    

    预编译
    其实这里可以写成预编译的方式,可以避免sql注入的问题,所谓预编译就是说对于原本在sql里面写值换成?问号用来占位,然后传入一个数组进去补全这个占位符

    也就是connect.query方法会多一个参数,为一个数组,放入第二个位置。

    安装express构建服务器
    执行命令 cnpm install express 或者 yarn add express
    使用express构建服务器

    var express = require("express");//构建服务器
    var app = express();
    app.get("/", function(req, res) {
    res.send("Hello World");//向前端发送数据
    });
    app.listen(8081,function() {
    console.log("应用实例,访问地址为 http://127.0.0.1:8081");
    });
    

    用post获取,传参,添加到数据库
    HTML代码post比get更安全,存储的数据量更大

    <body>
        <form action="http://127.0.0.1:8080/add" method="POST">
            <input type="text" name="bookname">
            <input type="text" name="price">
            <input type="text" name="theme">
            <input type="text" name="pages">
            <button>按钮</button>
        </form>
    </body>
    

    创建数据库

    var mysql = require("mysql");
    function getconnect(){
        var connection = mysql.createConnection({
            host : '127.0.0.1', //数据库地址
            user : 'root', //数据库用户名
            password : 'qwerty', //数据库密码
            database : 'opt_test' //数据库名
            });
        return connection;
    }
    module.exports = getconnect;
    

    利用post实现操作数据库

    var newconnect = require("./nofz.js");//拉取数据库,下载的express和mysql不用相对路径
    var express = require("express");//构建服务器
    var app = express();//执行
    
    //使用bodyParser模块,接收post参数
    var bodyParser = require('body-parser');
    app.use(bodyParser.urlencoded({extended:false}));
    app.use(bodyParser.json());
    
    app.post("/",function(req,res){
       res.send("hello")
    })
    //增
    app.post("/add", function (req, res) {
        console.log(req.body);
        var getcon = newconnect();
        getcon.connect();
        var sql = `insert into books values(?,?,?,?)`
        getcon.query(sql, [req.body.bookname, req.body.price, req.body.theme, req.body.pages], function (flas, trve) {//function的第一个参数是请求对象,第二个参数是响应对象
            if (flas) {
                console.log("注册失败", flas.message);
            }
            if (trve.affectedRows > 0) {//受影响行数大于0,说明操作数据库成功
                console.log("注册成功")
            }
            getcon.end();//结束数据库
        })
        res.send("注册成功");//向前端发送数据
    });
    //获取地址
    app.listen(8080, function () {//第一个参数是地址
        console.log("应用实例,访问地址为 http://127.0.0.1:8080");
    });
    
    //1.创建AJAX对象
    var xhr = new XMLHttpRequest();
    //2.创建AJAX请求
    xhr.open("get", "http://127.0.0.1:8080");//post请求将参数传入send()方法中;
    //3.发送AJAX请求
    xhr.send();//post方法要加一句表头
    //4.监听AJAX请求状态
    // 通过onreadystatechange 方法即可请求监听状态
    xhr.onreadystatechange = function () {
        if (xhr.readyState == 4) { //判断请求是否完成
            if (xhr.status == 200) { //判断请求是否成功
                var val = xhr.responseText; //获取请求返回的数据
                console.info(val);
            }
        }
    }
    
    更多相关内容
  • nodejs写后端接口

    2021-09-08 08:08:23
    一、目录 ├─ server │ ├─ app.js │ ├─ controller │ │ ├─ account.js │ ├─ DBhelper ...二、封装接口mysql.js const mysql = require('mysql'); //创建连接池对象 const pool = mysql.creat

    一、目录

    ├─ server
    │ ├─ app.js
    │ ├─ controller
    │ │ ├─ account.js
    │ ├─ DBhelper
    │ │ └─ mysql.js
    │ ├─ package-lock.json
    │ ├─ package.json
    │ └─ routers
    │ ├─ account.js

    二、封装接口mysql.js

    const mysql = require('mysql');
    //创建连接池对象
    const pool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '密码',
        port: '3306',
        database: '数据库',
        },
        //tokenKey: "myUrl.com"
    );
    pool.on('connection', (connection) => {
        //logger.info("connection!");
    });
    
    pool.on('enqueue', () => {
        //logger.info('Waiting for available connection slot');
    });
    
    module.exports.Pool = pool;
    
    module.exports.getConnection = (cb) => {
        if (typeof cb == "function") {
            pool.getConnection(function (err, connection) {
                cb(err, connection);
            });
        } else {
            return new Promise((resolve, reject) => {
                pool.getConnection((err, connection) => {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(connection);
                    }
                });
            });
        }
    };
    module.exports.exec = (sql, values, cb) => {
        if (typeof cb == "function") {
            pool.getConnection((err, connection) => {
                if (err) {
                    connection.release();
                    cb(err);
                } else {
                    connection.query(sql, values, (error, rows) => {
                        connection.release();
                        cb(error, rows);
                    });
                }
            });
        } else {
            return new Promise((resolve, reject) => {
                pool.getConnection((err, connection) => {
                    if (err) {
                        connection.release();
                        reject(err);
                    } else {
                        connection.query(sql, values, (error, rows) => {
                            connection.release();
                            if (error)
                                reject(error);
                            else
                                resolve(rows);
                        });
                    }
                });
            });
        }
    };
    module.exports.beginTransaction = (connection, cb) => {
        if (typeof cb == "function") {
            connection.beginTransaction(function (err) {
                if (err) {
                    throw err;
                }
                cb(null, connection);
            });
        } else {
            return new Promise((resolve, reject) => {
                connection.beginTransaction(function (err) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(connection);
                    }
                });
            });
        }
    };
    module.exports.rollback = (connection, cb) => {
        if (typeof cb == "function") {
            connection.rollback(function () {
                connection.release();
                cb && cb();
            });
        } else {
            return new Promise((resolve, reject) => {
                connection.rollback(function (err) {
                    connection.release();
                    if (err) {
                        reject(err);
                    } else {
                        resolve();
                    }
                });
            });
        }
    };
    module.exports.commit = (connection, cb) => {
        if (typeof cb == "function") {
            connection.commit(function (err) {
                if (err) {
                    connection.rollback(function () {
                        cb && cb(err);
                        throw err;
                    });
                }
                connection.release();
                cb && cb();
            });
        } else {
            return new Promise((resolve, reject) => {
                connection.commit(function (err) {
                    if (err) {
                        connection.rollback(function () {
                            reject(err);
                        });
                    }
                    connection.release();
                    resolve();
                });
            });
        }
    };
    //检查是否链接失败
    this.getConnection((err, connection) => {
        if (err) throw err;
        else {
            // logger.info("connected success!");
            connection.release();
        }
    });
    

    三、controller和对应的router与app

    例如:account的controller

    const db = require("../DBhelper/mysql");
    //日期的库
    // const moment = require("moment");
    //MD5加密
    // const md5 = require("md5");
    
    //npm jwt-simple --save-dev  操作Token
    const jwt = require("jwt-simple");
    
    class AccountController {
        //登录的
        async login(request, response, next) {
            let loginSql = "select username,password from user WHERE username = ? and password = ?;";
            let params = [
                request.body.username,
                request.body.password,
            ]
    
            try {
                let result = await db.exec(loginSql, params);
    
                if (result && result.length >= 1) {
                    response.json({
                        code: 200,
                        msg: "登录成功",
                        data: result,
                        //token: createToken(result[0])
                    })
                } else {
                    response.json({
                        code: 200,
                        msg: "登录失败,帐号或密码错误",
                        data: result[0],
                    })
                }
            } catch (error) {
                response.json({
                    code: -200,
                    msg: "登录服务器异常",
                    error
                })
            }
            // function createToken(data) {
            //     return jwt.encode({
            //         //Token保存一天
            //         exp:DataCue.now() + (1000 * 60 * 60 * 24),
            //         info: data
            //     },require("myUrl.com"))
            // }
        }
    
        //注册的
        async register(request, response, next) {
            //insert into user('username','password') value ('','')
            let insertSql = "INSERT INTO user(username,password) VALUES (?,?);";
            let params = [
                request.body.username,
                request.body.password,
            ];
            try {
                let result = await db.exec(insertSql, params);
                //判断是否有被一行影响
                if (result && result.affectedRows >= 1) {
                    response.json({
                        code: 200,
                        msg: "注册成功",
                    })
                } else {
                    response.json({
                        code: 200,
                        msg: "注册失败",
                    })
                }
            }catch (err) {
                response.json({
                    code: -200,
                    msg: "服务器异常",
                    err
                })
            }
        }
    }
    module.exports = new AccountController();
    

    account对应的router:

    const express = require("express");
    
    let router = express.Router();
    
    //登录
    router.post("/login", require("../controller/account").login);
    //注册
    router.post("/register", require("../controller/account").register);
    
    module.exports = router;
    

    app.js

    const express = require("express");
    //引入封装好的mysql文件
    const db = require("./DBhelper/mysql.js");
    
    const server = express();
    
    
    //引入中间件 外部的功能强大
    // const bodyParser = require("body-parser");
    // server.use(bodyParser.urlencoded({extended:false}));
    // server.use(bodyParser.json());
    
    // server.all("*",function(req,res,next){
    //     //设置允许跨域的域名,*代表允许任意域名跨域
    //     res.header("Access-Control-Allow-Origin","*");
    //     //允许的header类型
    //     res.header("Access-Control-Allow-Headers","content-type");
    //     //跨域允许的请求方式 
    //     res.header("Access-Control-Allow-Methods","DELETE,PUT,POST,GET,OPTIONS");
    //     if (req.method.toLowerCase() == 'options')
    //         res.send(200);  //让options尝试请求快速结束
    //     else
    //         next();
    // })
    
    //引入中间件 自带的的功能小
    server.use(express.urlencoded({extended:false}));
    server.use(express.json());
    //路由
    server.use("/api/account",require("./routers/account.js"))
    server.use("/api/table",require("./routers/tablelist.js"))
    
    server.listen(8080, () => {
        console.log("服务器启动完毕!");
    })
    
    展开全文
  • Node.js之 express写后端接口

    千次阅读 2022-03-09 11:11:05
    参考 ...一 1 首先,新建一个Node.js项目,在项目目录下...2 可以用express来建立一个最简单的后端server服务 新建一个server.js文件 const express = require('express'); const app = express(); app.get('/', (req, r

    参考

    https://blog.csdn.net/studysinklc/article/details/103166451

    1 首先,新建一个Node.js项目,在项目目录下安装express

    npm install express --save
    

    2 可以用express来建立一个最简单的后端server服务

    新建一个server.js文件

    const express = require('express');
    const app = express();
    
    app.get('/', (req, res) => res.send('hello world!'));
    
    app.listen(3000, () => console.log('Example app listening on port 3000!'));
    

    3 在命令行里用 Node server.js 启动

    在这里插入图片描述
    访问成功

    跨域

    为了能在前端调用,必须实现跨域,我们采用Node.js里的cors模块在后端实现跨域

    安装cors模块

    npm install cors --save
    

    在server.js里调用cors模块

    const cors = require('cors');
    app.use(cors());
    

    同时我们新加一个test接口,依然是用get方法,返回一个json,供前端调用

    app.get('/test', cors(), (req, res, next) => res.json({msg: 'This is a cros test.'}));
    

    完整 server.js

    const express = require('express');
    
    const cors = require('cors');
    
    const app = express();
    
    const bodyParser = require('body-parser');
    
    // 调用 cors模块
    
    app.use(cors());
    
    app.use(bodyParser.json());
    
    // 下面是接口 
    // http://127.0.0.1:3000/
    
    app.get('/', (req, res) => res.send('Hello!'))
    
    app.get('/get-test', cors(), (req, res, next) => res.json({msg: 'This is a cros test.'}));
    
    app.post('/post-test2', cors(), (req, res, next) => {
        res.setHeader('Content-Type', 'text/plain');
        res.write("your post is: \n");
        res.end(JSON.stringify(req.body));
    });
    
    
    app.listen(3000, () => console.log('Example app listening on port 3000!'));
    

    调用本地数据库

    参考 https://blog.csdn.net/qq_45152044/article/details/122310270

    1 在终端输入:npm i mysql

    2 使用mysql模块 (在js文件中编写)

    //引入mysql模块
    const mysql = require('mysql');
    
    //配置mysql访问方式
    const db = mysql.createConnection({
      host:'localhost',
      user:'root',
      //你的mysql密码
      password:'root',
      //你要连接的数据库
      database:'mydb'
    });
    
    //接收前端的数据   第一个是接口的名字
    app.get('/login',function(request,response){
    	  // request 请求,前端向后端请求
    	  // response后台给前端的反馈
    	  // request.query  前端发过来的get请求数据
      
      //查询语句
      const sql = `select * from user1 where username='${request.query.username}' and password = '${request.query.password}'`
      //在数据库中查询,err是错误信息,data是查询后的结果以对象的形式返回
      db.query(sql,function(err,data){
        if(err){
           console.log(err)
        }else{
          //data.length=1,即长度为1,直接简写
          if(data.length){
            //输入正确登录成功
            response.send({code:200,msg:'登录成功!'})
          }else{
          	//输入账号密码错误
            response.send({code:500,msg:'账号密码错误'})
          }
        }
      })
    

    结果

    在这里插入图片描述
    读取本地json文件

    app.js 同 上面的 server.js ,启动命令 node app.js

    const fs = require("fs"); // 文件模块
    const path = require("path"); // 系统路径模块
    
    const express = require("express"); // node.js Web 应用框架
    const bodyParser = require("body-parser"); // node.js 中间件,用于处理 JSON, Raw, Text 和 URL 编码的数据
    
    const app = express();
    app.use(bodyParser.json()); // 返回一个只解析 json 的中间件,最后保存的数据都存放在 request.body 对象上
    app.use(
      bodyParser.urlencoded({
        extended: true
      })
    ); // 返回的对象为任意类型
    
    // 设置跨域访问
    app.all("*", function(request, response, next) {
      response.header("Access-Control-Allow-Origin", "*"); // 设置跨域的域名,* 代表允许任意域名跨域
      response.header("Access-Control-Allow-Headers", "X-Requested-With");
      response.header(
        "Access-Control-Allow-Methods",
        "PUT,POST,GET,DELETE,OPTIONS"
      );
      response.header("X-Powered-By", " 3.2.1");
      response.header("Content-Type", "application/json;charset=utf-8");
      next();
    });
    
    // get 首页数据
    app.get("/api/index.json", (request, response) => {
      request.statusCode = 200;
      const file = path.join(__dirname, "./api/index.json");
      fs.readFile(file, "utf-8", (err, data) => {
        if (err) {
          response.send("文件读取失败!");
        } else {
          response.send(data);
        }
      });
    });
    
    // get 城市列表数据
    app.get("/api/city.json", (request, response) => {
      request.statusCode = 200;
      const file = path.join(__dirname, "./api/city.json");
      fs.readFile(file, "utf-8", (err, data) => {
        if (err) {
          response.send("文件读取失败!");
        } else {
          response.send(data);
        }
      });
    });
    
    // get 详情页数据
    app.get("/api/detail.json", (request, response) => {
      request.statusCode = 200;
      const file = path.join(__dirname, "./api/detail.json");
      fs.readFile(file, "utf-8", (err, data) => {
        if (err) {
          response.send("文件读取失败!");
        } else {
          response.send(data);
        }
      });
    });
    
    // 配置服务端口
    
    const hostname = "localhost";
    const port = 8082;
    const server = app.listen(port, hostname, () => {
      console.log(`服务器运行在 http://${hostname}:${port}`);
    });
    
    // const hostname = '127.0.0.1';
    // const port = 3000;
    // const server = app.listen(port,hostname, () => {
    //   console.log(`服务器运行在 http://${hostname}:${port}`);
    // });
    

    读取的 json文件 为 新建api中的 index.json 等等json文件

    {
    "ret": true,
    "data": {
        
        "swiperList": [{
                "id": "001",
                "src": "https://th.wallhaven.cc/small/96/96w8e8.jpg"
            },
            {
                "id": "002",
                "src": "https://th.wallhaven.cc/small/13/13mk9v.jpg"
            }
        ],
        "iconList": [{
                "id": "001",
                "imgSrc": "http://img1.qunarzz.com/piao/fusion/1803/95/f3dd6c383aeb3b02.png",
                "txt": "景点门票"
            },
            {
                "id": "002",
                "imgSrc": "http://mp-piao-admincp.qunarzz.com/mp_piao_admin_mp_piao_admin/admin/20193/f0f00d6dfe038c044dbc9a437f58b0eb.png",
                "txt": "一日游"
            }
        ],
        "recommendList": [
            {
              "id": "001",
              "imgUrl":
                "http://img1.qunarzz.com/sight/p0/1902/84/84696f368bbec10da3.img.jpg_200x200_50323152.jpg",
              "infoTit": "北京世界园艺博览会",
              "infoTxt": "80条评论",
              "infoMoney": "108"
            },
            {
              "id": "002",
              "imgUrl":
                "http://img1.qunarzz.com/sight/p0/1409/19/adca619faaab0898245dc4ec482b5722.jpg_200x200_1bc99086.jpg",
              "infoTit": "故宫",
              "infoTxt": "659条评论",
              "infoMoney": "60"
            }
          ],
          "weekendList": [
            {
              "id": "001",
              "imgUrl":
                "http://img1.qunarzz.com/sight/source/1603/6d/2f67ae0659f41f.jpg_r_640x214_bf6cbd0b.jpg",
              "infoTit": "北京赏花好地方",
              "infoTxt": "乱花渐欲迷人眼,京城赏花大搜索"
            },
            {
              "id": "002",
              "imgUrl":
                "http://img1.qunarzz.com/sight/source/1811/f3/86173f863bef61.jpg_r_640x214_52b003ac.jpg",
              "infoTit": "京城周末撒欢",
              "infoTxt": "在帝都过周末,不仅仅是城中游!"
            }
          ]
    }
    }
    
    展开全文
  • nodejs实现后台服务端api的例子基本用法和基础知识
  • 过了两个微信的页面,遇到了挺多不会的问题,当时也是自己边查资料,边实践完成了简单的需求,刚好现在有空,把之前的东西整理一遍。...后端返回接口 在前端调用时wx.config({…})中需要的参数需要我们
  • nodejs后端请求案例

    千次阅读 2019-05-25 21:50:55
    第一步:初始化项目 npm init 第二步,安装所需配置 我用的的是express框架,配合moment(时间格式化)中间件+cors中间件(跨域用)+body-...第三步,在index.js引入配置,连接数据库,写接口 const express = requ...

    第一步:初始化项目

    npm init

    第二步,安装所需配置
    我用的的是express框架,配合moment(时间格式化)中间件+cors中间件(跨域用)+body-parser(解析表单)+mysql中间件
    express为例:

    npm install express --save

    第三步,在index.js引入配置,连接数据库,写接口

    const express = require('express');
    const app = express();
    const moment = require('moment')
    //导入cors模块,该模块为跨域所用
    const cors = require('cors');
    app.use(cors());
    //解析表单的插件
    var bodyParser = require('body-parser')
    app.use(bodyParser.urlencoded({ extended: false }))
    app.use(bodyParser.json())
    
    //创建数据库连接对象
    const mysql = require('mysql');
    const conn = mysql.createConnection({
        host: 'localhost',//数据库地址
        user: 'root',//账号
        password: '******',//密码,填写自己数据库密码
        database: 'myblog',//库名
        port:'3306',     //端口号
        multipleStatements: true //允许执行多条语句
    })
    
    conn.connect(function(err){
        if(err){
          console.log('---:'+err);
          return;
        }
        console.log('连接succeed');
    });
    //查看
    app.get('/api/getlist', (req, res) => {
        const sqlStr = 'select * from userlist'
        conn.query(sqlStr, (err, results) => {
            if (err) return res.json({ err_code: 1, message: '资料不存在', affextedRows: 0 })
            res.json({ retCode: 200, data: results, affextedRows: results.affextedRows })
        })
    })
    
    //添加
    app.post('/api/adduser', (req, res) => {
        debugger
        const user = req.body
        user.id =new Date().getTime()
        const sqlStr = 'insert into userlist set ?'
        console.log(user)
        conn.query(sqlStr, user, (err, results) => {
            if (err) return res.json({ err_code: 1, message: err, affectedRows: 0 })
            res.json({ retCode: 200, message: '恭喜成功', affectedRows: results.affectedRows })
        })
    })
    app.listen(3000, () => {
        console.log('正在监听端口3000,http://192.168.0.1:3000'); //192.168.0.1换成你的ip,本机ip查询用cmd=>ipconfig
    })

    第四步,我们就按照平时写前端项目的步骤,调用接口就行。

    展开全文
  • console.log(time) 三、导入数据库模块的命令 npm install mysql --save 四、导入随机生成验证码的模块 导入svg-captcha模块的指令 npm install --save svg-captcha 在路由接口中里面调用 r.get('/code',(req, res...
  • nodejs后端 如您所知,如今对于所有类型的初创公司来说,安全性都变得越来越重要。 作为启动所有者,首先应注意Web应用程序的安全性。 请记住,用户信任您的信息,因此您应该专业地关心他们的数据,否则,如果有人...
  • nodejs 安装应用框架,可以访问npmjs.com 进行查找 进入需要编译的位置,打开cmd 在项目目录下输入指令npm init -y,进行初始化 得到一个json文件如下 { "name": "4day", "version": "1.0.0", "description...
  • 前端通过nodejs调用后端接口,相比于直接调用后端接口,这样有什么好处吗?
  • 1、后端返回base64格式的文件数据: // 异步读取文件为base64格式 let data = fs.readFileSync(path); data = new Buffer(data).toString('base64'); 2、base64格式在前端转回数组格式 // base64转比特,n为长度,...
  • 【node】nodejs原生搭建后端服务

    千次阅读 2021-10-28 10:26:19
    我们可以在用户登录之后,把用户信息到cookie,之后此域名下所有页面都能访问到这个用户信息。 可以在控制台看到详细的cookie信息。 在登录成功之后,在cookie中写入用户信息。 ./src/router/user.js if(req....
  • nodejs 服务后端运行

    千次阅读 2017-12-04 02:51:35
    后端运行nodejs 1.linux个检测服务,定时拉起服务 2.nodejs 自带的nohup 待续研究 3.安装插件forever npm install -g forever forever start server.js 或者 forever start -o out.log -e err.log -l ...
  • <NodeJS>使用express快速开发后端接口

    千次阅读 2020-02-20 17:03:11
    使用express快速开发后端接口 项目使用pm2部署在nginx服务器上。可以实现json文件接口化处理。 express + 项目名 yarn 装依赖 Scripts node改nodemon /app.js var mockRouter = require('./routes/mock'); ...
  • main.js(入口文件,开启9999端口监听,实现RESTful风格接口访问) const express = require("express"); const app = express(); const port = 9999;//设置端口号,如果端口号被占用需要自己修改,否则无法跑起来...
  • 用Flask写后端接口

    千次阅读 2021-01-29 16:12:46
    往期直达:为什么选择Flask,因为接下来要更新深度学习的相关技能了,用到的是python,为了给前端提供api,选择了python的Flask来开发web应用的后端服务,Nodejs不够用了哈。01安装Flask确保已经安装过python,可以...
  • //生成token ... //1、登录成功服务端生成一个字符串作为token //2、只要有token,说明用户已经登录了 //npm install jsonwebtoken --save const jwt = require('jsonwebtoken'); const signStr.
  • Nodejs后端框架搭建(express)

    千次阅读 2020-10-16 12:29:49
    res.status(500) res.send('down...') } app.use(errorHandler) 使用时需要注意两点: 参数一个都不能少,否则会被视为普通的中间件 中间件需要在请求之后引用 如果想要学习更多关于nodejs写接口可以看我 这篇博客
  • Node.js Express框架 后台接口API

    千次阅读 2020-01-21 23:38:43
    首先Chrome中安装好Postman插件(可以拟前端带参数发送请求到后端) 【1】初始化项目 1.1. 应用生成器Express的安装 这是为了快速创建一个Express应用的“骨架”,安装后express命令就可以使用了 ...
  • const mysql = require('mysql'); const connection = mysql.createConnection({ host:'', //域名 ... database:'', //数据库名 }); ...function requestQuery(sql){ //参数sql为sql语句 return new Promise.
  • 用于练习,用nodejs写后端接口,vue前端,express搭建服务器,本地一切顺利(除了我这该死的审美观和黄豆大小的创造力) 将项目部署在服务器后,我欣喜若狂的在本机访问,然后…头部出现了!!!入口一个都没有… ...
  • 摘要:这篇文章主要的目的是分享一个可与后端接口通信的自动化脚本插件,实现不同环境下可打包成不同配置的微信小程序源码。全程靠命令行自动发起请求、修改配置文件、自动编译,解放双手不是梦!
  • 后端nodejs的restful接口

    2020-01-11 21:00:30
    var express = require('express'); app = express(); /**读取body中的json请求数据,前端post请求时发送来的json对象 */ var bodyParser = require('body-parser') app.use(bodyParser.urlencoded({ ...
  • 一、创建nodejs 首先执行下边的命令,会得到一个类似vue-cli的node架包,以此为基础进行开发...在config中进行一下配置,mysql对象中的数据需要和数据库初始化时候的一样才行,这样数据库就搞好了,开始写接口了。 mysq
  • 博士做的钓鱼研究。其中有一章节,“how easy is it to launch a phishing attack”。主要来讲,现在做一个钓鱼网站,是一件多么简单的事情。...今天就用nodejs写一个简单的例子。可以接受前端发过来的数
  • nodejs5:后端MVC架构

    千次阅读 2020-05-26 22:35:41
    mvc三层架构 mvc 即 model 、controller、view;...后端分层 最外层路由层,用于分发HTTP请求 control层,参数校验和返回数据 server层,处理业务逻辑,需要连接数据库 module层,用于和db交互 mvc架构的好处 先

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,922
精华内容 6,368
关键字:

nodejs写后端接口