当前位置：首页 > 全部内容 > 正文

NodeJS实现单点登录原理解析

作者：桌面漫游

时间：2026-10-25

浏览：199

本文解析NodeJS环境下的单点登录（SSO）实现原理。通过模拟SSO认证中心与应用A、B的交互，详细阐述从用户登录、令牌生成到跨域会话共享的完整流程。文章包含基于Koa的服务端代码示例，展示如何校验用户凭证、签发Token及验证令牌有效性，帮助开发者理解多系统间统一鉴权的机制。

文章目录

什么是单点登录

随着企业业务的扩展，通常会衍生出多个不同的子系统。如果每个系统都要求用户单独进行身份验证，将极大降低使用体验。为此，单点登录（Single Sign On，简称SSO）方案应运而生。其核心概念是：用户在多个应用系统中只需登录一次，即可访问所有受信任的系统，无需重复输入认证信息。例如，用户登录淘宝后，访问天猫时即可直接跳转，无需再次登录。

单点登录原理

什么是单点登录

SSO架构依赖于一个独立的认证中心（Authentication Server）。该中心是唯一负责接收和处理用户凭据（如用户名、密码）的实体，其他业务系统不提供独立的登录入口，仅接受认证中心的间接授权。整个交互流程可概括为以下步骤：

  • 1. 用户访问应用A时，应用A检测到用户未登录，随即重定向至SSO认证中心，并将应用A自身的回调地址作为参数传递。
  • 2. SSO认证中心检查用户会话状态，若未登录，则将用户引导至登录页面。用户提交用户名和密码后，SSO中心校验凭据。若验证通过，SSO中心创建用户与自身的会话（信息存入Cookie），并生成一个授权令牌（Token）。
  • 3. SSO认证中心携带该令牌，重定向回最初的应用A请求地址。
  • 4. 应用A接收到令牌后，向SSO认证中心发起请求以验证令牌的有效性。若验证通过，应用A在本地注册该用户会话。
  • 5. 应用A创建与用户之间的本地会话，展示受保护资源，并维持用户的登录状态。
  • 6. 当用户访问应用B时，由于SSO认证中心与应用A、B不在同一域，无法直接共享登录态Cookie。应用B检测到用户未登录，同样重定向至SSO认证中心，并携带应用B的地址以及之前与SSO中心建立的会话Cookie信息。
  • 7. SSO认证中心检测到用户已存在有效会话，直接重定向回应用B的地址，并附上之前生成的令牌Token。
  • 8. 应用B接收到令牌后，同样向SSO认证中心验证其有效性。若有效，应用B在本地注册该用户会话。
  • 9. 应用B创建与用户之间的本地会话，展示资源并维持用户的登录状态。

NodeJS 演示

三个不同的服务

为了直观演示SSO的工作机制，我们需要启动三个独立的服务，分别模拟应用A、SSO认证服务器以及应用B。

什么是单点登录

在本示例中，端口8383的服务作为SSO认证服务器，而端口8686和8787的服务分别代表应用A与应用B。实际上，应用A与应用B的核心代码逻辑高度相似，主要区别在于通过参数配置不同的端口号和应用名称。以下展示具体的运行效果。

什么是单点登录

首次访问跳转至登录页

应用A判断登录态，跳转到SSO认证服务器

应用A

const Koa=require('koa');
const Router=require('koa-router')
const views=require('koa-views')
const static=require('koa-static')
const path=require('path');
const app=new Koa();
const router=new Router();
const session=require('koa-session')
const koa2Req=require('koa2-request');
//模版引擎相关配置
app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
app.keys=['key']
const keyMap={
  '8686':'koa:sess8686',
  '8787':'koa:sess8787'
}
const CONFIG={
    key:keyMap[process.env.PORT] || 'koa:sess',
    maxAge:1000*60*60*24,
    httpOnly:true
}
app.use(session(CONFIG,app))
const system=process.env.SERVER_NAME
router.get("/",async (ctx)=>{
    //通过 session来判断 应用A的登录状态
    let user=ctx.session.user
    if(user){
     //...
    }
    else //1、当用户登录访问应用A时，应用A发现用户未登录(应为服务器没有保存对应的session)
    {
      let token=ctx.query.token
      //第一次登录url上也不会有令牌
      if(!token)
      {
      //1、跳转到SSO认证服务器
       ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
      }
      else
      {
        //...
      }
    }
})
app.use(router.routes())

const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

认证服务器判断登录态，渲染登录页

SSO认证服务器的目录结构主要包含两大功能模块：一是处理用户登录逻辑，二是验证后续请求中令牌的有效性。这两个功能分别由路由文件login.js和check-token.js负责处理。

什么是单点登录

Auth/index.js

const Koa=require('koa');
const Router=require('koa-router')
const views=require('koa-views')
const path=require('path');
const app=new Koa();
const router=new Router();
const login=require("./routes/login")
const checkToken=require('./routes/check-token')
const bodyparser=require('koa-bodyparser')
app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
app.use(bodyparser())
//处理登录相关的逻辑
router.use('/login',login.routes())
//处理令牌验证的逻辑
router.use('/check_token',checkToken.routes())
app.use(router.routes())

app.listen(8383,()=>{
    console.log(`app listen at 8383`)
})

接下来，我们从应用A跳转至http://localhost:8383/login?redirectUrl=localhost:8686（即SSO登录接口）开始，分析login.js中的具体逻辑。

const service = require("../service");
const router=require("koa-router")()
router.get('/',async (ctx)=>{
  const cookies=ctx.cookies;
  const token=cookies.get('token');
  //从cookie中判断应用A的登录态
  if(token && service.isTokenVailid(token)){
    //。。。如果有登录过
  }else{
    //2、SSO认证中心发现用户没有登录过，于是渲染登录页面登录页面;
    await ctx.render('login.ejs',{
        extension:'ejs'
     })
  }
})
//。。。
module.exports=router

登录页面

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>统一登录</title>
</head>
<body>
    <h1>统一登录</h1>
    <form method="post">
       <div>用户名: <input type="text" name="name"/></div>
       <div>密码  <input type="text" name="password" /></div>
       <div><input type="submit" value='登录'></div>
    </form>
</body>
</html>

校验用户信息，创建令牌

Auth/routes/login.js

router.post('/',async (ctx)=>{
//2、用户填写用户名密码提交登录申请;
   const body=ctx.request.body;
   const {name,password}=body;
    //2、SSO认证中心校验用户信息，
   if(name==="admin" && password==="123456"){
    //2、创建用户雨SSO认证中心的会话(这时会把信息保存到cookie中)，同时创建授权令牌token
       const token="passport";
       await ctx.cookies.set('token',token,{
           maxAge:1000*60*60*24*30,
           httpOnly:true
       })
       if(ctx.query.redirectUrl){
       //3、sso认证中心带着令牌跳转到最初的请求地址(应用A)
           ctx.redirect(`${ctx.protocol}://${ctx.query.redirectUrl}?token=${token}`)
           //回跳地址是 http://localhost:8686/?token=passport
       }else{
           ctx.body="<h1>登录成功！</h1>"
       }
   }else{
       ctx.response.body={
           error:1,
           msg:'用户名或密码错误'
       }
   }
})

从认证服务器携带令牌跳转回应用A

令牌校验 返回资源

应用A

app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
//...
const system=process.env.SERVER_NAME
router.get("/",async (ctx)=>{
    let user=ctx.session.user
    if(user){
      //...
    }
    else
    //这时应用A依旧没有登录态 但url上有了令牌 http://localhost:8686/?token=passport
   {
      let token=ctx.query.token
      if(!token)
      {
        //...跳转去SSO登录页面
      }
      else 
      //跳回应用A时走这里的逻辑
      {
        //ajax请求 4. 应用A拿到令牌去SSO认证中心认证是否有效，如果返回有效注册应用A
        const url=`://localhost:8383/check_token?token=${token}&t=${new Date().getTime()}`
        let data = await koa2Req(ctx.protocol + url);
        if(data && data.body){
            try {
                const body=JSON.parse(data.body)
                const {error,userId}=body;
                // console.log(error,userId) 0,admin
                if(error==0){
                    if(!userId){
                        ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                        return
                    }
                    //验证通过后注册session，渲染页面
                    //5. 应用A创建与用户之间的会话，展示资源并维持用户登录态
                    ctx.session.user=userId;
                    await ctx.render('index.ejs',{
                        user:userId,
                        system
                    })
                }else{
                    ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                }
            } catch (error) {console.log(error)}

            
        }
      }
    }
})
app.use(router.routes())
const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

与上述逻辑对应，SSO服务器中处理令牌验证的代码位于Auth/routes/check-token。

const router=require("koa-router")()
const service=require("../service")
router.get('/',async (ctx)=>{
  const token=ctx.query.token;
  const result={
      error:1
  }
  //当token 是 password时
  if(service.isTokenVailid(token)){
    result.error=0;
    result.userId='admin'
  }
  ctx.body=result
})
module.exports=router

Auth/service/index.js

module.exports={
    isTokenVailid: function(token){
      if(token && token==='passport'){
          return true
      }
      return false
    }
}

至此，用户已成功访问应用A。此时，SSO服务器和应用A的服务器上均保存了该用户的登录状态信息。

访问应用B

带cookie跳转至SSO认证服务器

应用B

//...
router.get("/",async (ctx)=>{
    let user=ctx.session.user
    if(user){
      //...
    }else{
      let token=ctx.query.token
      //...
      if(!token)
      {
      //同样既没有session也没有令牌，跳转到SSO认证服务器
      //6、当用户访问应用B时，发现用户未登录(SSO认证服务器与应用A应用B不是同一个域,不能提供登录态)，跳转到SSO认证中心，并将自己的地址和之前和SSO认证中心会话的cookie信息带入
          ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
      }
      else
      {
        //。。。验证令牌的部分
      }
    }
})
app.use(router.routes())
const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

从认证服务器携带令牌跳转回应用B

SSO认证服务器。在再次登录场景中，由于用户已携带有效Cookie，系统不会再次请求登录页面（Auth/routes/login）。

//...
router.get('/',async (ctx)=>{
  const cookies=ctx.cookies;
  const token=cookies.get('token');
  //7. SSO认证中心发现用户已登录，跳转回应用B地址，并附上令牌token
  if(token && service.isTokenVailid(token)){
    const redirectUrl=ctx.query.redirectUrl;
    if(redirectUrl){
       //带着令牌跳转回应用B
        ctx.redirect(`${ctx.protocol}://${redirectUrl}?token=${token}`)
    }else{
        ctx.body="<h1>登录成功！</h1>"
    }
  }else{
    //...渲染登录页面
  }
})
//..

令牌校验 返回资源

此处的逻辑与前述第5、6步一致。由于Token存在被伪造的风险，应用B必须向SSO中心验证其真伪。

app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
//...
const system=process.env.SERVER_NAME
router.get("/",async (ctx)=>{
    let user=ctx.session.user
    if(user){
      //...
    }
    else
    //这时应用B依旧没有登录态 但url上有了令牌 http://localhost:8787/?token=passport
   {
      let token=ctx.query.token
      if(!token)
      {
        //...跳转去SSO登录页面
      }
      else 
      //跳回应用B时走这里的逻辑
      {
        //ajax请求 8. 同样的应用B拿到令牌去SSO认证中心认证是否有效，如果返回有效注册应用B
        const url=`://localhost:8383/check_token?token=${token}&t=${new Date().getTime()}`
        let data = await koa2Req(ctx.protocol + url);
        if(data && data.body){
            try {
                const body=JSON.parse(data.body)
                const {error,userId}=body;
                // console.log(error,userId) 0,admin
                if(error==0){
                    if(!userId){
                        ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                        return
                    }
                    //验证通过后注册session，渲染页面
                    //9. 应用B创建与用户之间的会话，展示资源并维持用户登录态
                    ctx.session.user=userId;
                    await ctx.render('index.ejs',{
                        user:userId,
                        system
                    })
                }else{
                    ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                }
            } catch (error) {console.log(error)}
            
        }
      }
    }
})
app.use(router.routes())
const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

至此，单点登录的核心逻辑已全部实现。在Session有效期内，用户再次访问页面时，系统将直接返回资源，无需重复登录。

router.get("/",async (ctx)=>{
//如果session中有用户信息，说明已经登录过，直接返回请求资源
    let user=ctx.session.user
    if(user){
        await ctx.render('index.ejs',{
              user,
              system
        })
    }
    //...
 })

到此这篇关于NodeJS实现单点登录的文章就介绍到这了,更多相关nodejs单点登录内容请搜索本站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本站！

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印，自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式，预览压缩前后的大小。

使用 ›
作者最新文章

Mock.js 拦截失效或数据格式错误的常见原因及排查

Java和JavaScript名字像但没关系：辨析Java、JavaWeb与JS

CodePen、JSFiddle与RunJS对比：哪款JS在线运行工具更适合你？

JS 统计图渲染空白或报错怎么排查？常见问题解决指南

flv.js 常见报错 MediaError 与解码失败排查指南

相关文章
热门文章
更多
CSS text-transform与JS修改首字母大写的适用场景区别
JS中constructor属性判断数组存在哪些风险
JS正则替换中$1捕获组引用与字符串重组技巧
全栈开发中JavaScript与Java怎么协作？前后端技术栈配合解析
Node.js后端生成高强度随机字符串的方法
怎么在本地运行JavaScript脚本：Node.js下载安装与环境配置教程
JS正则表达式基础：字面量与RegExp构造函数的区别及常用元字符
JS 解压出现乱码或报错怎么解决？
JavaScript常见SyntaxError语法错误排查与修复方法
JS动态构建复杂嵌套JSON对象的方法