尚医通 129节微信登录

最新推荐文章于 2023-02-19 08:21:30 发布
最新推荐文章于 2023-02-19 08:21:30 发布
阅读量230 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44798321/article/details/119760474
版权

一、实现原理

在这里插入图片描述
1.2、代码片段解释

@RequestMapping("callback")
    public String callback(String code, String state) {
        //获取授权临时票据
        System.out.println("微信授权服务器回调。。。。。。");
        System.out.println("state = " + state);
        System.out.println("code = " + code);

        //使用code和appid以及appscrect换取   access_token
        StringBuffer baseAccessTokenUrl = new StringBuffer()
                .append("https://api.weixin.qq.com/sns/oauth2/access_token")
                .append("?appid=%s")
                .append("&secret=%s")
                .append("&code=%s")
                .append("&grant_type=authorization_code");

        String accessTokenUrl = String.format(baseAccessTokenUrl.toString(),
                ConstantPropertiesUtil.WX_OPEN_APP_ID,
                ConstantPropertiesUtil.WX_OPEN_APP_SECRET,
                code);

        //请求这个地址
        try {
            String accesstokenInfo =  HttpClientUtils.get(accessTokenUrl);
            System.out.println("accesstokenInfo::" + accesstokenInfo);
            return accesstokenInfo;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";

1、StringBuffer()…append()为字符串拼接方法 其中appid=%s的**%s**为占位符
String.format（）为给占位符赋值的方法
String.format(baseAccessTokenUrl.toString(),
ConstantPropertiesUtil.WX_OPEN_APP_ID,
ConstantPropertiesUtil.WX_OPEN_APP_SECRET,
code);
2、accesstokenInfo 为通过工具类去换取access_token的字符串
在这里插入图片描述
3、工具类为HttpClientUtils

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.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.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.Set;


public class HttpClientUtils {

    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);
            }
            // 设置参数
            RequestConfig.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 = HttpClientUtils.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<Map.Entry<String, String>> entrySet = params.entrySet();
                for (Map.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 (Map.Entry<String, String> entry : headers.entrySet()) {
                    post.addHeader(entry.getKey(), entry.getValue());
                }
            }
            // 设置参数
            RequestConfig.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 = HttpClientUtils.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 请求
     */
    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 {
            // 设置参数
            RequestConfig.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 = HttpClientUtils.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
     */
    @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 = (SSLContext) new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();

            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory((javax.net.ssl.SSLContext) 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;
        }
    }
}
徐睡睡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
实战尚硅谷项目——尚医通（7）
dyf1996的博客
04-07 1586
微信登陆功能 微信扫描登录成功必须绑定手机号码，即：第一次扫描成功后绑定手机号，以后登录扫描直接登录成功 一、OAuth2 令牌是接近OAuth2方式，需要考虑如何管理令牌、颁发令牌、吊销令牌，需要统一的协议，因此就有了OAuth2协议 现代微服务中系统微服务化以及应用的形态和设备类型增多，不能用传统的登录方式 核心的技术不是用户名和密码，而是token，由AuthServer颁发token，用户使用token进行登录 二、前期准备 这部分准备直接使用尚硅谷课程的实例 1、注册 微信开放平
微信登录授权
10-07
微信登录授权是现代移动互联网应用中常见的用户身份验证方式，特别是在中国的互联网环境中，微信作为一款全民使用的社交软件，其登录授权功能为众多第三方应用提供了便捷的登录途径。本文将深入探讨微信登录授权的...
尚医通项目124-149：微信登录以及阿里云OSS的使用
qq_43568982的博客
06-26 627
尚医通项目
微信登录
weixin_45524836的博客
03-20 1010
一、登录需求 1、登录需求 1，登录采取弹出层的形式 2，登录方式： （1）手机号码+手机验证码 （2）微信扫描 3，无注册界面，第一次登录根据手机号判断系统是否存在，如果不存在则自动注册 4，微信扫描登录成功必须绑定手机号码，即：第一次扫描成功后绑定手机号，以后登录扫描直接登录成功 5，网关统一判断登录状态，如何需要登录，页面弹出登录层 二、微信登录 1、OAuth2 1.1 OAuth2解决什么问题 1.1.1 开放系统间授权 照片拥有者想要在云冲印服务上打印照片，云冲印服务需要访问云存储服务上的资源
尚医通 （十八）微信登录
Knight
02-19 577
尚医通 （十八）微信登录
​​​​尚硅谷—尚医通—前台用户系统—微信登录—OAuth2（124-133）
张老师的博客
07-21 858
一.OAuth2 介绍： 1）AOuth2 能解决什么问题： a：开放系统间的 授权问题： b：解决单点登录问题：（单点登录解决方案的一种） 2）授权方式： a：使用用户名密码：可以实现但不安全。 b：通用开发者 key（万能钥匙）：适用于 合作商 或者 授信的不用业务部门之间。 c：颁...
帝国CMS7.5微信登录插件可微信APP内登录 UTF-8版本
07-03
帝国CMS7.5微信登录插件是一款针对该内容管理系统开发的扩展组件，旨在提供微信账号的集成登录功能，尤其适用于支持微信APP内的便捷登录。这个插件特别强调了其兼容性和适应性，不仅覆盖了传统的PC端浏览器环境，还...
低版本微信登录修复工具解决老版本微信无法登陆问题
最新发布
06-04
微信作为中国最流行的即时通讯...总的来说，"低版本微信登录修复工具"是一种实用的解决方案，它帮助用户在无法升级微信版本的情况下也能正常使用服务。但同时，用户也应关注安全问题，适时更新软件以保护个人信息安全。
flutter中对接微信登录
01-03
如题，直接分析 本文重点讲解flutter中ios侧的微信登录对接。 fluter中对接微信分2侧，android侧很容易，而且基本没有说版本兼容性问题，很完美；ios侧就相当麻烦！ 1.微信flutter插件，我用的是 fluwx: ^1.2.1+1，...
ASP.NET Core集成微信登录
10-21
主要介绍了ASP.NET Core集成微信登录的相关资料,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
做尚医通项目遇到的问题及相关问题笔记
01-19
做尚医通项目遇到的问题及相关问题笔记
尚医通-OAuth2-微信登录接口开发（三十一）
dengfengling999的博客
01-28 1088
微信登录是基于理论知识OAuth2实现的。
Day113.尚医通：微信登录二维码、登录回调接口
a111042555的博客
07-29 2856
尚医通
尚医通 （十七）手机登录
Knight
02-18 835
尚医通 （十七）手机登录
尚医通 (三十一) --------- 手机登录
在森林里麋了鹿
12-09 938
手机登录机制
22-08-13 西安 尚医通（06）生成微信二维码、java实现微信扫码登录、阿里云存储图片
m0_56799642的博客
08-14 322
和微信端对接，忙完后微信端会给你3个参数 微信端扫描二维码，点击允许，就会调用redirect_uri接口，并且会返回code临时票据
【尚医通】微信扫码登录和手机号登录冲突问题解决思路
Decade_Faiz的博客
01-03 670
最近做尚医通遇到一个问题，和在特殊情况下会发生冲突，导致无法登录的问题。下面就描述一下几种情况。：用户第一次一上来就使用微信扫码登录，后端在调用回调函数的时候就完成了用户注册，由于是第一次登录，需要绑定手机号，于是又调用了一次手机号登录的接口，手机号登录成功之后就完成了绑定。之后就可以随便使用扫码登录或手机号登录了。：用户第一次一上来就使用手机号登录，后端会根据手机号去数据库搜索“唯一”的一条数据，如果结果为空则说明是第一次登录，直接注册；如果不为空，说明已经注册过，就直接登录。
​​​​尚硅谷—尚医通—前台用户系统—手机号登陆注册（112-123）
张老师的博客
07-21 992
一.登陆注册 需求分析： 1）登陆之后，才能预约挂号： 2）登陆采取 弹出层的 形式： 3）登录方式： a：手机号 + 验证码： b：微信扫码登陆： 4）无注册界面： a：登陆时，根据手机号判断是否存在该用户，不存在则自动注册： 5）微信扫描登陆成功后，必须绑定手机号： ...
尚医通平台地址以及服务启动
COCoDΣ的博客
03-30 3534
平台地址： - 尚医通用户前台：http://localhost:3000 - 尚医通管理后台：http://localhost:9528 - 模拟医院管理后台：http://localhost:9998/ Swagger地址： - service_hosp 医院服务api：http://localhost:8201/swagger-ui.html - service_cmn 数据字典服务api：[http://localhost:8202/swagger-ui.html
kotlin 微信登录
01-15
Kotlin是一种适用于Android开发的编程语言，可以通过它来实现微信登录功能。微信登录是指用户可以通过微信账号直接登录到我们的应用程序中，提供了一种方便快捷的登录方式。 要实现Kotlin微信登录，首先需要在微信...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

徐睡睡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值