微信小程序登录 + 基于token的身份验证

痛定思痛。 2023-07-16 11:55 27阅读 0赞

官方时序图如下：

https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/login.html

图里其实说的很清楚了，清理下流程：

1.前端调用wx.login()获取code值

2.前端通过调用wx.getUserInfo获取iv、rawData、signature、encryptedData等加密数据，传递给后端

3.服务器通过code请求api换回session\_key和openid

4.服务器通过前端给的rawData 加获取的session\_key使用sha1加密，计算出signature1

5.比对前端传的signature和自己算出来的signature1是否一致（防止数据不一致）

6.用AES算法解密encryptedData里的敏感数据

7.拿着敏感数据后做自己的逻辑

8.通知前端登陆成功

\*\* 这里只是想拿到用户的openid，则直接1,3就可以做到了。如下：

第一步：  
通过wx.login（微信前端--小程序）接口获取code，将code传到后台

注意：

code的来源：是用户打开小程序的时候，随机生成的，是腾讯生成的，每个code只能使用一次，因此，理论上这个code是安全的

package cn.wmyskxz.springboot.model.user;  
   
/\*\*  
 \* @Author: Yangke  
 \* @Date: 2019/3/31 15:52  
 \*\*/  
public class WeChatLoginModel \{  
    String code;  
   
    public String getCode() \{  
        return code;  
    \}  
   
    public void setCode(String code) \{  
        this.code = code;  
    \}  
\}  
第二步：  
后台通过code访问微信（腾讯）接口，微信（腾讯）接口返回当前登录的信息：session\_key及openid

返回的openid是每个用户唯一的，通过这个 可以匹配 微信（腾讯）的用户 跟 我们的用户，就是我们后台通过openid来判断这个人是谁，

UserController.java           微信小程序登录

/\*\*  
     \* 微信小程序登录  
     \*  
     \* 登录成功后，将用户身份信息及session\_key存入token  
     \* @param model  
     \* @return  
     \*/  
    @ResponseBody  
    @PostMapping("/weChatLogin")  
    public SingleResult<String> weChatLogin(@RequestBody WeChatLoginModel model)\{  
   
        /\*\*  
         \* 登录日志：  
         \* id\\ userid\\ date\\ wx\_code\\ createTime  
         \* create table loginLog (  
                id varchar(50) primary key,  
                userId varchar(50),  
                logindate date,  
                wxcode varchar(100),  
                createtime datetime  
           );  
         \*/  
   
        SingleResult<String> result = new SingleResult<String>();  
        //第三步：调用service.weChatLogin(model):后台检查openid是否存在，返回openid对应的用户  
        WeChatLoginResult<UserAccount> loginResult = service.weChatLogin(model);  
          
        //第四步：  
        UserAccount user = loginResult.getUser();  
        if(user == null )\{  
            result.setCode(0);  
            result.setMessage("登录失败");  
        \}  
        else \{  
            User u = new User();  
            u.setId(user.getId());  
            u.setPassword(user.getPassword() == null ? user.getWxopenid() : user.getPassword());  
            u.setSessionKey(loginResult.getSession\_key());  
            String token = getToken(u);  
            result.setToken(token);  
            result.setCode(1);  
            result.setMessage("登陆成功");  
        \}  
   
        return result;  
    \}  
其中：就是下面的第三步

//调用service.weChatLogin(model)  
WeChatLoginResult<UserAccount> loginResult = service.weChatLogin(model);

第三步：  
后台检查openid是否存在，

去UserService.java

@Override  
    public WeChatLoginResult<UserAccount> weChatLogin(WeChatLoginModel model)\{  
        WeChatLoginResult<UserAccount> result = null;  
        try \{  
   
            // code  -> openid  
            String urlFormat = "https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js\_code=%s&grant\_type=authorization\_code";  
            String url = String.format(urlFormat, WeChat.appId, WeChat.secret, model.getCode());  
            String json = WeChat.sendGet(url);  
   
            //将json字符串转化成对象  
            result = JSON.parseObject(json, WeChatLoginResult.class);  
   
            if(result.getErrcode() == null)\{  
                // 去数据库 检查 openId 是否存在 不存在就新建用户  
                UserAccount user = userAccount.wechatOpenIdIsExists(result.getOpenid());  
                if(user == null || user.getId() == null)\{  
                    // 不存在，就是第一次登录：新建用户信息  
                    user = new UserAccount();  
                    user.setId(UUID.randomUUID().toString());  
                    user.setWxopenid(result.getOpenid());  
                    user.setLasttime(new Date());  
                    userAccount.insert(user);  
                \}  
                else \{  
                    //如果存在，就不是第一次登录，更新最后登录时间  
                    user.setLasttime(new Date());  
                    userAccount.updateByPrimaryKeySelective(user);  
                \}  
                result.setUser(user);  
   
                // 保存登录日志  
                LoginLog log = new LoginLog();  
                log.setId(UUID.randomUUID().toString());  
                log.setCreatetime(new Date());  
                log.setLogindate(new Date());  
                log.setUserid(user.getId());  
                log.setWxcode(model.getCode());  
                loginLog.insert(log);  
            \}  
            else \{  
                System.out.println(json);  
            \}  
        \}  
        catch (Exception e)\{  
            System.out.println(e.getMessage());  
        \}  
   
        return result;  
    \}  
去数据库中检查openid是否存在：

UserAccountMapper.java  
@Select("select \* from useraccount where wxOpenId = \#\{wxOpenId\}")  
UserAccount wechatOpenIdIsExists(String wxOpenId);  
（1）如果不存在：就是该用户的第一次登录，后台数据库新添加一个用户信息

如果存在：就不是该用户的第一次登录，以前登陆过，就更新后台数据库中该用户的第一次登录时间

(2)  返回用户信息

第四步：  
下发token

//第四步：  
        UserAccount user = loginResult.getUser();  
        if(user == null )\{  
            result.setCode(0);  
            result.setMessage("登录失败");  
        \}  
        else \{  
            User u = new User();  
            u.setId(user.getId());  
            //用户如果是第一次登录，那就是没有密码的，这里用openid当做密码  
            u.setPassword(user.getPassword() == null ? user.getWxopenid() : user.getPassword());  
            u.setSessionKey(loginResult.getSession\_key());  
            //利用User.class中的信息生成token  
            String token = getToken(u);  
            //下发token  
            result.setToken(token);  
            result.setCode(1);  
            result.setMessage("登陆成功");  
        \}  
   
        return result;  
    \}  
其中生成token的步骤：BaseController.java

利用JWT框架生成token

package cn.wmyskxz.springboot.controllers;  
   
import cn.wmyskxz.springboot.model.User;  
import com.auth0.jwt.JWT;  
import com.auth0.jwt.algorithms.Algorithm;  
   
import java.util.Date;  
/\*\*  
 \* @Author: Yangke  
 \* @Date: 2019/3/28 21:12  
 \*\*/  
public abstract class BaseController \{  
   
    protected String getToken(User user) \{  
        String token="";  
        token= JWT.create()  
                .withKeyId(user.getId())  
                .withIssuer("www.ikertimes.com")  
                .withIssuedAt(new Date())  
                .withJWTId("jwt.ikertimes.com")  
                .withClaim("session\_key", user.getSessionKey())  
                .withAudience(user.getId())  
                .sign(Algorithm.HMAC256(user.getPassword()));  
        return token;  
    \}  
\}  
至此，再理一下上面的步骤：

（1）微信小程序通过访问wx.login获得一个code，返回给后台

（2）后台拿着这个code，调用腾讯的接口，获取到openid、seesion-key等信息，openid是用户唯一的

（3）后台拿着openid去数据库中检查，该用户是否是第一次登陆

如果是第一次登陆，那么就新建一个用户--UserAcount；如果不是第一次登陆，就修改该用户的最后登录时间

不管是不是第一次登录，都有了一个用户

（4）然后根据用户的信息利用JWT生成token，下发给微信小程序

第五步  
微信小程序收到token后，存起来

第六步  
微信小程序请求后台

微信小程序把token放在请求头中

第七步  
先介绍一个注解：

Authorize  
说明：如果有这个注解，就需要验证token

package cn.wmyskxz.springboot.annotation;  
   
import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
   
/\*\*  
 \* @Author: Yangke  
 \* @Date: 2019/3/28 19:57  
 \*authorize 是判断 是否需要 token  
 \*\*/  
@Target(\{ElementType.METHOD, ElementType.TYPE\})  
@Retention(RetentionPolicy.RUNTIME)  
public @interface Authorize \{  
    boolean required() default true;  
\}  
用拦截器，验证token

package cn.wmyskxz.springboot.interceptors;  
   
import cn.wmyskxz.springboot.annotation.AllowAnonymous;  
import cn.wmyskxz.springboot.annotation.Authorize;  
import cn.wmyskxz.springboot.model.User;  
import cn.wmyskxz.springboot.service.UserService;  
import com.auth0.jwt.JWT;  
import com.auth0.jwt.JWTVerifier;  
import com.auth0.jwt.algorithms.Algorithm;  
import com.auth0.jwt.exceptions.JWTDecodeException;  
import com.auth0.jwt.exceptions.JWTVerificationException;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.method.HandlerMethod;  
import org.springframework.web.servlet.HandlerInterceptor;  
import org.springframework.web.servlet.ModelAndView;  
   
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import java.lang.reflect.Method;  
   
/\*\*  
 \* @Author: Yangke  
 \* @Date: 2019/3/28 20:00  
 \*  
 \* 获取token并验证token  
 \*\*/  
public class AuthorizationInterceptor implements HandlerInterceptor \{  
    @Autowired  
    UserService userService;  
   
    //拦截器：请求之前preHandle  
    @Override  
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception \{  
        // 如果不是映射到方法直接通过  
        if (!(object instanceof HandlerMethod)) \{  
            return true;  
        \}  
        HandlerMethod handlerMethod = (HandlerMethod) object;  
        Method method = handlerMethod.getMethod();  
   
        //检查是否有passtoken注释，有则跳过认证，注意:其中这个注解多余了  
        if (method.isAnnotationPresent(AllowAnonymous.class)) \{  
            AllowAnonymous passToken = method.getAnnotation(AllowAnonymous.class);  
            if (passToken.required()) \{  
                return true;  
            \}  
        \}  
        //检查有没有需要用户权限的注解  
        //如果有注解Authorize，就需要验证token  
        if (method.isAnnotationPresent(Authorize.class)) \{  
            Authorize userLoginToken = method.getAnnotation(Authorize.class);  
            if (userLoginToken.required()) \{  
   
                String token = httpServletRequest.getHeader("authorization");// 从 http 请求头中取出 token  
   
                // 执行认证  
                if (token == null) \{  
                    throw new RuntimeException("无token，请重新登录");  
                \}  
                // 获取 token 中的 user id  
                String userId;  
                try \{  
                    // 获取 userid  
                    userId = JWT.decode(token).getKeyId();  
                    // 添加request参数，用于传递userid  
                    httpServletRequest.setAttribute("currentUser", userId);  
                    // 根据userId 查询用户信息  
                    User user = userService.getUserById(userId);  
                    if (user == null) \{  
                        throw new RuntimeException("用户不存在，请重新登录");  
                    \}  
   
                    try \{  
                        String session\_key = JWT.decode(token).getClaim("session\_key").as(String.class);  
                        // 添加request参数，用于传递userid  
                        httpServletRequest.setAttribute("sessionKey", session\_key);  
                    \}  
                    catch (Exception e)\{  
                    \}  
   
                    // 验证 密码  
                    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();  
                    try \{  
                        jwtVerifier.verify(token);  
                    \} catch (JWTVerificationException e) \{  
                        throw new RuntimeException("401");  
                    \}  
                \} catch (JWTDecodeException j) \{  
                    throw new RuntimeException("401");  
                \}  
   
                return true;  
            \}  
        \}  
        return true;  
    \}  
   
   
    @Override  
    public void postHandle(HttpServletRequest httpServletRequest,  
                           HttpServletResponse httpServletResponse,  
                           Object o, ModelAndView modelAndView) throws Exception \{  
   
    \}  
   
    //拦截器：请求之后：afterCompletion  
    @Override  
    public void afterCompletion(HttpServletRequest httpServletRequest,  
                                HttpServletResponse httpServletResponse,  
                                Object o, Exception e) throws Exception \{  
    \}  
\}  
流程：

1、从http请求头中取出token

String token = httpServletRequest.getHeader("authorization");  
2、如果没有token，抛出异常，请用户登录

如果有token，利用JWT从token中取出userid，添加到request参数

3、根据userid去后台数据库中查询用户是否存在，如果不存在，抛出异常：用户不存在，请重新登录

User user = userService.getUserById(userId);  
这个方法：

@Override  
public User getUserById(String id) \{  
   UserAccount u = userAccount.selectByPrimaryKey(id);  
   User user = new User();  
   user.setId(u.getId());  
   user.setPassword(u.getPassword() == null ? u.getWxopenid() : u.getPassword());  
   user.setUsername(u.getUsername());  
   return  user;  
\}  
4、如果用户存在，再利用JWT从token中取出seesion-key，添加到request参数

String session\_key = JWT.decode(token).getClaim("session\_key").as(String.class);  
5、验证密码：因为我生成token的时候，是存了密码的，这个就是检查一下密码对不对

验证 token里面的密码 跟 你存的 是不是一样

JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();  
try \{  
    jwtVerifier.verify(token);  
\} catch (JWTVerificationException e) \{  
     throw new RuntimeException("401");  
\}  
6、最终token验证成功，返回true，放行

拦截器介绍一下：

preHandle：在业务处理器处理请求之前被调用。预处理，可以进行编码、安全控制、权限校验等处理；  
postHandle：在业务处理器处理请求执行完成后，生成视图之前执行。后处理（调用了Service并返回ModelAndView，但未进行页面渲染），有机会修改ModelAndView （这个博主就基本不怎么用了）；  
afterCompletion：在DispatcherServlet完全处理完请求后被调用，可用于清理资源等。返回处理（已经渲染了页面）；  
   
第八步：  
request里面有userid，后台就可以识别是对哪个用户做处理  
————————————————  
版权声明：本文为CSDN博主「每天开心成为别人的望尘莫及」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/qq\_39474604/article/details/100016352