精华内容
参与话题
问答
  • 说明:我的是springboot项目 1. pom.xml添加依赖 ...-- https://mvnrepository.com/artifact/org.dom4j/dom4j 微信基本设置token认证--> <dependency> <groupId>dom4j</groupId>...

    说明:我的是springboot项目

    1. pom.xml添加依赖

            <!-- https://mvnrepository.com/artifact/org.dom4j/dom4j 微信基本设置token认证-->
            <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.9</version>
            </dependency>

    2.创建Controller

    package com.ziteng.controller;
    
    import com.ziteng.util.SignUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /**
      * @Author 徐本锡
      * @Description //TODO
      * @Date 2019/10/16  
      * @Param 
      * @return 
      **/
    @RestController
    @RequestMapping("/index")
    public class WechatIndexController {
        private static final Logger LOGGER = LoggerFactory.getLogger(WechatIndexController.class);
    
        @RequestMapping(method = RequestMethod.GET)
        public void get(HttpServletRequest request, HttpServletResponse response) {
            // 微信加密签名,signature结合了开发者填写的token参数和请求中的timestamp参数、nonce参数。
            String signature = request.getParameter("signature");
            // 时间戳
            String timestamp = request.getParameter("timestamp");
            // 随机数
            String nonce = request.getParameter("nonce");
            // 随机字符串
            String echostr = request.getParameter("echostr");
    
            PrintWriter out = null;
            try {
                out = response.getWriter();
                // 通过检验signature对请求进行校验,若校验成功则原样返回echostr,否则接入失败
                if (SignUtil.checkSignature(signature, timestamp, nonce)) {
                    out.print(echostr);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                out.close();
                out = null;
            }
        }
    
    }

     3.签名工具类

    package com.ziteng.util;
    
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Arrays;
    
    /**
     * @ClassName SignUtil
     * @Author xbx
     * @Date 2019/11/8 13:50
     * @Version 1.0
     **/
    
    public class SignUtil {
        //token可以自己进行定义,必须为英文或者是数字,长度为3-32字符,这个token要跟服务器配置中的token一致
        private static String token = "aaa123";
    
        /**
         * 校验签名
         * @param signature 签名
         * @param timestamp 时间戳
         * @param nonce 随机数
         * @return 布尔值
         */
        public static boolean checkSignature(String signature,String timestamp,String nonce){
            String checktext = null;
            if (null != signature) {
                //对ToKen,timestamp,nonce 按字典排序
                String[] paramArr = new String[]{token,timestamp,nonce};
                Arrays.sort(paramArr);
                //将排序后的结果拼成一个字符串
                String content = paramArr[0].concat(paramArr[1]).concat(paramArr[2]);
    
                try {
                    MessageDigest md = MessageDigest.getInstance("SHA-1");
                    //对接后的字符串进行sha1加密
                    byte[] digest = md.digest(content.toString().getBytes());
                    checktext = byteToStr(digest);
                } catch (NoSuchAlgorithmException e){
                    e.printStackTrace();
                }
            }
            //将加密后的字符串与signature进行对比
            return checktext !=null ? checktext.equals(signature.toUpperCase()) : false;
        }
    
        /**
         * 将字节数组转化我16进制字符串
         * @param byteArrays 字符数组
         * @return 字符串
         */
        private static String byteToStr(byte[] byteArrays){
            String str = "";
            for (int i = 0; i < byteArrays.length; i++) {
                str += byteToHexStr(byteArrays[i]);
            }
            return str;
        }
    
        /**
         *  将字节转化为十六进制字符串
         * @param myByte 字节
         * @return 字符串
         */
        private static String byteToHexStr(byte myByte) {
            char[] Digit = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
            char[] tampArr = new char[2];
            tampArr[0] = Digit[(myByte >>> 4) & 0X0F];
            tampArr[1] = Digit[myByte & 0X0F];
            String str = new String(tampArr);
            return str;
        }
    }

    4.打包放服务器启动

    端口需要设置为80

    5.基本设置提交

    1.URL是  http://+服务器的域名+请求接口(这里是/index)

    2.token是SignUtil工具类中设置的token

    3.EncodingAESKey随机生成即可

    提交保存成功。

     

     

    
     
    展开全文
  • 微信公众号主要有以下几个步骤 微信公众号的通讯机制 微信公众号简介 1.注册微信公众号 2.注册测试公众号 3.搭建微信本地调试环境 1)下载客户端natapp: 2)安装natapp: 4.微信公众号接入(校验签名) 第1步中...

    由于图片图床问题,文章部分图片无法预览,暂时把该文章迁移至简书,给大家带来麻烦,抱歉了。
    感兴趣的小伙伴可参考:https://www.jianshu.com/p/cc1b1050b5b4

    Author xiuhong.chen

    Date 2017/11/23

    Desc 微信公众号公注册、开发环境搭建、access_token管理、Demo实现不同类型消息发送、实现天气预报和翻译功能、natapp外网穿透

    微信公众号的通讯机制

    image.png

    微信公众号简介

    微信公众号分为服务号、订阅号、企业号,订阅号可以个人申请,服务号和企业号要有企业资质才可以。

    我们所说的微信公众号开发指的是订阅号和服务号。关于订阅号和服务器的区别,官方是这样解释的

    • 服务号**:主要偏向于服务交互(功能类似12315,114,银行,提供绑定信息,服务交互),每月可群发4条消息;服务号**适用人群:**媒体、企业、政府或其他组织。

    • 订阅号**:主要偏向于为用户传达资讯,(功能类似报纸杂志,为用户提供新闻信息或娱乐趣事),每天可群发1条消息;订阅号适用人群:个人、媒体、企业、政府或其他组织。

    1.注册微信公众号

    进入微信公众号注册页面https://mp.weixin.qq.com/点击公众号右上方的注册按钮,进入注册界面,填写基本信息,选择订阅号, 完成身份认证, 此处我选择的是个人订阅号,如下完善即可:

    image.png

    image.png

    然后注册成功之后进入微信公众平台后台,然后完善微信号名称和微信号ID:

    image.png

    image.png

    微信号名称默认是新注册公众号,还需要修改微信号名称, 修改的时候需要经过微信认证,并且审核通过之后才可以使用该公众号.

    image.png

    2.注册测试公众号

    个人订阅号有一些接口是没有权限的,也就是说个人订阅号无法调用一些高级的权限接口,如生成二维码、网页授权、自定义菜单、微信支付这样的接口权限个人订阅号是没有调用权限的, 幸运的是,微信公众平台提供了测试公众账号,测试公众号有很多个人订阅号不具备的权限, 测试公众号的注册地址为:

    http://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login

    用微信扫描页面中的二维码进行登录,登录成功后,就可以看到腾讯分配给我们的测试公众号的信息了,如下图所示, 接下来我们就可以搭建环境,进行开发测试了

    image.png

    测试公众号的所拥有的接口权限如下:

    image.png
    image.png
    image.png
    image.png

    3.搭建微信本地调试环境

    开发基于微信公众号的应用最大的痛苦之处就是调试问题,每次实现一个功能后都需要部署到一个公网服务器进行测试,因为微信用户每次向公众号发起请求时,微信服务器会先接收到用户的请求,然后再转发到我们的服务器上,也就是说,微信服务器是要和我们的服务器进行网络交互,所以我们必须保证我们的服务器外网可以访问到,这种部署到公网服务器进行测试的做法对于我们开发者来说简直是噩梦。所以我们要想一个办法可以做到本地部署,本地调试代码,而要做到这一点,那么我们要解决的问题就是将内网的部署服务器映射到外网,让微信服务器可以正常访问到,幸运的是,借助于第三方软件Ngrok,我们就可以做得到。Ngrok是一个免费的软件Ngrok,使用Ngrok后,我们就可以实现内网穿透,也就是说我们可以将内网的服务器映射到外网给别人访问,这对于我们在本地开发环境中调试微信代码是以及给用户演示一些东西非常快速和有帮助的,因为可以直接使用我们自己的内网的电脑作为服务器。不过需要翻墙访问.

    国内提供Ngrok服务比较好的网站是:http://natapp.cn/,如下图所示:

    image.png

    1)下载客户端natapp:

    image.png

    2)安装natapp:

    具体参考http://blog.csdn.net/xunxianren007/article/details/54954520, 这个网址里详细介绍了win/Mac/Linux下安装步骤

    • 解压缩到目录D:\Program Files\natapp

    • 直接双击打开失败,需要配置环境变量,编辑环境变量Path,新建natapp目录

      image.png

    • 打开cmd, 执行命令 natapp, 显示认证错误

      image.png

    • 这个时候是需要token认证的, 所以我们的主要工作就是如何获得authtoken

      进入https://natapp.cn/,根据提示注册并创建免费隧道, 注册的时候需要用支付宝实名认证的手机号注册

      根据《中华人民共和国网络安全法》,以及防止隧道被非法使用,Natapp实行实名认证制度.
      本站承诺身份信息仅用于身份验证识别,不做任何其他用途,且严格加密存储杜绝泄漏风险
      本实名认证系统基于阿里大数据的强个人识别验证.手机,身份证信息须匹配,比如手机号是你的支付宝实名认证的手机号,日常正常使用的.如其他小号可能无法通过验证
      目前创建免费隧道强制要求实名认证.付费隧道可通过支付宝支付来实名认证
      

      image.png

      image.png

    • 复制authtoken, cmd进入natapp目录执行 natapp -authtoken yourauthtoken 出现下图即为成功

      image.png

    • 此时外网的用户可以直接使用http://rzxjzk.natappfree.cc这个域名访问到我内网的127.0.0.1:8080服务器了,如下图所示:

      image.png

      image.png

      使用了ngrok之后,我们就可以把内网的服务器当成公网服务器来使用了.访问的速度也还在可以接受的范围内吧,截止到目前为止ngrok是可用的,微信公众号服务器是可以访问的,这样一来也就不妨碍我们做本地调式了。到此,我们的微信本地调试开发环境就算是搭建好了。

    4.微信公众号接入(校验签名)

    微信公众平台开发者文档上,关于公众号接入这一节内容在接入指南上写的比较详细的,文档中说接入公众号需要3个步骤,分别是:

    1、填写服务器配置
      2、验证服务器地址的有效性
      3、依据接口文档实现业务逻辑

    其实,第3步已经不能算做公众号接入的步骤,而是接入之后,开发人员可以根据微信公众号提供的接口所能做的一些开发。

    第1步中服务器配置包含服务器地址(URL)、令牌(Token) 和 消息加解密密钥(EncodingAESKey)。

    ​ 可在开发–>基本配置–>服务器配置中配置

    ​ 服务器地址即公众号后台提供业务逻辑的入口地址,目前只支持80端口,之后包括接入验证以及任何其它的操作的请求(例如消息的发送、菜单管理、素材管理等)都要从这个地址进入。接入验证和其它请求的区别就是,接入验证时是get请求,其它时候是post请求;

    Token可由开发者可以任意填写,用作生成签名(该Token会和接口URL中包含的Token进行比对,从而验证安全性);

    EncodingAESKey由开发者手动填写或随机生成,将用作消息体加解密密钥。本例中全部以未加密的明文消息方式,不涉及此配置项。

    第2步,验证服务器地址的有效性,当点击“提交”按钮后,微信服务器将发送一个http的get请求到刚刚填写的服务器地址,并且携带四个参数:

    image.png

    接到请求后,我们需要做如下三步,若确认此次GET请求来自微信服务器,原样返回echostr参数内容,则接入生效,否则接入失败。

        1. 将token、timestamp、nonce三个参数进行字典序排序
        2. 将三个参数字符串拼接成一个字符串进行sha1加密 (可逆加密解密函数)
        3. 开发者获得加密后的字符串可与signature对比,标识该请求来源于微信
    

    下面我们用Java代码来演示一下这个验证过程

    使用IDE(Eclipse或者IntelliJ IDEA)创建一个JavaWeb项目,新建servlet weChatAccounts,代码如下:

    package weChatServlet;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.activation.DataHandler;
    import javax.activation.FileDataSource;
    import javax.mail.*;
    import javax.mail.internet.*;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Arrays;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.Properties;
    
    public class weChatAccounts extends HttpServlet {
        static Logger logger = LoggerFactory.getLogger(weChatAccounts.class);
    
        /*
        * 自定义token, 用作生成签名,从而验证安全性
        * */
        private final String TOKEN = "cherry";
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
        @Override
        public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("-----开始校验签名-----");
    
            /**
             * 接收微信服务器发送请求时传递过来的参数
             */
            String signature = req.getParameter("signature");
            String timestamp = req.getParameter("timestamp");
            String nonce = req.getParameter("nonce"); //随机数
            String echostr = req.getParameter("echostr");//随机字符串
    
            /**
             * 将token、timestamp、nonce三个参数进行字典序排序
             * 并拼接为一个字符串
             */
            String sortStr = sort(TOKEN,timestamp,nonce);
            /**
             * 字符串进行shal加密
             */
            String mySignature = shal(sortStr);
            /**
             * 校验微信服务器传递过来的签名 和  加密后的字符串是否一致, 若一致则签名通过
             */
            if(!"".equals(signature) && !"".equals(mySignature) && signature.equals(mySignature)){
                System.out.println("-----签名校验通过-----");
                resp.getWriter().write(echostr);
            }else {
                System.out.println("-----校验签名失败-----");
            }
        }
    
        /**
         * 参数排序
         * @param token
         * @param timestamp
         * @param nonce
         * @return
         */
        public String sort(String token, String timestamp, String nonce) {
            String[] strArray = {token, timestamp, nonce};
            Arrays.sort(strArray);
            StringBuilder sb = new StringBuilder();
            for (String str : strArray) {
                sb.append(str);
            }
            return sb.toString();
        }
    
        /**
         * 字符串进行shal加密
         * @param str
         * @return
         */
        public String shal(String str){
            try {
                MessageDigest digest = MessageDigest.getInstance("SHA-1");
                digest.update(str.getBytes());
                byte messageDigest[] = digest.digest();
    
                StringBuffer hexString = new StringBuffer();
                // 字节数组转换为 十六进制 数
                for (int i = 0; i < messageDigest.length; i++) {
                    String shaHex = Integer.toHexString(messageDigest[i] & 0xFF);
                    if (shaHex.length() < 2) {
                        hexString.append(0);
                    }
                    hexString.append(shaHex);
                }
                return hexString.toString();
    
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return "";
        }
    }
    
    

    在web.xml中配置 servlet:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://java.sun.com/xml/ns/javaee"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    		  http://java.sun.com/xml/ns/javaee/web-app_3_1.xsd"
               version="3.1">
        <welcome-file-list>
            <welcome-file>index.jsp</welcome-file>
        </welcome-file-list>
    
        <servlet>
            <servlet-name>weChatServlet</servlet-name>
            <servlet-class>weChatServlet.weChatAccounts</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>weChatServlet</servlet-name>
            <url-pattern>/weChatServlet</url-pattern> <!--url-pattern必须与servlet-name一致-->
        </servlet-mapping>
    </web-app>
    
    

    然后在index.jsp中写hello world 测试:

    <%-- Created by IntelliJ IDEA. --%>
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <html>
      <head>
        <title></title>
      </head>
      <body>
          <h3>微信公众号测试!</h3>
      </body>
    </html>
    

    启动项目结果如下:

    image.png

    然后启动natapp,进行内网透传 natapp -authtoken mytoken

    image.png

    根据动态生成的ip地址访问.,得到如下效果,则表示外网可以成功访问:

    image.png

    进入微信测试公众号管理界面,在接口配置信息中填入映射的外网地址和代码中声明的token,如下图所示:

    点击提交,会显示配置成功, 控制台就会打印信息, 显示签名校验通过.

    注意: URL是 外网的ip地址加上 web.xml中配置的servlet名称

    image.png

    image.png

    到此,我们的公众号应用已经能够和微信服务器正常通信了,也就是说我们的公众号已经接入到微信公众平台了。

    5.access_token管理

    我们的公众号和微信服务器对接成功之后,接下来要做的就是根据我们的业务需求调用微信公众号提供的接口来实现相应的逻辑了。在使用微信公众号接口中都需要一个access_token。

    1)access_token介绍

    access_token是公众号的全局唯一接口调用凭据,公众号调用各接口时都需使用access_token。开发者需要进行妥善保存。access_token的存储至少要保留512个字符空间。access_token的有效期目前为2个小时,需定时刷新,重复获取将导致上次获取的access_token失效。

    总结以上说明,access_token需要做到以下两点:

    1.因为access_token有2个小时的时效性,要有一个机制保证最长2个小时重新获取一次。

    2.因为接口调用上限每天2000次,所以不能调用太频繁。

    2)获取access_token步骤

    公众号可以使用AppID和AppSecret调用本接口来获取access_token。AppID和AppSecret可在“微信公众平台-开发-基本配置”页中获得(需要已经成为开发者,且帐号没有异常状态)。调用接口时,请登录“微信公众平台-开发-基本配置”提前将服务器IP地址添加到IP白名单中,点击查看设置方法,否则将无法调用成功。

    接口调用请求说明

    https请求方式: GET
    https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET
    

    参数说明

    参数 是否必须 说明
    grant_type 获取access_token填写client_credential
    appid 第三方用户唯一凭证
    secret 第三方用户唯一凭证密钥,即appsecret

    返回说明

    正常情况下,微信会返回下述JSON数据包给公众号:

    {"access_token":"ACCESS_TOKEN","expires_in":7200}
    

    参数说明

    参数 说明
    access_token 获取到的凭证
    expires_in 凭证有效时间,单位:秒

    错误时微信会返回错误码等信息,JSON数据包示例如下(该示例为AppID无效错误):

    {"errcode":40013,"errmsg":"invalid appid"}
    

    返回码说明

    返回码 说明
    -1 系统繁忙,此时请开发者稍候再试
    0 请求成功
    40001 AppSecret错误或者AppSecret不属于这个公众号,请开发者确认AppSecret的正确性
    40002 请确保grant_type字段值为client_credential
    40164 调用接口的IP地址不在白名单中,请在接口IP白名单中进行设置

    3)代码实现获取access_token

    定义一个默认启动的servlet,在init方法中启动一个Thread,这个进程中定义一个无限循环的方法,用来获取access_token,当获取成功后,此进程休眠7000秒(7000秒=1.944444444444444小时),否则休眠3秒钟继续获取。流程图如下:

    image.png

    定义一个dto AccessToken:

    package AccessToken;
    
    public class AccessToken {
        private String tokenName; //获取到的凭证
        private int expireSecond;    //凭证有效时间  单位:秒
    
        public String getTokenName() {
            return tokenName;
        }
    
        public void setTokenName(String tokenName) {
            this.tokenName = tokenName;
        }
    
        public int getExpireSecond() {
            return expireSecond;
        }
    
        public void setExpireSecond(int expireSecond) {
            this.expireSecond = expireSecond;
        }
    }
    
    
    package AccessToken;
    
    import AccessToken.AccessToken;
    
    public class AccessTokenInfo {
    
        public static AccessToken accessToken = null;
    }
    
    

    编写一个用于发起https请求的工具类NetWorkUtil,代码如下:

    getHttpsResponse方法是请求一个https地址,参数requestMethod为字符串“GET”或者“POST”,传null或者“”默认为get方式。

    package AccessToken;
    
    import javax.net.ssl.*;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    
    /**
     * created by xiuhong.chen
     * 2017/12/28
     * 发起HTTPS请求的工具类
     * getHttpsResponse方法是请求一个https地址,参数requestMethod为字符串“GET”或者“POST”,传null或者“”默认为get方式。
     */
    public class NetWorkUtil {
        /**
         * 发起HTTPS请求
         * @param reqUrl
         * @param requestMethod
         * @return 相应字符串
         */
        public String getHttpsResponse(String reqUrl, String requestMethod) {
            URL url;
            InputStream is;
            String result ="";
    
            try {
                url = new URL(reqUrl);
                HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
    
                TrustManager[] tm = {xtm};
                SSLContext ctx = SSLContext.getInstance("TLS");
                ctx.init(null, tm, null);
    
                con.setSSLSocketFactory(ctx.getSocketFactory());
                con.setHostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String arg0, SSLSession arg1) {
                        return true;
                    }
                });
    
                con.setDoInput(true); //允许输入流,即允许下载
    
                //在android中必须将此项设置为false
                con.setDoOutput(false); //允许输出流,即允许上传
                con.setUseCaches(false); //不使用缓冲
                if (null != requestMethod && !requestMethod.equals("")) {
                    con.setRequestMethod(requestMethod); //使用指定的方式
                } else {
                    con.setRequestMethod("GET"); //使用get请求
                }
                is = con.getInputStream();   //获取输入流,此时才真正建立链接
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader bufferReader = new BufferedReader(isr);
                String inputLine;
                while ((inputLine = bufferReader.readLine()) != null) {
                    result += inputLine + "\n";
                }
                System.out.println(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        X509TrustManager xtm = new X509TrustManager() {
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
    
            @Override
            public void checkServerTrusted(X509Certificate[] arg0, String arg1)
                    throws CertificateException {
            }
    
            @Override
            public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                    throws CertificateException {
            }
        };
    }
    
    

    定义一个默认启动的servlet,在init方法中启动一个新的线程去获取accessToken:

    此处需要将JSON数据解析为object, 需要用到fastjson.jar

    package AccessToken;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    
    
    public class AccessTokenServlet extends HttpServlet {
        static Logger logger = LoggerFactory.getLogger(AccessTokenServlet.class);
    
        @Override
        public void init() throws ServletException {
            System.out.println("-----启动AccessTokenServlet-----");
            super.init();
    
            final String appId = getInitParameter("appId");
            final String appSecret = getInitParameter("appSecret");
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            //获取accessToken
                            AccessTokenInfo.accessToken = getAccessToken(appId, appSecret);
                            //获取成功
                            if (AccessTokenInfo.accessToken != null) {
                                //获取到access_token 休眠7000秒,大约2个小时左右
                                Thread.sleep(7000 * 1000);
                            } else {
                                //获取失败
                                Thread.sleep(1000 * 3); //获取的access_token为空 休眠3秒
                            }
                        } catch (Exception e) {
                            System.out.println("发生异常:" + e.getMessage());
                            e.printStackTrace();
                            try {
                                Thread.sleep(1000 * 10); //发生异常休眠1秒
                            } catch (Exception e1) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }).start();
        }
    
        private AccessToken getAccessToken(String appId, String appSecret) {
            NetWorkUtil netHelper = new NetWorkUtil();
            /**
             * 接口地址为https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET,其中grant_type固定写为client_credential即可。
             */
            String Url = String.format("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s", appId, appSecret);
            //此请求为https的get请求,返回的数据格式为{"access_token":"ACCESS_TOKEN","expires_in":7200}
            String result = netHelper.getHttpsResponse(Url, "");
            System.out.println("获取到的access_token="+result);
    
            //使用FastJson将Json字符串解析成Json对象
            JSONObject json = JSON.parseObject(result);
            AccessToken token = new AccessToken();
            token.setTokenName(json.getString("access_token"));
            token.setExpireSecond(json.getInteger("expires_in"));
            return token;
        }
    
    }
    
    

    然后在web.xml中配置AccessTokenServlet:

    	<servlet>
            <servlet-name>accessTokenServlet</servlet-name>
            <servlet-class>weChatServlet.AccessTokenServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>accessTokenServlet</servlet-name>
            <url-pattern>/accessTokenServlet</url-pattern> <!--url-pattern必须与servlet-name一致-->
        </servlet-mapping>
    

    index.jsp:

    <%-- Created by IntelliJ IDEA. --%>
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
    <c:set var="basePath" value="${pageContext.request.contextPath }"></c:set>
    <%@ page import="AccessToken.AccessTokenInfo"%>
    <html>
      <head>
        <title></title>
      </head>
      <body>
    
          <h3>微信公众号测试!</h3>
          <form action="${pageContext.request.contextPath}/weChatServlet" method="get">
              <button οnclick="submit">测试微信公众号</button>
          </form>
    
          <hr/>
    		
          <%--获取access_token--%>
          <form action="${pageContext.request.contextPath}/accessTokenServlet" method="get">
              <button οnclick="submit">获取access_token</button>
          </form>
          <c:if test="AccessTokenInfo.accessToken != null">
              access_token为:<%=AccessTokenInfo.accessToken.getTokenName()%>
          </c:if>
    
      </body>
    </html>
    

    启动项目, 点击获取access_token按钮: 获取出错, 返回码40013,表示AppID无效错误

    -----启动AccessTokenServlet-----
    SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
    SLF4J: Defaulting to no-operation (NOP) logger implementation
    SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
    {"errcode":40013,"errmsg":"invalid appid hint: [OwC0oa06551466]"}
    
    获取到的access_token={"errcode":40013,"errmsg":"invalid appid hint: [OwC0oa06551466]"}
    

    再次确认appID和appsecret没有错误之后,再次获取token:

    image.png

    至此, access_token获取成功 !

    6.总结一下项目启动之后, 通过微信公众号测试的全过程:

    1. 开启外网访问 : CMD进入natapp目录下, 运行命令natapp -authtoken yourauthtoken , 得到外网访问的域名

    2. Tomcat启动项目

    3. 进入微信公众号测试管理平台, 修改接口配置信息URL为: 新域名/weChatServlet , 待签名校验通过,就可以测试

    4. 进入测试公众号, 发送消息进行测试

    7.被动发送用户消息

    业务逻辑(一) — 发送文本消息

    经过上述的三步,我们开发前的准备工作已经完成了,接下来要做的就是接收微信服务器发送的消息并做出响应

    从微信公众平台接口消息指南中可以了解到,当用户向公众帐号发消息时,微信服务器会将消息通过POST方式提交给我们在接口配置信息中填写的URL,而我们就需要在URL所指向的请求处理类WxServlet的doPost方法中接收消息、处理消息和响应消息。

    可以参考微信API文档 – 被动回复用户消息 https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421140543

    1)编写一个用于处理消息的工具类

    这个工具类主要是解析消息, 构建消息

    package weChatServlet;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    import javax.servlet.http.HttpServletRequest;
    import java.io.InputStream;
    import java.text.DateFormat;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class MessageUtil {
        /**
         * 解析微信发来的请求(XML)
         * @param request
         * @return map
         * @throws Exception
         */
        public static Map<String,String> parseXml(HttpServletRequest request) throws Exception {
            // 将解析结果存储在HashMap中
            Map<String,String> map = new HashMap();
            // 从request中取得输入流
            InputStream inputStream = request.getInputStream();
            System.out.println("获取输入流");
            // 读取输入流
            SAXReader reader = new SAXReader();
            Document document = reader.read(inputStream);
            // 得到xml根元素
            Element root = document.getRootElement();
            // 得到根元素的所有子节点
            List<Element> elementList = root.elements();
    
            // 遍历所有子节点
            for (Element e : elementList) {
                System.out.println(e.getName() + "|" + e.getText());
                map.put(e.getName(), e.getText());
            }
    
            // 释放资源
            inputStream.close();
            inputStream = null;
            return map;
        }
    
        /**
         * 根据消息类型 构造返回消息
         */
        public static String buildXml(Map<String,String> map) {
            String result;
            String msgType = map.get("MsgType").toString();
            System.out.println("MsgType:" + msgType);
            if(msgType.toUpperCase().equals("TEXT")){
                result = buildTextMessage(map, "Cherry的小小窝, 请问客官想要点啥?");
            }else{
                String fromUserName = map.get("FromUserName");
                // 开发者微信号
                String toUserName = map.get("ToUserName");
                result = String
                        .format(
                                "<xml>" +
                                        "<ToUserName><![CDATA[%s]]></ToUserName>" +
                                        "<FromUserName><![CDATA[%s]]></FromUserName>" +
                                        "<CreateTime>%s</CreateTime>" +
                                        "<MsgType><![CDATA[text]]></MsgType>" +
                                        "<Content><![CDATA[%s]]></Content>" +
                                        "</xml>",
                                fromUserName, toUserName, getUtcTime(),
                                "请回复如下关键词:\n文本\n图片\n语音\n视频\n音乐\n图文");
            }
    
            return result;
        }
    
        /**
         * 构造文本消息
         *
         * @param map
         * @param content
         * @return
         */
        private static String buildTextMessage(Map<String,String> map, String content) {
            //发送方帐号
            String fromUserName = map.get("FromUserName");
            // 开发者微信号
            String toUserName = map.get("ToUserName");
            /**
             * 文本消息XML数据格式
             */
            return String.format(
                    "<xml>" +
                            "<ToUserName><![CDATA[%s]]></ToUserName>" +
                            "<FromUserName><![CDATA[%s]]></FromUserName>" +
                            "<CreateTime>%s</CreateTime>" +
                            "<MsgType><![CDATA[text]]></MsgType>" +
                            "<Content><![CDATA[%s]]></Content>" + "</xml>",
                    fromUserName, toUserName, getUtcTime(), content);
        }
    
        private static String getUtcTime() {
            Date dt = new Date();// 如果不需要格式,可直接用dt,dt就是当前系统时间
            DateFormat df = new SimpleDateFormat("yyyyMMddhhmm");// 设置显示格式
            String nowTime = df.format(dt);
            long dd = (long) 0;
            try {
                dd = df.parse(nowTime).getTime();
            } catch (Exception e) {
    
            }
            return String.valueOf(dd);
        }
    
    }
    
    
    2)在WxServlet的doPost方法中处理请求

    WxServlet的doPost方法的代码如下:

    package weChatServlet;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Arrays;
    import java.util.Map;
    
    public class WeChatAccounts extends HttpServlet {
        static Logger logger = LoggerFactory.getLogger(WeChatAccounts.class);
    
        /*
        * 自定义token, 用作生成签名,从而验证安全性
        * */
        private final String TOKEN = "cherry";
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // TODO 接收、处理、响应由微信服务器转发的用户发送给公众帐号的消息
            // 将请求、响应的编码均设置为UTF-8(防止中文乱码)
            req.setCharacterEncoding("UTF-8");
            resp.setCharacterEncoding("UTF-8");
            System.out.println("请求进入");
            String result = "";
            try {
                Map<String,String> map = MessageUtil.parseXml(req);
    
                System.out.println("开始构造消息");
                result = MessageUtil.buildXml(map);
                System.out.println(result);
    
                if(result.equals("")){
                    result = "未正确响应";
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("发生异常:"+ e.getMessage());
            }
            resp.getWriter().println(result);
        }
        @Override
        public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("-----开始校验签名-----");
         ..............................
            
        }
    }
    
    

    将WxStudy部署到Tomcat服务器,启动服务器,记得使用ngrok将本地Tomcat服务器的8080端口映射到外网,保证接口配置信息的URL地址:http://xdp.ngrok.natapp.cn/WxServlet可以正常与微信服务器通信

    登录到我们的测试公众号的管理后台,然后用微信扫描一下测试号的二维码,如下图所示:

    image.png

    关注成功后,我们开发好的公众号应用会先给用户发一条提示用户操作的文本消息,微信用户根据提示操作输入"文本",我们的公众号应用接收到用户请求后就给用户回复了一条我们自己构建好的文本消息,如下图所示:

    image.png

    我们公众号获取到的输入流如下:

    第一次关注时获取的输入流, 消息类型为事件event, 订阅
    ToUserName|gh_fbcf752402d4
    FromUserName|oEG9V1PeFHnsQviezVY9D4IDcyAk
    CreateTime|1514461156
    MsgType|event
    Event|subscribe
    EventKey|
    
    第一次发送消息内容为"文本"获取的输入流, 消息类型是text
    ToUserName|gh_fbcf752402d4
    FromUserName|oEG9V1PeFHnsQviezVY9D4IDcyAk
    CreateTime|1514461351
    MsgType|text
    Content|文本
    MsgId|6504561974052876654
    

    我们公众号应用响应给微信用户的文本消息的XML数据如下:

    关注之后返回的消息是:
    MsgType:event
    <xml>
    	<ToUserName><![CDATA[oEG9V1PeFHnsQviezVY9D4IDcyAk]]></ToUserName>
        <FromUserName><![CDATA[gh_fbcf752402d4]]></FromUserName>					     			<CreateTime>1514417940000</CreateTime>
    	<MsgType><![CDATA[text]]></MsgType>
    	<Content><![CDATA[请回复如下关键词:
    	文本
    	图片
    	语音
    	视频
    	音乐
    	图文]]></Content>
    </xml>
    
    
    输入文本之后返回的消息是:
    <xml>
    	<ToUserName><![CDATA[oEG9V1PeFHnsQviezVY9D4IDcyAk]]></ToUserName>
    	<FromUserName><![CDATA[gh_fbcf752402d4]]></FromUserName>
    	<CreateTime>1514418120000</CreateTime>
    	<MsgType><![CDATA[text]]></MsgType>
    	<Content><![CDATA[Cherry的小小窝, 请问客官想要点啥?]]></Content>
    </xml>
    

    业务逻辑(二) — 上传素材获取Media_id

    图片,语音,视频的回复消息构造,这三种消息构造时的都需要一个mediaId,而这个mediaId是通过素材管理接口上传多媒体文件得到的,为了构造图片,语音,视频的这几种回复消息,我事先准备好了测试素材,

    如图片路径为: C:\Users\Chen Xiuhong\Pictures\timg (1).jpg

    然后通过微信公众号平台提供的素材管理接口将图片,语音,视频上传到微信服务器上,上传成功后,微信服务器会给我们返回一个mediaId,用于标识上传成功的多媒体素材,上传素材的工具类代码如下:

    package weChatServlet;
    
    import AccessToken.AccessToken;
    import AccessToken.NetWorkUtil;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONException;
    import com.alibaba.fastjson.JSONObject;
    import org.apache.commons.httpclient.HttpClient;
    import org.apache.commons.httpclient.HttpException;
    import org.apache.commons.httpclient.HttpStatus;
    import org.apache.commons.httpclient.methods.PostMethod;
    import org.apache.commons.httpclient.methods.multipart.FilePart;
    import org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity;
    import org.apache.commons.httpclient.methods.multipart.Part;
    import org.apache.commons.httpclient.methods.multipart.StringPart;
    import org.apache.commons.httpclient.protocol.Protocol;
    import org.apache.commons.httpclient.protocol.SSLProtocolSocketFactory;
    import org.apache.commons.httpclient.util.HttpURLConnection;
    
    import java.io.*;
    import java.net.URL;
    
    /**
     * Author xiuhong.chen@hand-china.com
     * created on 2018/1/9
     * 上传media素材, 获取media_id
     */
    public class UploadMediaApiUtil {
        // token 接口(GET)
        private static final String ACCESS_TOKEN = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s";
        // 素材上传(POST)URL
        private static final String UPLOAD_MEDIA = "https://api.weixin.qq.com/cgi-bin/media/upload";
        // 素材下载:不支持视频文件的下载(GET)
        private static final String DOWNLOAD_MEDIA = "http://file.api.weixin.qq.com/cgi-bin/media/get?access_token=%s&media_id=%s";
    
        public static String getTokenUrl(String appId, String appSecret) {
         return String.format(ACCESS_TOKEN, appId, appSecret);
        }
    
        public static String getDownloadUrl(String token, String mediaId) {
         return String.format(DOWNLOAD_MEDIA, token, mediaId);
        }
    
        /**
         * 通用接口获取token凭证
         * @param appId
         * @param appSecret
         * @return
         */
        public String getAccessToken(String appId, String appSecret) {
            NetWorkUtil netHelper = new NetWorkUtil();
            String Url = String.format("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s", appId, appSecret);
            String result = netHelper.getHttpsResponse(Url, "");
            JSONObject json = JSON.parseObject(result);
            return json.getString("access_token");
        }
    
        /**
         * 素材上传到微信服务器
         * @param file  File file = new File(filePath); // 获取本地文件
         * @param token access_token
         * @param type type只支持四种类型素材(video/image/voice/thumb)
         * @return
         */
        public  JSONObject uploadMedia(File file, String token, String type) {
            if(file == null || token == null || type == null){
                return null;
            }
            if(!file.exists()){
                System.out.println("上传文件不存在,请检查!");
                return null;
            }
            JSONObject jsonObject = null;
            PostMethod post = new PostMethod(UPLOAD_MEDIA);
            post.setRequestHeader("Connection", "Keep-Alive");
            post.setRequestHeader("Cache-Control", "no-cache");
            FilePart media;
            HttpClient httpClient = new HttpClient();
            //信任任何类型的证书
            Protocol myhttps = new Protocol("https", new SSLProtocolSocketFactory(), 443);
            Protocol.registerProtocol("https", myhttps);
    
            try {
                media = new FilePart("media", file);
                Part[] parts = new Part[]{
                        new StringPart("access_token", token),
                        new StringPart("type", type),
                        media
                        };
                MultipartRequestEntity entity = new MultipartRequestEntity(parts,post.getParams());
                post.setRequestEntity(entity);
                int status = httpClient.executeMethod(post);
                if (status == HttpStatus.SC_OK) {
                    String text = post.getResponseBodyAsString();
                    jsonObject = JSONObject.parseObject(text);
                } else {
                    System.out.println("upload Media failure status is:" + status);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (HttpException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return jsonObject;
        }
        public static File downloadMedia(String fileName, String token, String mediaId) {
            String path = getDownloadUrl(token, mediaId);
            //return httpRequestToFile(fileName, url, "GET", null);
    
            if (fileName == null || path == null) {
                return null;
            }
            File file = null;
            HttpURLConnection conn = null;
            InputStream inputStream = null;
            FileOutputStream fileOut = null;
            try {
                 URL url = new URL(path);
                 conn = (HttpURLConnection) url.openConnection();
                 conn.setDoOutput(true);
                 conn.setDoInput(true);
                 conn.setUseCaches(false);
                 conn.setRequestMethod("GET");
    
                 inputStream = conn.getInputStream();
                 if (inputStream != null) {
                     file = new File(fileName);
                 } else {
                     return file;
                 }
    
                 //写入到文件
                 fileOut = new FileOutputStream(file);
                 if (fileOut != null) {
                     int c = inputStream.read();
                     while (c != -1) {
                         fileOut.write(c);
                         c = inputStream.read();
                     }
                 }
            } catch (Exception e) {
            } finally {
                 if (conn != null) {
                     conn.disconnect();
                 }
    
                 try {
                      inputStream.close();
                      fileOut.close();
                   } catch (IOException execption) {
                 }
            }
        return file;
        }
    
    }
    
    
    package weChatServlet;
    
    import com.alibaba.fastjson.JSONObject;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.File;
    import java.io.IOException;
    
    /**
     * 上传素材servlet
     */
    @WebServlet(name = "UploadMediaServlet")
    public class UploadMediaServlet extends HttpServlet {
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
        }
    
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            UploadMediaApiUtil uploadMediaApiUtil = new UploadMediaApiUtil();
            String appId = "wx0aa26453a7ec9df7";
            String appSecret = "2819f0c98199daef39cb6220b4d01b96";
            String accessToken = uploadMediaApiUtil.getAccessToken(appId,appSecret);
    
            String filePath = "C:\\Users\\Chen Xiuhong\\Pictures\\timg (1).jpg";
            File file = new File(filePath);
            String type = "IMAGE";
            JSONObject jsonObject = uploadMediaApiUtil.uploadMedia(file,accessToken,type);
            System.out.println(jsonObject.toString());
        }
    }
    
    

    运行的时候老是在PostMethod处报错, 错误信息显示缺包

    image.png

    百度之后发现Http协议使用封装jar包(commons-codec-1.3.jar、commons-httpclient-3.1.jar、commons-logging-1.1.jar), 所以还缺少一个包, 添加三个包之后就成功运行,可以得到media_id

    image.png

    可以看到,素材上传成功后,微信服务器就会返回一个media_id,用于标识上传后的文件.有了这个media_id后,我们就可以构建我们想要的图片,语音,视频回复消息了.

    业务逻辑(三) — 发送图片消息

    在第7部分中我们已经上传了一个图片素材, 并且也获得了media_id

    UCWXNCogK5ub6YFFQf7QcEpvDIYLf3Zh0L5W9i4aEp2ehfnTrASeV59x3LMD88SS
    

    接下来我们就使用media_id来构造图片消息:

    	/**
         *  构建图片消息
         * @param map
         * @param picUrl
         * @return
         */
        private static String buildImageMessage(Map<String, String> map, String picUrl) {
            String fromUserName = map.get("FromUserName");
            String toUserName = map.get("ToUserName");
            /*返回指定的图片(该图片是上传为素材的,获得其media_id)*/
            //String media_id = "UCWXNCogK5ub6YFFQf7QcEpvDIYLf3Zh0L5W9i4aEp2ehfnTrASeV59x3LMD88SS";
    
            /*返回用户发过来的图片*/
            String media_id = map.get("MediaId");
            return String.format(
                    "<xml>" +
                    "<ToUserName><![CDATA[%s]]></ToUserName>" +
                    "<FromUserName><![CDATA[%s]]></FromUserName>" +
                    "<CreateTime>%s</CreateTime>" +
                    "<MsgType><![CDATA[image]]></MsgType>" +
                    "<Image>" +
                    "   <MediaId><![CDATA[%s]]></MediaId>" +
                    "</Image>" +
                    "</xml>",
                    fromUserName,toUserName, getUtcTime(),media_id
            );
        }
    
    

    用户发送图片时,公众号返回给用户我之前上传的素材; 或者将用户发送的图片又返回一次

    image.png

    业务逻辑(四) — 发送语音消息

     	/**
         * 构造语音消息
         * @param map
         * @return
         */
        private static String buildVoiceMessage(Map<String, String> map) {
            String fromUserName = map.get("FromUserName");
            String toUserName = map.get("ToUserName");
            /*返回用户发过来的语音*/
            String media_id = map.get("MediaId");
            return String.format(
                    "<xml>" +
                    "<ToUserName><![CDATA[%s]]></ToUserName>" +
                    "<FromUserName><![CDATA[%s]]></FromUserName>" +
                    "<CreateTime>%s</CreateTime>" +
                    "<MsgType><![CDATA[voice]]></MsgType>" +
                    "<Voice>" +
                    "   <MediaId><![CDATA[%s]]></MediaId>" +
                    "</Voice>" +
                    "</xml>",
                    fromUserName,toUserName, getUtcTime(),media_id
            );
        }
    
    

    业务逻辑(五) — 发送视频消息

    首先需要调用业务逻辑(二)上传一段小视频,获取media_id,上传的视频不大于10MB,支持MP4格式, 然后当用户发送视频格式时,公众号就回复视频格式

    	/**
         * 回复视频消息
         * @param map
         * @return
         */
        private static String buildVideoMessage(Map<String, String> map) {
            String fromUserName = map.get("FromUserName");
            String toUserName = map.get("ToUserName");
            String title = "客官发过来的视频哟~~";
            String description = "客官您呐,现在肯定很开心,对不啦 嘻嘻?";
            /*返回用户发过来的视频*/
            //String media_id = map.get("MediaId");
            String media_id = "hTl1of-w78xO-0cPnF_Wax1QrTwhnFpG1WBkAWEYRr9Hfwxw8DYKPYFX-22hAwSs";
            return String.format(
                    "<xml>" +
                    "<ToUserName><![CDATA[%s]]></ToUserName>" +
                    "<FromUserName><![CDATA[%s]]></FromUserName>" +
                    "<CreateTime>%s</CreateTime>" +
                    "<MsgType><![CDATA[video]]></MsgType>" +
                    "<Video>" +
                    "   <MediaId><![CDATA[%s]]></MediaId>" +
                    "   <Title><![CDATA[%s]]></Title>" +
                    "   <Description><![CDATA[%s]]></Description>" +
                    "</Video>" +
                    "</xml>",
                    fromUserName,toUserName, getUtcTime(),media_id,title,description
            );
        }
    

    展示效果如下:

    image.png

    注意: media_id只能用上传的视频的id, 不能使用用户发送视频时的那个id, 至于原因待探究

    业务逻辑(六) — 发送音乐消息

    	/**
         * 回复音乐消息
         * @param map
         * @return
         */
        private static String buildMusicMessage(Map<String, String> map) {
            String fromUserName = map.get("FromUserName");
            String toUserName = map.get("ToUserName");
            String title = "亲爱的路人";
            String description = "多听音乐 心情棒棒 嘻嘻?";
            String hqMusicUrl ="http://www.kugou.com/song/20qzz4f.html?frombaidu#hash=20C16B9CCCCF851D1D23AF52DD963986&album_id=0";
            return String.format(
                    "<xml>" +
                    "<ToUserName><![CDATA[%s]]></ToUserName>" +
                    "<FromUserName><![CDATA[%s]]></FromUserName>" +
                    "<CreateTime>%s</CreateTime>" +
                    "<MsgType><![CDATA[music]]></MsgType>" +
                    "<Music>" +
                    "   <Title><![CDATA[%s]]></Title>" +
                    "   <Description><![CDATA[%s]]></Description>" +
                    "   <MusicUrl>< ![CDATA[%s] ]></MusicUrl>" +  //非必须项 音乐链接
                    "   <HQMusicUrl><![CDATA[%s]]></HQMusicUrl>"+ //非必须项 高质量音乐链接,WIFI环境优先使用该链接播放音乐
                    "</Music>" +
                    "</xml>",
                    fromUserName,toUserName, getUtcTime(),title,description,hqMusicUrl,hqMusicUrl
            );
        }
    

    image.png

    业务逻辑(七) — 发送图文消息

    /**
         * 返回图文消息
         * @param map
         * @return
         */
        private static String buildNewsMessage(Map<String, String> map) {
            String fromUserName = map.get("FromUserName");
            String toUserName = map.get("ToUserName");
            String title1 = "HAP审计的实现和使用";
            String description1 = "由于HAP框架用的是Spring+SpringMVC+Mybatis,其中Mybatis中的拦截器可以选择在被拦截的方法前后执行自己的逻辑。所以我们通过拦截器实现了审计功能,当用户对某个实体类进行增删改操作时,拦截器可以拦截,然后将操作的数据记录在审计表中,便于用户以后审计。";
            String picUrl1 ="http://upload-images.jianshu.io/upload_images/7855203-b9e9c9ded8a732a1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240";
            String textUrl1 = "http://blog.csdn.net/a1786223749/article/details/78330890";
    
            String title2 = "KendoUI之Grid的问题详解";
            String description2 = "kendoLov带出的值出现 null和undefined";
            String picUrl2 ="https://demos.telerik.com/kendo-ui/content/shared/images/theme-builder.png";
            String textUrl2 = "http://blog.csdn.net/a1786223749/article/details/78330908";
    
            return String.format(
                    "<xml>" +
                    "<ToUserName><![CDATA[%s]]></ToUserName>" +
                    "<FromUserName><![CDATA[%s]]></FromUserName>" +
                    "<CreateTime>%s</CreateTime>" +
                    "<MsgType><![CDATA[news]]></MsgType>" +
                    "<ArticleCount>2</ArticleCount>" + //图文消息个数,限制为8条以内
                    "<Articles>" + //多条图文消息信息,默认第一个item为大图,注意,如果图文数超过8,则将会无响应
                        "<item>" +
                            "<Title><![CDATA[%s]]></Title> " +
                            "<Description><![CDATA[%s]]></Description>" +
                            "<PicUrl><![CDATA[%s]]></PicUrl>" + //图片链接,支持JPG、PNG格式,较好的效果为大图360*200,小图200*200
                            "<Url><![CDATA[%s]]></Url>" + //点击图文消息跳转链接
                        "</item>" +
                        "<item>" +
                            "<Title><![CDATA[%s]]></Title>" +
                            "<Description><![CDATA[%s]]></Description>" +
                            "<PicUrl><![CDATA[%s]]]></PicUrl>" +
                            "<Url><![CDATA[%s]]]></Url>" +
                        "</item>" +
                    "</Articles>" +
                    "</xml>"
                    ,
                    fromUserName,toUserName, getUtcTime(),
                    title1,description1,picUrl1,textUrl1,
                    title2,description2,picUrl2,textUrl2
            );
        }
    

    image.png

    网络不太好,所以图片没有加载出来, 在手机上测试是可以看到图片的.

    8.天气预报功能开发

    借助百度API查询天气, 所以首先我们要在百度开发平台注册信息

    image.png

    申请天气查询的API, 然后获取AK

    image.png

    但是查询天气的时候AK并不能使用, 显示APP服务被禁用

    image.png

    看来用百度的API这一步行不通, 只能使用Webservice网站上公开的接口

    调用WebService查询天气预报

    直接使用wsimport 通过该地址生成Java文件时,会报错。因为该wsdl里面包含 ref = “s:schema” 这样的引用。而jaxb是不支持的。所以需要手动将该wsdl下载下来做下修改,然后再生成java文件。

    wsimport -keep http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl

    D:\Eclipse Files\TEST_EMAIL\src\weatherService>wsimport -keep  http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl
    正在解析 WSDL...
    
    
    [WARNING] src-resolve.4.2: 解析组件 's:schema' 时出错。在该组件中检测到 's:schema' 位于名称空间 'http://www.w3.org/2001/XMLSchema' 中, 但无法从方案文档 'http://
    ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl#types?schema1' 引用此名称空间的组件。如果这是不正确的名称空间, 则很可能需要更改 's:schema' 的前缀。如果这是正确
    的名称空间, 则应将适当的 'import' 标记添加到 'http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl#types?schema1'。
      http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl#types?schema1的第 15 行
    
    [WARNING] src-resolve: 无法将名称 's:schema' 解析为 'element declaration' 组件。
      http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl#types?schema1的第 15 行
    
    [ERROR] undefined element declaration 's:schema'
      http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl的第 15 行
    
    [ERROR] undefined element declaration 's:schema'
      http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl的第 61 行
    
    [ERROR] undefined element declaration 's:schema'
      http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl的第 101 行
    
    Exception in thread "main" com.sun.tools.internal.ws.wscompile.AbortException
            at com.sun.tools.internal.ws.processor.modeler.wsdl.JAXBModelBuilder.bind(JAXBModelBuilder.java:129)
            at com.sun.tools.internal.ws.processor.modeler.wsdl.WSDLModeler.buildJAXBModel(WSDLModeler.java:2283)
            at com.sun.tools.internal.ws.processor.modeler.wsdl.WSDLModeler.internalBuildModel(WSDLModeler.java:183)
            at com.sun.tools.internal.ws.processor.modeler.wsdl.WSDLModeler.buildModel(WSDLModeler.java:126)
            at com.sun.tools.internal.ws.wscompile.WsimportTool.buildWsdlModel(WsimportTool.java:429)
            at com.sun.tools.internal.ws.wscompile.WsimportTool.run(WsimportTool.java:190)
            at com.sun.tools.internal.ws.wscompile.WsimportTool.run(WsimportTool.java:168)
            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
            at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
            at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
            at java.lang.reflect.Method.invoke(Method.java:497)
            at com.sun.tools.internal.ws.Invoker.invoke(Invoker.java:159)
            at com.sun.tools.internal.ws.WsImport.main(WsImport.java:42)
    
    

    解决方法:

     1) 打开 http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl , 页面另存为xml文件;
     2)将所有的
    <s:element ref="s:schema" />
    <s:any />
    改成 <s:any minOccurs="2" maxOccurs="2"/>,一共有三处需要修改,建议查找<s:element ref="s:schema" />,修改时把<s:any />也要删掉
    3)运行命令
    wsimport -keep D:\WeatherWS.xml
    	
    需要注意的是,要修改WeatherWS.java文件中wsdl的url,因为我们用的是本地文件生成的,要修改成网站的
    url:http://ws.webxml.com.cn/WebServices/WeatherWS.asmx?wsdl
    

    image.png

    image.png

    然后就可以调用生成的代码weatherWSSoap.getWeather(cityName,null);,来查询天气:

    public static String buildXml(Map<String,String> map) {
            String result = "";
            String msgType = map.get("MsgType").toString().toUpperCase();
            String content = map.get("Content");
            if("TEXT".equals(msgType)){
                /*查询天气*/
                if(content.contains("天气") && !"".equals(content)){
                    if(content.contains(":")){
                        String cityName = content.substring(content.lastIndexOf(":")+1,content.length());
                        WeatherInfo weather = new WeatherInfo();
                        String weaInfo = weather.getWeatherInfo(cityName);
                        result = buildTextMessage(map,weaInfo);
                    }else{
                        String notice = "查询天气的正确姿势: 天气:城市名\n请客官输入正确的格式哟~";
                        result = buildTextMessage(map,notice);
                    }
                }else{
                    result = buildTextMessage(map,"");
                }
            }
            return result;
        }
    
    package weChatServlet;
    
    import cn.com.webxml.ArrayOfString;
    import cn.com.webxml.WeatherWS;
    import cn.com.webxml.WeatherWSSoap;
    
    import java.util.List;
    
    /**
     * 调用weather 的webservice, 并处理json数据
     */
    public class WeatherInfo {
        public String getWeatherInfo(String cityName){
            /*实例化工厂WeatherWS  创建实例WeatherWSSoap  调用实例的方法getWeather()*/
            WeatherWS weatherWS = new WeatherWS();
            WeatherWSSoap weatherWSSoap = weatherWS.getWeatherWSSoap();
    
            /*响应信息*/
            StringBuffer sb = new StringBuffer();
    
            /*获取指定城市的天气预报*/
            ArrayOfString weatherInfo = weatherWSSoap.getWeather(cityName,null);
            List<String> listWeatherInfo = weatherInfo.getString();
            for(String str :  listWeatherInfo){
                if(!str.contains(".gif")){
                    sb.append(str);
                    sb.append("\n");
                    System.out.println(str);
                    System.out.println("------------------------");
                }
            }
            return sb.toString();
        }
    }
    
    

    结果如下: 查询天气的格式为: 天气:城市名

    image.png

    image.png

    9.翻译功能开发(有道智云)

    网络上有很多翻译API,大家可以根据自己的需求进行选择。这里我们选择应用比较广泛的,翻译功能还比较不错的有道翻译API,下面对这种API的相关信息进行分析。

    2017.12.31之前,我们可以使用有道翻译API

    关于有道翻译API使用 ,请参考链接: http://blog.csdn.net/nomasp/article/details/48995039

    有道翻译API key申请,请参考链接: http://fanyi.youdao.com/openapi?path=data-mode

    image.png

    有道翻译API已经禁用,所以我们要去有道智云寻求方法(http://ai.youdao.com/index.s), 首先需要注册,注册之后账户里默认有100元的额度,使用有道智云是有字数限制的,资费如下:

    image.png

    image.png

    然后我们需要创建应用, 绑定服务之后,就可以生成appKey和密钥 , 这两个数据在调用API中会用到

    image.png

    有道智云的API文档: http://ai.youdao.com/docs/doc-trans-api.s#p01

    下边就详细介绍如何调用有道智云API

    1) 接口调用参数:

    调用API需要向接口发送以下字段来访问服务。

    字段名 类型 含义 必填 备注
    q text 要翻译的文本 True 必须是UTF-8编码
    from text 源语言 True 语言列表 (可设置为auto)
    to text 目标语言 True 语言列表 (可设置为auto)
    appKey text 应用 ID True 可在 应用管理 查看
    salt text 随机数 True
    sign text 签名,通过md5(appKey+q+salt+密钥)生成 True appKey+q+salt+密钥的MD5值

    签名生成方法如下:

    1. 将请求参数中的 appKey,翻译文本 q (注意为UTF-8编码),随机数 salt密钥 (可在 应用管理 查看), 按照 appKey+q+salt+密钥 的顺序拼接得到字符串 str
    2. 对字符串 str 做md5,得到32位大写的 sign (参考Java生成MD5示例)

    注意:

    1. 请先将需要翻译的文本转换为 UTF-8 编码
    2. 在发送 HTTP 请求之前需要对各字段做 URL encode。
    3. 在生成签名拼接 appKey+q+salt+密钥 字符串时,q 不需要做 URL encode,在生成签名之后,发送 HTTP 请求之前才需要对要发送的待翻译文本字段 q 做 URL encode。

    我们代码中需要使用CloseableHttpClient, 所以需要引入两个jar包 httpclient-4.5.3.jar 和 httpcore-4.4.6.jar

    2) 输出结果

    返回的结果是json格式,包含字段与FROM和TO的值有关,具体说明如下:

    字段名 类型 含义 备注
    errorCode text 错误返回码 一定存在
    query text 源语言 查询正确时,一定存在
    translation text 翻译结果 查询正确时一定存在
    basic text 词义 基本词典,查词时才有
    web text 词义 网络释义,该结果不一定存在
    l text 源语言和目标语言 一定存在
    dict text 词典deeplink 查询语种为支持语言时,存在
    webdict text webdeeplink 查询语种为支持语言时,存在
    3)支持的语言表
    语言 代码
    中文 zh-CHS
    日文 ja
    英文 EN
    韩文 ko
    法文 fr
    俄文 ru
    葡萄牙文 pt
    西班牙文 es
    4) 错误代码列表
    错误码 含义
    101 缺少必填的参数,出现这个情况还可能是et的值和实际加密方式不对应
    102 不支持的语言类型
    103 翻译文本过长
    104 不支持的API类型
    105 不支持的签名类型
    106 不支持的响应类型
    107 不支持的传输加密类型
    108 appKey无效,注册账号, 登录后台创建应用和实例并完成绑定, 可获得应用ID和密钥等信息,其中应用ID就是appKey( 注意不是应用密钥)
    109 batchLog格式不正确
    110 无相关服务的有效实例
    111 开发者账号无效,可能是账号为欠费状态
    201 解密失败,可能为DES,BASE64,URLDecode的错误
    202 签名检验失败
    203 访问IP地址不在可访问IP列表
    301 辞典查询失败
    302 翻译查询失败
    303 服务端的其它异常
    401 账户已经欠费停
    5) DEMO

    result = EntityUtils.toString(httpEntity, “utf-8”); 返回的是JSON对象格式的字符串,如下:

    {
    	"web":[
    		{
    			"value":["Hello","How do you do","hi"],
    			"key":"你好"
    		},
    
    		{
                "value":["How are you","How Do You Do","Harvey, how are you Harvey"],
                "key":"你好吗"
    		},
    
    		{
                "value":["Teacher Kim Bong-du","My Teacher Mr Kim","Seonsaeng Kim Bong-du"],
                "key":"老师你好"
    		}
    	],
    
    	"query":"你好",
    
    	"translation":[
    		"How are you"
    	],
    
    	"errorCode":"0",
    
    	"dict":{"url":"yddict://m.youdao.com/dict?le=eng&q=%E4%BD%A0%E5%A5%BD"},
    
    	"webdict":{"url":"http://m.youdao.com/dict?le=eng&q=%E4%BD%A0%E5%A5%BD"},
    
    	"basic":{
    		"explains":["hello","hi"]
    	},
    
    	"l":"zh-CHS2EN"
    }
    

    所以需要将JSON字符串转换为实体类对象DTO

    /*处理JSON字符串为实体对象TranslateResponseDto*/
    TranslateResponseDto dto = new TranslateResponseDto();
    dto=JSON.parseObject(result, TranslateResponseDto.class);
    

    image.png

    YouDaoAPI.java

    package translate;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import org.apache.http.HttpEntity;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.net.URLEncoder;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    public class YouDaoAPI {
        public String translate(String q)throws Exception{
            //应用申请的key
            String appKey ="2d156317f9da5d91";
            //要翻译的文本 必须是UTF-8编码
            String query = q;
            //随机数
            String salt = String.valueOf(System.currentTimeMillis());
            //源语言
            String from = "auto";
            //目标语言
            String to = "auto";
            //签名,通过md5(appkey+q+salt+密钥)生成
            String sign = md5(appKey + query + salt+"PXwLK5mGbARMsbtjIfpZBM7sDwt40YAL");
    
            Map params = new HashMap();
            params.put("q", query);
            params.put("from", from);
            params.put("to", to);
            params.put("sign", sign);
            params.put("salt", salt);
            params.put("appKey", appKey);
            return requestForHttp("http://openapi.youdao.com/api", params);
        }
    
        public  String requestForHttp(String url,Map requestParams) throws Exception{
            String result = null; //翻译后的JSON字符串
            StringBuffer sb = new StringBuffer(); //处理后的返回结果
    
            CloseableHttpClient httpClient = HttpClients.createDefault();
            /**HttpPost*/
            HttpPost httpPost = new HttpPost(url);
    
            List params = new ArrayList();
            Iterator it = requestParams.entrySet().iterator();
            while (it.hasNext()) {
                Entry<String, String> en = (Entry)it.next();
                String key = en.getKey();
                String value = en.getValue();
                if (value != null) {
                    params.add(new BasicNameValuePair(key, value));
                }
            }
            httpPost.setEntity(new UrlEncodedFormEntity(params,"UTF-8"));
            /**HttpResponse*/
            CloseableHttpResponse httpResponse = httpClient.execute(httpPost);
            try{
                HttpEntity httpEntity = httpResponse.getEntity();
                result = EntityUtils.toString(httpEntity, "utf-8");
                //EntityUtils.consume(httpEntity);
    
                /*处理JSON字符串为实体对象TranslateResponseDto*/
                TranslateResponseDto dto = new TranslateResponseDto();
                dto=JSON.parseObject(result, TranslateResponseDto.class);
    
                /*遍历实体类的每个字段,拼接为字符串返回给用户*/
                if(!"".equals(dto.getQuery()) && dto.getQuery() != null){
                    sb.append("原文:"+dto.getQuery() + "\n");
                }
                if(!"".equals(dto.getTranslation()) && dto.getTranslation() != null){
                    sb.append("翻译结果:");
                    List<String> translation = dto.getTranslation();
                    for(String s : translation){
                        sb.append(s + "\n");
                    }
                }
                if(!"".equals(dto.getBasic()) && dto.getBasic() != null){
                    Map<String, List<String>> basic = dto.getBasic();
                    sb.append("词义:");
                    for (Map.Entry<String, List<String>> entry : basic.entrySet()) {
                        sb.append(entry.getValue()+ "\n");
                    }
                }
                if(!"".equals(dto.getErrorCode()) && dto.getErrorCode() != null && !"0".equals(dto.getErrorCode())){
                    if("103".equals(dto.getErrorCode())){
                        sb.append("翻译出错:翻译文本过长\n");
                    }else{
                        sb.append("翻译出错:错误代码为"+dto.getErrorCode()+"\n");
                    }
                }
    
    
            }finally{
                try{
                    if(httpResponse!=null){
                        httpResponse.close();
                    }
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            return sb.toString();
        }
    
        /**
         * 生成32位MD5摘要
         * @param string
         * @return
         */
        public static String md5(String string) {
            if(string == null){
                return null;
            }
            char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                    'A', 'B', 'C', 'D', 'E', 'F'};
    
            try{
                byte[] btInput = string.getBytes("utf-8");
                /** 获得MD5摘要算法的 MessageDigest 对象 */
                MessageDigest mdInst = MessageDigest.getInstance("MD5");
                /** 使用指定的字节更新摘要 */
                mdInst.update(btInput);
                /** 获得密文 */
                byte[] md = mdInst.digest();
                /** 把密文转换成十六进制的字符串形式 */
                int j = md.length;
                char str[] = new char[j * 2];
                int k = 0;
                for (byte byte0 : md) {
                    str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                    str[k++] = hexDigits[byte0 & 0xf];
                }
                return new String(str);
            }catch(NoSuchAlgorithmException | UnsupportedEncodingException e){
                return null;
            }
        }
    
        /**
         * 根据api地址和参数生成请求URL
         * @param url
         * @param params
         * @return
         */
        public static String getUrlWithQueryString(String url, Map params) {
            if (params == null) {
                return url;
            }
    
            StringBuilder builder = new StringBuilder(url);
            if (url.contains("?")) {
                builder.append("&");
            } else {
                builder.append("?");
            }
    
            int i = 0;
            for (String key : (List<String>)params.keySet()) {
                String value = (String) params.get(key);
                if (value == null) { // 过滤空的key
                    continue;
                }
    
                if (i != 0) {
                    builder.append('&');
                }
    
                builder.append(key);
                builder.append('=');
                builder.append(encode(value));
    
                i++;
            }
    
            return builder.toString();
        }
    
        /**
         * 进行URL编码
         * @param input
         * @return
         */
        public static String encode(String input) {
            if (input == null) {
                return "";
            }
    
            try {
                return URLEncoder.encode(input, "utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
    
            return input;
        }
    }
    
    
    
    if(content.contains("翻译") && !"".equals(content)){
                    if(content.contains(":")){
                        String word = content.substring(content.lastIndexOf(":")+1,content.length()).trim();
                        YouDaoAPI translateInfo = new YouDaoAPI();
                        String weaInfo = translateInfo.translate(word);
                        result = buildTextMessage(map,weaInfo);
                    }else{
                        String notice = "翻译的正确姿势: 翻译:翻译文本\n请客官输入正确的格式哟~";
                        result = buildTextMessage(map,notice);
                    }
    

    image.png

    image.png

    10.发送emoji表情

    关于普通表情和emoji表情的处理可以参考:http://blog.csdn.net/frankcheng5143/article/details/64129433

    一般的表情是/:: 或者 [heart] 或者 空白的(其实是有特殊编码的), 所以此处我们要对emoji转换为unicode编码, 代码如下:

    package weChatServlet;
    
    import java.util.Formatter;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * emoji表情的工具类
     * 工具类中是将emoji转换为unicode编码,可以将其替换为图片,或者用空格过滤掉。
     */
    public class EmojiUtil {
    
        /**
         * 显示不可见字符的Unicode
         *
         * @param input
         * @return
         */
        public static String escapeUnicode(String input) {
            StringBuilder sb = new StringBuilder(input.length());
            @SuppressWarnings("resource")
            Formatter format = new Formatter(sb);
            for (char c : input.toCharArray()) {
                if (c < 128) {
                    sb.append(c);
                } else {
                    format.format("\\u%04x", (int) c);
                }
            }
            return sb.toString();
        }
    
        /**
         * 将emoji替换为unicode
         *
         * @param source
         * @return
         */
        public  String filterEmoji(String source) {
            if (source != null) {
                Pattern emoji = Pattern.compile("[\ue000-\uefff]", Pattern.CASE_INSENSITIVE);
                Matcher emojiMatcher = emoji.matcher(source);
                Map<String, String> tmpMap = new HashMap<>();
                while (emojiMatcher.find()) {
                    String key = emojiMatcher.group();
                    String value = escapeUnicode(emojiMatcher.group());
                    tmpMap.put(key, value);
                }
                if (!tmpMap.isEmpty()) {
                    for (Map.Entry<String, String> entry : tmpMap.entrySet()) {
                        String key = entry.getKey().toString();
                        String value = entry.getValue().toString();
                        source = source.replace(key, value);
                    }
                }
            }
            return source;
        }
    }
    
    

    在messageUtil中调用emoji工具类

    String content = map.get("Content");
    
    EmojiUtil emojiUtil = new EmojiUtil();
    String unicodeEmoji = emojiUtil.filterEmoji(content); //unicode编码的Emoji
    
    if(content.contains("/:")  || content.contains("\\:")  || content.contains("[") && content.contains("]") || unicodeEmoji.contains("\\")){
        result = buildTextMessage(map,"客官发送的内容很特别哟~/:heart    " + content);
    }
    
    

    结果如下:

    image.png

    展开全文
  • 微信公众号开发

    2018-03-21 10:19:41
    本课程作为学习微信开发的基础课程,详细介绍了微信开发的准备条件,以及如何申请一个微信公众账号,并在项目应用中如何成功接入微信开发的api接口,课程由浅入深,内容详实,非常适合新手学习。
  • 如果用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑。 现在,我们要实现一个微信内网页,通过微信访问网页时,网页会展示微信用户的个人信息。因为涉及...

    说明:该篇博客是博主一字一码编写的,实属不易,请尊重原创,谢谢大家!

    一丶概述

    • 微信网页授权

    如果用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑。

    现在,我们要实现一个微信内网页,通过微信访问网页时,网页会展示微信用户的个人信息。因为涉及到用户的个人信息,所以需要有用户授权才可以。当用户授权后,我们的网页服务器(开发者服务器)会拿到用户的“授权书”(code),我们用这个code向微信服务器领取访问令牌(accecc_token)和用户的身份号码(openid),然后凭借access_token和openid向微信服务器提取用户的个人信息。

    1. 第一步:用户同意授权,获取code
    2. 第二步:通过code换取网页授权access_token
    3. 第三步:拉取用户信息(需scope为 snsapi_userinfo)

    那么,如何拿到用户的授权code呢?

    授权是由微信发起让用户进行确认,在这个过程中是微信在与用户进行交互,所以用户应该先访问微信的内容,用户确认后再由微信将用户导向到我们的网页链接地址,并携带上code参数。我们把这个过程叫做网页回调,类似于我们在程序编写时用到的回调函数,都是回调的思想。

    • 关于网页授权回调域名的说明 

    1、在微信公众号请求用户网页授权之前,开发者需要先到公众平台官网中的“开发 - 接口权限 - 网页服务 - 网页帐号 - 网页授权获取用户基本信息”的配置选项中,修改授权回调域名。请注意,这里填写的是域名(是一个字符串),而不是URL,因此请勿加 http:// 等协议头;关于网页授权回调域名的说明

    2、授权回调域名配置规范为全域名,比如需要网页授权的域名为:www.qq.com,配置以后此域名下面的页面http://www.qq.com/music.html 、 http://www.qq.com/login.html 都可以进行OAuth2.0鉴权。但http://pay.qq.com 、 http://music.qq.com 、 http://qq.com无法进行OAuth2.0鉴权

    3、如果公众号登录授权给了第三方开发者来进行管理,则不必做任何设置,由第三方代替公众号实现网页授权即可。

    第一步:用户同意授权,获取code

    在确保微信公众账号拥有授权作用域(scope参数)的权限的前提下(服务号获得高级接口后,默认拥有scope参数中的snsapi_base和snsapi_userinfo),引导关注者打开如下页面:

    https://open.weixin.qq.com/connect/oauth2/authorize?appid=APPID&redirect_uri=REDIRECT_URI&response_type=code&scope=SCOPE&state=STATE#wechat_redirect

    尤其注意:由于授权操作安全等级较高,所以在发起授权请求时,微信会对授权链接做正则强匹配校验,如果链接的参数顺序不对,授权页面将无法正常访问

    参考链接(请在微信客户端中打开此链接体验):
    scope为snsapi_base
    https://open.weixin.qq.com/connect/oauth2/authorize?appid=wx520c15f417810387&redirect_uri=https%3A%2F%2Fchong.qq.com%2Fphp%2Findex.php%3Fd%3D%26c%3DwxAdapter%26m%3DmobileDeal%26showwxpaytitle%3D1%26vb2ctag%3D4_2030_5_1194_60&response_type=code&scope=snsapi_base&state=123#wechat_redirect
    scope为snsapi_userinfo
    https://open.weixin.qq.com/connect/oauth2/authorize?appid=wxf0e81c3bee622d60&redirect_uri=http%3A%2F%2Fnba.bluewebgame.com%2Foauth_response.php&response_type=code&scope=snsapi_userinfo&state=STATE#wechat_redirec

    尤其注意:跳转回调redirect_uri,应当使用https链接来确保授权code的安全性。

    参数说明

    参数 是否必须 说明
    appid 公众号的唯一标识
    redirect_uri 授权后重定向的回调链接地址, 请使用 urlEncode 对链接进行处理
    response_type 返回类型,请填写code
    scope 应用授权作用域,snsapi_base (不弹出授权页面,直接跳转,只能获取用户openid),snsapi_userinfo (弹出授权页面,可通过openid拿到昵称、性别、所在地。并且, 即使在未关注的情况下,只要用户授权,也能获取其信息 )
    state 重定向后会带上state参数,开发者可以填写a-zA-Z0-9的参数值,最多128字节
    #wechat_redirect 无论直接打开还是做页面302重定向时候,必须带此参数

     下图为scope等于snsapi_userinfo时的授权页面:

    用户同意授权后

    如果用户同意授权,页面将跳转至 redirect_uri/?code=CODE&state=STATE。

    code说明 : code作为换取access_token的票据,每次用户授权带上的code将不一样,code只能使用一次,5分钟未被使用自动过期。 

    第二步:通过code换取网页授权access_token

    首先请注意,这里通过code换取的是一个特殊的网页授权access_token,与基础支持中的access_token(该access_token用于调用其他接口)不同。公众号可通过下述接口来获取网页授权access_token。如果网页授权的作用域为snsapi_base,则本步骤中获取到网页授权access_token的同时,也获取到了openid,snsapi_base式的网页授权流程即到此为止。

    尤其注意:由于公众号的secret和获取到的access_token安全级别都非常高,必须只保存在服务器,不允许传给客户端。后续刷新access_token、通过access_token获取用户信息等步骤,也必须从服务器发起。

    请求方法

    获取code后,请求以下链接获取access_token:  https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code

    参数说明

    参数 是否必须 说明
    appid 公众号的唯一标识
    secret 公众号的appsecret
    code 填写第一步获取的code参数
    grant_type 填写为authorization_code

    返回说明

    正确时返回的JSON数据包如下:

    { "access_token":"ACCESS_TOKEN",
    "expires_in":7200,
    "refresh_token":"REFRESH_TOKEN",
    "openid":"OPENID",
    "scope":"SCOPE" }
    参数 描述
    access_token 网页授权接口调用凭证,注意:此access_token与基础支持的access_token不同
    expires_in access_token接口调用凭证超时时间,单位(秒)
    refresh_token 用户刷新access_token
    openid 用户唯一标识,请注意,在未关注公众号时,用户访问公众号的网页,也会产生一个用户和公众号唯一的OpenID
    scope 用户授权的作用域,使用逗号(,)分隔

     

    错误时微信会返回JSON数据包如下(示例为Code无效错误):

    {"errcode":40029,"errmsg":"invalid code"}

     第三步:拉取用户信息(需scope为 snsapi_userinfo)

    如果网页授权作用域为snsapi_userinfo,则此时开发者可以通过access_token和openid拉取用户信息了。

    请求方法

    http:GET(请使用https协议) https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID&lang=zh_CN

    参数说明

    参数 描述
    access_token 网页授权接口调用凭证,注意:此access_token与基础支持的access_token不同
    openid 用户的唯一标识
    lang 返回国家地区语言版本,zh_CN 简体,zh_TW 繁体,en 英语

    返回说明

    正确时返回的JSON数据包如下:

    {    "openid":" OPENID",
    " nickname": NICKNAME,
    "sex":"1",
    "province":"PROVINCE"
    "city":"CITY",
    "country":"COUNTRY",
    "headimgurl":    "http://thirdwx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/46",
    "privilege":[ "PRIVILEGE1" "PRIVILEGE2"     ],
    "unionid": "o6_bmasdasdsad6_2sgVt7hMZOPfL"
    }
    参数 描述
    openid 用户的唯一标识
    nickname 用户昵称
    sex 用户的性别,值为1时是男性,值为2时是女性,值为0时是未知
    province 用户个人资料填写的省份
    city 普通用户个人资料填写的城市
    country 国家,如中国为CN
    headimgurl 用户头像,最后一个数值代表正方形头像大小(有0、46、64、96、132数值可选,0代表640*640正方形头像),用户没有头像时该项为空。若用户更换头像,原有头像URL将失效。
    privilege 用户特权信息,json 数组,如微信沃卡用户为(chinaunicom)
    unionid 只有在用户将公众号绑定到微信开放平台帐号后,才会出现该字段。

    错误时微信会返回JSON数据包如下(示例为openid无效):

    {"errcode":40003,"errmsg":" invalid openid "}

     二丶代码实现

    • 思路分析
    • 首选在我们的flask程序中需要定义一个视图函数路由规则为/wechat8007/index,定义微信服务器重定向网址redirect_uri为服务器域名+/wechat8007/index(例如http://www.xxxx.com/wechat8007/index),通过访问微信提供的引导页面,让用户同意授权,然后重定向到我们定义的网址,此时微信服务器就会给我们的服务一个code,我们的服务器再通过code向微信服务器换取网页授权access_token(存取令牌),如果网页授权作用域为snsapi_userinfo,则此时可以通过access_token和openid拉取用户信息了。
    • step1 同意授权,这一块不需要代码实现,只需要提供授权链接即可
    • step2 定义视图函数,当用户同意授权,页面将跳转至 redirect_uri/?code=CODE&state=STATE ,在flask程序中定义一个是视图函数接口index,让用户同意授权后,去访问的视图
    • 上一篇博客定义的wechat视图,是由微信服务器访问,现在定义的index视图为用户访问的
    @app.route("/wechat8007/index")
    def index():
        """让用户通过微信访问的网页页面视图"""
    • step3  刚开始还没拉去用户资料时,可直接返回一个模板
    return render_template("index.html")
    • step4 从微信服务器中获取用户的资料数据,将用户的资料数据填充到index.html模板中
    • 1.获取code参数
    code = request.args.get("code")
    • 2.当code不存在时,返回字符串
    if not code:
        return u"缺失code参数"
    url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code" %(WECHAT_APPID,WECHAT_APPSECRET,code)
    
    response = urllib2.urlopen(url)
    
    # 获取响应体数据,微信返回的json数据
    json_str = response.read()
    resp_dict = json.loads(json_str)
    • 4.提取access_token,首先对获取到的响应体数据进行判断,如果不存在,直接返回提示字符串,存在则通过get方式拿去字典中的access_token键的值以及用户编号openid的值
    if "errcode" in resp_dict:
        return u"获取access_token失败"
    
    access_token = resp_dict.get("access_token")
    open_id = resp_dict.get("openid")  # 用户的编号
    • step5 向微信服务器发送http请求,获取用户的资料数据 
    url = "https://api.weixin.qq.com/sns/userinfo?access_token=%s&openid=%s&lang=zh_CN" %(access_token,open_id)
    
    response = urllib2.urlopen(url)
    
    # 读取微信传回的json的响应体数据
    user_json_str = response.read()
    user_dict_data = json.loads(user_json_str)
    • step6 判断微信返回的响应体数据中是否有errorcode字段,如果存在则返回失败信息,不存在说明微信返回的json数据为正确数据,则将该数据传给index.html模板,当用户访问 http://xxx/wechat8007/index地址时,会渲染出我们定义的index.html模板
    if "errcode" in user_dict_data:
        return u"获取用户信息失败"
    else:
        # 将用户的资料数据填充到页面中
        return render_template("index.html", user=user_dict_data)
    •  step7 当前目录下创建templates模板目录,在该目录中创建index.html文件 ,代码如下
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <title>{{user["nickname"]}}的个人主页</title>
    </head>
    <body>
        <img alt="头像" src="{{user['headimgurl']}}" width="60">
        <table>
            <tr>
                <th>openid</th>
                <td>{{user["openid"]}}</td>
            </tr>
            <tr>
                <th>昵称</th>
                <td>{{user["nickname"]}}</td>
            </tr>
            <tr>
                <th>性别</th>
                <td>
                    {% if 1 == user["sex"] %}
                        男
                    {% elif 2 == user["sex"] %}
                        女
                    {% else %}
                        未知
                    {% endif %}
                </td>
            </tr>
            <tr>
                <th>省份</th>
                <td>{{user["province"]}}</td>
            </tr>
            <tr>
                <th>城市</th>
                <td>{{user["city"]}}</td>
            </tr>
            <tr>
                <th>国家</th>
                <td>{{user["country"]}}</td>
            </tr>
        </table>
    </body>
    </html>

     三丶部署测试

    • step1 将代码推送到服务器上

    成功推送到服务器上

    •  step2 在服务器上进入虚拟环境,运行此程序

     

    In [1]: import urllib
    
    In [2]: urllib.quote("http://www.xxx.com/wechat8007/index")
    Out[2]: 'http%3A//www.xxx.com/wechat8007/index'
    
    
    

     

    • 拼接好的用户访问的url地址为

    • step4 可以将该网址生成二维码,使用微信扫一扫,也可以在接口公众号直接发送此链接地址
    •  使用谷歌浏览器的二维码插件,将网址生成对应的二维码(这里以百度首页网址为例)

    • 直接在浏览器中输入此地址会提示请在微信客户端打开链接

    •  step5 测试,在手机微信上打开此链接,出现授权登录提示,点击允许即可获取用户个人信息

    点击允许后,进入如下界面

    点击继续访问,则出现博主个人的微信信息了,如下图 

    此时查看服务器上程序运行日志 

    四丶完整代码

    # coding:utf-8
    from flask import Flask, request, render_template
    import json, urllib2
    
    
    WECHAT_APPID = "yourappid"
    WECHAT_APPSECRET = "yoursecret"
    
    app = Flask(__name__)
    
    
    
    @app.route("/wechat8007/index")
    def index():
    
        code = request.args.get("code")
    
        if not code:
            return u"缺失code参数"
    
        url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code" % (WECHAT_APPID, WECHAT_APPSECRET, code)
    
        response = urllib2.urlopen(url)
    
        json_str = response.read()
        resp_dict = json.loads(json_str)
    
        if "errcode" in resp_dict:
            return u"获取access_token失败"
    
        access_token = resp_dict.get("access_token")
        open_id = resp_dict.get("openid")
    
        url = "https://api.weixin.qq.com/sns/userinfo?access_token=%s&openid=%s&lang=zh_CN" % (access_token, open_id)
    
        response = urllib2.urlopen(url)
        user_json_str = response.read()
        user_dict_data = json.loads(user_json_str)
    
        if "errcode" in user_dict_data:
            return u"获取用户信息失败"
        else:
            return render_template("index.html", user=user_dict_data)
    
    
    if __name__ == '__main__':
        app.run(port=8007, debug=True)

    总结:微信公众号接口开发,根据官方提供的开发文档,进行开发,逻辑实现都很简单,多想多思考多练习,你会越来越棒的!

    展开全文
  • 微信公众平台开发之微信支付开发是子恒老师《微信公众平台开发》视频教程的第12部。...内容包含获取支付密钥,微信公众号支付开发,扫码支付,微信刷卡支付,异步处理支付结果等等。欢迎反馈,微信/QQ:68183131
  • 微信公众号开发之接收与发送消息

    万次阅读 2018-12-28 22:04:14
    说明:该篇博客是博主一字一码编写的,实属不易,请尊重原创,谢谢大家! ... 一丶概论 公众号接收与发送消息 ...如果公众号类型为服务号(订阅号只能使用普通消息接口),可以在公众平台网站中申请认证...

    说明:该篇博客是博主一字一码编写的,实属不易,请尊重原创,谢谢大家!

    在上一篇博客中已经验证了服务器有效性:https://blog.csdn.net/qq_41782425/article/details/85321424

    一丶概论

    • 公众号接收与发送消息

    验证URL有效性成功后即接入生效,成为开发者。如果公众号类型为服务号(订阅号只能使用普通消息接口),可以在公众平台网站中申请认证,认证成功的服务号将获得众多接口权限,以满足开发者需求。

    此后用户每次向公众号发送消息、或者产生自定义菜单点击事件时,开发者填写的服务器配置URL将得到微信服务器推送过来的消息和事件,然后开发者可以依据自身业务逻辑进行响应,例如回复消息等。

    用户向公众号发送消息时,公众号方收到的消息发送者是一个OpenID,是使用用户微信号加密后的结果,每个用户对每个公众号有一个唯一的OpenID。

    1.接收普通消息

    当普通微信用户向公众账号发消息时,微信服务器将POST消息的XML数据包到开发者填写的URL上。

    微信服务器在五秒内收不到响应会断掉连接,并且重新发起请求,总共重试三次。假如服务器无法保证在五秒内处理并回复,可以直接回复空串,微信服务器不会对此作任何处理,并且不会发起重试。

    各消息类型的推送使用XML数据包结构,如:

    <xml>
    <ToUserName><![CDATA[gh_866835093fea]]></ToUserName>
    <FromUserName><![CDATA[ogdotwSc_MmEEsJs9-ABZ1QL_4r4]]></FromUserName>
    <CreateTime>1478317060</CreateTime>
    <MsgType><![CDATA[text]]></MsgType>
    <Content><![CDATA[你好]]></Content>
    <MsgId>6349323426230210995</MsgId>
    </xml>

    注意:<![CDATA 与 ]]> 括起来的数据不会被xml解析器解析 

    2.普通消息类别

    1. 文本消息
    2. 图片消息
    3. 语音消息
    4. 视频消息
    5. 小视频消息
    6. 地理位置消息
    7. 链接消息

    文本消息

     <xml>
     <ToUserName><![CDATA[toUser]]></ToUserName>
     <FromUserName><![CDATA[fromUser]]></FromUserName> 
     <CreateTime>1348831860</CreateTime>
     <MsgType><![CDATA[text]]></MsgType>
     <Content><![CDATA[this is a test]]></Content>
     <MsgId>1234567890123456</MsgId>
     </xml>

    3. 回复的消息类型

    1. 文本消息
    2. 图片消息
    3. 语音消息
    4. 视频消息
    5. 音乐消息
    6. 图文消息

    回复文本消息

    <xml>
    <ToUserName><![CDATA[toUser]]></ToUserName>
    <FromUserName><![CDATA[fromUser]]></FromUserName>
    <CreateTime>12345678</CreateTime>
    <MsgType><![CDATA[text]]></MsgType>
    <Content><![CDATA[你好]]></Content>
    </xml>
    

     注:开发文档可以到 https://mp.weixin.qq.com/wiki/home/index.html  进行阅读查看

    二丶代码实现

    需求:我们现在来实现一个针对文本消息的收发程序。实现的业务逻辑,关注者发什么内容,我们就传回给什么内容。

    说明:微信服务器推送消息还是往/wechat/8007,所以在之前代码上进行修改即可

    1.开发步骤

    • step1 如何区分微信服务器发过来的是第一次的验证操作还是消息操作
    • 验证操作为GET请求,消息操作为POST请求
    @app.route("/wechat8007", methods=["GET", "POST"])
    • step2 参数变更,echostr参数只是在第一次验证的时候需要,无论是POST请求还是GET请求这三种参数都必要要,因为需要验证是不是微信服务器发送过来的数据
    signature = request.args.get("signature")
    timestamp = request.args.get("timestamp")
    nonce = request.args.get("nonce")
    • step3 对微信服务器发送的请求进行验证判断,如果是GET请求,那么代表是第一次的验证操作,那么就需要获取echostr字段的内容,如果内容为空则抛出404,存在则返回echostr
    if request.method == "GET":
        # 表示是第一次接入微信服务器的验证
        echostr = request.args.get("echostr")
        if not echostr:
            abort(404)
        return echostr
    • step4  如果为POST请求,那么代表为微信服务器转发消息过来,获取请求中的data xml数据 ,数据为空抛出400
    elif request.method == "POST":
        # 表示微信服务器转发消息过来
        xml_str = request.data
        if not xml_str:
            abort(400)
    • step5 将对获取的数据进行解析,通过xmltodict模块中的parse方法将字符串类型的xml数据,转换成字典类型的xml格式数据,因为xml数据最外层有一个<xml></xml>标签,通过get方式获取标签里的内容,再通过get获取内容中的MsgType消息类型字段的值
    # 对xml字符串进行解析
    xml_dict = xmltodict.parse(xml_str)
    xml_dict = xml_dict.get("xml")
    
    # 提取消息类型
    msg_type = xml_dict.get("MsgType")
    • step6 对消息类型进行判断,如果为text文本消息,则返回文本消息,不是文本消息还是返回文本消息,这里可以拓展为(image,voice,video等等可以查看开发文档),这里为了演示,就简单写写
     if msg_type == "text":
        # 表示发送的是文本消息
        # 构造返回值,经由微信服务器回复给用户的消息内容
        resp_dict = {
            "xml": {
                "ToUserName": xml_dict.get("FromUserName"),
                "FromUserName": xml_dict.get("ToUserName"),
                "CreateTime": int(time.time()),
                "MsgType": "text",
                "Content": "taogang say:" + xml_dict.get("Content")
            }
        }
    else:
        resp_dict = {
            "xml": {
                "ToUserName": xml_dict.get("FromUserName"),
                "FromUserName": xml_dict.get("ToUserName"),
                "CreateTime": int(time.time()),
                "MsgType": "text",
                "Content": "Dear I Love you so much"
            }
        }
    • step7 最后将我们构造的响应返回值通过unparse方法转换成xml格式的字符串,返回给微信服务器
    # 将字典转换为xml字符串
    resp_xml_str = xmltodict.unparse(resp_dict)
    # 返回消息数据给微信服务器
    return resp_xml_str

    2.部署测试

    • step1 将代码推送到服务器上

    • step2 在服务器上进入虚拟环境,运行此程序

    • step3 进入微信公众平台,用手机扫描测试号二维码,进行关注测试

    扫码后进行关注 

    关注后进入此公众号,公众号则发送我们在开发步骤step 6,Dear I Love you so much 消息内容

    回到服务器程序运行日志上,显示为POST请求,说明程序逻辑完全没问题

    公众号测试平台用户列表将我的微信添加上去了

    • step4 测试,在关注的此公众中,进行消息(文本,表情,语言,图片,视频)发送,当消息类型为文本时,即返回此消息内容,如果不是都是返回文本类型,内容为Dear I Love you so much

     

    此时的服务器代码运行日志

    3.完整代码

    # coding:utf-8
    from flask import Flask, request, abort, render_template
    import hashlib
    import xmltodict, time
    
    
    # 常量
    # 微信的token令牌
    WECHAT_TOKEN = "cdtaogang"
    
    
    app = Flask(__name__)
    
    
    @app.route("/wechat8007", methods=["GET", "POST"])
    def wechat():
        """对接微信公众号服务器"""
        # 接收微信服务器发送的参数
        signature = request.args.get("signature")
        timestamp = request.args.get("timestamp")
        nonce = request.args.get("nonce")
    
        if not all([signature, timestamp, nonce]):
            abort(400)
    
        # 按照微信的流程进行计算签名
        li = [WECHAT_TOKEN, timestamp, nonce]
        # 排序
        li.sort()
        # 拼接字符串
        tmp_str = ''.join(li)
        # 进行sha1加密, 得到正确的签名值
        sign = hashlib.sha1(tmp_str).hexdigest()
        # 将自己计算的签名值与请求的签名参数进行对比,如果相同,则证明请求来自微信服务器
        if sign != signature:
            # 表示请求不是微信发的
            abort(403)
        else:
            # 表示是微信发送的请求
            if request.method == "GET":
                # 表示是第一次接入微信服务器的验证
                echostr = request.args.get("echostr")
                if not echostr:
                    abort(404)
                return echostr
            elif request.method == "POST":
                # 表示微信服务器转发消息过来
                xml_str = request.data
                if not xml_str:
                    abort(400)
    
                # 对xml字符串进行解析
                xml_dict = xmltodict.parse(xml_str)
                xml_dict = xml_dict.get("xml")
    
                # 提取消息类型
                msg_type = xml_dict.get("MsgType")
    
                if msg_type == "text":
                    # 表示发送的是文本消息
                    # 构造返回值,经由微信服务器回复给用户的消息内容
                    resp_dict = {
                        "xml": {
                            "ToUserName": xml_dict.get("FromUserName"),
                            "FromUserName": xml_dict.get("ToUserName"),
                            "CreateTime": int(time.time()),
                            "MsgType": "text",
                            "Content": "taogang say:" + xml_dict.get("Content")
                        }
                    }
                else:
                    resp_dict = {
                        "xml": {
                            "ToUserName": xml_dict.get("FromUserName"),
                            "FromUserName": xml_dict.get("ToUserName"),
                            "CreateTime": int(time.time()),
                            "MsgType": "text",
                            "Content": "Dear I Love you so much"
                        }
                    }
                # 将字典转换为xml字符串
                resp_xml_str = xmltodict.unparse(resp_dict)
                # 返回消息数据给微信服务器
                return resp_xml_str
    
    if __name__ == '__main__':
        app.run(port=8007, debug=True)

     

    展开全文
  • 微信公众平台开发之公众号JSSDK开发是子恒...详细讲解了用php开发微信公众号,对微信公众平台中的JSSDK开发。内容包含用JSSDK获取网络状态,地理位置,分享到朋友圈,QQ,空间设置等等。欢迎反馈,微信/QQ:68183131
  • Java微信公众号开发毕业论文,农业微信推广平台,大概功能如下: (1)知识库查询,通过回复微信公众号或选择菜单查询相关农业知识; (2)新闻的推送和热点公告的通知,主要为与农业政策相关的信息和专家用户工作的...
  • 微信公众平台开发之微信编辑器开发是子恒老师《微信公众平台开发》视频教程的第11部。...内容包含微信公众号编辑器开发思路,编辑器前端页面,功能实现,添加新样式等等。欢迎反馈,微信号:QQ68183131
  • 微信公众号开发-开发后台设计

    万人学习 2016-07-19 09:27:37
    微信公众号开发-开发后台设计》是子恒老师出品的微信公众号开发系列之一,这套视频教程,使用响应式网站的模式,帮你设计好开发后台,让你在后续的微信公众号开发中更高效。欢迎反馈,QQ/微信:68183131
  • 微信公众号开发基本流程

    万次阅读 多人点赞 2019-04-07 16:46:18
    过年前后做了个微信公众号项目,已经过去一段时间了,抽空回忆总结下基本流程吧,不然很快估计自己就忘了。。 微信公众平台官网:https://mp.weixin.qq.com 文章目录一、注册公众号二、了解公众号管理页面三、必备...
  • 微信公众号开发,原来这么简单?[java框架]

    万次阅读 多人点赞 2016-12-15 22:13:52
    Wx-tools是基于微信公众平台API的轻量级框架。 基于Wx-tools你可以开速开发一个订阅号/服务号的web应用后台。 博主最近终于有空!!已经更新到2.1.0啦!! GitHub仓库 下载wx-tools-2.1.0.jar wx-tools开发...
  • 微信公众号开发(一)服务器及接口的配置

    万次阅读 多人点赞 2017-09-04 01:44:20
    微信公众号开发(一)服务器及接口的配置 关于微信公众号中的订阅号和服务的区别这里不多加讨论,网上有很多资源可以搜到,这里直接进入正题,如果是个人开发者,这里建议使用测试号进行开发学习,测试号的权限要比...

空空如也

1 2 3 4 5 ... 20
收藏数 20,264
精华内容 8,105
关键字:

微信公众号开发