express实现JWT用户认证系统

发表于 |

介绍

掌握本文知识点之前需要了解的技术点有：

JavaScript，express，MongoDB，jsonwebtoken，redis，docker

因为MongoDB和redis我是通过docker运行的，所以需要一点docker的知识。

了解以上知识点之后，下面就直接撸代码，大部分都是用户系统需要用到的业务逻辑，文章最后会放出源码地址，代码中大都实现了模块化处理，需要的验证的可以下载源码参考，自行编译。

config模块

项目中需要配置的动态信息我都放在了config模块，比如验证码过期时长，加密密钥，mongo地址等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var isthinkpad=true
var mail = {
    host: 'smtp.163.com',
    user: 'xxx@163.com', // generated ethereal user
    pass: 'xxxxxx', // generated ethereal password
    from: '"Fred Foo" <xxxx@163.com>', // sender address
    to: 'xxxx@qq.com,', // list of receivers
}
module.exports = {
    codeexpire:180,//秒
    jwtsecret:"jjjjjj",
    md5secret:"jkkks934(EIURLOE(W)WF<{fs;f{{",
    mongolink:isthinkpad?'mongodb://test:123456@192.168.99.100:27017/test':'mongodb://test:123456@localhost:27017/test',
    redislink:isthinkpad?'192.168.99.100':'localhost',
    mail:mail,
}

注册逻辑

实现数据库连接

1
2
3
4
5
6
7
var config = require('./config')
var mongoose = require('mongoose');
mongoose.connect(config.mongolink, { autoIndex: false, useNewUrlParser: true});
var db = mongoose.connection;
db.on('error', console.error.bind(console, '数据库connection error:'));

数据库连接单独封装到mongoconn模块中，在server开始启动中调用

1
2
//mongodb
require('./mongoconn')

实现用户model

1
2
3
4
5
6
7
8
9
10
11
12
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var User = mongoose.model('User', new Schema({ 
    username: String, 
    password: String
}))
// 返回一个mongo用户库实例
module.exports = {
    user: User
};

实现User模型，用于CRUD功能，由于只是实现注册登录的效果，所以字段只设置了username和password，根据业务功能可以自行更改。

判断参数是否合法

1
2
3
4
5
6
7
8
9
route.post('/register', (req, res) => {
    var username = req.body.username
    var password = req.body.password
    //是否合法的参数
    if (username == null || username.trim() == '' || password == null || password.trim() == '') {
        res.send(response.err("用户名或密码不能为空"))
        return
    }

判断用户参数是否合法需要很多判断条件，目前这些判断条件业务不是很全，可以根据测试不断增加。

判断用户是否已注册

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//是否存在用户
User.findOne({ username: username }).then((data) => {
    console.log(data)
    return new Promise((resolve, reject)=>{
        if (data) {
            res.send(response.err("用户已注册过"))
            reject()
        }
        else {
            resolve()
        }
    })
}).then(() => {
    //存储
    return new User({
        username: username,
        password: common.md5(password)
    }).save()
}).then((data) => {
    console.log(data)
    if (data) {
        //返回
        res.send(response.succ("注册成功"))
        return
    }
    
    //返回
    res.send(response.err("注册失败"))
}).catch((err)=>{
    //异常
    if (err) {
        console.log(err)
    }
})

使用user模型查询是否已存在用户注册，因为查询是异步的，所以使用返回一个promise作为查询结果，然后进行链式结果的传输，其中密码使用md5加密，防止数据泄露。

发送验证码逻辑

业务上对于以上注册api调用之前，应该先调用验证码接口，比如邮箱注册调用邮箱验证，手机注册调用手机验证，所以就实现了手机和邮箱验证的模块。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
var response = require('./response')
var express = require('express')
var route = express.Router()
var sendverycode = require('./sendverycode')
var common = require('./common')
var config = require('./config')
var expire = config.codeexpire
var redis = require('./redis')
route.post('/verycode', function (req, res) {
    //生成6位验证码
    var vcode = Math.ceil(Math.random() * (1000000 - 100000) + 100000)
    console.log(vcode)
    if (req.body.type == 1) {//邮件
        var mail = req.body.mail
        if (common.ismail(mail) == false) {
            res.send(response.err('请输入正确的邮件地址'))
            return
        }
        verify(mail)
    }
    else {//手机
        var phone = req.body.phone
        if (common.isphone(phone) == false) {
            res.send(response.err("请输入正确的手机号"))
            return
        }
        
        verify(phone)
    }
    function verify(key){
        redis.getkey(key).then((data)=>{
            if (data) {
                res.send(response.err('验证码已发送' + expire + '秒后再重新请求'))
                return
            }
            res.send(response.succ("验证码已发送"))
            if (common.ismail(key)){
                return sendverycode.mail(key, vcode)
            }
            else{
                return sendverycode.phone(key, vcode)
            }
        }).then((data) => {
            if (data) {
                console.log('验证码发送成功')
                redis.setkv(key,vcode,expire).then((data)=>{
                    console.log('验证码保存redis成功'+expire+'秒后超时')
                })
            }
            else {
                console.log('验证码发送失败')
            }
        })
    }
})
module.exports = route

首先生成了6位的验证码，根据type判断是邮箱验证，还是手机验证，发送成功后，把验证码放到redis里面，用于过期判断。

登录逻辑

判断用户密码是否正确

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var response = require('./response')
var model = require('./model')
var User = model.user
var express = require('express')
var route = express.Router()
var common = require('./common')
route.post('/login', function(req, res){
    var username = req.body.username
    var password = req.body.password
    //是否合法的参数
    if (username == null || username.trim() == '' || password == null || password.trim() == '') {
        res.send(response.err("用户名或密码不能为空"))
        return
    }
    User.findOne({username:username, password: common.md5(password)}).then((data)=>{
        return new Promise((resolve, reject)=>{
            if(data){
                resolve(data)
            }
            else{
                res.send(response.err("用户名或密码错误"))
                reject()
            }
        })
    })

把username和password作为条件放在用户表中查找，根据返回判断用户密码是否正确。登陆成功后就开始进行下一步操作。

生成token返回用户

1
2
3
4
5
6
7
8
9
then((data)=>{
        console.log(data)
        var token = common.signtoken(JSON.stringify(data))
        res.send(response.succ("用户登录成功", {token: token}))
    }).catch((err)=>{
        if(err){
            console.log(err)
        }
    })

把data放到token里面，返回给用户，下次需要验证的时候客户端带上需要带上token值进行传输。

用户信息逻辑

用户信息是肯定要带上token进行用户认证的，所以需要传递token值，这里可以把token验证放到中间件里面进行验证，需要认证的时候直接加上中间件就好了。

token中间件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var response = require('./response')
var common = require('./common')
module.exports = function(req, res, next){
    var token = req.body.token || req.query.token || req.headers['token']
    if (token){
        common.verifytoken(token).then((data)=>{
            if(data){
                req.decoded=data
                next()
            }
            else{
                res.send(response.out("无效的token,请重新登录"))
            }
        })
    }
    else{
        res.send(response.err("没有传token,请先登录"))
    }
}

如果token解码成功，传递给下个路由接收，否则返回错误信息。

获取用户信息

1
2
3
4
5
6
7
8
9
10
var response = require('./response')
var express = require('express')
var route = express.Router()
var authtoken = require('./authtoken')
route.post('/getUserInfo', authtoken, function(req, res){
    res.send(req.decoded)
})
module.exports = route

添加中间件authtoken，如果token验证通过，会传递到当前接口。目前这个接口写的比较简单，直接返回了token的信息给客户端。正常的业务中应该还会查询表，然后再返回用户信息的逻辑。到这里基本就结束了，用到了注册、登陆、验证码、缓存等。

总结

本文只做认证系统的雏形，根据这个项目改改应该就能使用了，很多地方可以继续优化，比如对频繁使用地方建立索引，一些地方需要增加更多逻辑，对传输的信息进行二次加密，增强安全性等。

代码参考https://github.com/jackyshan/express-jwt