使用mongodb数据库+node.js封装接口详细过程

学习内容：

使用mongodb存储数据，用node语言编写后端

学习产出：

【下载mongoose依赖包】

npm install mongoose

【创建一个js文件】

keys.js

文件写入路径配置（模块入口）

module.exports = {
  mongoURI: "mongodb://localhost/playground",
  secretOrkey: "secret",
};

mongoURI是连接mongodb数据库的路径，路径中的数据库(此代码的数据库名为playground)不存在则会创建该数据库。

【server.js入口文件】

导入mongoose

const mongoose=require("mongoose");

---

引入keys.js

const db=require("./config/keys").mongoURI;

---

连接数据库

mongoose
  .connect(db)
  .then(() => console.log("数据库连接成功"))
  .catch((err) => console.log(err, "数据库连接失败"));

【搭建路由】

新建文件夹routes

在routes中新建文件 users.js

1.需要导入express、router

const express = require("express");
const router = express.Router();

2.即可使用router提供的方法

router.get("/test",(req,res)=>{

res.json({msg:"user"})})

注册登录使用post，token验证使用get

还是要将users.js文件引入到server.js入口文件中

const users=require("./routes/api/users");

引入后要使用routes

app.use("api/users"，users)

【创建模型】存储响应的数据

新建文件夹models

新建文件 Users.js

1.导入mongoose   使用mongoose.Schema

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

2.创建Schema

const UserSchema = new Schema({
  name: {
    type: String,
    required: true,
  },
  email: {
    type: String,
    required: true,
  },
  password: {
    type: String,
    required: true,
  },
  avatar: {
    type: String,
  },
  identity: {
    type: String,
    required: true,
  },
  date: {
    type: Date,
    default: Date.now,
  },
});

3.暴露接口User

module.exports = User = mongoose.model("users", UserSchema);

4.在接口server.js文件去使用

【搭建注册接口并存储数据】

 使用post请求数据需要安装第三方库   在server.js中去引入

以及使用body-parser中间件

 npm install body-parser

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

users.js文件

注册用户

router.post("/register", (req, res) => {
  console.log(req.body);
  //查询数据库中是否拥有邮箱
  User.findOne({ email: req.body.email }).then((user) => {
    if (user) {
      return res.status(400).json("邮箱已被注册！");
    } else {
      const avatar = gravatar.url(req.body.email, {
        s: "200",
        r: "pg",
        d: "mm",
      });
      const newUser = new User({
        name: req.body.name,
        email: req.body.email,
        //相同名字写一个
        avatar,
        password: req.body.password,
        identity: req.body.identity,
      });
      //saltRounds：加密的模式--10
      // bcrypt.genSalt(saltRounds, function (err, salt) {
      //   bcrypt.hash(myPlaintextPassword, salt, function (err, hash) {
      //     // Store hash in your password DB.
      //   });
      // });
      bcrypt.genSalt(10, function (err, salt) {
        bcrypt.hash(newUser.password, salt, function (err, hash) {
          // Store hash in your password DB.
          if (err) throw err;
          newUser.password = hash;
          newUser
            .save() //存储方法
            .then((user) => res.json(user)) //如果返回成功
            .catch((err) => console.log(err));
        });
      });
    }
  });
});

【登录】

密码匹配==当前请求的与数据库存储的比较     使用jwt返回token

//3.登录密码匹配
//$route POST api/users/login
//@desc 返回token jwt passport
//@access public
router.post("/login", (req, res) => {
  const email = req.body.email;
  const password = req.body.password;
  //查询数据库
  User.findOne({ email }).then((user) => {
    if (!user) {
      return res.status(404).json("用户不存在!");
    }
    // 密码匹配（当前请求到前端的密码与数据库存储的密码对比）
    bcrypt.compare(password, user.password).then((isMatch) => {
      if (isMatch) {
        //jwt.sign("规则","加密名字","过期时间","箭头函数")签名
        const rule = {
          id: user.id,
          name: user.name,
          avatar: user.avatar,
          identity: user.identity,
        };
        jwt.sign(rule, keys.secretOrkey, { expiresIn: 3600 }, (err, token) => {
          if (err) throw err;
          res.json({
            success: true,
            token: "Bearer " + token,
          });
        });
        //res.json({ msg: "success" });
      } else {
        return res.status(400).json("密码错误!");
      }
    });
  });
});

【验证token】

使用passport  ==  要对其初始化（server.js）引入passport.js 文件并传入passport（目的：可以直接使用passport不用导入了）

app.use(passport.initialize());

require("./config/passport")(passport);

config文件夹创建一个文件passport.j

const JwtStrategy = require("passport-jwt").Strategy;
const ExtractJwt = require("passport-jwt").ExtractJwt;
const mongoose = require("mongoose");
const User = mongoose.model("users");
const keys = require("../config/keys");

const opts = {};
opts.jwtFromRequest = ExtractJwt.fromAuthHeaderAsBearerToken();
opts.secretOrKey = keys.secretOrkey;

module.exports = (passport) => {
  passport.use(
    new JwtStrategy(opts, (jwt_payload, done) => {
      // console.log(jwt_payload);
      User.findById(jwt_payload.id)
        .then((user) => {
          if (user) {
            //done回调，null对象，返回user
            return done(null, user);
          }
          return done(null, false);
        })
        .catch((err) => console.log(err));
    })
  );
};

//4.验证token
//$route GET api/users/current（信息）
//@desc 返回 current user
//@access private
// router.get("/current","验证token(passport-jwt)",(req,res)=>{
//   res.json({msg:"success"})
// })
router.get(
  "/current",
  passport.authenticate("jwt", { session: false }),
  (req, res) => {
    res.json({
      id: req.user.id,
      name: req.user.name,
      email: req.user.email,
      identity: req.user.identity,
    });
  }
);

这是users,js文件请求当前的用户信息，passport.js是通过passport-jwt方法验证