Spring实现微信授权登录

2021-11-28

Spring实现微信授权登录

OAuth 核心

OAuth 的核心是向第三方应用颁发令牌。OAuth提供了四种获取令牌的授权方式：
授权码（authorization-code）、隐藏式（implicit）、密码式（password）、客户端凭证（client credentials）。
微信登陆采用的是授权码模式。

微信开放平台注册网站

官网地址

注册用户，添加网站应用，获取appid、appSecret、redirect_uri。

appid：应用唯一标识，微信通过这个id来识别是那个网站应用来访问的。
appSecret：应用接口使用密钥，要严格保密。一般保存在后台服务器上。
redirect_uri：微信开放平台授权回调域，用户扫描二维码并同意授权之后回调的域名。

微信授权登录流程

第三方发起微信授权登录请求，微信用户允许授权第三方应用后，微信会拉起应用或重定向到第三方网站，并且带上授权临时票据code参数；
通过code参数加上AppID和AppSecret等，通过API换取access_token、openid；
通过access_token进行接口调用，获取用户基本数据资源或帮助用户实现基本操作。

引入依赖

// https://mvnrepository.com/artifact/com.alibaba/fastjson
implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.78'

// https://mvnrepository.com/artifact/org.projectlombok/lombok
compileOnly group: 'org.projectlombok', name: 'lombok', version: '1.18.10'

// https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient
implementation group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5.13'

返回类实现

Response模板实现

import com.alibaba.fastjson.JSONObject;
import lombok.Data;

@Data
public class ServerResponseT<T> {

    String status;      //成功 or 失败
    Integer code;       //响应状态码
    String message;     //响应信息
    Object data;        //响应数据

    public static <T> ServerResponseT<T> getInstance(Class<T> t) {
        return new ServerResponseT<T>();
    }

    public static ServerResponseT<?> getInstance() {
        return new ServerResponseT();
    }

    public ServerResponseT<?> code(Integer code) {
        this.code = code;
        return (ServerResponseT<?>) this;
    }

    public ServerResponseT<?> message(String message) {
        this.message = message;
        return (ServerResponseT<?>) this;
    }

    public ServerResponseT<?> data(Object data) {
        this.data = data;
        return (ServerResponseT<?>) this;
    }

    public ServerResponseT<T> t_data(T data) {
        this.data = data;
        return (ServerResponseT<T>) this;
    }


    public ServerResponseT<T> responseEnum(ResponseEnum responseEnum) {
        this.code = responseEnum.code;
        this.message = responseEnum.message;
        return (ServerResponseT<T>) this;
    }

    public ServerResponseT<?> ok() {
        this.status = "success";
        return (ServerResponseT<?>) this;
    }

    public ServerResponseT<?> failed() {
        this.status = "failed";
        return (ServerResponseT<?>) this;
    }

    @Override
    public String toString() {
        JSONObject resultJson = new JSONObject();
        resultJson.put("code", this.code);
        resultJson.put("message", this.message);
        resultJson.put("data", this.data);
        return resultJson.toString();
    }

    // 测试
    public static void main(String[] args) {
    }
}

Response枚举类实现

public enum ResponseEnum {

    SUCCESS(1000, "成功"),
    FAILED(1001, "失败"),

    // 登录类错误
    INTERNAL_ERROR(2001, "内部错误"),
    LOGIN_SUCCESS(2002, "登录成功"),
    LOGIN_FAILED(2003, "登录错误"),
    PASSWORD_WRONG(2004, "密码错误"),
    ACCOUNT_NOT_FOUND(2005, "账号不存在，请先注册"),
    ACCOUNT_NOT_LOGIN(2006, "账号未登录"),
    ACCOUNT_TYPE_WRONG(2007, "账号类型错误"),
    ACCOUNT_PRIVILEGE_WRONG(2008, "账号权限错误"),
    WECHAT_LOGIN_FAILED(3100,"微信登录失败,请重试"),
    WECHAT_USER_EXIST(3101,"微信号已注册"),
    WECHAT_USER_NOT_EXIST(3102,"微信号未注册"),
    USER_ALREADY_BIND_WECHAT(3103,"用户已绑定微信！"),
    WECHAT_BIND_FAILED(3104,"微信绑定失败，请重试"),

    // 注册类错误
    REGISTER_SUCCESS(3000, "注册成功"),
    REGISTER_FAILED(3001, "注册失败"),
    INVALID_PARAM(3002, "参数非法"),
    USERNAME_EXIST(3003, "用户名已被注册"),

    // 验证类错误
    TOKEN_EXPIRED(4001, "userToken失效"),
    TOKEN_ERROR(4002, "userToken不能为空"),
    TOKEN_INVALID(4010, "Token失效"),

    // 文件类错误
    FILE_TYPE_INVALID(7001, "文件类型错误"),

    // 数据类错误
    GET_SUCCESS(20000, "数据获取成功"),
    GET_FAILED(20001, "数据获取失败"),
    SAVE_SUCCESS(20002, "数据上传成功"),
    SAVE_FAILED(20003, "数据上传失败"),
    DATA_NOT_EXIST(20004, "数据不存在"),
    DATA_NOT_MATCH(20005, "数据不匹配"),

    ;

    Integer code;        // 响应码
    String message;      // 响应信息

    ResponseEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Boolean checkCode(Integer code) {
        return this.code.equals(code);
    }
}

Response实现

import com.alibaba.fastjson.JSONObject;
import lombok.Data;
import lombok.EqualsAndHashCode;

@EqualsAndHashCode(callSuper = true)
@Data
public class ServerResponse extends ServerResponseT{

    String status;      //成功 or 失败
    Integer code;       //响应状态码
    String message;		//响应信息
    Object data;		//响应数据

    public static  ServerResponse getInstance() {
        return new ServerResponse();
    }

    public  ServerResponse code(Integer code){
        this.code = code;
        return (ServerResponse) this;
    }

    public  ServerResponse message(String message){
        this.message = message;
        return (ServerResponse) this;
    }

    public  ServerResponse data(Object data){
        this.data = data;
        return (ServerResponse) this;
    }


    public  ServerResponse responseEnum(ResponseEnum responseEnum){
        this.code = responseEnum.code;
        this.message = responseEnum.message;
        return (ServerResponse) this;
    }

    public ServerResponse ok(){
        this.status = "success";
        responseEnum(ResponseEnum.SUCCESS);
        return (ServerResponse) this;
    }

    public ServerResponse failed(){
        this.status = "failed";
        responseEnum(ResponseEnum.FAILED);
        return (ServerResponse) this;
    }

    @Override
    public String toString() {
        JSONObject resultJson = new JSONObject();
        resultJson.put("code", this.code);
        resultJson.put("status", this.status);
        resultJson.put("message", this.message);
        resultJson.put("data", this.data);
        return resultJson.toString();
    }

    //测试
    public static void main(String[] args) {
        JSONObject resultJSON = new JSONObject();
        resultJSON.put("userName", "曳戈泰尔");
        System.out.println(ServerResponse.getInstance().ok().responseEnum(ResponseEnum.SUCCESS).data(resultJSON));
    }
}

HTTP请求类实现

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.Map;

public class HttpHelper {

    /**
     * post请求
     *
     * @param url
     * @param json
     * @return JSONObject
     */
    public static JSONObject doPost(String url, JSONObject json) {

        CloseableHttpClient httpclient = HttpClientBuilder.create().build();
        HttpPost post = new HttpPost(url);
        JSONObject response = null;
        try {
            StringEntity s = new StringEntity(json.toString());
            s.setContentEncoding("UTF-8");
            // 发送json数据需要设置contentType
            s.setContentType("application/json");
            post.setEntity(s);
            HttpResponse res = httpclient.execute(post);
            if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                // 返回json格式
                String result = EntityUtils.toString(res.getEntity());
                response = JSONObject.parseObject(result);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return response;
    }

    /**
     * get请求
     *
     * @param url
     * @param param
     * @return JSONObject
     */
    public static JSONObject doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return JSONObject.parseObject(resultString);
    }

    /**
     * 无参get请求
     *
     * @param url
     * @return JSONObject
     */
    public static JSONObject doGet(String url) {
        return doGet(url, null);
    }

    /**
     * post请求
     *
     * @param url
     * @param map
     * @return String
     */
    public static String sendRequest(String url, Map<String, Object> map) {
        String result = "";
        // CloseableHttpClient：建立一个可以关闭的httpClient
        // 使得创建出来的HTTP实体，可以被Java虚拟机回收掉，不至于出现一直占用资源的情况。
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        // 设置请求超时时间
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(60000)
                .setConnectTimeout(60000)
                .setConnectionRequestTimeout(60000)
                .build();
        try {
            HttpPost post = new HttpPost(url);
            post.setConfig(requestConfig);
            // 发送的参数数据
            // 设置发送的数据
            StringEntity s = new StringEntity(JSON.toJSONString(map), "utf-8");
            // 发送json数据需要设置contentType
            s.setContentType("application/json");
            post.setEntity(s);
            //获取返回值
            CloseableHttpResponse res = closeableHttpClient.execute(post);
            if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                result = EntityUtils.toString(res.getEntity());
                System.out.println("POST请求返回的数据是：" + result);
            }
        } catch (Exception e) {
            System.out.println("发生了异常：" + e.getMessage());
        } finally {
            // 关闭流并释放资源
            try {
                closeableHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * post请求
     *
     * @param url
     * @param jsonObject
     * @return String
     */
    public static String sendRequest(String url, JSONObject jsonObject) {
        String result = "";
        // CloseableHttpClient：建立一个可以关闭的httpClient
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        // 设置请求超时时间
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(60000)
                .setConnectTimeout(60000)
                .setConnectionRequestTimeout(60000)
                .build();
        try {
            HttpPost post = new HttpPost(url);
            post.setConfig(requestConfig);
            // 发送的参数数据
            // 设置发送的数据
            StringEntity s = new StringEntity(jsonObject.toJSONString(), "utf-8");
            s.setContentType("application/json");
            post.setEntity(s);
            // 获取返回值
            CloseableHttpResponse res = closeableHttpClient.execute(post);
            if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                result = EntityUtils.toString(res.getEntity());// 返回json格式：
                System.out.println("POST请求返回的数据是：" + result);
            }
        } catch (Exception e) {
            System.out.println("发生了异常：" + e.getMessage());
        } finally {
            try {
                closeableHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * post请求
     *
     * @param url
     * @param map
     * @return JSONObject
     */
    public static JSONObject sendRequestGetStatus(String url, Map<String, Object> map) {
        String result = HttpHelper.sendRequest(url, map);
        if (!result.equals("")) {
            JSONObject json = JSONObject.parseObject(result);
            return json;
        }
        return null;
    }

    /**
     * post请求
     *
     * @param url
     * @param jsonObject
     * @return JSONObject
     */
    public static JSONObject sendRequestGetStatus(String url, JSONObject jsonObject) {
        String result = HttpHelper.sendRequest(url, jsonObject);
        if (!result.equals("")) {
            JSONObject json = JSONObject.parseObject(result);
            return json;
        }
        return null;
    }
}

微信配置参数实现

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * 微信配置类
 * 读取yaml配置文件参数
 */
@Configuration
public class WechatConfig {

    /**
     * 开发平台appid
     */
    @Value("${wechat.app_id}")
    private String APP_ID;

    public String getAppId() {
        return APP_ID;
    }

    /**
     * 开放平台appsecret
     */
    @Value("${wechat.app_secret}")
    private String APP_SECRET;

    public String getAppSecret() {
        return APP_SECRET;
    }

    /**
     * 开放平台回调url
     */
    @Value("${wechat.redirect_url}")
    private String REDIRECT_URL;

    public String getRedirectUrl() {
        return REDIRECT_URL;
    }

    /**
     * 微信开放平台二维码连接
     */
    public final static String OPEN_QRCODE_URL =
            "https://open.weixin.qq.com/connect/qrconnect?appid=%s&redirect_uri=%s&response_type=code&scope=snsapi_login&state=%s#wechat_redirect";
}

用户微信信息实体实现

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class WechatUserInfo {

    private String country;
    private String unionId;
    private String province;
    private String city;
    private String openid;
    private Integer sex;
    private String nickname;
    private String headimgurl;
    private String language;
    private List<String> privilege;

}

服务层实现

服务层接口

import com.demo.common.ServerResponse;
import com.demo.entity.WechatUserInfo;

public interface WechatService {

    ServerResponse getLoginUrl(String accessPage);

    ServerResponse registerUserByWechat(String code);

    ServerResponse loginUserByWechat(String code);

    ServerResponse updateWechatInfo(String userId, String code);

    public WechatUserInfo getWechatUserInfo(String code);
}

服务层实现

import com.alibaba.fastjson.JSONObject;
import com.demo.common.HttpHelper;
import com.demo.common.ResponseEnum;
import com.demo.common.ServerResponse;
import com.demo.config.WechatConfig;
import com.demo.entity.WechatUserInfo;
import com.demo.service.WechatService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

@Service
public class WechatServiceImpl implements WechatService {

    @Autowired
    private WechatConfig wechatConfig;

    @Override
    public ServerResponse getLoginUrl(String accessPage) {
        try {
            // 编码处理为官方要求
            String redirectUrl = URLEncoder.encode(accessPage, "GBK");
            // 格式化weChatConfig.getOpenQrcodeUrl()，把原模板链接的APP_ID、REDIRECT_URl、STATE替换成实际值。
            String qrcodeUrl = String.format(WechatConfig.OPEN_QRCODE_URL, wechatConfig.getAppId(), redirectUrl, "STATE");
            return ServerResponse.getInstance().ok().responseEnum(ResponseEnum.SUCCESS).data(qrcodeUrl);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.INTERNAL_ERROR);
        }
    }

    @Override
    public ServerResponse registerUserByWechat(String code) {
        WechatUserInfo wechatUserInfo = getWechatUserInfo(code);
        if (wechatUserInfo == null)
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_LOGIN_FAILED);

        // 伪代码 start
        // 已经存在的微信号无法注册，通过查询数据表获得
        if (WechatUserMapper.existsByOpenid(wechatUserInfo.getOpenid())) {
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_USER_EXIST);
        }

        // 生成用户ID
        String userId = IDGenerator.UserIDGenerate();

        // 获取用户微信信息的实体
        WechatUserEntity wechatUserEntity = WechatUserConverter.INSTANCE.dto2entity(wechatUserInfo);
        wechatUserEntity.setUserId(userId);

        // 设置用户实体信息
        UserEntity userEntity = UserEntity.builder()
                .userId(userId)
                .userName(wechatUserEntity.getNickname())
                .userAvatar(wechatUserEntity.getHeadimgurl())
                .openid(wechatUserEntity.getOpenid())
                .wechatBindState(true)
                .build();

        // 微信帐号体系关联平台账号体系，通过userId
        try {
            // 保存用户信息到用户信息表
            // 如果用户不绑定平台账户，需要使用这个实体信息
            UserMapper.save(userEntity);
            // 保存用户微信信息到用户微信信息表
            WechatUserMapper.save(wechatUserEntity);
        } catch (Exception e) {
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.REGISTER_FAILED);
        }

        // 生成平台token，登录部分
        String token = loginTokenHelper.createToken(userId);
        // 返回用户ID及token到前端
        JSONObject resultJSON = new JSONObject();
        resultJSON.put("userId", userId);
        resultJSON.put("token", token);
        return ServerResponse.getInstance().ok().responseEnum(ResponseEnum.SUCCESS).data(resultJSON);

        // 伪代码 end
    }

    @Override
    public ServerResponse loginUserByWechat(String code) {
        WechatUserInfo wechatUserInfo = getWechatUserInfo(code);
        if (wechatUserInfo == null)
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_LOGIN_FAILED);

        // 伪代码 start
        // 通过openid查询用户
        UserEntity userEntity = UserMapper.findByOpenid(wechatUserInfo.getOpenid());
        //用户不存在
        if (userEntity == null)
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_USER_NOT_EXIST);

        // 用户存在，生成token
        String token = loginTokenHelper.createToken(userEntity.getUserId());
        if (!StringUtils.isEmpty(token)) {
            LoginUserEntity loginEntity = UserConverter.INSTANCE.entity2loginEntity(userEntity);
            loginEntity.setUserToken(token);
            return ServerResponse.getInstance().ok().responseEnum(ResponseEnum.SUCCESS).data(loginEntity);
        }
        // 伪代码 end

        return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.INTERNAL_ERROR);
    }

    // 已经存在的账号，绑定微信账号
    @Override
    public ServerResponse updateWechatInfo(String userId, String code) {

        WechatUserInfo wechatUserInfo = getWechatUserInfo(code);
        if (wechatUserInfo == null)
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_LOGIN_FAILED);

        // 伪代码 start
        // 判断微信号是否已经存在
        if (WechatUserMapper.existsByOpenid(wechatUserInfo.getOpenid())) {
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_USER_EXIST);
        }

        // 判断是否已经绑定微信号。已经绑定则无法绑定新的微信号（暂不支持换绑）
        UserEntity userEntity = UserMapper.findByUserId(userId);
        if (userEntity == null)
            // 平台账户不存在
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.ACCOUNT_NOT_FOUND);
        if (userEntity.getWechatBindState()) {
            // 用户已经绑定微信
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.USER_ALREADY_BIND_WECHAT);
        }

        // 设置userId到用户微信信息实体
        WechatUserEntity wechatUserEntity = WechatUserConverter.INSTANCE.dto2entity(wechatUserInfo);
        wechatUserEntity.setUserId(userId);

        // 设置用户实体绑定状态，openid
        userEntity.setWechatBindState(true);
        userEntity.setOpenid(wechatUserEntity.getOpenid());

        // 保存关联信息到数据表，通过userId关联两个账户体系
        try {
            WechatUserMapper.save(wechatUserEntity);
            UserMapper.save(userEntity);
        } catch (Exception e) {
            return ServerResponse.getInstance().failed().responseEnum(ResponseEnum.WECHAT_BIND_FAILED);
        }
        // 伪代码 end

        return ServerResponse.getInstance().ok().responseEnum(ResponseEnum.SUCCESS);
    }

    public WechatUserInfo getWechatUserInfo(String code) {
        // 第二步：通过code换取网页授权access_token
        String url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + wechatConfig.getAppId() +
                "&secret=" + wechatConfig.getAppSecret() +
                "&code=" + code +
                "&grant_type=authorization_code";
        JSONObject jsonObject = HttpHelper.doGet(url);
        System.out.println(jsonObject.toString());

        String openId = jsonObject.getString("openid");
        String access_Token = jsonObject.getString("access_token");

        if (access_Token == null) {
            return null;
        }

        // 第四步：拉取用户信息(需scope为 snsapi_userinfo)
        url = "https://api.weixin.qq.com/sns/userinfo?access_token=" + access_Token +
                "&openid=" + openId +
                "&lang=zh_CN";
        JSONObject userInfoJson = HttpHelper.doGet(url);
        System.out.println(jsonObject.toString());

        try {
            WechatUserInfo userInfo = JSONObject.toJavaObject(userInfoJson, WechatUserInfo.class);
            if (userInfo == null)
                throw new Exception();
            return userInfo;

        } catch (Exception e) {
            return null;
        }
    }
}

控制层实现

import com.demo.common.ServerResponse;
import com.demo.service.WechatService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

@RestController
@RequestMapping("/user")
public class WechatController {

    @Autowired
    private WechatService wechatService;

    /**
     * 拼装微信扫一扫登录url
     */
    @PostMapping("/check/checkWechat")
    // 传入 access_page 参数
    public ServerResponse checkWechat(@RequestParam(value = "access_page", required = true) String accessPage) {
        return wechatService.getLoginUrl(accessPage);
    }

    /**
     * 微信扫码注册
     */
    @PostMapping("/register/ByWechat")
    public ServerResponse registerUserByWechat(@RequestParam(value = "code", required = true) String code) throws IOException {
        return wechatService.registerUserByWechat(code);
    }

    /**
     * 微信扫码登录
     */
    @PostMapping("/login/ByWechat")
    public ServerResponse loginUserByWechat(@RequestParam(value = "code", required = true) String code) throws IOException {
        return wechatService.loginUserByWechat(code);
    }

    /**
     * 微信扫码更新用户绑定
     */
    @PostMapping("/info/updateWechat")
    public ServerResponse updateWechatInfo(@RequestParam String userId, @RequestParam String code) throws IOException {
        return wechatService.updateWechatInfo(userId, code);
    }

}

参考文章

SpringBoot实现微信授权登录、二维码登录

spring security oauth2 实现微信登陆