微信jsapi 调用分享接口(完整版)

最新推荐文章于 2024-06-14 09:24:10 发布
最新推荐文章于 2024-06-14 09:24:10 发布
阅读量9.7k 收藏 10
点赞数
分类专栏： wechat 文章标签： 微信分享开发总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36349616/article/details/100663442
版权

1.测试环境

申请测试账号

地址: https://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo?action=showinfo&t=sandbox/index

填写内容:

    ①:接口配置信息

        url:配置http://+域名或者http://+外网ip也可以

        token:自定义(任意)

        js安全域名(要和url的中的域名)

  提交配置信息时微信会先进行验证所以你需要在能访问的url对应的服务上面进行验证代码如下:  能够打印出System.out.println("echostr:"+echostr);的值验证成功.

微信会通过你配置的url+代码中(/) 在你提交接口配置信息时,微信服务会请求到前面叙述的那个路径,来验证成功即能打印出echostr值(关键的一步,如果验证不通过,后续开发没办法进行)

/**
* 微信消息接收和token验证
*
* @param reqDate
* @param request
* @param response
* @throws IOException
value的值你可以自定义,但是要保证和url的一致性
*/
@RequestMapping(value = {"/"}, method = {RequestMethod.POST, RequestMethod.GET})
public void get(@RequestBody(required = false) String reqDate, HttpServletRequest request,
                HttpServletResponse response) throws Exception {
    boolean isGet = request.getMethod().toLowerCase().equals("get");
    PrintWriter print;
    if (isGet) {
        // 微信加密签名
        String signature = request.getParameter("signature");
        // 时间戳
        String timestamp = request.getParameter("timestamp");
        // 随机数
        String nonce = request.getParameter("nonce");
        // 随机字符串
        String echostr = request.getParameter("echostr");
        // 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
        if (signature != null && CheckoutUtil.checkSignature(signature, timestamp, nonce)) {
            try {
                print = response.getWriter();
                print.write(echostr);
                print.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("echostr:"+echostr);
    }
}
public class CheckoutUtil {
    private static String token = "weixin"; //与在后台配置的Token一样
    /**
     * 验证签名
     *
     * @param signature
     * @param timestamp
     * @param nonce
     * @return
     */
    public static boolean checkSignature(String signature, String timestamp, String nonce) {
        String[] arr = new String[] { token, timestamp, nonce };
        // 将token、timestamp、nonce三个参数进行字典序排序
        // Arrays.sort(arr);
        sort(arr);
        StringBuilder content = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            content.append(arr[i]);
        }
        MessageDigest md = null;
        String tmpStr = null;
        try {
            md = MessageDigest.getInstance("SHA-1");
            // 将三个参数字符串拼接成一个字符串进行sha1加密
            byte[] digest = md.digest(content.toString().getBytes());
            tmpStr = byteToStr(digest);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        content = null;
        // 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
        return tmpStr != null ? tmpStr.equals(signature.toUpperCase()) : false;
    }
    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param byteArray
     * @return
     */
    private static String byteToStr(byte[] byteArray) {
        String strDigest = "";
        for (int i = 0; i < byteArray.length; i++) {
            strDigest += byteToHexStr(byteArray[i]);
        }
        return strDigest;
    }


    /**
     * 将字节转换为十六进制字符串
     */
    private static String byteToHexStr(byte mByte) {
        char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        char[] tempArr = new char[2];
        tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
        tempArr[1] = Digit[mByte & 0X0F];
        String s = new String(tempArr);
        return s;
    }
    public static void sort(String a[]) {
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[j].compareTo(a[i]) < 0) {
                    String temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }
}

 

②:JS接口安全域名(注意:是域名不是url不要携带 http://,直接填写域名否侧报错:invalid url domain)

2.关注测试号二维码(不重要)

url/token/js域名配置都成功之后就可以开始开发了

 

3.前端页面代码如下:

$.ajax({
    type: "POST",
    url: 'http://www.innshine.com/wechat/token',
    // contentType: "application/json; charset=utf-8",
    dataType: "JSON",
    data:{"url":location.href.split('#')[0]},//url一定要是当前的页面的路径而且出去#后面的(微信规定),后台加需要url
    success: function (res) {
        console.log('res', res)
        wx.config({
            debug: true, // 开启调试模式,调用的所有api的返回值会在客户端alert出来，若要查看传入的参数，可以在pc端打开，参数信息会通过log打出，仅在pc端时才会打印。
            appId: 'wxae743829eed54eaa', // 必填，公众号的唯一标识
            timestamp: res.timestamp, // 必填，生成签名的时间戳
            nonceStr: res.noncestr, // 必填，生成签名的随机串
            signature: res.signature,// 必填，签名
            jsApiList: ['updateAppMessageShareData', 'updateTimelineShareData'] // 必填，需要使用的JS接口列表
        });

        wx.ready(function () {   //需在用户可能点击分享按钮前就先调用
            wx.updateAppMessageShareData({
                title: 'test', // 分享标题
                desc: 'test列表', // 分享描述
                link: 'http://www.innshine.com/wechat/index.html', // 分享链接，该链接域名或路径必须与当前页面对应的公众号JS安全域名一致
                imgUrl: 'http://www.innshine.com/wechat/images/down.jpg', // 分享图标
            }, function (res) {
                console.info("success")
            });
            

            wx.updateTimelineShareData({
                title: 'test', // 分享标题
                link: 'http://www.innshine.com/wechat/index.html', // 分享链接，该链接域名或路径必须与当前页面对应的公众号JS安全域名一致
                imgUrl: 'http://www.innshine.com/wechat/images/down.jpg', // 分享图标
            }, function (res) {
                console.info("success")
            });
           



        });
        wx.error(function (res) {
            //打印错误消息。及把 debug:false,设置为debug:ture就可以直接在网页上看到弹出的错误提示
            alert("错误error" + JSON.stringify(res));
        });
    }
})

4.后端代码:

controller

@Autowired
WxJsApiServer wxJsApiServer;
@Autowired
Properties properties;


@RequestMapping("token")
public  Map<String, String> getJsapiTicket(String url)throws DigestException {
     String token = wxJsApiServer.getAccessTokenByAppIdAndSecret(properties.getAPPID(),properties.getAPPSECRET());
     String ticket = wxJsApiServer.getJsApiTicketByToken(token);
     return  getSign(url,ticket);
}


//url:去掉不包含#之后的路径
public  Map<String, String> getSign(String url,String ticket ) throws DigestException {
//注意哥哥蚕食都是小写的不要有大写(微信加密参数规则要求)
   HashMap<String,String> map = new HashMap<String,String>();
   map.put("jsapi_ticket",ticket);
   map.put("noncestr",SHA1.generateNonceStr());
   map.put("timestamp",String.valueOf(SHA1.getCurrentTimestamp()));//注意:一定要重视这一点参加加密的时间戳是秒级的值 不要使用毫秒值
   map.put("url",url);
   //生成signature
   String signature=SHA1.getSha1Encode(map);
   map.put("signature",signature);
   logger.info("signature:{}",signature);
   return map;
}

properties:参数实体类

@Component
@Data
public class Properties {
/**
* 获取token接口
*/
@Value("${wx.token}")
private String GetPageAccessTokenUrl;
/**
* 获取ticket接口
*/
@Value("${wx.ticket}")
private String GetJsapiTicketUrl;
/**
* 公众号标识
*/
@Value("${wx.appid}")
private String APPID;
/**
* 公众号验证所需参数(必须)
*/
@Value("${wx.secret}")
private String APPSECRET;
}

server

@Autowired
Properties properties;
@Override
public String getAccessTokenByAppIdAndSecret(String APPID, String SECRET) {
   String wxUrl = properties.getGetPageAccessTokenUrl().replace("APPID", properties.getAPPID()).replace("SECRET", properties.getAPPSECRET());
    HttpClient client = null;
    String accessToken = null;
    try {
        client = new DefaultHttpClient();
        HttpGet httpget = new HttpGet(wxUrl);
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        String response = client.execute(httpget, responseHandler);
        JSONObject OpenidJSONO = JSONObject.parseObject(response);
        if (OpenidJSONO.get("access_token")==null){
            return "FALSE";
        }
        accessToken = String.valueOf(OpenidJSONO.get("access_token"));
        //缓存
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        //关闭连接
        client.getConnectionManager().shutdown();
    }
    return accessToken;
}
@Override
public String getJsApiTicketByToken(String accessToken) {
    String requestUrl = properties.getGetJsapiTicketUrl().replace("ACCESS_TOKEN", accessToken);
    HttpClient client = null;
    String ticket = null;
    try {
        client = new DefaultHttpClient();
        HttpGet httpget = new HttpGet(requestUrl);
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        String response = client.execute(httpget, responseHandler);
        JSONObject OpenidJSONO = JSONObject.parseObject(response);
        if (OpenidJSONO.get("ticket") == null) {
            return "FALSE";
        }
        ticket = String.valueOf(OpenidJSONO.get("ticket"));
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        client.getConnectionManager().shutdown();
    }
    return ticket;
}

sha1加密

public class    SHA1 {
    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
    private static final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final Random RANDOM = new SecureRandom();
    /**
     * Takes the raw bytes from the digest and formats them correct.
     *
     * @param bytes the raw bytes from the digest.
     * @return the formatted bytes.
     */
    private static String getFormattedText(byte[] bytes) {
        int len = bytes.length;
        StringBuilder buf = new StringBuilder(len * 2);
        // 把密文转换成十六进制的字符串形式
        for (int j = 0; j < len; j++) {
            buf.append(HEX_DIGITS[(bytes[j] >> 4) & 0x0f]);
            buf.append(HEX_DIGITS[bytes[j] & 0x0f]);
        }
        return buf.toString();
//            Formatter formatter = new Formatter();
//            for (byte b : bytes)
//            {
//                formatter.format("%02x", b);
//            }
//            String result = formatter.toString();
//            formatter.close();
//            return result;
    }
    public static String encode(String str) {
        if (str == null) {
            return null;
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
            messageDigest.update(str.getBytes("UTF-8"));
            byte[]  bytes= messageDigest.digest();
            int len = bytes.length;
            StringBuilder buf = new StringBuilder(len * 2);
            // 把密文转换成十六进制的字符串形式
            for (int j = 0; j < len; j++) {
                buf.append(HEX_DIGITS[(bytes[j] >> 4) & 0xf]);
                buf.append(HEX_DIGITS[bytes[j] & 0xf]);
            }
            return buf.toString();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public static String getSha1(String str){
        if(str == null || str.length()==0){
            return null;
        }
        char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        try {
            MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
            mdTemp.update(str.getBytes("UTF-8"));
            byte[] md = mdTemp.digest();
            int j = md.length;
            char buf[] = new char[j*2];
            int k = 0;
            for(int i=0;i<j;i++){
                byte byte0 = md[i];
                buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
                buf[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(buf);
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * 获取随机字符串 Nonce Str
     *
     * @return String 随机字符串
     */
    public static String generateNonceStr() {
        char[] nonceChars = new char[32];
        for (int index = 0; index < nonceChars.length; ++index) {
            nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
        }
        return new String(nonceChars);
    }
    /**
     * 获取当前时间戳，单位秒
     * @return
     */
    public static long getCurrentTimestamp() {
        return System.currentTimeMillis()/1000;
    }
    /**
     * 获取当前时间戳，单位毫秒
     * @return
     */
    public static long getCurrentTimestampMs() {
        return System.currentTimeMillis();
    }
    /**
     * SHA1 安全加密算法
     *
     * @return
     * @throws DigestException
     */
    public static String getSha1Encode(Map<String, String> map)  {
        String encode = encode(getOrderByLexicographic(map));
        return encode;
    }




    public static String getOrderByLexicographic(Map<String, String> map) {
        return splitParams(lexicographicOrder(getParamsName(map)), map);
    }
    /**
     * 拼接参数
     *
     * @param paramNames
     * @param maps
     * @return
     */
    public static String splitParams(List<String> paramNames, Map<String, String> maps) {
        StringBuilder params = new StringBuilder();
        for (String paramName : paramNames) {
            params.append(paramName);
            for (Map.Entry<String, String> entry : maps.entrySet()) {
                if (paramName.equals(entry.getKey())) {
                    params.append("=" + String.valueOf(entry.getValue()) + "&");
                }
            }
        }
        params.deleteCharAt(params.length() - 1);
        return params.toString();
    }
    /**
     * 参数按字典顺序排序
     *
     * @param paramNames 参数集合
     * @return 返回排序集合
     */
    public static List<String> lexicographicOrder(List<String> paramNames) {
        Collections.sort(paramNames);
        return paramNames;
    }
    /**
     * 获取参数名称 key
     *
     * @param maps
     * @return
     */
    public static List<String> getParamsName(Map<String, String> maps) {
        List<String> paramNames = new ArrayList<String>();
        for (Map.Entry<String, String> entry : maps.entrySet()) {
            paramNames.add(entry.getKey());
        }
        return paramNames;
    }

httputile:

public class HttpUtils {
    /**
     * get请求，参数拼接在地址上
     * @param url 请求地址加参数
     * @return 响应
     */
    public static String get(String url,String AccessToken)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        url = url.replaceAll(" ","%20");
        HttpGet get = new HttpGet(url);
        if(AccessToken != null && !AccessToken.equals("")){
            get.addHeader("Authorization",AccessToken);
        }
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(get);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * get请求，参数放在map里
     * @param url 请求地址
     * @param map 参数map
     * @return 响应
     */
    public static String getMap(String url,String AccessToken,Map<String,String> map)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        for(Map.Entry<String,String> entry : map.entrySet())
        {
            pairs.add(new BasicNameValuePair(entry.getKey(),entry.getValue()));
        }
        CloseableHttpResponse response = null;
        try {
            URIBuilder builder = new URIBuilder(url);
            builder.setParameters(pairs);
            HttpGet get = new HttpGet(builder.build());
            if(AccessToken != null && !AccessToken.equals("")){
                get.addHeader("Authorization",AccessToken);
            }
            response = httpClient.execute(get);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 发送post请求，参数用map接收
     * @param url 地址
     * @param map 参数
     * @return 返回值
     */
    public static  String postMap(String url,Map<String,String> map) {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);
        post.addHeader("Content-Type", "application/json");
        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        if (map != null){
            for(Map.Entry<String,String> entry : map.entrySet())
            {
                pairs.add(new BasicNameValuePair(entry.getKey(),entry.getValue()));
            }
        }
        CloseableHttpResponse response = null;
        try {
            post.setEntity(new UrlEncodedFormEntity(pairs,"UTF-8"));
            response = httpClient.execute(post);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 发送post请求，参数用map<String object>接收
     * @param url
     * @param map
     * @param encoding
     * @return
     */
    public static String mapPost(String url, Map<String,Object> map, String encoding){
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try{
             httpClient = HttpClients.createDefault();
            httpPost = new HttpPost(url);
            //设置参数
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            Iterator iterator = map.entrySet().iterator();
            while(iterator.hasNext()){
            Map.Entry<String,String> elem = (Map.Entry<String, String>) iterator.next();
            list.add(new BasicNameValuePair(elem.getKey(),String.valueOf(elem.getValue())));
            }
            if(list.size() > 0){
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list,encoding);
            httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            if(response != null){
            HttpEntity resEntity = response.getEntity();
            if(resEntity != null){
            result = EntityUtils.toString(resEntity,encoding);
            }
            }
            }catch(Exception ex){
            ex.printStackTrace();
            }
            System.out.println(result);
        return result;
    }
    /**
     * post请求，参数为json字符串
     * @param url 请求地址
     * @param jsonString json字符串
     * @return 响应
     */
    public static String postJson(String url,String jsonString,String AccessToken)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);
        post.addHeader("Content-Type", "application/json");
        if(AccessToken != null && !AccessToken.equals("")){
            post.addHeader("Authorization",AccessToken);
        }
        CloseableHttpResponse response = null;
        try {
            if(jsonString != null && !jsonString.equals("")){
                post.setEntity(new ByteArrayEntity(jsonString.getBytes("UTF-8")));
            }
            response = httpClient.execute(post);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    private static String entityToString(HttpEntity entity) throws IOException {
        String result = null;
        if(entity != null)
        {
            long lenth = entity.getContentLength();
            if(lenth != -1 && lenth < 2048)
            {
                result = EntityUtils.toString(entity,"UTF-8");
            }else {
                InputStreamReader reader1 = new InputStreamReader(entity.getContent(), "UTF-8");
                CharArrayBuffer buffer = new CharArrayBuffer(2048);
                char[] tmp = new char[1024];
                int l;
                while((l = reader1.read(tmp)) != -1) {
                    buffer.append(tmp, 0, l);
                }
                result = buffer.toString();
            }
        }
        return result;
    }


}

正式环境开发:

        登录公众号平台:

                配置两处:

                    1.导航"基础配置"中配置url/token,配置要求和测试配置一样.

                    2.再在"基础配置"的"ip白名单"添加项目所要部署到的服务器的ip.

                    3.导航"公众号设置"中再点击"功能设置"然后配置"js安全域配置,注意此时需要下载一个文件MP_verify_gt5yNwRcoQWm4SIk.txt,文件可在弹出窗口中的提示出获取,文件下载以后*(springboot项目为例)放在static目录下,然后通过上面配置的url+文件名,页面响应一串字符串即代表成功.

 

正是开发代码和测试代码一样.

 

微信 JS 接口签名校验工具: https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=jsapisign

 

nginx配置

  安装和配置过程可以自己百度:

注意点给大家说一下:nginx.conf文件

server {
       listen       8089;//只是服务器开放的端口并不是项目端口号,但是却要和项目的端口号保持一致.默认是80端口
       server_name  www.innshines.com;//你自己的域名
       location /wxshare {
           # root   html;
           # index  index.html index.htm;
            proxy_pass   http://127.0.0.1:8089;//项目部署所在的服务器的本地ip,端口记得要开放而且要在防火墙的白名单中放行端口
        }
    }

 

wwm_帅
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微信JS接口说明
思科网络
07-16 3415
概述 微信JS-SDK是微信公众平台面向网页开发者提供的基于微信内的网页开发工具包。 通过使用微信JS-SDK，网页开发者可借助微信高效地使用拍照、选图、语音、位置等手机系统的能力，同时可以直接使用微信分享、扫一扫、卡券、支付等微信特有的能力，为微信用户提供更优质的网页体验。 此文档面向网页开发者介绍微信JS-SDK如何使用及相关注意事项。 使用说明 在使用微信JS-
js常用API汇总
Tox-boy的博客
08-02 488
typeof();                检测数据类型 String();                转换成字符串 parseInt();                解析出一个string或number的整数部分 parseFloat();        解析出一个string的浮点数部分 Number();                把一个string解析为numbe
h5端通过微信weixin-jsapi的 updateAppMessageShareData 方法来自定义分享踩过的坑
最新发布
weixin_48198130的博客
06-14 473
插句嘴：如果是其他浏览器想分享可以使用可以参考。
微信公众号支付(JSAPI)
江拥羡橙的博客
09-06 1万+
JSAPI支付是指商户通过调用微信支付提供的JSAPI接口，在支付场景中调起微信支付模块完成收款。
微信jsapi获取用户地理位置接口开发(第八课)
热门推荐
飞龙在天
11-11 1万+
本章节给大家介绍通过微信jsapi获取用户的地理位置，微信官方文档关于地理位置给了两种接口，一种是通过微信内置地图查看用户的地理位置，第二种是直接获取当前用户的地理位置坐标信息。 使用微信内置地图查看位置接口 wx.openLocation({     latitude: 0, // 纬度，浮点数，范围为90 ~ -90     lo
企业微信客户端API分享微信朋友圈使用过程及总结
weixin_44052136的博客
09-19 3643
本篇文章我们将介绍使用企业微信客户端API分享微信朋友圈中所遇到各式各样的API无效以及各机型的兼容问题。
微信jsapi V3支付、退款、小程序登录
07-15
微信JSAPI V3支付、退款以及小程序登录是微信支付接口中的关键组成部分，这些功能在现代电商和移动应用中被广泛使用。以下是对这些知识点的详细解释： 1. **微信JSAPI V3支付**： 微信JSAPI（JavaScript API）支付...
微信分享ASP版
09-24
总之，"微信分享ASP版"是一个实现微信分享功能的ASP解决方案，它包括了获取微信API凭证、配置分享参数、以及处理分享事件的关键代码。通过理解和运用这些知识点，开发者能够使自己的ASP应用具备在微信生态中传播的...
微信支付接口demo
02-01
需要获取用户的OpenID，然后调用统一下单接口，得到预支付交易会话标识后，通过微信JS-SDK生成支付二维码或直接调起微信支付界面。 5. **H5支付**：对于H5网页应用，可以使用H5支付接口。用户点击支付按钮后，跳转...
h5微信支付完整版_h5微信支付完整版_微信支付分_fathercxc_h5支付_微信支付_
10-03
3. **前端发起支付请求**：商家的H5页面接收到预支付标识后，通过JavaScript调用微信支付JSAPI，生成支付二维码或发起支付请求。 4. **用户确认支付**：用户在手机上确认支付信息，输入密码或者使用指纹完成支付。 ...
微信支付完全源码PHP，包Jsapi支付，二维码支付，刷卡支付，订单查询
03-30
通过调用微信支付的JSAPI接口，开发者可以实现用户在浏览器中无跳转完成支付。这一过程涉及的关键步骤包括获取预支付交易会话标识（prepay_id）、配置微信支付参数、调用微信支付JSAPI方法等。 2. **二维码支付**：...
微信公众号支付（JSAPI支付）
qq_40936013的博客
12-07 2901
微信浏览器会内置 WeixinJSBridge 对象，但是其可能需要加载时间，可以通过文档代码 if (typeof WeixinJSBridge == "undefined"){ if( document.addEventListener ){ document.addEventListener('WeixinJSBridgeReady', onBridgeReady, false); }else if (document.attachEve
微信公众平台Js API实现微信分享
Gabriel的专栏
06-11 1万+
转自：http://www.itnose.net/detail/6184348.html 今天上班第一天，Boss让实现微信分享后，要知道用户是否分享成功，分享成功后就给用户一个surprise(游戏礼包)。   通过查看API，做简单记录： 1.编写一个简单的jsp页面，加入如下JS代码： // 开发阶段，开启WeixinApi的调试模式 WeixinApi.e
个人微信API开发，API接口核心
seeseeyoua的博客
07-21 1144
其实对于产品经理而言，我们应该更关注这个公司可以提供什么样的API接口服务，比如我知道高德可以提供地图API，规划路线的API，这样的话在我们设计功能和工作中就可以想到调用他们的服务或者参考。所以产品小白们看不懂也不用过于担心，未来工作中你也会更深入了解清楚，因为看懂并不复杂，以下是API接口的核心点，所有的说明文档离不开这5个核心点。对于小白而言，初看API文档可能是一头雾水的——从哪里看，怎么看，看什么是摆在面前的问题。以下说明均以微信开放平台为例说明，文末有各开放平台的地址，大家有空可以去学习。
微信环境下H5跳转小程序
l-ddui的博客
02-10 519
官方文档：https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/Wechat_Open_Tag.html#21 使用步骤： 绑定域名（根据具体情况，用不用都行） 登录微信公众平台进入“公众号设置”的“功能设置”里填写“JS接口安全域名”。 引入JS文件 在需要调用JS接口的页面引入如下JS文件：http://res.wx.qq.com/open/js/jweixin-1.6.0.js （支持https） 备注：支持使用 AMD/C
微信开发之微信公众平台基本配置--服务器token验证（Java实现）
07feng的博客
06-13 8842
1. 登录微信公众平台 对于自学者，可以申请公众号测试账号，地址：http://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo?action=showinfo&t=sandbox/index 注册账号 对于企业开发者，可以直接用公司微信公众号登录微信公众平台，地址：https://mp.weixin.qq.com/ 登录后，在导航栏最底部找到开发—基...
微信公众号接口之接口信息配置(一)
郑向阳
06-01 7460
微信公众号地址：https://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo?action=showinfo&amp;t=sandbox/index配置url和token&lt;?php/**  * wechat php test  *///define your tokendefine("TOKEN", "你的token");$wechatObj = ne...
微信公众号分享功能开发体验
gycommunicate的专栏
11-10 1626
可到此网点体验分享
微信jsapi支付 openid
09-15
微信JSAPI支付是指在网页或移动应用中使用微信支付功能，通过获取用户的OpenID来进行支付。 首先，用户在网页或移动应用中选择使用微信支付，在支付过程中会调用微信JSAPI进行支付请求。 接下来，前端开发者需要通过微信开放平台提供的API获取用户的OpenID。在用户确认支付后，微信会将OpenID作为参数传递给开发者的服务器端。 开发者的服务器端通过调用微信开放平台提供的接口，使用预先设置的AppID和AppSecret来获取接口调用凭证access_token。 然后，开发者的服务器端可以通过OpenID和access_token进行相关操作，比如查询用户的基本信息、验证用户身份等。 最后，开发者的服务器端将支付相关信息和OpenID传递给微信支付接口，完成支付过程。 需要注意的是，为了保护用户的隐私，获取用户OpenID的过程需要进行身份验证。开发者需要在微信开放平台注册并获得AppID和AppSecret，在后台设置好接口的安全验证，确保支付过程的安全性。 总之，使用微信JSAPI支付需要获取用户的OpenID，通过微信开放平台提供的接口和密钥进行验证和支付操作，从而实现网页或移动应用中的微信支付功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值