springboot整合qq登录＜3.获取跳转url和回调的接口＞

已于 2022-07-26 17:57:18 修改
阅读量8.9k 收藏
点赞数
分类专栏： springboot 笔记 文章标签： spring boot java spring
于 2022-07-26 17:19:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42794826/article/details/125999096
版权

目录

1.前置要求和授权登录原理
2.读取自定义json配置文件信息
3.获取跳转url和回调的接口
4.使用websocket和前端建立连接
5.对接qq登录的流程

获取跳转url和回调的接口
本节就是qq登录主要的核心代码了

controller

@Autowired
    private QQService qqService;

    //1.获取qq登录跳转的url
    @GetMapping("/getQQUrl")
    public Object getUrl() {
        return qqService.getUrl();
    }

    //2.回调的接口方法
        @GetMapping("/qqLogin")
    public void qqLogin(String code,String state) throws Exception {
        qqService.getToken(code,state);
    }

service

 @Autowired
    private QQBaseConfig qqBaseConfig;

    @Autowired
    private QQBaseUrl qqBaseUrl;

    @Autowired
    private RedisUtils redisUtils;

    @Override
    public String getUrl() {
        //获取get请求的url(url,Map参数)
        Map<String,String> map =new HashMap<>();
        map.put("client_id",qqBaseConfig.getClientId());
        map.put("response_type","code");
        map.put("redirect_uri", URLEncodeUtil.getURLEncoderString(qqBaseUrl.getCallbackAddress()));
        return HttpClientConfigUtils.getGetUrl(qqBaseUrl.getWebRequestUrl(), map);
    }

    /**
     * 获取用户登录的状态
     * @param uuid
     * @return
     */
    @Override
    public Object getStatus(String uuid) {
        Map<String,String> map =new HashMap<>();
        if (redisUtils.exists(uuid)){
            String status = (String) redisUtils.get(uuid);
            map.put("status",status);
            return map;
        }
        map.put("status","not_login");
        return map;
    }

    //3.通过code获取token
    public Map<String, Object> getToken(String code,String state) throws Exception {
        Map<String,String> map =new HashMap<>();
        map.put("grant_type","authorization_code");
        map.put("client_id",qqBaseConfig.getClientId());
        map.put("client_secret",qqBaseConfig.getClientSecret());
        map.put("code",code);
        map.put("redirect_uri",URLEncodeUtil.getURLEncoderString(qqBaseUrl.getCallbackAddress()));
        String getUrl = HttpClientConfigUtils.getGetUrl(qqBaseUrl.getGetTokenUrl(), map);
        // 获得token
        String result = HttpClientConfigUtils.get(getUrl, "UTF-8");
        // 把token保存
        String[] items = StringUtils.splitByWholeSeparatorPreserveAllTokens(result, "&");
        String accessToken = StringUtils.substringAfterLast(items[0], "=");
        Long expiresIn = new Long(StringUtils.substringAfterLast(items[1], "="));
        String refreshToken = StringUtils.substringAfterLast(items[2], "=");
        //token信息
        Map<String, Object> qqProperties = new HashMap<String, Object>();
        qqProperties.put("accessToken", accessToken);
        qqProperties.put("expiresIn", String.valueOf(expiresIn));
        qqProperties.put("refreshToken", refreshToken);
        String openId = getOpenId(qqProperties);
        qqProperties.put("openId", openId);
        //获取数据
        QQUserInfo userInfo = getUserInfo(qqProperties);
        Map<String,Object> infoMap = new HashMap<>();
        infoMap.put("openId",openId);
        infoMap.put("userInfo",userInfo);
        toSaveRedis(state,infoMap);
        //成功之后向
        Map<String,Object> resultMap=new HashMap<>();
        resultMap.put("state",state);
        resultMap.put("openId",openId);
        String resMapStr = JSON.toJSONString(resultMap);
        WsController.sendMessage(state,resMapStr);
        return qqProperties;
    }

    /**
     * 获取userInfo
     * @param qqProperties
     * @return
     */
    private QQUserInfo getUserInfo(Map<String, Object> qqProperties) throws Exception {
        // 取token
        String accessToken = (String) qqProperties.get("accessToken");
        String openId = (String) qqProperties.get("openId");
        if (!StringUtils.isNotEmpty(accessToken) || !StringUtils.isNotEmpty(openId)) {
            return null;
        }
        //拼接url
        StringBuilder url = new StringBuilder("https://graph.qq.com/user/get_user_info?");
        url.append("access_token=" + accessToken);
        url.append("&oauth_consumer_key=" + qqBaseConfig.getClientId());
        url.append("&openid=" + openId);
        // 获取qq相关数据
        String result = HttpClientConfigUtils.get(url.toString(), "UTF-8");
        Object json = JSON.parseObject(result, QQUserInfo.class);
        QQUserInfo userInfo = (QQUserInfo) json;
        return userInfo;
    }

    /**
     * 获取openid
     * @param qqProperties
     * @return
     */
    private String getOpenId(Map<String, Object> qqProperties) throws Exception {
// 获取保存的用户的token
        String accessToken = (String) qqProperties.get("accessToken");
        if (!StringUtils.isNotEmpty(accessToken)) {
            // return "未授权";
        }
        StringBuilder url = new StringBuilder("https://graph.qq.com/oauth2.0/me?");
        url.append("access_token=" + accessToken);
        String result = HttpClientConfigUtils.get(url.toString(), "UTF-8");
        String openId = StringUtils.substringBetween(result, "\"openid\":\"", "\"}");
        return openId;
    }

    private void toSaveRedis(String state,Object qqProperties){
        //存到redis中
        redisUtils.setWithTime(state,"login",60*10);
        //并把信息放到redis中
        String gensalt = BCrypt.gensalt();//这个是盐  29个字符，随机生成
        String uuid = BCrypt.hashpw(state, gensalt);  //根据盐对密码进行加密
        redisUtils.setWithTime(uuid,qqProperties,60*10);
    }

util

package top.chenyp.qqService.utils;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;

//清除所有类型的警告
@SuppressWarnings("all")
public class HttpClientConfigUtils {

    public static final int connTimeout = 10000;
    public static final int readTimeout = 10000;
    public static final String charset = "UTF-8";
    private static HttpClient client = null;

    static {
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(128);
        cm.setDefaultMaxPerRoute(128);
        client = HttpClients.custom().setConnectionManager(cm).build();
    }

    public static String postParameters(String url, String parameterStr)
            throws ConnectTimeoutException, SocketTimeoutException, Exception {
        return post(url, parameterStr, "application/x-www-form-urlencoded", charset, connTimeout, readTimeout);
    }

    public static String postParameters(String url, String parameterStr, String charset, Integer connTimeout,
                                        Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception {
        return post(url, parameterStr, "application/x-www-form-urlencoded", charset, connTimeout, readTimeout);
    }

    public static String postParameters(String url, Map<String, String> params)
            throws ConnectTimeoutException, SocketTimeoutException, Exception {
        return postForm(url, params, null, connTimeout, readTimeout);
    }

    public static String postParameters(String url, Map<String, String> params, Integer connTimeout,
                                        Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception {
        return postForm(url, params, null, connTimeout, readTimeout);
    }

    public static String get(String url) throws Exception {
        return get(url, charset, null, null);
    }

    public static String get(String url, String charset) throws Exception {
        return get(url, charset, connTimeout, readTimeout);
    }

    /**
     * 发送一个 Post 请求, 使用指定的字符集编码.
     *
     * @param url
     * @param body        RequestBody
     * @param mimeType    例如 application/xml "application/x-www-form-urlencoded"
     *                    a=1&b=2&c=3
     * @param charset     编码
     * @param connTimeout 建立链接超时时间,毫秒.
     * @param readTimeout 响应超时时间,毫秒.
     * @return ResponseBody, 使用指定的字符集编码.
     * @throws ConnectTimeoutException 建立链接超时异常
     * @throws SocketTimeoutException  响应超时
     * @throws Exception
     */
    public static String post(String url, String body, String mimeType, String charset, Integer connTimeout,
                              Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception {
        HttpClient client = null;
        HttpPost post = new HttpPost(url);
        String result = "";
        try {
            if (StringUtils.isNotBlank(body)) {
                HttpEntity entity = new StringEntity(body, ContentType.create(mimeType, charset));
                post.setEntity(entity);
            }
            // 设置参数
            Builder customReqConf = RequestConfig.custom();
            if (connTimeout != null) {
                customReqConf.setConnectTimeout(connTimeout);
            }
            if (readTimeout != null) {
                customReqConf.setSocketTimeout(readTimeout);
            }
            post.setConfig(customReqConf.build());

            HttpResponse res;
            if (url.startsWith("https")) {
                // 执行 Https 请求.
                client = createSSLInsecureClient();
                res = client.execute(post);
            } else {
                // 执行 Http 请求.
                client = HttpClientConfigUtils.client;
                res = client.execute(post);
            }
            result = IOUtils.toString(res.getEntity().getContent(), charset);
        } finally {
            post.releaseConnection();
            if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) {
                ((CloseableHttpClient) client).close();
            }
        }
        return result;
    }

    /**
     * 提交form表单
     *
     * @param url
     * @param params
     * @param connTimeout
     * @param readTimeout
     * @return
     * @throws ConnectTimeoutException
     * @throws SocketTimeoutException
     * @throws Exception
     */
    public static String postForm(String url, Map<String, String> params, Map<String, String> headers,
                                  Integer connTimeout, Integer readTimeout)
            throws ConnectTimeoutException, SocketTimeoutException, Exception {

        HttpClient client = null;
        HttpPost post = new HttpPost(url);
        try {
            if (params != null && !params.isEmpty()) {
                List<NameValuePair> formParams = new ArrayList<NameValuePair>();
                Set<Entry<String, String>> entrySet = params.entrySet();
                for (Entry<String, String> entry : entrySet) {
                    formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                }
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8);
                post.setEntity(entity);
            }

            if (headers != null && !headers.isEmpty()) {
                for (Entry<String, String> entry : headers.entrySet()) {
                    post.addHeader(entry.getKey(), entry.getValue());
                }
            }
            // 设置参数
            Builder customReqConf = RequestConfig.custom();
            if (connTimeout != null) {
                customReqConf.setConnectTimeout(connTimeout);
            }
            if (readTimeout != null) {
                customReqConf.setSocketTimeout(readTimeout);
            }
            post.setConfig(customReqConf.build());
            HttpResponse res = null;
            if (url.startsWith("https")) {
                // 执行 Https 请求.
                client = createSSLInsecureClient();
                res = client.execute(post);
            } else {
                // 执行 Http 请求.
                client = HttpClientConfigUtils.client;
                res = client.execute(post);
            }
            return IOUtils.toString(res.getEntity().getContent(), "UTF-8");
        } finally {
            post.releaseConnection();
            if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) {
                ((CloseableHttpClient) client).close();
            }
        }
    }

    /**
     * 发送一个 GET 请求
     *
     * @param url
     * @param charset
     * @param connTimeout 建立链接超时时间,毫秒.
     * @param readTimeout 响应超时时间,毫秒.
     * @return
     * @throws ConnectTimeoutException 建立链接超时
     * @throws SocketTimeoutException  响应超时
     * @throws Exception
     */
    public static String get(String url, String charset, Integer connTimeout, Integer readTimeout)
            throws ConnectTimeoutException, SocketTimeoutException, Exception {

        HttpClient client = null;
        HttpGet get = new HttpGet(url);
        String result = "";
        try {
            // 设置参数
            Builder customReqConf = RequestConfig.custom();
            if (connTimeout != null) {
                customReqConf.setConnectTimeout(connTimeout);
            }
            if (readTimeout != null) {
                customReqConf.setSocketTimeout(readTimeout);
            }
            get.setConfig(customReqConf.build());

            HttpResponse res = null;

            if (url.startsWith("https")) {
                // 执行 Https 请求.
                client = createSSLInsecureClient();
                res = client.execute(get);
            } else {
                // 执行 Http 请求.
                client = HttpClientConfigUtils.client;
                res = client.execute(get);
            }

            result = IOUtils.toString(res.getEntity().getContent(), charset);
        } finally {
            get.releaseConnection();
            if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) {
                ((CloseableHttpClient) client).close();
            }
        }
        return result;
    }

    /**
     * 从 response 里获取 charset
     *
     * @param ressponse
     * @return
     */
    @SuppressWarnings("unused")
    private static String getCharsetFromResponse(HttpResponse ressponse) {
        // Content-Type:text/html; charset=GBK
        if (ressponse.getEntity() != null && ressponse.getEntity().getContentType() != null
                && ressponse.getEntity().getContentType().getValue() != null) {
            String contentType = ressponse.getEntity().getContentType().getValue();
            if (contentType.contains("charset=")) {
                return contentType.substring(contentType.indexOf("charset=") + 8);
            }
        }
        return null;
    }

    /**
     * 创建 SSL连接
     *
     * @return
     * @throws GeneralSecurityException
     */
    private static CloseableHttpClient createSSLInsecureClient() throws GeneralSecurityException {
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();

            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }

                @Override
                public void verify(String host, SSLSocket ssl) throws IOException {
                }

                @Override
                public void verify(String host, X509Certificate cert) throws SSLException {
                }

                @Override
                public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
                }

            });

            return HttpClients.custom().setSSLSocketFactory(sslsf).build();

        } catch (GeneralSecurityException e) {
            throw e;
        }
    }

    public static String getGetUrl(String url,Map<String,String> map){
        StringBuilder sb =new StringBuilder(url);
        if (map.size()<=0) {
            return sb.toString();
        }else {
            sb.append("?");
        }
        AtomicBoolean isFalse = new AtomicBoolean(true);
        map.forEach((key,value)->{
            if (!isFalse.get()){
                sb.append("&");
            }else {
                isFalse.set(false);
            }
            sb.append(key);
            sb.append("=");
            sb.append(value);
        });
        return sb.toString();
    }

    public static void main(String[] args) {
        try {
            String str = post("https://localhost:443/ssl/test.shtml", "name=12&page=34",
                    "application/x-www-form-urlencoded", "UTF-8", 10000, 10000);
            // String str=
            // get("https://localhost:443/ssl/test.shtml?name=12&page=34","GBK");
            /*
             * Map<String,String> map = new HashMap<String,String>(); map.put("name",
             * "111"); map.put("page", "222"); String str=
             * postForm("https://localhost:443/ssl/test.shtml",map,null, 10000, 10000);
             */
            System.out.println(str);
        } catch (ConnectTimeoutException e) {
            e.printStackTrace();
        } catch (SocketTimeoutException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

url

package top.chenyp.qqService.utils;

import java.io.UnsupportedEncodingException;

public class URLEncodeUtil {
    private final static String ENCODE = "UTF-8";
    /**
     * URL 解码
     */
    public static String getURLDecoderString(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLDecoder.decode(str, ENCODE);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * URL 转码
     */
    public static String getURLEncoderString(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLEncoder.encode(str, ENCODE);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }
}
小小雨伞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
跳转3秒后自动返回该页面
07-25
跳转3秒后自动返回该页面 点击提交 跳转到提示页面 3秒后自动返回提交页面。
用SpringBoot整合MyBatis实现登录注册功能
12-04
这是SpringBoot整合MyBatis实现的简易登陆注册。这里所使用的开发环境是：IDEA、MySQL_8.0.17、Java8；其中用到了Druid数据库连接池...配套的博客地址为：https://blog.csdn.net/qq_44713454/article/details/103394652
js中页面跳转
u012169411的专栏
10-08 710
Javascript 返回上一页并刷新 Response.Write("alert('修改成功');history.go(-2);window.location.reload(true);");   Javascript 返回上一页 1. Javascript 返回上一页 history.go(-1), 返回两个页面: history.go(-2); 2. h
js实现页面跳转的几种方式
在思考中沉淀．．．．．．
07-23 667
第一种：    "javascript" type="text/javascript">           window.location.href="login.jsp?backurl="+window.location.href;     第二种：    "javascript"> alert("返回"); window.history.back(-1);   第三种：   "javascr
JSP跳转方式
热门推荐
itmyhome的专栏
11-15 3万+
一：RequestDispatcher.forward()        是在服务器端起作用，当使用forward()时，Servlet engine 传递HTTP请求从当前的Servlet  or jsp  到另外一个Servlet JSP 或普通HTML文件        可以进行参数传递 如： RequestDispatcher rd = context.getRequestDispa
[ 物联网篇 ] 02 - Yocto Project (YP)快速入门
程序手艺人 - 嵌入式音频技术之旅
04-07 1万+
NXP i.MX 8M Mini 的源码构建系统使用的是Yocto，如果不熟悉Yocto，完全看不懂 i.MX 8M Mini 的相关代码。 废话不多说，直接到Yocto 官网看文档，写Demo。参考官网的文档 Yocto Project Quick Start Yocto Project Quick Build Yocto Project Overview and Concepts...
记一次偶然的网站sql注入
he11oWor1d2000的博客
09-09 1万+
“绿色网站”
浏览器安全
CYP11112的博客
02-23 3150
1.同源策略 所谓的同源，指的是协议，域名，端口相同。浏览器处于安全方面的考虑，只允许本域名下的接口交互，不同源的客户端脚本，在没有明确授权的情况下，不能读写对方的资源。 URL 结果 http://a.xyz.com/dir2/other.html 成功 http://a.xyz.com/dir/inner/another.html 成功 http://a.xyz.com...
Vue+Springboot+shiro+QQ邮箱验证码的登录案例.rar
09-28
这是一个Vue+Springboot+shiro的登录案例。前端采用Vue+Elementui，对于axios进行了封装，实现了前端的路由控制，登录状态检测等。后端采用Springboot，数据持久化工具采用Mybatis，对于返回的数据进行了封装，对于...
Springboot整合Vue_CLI.zip
01-05
https://blog.csdn.net/qq_41936090/article/details/112214901
webRTC+socketio+SpringBoot视频及文字聊天demo.zip
05-18
demo使用SpringBoot+socket.io框架，基于webRTC开发的浏览器web视频与文字聊天 coturn服务搭建地址：https://blog.csdn.net/qq_37231681/article/details/92834298（在main.js中配置coturn地址及账号密码）
QQ获取等级接口.txt
07-25
QQ获取等级接口
springboot_wx_qq_login.zip
06-04
1.对接腾讯QQ登录 2.对接微信扫码登录
springboot整合license-master.zip
12-17
springboot整合license-master.zip
基于SpringBoot+Vue的聊天系统.zip
最新发布
02-21
基于SpringBoot+Vue的在线聊天系统 参考文章 https://blog.csdn.net/weixin_45393094/article/details/127940327 项目说明：即时通讯（Instant Messaging），简称IM 。经常使用QQ、微信.就是即时通讯工具，此处做一...
基于SpringBoot的校园圈子小程序.zip
04-13
目前各个高校基本都有各自的社区，但仍以传统的BBS论坛等形式为主，移动互联网形式下，多以班级、社团为单位组织的QQ、微信群为主，多未形成基于移动端的App社群区。而以学习、校园生活作为目的的交流社区、圈子，...
2000003-springboot+mysql仓库管理系统.zip
07-16
ideaIU-2020.2.3.exe jdk_8u60_x64.zip maven.zip mysql-5.7.22.1.zip SunloginClient_10.5.0.29613.exe 环境下载链接：https://blog.csdn.net/qq_36402131/article/details/118803192 系统有问题可以联系Q：...
基于SpringBoot的QQ机器人开发框架.zip
05-18
基于SpringBoot的QQ机器人开发框架.zip
springboot-0.0.1-SNAPSHOT.jar
01-24
springboot-0.0.1-SNAPSHOT.jar
springboot整合qq登录
08-11
spring.security.oauth2.client.registration.qq.redirect-uri=<YOUR_REDIRECT_URI> spring.security.oauth2.client.provider.qq.authorization-uri=https://graph.qq.com/oauth2.0/authorize spring.security....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值