【编程开发】之单点登录

一、单点登录介绍

---

1、什么是单点登录？为什么要使用单点登录？单点登录解决什么问题？

在早期的单一服务器模式下（即服务器只有一台），我们的登录一般使用的是 session 对象来实现的：

• 登录成功后，把用户数据放到 session 中： session.setAttribute(“user”, user)
• 判断是否登录的时候，从 session 中获取数据：session.getAttribute(“user”) 如果可以获取到即为登录

在实际项目中，我们的服务器肯定是不止一台，特别是分布式集群模式下，不同的服务模块部署在不同的服务器中，所以，如果使用单一服务器模式的登录方式的话，就会导致每个服务模块调用的时候都要登录一次，因为每个服务模块的 session 都是不同的。

而正常情况下，我们应该做到的逻辑是：只要是同一项目下的不同服务模块，应该只需要登录一次就可以了。这样，只要在调用某一个服务模块登录过一次了，那么调用其它模块的时候就不需要二次登录了。

最典型的例子就是百度全家桶，百度有很多产品，比如百度网盘、百度知道、百度贴吧等等，如果我们在百度网盘登录过百度账号之后，再切换到百度贴吧的时候不需要你再次百度账号了，因为它已经自动帮你登录了。

所以，单点登录就是为了解决这种分布式集群登录问题。

2、单点登录

单点登录，又叫 SSO（single sign in）模式：只要在一个模块下登录了，其它模块就不要进行二次登录了，这个过程就叫单点登录。

单点登录的优点：

• 用户身份信息独立管理，更好的分布式管理
• 可以自己扩展安全策略

缺点：

• 认证服务器访问压力较大

3、点单登录常见方式

单点登录的方式有很多种，常见的有一下三种：

• session 广播机制实现
• 使用 cookie + redis 实现
• 使用 token 实现（结合 Redis 和网关一起使用）

（1）、session 广播机制实现

session 广播机制实现的原理是 session 复制，只要在某个服务模块进行了登录并设置了 session，则通过广播把这个 session 对象复制到其它模块中。

这种方式有一个致命的缺点：每次登录都要进行 session 复制，如果服务模块有几十上百的话，这时复制操作就会消耗资源，而且每个模块都复制一份的话也会造成数据重复浪费资源的现象。所以这种方式一般都是比较早期、服务模块不多的情况下使用的。

（2）、使用 cookie + redis 实现

cookie 是一种客户端技术，客户端每次发送请求时会带着 cookie 值一起发送，而 redis 的 key-value 特性就方便了我们进行数据存储和查询。

这种组合的实现过程如下：

（1）、在项目中任何一个模块进行登录之后，把用户数据存放在以下两个地方：

• redis：由于 redis 是以 key-value形式存在的，所以我们在 key 中存放生成的唯一随机值（可以使用 ip、用户 id、uuid 等等），而 value 则存放用户数据。
• cookie：把 redis 中生成的 key 值存放到 cookie 中

（2）、在访问项目中的其他模块时，发送请求带着 cookie 进行发送，服务器获取到 cookie 后进行解析并得到相应的 cookie 值，然后拿着相应的 cookie 值到 redis 中进行查询，这个 cookie 值就是我们 redis 中存放的 key 值，如果在 redis 中能够查询获取到数据则表示已经登录。

（3）、使用 token 实现

token 简介

token 是按照一定规则生成的字符串（也称之为口令或令牌），里面可以包含我们的用户信息。比如，我们对包含用户信息的字符如串 “192.168.56.10#name#1#” 进行 base64 编码然后使用 md5 加密等等方式生成一个很长的 token 字符车。

项目的实现方式

（1）、在项目中某个模块进行登录之后，按照规则生成 token 字符串，把登录之后的用户信息包含到生成的字符串里面，然后把字符串返回给客户端。

客户端可以通过两种方式返回 token 字符串：

• 通过 cookie 返回：把 token 存放在 cookie 中然后发送请求时一并返回
• 通过地址栏返回：再发送请求地址时可以把 token 作为参数返回，比如：http://www.badidu.com?token=urtewef7s34

（2）、当客户端得到 token 之后再去访问其他模块时，把 token 附带在访问的地址栏中，而服务器收到请求后解析请求地址栏的 token 字符串，然后根据 token 获取用户信息，如果可以获取到则表示已经登录。

细节：我们的 session 有一个过期时间，默认是 30 分钟，cookie + redis 方式可以通过设置 redis 的过期时间来实现这个效果，而 token 也可以设置过期时间（下面讲解 jwt 时会解释）。

token 登录流程如下图：

token 登录的优点：

• 无状态：token无状态，session有状态的
• 基于标准化：你的API可以采用标准化的 JSON Web Token (JWT)

缺点：

• 占用带宽
• 无法在服务器端销毁

基于微服务开发，选择 token 的形式相对较多，因此我使用 token 作为用户认证的标准。

注意：这里的 token 的实现需要依赖 Redis 来完成登录和登出功能，登录成功就保存 token 到 Redis 中，登出就从 Redis 中删除。同时结合网关服务实现鉴权功能，当访问其他服务的时候，通过网关验证和校验 token 信息，然后再进行路由跳转。

二、JWT 令牌

---

上面我们说到：token 是按照一定规则生成的字符串，里面包含了用户信息。那么规则如何制定呢？不同的公司有不同的规则，可以自己定制规则。那么有没有一种通过的生成规则呢，换句话说，有没有生成规则的标准呢？

答案是：有的，就是官方的通用规则 JWT。JWT 就是给我们规定好了规则，使用 jwt 规则可以生成包含用户信息的 token 字符串。

1、访问令牌的类型

使用自包含令牌，通过客户端保存数据，而服务器不保存会话数据。 JWT是这种解决方案的代表。

2、JWT 的组成

典型的，一个JWT看起来如下图：

该对象为一个很长的字符串，字符之间通过"."分隔符分为三个子串。

每一个子串表示了一个功能块，总共有以下三个部分：

• JWT头信息
• 有效载荷，包含主体信息（用户信息）
• 签名哈希，防伪标志

JWT 头信息（Header）

WT头部分是一个描述JWT元数据的JSON对象，通常如下所示：

{
  "alg": "HS256",
  "typ": "JWT"
}

在上面的代码中：

• alg 属性表示签名使用的算法，默认为 HMAC SHA256（写为 HS256）；
• typ 属性表示令牌的类型，JWT 令牌统一写为 JWT。最后，使用 Base64 URL 算法将上述 JSON 对象转换为字符串保存。

有效载荷（Claims）

有效载荷部分，是 JWT 的主体内容部分，也是一个 JSON 对象，包含需要传递的数据。

JWT 指定七个默认字段供选择：

iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

除以上默认字段外，我们还可以自定义私有字段，如下例：

{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

请注意，默认情况下 JWT 是未加密的，任何人都可以解读其内容，因此不要构建隐私信息字段，存放保密信息，以防止信息泄露。

JSON 对象也使用 Base64 URL 算法转换为字符串保存。

签名哈希（Signature）

签名哈希部分是对上面两部分数据签名，通过指定的算法生成哈希，以确保数据不会被篡改。

首先，需要指定一个密码（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用标头中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成签名。

HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(claims), secret)

在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用"."分隔，就构成整个JWT对象。

Base64URL 算法

如前所述，JWT头和有效载荷序列化的算法都用到了Base64URL。该算法和常见Base64算法类似，稍有差别。

作为令牌的JWT可以放在URL中（例如api.example/?token=xxx）。 Base64中用的三个字符是"+"，"/“和”="，由于在URL中有特殊含义，因此Base64URL中对他们做了替换："=“去掉，”+“用”-“替换，”/“用”_"替换，这就是Base64URL算法。

3、JWT 的原则

WT的原则是在服务器身份验证之后，将生成一个JSON对象并将其发送回用户，如下所示：

{
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}

之后，当用户与服务器通信时，客户在请求中发回JSON对象。服务器仅依赖于这个JSON对象来标识用户。为了防止用户篡改数据，服务器将在生成对象时添加签名。

服务器不保存任何会话数据，即服务器变为无状态，使其更容易扩展。

4、JWT 的用法

客户端接收服务器返回的JWT，将其存储在Cookie或localStorage中。

此后，客户端将在与服务器交互中都会带JWT。如果将它存储在Cookie中，就可以自动发送，但是不会跨域，因此一般是将它放入HTTP请求的Header Authorization字段中。当跨域时，也可以将JWT被放置于POST请求的数据主体中。

5、JWT 问题和趋势

• JWT不仅可用于认证，还可用于信息交换。善用JWT有助于减少服务器请求数据库的次数。
• 生产的token可以包含基本信息，比如id、用户昵称、头像等信息，避免再次查库
• 存储在客户端，不占用服务端的内存资源
• JWT默认不加密，但可以加密。生成原始令牌后，可以再次对其进行加密。
• 当JWT未加密时，一些私密数据无法通过JWT传输。
• JWT的最大缺点是服务器不保存会话状态，所以在使用期间不可能取消令牌或更改令牌的权限。也就是说，一旦JWT签发，在有效期内将会一直有效。
• JWT本身包含认证信息，token是经过base64编码，所以可以解码，因此token加密前的对象不应该包含敏感信息，一旦信息泄露，任何人都可以获得令牌的所有权限。为了减少盗用，JWT的有效期不宜设置太长。对于某些重要操作，用户在使用时应该每次都进行进行身份验证。
• 为了减少盗用和窃取，JWT不建议使用HTTP协议来传输代码，而是使用加密的HTTPS协议进行传输。

5、整合 JWT 令牌

（1）、引入 jwt 依赖

<!-- JWT-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
</dependency>

（2）、创建JWT工具类

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * @author
 */
public class JwtUtils {

    // 常量
    public static final long EXPIRE = 1000 * 60 * 60 * 24; // token过期时间
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO"; // 秘钥

    // 生成token字符串的方法
    public static String getJwtToken(String id, String nickname){

        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")	// 头部信息
                .setHeaderParam("alg", "HS256")
                
                .setSubject("edu-user")			
                .setIssuedAt(new Date())		// 设置过期时间
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                
                .claim("id", id)				// 设置token主体部分 ，存储用户信息
                .claim("nickname", nickname)
                
                .signWith(SignatureAlgorithm.HS256, APP_SECRET) // 签名哈希
                .compact();

        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * @param jwtToken
     * @return
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     * @param request
     * @return
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根据token获取会员id
     * @param request
     * @return
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}

结合我们之前说的过期时间问题：session 有过期时间（有默认时间也可以自己修改）、cookie + redis 组合可以设置 redis 过期时间。

现在我们的 token 方式则可以通过使用 JWT 工具设置过期时间来达到处理过期问题。

三、Token 单点登录

---

登录流程如下：

• 首先前端登录页面填写完用户名和密码之后，点击登录按钮发送登录请求；
• 后台服务器收到登录请求后，会先对用户名和密码进行校验（比如非空校验、用户名密码是否正确校验等），校验成功之后就会调用 jwt 工具生成 token（主要包括用户ID信息），并把 token 存放到 Redis 中，最后返回给我们前端；
• 前端收到 token 之后会把 token 封装到 cookie 中，并调用获取用户信息的接口，在发送请求之前，由于前端有 request 拦截器，它会判断 cookie 中是否有 token 值，如果有就会把 token 值放到 header 请求头中；
• 服务端收到这个请求之后就会通过 HttpServletRequest 对象从 header 中拿到这个token 值，然后再使用 jwt 工具解析得到 token 中包含的数据，比如我们的用户ID；
• 得到用户ID之后再调用数据库查询得到用户信息数据，然后封装前端所需要的数据，比如用户姓名、昵称、头像等等，最后再把这些数据返回给前端。
• 前端获取到用户数据后会把它放到 cookie 中，然后跳转首页，首页会从 cookie 中获取数据，并展示相关的用户数据，比如用户昵称、用户头像等等。

整个登录过程的重点是生成 token 之后把它放入了 Redis 中，这样下次访问后台的其他服务模块时，后台的网关会先进行拦截并使用 JWT 校验 token，校验成功之后就可以访问服务资源了，相关代码如下：

@Autowired
private RedisTemplate<String, String> redisTemplate;

// 用户登录
public String login(UcenterMember member) {
    // 获取登陆手机号和密码
    String mobile = member.getMobile();
    String password = member.getPassword();

    // 手机号和密码非空判断
    if (StringUtils.isEmpty(mobile) || StringUtils.isEmpty(password)) {
        throw new EduShopException(20001, "手机号码或密码不能为空！");
    }

    // 判断手机号是否正确
    QueryWrapper<UcenterMember> wrapper = new QueryWrapper<>();
    wrapper.eq("mobile", mobile);
    UcenterMember mobileMember = this.baseMapper.selectOne(wrapper);
    if (mobileMember == null) {
        throw new EduShopException(20001, "用户不存在！");
    }

    // 判断密码是否正确：密码为MD5加密
    if (!MD5Utils.encrypt(password).equals(mobileMember.getPassword())) {
        throw new EduShopException(20001, "密码不正确！");
    }

    // 判断是否被禁用
    if (mobileMember.getIsDisabled()) {
        throw new EduShopException(20001, "该用户已经被禁用！");
    }

    // 登陆成功，生成 token，并存放在 Redis 中
    String jwtToken = JwtUtils.getJwtToken(mobileMember.getId(), mobileMember.getNickname());
	renewToen(mobileMember.getId(), jwtToken);
    
    return jwtToken;
}

保存 token 到 Redis 中的方法：

// 保存 token 到 Redis 中
private void renewToken(String token, int id) {
    redisTemplate.opsForValue().set(id, token);
    redisTemplate.expire(id, 24, TimeUnit.HOURS);
}

同理，退出登录的时候就直接delete掉就可以了：

// 从 Redis 中删除 token
public void removeToken(String token) {
    String id = JwtUtils.getMemberIdByJwtToken(token);
    redisTemplate.delete(id);
}

用户点击退出登录的时候，客户端会清空 cookie 中 token 和用户数据，服务端收到退出登录请求时会删除 Redis 中保存的 token 数据，这样下次登录的时候就需要重新申请和创建新的 token。