微信扫描带参二维码推送事件（二）

最新推荐文章于 2023-04-14 16:16:14 发布
最新推荐文章于 2023-04-14 16:16:14 发布
阅读量2.6k 收藏 3
点赞数 1
分类专栏： 微信公众号开发 文章标签： 微信公众号 微信开发 扫码推送 微信扫码事件 java微信开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42720002/article/details/90520145
版权

上个帖子已经配置好了微信服务器，下面就是要调微信接口生成带参二维码
具体接口信息请参考微信官方文档：微信官方文档
1、生成带参数的二维码
带参永久二维码（1）、调微信接口生成生成二维码前先要获取 access_token，下面是获取access_token的方法。

public class Util {

    // 微信获取accessToken接口
    private static final String ACCESSTOKENURL = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={appId}&secret={appSecret}";
    //appid
    private static final String appid = " "; //这里是公众号后台的 appID
    //appSecret
    private static final String appSecret = " "; //这里是公众号后台的 appsecret

    /**
     * 获取access_Token
     *
     * @return
     */
    public  String getAccessToken() {
        String url = ACCESSTOKENURL.replace("{appId}", appid).replace("{appSecret}", appSecret);
        String accessTokenJsonStr = HttpRequest.get(url, null, false);
        Map<String, String> accessTokenMap = GsonUtil.fromJson(accessTokenJsonStr, Map.class);
        String accessToken = null;
        if (null != accessTokenMap && !accessTokenMap.isEmpty()) {
            accessToken = accessTokenMap.get("access_token");
            if (!StringUtils.isEmpty(accessToken)) {
                LogUtil.info("时间：" + DateUtil.getDateStr(new Date()) + ";成功获取accessToken；值为：" + accessToken);
            }
        }
        if (StringUtils.isEmpty(accessToken)) {
            String errCode = null;
            String errMsg = null;
            try {
                errCode = accessTokenMap.get("errcode");
                errMsg = accessTokenMap.get("errmsg");
            } catch (Exception e) {
            }
            LogUtil.info("时间：" + DateUtil.getDateStr(new Date()) + ";获取accessToken失败；errCode为：" + errCode + "；errMsg" + errMsg);
        }
        return accessToken;
    }
}

下面是封装的请求方法，网上很多仅供参考，代码可能会报错，需要导一些架包，这里就不写了，后面把pom文件发出来，根据需要进行导入 ，下面是代码：

package com.wechat.util;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
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.methods.HttpRequestBase;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.ssl.AllowAllHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustStrategy;
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.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.Map;

/**
 * Created by rongyaowen
 * on 2018/10/22.
 */
public class HttpRequest {
    private static final String PROXY_HOST_NAME = "";
    private static final int PROXY_PORT = 0;
    private static final String PROXY_SCHEME = "http";
    // 需要代理请改为true
    private static final boolean OPEN_PROXY = false;

    /**
     * get请求
     *
     * @param url
     * @param ignoreHttps 是否忽略https证书 true 忽略
     * @return
     */
    public static String get(String url, Map<String, String> header, boolean ignoreHttps) {
        StringBuffer logSb = new StringBuffer();
        logSb.append("[GET]-").append("url:[" + url + "]-").append("header:[");
        // 创建httpGet请求，设置httpGet请求的头部信息
        HttpGet httpGet = new HttpGet(url);
        // 设置头信息
        if (null != header && !header.isEmpty()) {
            for (Map.Entry<String, String> entry : header.entrySet()) {
                httpGet.addHeader(entry.getKey(), entry.getValue());
                logSb.append(entry.getKey()).append(":").append(entry.getValue()).append(",");
            }
        }
        logSb.append("]-");
        logSb.append(ignoreHttps == true ? "[忽略https证书]-" : "[不忽略https证书]-");
        logSb.append(OPEN_PROXY == true ? ("[开启代理" + PROXY_SCHEME + "://" + PROXY_HOST_NAME + ":" + PROXY_PORT + "]-") : "[未开启代理]");
        LogUtil.info(logSb);
        String resStr = response(httpGet, ignoreHttps);
        LogUtil.info("响应报文：[" + resStr + "]");
        return resStr;
    }

    /**
     * post请求
     *
     * @param url
     * @param param       请求体参数
     * @param header      请求头
     * @param cotentType  请求数据类型
     * @param ignoreHttps 是否忽略https证书 true 忽略
     * @return
     */
    public static String post(String url, String param, Map<String, String> header, String cotentType, boolean ignoreHttps) {
        StringBuffer logSb = new StringBuffer();
        logSb.append("[GET]-").append("url:[" + url + "]-").append("param:[" + param + "]-").append("header:[");

        HttpPost httpPost = new HttpPost(url);
        // 设置请求数据
        StringEntity stringEntity = new StringEntity(param, Charset.forName("UTF-8"));
        stringEntity.setContentEncoding("UTF-8");
        // 发送Json格式的数据请求
        stringEntity.setContentType(cotentType);
        httpPost.setEntity(stringEntity);
        // 设置头信息
        if (null != header && !header.isEmpty()) {
            for (Map.Entry<String, String> entry : header.entrySet()) {
                httpPost.addHeader(entry.getKey(), entry.getValue());
                logSb.append(entry.getKey() + ":" + entry.getValue());
            }
        }
        logSb.append("]-");
        logSb.append("cotentType" + "[" + cotentType + "]-");
        logSb.append(ignoreHttps == true ? "[忽略https证书]-" : "[不忽略https证书]-");
        logSb.append(OPEN_PROXY == true ? ("[开启代理" + PROXY_SCHEME + "://" + PROXY_HOST_NAME + ":" + PROXY_PORT + "]-") : "[未开启代理]");
        LogUtil.info(logSb);
        String resStr = response(httpPost, ignoreHttps);
        LogUtil.info("响应报文：[" + resStr + "]");
        return resStr;
    }

    /**
     * post请求获取流对象
     *
     * @param url
     * @param param
     * @param header
     * @param cotentType
     * @param ignoreHttps
     * @return
     */
    public static InputStream postAsStream(String url, String param, Map<String, String> header, String cotentType, boolean ignoreHttps) {
        StringBuffer logSb = new StringBuffer();
        logSb.append("[GET]-").append("url:[" + url + "]-").append("param:[" + param + "]-").append("header:[");

        HttpPost httpPost = new HttpPost(url);
        // 设置请求数据
        StringEntity stringEntity = new StringEntity(param, Charset.forName("UTF-8"));
        stringEntity.setContentEncoding("UTF-8");
        // 发送Json格式的数据请求
        stringEntity.setContentType(cotentType);
        httpPost.setEntity(stringEntity);
        // 设置头信息
        if (null != header && !header.isEmpty()) {
            for (Map.Entry<String, String> entry : header.entrySet()) {
                httpPost.addHeader(entry.getKey(), entry.getValue());
                logSb.append(entry.getKey() + ":" + entry.getValue());
            }
        }
        logSb.append("]-");
        logSb.append("cotentType" + "[" + cotentType + "]-");
        logSb.append(ignoreHttps == true ? "[忽略https证书]-" : "[不忽略https证书]-");
        logSb.append(OPEN_PROXY == true ? ("[开启代理" + PROXY_SCHEME + "://" + PROXY_HOST_NAME + ":" + PROXY_PORT + "]-") : "[未开启代理]");
        LogUtil.info(logSb);
        return responseAsStream(httpPost, ignoreHttps);
    }

    /**
     * 获取请求数据
     *
     * @param httpRequestBase
     * @param ignoreHttps
     * @return
     */
    private static InputStream responseAsStream(HttpRequestBase httpRequestBase, boolean ignoreHttps) {
        CloseableHttpClient closeableHttpClient;
        if (ignoreHttps) {
            closeableHttpClient = getIgnoreHttpsClient();
        } else {
            closeableHttpClient = getClient();
        }
        CloseableHttpResponse closeableHttpResponse = null;
        String res = null;
        InputStream inputStream = null;
        try {
            closeableHttpResponse = closeableHttpClient.execute(httpRequestBase);
            if (closeableHttpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity entity = closeableHttpResponse.getEntity();
                inputStream = entity.getContent();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != closeableHttpResponse) {
                    closeableHttpResponse.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return inputStream;
    }

    /**
     * 获取请求数据
     *
     * @param httpRequestBase
     * @param ignoreHttps
     * @return
     */
    private static String response(HttpRequestBase httpRequestBase, boolean ignoreHttps) {
        CloseableHttpClient closeableHttpClient;
        if (ignoreHttps) {
            closeableHttpClient = getIgnoreHttpsClient();
        } else {
            closeableHttpClient = getClient();
        }
        CloseableHttpResponse closeableHttpResponse = null;
        String res = null;
        try {
            closeableHttpResponse = closeableHttpClient.execute(httpRequestBase);
            if (closeableHttpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity entity = closeableHttpResponse.getEntity();
                res = EntityUtils.toString(entity, "utf-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != closeableHttpResponse) {
                    closeableHttpResponse.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return res;
    }

    /**
     * @return
     */
    private static RequestConfig getRequestConfig() {
        // 依次是代理地址，代理端口号，协议类型
        HttpHost proxy = new HttpHost(PROXY_HOST_NAME, PROXY_PORT, PROXY_SCHEME);
        if (OPEN_PROXY) {
            return RequestConfig.custom().setProxy(proxy).setConnectionRequestTimeout(20000).setConnectTimeout(20000).setSocketTimeout(20000).build();
        } else {
            return RequestConfig.custom().setConnectionRequestTimeout(20000).setConnectTimeout(20000).setSocketTimeout(20000).build();
        }
    }

    /**
     * 获取忽略https的client
     *
     * @return
     * @throws Exception
     */
    private static CloseableHttpClient getIgnoreHttpsClient() {
        SSLContext sslContext = null;
        try {
            sslContext = SSLContexts.custom().useTLS().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain, String authType) {
                    //信任所有
                    return true;
                }
            }).build();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }
        SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, new AllowAllHostnameVerifier());
        Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory>create().register("https", sslConnectionSocketFactory).build();
        //设置连接池，配置过期时间为20s。
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(r);
        cm.setMaxTotal(500);
        cm.setDefaultMaxPerRoute(350);
        SocketConfig socketConfig = SocketConfig.custom().setSoKeepAlive(true).setTcpNoDelay(true).setSoTimeout(20000).build();
        cm.setDefaultSocketConfig(socketConfig);
        RequestConfig requestConfig = getRequestConfig();
        //创建httpClient
        CloseableHttpClient closeableHttpClient = HttpClientBuilder.create().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).build();
        return closeableHttpClient;
    }


    /**
     * 获取httpclient
     *
     * @return
     */
    private static CloseableHttpClient getClient() {
        //设置连接池，配置过期时间为20s。
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(500);
        cm.setDefaultMaxPerRoute(350);
        SocketConfig socketConfig = SocketConfig.custom().setSoKeepAlive(true).setTcpNoDelay(true).setSoTimeout(20000).build();
        cm.setDefaultSocketConfig(socketConfig);
        RequestConfig requestConfig = getRequestConfig();
        //创建httpClient
        CloseableHttpClient closeableHttpClient = HttpClientBuilder.create().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).build();
        return closeableHttpClient;
    }
}

2、access_token 已经获取到了，下面就可以调接口获取二维码了
生成的二维码可以根据自己的需求进行生成，这里生成是永久的二维码的，两种入参格式。可以参考下微信的文档：公众号官方文档

创建字符串形式的二维码参数：
{"action_name": "QR_LIMIT_STR_SCENE", "action_info": {"scene": {"scene_str": "test"}}}
创建整型参数值形式的二维码参数：
{"action_name": "QR_LIMIT_SCENE", "action_info": {"scene": {"scene_id": 123}}}

二维码类型，QR_SCENE为临时的整型参数值，QR_STR_SCENE为临时的字符串参数值，QR_LIMIT_SCENE为永久的整型参数值，QR_LIMIT_STR_SCENE为永久的字符串参数值

接下来返回的是可以直接显示二维码的url：

// 获取ticket
    private static final String GET_QRCODE_URL = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token={TOKEN}";
    // 换取二维码
    private static final String QR_CODE_URL = "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket={TICKET}";
    
public String getYJQrCode() {
        //获取access_token
        String access_token=util.getAccessToken();
        JSONObject req=new JSONObject();
        JSONObject data=new JSONObject();
        JSONObject datare=new JSONObject();
        req.put("action_name","QR_LIMIT_STR_SCENE");
        datare.put("scene_str","000165");
        data.put("scene",datare);
        req.put("action_info",data);
        System.out.println("获取二维码入参"+req);
        String url = GET_QRCODE_URL.replace("{TOKEN}", access_token);
        JSONObject res= HttpClientUtil.doPost(req,url);
        System.out.println("获取二维码出参"+res);
        String ticket=res.optString("ticket");
        String returnUrl = QR_CODE_URL.replace("{TICKET}", ticket);
        return returnUrl;
    }

把pom文件导出来可以根据需要添加架包：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wry</groupId>
    <artifactId>wechat</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.1.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3</version>
        </dependency>

        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient-cache</artifactId>
            <version>4.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.3</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.10</version>
        </dependency>

        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.1.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

下个帖子会讲扫码后的事件推送，也是第一次接触，不懂的大家可以多多交流。

叁拾柒°伍
关注
专栏目录
Java微信公众号开发之创建带参数二维码
Thinkingcao的专栏
04-03 6219
生成带参数二维码接口文档：生成带参数二维码 一、介绍 1.1、目前有2种类型的二维码： 1. 临时二维码：临时二维码，是有过期时间的，最长可以设置为在二维码生成后的30天（即2592000秒）后过期，但能够生成较多数量，主要用于帐号绑定等不要求二维码永久保存的业务场景2. 永久二维码：永久二维码，是无过期时间的，但数量较少（目前为最多10万个）,主要用于适用于帐号绑定、用户来源统计等场景 ...
公众号开发（四）----接收事件推送之扫描带参数二维码事件
w_t_y_y的博客
01-27 6401
接着前面的博客进度。如现在再把扫描带参数二维码进入公众号的用户保存到数据库 一、临时二维码： 获取二维码需要先获取ticket，再用ticket来换图片。这里请求参数比较短，就不封装对象了，直接使用字符串拼接成json串。 1、方法一、使用scene_id获取ticket，建议使用这种方法： （1）、先生成二维码加一张背景图的图片： WechatUtil： //生成临时二维码tick...
微信扫描带参二维码推送事件（三）
weixin_42720002的博客
05-24 2677
前面已经搞好了微信服务器配置，和生成了带参二维码，现在就是微信扫码事件的实现，未关注的先关注在推送，关注过公众号的直接推送。 之前也是在配置好的微信服务器，下面的扫码事件也要写那个方法里，这样才可以和微信服务器 “交流” 推送消息。 下面是代码 @Controller @RequestMapping(value = "/vatToken") public class VatifyToken { ...
微信公众号开发（十）——扫描带参数二维码事件
bdmh的专栏
12-17 7310
我们通过微信扫码二维码已经是十分频繁的操作了，为了满足用户渠道推广分析和用户帐号绑定等场景的需要，微信公众平台提供了创建带参数二维码的接口，通过产生的ticket，去获取二维码图片。当用户扫描这个二维码时，公众平台就会向你设置的接口推送扫描消息。 二维码分为临时二维码和永久二维码，介绍可以参考官方文档。https://developers.weixin.qq.com/doc/offiacco...
微信公众号之扫描带参数的二维码事件 文末附获取用户信息以及校验URL真实性代码
就写一行代码
01-22 7137
本文旨在记录如何扫码带参数的二维码事件 本文为作者原创 转载请注明出处 尊重一下笔者的劳动成果 十分感谢 什么是带参数的二维码事件？ 当我们需要扫描二维码进入公众号并且期望可以做一些自定义的业务处理，比如说某人通过谁的邀请关注了公众号，需要对这个人和关注人做业务处理的时候就可以使用带参数的二维码事件 带参数的二维码扫描后在用户未关注和关注后都会给我们的开发服务器推送消息，很方便我们做相关场景...
微信扫描带参数二维码事件
weixin_30655219的博客
04-03 824
用户扫描带场景值二维码时，可能推送以下两种事件：如果用户还未关注公众号，则用户可以关注公众号，关注后微信会将带场景值关注事件推送给开发者。如果用户已经关注公众号，则微信会将带场景值扫描事件推送给开发者。 1. 用户未关注时，进行关注后的事件推送推送XML数据包示例：<xml><ToUserName><![CDATA[toUser］></ToUserNam...
nodejs实现带参微信公众号二维码进行事件推送
08-25
结合了express+request+config+wechat等模块，实现了获取微信二维码url地址和ticket，事件推送服务
微信接口生成带参数的二维码
12-17
使用该接口可以获得多个带不同场景值的二维码，用户扫描后，公众号可以接收到事件推送。 用户扫描带场景值二维码时，可能推送以下两种事件： （1）如果用户还未关注公众号，则用户可以关注公众号，关注后微信会将带...
Java微信开发——生成带参数的二维码以及扫描带参数二维码事件
热门推荐
Sunday2017的博客
04-25 2万+
目前有2种类型的二维码：1、临时二维码，是有过期时间的，最长可以设置为在二维码生成后的30天（即2592000秒）后过期，但能够生成较多数量。临时二维码主要用于帐号绑定等不要求二维码永久保存的业务场景2、永久二维码，是无过期时间的，但数量较少（目前为最多10万个）。永久二维码主要用于适用于帐号绑定、用户来源统计等场景。用户扫描带场景值二维码时，可能推送以下两种事件：如果用户还未关注公众号，则用户可...
uniCloud开发公众号：六、解析不同情况下用户扫码后微信推送的事件并完成登录
花儿为何这样红
09-30 1836
终于来到最后也是最重要的一节，这节将把前边全部的内容串起来，最终完成一开始说的扫公众号二维码、关注公众号、完成网站登录。
公众号扫描带参数二维码实现分组
08-24
微信公众号扫描带参数二维码实现自动分组，实现不同渠道进入用户数量统计，为地推用户进行绩效统计。
微信公众号事件推送（点击推送图文）
atmknight的博客
08-03 1万+
最近做微信公众号的功能，按钮菜单中有 type 为 click 的按钮，其功能是 若你配置好了服务器配置，设置后回调的url, 点击后微信会将该事件推送到配置好的地址，后台接受数据然后进行相应的处理。网上看了很多例子，学习了很多，我发现最好的还是这位博主写的文章，分享给大家：https://blog.csdn.net/tuposky/article/details/40589319 然后开始主题...
获取带事件值的二维码
enutter的专栏
05-16 1255
Step 1: http://weixin.example.com/Home/ShowAccessToken?appid=xxxx&appsecret=yyyy POST {     "AccessToken": "ijWnvbiAdHM1Mx83GASA_PKi9AOj2fdHDx9L_RqItQzq0RopwVQT_e0oNO3561Ur4RXDKiVM19X4
【微信公众号入门到精通 二】生成带参数二维码以及扫码事件响应
最新发布
程序猿学社的博客
04-14 1475
模拟正式业务场景，实现机构学生上课，家长绑定学生的二维码，通过扫码实现快速绑定
微信公众号开发，扫描二维码事件推送丢失参数问题
weixin_39105981的博客
02-11 1244
需求场景： 每个用户都有自己的推广二维码，分享自己推广二维码，别人扫码后跳转关注公众号，关注后绑定推荐关系。 用到技术点： 1、生成带参数二维码 文档：生成带参数二维码 2、接收事件推送，这里主要是关注和扫带参数二维码两个事件。腾讯会往我们配置的服务器链接推送我们当初绑定的参数，我们获取这个参数就可以处理后续用户推广关系绑定的问题了 文档：接收事件推送 因为公众号后台开通服务器配置后，之前的自定义菜单会失效，所以，还需要根据实际情况做自定义菜单或个性化菜单开发 文档：创建自定义菜单 创建个性化菜单 本人做公
微信二维码带参数的二维码(转)
weixin_34378045的博客
12-13 230
官方文档地址：https://mp.weixin.qq.com/wiki/18/28fc21e7ed87bec960651f0ce873ef8a.html 原文地址：http://jingyan.baidu.com/article/fdbd4277cfd0c6b89f3f485f.html 注意事项 我知道你们是没有心情看注意事项的，但是很重要，所以我先摆上来。   用户扫描带参数的二维码，...
微信扫带参数二维码，微信回调
wy_2_7的博客
09-16 2910
先申请公众号的测试账号:微信公众平台 在关注者与公众号产生消息交互后，公众号可获得关注者的OpenID（加密后的微信号，每个用户对每个公众号的OpenID是唯一的。对于不同公众号，同一用户的openid不同）。公众号可通过本接口来根据OpenID获取用户基本信息，包括昵称、头像、性别、所在城市、语言和关注时间。 请注意，如果开发者有在多个公众号，或在公众号、移动应用之间统一用户帐号的需求，需要前往微信开放平台（open.weixin.qq.com）绑定公众号后，才可利用UnionID机制来满足上述需求。
微信公众平台开发(83) 生成带参数二维码
weixin_33744141的博客
03-07 657
本文介绍在微信公众平台上如何使用高级接口开发生成带参数二维码的功能。   一、场景二维码 为了满足用户渠道推广分析的需要，公众平台提供了生成带参数二维码的接口。使用该接口可以获得多个带不同场景值的二维码，用户扫描后，公众号可以接收到事件推送。 目前有2种类型的二维码，分别是临时二维码和永久二维码，前者有过期时间，最大为1800秒，但能够生成较多数量，后者无过期时间，数量较少（目前参数只支持...
微信开发–带参数的二维码
php_lzr的博客
06-12 1541
1 接入 首先进入微信公众号 -> 基本配置 下面是基本配置的页面，在URL中填写服务器地址，这个地址就是接受微信推送事件的一个接口，我是使用thinkPHP框架开发的程序，在其中一个Module（Decoration）的Action目录下新建一个类，比如叫： WechatAction.class.php ，在该Action中新建一个public方法，比如叫： URLRedirect() ，那
微信三方开发：事件消息推送详解（关注-取消、扫码-位置上报等）
在微信三方代开发平台上，事件消息推送是开发者与用户互动的重要环节，它允许公众号通过特定的事件触发特定的响应动作。本文将深入探讨微信第三方开发模式下的几种关键事件消息接收机制。 1. **关注/取消关注事件**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值