微信登录(授权登录、扫码登录、静默登录)简述

最新推荐文章于 2023-10-28 17:06:26 发布
最新推荐文章于 2023-10-28 17:06:26 发布
阅读量2.4k 收藏 2
点赞数 1
分类专栏： Java_工具类 文章标签： weixin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao190128/article/details/100702418
版权

微信登录我写过的有三种登录方法(授权登录、静默登录、扫码登录)这里说一下我的看法(个人观点，欢迎拍砖)。
1、授权登录需要拉起需要用户确认的授权页(｀・ω・´)
这里写图片描述
有些人可能会不喜欢，例如我老板(T＿T)，此方式可以获取比较多的信息，例如头像、昵称、openid、unionid、是否关注公众号等信息
个人认为此种授权方式比较适合纯在微信端运营的网站，如果不考虑脱离微信端的话。
2、静默登录，这个当前环境下很流行，用appid去获取code然后获取用户的openid，拿到openid之后就可以进行自己业务处理了，从体验上来说用户无感，没有上面那个授权页，个人认为此种授权方式比较适合较为独立或者正在考虑脱离微信的网站，
3、扫码登录，此种方式一般适用于电商网站的PC登录,如下图
这里写图片描述
好啦，开始介绍开发流程。

1、授权登录：
a)、首先需要在公众号取得相应的获取用户基本信息的权限。推荐适用拦截器的方式拦截部分需要授权的功能，例如钱包、个人中心等，对于网站介绍，或者一些推广页、首页这些不需要授权可以提升一下用户体验，虽然从开发的角度看意义不大，拦截代码如下

package com.xxx.filter;

import com.xxx.util.CookieUtil;
import com.xxx.util.IPUtil;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class WeChatUserFilter implements Filter {

    protected static final Logger LOG = LoggerFactory.getLogger(WeChatUserFilter.class);

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest _request, ServletResponse _response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) _request;
        HttpServletResponse response = (HttpServletResponse) _response;
        // 获取当前访问路径
        String path = request.getRequestURI().toString();
        // 拦截地址配置
        String[] filterUrls = { "/home", "/XXXX/XXX", "/XXX/XXXX" };
        for (String url : filterUrls) {
            if (path.contains(url)) {
                // 拦截
                LOG.info("拦截的地址是:" + path + ",ip:" + IPUtil.getIpAddr(request));
                String openid = CookieUtil.getCookieValue(request, "openid");
                if (StringUtils.isNotBlank(openid)) {
                    chain.doFilter(_request, _response);
                    return;
                }
                if (StringUtils.isNotBlank(request.getQueryString())) {
                    path += "?" + request.getQueryString();
                }
                response.sendRedirect(response.encodeURL("/user/login?u=" + response.encodeURL(path)));
                return;
            }
        }
        chain.doFilter(_request, _response);
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
        // TODO Auto-generated method stub

    }

}

    b)、如果用户没有进行过授权则会跳转到/user/login中进行登录，完整的登录代码如下

    @RestController
@RequestMapping(value = "user")
public class LoginController {
    protected static final Logger LOG = LoggerFactory.getLogger(LoginController.class);

    // 公众号APPID
    public static final String WX_APPID = "XXXXXXXXXXXX";
    // 公众号SECRET
    public static final String WX_APP_SECRET = "XXXXXXXXXXXX";

    @RequestMapping(value = "login", method = RequestMethod.GET)
    public void toLogin(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 获取cookie中的openid
        String openid = CookieUtil.getCookieValue(request, "openid");
        String unionid = CookieUtil.getCookieValue(request, "unionid");
        // 定义微信授权之后的跳转地址命名方式为(http://你的网址+/user/login?u=)
        String reUrl = "";
        // 获取需要跳转的url
        String u = request.getParameter("u");
        LOG.error("需要跳转的url为:", u);
        // 判断如果openid不存在，则获取code
        // 如果拦截到的跳转的地址为空则给个默认值
        if (StringUtils.isBlank(u)) {
            u = "/indexController/index";
        }
        if (StringUtils.isBlank(openid) || StringUtils.isBlank(unionid)) {
            // 获取code
            String code = request.getParameter("code");
            LOG.error("code:", code);
            if (StringUtils.isBlank(code)) {
                // 跳转到微信端获取code
                String redrictUrl = response.encodeURL(reUrl + response.encodeURL(u));
                String url = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=" + WX_APPID + "&redirect_uri="
                        + redrictUrl + "&response_type=code&scope=snsapi_userinfo&state=0#wechat_redirect";
                try {
                    response.sendRedirect(url);
                } catch (IOException e) {
                    // logger.error("url:重定向错误");
                }
                return;
            } else {
                // 获取用户信息
                JSONObject object = getSnsapiUserinfo(request, code);
                if (object != null) {
                    String user_unionid = object.getString("unionid");
                    String user_openid = object.getString("openid");
                    if (StringUtils.isBlank(user_unionid) || StringUtils.isBlank(user_openid)) {
                        return;
                    }
                    String headimgurl = object.getString("headimgurl");
                    String nickname = EmojiFilter.filterEmoji(object.getString("nickname"));
                }

            }
        }
        // 返回客户访问页面
        try {
            response.sendRedirect(u);
        } catch (IOException e) {
            // logger.error("url:重定向错误");
        }
    }

    public static JSONObject getSnsapiUserinfo(HttpServletRequest request, String code)
            throws org.apache.commons.httpclient.HttpException {
        JSONObject wxuser;

        String t_url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + WX_APPID + "&secret="
                + WX_APP_SECRET + "&code=" + code + "&grant_type=authorization_code";
        Proxy httproxy = new Proxy();
        final String result = httproxy.get(t_url, null);
        LOG.info("sns/oauth2/access_token：" + result);
        JSONObject obj = JSON.parseObject(result);
        String openid = obj.getString("openid");
        // 判断用户是否存在
        String t_access_token = obj.getString("access_token");
        String t_url_2 = "https://api.weixin.qq.com/sns/userinfo?access_token=" + t_access_token + "&openid=" + openid;
        final String res2 = httproxy.get(t_url_2, null);
        wxuser = JSON.parseObject(res2);
        LOG.info("网页授权获取用户基本信息：" + wxuser.toString());
        return wxuser;
    }
}

      2、静默登录 静默登录只需在授权登录的基础之上更改scope参数的值即可 如下

      String url = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=" + WX_APPID + "&redirect_uri="
                        + redrictUrl + "&response_type=code&scope=     snsapi_base&state=0#wechat_redirect";
 
 
      
 
 
      • 1
      • 2

      3、扫码登录就简单很多了
      只需拉起微信扫码页然后设置扫码成功之后的回调方法即可，具体如下:
      a)、拉起微信扫码登录页

      String WX_SCAN_CODE_URL = "https://open.weixin.qq.com/connect/qrconnect?appid={APPID}&redirect_uri={REUTL}&response_type=code&scope=snsapi_login&state={STATE}#wechat_redirect";
    // 千万要记住，这个是微信开放平台的APPID
    String WX_PLATFROM_APPID = "XXXXXX";
    // 你的回调地址
    String scanReUrl = "http://你的网址/user/wxLoginCallback";

    /**
     * 微信扫码登陆
     * 
     * @param request
     * @param response
     */
    @RequestMapping(value = "weixinScanLogin", method = RequestMethod.GET)
    public void weixinRetrun(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 获取回调url(非必填，只是附带上你扫码之前要进入的网址，具体看业务是否需要)
        String url = request.getParameter("reurl");
        // 拼接扫码登录url
        String wxLoginurl = WX_SCAN_CODE_URL;
        wxLoginurl = wxLoginurl.replace("{APPID}", WX_PLATFROM_APPID).replace("{REUTL}", scanReUrl).replace("{STATE}",
                url);
        wxLoginurl = response.encodeURL(wxLoginurl);
        response.sendRedirect(wxLoginurl);
    }

        b)、微信扫码登录的回调地址

        // 千万要记住，这个是微信开放平台的APPID
    String WX_PLATFROM_APPID = "XXXXXXXXX";
    // 千万要记住，这个是微信开放平台的APPSECRET
    String WX_PLATFORM_APPSECRET = "XXXXXXXXXX";
    // 拉起微信扫码页地址
    String WX_SCAN_URL = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code";
    // 微信扫码之后获取用户基本信息的地址
    String WX_SCAN_GET_USER_INFO = "https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID";

    /**
     * 微信扫码登录回调
     * 
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "wxLoginCallback", method = RequestMethod.GET)
    public void loginCallback(HttpServletRequest request, HttpServletResponse response) throws Exception {
        String code = request.getParameter("code");
        if (code == null) {
            // 用户禁止授权
        }
        String url = WX_SCAN_URL.replace("APPID", WX_PLATFROM_APPID).replace("SECRET", WX_PLATFORM_APPSECRET)
                .replaceAll("CODE", code);
        url = response.encodeURL(url);
        try {
            String result = HttpClientUtils.get(url, null);
            Map<String, Object> resultMap = JsonHelper.toMap(result);
            String unionid = (String) resultMap.get("unionid");
            String access_token = (String) resultMap.get("access_token");
            String openid = (String) resultMap.get("openid");
            // 这里可以根据获取的信息去库中判断是否存在库中 如果不存在执行以下方法
            // 如果该用户不存在数据库中
            // 获取用户信息
            url = ConstantHelper.WX_SCAN_GET_USER_INFO.replace("ACCESS_TOKEN", access_token).replace("OPENID", openid);
            url = response.encodeURL(url);
            String userResult = HttpClientUtils.get(url, null);
            Map<String, Object> userResultMap = JsonHelper.toMap(userResult);
            // 注册一个用户
            System.out.println("扫码登录返回值******************:" + userResult);
            String headimgurl = (String) userResultMap.get("headimgurl");
            // 处理微信名特殊符号问题 过滤图标
            String nickname = (String) userResultMap.get("nickname");
            // 把用户信息存入session中
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 返回地址
        try {
            String newUrl = request.getParameter("state");
            response.sendRedirect(newUrl);
        } catch (IOException e) {
            // logger.error("url:重定向错误");
        }
    }

          下面附上几个工具类

          public class Proxy {
    // const
    public final static int DEFAULT_CONNECT_TIMEOUT = 15000 * 2;
    public final static int DEFAULT_SO_TIMEOUT = 30000 * 2;
    public final static int DEFAULT_BUFFER_SIZE = 256;
    public final static int DEFAULT_MAX_CONNECTIONS = 200 * 2;

    private final static String CS_PREFIX = "charset=";
    private final static int CS_PREFIX_LEN = CS_PREFIX.length();

    // 数据编码格式
    private final String encoding;
    // client
    private final HttpClient client;
    // buffer
    private final int bufferSize;

    public Proxy() {
        this("UTF-8", DEFAULT_CONNECT_TIMEOUT, DEFAULT_SO_TIMEOUT, DEFAULT_BUFFER_SIZE, DEFAULT_MAX_CONNECTIONS);
    }

    public Proxy(final String encoding) {
        this(encoding, DEFAULT_CONNECT_TIMEOUT, DEFAULT_SO_TIMEOUT, DEFAULT_BUFFER_SIZE, DEFAULT_MAX_CONNECTIONS);
    }

    public Proxy(final int bufferSize) {
        this("UTF-8", DEFAULT_CONNECT_TIMEOUT, DEFAULT_SO_TIMEOUT, bufferSize, DEFAULT_MAX_CONNECTIONS);
    }

    public Proxy(final String encoding, final int connectTimeout, final int soTimeout) {
        this(encoding, connectTimeout, soTimeout, DEFAULT_BUFFER_SIZE, DEFAULT_MAX_CONNECTIONS);
    }

    public Proxy(final String encoding, final int connectTimeout, final int soTimeout, final int bufferSize) {
        this(encoding, connectTimeout, soTimeout, bufferSize, DEFAULT_MAX_CONNECTIONS);
    }

    public Proxy(final String encoding, final int connectTimeout, final int soTimeout, final int bufferSize, final int maxConnections) {
        this.encoding = encoding;
        // connect-parameters
        final HttpConnectionManagerParams mp = new HttpConnectionManagerParams();
        mp.setConnectionTimeout(connectTimeout);
        mp.setSoTimeout(soTimeout);
        mp.setStaleCheckingEnabled(true);
        mp.setTcpNoDelay(true);
        mp.setMaxTotalConnections(maxConnections);
        final HttpConnectionManager mgr = new SimpleHttpConnectionManager();
        mgr.setParams(mp);
        // client-init
        this.client = new HttpClient(mgr);
        // client-parameters
        final HttpClientParams cparams = new HttpClientParams();
        // 设置httpClient的连接超时，对连接管理器设置的连接超时是无用的
        cparams.setConnectionManagerTimeout(connectTimeout);
        this.client.setParams(cparams);
        this.bufferSize = bufferSize;
    }

    public HttpClient getClient() {
        return client;
    }

    public String getEncoding() {
        return encoding;
    }

    public String post(final String url, final Map<String, String> headers, final Map<String, String> data, final String encoding) throws HttpException {
        // post方式
        final PostMethod post = new PostMethod(url);
        // headers
        setHeaders(post, headers);
        // content
        if (data != null) {
            Set<Map.Entry<String, String>> postset = data.entrySet();
            final NameValuePair[] params = new NameValuePair[postset.size()];
            int i = 0;
            for (Iterator<Map.Entry<String, String>> it = postset.iterator(); it.hasNext();) {
                Map.Entry<String, String> p = it.next();
                params[i++] = new NameValuePair(p.getKey(), p.getValue());
            }
            post.setRequestBody(params);
        }
        try {
            return (execute(post, encoding));
        } finally {
            post.releaseConnection();
        }
    }

    public String post(final String url, final Map<String, String> data, final String encoding) throws HttpException {
        return post(url, null, data, encoding);
    }

    @SuppressWarnings("deprecation")
    public String post(final String url, final Map<String, String> headers, final String data, final String encoding) throws HttpException {
        // post方式
        final PostMethod post = new PostMethod(url);
        // headers
        setHeaders(post, headers);
        // content
        if (data != null) {
            try {
                final InputStream bin = new ByteArrayInputStream(data.getBytes(this.encoding));
                post.setRequestBody(bin);
            } catch (final UnsupportedEncodingException e) {
            }
        }
        try {
            return (execute(post, encoding));
        } finally {
            post.releaseConnection();
        }
    }

    public String post(final String url, final String data, final String encoding) throws HttpException {
        // post方式
        return post(url, null, data, encoding);
    }

    public String get(final String url, final Map<String, String> headers) throws HttpException {
        // get方式
        final GetMethod get = new GetMethod(url);
        try {
            // headers
            setHeaders(get, headers);
            return (execute(get, encoding));
        } finally {
            get.releaseConnection();
        }
    }

    private final HttpMethod setHeaders(final HttpMethod method, final Map<String, String> headers) {
        if (headers != null) {
            final Set<Map.Entry<String, String>> headset = headers.entrySet();
            for (Iterator<Map.Entry<String, String>> it = headset.iterator(); it.hasNext();) {
                Map.Entry<String, String> header = it.next();
                method.setRequestHeader(header.getKey(), header.getValue());
            }
        }
        return method;
    }

    private String execute(final HttpMethod method, final String encoding) throws HttpException {
        InputStream in = null;
        BufferedReader reader = null;
        try {
            client.executeMethod(method);
            // get-encoding
            String encode = encoding;
            final Header ctypeh = method.getResponseHeader("Content-Type");
            if (ctypeh != null) {
                final String cv = ctypeh.getValue();
                final String ctype;
                if (cv == null) {
                    ctype = null;
                } else {
                    ctype = cv.toLowerCase(Locale.ENGLISH);
                }
                final int i;
                if (ctype != null && (i = ctype.indexOf(CS_PREFIX)) != -1) {
                    encode = ctype.substring(i + CS_PREFIX_LEN).trim();
                    // test encoding
                    try {
                        "a".getBytes(encode);
                    } catch (UnsupportedEncodingException e) {
                        encode = encoding;
                    }
                    //
                }
            }
            //
            if (encode == null) {
                return (method.getResponseBodyAsString());
            }
            in = method.getResponseBodyAsStream();
            reader = new BufferedReader(new InputStreamReader(in, encode), bufferSize);
            final StringBuffer sbuf = new StringBuffer(bufferSize >>> 1);
            for (String line = reader.readLine(); line != null; line = reader.readLine()) {
                sbuf.append(line).append("\r\n");
            }
            return (sbuf.toString());
        } catch (IOException e) {
            throw new HttpException(e.getMessage());
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                }
            }
        }
    }
}

            下面这个工具类是去除微信名中的Emoji表情

            public class EmojiFilter {

    /**
     * 检测是否有emoji字符
     * @param source
     * @return 一旦含有就抛出
     */
    public static boolean containsEmoji(String source) {
        if (StringUtils.isBlank(source)) {
            return false;
        }

        int len = source.length();

        for (int i = 0; i < len; i++) {
            char codePoint = source.charAt(i);

            if (isEmojiCharacter(codePoint)) {
                //do nothing，判断到了这里表明，确认有表情字符
                return true;
            }
        }

        return false;
    }

    private static boolean isEmojiCharacter(char codePoint) {
        return (codePoint == 0x0) ||
                (codePoint == 0x9) ||
                (codePoint == 0xA) ||
                (codePoint == 0xD) ||
                ((codePoint >= 0x20) && (codePoint <= 0xD7FF)) ||
                ((codePoint >= 0xE000) && (codePoint <= 0xFFFD)) ||
                ((codePoint >= 0x10000) && (codePoint <= 0x10FFFF));
    }

    /**
     * 过滤emoji 或者 其他非文字类型的字符
     * @param source
     * @return
     */
    public static String filterEmoji(String source) {

        if (!containsEmoji(source)) {
            return source;//如果不包含，直接返回
        }
        //到这里铁定包含
        StringBuilder buf = null;

        int len = source.length();

        for (int i = 0; i < len; i++) {
            char codePoint = source.charAt(i);

            if (isEmojiCharacter(codePoint)) {
                if (buf == null) {
                    buf = new StringBuilder(source.length());
                }

                buf.append(codePoint);
            } else {
            }
        }

        if (buf == null) {
            return source;//如果没有找到 emoji表情，则返回源字符串
        } else {
            if (buf.length() == len) {//这里的意义在于尽可能少的toString，因为会重新生成字符串
                buf = null;
                return source;
            } else {
                return buf.toString();
            }
        }

    }
}

              如果有什么问题咱们可以讨论一下(～￣▽￣)～
              转载需注明出处，不然你会尝到正义的小拳拳

              江湖之笑
              关注
              • 1
                点赞
              • 踩
              • 2
                收藏
                觉得还不错? 一键收藏
              • 0
                评论
              专栏目录
              微信二维码授权登录
              weixin_42353487的博客
              08-14 8973
              1登录微信开放平台（开放平台、开放平台、开放平台）进入管理中心 -> 网站应用-> 注：appid和appsecret也都在这个页面 2 授权二维码 授权请求地址（直接跳转url）： https://open.weixin.qq.com/connect/qrconnect?appid=APPID&redirect_uri=REDIRECT_U...
              网站实现微信扫码登录(利用微信开放平台实现)
              最新发布
              qq_66313178的博客
              05-11 993
              二 手机授权后带这个code码和state 请求到你的回调域接口 这个接口就可以拿接收到的code和你网站应用上的appid,appSecret 请求这个用户的唯一的openid 拿着这个openid就可以存数据库。点击允许后会带着code及你设置的state 调用回调域接口进行处理 如果是我的代码就会调用到这个接口【审核通过后，列表就会可以查看到这个网站应用，点击查看可以获取到appId 和appSecret了。第三步：用网站应用里的appId 调用微信二维码 下面是代码（控制器方法）
              微信第三方登录与静默授权
              热门推荐
              月月鸟先森的博客
              10-20 7万+
              微信的授权登录在日常应用中应用的非常广泛，最多就是第三方登录，最近在搞这方面的例子，做个笔记，方便查阅。 微信登录分为两类：需要用户确认的授权登录与静默授权，用户确认的授权登录因为要通过用户的个人确认，所以可以获取用户全面的信息，无论是否关注相关微信号都可以获取，静默授权是嵌套在普通网页中的授权方式，不需要用户确认，但只能获取微信用户的唯一标识openid，但有时候这种交互方式更加的友好，对于用
              第三方微信登录 | 静默授权与网页授权的实现
              weixin_34402408的博客
              04-17 1188
              一：介绍 第三方登录有QQ、微信、微博、支付宝等等，如果现在自己的项目中实现这些登录，即可以使用友盟的sdk，也可以一个一个接入，各有各的有点，这里不做赘述。 今天和大家分享的是，在项目中实现微信登录，虽然微信官网给出了接入文档，但是我在接入的过程中，遇到一些问题，在此做出总结以便大家参考。主要讲微信snsapi_base静默授权与snsapi_userinfo网页授权的实现。 二：准备工作 移动...
              微信网页扫码登录与微信公众号授权登录的区别
              12-06 1万+
              最近着手开发了微信网页扫码登录和公众号授权登录收获颇丰，两者的开发很类似。以下是我个人摸索过程中发现的两者的异同： 两者都可以通过微信客户端扫码授权的方式，让第三方页面获得微信用户的一些基本信息（昵称、性别、所在地、在微信唯一标示等……）。他们都是通过提供一个链接让用户授权的方式。但网页版需要在页面打开二维码之后授权，而公众号则需要用户先关注了我们的公众号，然后点开公众号里面的链接，确认授权即可...
              微信网页授权的2种方式
              神客
              05-27 2699
              《微信网页授权》专题 1 第一步：用户同意授权，获取code 2 第二步：通过code换取网页授权access_token 3 第三步：刷新access_token（如果需要） 4 第四步：拉取用户信息(需scope为 snsapi_userinfo) 5 附：检验授权凭证（access_token）是否有效 1，获取code https://open.weixin.qq.com/connect/oauth2/authorize?appid=APPID&redirect_uri=RED
              ASP网页调用微信扫码登录方法
              08-17
              微信扫码登录基于OAuth2.0授权协议，允许用户在不泄露密码的情况下授权第三方应用访问其在微信的部分信息。在这个过程中，用户会通过微信客户端扫描网页上的二维码，然后在微信APP内确认授权。 3. **获取授权URL**...
              微信沙箱扫码登录.docx
              04-01
              微信扫码登录实现，（需要源码请留邮箱）
              基于Winfrom的企业微信扫码登录案例
              02-02
              而在这个“基于Winfrom的企业微信扫码登录案例”中，我们将探讨如何利用C#编程语言集成企业微信的扫码登录功能，为用户提供安全、便捷的身份验证方式。 首先，企业微信扫码登录的核心在于调用其提供的API接口。企业...
              vue 微信扫码登录(自定义样式)
              10-15
              主要介绍了vue 微信扫码登录(自定义样式)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
              微信开发网页授权的两种方式（基于SpringBoot）
              12-21
              一、方式一：手动实现微信授权 1、若没有微信公众号，可以用测试号来进行测试号      （1）官方链接：http://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login 其中Token可以随便写，可能一开始配置的URL无法配置成功，别着急，按照我下面的步骤操作 （2）在“网页授权获取用户基本信息”那一栏，点击修改 在此处设置自己的域名，可以是通过花生壳或者natapp[链接：https://natapp.cn/ ]获取来的，均可！！ [不要包含http://或https://] 2、SpringBoot后台 例如我配置的上述URL
              帝国微信授权登录、扫码登录
              02-28
              phome_gn_wechat表: weixin字段设置为允许为空 否则微信参数配置完会报错
              C# aps.net MVC web微信三方扫码登录与授权登录
              05-02
              该项目有两个dome 注释清晰明了，其中一个用微信开发平台的Web端扫码登录演示，一个用微信公平平台授权登录
              微信小程序静默登录的实现代码
              10-15
              主要介绍了微信小程序静默登录的实现代码,代码简单易懂，非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
              delphi微信扫码登录.rar
              01-15
              微信扫码登录的核心原理是OAuth2.0授权框架，它允许第三方应用在用户授权的情况下，获取到微信用户的部分信息，以便完成身份验证。下面将详细介绍这个过程和可能涉及的关键技术点： 1. **OAuth2.0授权流程**： - ...
              微信静默授权登录（h5）
              qq_51637289的博客
              10-28 1349
              h5静默授权登录
              微信扫码登陆（1）---扫码登录流程讲解、获取授权登陆二维码
              a8892117的博客
              09-18 1万+
              扫码登录流程讲解、获取授权登陆二维码 具体流程可以看微信官网的扫码登录文档 地址：https://open.weixin.qq.com/cgi-bin/showdocument?action=dir_list&t=resource/res_list&verify=1&id=open1419316505&token=&lang=zh_CN 其实...
              通过小程序实现微信扫码授权登录，网站接入微信扫码登录功能（免费）
              TANKING，开源开发者！
              09-13 6999
              网站如果想要实现微信扫码登录其实有很多种方案，常见的方案就是微信开放平台和微信公众号服务号。前者是目前大部分网站并且是微信认可的一种方式，后者是开发者发现服务号具备扫码关注后即可获取用户基本信息的能力后而开发的一种方式。
              评论
              添加红包

              请填写红包祝福语或标题

              个

              红包个数最小为10个

              元

              红包金额最低5元

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

              抵扣说明：

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

              余额充值