微信小程序一键登录功能,使用uni-app和springboot(JWT鉴权)

微信小程序一键登录功能,使用uni-app和springboot(JWT鉴权)

目录

概述

微信登录接口说明

 关于获取微信用户的信息

后端代码(SpringBoot)

配置文件:application.yml 

配置文件:Pom.xml 

类:WeChatModel  

 类:WeChatSessionModel

 类:UserInfoController

业务层实现类:UserInfoServiceImpl

拦截器配置-自定义拦截器

拦截器配置-注册自定义拦截器

测试(Postman)

总结


概述

本篇博本主要为了记录使用uni-app开发微信小程序时实现微信一键登录功能,并且使用JWT实现身份认证

微信登录接口说明

可以点击==>官方的登录时序图<== ,看到官方描述登录的流程。

大概描述就是 :uni-app调用login()方法,获取临时凭证code,将此临时凭证发送到我们的后端,后端通过我们传入的临时凭证code,调用微信接口服务获取当前微信用户的唯一标识openid,我们就可以凭借此openid知道哪一个用户在进行登录操作。

值得注意的是

1.通过login()获取的临时凭证code的有效期为5分钟,并且只能使用一次。

2.后端调用微信凭证验证接口获取openid需要appIdappSecret,两者都可以到微信小程序官网==>开发管理==>开发设置 中获取。

如下是我画的整体大概流程

总体说明 整个流程就是当用户点击"微信一键登录",传入临时凭证code,后端通过临时凭证code去微信服务接口获取该用户的openid,此openid是唯一的不会变的。 那么我们就可以将openid存储用户数据表中,用来标识此用户。

 关于获取微信用户的信息

关于API:uni.getUserInfo(OBJECT) 和 uni.getUserProfile(OBJECT) 接口的说明。

目前两个接口都无法获取用户信息,只能获取到默认用户信息,名称为'微信用户',头像为灰色用户头像。

关于官方描述:==>原文<==

 那么解决方案只能是用户登录后,让用户自行上传修改信息。

前端代码(uni-app)

 前端的代码很简单,只是调用uni.login()获取临时凭证code传入后端接口即可。

<template>
	<view>
		<button id="loginHanle" @tap="goLogin">微信一键登录</button>
	</view>
</template>
<script>
	export default {
		methods: {
			// 登录按钮触发
			loginHanle() {
			    // 获取临时登录凭证code。
			    uni.login({
			        provider: 'weixin',
			        su***ess(res) {
                        console.log(res.code);
						// 调用后端接口,传入code
			            axios.post('http://localhost:8888/api/userInfo/login',{code:res.code})
.then(res=>{
    // 登录成功后的逻辑处理
    ...
})
			        }
			    })
		}
	}
</script>

后端代码(SpringBoot)

后端需要接收前端传入的临时凭证code,向微信服务器发送请求获取登录用户的openid。并且操作数据库后返回用户信息,以及响应头返回token


配置文件:application.yml 

# JWT配置
jwt:
  header: "Authorization" #token返回头部
  tokenPrefix: "Bearer " #token前缀
  secret: "maohe101" #密钥
  expireTime: 3600000 #token有效时间 3600000毫秒 ==> 60分钟
# 微信小程序配置码
APPID: 自己的appid
APPSECRET: 自己的密匙

配置文件:Pom.xml 

添加需要依赖 

<!-- jwt支持 -->
<dependency>
    <groupId>***.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.19.2</version>
</dependency>

<!-- json格式化 -->
<dependency>
    <groupId>***.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
</dependency>

类:WeChatModel  

接收前端传入参数

package ***.mh.***mon;

import lombok.Data;

/**
 * Date:2023/5/24
 * author:zmh
 * description: 接收小程序传入参数
 **/

@Data
public class WeChatModel {

    /**
     * 临时登录凭证
     */
    private String code;

    /**
     * 微信服务器上的唯一id
     */
    private String openId;
}

 类:WeChatSessionModel

接收调用微信验证code后返回的数据。

package ***.mh.***mon;

import lombok.Data;

/**
 * Date:2023/5/24
 * author:zmh
 * description: 接收微信服务器返回参数
 **/

@Data
public class WeChatSessionModel {

    /**
     * 微信服务器上辨识用户的唯一id
     */
    private String openid;

    /**
     * 身份凭证
     */
    private String session_key;

    /**
     * 错误代码
     */
    private String errcode;

    /**
     * 错误信息
     */
    private String errmsg;
}

 类:UserInfoController

接收临时凭证code,调用业务层方法

@Autowired
private UserInfoService userInfoService;

/**
 * 微信登录
 * @param weChatModel 获取临时凭证code
 * @param response ·
 * @return 返回执行结果
 */
@PostMapping("/login")
public R<String> loginCheck(@RequestBody WeChatModel weChatModel, HttpServletResponse response){
    // 检查登录
    Map<String, Object> resultMap = userInfoService.checkLogin(weChatModel.getCode());
    // resultMap大于1为通过,业务层判断正确后返回用户信息和token,所以应该size为2才正确。
    if (resultMap.size() > 1){
        log.info("创建的token为=>{}", resultMap.get("token"));
        // 将token添加入响应头以及返回用户信息
        response.setHeader(JWTUtils.header, (String) resultMap.get("token"));
        return R.su***ess(resultMap.get("user").toString());
    }else{
        // 当返回map的size为1时,即为报错信息
        return R.error(resultMap.get("errmsg").toString());
    }
}

业务层实现类:UserInfoServiceImpl

登录验证的逻辑处理 

package ***.mh.service.impl;

import ***.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import ***.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import ***.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import ***.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import ***.google.gson.Gson;
import ***.mh.***mon.R;
import ***.mh.***mon.WeChatSessionModel;
import ***.mh.***mon.WeChatModel;
import ***.mh.dao.FansInfoDao;
import ***.mh.dao.FollowInfoDao;
import ***.mh.dao.UserInfoDao;
import ***.mh.pojo.FansInfo;
import ***.mh.pojo.FollowInfo;
import ***.mh.pojo.UserInfo;
import ***.mh.service.UserInfoService;
import ***.mh.utils.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * Date:2023/5/24
 * author:zmh
 * description: 用户信息业务层实现类
 **/

@Service
@Slf4j
public class UserInfoServiceImpl extends ServiceImpl<UserInfoDao, UserInfo> implements UserInfoService {

    @Autowired
    private UserInfoDao userInfoDao;

    @Value("${APPID}")
    private String appid;

    @Value("${APPSECRET}")
    private String appsecret;

    @Autowired
    private RestTemplate restTemplate;
	
	// 用于存储用户信息和token
    Map<String,Object> map = new HashMap<>();

    /**
     * 登录验证
     * @param code 临时登录码
     * @return ·
     */
    public Map<String,Object> checkLogin(String code){
        // 根据传入code,调用微信服务器,获取唯一openid
        // 微信服务器接口地址
        String url = "https://api.weixin.qq.***/sns/jscode2session?appid="+appid+ "&secret="+appsecret
                +"&js_code="+ code +"&grant_type=authorization_code";
        String errmsg = "";
        String errcode = "";
        String session_key = "";
        String openid = "";
        WeChatSessionModel weChatSessionModel;
        // 发送请求
        ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, null, String.class);
		// 判断请求是否成功
        if(responseEntity != null && responseEntity.getStatusCode() == HttpStatus.OK) {
			// 获取主要内容
            String sessionData = responseEntity.getBody();
            Gson gson = new Gson();
            //将json字符串转化为实体类;
            weChatSessionModel = gson.fromJson(sessionData, WeChatSessionModel.class);
            log.info("返回的数据==>{}",weChatSessionModel);
            //获取用户的唯一标识openid
            openid = weChatSessionModel.getOpenid();
            //获取错误码
            errcode = weChatSessionModel.getErrcode();
            //获取错误信息
            errmsg = weChatSessionModel.getErrmsg();
        }else{
            log.info("出现错误,错误信息:{}",errmsg );
            map.put("errmsg",errmsg);
            return map;
        }
        // 判断是否成功获取到openid
        if ("".equals(openid) || openid == null){
            log.info("错误获取openid,错误信息:{}",errmsg);
            map.put("errmsg",errmsg);
            return map;
        }else{
            // 判断用户是否存在,查询数据库
            LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(UserInfo::getOpenid, openid);
            UserInfo userInfo = userInfoDao.selectOne(queryWrapper);
            // 不存在,加入数据表
            if (userInfo == null){
                // 填充初始信息
                UserInfo tempUserInfo = new UserInfo(UUID.randomUUID().toString(), openid, "微信用户", 1,"default.png", "",0,0,0);
				// 加入数据表
                userInfoDao.insert(tempUserInfo);
				// 加入map返回
                map.put("user",tempUserInfo);
				// 调用自定义类封装的方法,创建token
                String token = JWTUtils.createToken(tempUserInfo.getId().toString());
                map.put("token",token);
                return map;
            }else{
                // 存在,将用户信息加入map返回
                map.put("user",userInfo);
                String token = JWTUtils.createToken(userInfo.getId().toString());
                map.put("token",token);
                return map;
            }
        }
    }


}

工具类:JWTUtils

 用于创建,验证和更新token

package ***.mh.utils;

import ***.auth0.jwt.JWT;
import ***.auth0.jwt.algorithms.Algorithm;
import ***.auth0.jwt.exceptions.TokenExpiredException;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.***ponent;

import java.util.Date;

/**
 * Date:2023/5/24
 * author:zmh
 * description:JWT工具类,JWT生成,验证
 **/


@***ponent
@Data
@ConfigurationProperties(prefix = "jwt")
@Slf4j
public class JWTUtils {
    //定义token返回头部
    public static String header;

    //token前缀
    public static String tokenPrefix;

    //签名密钥
    public static String secret;

    //有效期
    public static long expireTime;

    public void setHeader(String header) {
        JWTUtils.header = header;
    }

    public void setTokenPrefix(String tokenPrefix) {
        JWTUtils.tokenPrefix = tokenPrefix;
    }

    public void setSecret(String secret) {
        JWTUtils.secret = secret;
    }

    public void setExpireTime(long expireTime) {
        JWTUtils.expireTime = expireTime;
    }

    /**
     * 创建TOKEN
     *
     * @param sub
     * @return
     */
    public static String createToken(String sub) {
        return tokenPrefix + JWT.create()
                .withSubject(sub)
                .withExpiresAt(new Date(System.currentTimeMillis() + expireTime))
                .sign(Algorithm.HMAC512(secret));
    }


    /**
     * 验证token
     *
     * @param token
     */
    public static String validateToken(String token) {
        try {
            return JWT.require(Algorithm.HMAC512(secret))
                    .build()
                    .verify(token.replace(tokenPrefix, ""))
                    .getSubject();
        } catch (TokenExpiredException e) {
            log.info("token已过期");
            return "";
        } catch (Exception e) {
            log.info("token验证失败");
            return "";
        }
    }

    /**
     * 检查token是否需要更新
     * @param token ·
     * @return
     */
    public static boolean isNeedUpdate(String token) {
        //获取token过期时间
        Date expiresAt = null;
        try {
            expiresAt = JWT.require(Algorithm.HMAC512(secret))
                    .build()
                    .verify(token.replace(tokenPrefix, ""))
                    .getExpiresAt();
        } catch (TokenExpiredException e) {
            return true;
        } catch (Exception e) {
            log.info("token验证失败");
            return false;
        }
        //如果剩余过期时间少于过期时常的一般时 需要更新
        return (expiresAt.getTime() - System.currentTimeMillis()) < (expireTime >> 1);
    }

}

拦截器配置-自定义拦截器

当用户访问非登录接口时,需要拦截请求,判断用户的请求头是否携带了正确的token,携带了代表登录过了,请求通过,返回数据,若未token验证失败则错误提示。

package ***.mh.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Date:2023/5/26
 * author:zmh
 * description: 自定义登录拦截器
 **/

@Slf4j
public class UserLoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取请求头,header值为Authorization,承载token
        String token = request.getHeader(JWTUtils.header);
        //token不存在
        if (token == null || token.equals("")) {
            log.info("传入token为空");
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Token为空!");
            return false;
        }
        //验证token
        String sub = JWTUtils.validateToken(token);
        if (sub == null || sub.equals("")){
            log.info("token验证失败");
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Token验证失败!");
            return false;
        }
        //更新token有效时间 (如果需要更新其实就是产生一个新的token)
        if (JWTUtils.isNeedUpdate(token)){
            String newToken = JWTUtils.createToken(sub);
            response.setHeader(JWTUtils.header,newToken);
        }
        return true;
    }

}

拦截器配置-注册自定义拦截器

package ***.mh.config;

import ***.mh.utils.UserLoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMv***onfigurer;

/**
 * Date:2023/5/26
 * author:zmh
 * description: MVW配置
 **/

@Configuration
public class WebMv***onfig implements WebMv***onfigurer {

    /**
     * 注册自定义拦截器
     * @param registry ·
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserLoginInterceptor())
                .addPathPatterns("/api/**") // 拦截地址
                .excludePathPatterns("/api/userInfo/login");// 开放登录路径
    }

}

测试(Postman)

1.测试微信一键登录 

微信小程序获取临时凭证code

 通过返回的code到postman中测试调用后端登录接口

 获取到返回,代表登录成功。

2.测试token的验证 

调用非登录接口,会被拦截进行token的检查。

后端日志输出: 

 携带错误或过期的token,验证失败

 后端日志输出 

 携带正确且在有效期内的token,验证成功,测试通过。

总结

 对于如上代码,其实微信登录的逻辑是比较简单的,代码更多的是在处理身份验证(token验证),后端设置了请求拦截器,会去拦截所有非登录接口,通过检查token判断是否登录过了。

对于前端发送请求,如上只是使用了Postman进行接口的访问,并没有从代码层面去发送请求,那么,其实前端是比较需要去封装请求方法的,在封装的请求方法中加入请求头携带token,避免每一次请求都需要手动加上请求头携带token。

如博文内容存在不足之处请指出,感谢访问。

转载请说明出处内容投诉
CSS教程_站长资源网 » 微信小程序一键登录功能,使用uni-app和springboot(JWT鉴权)

发表评论

欢迎 访客 发表评论

一个令你着迷的主题!

查看演示 官网购买