微信开发菜单 指定素材_微信开发微信素材获取封面图 - CSDN
  • 微信公众号获取指定菜单发送的素材数据 需求:获取指定公众号菜单中所编辑并发布的全部永久素材数据。其他主题栏中的均不要! 思路 微信中只有返回全部素材的接口,并没有其他的参数,并不能区分特定栏所发布的...

    微信公众号获取指定菜单发送的素材数据

    需求:获取指定公众号菜单中所编辑并发布的全部永久素材数据。其他主题栏中的均不要!

    思路

    微信中只有返回全部素材的接口,并没有其他的参数,并不能区分特定栏所发布的数据。仔细观察发布永久素材时需要添加作者,这便是关键字段。利用这个作者名称进行区分指定菜单栏所发布的永久素材。因此,我们便可以对获取到的所有素材数据进行筛选,便可满足需求。

    编程环境(java、springboot)

    笔者是JAVA,因此在这里给出Java的代码。

    1、获取所有永久素材
    步骤:
    1)获取access_token, springboot 启动便获取access_token,因为access_token有效时长是2个小时,而每次启动项目都会刷新access_token,导致其他地方采用access_token的会代码会失效。因此我们在代码中设置,只有在正式环境时才进行启动刷新access_token。其余环境开发时不需要刷新access_token,而access_token过期才会动态的重新获取access_token。

    启动获取access_token。
    在这里插入图片描述
    设置acess_token动态变量:
    在这里插入图片描述在这里插入图片描述
    access_token 失效,定时2小时去重新获取access_token
    在这里插入图片描述
    2)获取全部素材
    在这里插入图片描述

    工具集

    截图里的:httpClientUtil.doPostJson方法
    在这里插入图片描述
    截图里的 httpClientUtil.doGet方法:
    在这里插入图片描述
    Constant.java (获取access_token 时的Constant 类)

    // 公众号获取素材url
    public static final String XS_GET_MATERIAL_LIST = “https://api.weixin.qq.com/cgi-bin/material/batchget_material?access_token=”;

    // 微信公众号APPID和APPsecret
    public static final String XS_APP_ID = “”;
    public static final String XS_APP_SECRET = “”;

    以上便可以获取到所有的微信公众号永久素材; 获取的json格式是下面的这种形式。我们只需要对这个json进行处理比对。以author进行区分便可获取指定的数据。
    在这里插入图片描述
    代码整理为:
    在这里插入图片描述
    获取结果为:
    在这里插入图片描述
    ResultUtils.java方法为接口统一返回结果:
    在这里插入图片描述
    ResultEntity.java是包裹的接口返回实体:
    在这里插入图片描述

    展开全文
  • 自定义菜单创建接口: http请求方式:POST(请使用https协议)https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN 自定义菜单查询接口: http请求方式:GET...

     

    自定义菜单创建接口:

    http请求方式:POST(请使用https协议) https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN

    自定义菜单查询接口:

    http请求方式:GET https://api.weixin.qq.com/cgi-bin/menu/get?access_token=ACCESS_TOKEN

    自定义菜单删除接口:

    http请求方式:GET https://api.weixin.qq.com/cgi-bin/menu/delete?access_token=ACCESS_TOKEN

    自定义菜单接口可实现多种类型按钮,如下:

    1、click:点击推事件
    用户点击click类型按钮后,微信服务器会通过消息接口推送消息类型为event    的结构给开发者(参考消息接口指南),并且带上按钮中开发者填写的key值,开发者可以通过自定义的key值与用户进行交互;
    2、view:跳转URL
    用户点击view类型按钮后,微信客户端将会打开开发者在按钮中填写的网页URL,可与网页授权获取用户基本信息接口结合,获得用户基本信息。
    3、scancode_push:扫码推事件
    用户点击按钮后,微信客户端将调起扫一扫工具,完成扫码操作后显示扫描结果(如果是URL,将进入URL),且会将扫码的结果传给开发者,开发者可以下发消息。
    4、scancode_waitmsg:扫码推事件且弹出“消息接收中”提示框
    用户点击按钮后,微信客户端将调起扫一扫工具,完成扫码操作后,将扫码的结果传给开发者,同时收起扫一扫工具,然后弹出“消息接收中”提示框,随后可能会收到开发者下发的消息。
    5、pic_sysphoto:弹出系统拍照发图
    用户点击按钮后,微信客户端将调起系统相机,完成拍照操作后,会将拍摄的相片发送给开发者,并推送事件给开发者,同时收起系统相机,随后可能会收到开发者下发的消息。
    6、pic_photo_or_album:弹出拍照或者相册发图
    用户点击按钮后,微信客户端将弹出选择器供用户选择“拍照”或者“从手机相册选择”。用户选择后即走其他两种流程。
    7、pic_weixin:弹出微信相册发图器
    用户点击按钮后,微信客户端将调起微信相册,完成选择操作后,将选择的相片发送给开发者的服务器,并推送事件给开发者,同时收起相册,随后可能会收到开发者下发的消息。
    8、location_select:弹出地理位置选择器
    用户点击按钮后,微信客户端将调起地理位置选择工具,完成选择操作后,将选择的地理位置发送给开发者的服务器,同时收起位置选择工具,随后可能会收到开发者下发的消息。
    9、media_id:下发消息(除文本消息)
    用户点击media_id类型按钮后,微信服务器会将开发者填写的永久素材id对应的素材下发给用户,永久素材类型可以是图片、音频、视频、图文消息。请注意:永久素材id必须是在“素材管理/新增永久素材”接口上传后获得的合法id。
    10、view_limited:跳转图文消息URL
    用户点击view_limited类型按钮后,微信客户端将打开开发者在按钮中填写的永久素材id对应的图文消息URL,永久素材类型只支持图文消息。请注意:永久素材id必须是在“素材管理/新增永久素材”接口上传后获得的合法id。

    请注意,3到8的所有事件,仅支持微信iPhone5.4.1以上版本,和Android5.4以上版本的微信用户,旧版本微信用户点击后将没有回 应,开发者也不能正常接收到事件推送。9和10,是专门给第三方平台旗下未微信认证(具体而言,是资质认证未通过)的订阅号准备的事件类型,它们是没有事 件推送的,能力相对受限,其他类型的公众号不必使用。

    click和view的请求示例

    {
         "button":[
         {    
              "type":"click",
              "name":"今日",
              "key":"1"
          },
          {
               "name":"菜单",
               "sub_button":[
               {    
                   "type":"view",
                   "name":"搜索",
                   "url":"http://www.soso.com/"
                },
                {
                   "type":"view",
                   "name":"视频",
                   "url":"http://v.qq.com/"
                },
                {
                   "type":"click",
                   "name":"测试",
                   "key":"2"
                }]
           }]
     }

    其他新增按钮类型的请求示例

    {
        "button": [
            {
                "name": "扫码", 
                "sub_button": [
                    {
                        "type": "scancode_waitmsg", 
                        "name": "扫码带提示", 
                        "key": "rselfmenu_0_0", 
                        "sub_button": [ ]
                    }, 
                    {
                        "type": "scancode_push", 
                        "name": "扫码推事件", 
                        "key": "rselfmenu_0_1", 
                        "sub_button": [ ]
                    }
                ]
            }, 
            {
                "name": "发图", 
                "sub_button": [
                    {
                        "type": "pic_sysphoto", 
                        "name": "系统拍照发图", 
                        "key": "rselfmenu_1_0", 
                       "sub_button": [ ]
                     }, 
                    {
                        "type": "pic_photo_or_album", 
                        "name": "拍照或者相册发图", 
                        "key": "rselfmenu_1_1", 
                        "sub_button": [ ]
                    }, 
                    {
                        "type": "pic_weixin", 
                        "name": "微信相册发图", 
                        "key": "rselfmenu_1_2", 
                        "sub_button": [ ]
                    }
                ]
            }, 
            {
                "name": "发送位置", 
                "type": "location_select", 
                "key": "rselfmenu_2_0"
            },
            {
               "type": "media_id", 
               "name": "图片", 
               "media_id": "MEDIA_ID1"
            }, 
            {
               "type": "view_limited", 
               "name": "图文消息", 
               "media_id": "MEDIA_ID2"
            }
        ]
    }

    参数说明

    参数 是否必须 说明
    button 一级菜单数组,个数应为1~3个
    sub_button 二级菜单数组,个数应为1~5个
    type 菜单的响应动作类型
    name 菜单标题,不超过16个字节,子菜单不超过40个字节
    key click等点击类型必须 菜单KEY值,用于消息接口推送,不超过128字节
    url view类型必须 网页链接,用户点击菜单可打开链接,不超过256字节
    media_id media_id类型和view_limited类型必须 调用新增永久素材接口返回的合法media_id


    返回结果

    正确时的返回JSON数据包如下:{"errcode":0,"errmsg":"ok"}

    错误时的返回JSON数据包如下(示例为无效菜单名长度):{"errcode":40018,"errmsg":"invalid button name size"}

    根据以上的信息,我们进行封装一下菜单。

    我们现在能用的是一个点击click(点击事件)和view(访问网页)这俩种类型。

    代码实现:

    首先是 菜单项的基类,所有一级菜单、二级菜单都共有一个相同的属性,那就是name。菜单项基类的封装代码如下:

    package cn.com.comit.appointment.modules.wechat.message.menu;
    
    
    /**
    * 类名: Button </br>
    * 描述: 菜单项的基类  </br>
     */
    public class Button {
        
        private String name;//所有一级菜单、二级菜单都共有一个相同的属性,那就是name
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    接着是子菜单项的封装。这里对子菜单是这样定义的:没有子菜单的菜单项,有可能是二级菜单项,也有可能是不含二级菜单的一级菜单。这类子菜单项一定会包含三个属性:type、name和key,封装的代码如下:

    package cn.com.comit.appointment.modules.wechat.message.menu;
    
    
    /**
    * 类名: CommonButton </br>
    * 描述: 子菜单项 :没有子菜单的菜单项,有可能是二级菜单项,也有可能是不含二级菜单的一级菜单。 </br>
     */
    public class CommonButton extends Button {
        
        private String type;
        private String key;
        
    
    	public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    }
    
    package cn.com.comit.appointment.modules.wechat.message.menu;
    
    /**
     * view按钮
     *
     */
    public class ViewButton extends Button{
    	
    	 private String type;
    	 private String url;
    	public String getType() {
    		return type;
    	}
    	public void setType(String type) {
    		this.type = type;
    	}
    	public String getUrl() {
    		return url;
    	}
    	public void setUrl(String url) {
    		this.url = url;
    	}
    	 
    	 
    
    }
    

     再往下是父菜单项的封装。对父菜单项的定义:包含有二级菜单项的一级菜单。这类菜单项包含有二个属性:name和sub_button,而sub_button以是一个子菜单项数组。父菜单项的封装代码如下:

    package cn.com.comit.appointment.modules.wechat.message.menu;
    
    
    /**
    * 类名: ComplexButton </br>
    * 描述: 父菜单项 :包含有二级菜单项的一级菜单。这类菜单项包含有二个属性:name和sub_button,而sub_button以是一个子菜单项数组 </br>
     */
    public class ComplexButton extends Button {
        private Button[] sub_button;
    
        public Button[] getSub_button() {
            return sub_button;
        }
    
        public void setSub_button(Button[] sub_button) {
            this.sub_button = sub_button;
        }
    }

    最后是整个菜单对象的封装,菜单对象包含多个菜单项(最多只能有3个),这些菜单项即可以是子菜单项(不含二级菜单的一级菜单),也可以是父菜单项(包含二级菜单的菜单项),如果能明白上面所讲的,再来看封装后的代码就很容易理解了:

    package cn.com.comit.appointment.modules.wechat.message.menu;
    
    
    /**
    * 类名: Menu </br>
    * 描述: 整个菜单对象的封装 </br>
     */
    public class Menu {
        private Button[] button;
    
        public Button[] getButton() {
            return button;
        }
    
        public void setButton(Button[] button) {
            this.button = button;
        }
    }
    

    AccessToken 的POJO的封装:详情可以看微信公众号开发之获取公众号的access_token

    package cn.com.comit.appointment.modules.wechat.entity;
    
    
    /**
    * 类名: AccessToken </br>
    * 描述: 微信通用接口凭证  </br>
     */
    public class AccessToken {
        // 获取到的凭证
        private String token;
        // 凭证有效时间,单位:秒
        private int expiresIn;
    
        public String getToken() {
            return token;
        }
    
        public void setToken(String token) {
            this.token = token;
        }
    
        public int getExpiresIn() {
            return expiresIn;
        }
    
        public void setExpiresIn(int expiresIn) {
            this.expiresIn = expiresIn;
        }
    }
    

    封装通用的请求方法

    读到这里,就默认大家已经掌握了上面讲到的所有关于自定义菜单的理论知识,下面就进入代码实战讲解的部分。

    先前我们了解到,创建菜单需要调用二个接口,并且都是https请求,而非http。如果要封装一个通用的请求方法,该方法至少需要具备以下能力:

    1)支持HTTPS请求;

    2)支持GET、POST两种方式;

    3)支持参数提交,也支持无参数的情况;

    对于https请求,我们需要一个证书信任管理器,这个管理器类需要自己定义,但需要实现X509TrustManager接口,代码如下:

    package cn.com.comit.appointment.modules.wechat.utils;
    
    
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import javax.net.ssl.X509TrustManager;
    
    /**
    * 类名: MyX509TrustManager </br>
    * 描述: 信任管理器 </br>
     */
    public class MyX509TrustManager implements X509TrustManager {
    
        // 检查客户端证书
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    
        // 检查服务器端证书
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    
        // 返回受信任的X509证书数组
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    }
    

    这个证书管理器的作用就是让它信任我们指定的证书,上面的代码意味着信任所有证书,不管是否权威机构颁发。

    证书有了,通用的https请求方法就不难实现了,实现代码如下:

    package cn.com.comit.appointment.modules.wechat.utils;
    
    
    import java.io.BufferedReader;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.ConnectException;
    import java.net.URL;
    
    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManager;
    
    import net.sf.json.JSONException;
    import net.sf.json.JSONObject;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import cn.com.comit.appointment.modules.wechat.entity.AccessToken;
    import cn.com.comit.appointment.modules.wechat.message.menu.Menu;
    
    
    /**
    * 类名: WeixinUtil </br>
    * 描述: 公众平台通用接口工具类 </br>
     */
    public class WeixinUtil {
        
        private static Logger log = LoggerFactory.getLogger(WeixinUtil.class);
        
        // 获取access_token的接口地址(GET) 限200(次/天)
        public final static String access_token_url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";
        
        // 菜单创建(POST) 限100(次/天)
        public static String menu_create_url = "https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN";
    
        
        
        
        /**
         * 创建菜单
         * 
         * @param menu 菜单实例
         * @param accessToken 有效的access_token
         * @return 0表示成功,其他值表示失败
         */
        public static int createMenu(Menu menu, String accessToken) {
            int result = 0;
            // 拼装创建菜单的url
            String url = menu_create_url.replace("ACCESS_TOKEN", accessToken);
            // 将菜单对象转换成json字符串
            String jsonMenu = JSONObject.fromObject(menu).toString();
            System.out.println("cs-->"+jsonMenu);
            // 调用接口创建菜单
            JSONObject jsonObject = httpRequest(url, "POST", jsonMenu);
            if (null != jsonObject) {
                if (0 != jsonObject.getInt("errcode")) {
                    result = jsonObject.getInt("errcode");
                    log.error("创建菜单失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
                }
            }
    
            return result;
        }
        
        
        /**
         * 获取access_token
         * 
         * @param appid 凭证
         * @param appsecret 密钥
         * @return
         */
        public static AccessToken getAccessToken(String appid, String appsecret) {
            AccessToken accessToken = null;
    
            String requestUrl = access_token_url.replace("APPID", appid).replace("APPSECRET", appsecret);
            JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
            // 如果请求成功
            if (null != jsonObject) {
                try {
                    accessToken = new AccessToken();
                    accessToken.setToken(jsonObject.getString("access_token"));
                    accessToken.setExpiresIn(jsonObject.getInt("expires_in"));
                } catch (JSONException e) {
                    accessToken = null;
                    // 获取token失败
                    log.error("获取token失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
                }
            }
            return accessToken;
        }
        
        
        /**
         * 描述:  发起https请求并获取结果
         * @param requestUrl 请求地址
         * @param requestMethod 请求方式(GET、POST)
         * @param outputStr 提交的数据
         * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值)
         */
        public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {
            JSONObject jsonObject = null;
            StringBuffer buffer = new StringBuffer();
            try {
                // 创建SSLContext对象,并使用我们指定的信任管理器初始化
                TrustManager[] tm = { new MyX509TrustManager() };
                SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
                sslContext.init(null, tm, new java.security.SecureRandom());
                // 从上述SSLContext对象中得到SSLSocketFactory对象
                SSLSocketFactory ssf = sslContext.getSocketFactory();
    
                URL url = new URL(requestUrl);
                HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
                httpUrlConn.setSSLSocketFactory(ssf);
    
                httpUrlConn.setDoOutput(true);
                httpUrlConn.setDoInput(true);
                httpUrlConn.setUseCaches(false);
                
                // 设置请求方式(GET/POST)
                httpUrlConn.setRequestMethod(requestMethod);
    
                if ("GET".equalsIgnoreCase(requestMethod))
                    httpUrlConn.connect();
    
                // 当有数据需要提交时
                if (null != outputStr) {
                    OutputStream outputStream = httpUrlConn.getOutputStream();
                    // 注意编码格式,防止中文乱码
                    outputStream.write(outputStr.getBytes("UTF-8"));
                    outputStream.close();
                }
    
                // 将返回的输入流转换成字符串
                InputStream inputStream = httpUrlConn.getInputStream();
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
    
                String str = null;
                while ((str = bufferedReader.readLine()) != null) {
                    buffer.append(str);
                }
                bufferedReader.close();
                inputStreamReader.close();
                // 释放资源
                inputStream.close();
                inputStream = null;
                httpUrlConn.disconnect();
                jsonObject = JSONObject.fromObject(buffer.toString());
            } catch (ConnectException ce) {
                log.error("Weixin server connection timed out.");
            } catch (Exception e) {
                log.error("https request error:{}", e);
            }
            return jsonObject;
        }
    }
    

    添加菜单管理器:注意替换称自己公众号的appId和appSecret。

    package cn.com.comit.appointment.modules.wechat.test;
    
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import cn.com.comit.appointment.modules.wechat.entity.AccessToken;
    import cn.com.comit.appointment.modules.wechat.message.menu.Button;
    import cn.com.comit.appointment.modules.wechat.message.menu.CommonButton;
    import cn.com.comit.appointment.modules.wechat.message.menu.ComplexButton;
    import cn.com.comit.appointment.modules.wechat.message.menu.Menu;
    import cn.com.comit.appointment.modules.wechat.message.menu.ViewButton;
    import cn.com.comit.appointment.modules.wechat.utils.WeixinUtil;
    
    
    /**
    * 类名: MenuManager </br>
    * 描述:菜单管理器类 </br>
     */
    public class MenuManager {
        private static Logger log = LoggerFactory.getLogger(MenuManager.class);
    
        public static void main(String[] args) {
            // 第三方用户唯一凭证
            String appId = "你公众号的appId";
            // 第三方用户唯一凭证密钥
            String appSecret = "你公众号的appSecret";
    
            // 调用接口获取access_token
            AccessToken at = WeixinUtil.getAccessToken(appId, appSecret);
    
            if (null != at) {
                // 调用接口创建菜单
                int result = WeixinUtil.createMenu(getMenu(), at.getToken());
    
                // 判断菜单创建结果
                if (0 == result)
                    log.info("菜单创建成功!");
                else
                    log.info("菜单创建失败,错误码:" + result);
            }
        }
    
        /**
         * 组装菜单数据
         * 
         * @return
         */
        private static Menu getMenu() {
           
    
    
            ViewButton btn21 = new ViewButton();
            btn21.setName("百度");
            btn21.setType("view");
            btn21.setUrl("http://www.baidu.com");
    
            ViewButton btn22 = new ViewButton();
            btn22.setName("官方链接");
            btn22.setType("view");
            btn22.setUrl("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");
            
            ViewButton btn23 = new ViewButton();
            btn23.setName("查询");
            btn23.setType("view");
            btn23.setUrl("https://open.weixin.qq.com/connect/oauth2/authorize?appid=wx44eb1076428bc798&redirect_uri=http://992nkr.natappfree.cc/appointment/wechat/toAppoin/oauth&response_type=code&scope=snsapi_userinfo&state=123#wechat_redirect");
            
            ViewButton btn24 = new ViewButton();
            btn24.setName("查询2");
            btn24.setType("view");
            btn24.setUrl("https://open.weixin.qq.com/connect/oauth2/authorize?appid=wx44eb1076428bc798&redirect_uri=http%3a%2f%2fgb4xrs.natappfree.cc%2fappointment%2fwechat%2ftoAppoin%2foauth&response_type=code&scope=snsapi_base&state=123#wechat_redirect");
            
         ViewButton btn25 = new ViewButton();
            btn25.setName("登录");
            btn25.setType("view");
            btn25.setUrl("http://gb4xrs.natappfree.cc/appointment/sys/login.view");
            
          /*  ViewButton btn26 = new ViewButton();
            btn26.setName("测试");
            btn26.setType("view");
            btn26.setUrl("http://ytuwpp.natappfree.cc/appointment/wechat/toAppoin/toAppointInit");
            */
            
    
            CommonButton btn33 = new CommonButton();
            btn33.setName("幽默笑话");
            btn33.setType("click");
            btn33.setKey("33");
    
            
            /**
             * 微信:  mainBtn1,mainBtn2,mainBtn3底部的三个一级菜单。
             */
            
            ComplexButton mainBtn1 = new ComplexButton();
            mainBtn1.setName("违章查询");
            //一级下有4个子菜单
            mainBtn1.setSub_button(new ViewButton[] { btn21 });
            
            ComplexButton mainBtn2 = new ComplexButton();
            mainBtn2.setName("菜单");
            mainBtn2.setSub_button(new ViewButton[] {btn22,btn23,btn24,btn25 });
    
            
            ComplexButton mainBtn3 = new ComplexButton();
            mainBtn3.setName("更多体验");
            mainBtn3.setSub_button(new CommonButton[] {  btn33 });
    
            
            
            /**
             * 封装整个菜单
             */
            Menu menu = new Menu();
            menu.setButton(new Button[] { mainBtn1, mainBtn2, mainBtn3 });
    
            return menu;
        }
    }
    

    最后直接执行MenuManager 的main 方法即可。

    点击菜单中登录的按钮就跳转到我本地ssm项目的登录页面了,ssm是在本地run起来的。

    菜单跳转的url是你的域名+项目+访问路径。详情可以看微信公众号开发需要准备的一些资料以及如何搭建一个本地测试服务环境

    效果:

    在公众号点击登录菜单在手机上跳转:

     

    在浏览器打开登录的url:

     

     

    我的座右铭:不会,我可以学;落后,我可以追赶;跌倒,我可以站起来;我一定行。

     

    展开全文
  • 微信开发与代码的编写(一) 微信开发环境的搭建 目前移动开发处于比较火的的趋势,很多的开发者都跃跃欲试,目前移动App开发领域主要分为以下几种类型    我在平时的工作中接触得比较多的就是基于Android的Native...

    微信开发与代码的编写(一)

    微信开发环境的搭建

    目前移动开发处于比较火的的趋势,很多的开发者都跃跃欲试,目前移动App开发领域主要分为以下几种类型

      

      我在平时的工作中接触得比较多的就是基于Android的Native App开发和基于微信公众号的Light App开发,今天就来带领大家快速进入微信公众号的开发领域.

    微信开发环境搭建

      工欲善其事,必先利其器。要做微信公众号开发,那么要先准备好两样必不可少的东西:

      1、要有一个用来测试的公众号。

      2、用来调式代码的开发环境。

     

    注册测试公众号

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

      我们所说的微信公众号开发指的是订阅号和服务号。

      关于订阅号和服务器的区别,官方是这样解释的

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

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

      个人订阅号有一些接口是没有权限的,也就是说个人订阅号无法调用一些高级的权限接口,下图就是一个我的个人订阅号所具备权限列表,如下图所示:

      

      而一些高级接口,如生成二维码、网页授权、自定义菜单、微信支付这样的接口权限个人订阅号是没有调用权限的,如上图红色框起来的那些接口,个人订阅号都无法调用。

      幸运的是,微信公众平台提供了测试公众账号,测试公众号的注册地址为:http://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login,只需要到这个页面,点击登录,并用自己的微信客户端扫码,并授权登录,就可以获得属于自己的测试公众号。测试公众号具备几乎所有的接口,所以平时学习微信公众号开发时,就可以去注册一个测试公众号,然后使用这个测试公众号做开发就可以了。不废话了,还是先注册一个测试公众号吧

      访问http://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login,注册一个测试公众号。

      注册测试公众号的步骤如下图所示:

      

        

       用微信扫描上述的二维码进行登录,登录成功后,就可以看到腾讯分配给我们的测试公众号的信息了,如下图所示:

      

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

      

      可以看到,测试公众号拥有大部分的接口调用权限,因此用测试公众号来学习微信开发是完全可以的。

     

    搭建微信本地调试环境

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

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

      

      从http://natapp.cn/网站上下载ngrok客户端,如下图所示:

      

       下载完成后,得到一个压缩包,解压压缩包后,得到一个文件夹,里面有如下图所示的几个文件:

      

      打开CMD命令行窗口,进入到ngrok_windows目录下,然后输入如下命令:

      ngrok -config ngrok.cfg -subdomain xdp 8080,如下图所示:

      

      xdp是我自己自定义的一个域名, 8080为本地服务器的运行端口,执行完上述命令后,我们就可以本地的127.0.0.1:8080服务器映射到外网了,如下图所示:

      

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

      

      

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

     

    微信公众平台的基本原理

      在开始做之前,先简单介绍了微信公众平台的基本原理。

      微信服务器就相当于一个转发服务器,终端(手机、Pad等)发起请求至微信服务器,微信服务器然后将请求转发给我们的应用服务器。应用服务器处理完毕后,将响应数据回发给微信服务器,微信服务器再将具体响应信息回复到微信App终端。

      通信协议为:HTTP

      数据传输格式为:XML

      具体的流程如下图所示:

      

      来一张更加直观的图吧:

      

      我们需要做的事情,就是对微信服务器转发的HTTP请求做出响应。具体的请求内容,我们按照特定的XML格式去解析,处理完毕后,也要按照特定的XML格式返回。

     

    微信公众号接入

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

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

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

      第1步中服务器配置包含服务器地址(URL)、Token和EncodingAESKey。

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

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

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

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

      

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

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

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

      使用IDE(Eclipse或者IntelliJ IDEA)创建一个JavaWeb项目,这里我使用的是IntelliJ IDEA,项目目录结构如下图所示:

      

      编写一个servlevt,在其中的doGet方法中定义校验方法,具体代码如下:

    package me.gacl.wx.web.servlet;
      
      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.IOException;
      import java.security.MessageDigest;
      import java.security.NoSuchAlgorithmException;
      import java.util.Arrays;
      
      /**
       * Created by xdp on 2016/1/25.
       * 使用@WebServlet注解配置WxServlet,urlPatterns属性指明了WxServlet的访问路径
       */
      @WebServlet(urlPatterns="/WxServlet")
      public class WxServlet extends HttpServlet {
      
          /**
           * Token可由开发者可以任意填写,用作生成签名(该Token会和接口URL中包含的Token进行比对,从而验证安全性)
           * 比如这里我将Token设置为gacl
           */
         private final String TOKEN = "gacl";
      
          protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      
          }
      
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              System.out.println("开始校验签名");
              /**
               * 接收微信服务器发送请求时传递过来的4个参数
               */
              String signature = request.getParameter("signature");//微信加密签名signature结合了开发者填写的token参数和请求中的timestamp参数、nonce参数。
              String timestamp = request.getParameter("timestamp");//时间戳
              String nonce = request.getParameter("nonce");//随机数
              String echostr = request.getParameter("echostr");//随机字符串
              //排序
              String sortString = sort(TOKEN, timestamp, nonce);
              //加密
              String mySignature = sha1(sortString);
              //校验签名
             if (mySignature != null && mySignature != "" && mySignature.equals(signature)) {
                  System.out.println("签名校验通过。");
                  //如果检验成功输出echostr,微信服务器接收到此输出,才会确认检验完成。
                  //response.getWriter().println(echostr);
                  response.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();
          }
      
          /**
           * 将字符串进行sha1加密
           *
           * @param str 需要加密的字符串
           * @return 加密后的内容
           */
         public String sha1(String str) {
              try {
                  MessageDigest digest = MessageDigest.getInstance("SHA-1");
                  digest.update(str.getBytes());
                  byte messageDigest[] = digest.digest();
                  // Create Hex String
                  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 "";
         }
     }

      我这里用的Servlet3.0,使用Servlet3.0的好处就是可以直接使用@WebServlet注解映射Servlet的访问路径,不再需要在web.xml文件中进行配置.

      将WxStudy项目部署到Tomcat服务器中运行,直接启动项目,然后用ngrok将本地8080端口映射到外网(如何使用ngrok请参考博客《微信开发学习总结(一)——微信开发环境搭建》)。如下图所示:

      

      测试是否可以通过http://xdp.ngrok.natapp.cn地址正常访问,测试结果如下:

      

      可以看到,我们的项目已经可以被外网正常访问到了。

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

    点击提交按钮,页面会提示配置成功,

      

      IDE的控制台中输出了校验通过的信息,如下图所示:

      

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

     

    access_token管理

    access_token介绍

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

      关于access_token,在微信公众平台开发者文档上的获取接口调用凭据有比较详细的介绍:access_token是公众号的全局唯一票据,公众号调用各接口时都需使用access_token,开发者需要妥善保存access_token的存储至少要保留512个字符空间。access_token的有效期目前为2个小时,需定时刷新,重复获取将导致上次获取的access_token失效。并且每天调用获取access_token接口的上限是2000次。

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

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

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

    微信公众平台提供的获取access_token的接口

      关于access_token的获取方式,在微信公众平台开发者文档上有说明,公众号可以调用一个叫"获取access token"的接口来获取access_token。

      获取access token接口调用请求说明

        http请求方式: GET

        请求的URL地址:https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET
           

      我们可以看到,调用过程中需要传递appID和AppSecret,appID和AppSecret是在申请公众号的时候自动分配给公众号的,相当于公众号的身份标示,使用微信公众号的注册帐号登录到腾讯提供的微信公众号管理后台就可以看到自己申请的公众号的AppID和AppSecret,如下图所示:

                 

      这是我申请公众号测试帐号时分配到的AppID和AppSecret。

    获取access_token方案以及具体实现

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

      

      下面正式开始在工程中实现以上思路,因为返回的数据都是json格式,这里会用到阿里的fastjson库,为构造请求和处理请求后的数据序列化和反序列化提供支持。

      1.定义一个AccessToken实体类

     package me.gacl.wx.entry;
     
     /**
       * AccessToken的数据模型
      * Created by xdp on 2016/1/25.
      */
     public class AccessToken {
     
         //获取到的凭证
         private String accessToken;
        //凭证有效时间,单位:秒
         private int expiresin;
     
         public String getAccessToken() {
             return accessToken;
         }
     
         public void setAccessToken(String accessToken) {
            this.accessToken = accessToken;
         }
     
         public int getExpiresin() {
             return expiresin;
         }
     
         public void setExpiresin(int expiresin) {
             this.expiresin = expiresin;
         }
     }

         2.定义一个AccessTokenInfo类,用于存放获取到的AccessToken,代码如下:

     package me.gacl.wx.Common;
     
      import me.gacl.wx.entry.AccessToken;
     
     /**
      * Created by xdp on 2016/1/25.
      */
     public class AccessTokenInfo {
     
         //注意是静态的
         public static AccessToken accessToken = null;
     }

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

     package me.gacl.wx.util;
     
     import javax.net.ssl.*;
     import java.io.BufferedReader;
     import java.io.InputStream;
     import java.io.InputStreamReader;
     import java.net.URL;
     import java.security.cert.CertificateException;
     import java.security.cert.X509Certificate;
     
     /**
     * 访问网络用到的工具类
      */
     public class NetWorkHelper {
     
         /**
          * 发起Https请求
          * @param reqUrl 请求的URL地址
          * @param requestMethod
          * @return 响应后的字符串
          */
         public String getHttpsResponse(String reqUrl, String requestMethod) {
             URL url;
             InputStream is;
             String resultData = "";
             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) {
                     resultData += inputLine + "\n";
                 }
                 System.out.println(resultData);
     
             } catch (Exception e) {
                 e.printStackTrace();
             }
             return resultData;
         }
     
         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 {
     
             }
         };
     }

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

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

     package me.gacl.wx.web.servlet;
     
     import com.alibaba.fastjson.JSON;
     import com.alibaba.fastjson.JSONObject;
     import me.gacl.wx.Common.AccessTokenInfo;
     import me.gacl.wx.entry.AccessToken;
     import me.gacl.wx.util.NetWorkHelper;
     
     import javax.servlet.ServletException;
     import javax.servlet.annotation.WebInitParam;
     import javax.servlet.annotation.WebServlet;
     import javax.servlet.http.HttpServlet;
     
     /**
      * 用于获取accessToken的Servlet
      * Created by xdp on 2016/1/25.
      */
     @WebServlet(
             name = "AccessTokenServlet",
             urlPatterns = {"/AccessTokenServlet"},
             loadOnStartup = 1,
             initParams = {
                     @WebInitParam(name = "appId", value = "wxbe4d433e857e8bb1"),
                     @WebInitParam(name = "appSecret", value = "ccbc82d560876711027b3d43a6f2ebda")
             })
     public class AccessTokenServlet extends HttpServlet {
     
         @Override
         public void init() throws ServletException {
             System.out.println("启动WebServlet");
             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);
                                 //Thread.sleep(10 * 1000);//10秒钟获取一次
                             } 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) {
     
                             }
                         }
                     }
     
                 }
             }).start();
         }
     
         /**
          * 获取access_token
          *
          * @return AccessToken
          */
         private AccessToken getAccessToken(String appId, String appSecret) {
             NetWorkHelper netHelper = new NetWorkHelper();
             /**
              * 接口地址为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.setAccessToken(json.getString("access_token"));
             token.setExpiresin(json.getInteger("expires_in"));
             return token;
         }
     }

            AccessTokenServlet采用注解的方式进行配置
      至此代码实现完毕,将项目部署,看到控制台输出如下:

      

      为了方便看效果,可以把休眠时间设置短一点,比如10秒获取一次,然后将access_token输出。

      下面做一个测试jsp页面,并把休眠时间设置为10秒,这样过10秒刷新页面,就可以看到变化

     <%-- Created by IntelliJ IDEA. --%>
      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      <%@ page import="me.gacl.wx.Common.AccessTokenInfo"%>
      <html>
       <head>
         <title></title>
       </head>
       <body>
         微信学习
         <hr/>
         access_token为:<%=AccessTokenInfo.accessToken.getAccessToken()%>
       </body>
     </html>

      

      10秒钟后刷新页面,access_token变了,如下图所示:

      

     

    接收微信服务器发送的消息并做出响应

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

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

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

      编写处理消息的工具栏,工具类代码如下:

     package me.gacl.wx.util;
      
      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;
      
      /**
       * 消息处理工具类
       * Created by xdp on 2016/1/26.
       */
      public class MessageHandlerUtil {
      
          /**
           * 解析微信发来的请求(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, "孤傲苍狼在学习和总结微信开发了,构建一条文本消息:Hello World!");
              }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数据格式
               * <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>
              */
             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);
         }
     }

     为了方便解析微信服务器发送给我们的xml格式的数据,这里我们借助于开源框架dom4j去解析xml(这里使用的是dom4j-2.0.0-RC1.jar)

      

     

    在WxServlet的doPost方法中处理请求

      WxServlet的doPost方法的代码如下:

      /**
          * 处理微信服务器发来的消息
          */
         protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
             // TODO 接收、处理、响应由微信服务器转发的用户发送给公众帐号的消息
             // 将请求、响应的编码均设置为UTF-8(防止中文乱码)
             request.setCharacterEncoding("UTF-8");
             response.setCharacterEncoding("UTF-8");
             System.out.println("请求进入");
             String result = "";
             try {
                 Map<String,String> map = MessageHandlerUtil.parseXml(request);
                 System.out.println("开始构造消息");
                 result = MessageHandlerUtil.buildXml(map);
                 System.out.println(result);
                 if(result.equals("")){
                     result = "未正确响应";
                 }
             } catch (Exception e) {
                 e.printStackTrace();
                 System.out.println("发生异常:"+ e.getMessage());
             }
             response.getWriter().println(result);
         }
    

      到此,我们的WxServlet已经可以正常处理用户的请求并做出响应了.接下来我们测试一下我们开发好的公众号应用是否可以正常和微信用户交互

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

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

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

     

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

     <xml>
       <ToUserName><![CDATA[ojADgs0eDaqh7XkTM9GvDmdYPoDw]]></ToUserName>
       <FromUserName><![CDATA[gh_43df3882c452]]></FromUserName>
       <CreateTime>1453755900000</CreateTime>
       <MsgType><![CDATA[text]]></MsgType>
       <Content><![CDATA[孤傲苍狼在学习和总结微信开发了,构建一条文本消息:Hello World!]]></Content>
    </xml>

      测试公众号的管理后台也可以看到关注测试号的用户列表,如下图所示:

      通过这个简单的入门程序,我们揭开了微信开发的神秘面纱了.

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 最近想学习下微信公众号的开发,所以从自定义菜单功能开始开发,自定义菜单功能的开发需要完成微信认证之后才能拥有权限,否则会报错:40081, 没有微信认证可以申请微信接口测试公众号。 自定义菜单能够帮助公众号...

    最近想学习下微信公众号的开发,所以从自定义菜单功能开始开发,自定义菜单功能的开发需要完成微信认证之后才能拥有权限,否则会报错:40081, 没有微信认证可以申请微信接口测试公众号。
    自定义菜单能够帮助公众号丰富界面,让用户更好更快地理解公众号的功能。开启自定义菜单后,公众号界面如图所示:
    这里写图片描述
    注意:
    1、自定义菜单最多包括3个一级菜单,每个一级菜单最多包含5个二级菜单。
    2、一级菜单最多4个汉字,二级菜单最多7个汉字,多出来的部分将会以“…”代替。
    3、创建自定义菜单后,菜单的刷新策略是,在用户进入公众号会话页或公众号profile页时,如果发现上一次拉取菜单的请求在5分钟以前,就会拉取一下菜单,如果菜单有更新,就会刷新客户端的菜单。测试时可以尝试取消关注公众账号后再次关注,则可以看到创建后的效果。
    其次:
    自定义菜单接口可实现多种类型按钮,如下:
    1、click:点击推事件用户点击click类型按钮后,微信服务器会通过消息接口推送消息类型为event的结构给开发者(参考消息接口指南),并且带上按钮中开发者填写的key值,开发者可以通过自定义的key值与用户进行交互;
    2、view:跳转URL用户点击view类型按钮后,微信客户端将会打开开发者在按钮中填写的网页URL,可与网页授权获取用户基本信息接口结合,获得用户基本信息。
    3、scancode_push:扫码推事件用户点击按钮后,微信客户端将调起扫一扫工具,完成扫码操作后显示扫描结果(如果是URL,将进入URL),且会将扫码的结果传给开发者,开发者可以下发消息。
    4、scancode_waitmsg:扫码推事件且弹出“消息接收中”提示框用户点击按钮后,微信客户端将调起扫一扫工具,完成扫码操作后,将扫码的结果传给开发者,同时收起扫一扫工具,然后弹出“消息接收中”提示框,随后可能会收到开发者下发的消息。
    5、pic_sysphoto:弹出系统拍照发图用户点击按钮后,微信客户端将调起系统相机,完成拍照操作后,会将拍摄的相片发送给开发者,并推送事件给开发者,同时收起系统相机,随后可能会收到开发者下发的消息。
    6、pic_photo_or_album:弹出拍照或者相册发图用户点击按钮后,微信客户端将弹出选择器供用户选择“拍照”或者“从手机相册选择”。用户选择后即走其他两种流程。
    7、pic_weixin:弹出微信相册发图器用户点击按钮后,微信客户端将调起微信相册,完成选择操作后,将选择的相片发送给开发者的服务器,并推送事件给开发者,同时收起相册,随后可能会收到开发者下发的消息。
    8、location_select:弹出地理位置选择器用户点击按钮后,微信客户端将调起地理位置选择工具,完成选择操作后,将选择的地理位置发送给开发者的服务器,同时收起位置选择工具,随后可能会收到开发者下发的消息。
    9、media_id:下发消息(除文本消息)用户点击media_id类型按钮后,微信服务器会将开发者填写的永久素材id对应的素材下发给用户,永久素材类型可以是图片、音频、视频、图文消息。请注意:永久素材id必须是在“素材管理/新增永久素材”接口上传后获得的合法id。
    10、view_limited:跳转图文消息URL用户点击view_limited类型按钮后,微信客户端将打开开发者在按钮中填写的永久素材id对应的图文消息URL,永久素材类型只支持图文消息。请注意:永久素材id必须是在“素材管理/新增永久素材”接口上传后获得的合法id。

    主要功能代码:
    写好之后在IDEA中直接运行它的main方法即可

    public class MenuManager {
    //  private static Logger log = LoggerFactory.getLogger(MenuManager.class);  
    
        public static void main(String[] args) {
    
            // 调用接口获取access_token  
            AccessToken at = WeixinUtil.getAccessToken();
    
            if (null != at) {  
                // 调用接口创建菜单  
                int result = WeixinUtil.createMenu(getMenu(), at.getToken());
    
                // 判断菜单创建结果  
                if (0 == result)  
                    System.out.println("菜单创建成功!");  
                else  
                    System.out.println("菜单创建失败,错误码:" + result);  
            }  
        }  
    
        /** 
         * 组装菜单数据 
         *  
         * @return 
         */  
        public static Menu getMenu() {
            CommonButton btn11 = new CommonButton();  
            btn11.setName("天气预报");  
            btn11.setType("click");  
            btn11.setKey("11");  
    
            CommonButton btn12 = new CommonButton();  
            btn12.setName("公交查询");  
            btn12.setType("click");  
            btn12.setKey("12");  
    
            CommonButton btn13 = new CommonButton();  
            btn13.setName("周边搜索");  
            btn13.setType("click");  
            btn13.setKey("13");  
    
            CommonButton btn14 = new CommonButton();  
            btn14.setName("历史上的今天");  
            btn14.setType("click");  
            btn14.setKey("14");  
    
            CommonButton btn21 = new CommonButton();  
            btn21.setName("歌曲点播");  
            btn21.setType("click");  
            btn21.setKey("21");  
    
            CommonButton btn22 = new CommonButton();  
            btn22.setName("经典游戏");  
            btn22.setType("click");  
            btn22.setKey("22");  
    
            CommonButton btn23 = new CommonButton();  
            btn23.setName("美女电台");  
            btn23.setType("click");  
            btn23.setKey("23");  
    
            CommonButton btn24 = new CommonButton();  
            btn24.setName("人脸识别");  
            btn24.setType("click");  
            btn24.setKey("24");  
    
            CommonButton btn25 = new CommonButton();  
            btn25.setName("聊天唠嗑");  
            btn25.setType("click");  
            btn25.setKey("25");  
    
            CommonButton btn31 = new CommonButton();  
            btn31.setName("Q友圈");  
            btn31.setType("click");  
            btn31.setKey("31");  
    
            CommonButton btn32 = new CommonButton();  
            btn32.setName("电影排行榜");  
            btn32.setType("click");  
            btn32.setKey("32");  
    
            CommonButton btn33 = new CommonButton();  
            btn33.setName("幽默笑话");  
            btn33.setType("click");  
            btn33.setKey("33");  
    
            ComplexButton mainBtn1 = new ComplexButton();  
            mainBtn1.setName("生活助手");  
            mainBtn1.setSub_button(new CommonButton[] { btn11, btn12, btn13, btn14 });  
    
            ComplexButton mainBtn2 = new ComplexButton();  
            mainBtn2.setName("休闲驿站");  
            mainBtn2.setSub_button(new CommonButton[] { btn21, btn22, btn23, btn24, btn25 });  
    
            ComplexButton mainBtn3 = new ComplexButton();  
            mainBtn3.setName("更多体验");  
            mainBtn3.setSub_button(new CommonButton[] { btn31, btn32, btn33 });  
    
            /** 
             * 这是目前的菜单结构,每个一级菜单都有二级菜单项<br> 
             *  
             * 在某个一级菜单下没有二级菜单的情况,menu该如何定义呢?<br> 
             * 比如,第三个一级菜单项不是“更多体验”,而直接是“幽默笑话”,那么menu应该这样定义:<br> 
             * menu.setButton(new Button[] { mainBtn1, mainBtn2, btn33 }); 
             */  
            Menu menu = new Menu();  
            menu.setButton(new Button[] { mainBtn1, mainBtn2, mainBtn3 });  
    
            return menu;  
        }  
    }
    

    WeixinUtil.java的代码如下

    public class WeixinUtil {
    
        // 第三方用户唯一凭证
        public  static final   String APPID = "你的APPID";
        // 第三方用户唯一凭证密钥
        public  static final String APPSECRET = "你的APPSECRET";
    
        //  private static Logger log = LoggerFactory.getLogger(WeixinUtil.class);
        // 获取access_token的接口地址(GET) 限200(次/天)  
        public final static String access_token_url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";  
        // 菜单创建(POST) 限100(次/天)  
        public static String menu_create_url = "https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN";
    
        public static  AccessToken accessToken = null;
    
        /**
         * 发起https请求并获取结果 
         *  
         * @param requestUrl 请求地址 
         * @param requestMethod 请求方式(GET、POST) 
         * @param outputStr 提交的数据 
         * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值) 
         */  
        public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {  
            JSONObject jsonObject = null;  
            StringBuffer buffer = new StringBuffer();  
            try {  
                // 创建SSLContext对象,并使用我们指定的信任管理器初始化  
                TrustManager[] tm = { new MyX509TrustManager() };  
                SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");  
                sslContext.init(null, tm, new java.security.SecureRandom());  
                // 从上述SSLContext对象中得到SSLSocketFactory对象  
                SSLSocketFactory ssf = sslContext.getSocketFactory();  
    
                URL url = new URL(requestUrl);  
                HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();  
                httpUrlConn.setSSLSocketFactory(ssf);  
    
                httpUrlConn.setDoOutput(true);  
                httpUrlConn.setDoInput(true);  
                httpUrlConn.setUseCaches(false);  
                // 设置请求方式(GET/POST)  
                httpUrlConn.setRequestMethod(requestMethod);  
    
                if ("GET".equalsIgnoreCase(requestMethod))  
                    httpUrlConn.connect();  
    
                // 当有数据需要提交时  
                if (null != outputStr) {  
                    OutputStream outputStream = httpUrlConn.getOutputStream();  
                    // 注意编码格式,防止中文乱码  
                    outputStream.write(outputStr.getBytes("UTF-8"));  
                    outputStream.close();  
                }  
    
                // 将返回的输入流转换成字符串  
                InputStream inputStream = httpUrlConn.getInputStream();  
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");  
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
    
                String str = null;  
                while ((str = bufferedReader.readLine()) != null) {  
                    buffer.append(str);  
                }  
                bufferedReader.close();  
                inputStreamReader.close();  
                // 释放资源  
                inputStream.close();  
                inputStream = null;  
                httpUrlConn.disconnect();  
                System.out.println(buffer.toString());
                jsonObject = JSONObject.fromObject(buffer.toString());
            } catch (ConnectException ce) {  
                System.out.println("Weixin server connection timed out.");
            } catch (Exception e) {  
                System.err.println("https request error:{}");
    //            log.error("https request error:{}", e);  
            }  
            return jsonObject;  
        }  
        /** 
         * 获取access_token
         * @return 
         */  
        public static AccessToken getAccessToken() {
            if(accessToken==null){
                accessToken=getToken();
            }else if ( ( accessToken.getTokenTime()-System.currentTimeMillis() ) >accessToken.getExpiresIn()){  //凭证过期了
                accessToken=getToken();
            }
    
            return accessToken;  
        }
    
        public static AccessToken  getToken(){
            String requestUrl = access_token_url.replace("APPID", APPID).replace("APPSECRET", APPSECRET);
            JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
            // 如果请求成功
            if (null != jsonObject) {
                try {
                    accessToken = new AccessToken();
                    accessToken.setTokenTime(System.currentTimeMillis());
                    accessToken.setToken(jsonObject.getString("access_token"));
                    accessToken.setExpiresIn(jsonObject.getInt("expires_in"));
                } catch (Exception e) {
                    accessToken = null;
                    // 获取token失败
                    System.out.println("获取token失败 errcode:"+jsonObject.getInt("errcode")+"errmsg:"+jsonObject.getString("errmsg"));
    //              log.error("获取token失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
                }
            }
            return accessToken;
        }
        /** 
         * 创建菜单 
         *  
         * @param menu 菜单实例 
         * @param accessToken 有效的access_token 
         * @return 0表示成功,其他值表示失败 
         */  
        public static int createMenu(Menu menu, String accessToken) {
            int result = 0;  
    
            // 拼装创建菜单的url  
            String url = menu_create_url.replace("ACCESS_TOKEN", accessToken);  
            // 将菜单对象转换成json字符串  
            String jsonMenu = JSONObject.fromObject(menu).toString();  
            // 调用接口创建菜单  
            JSONObject jsonObject = httpRequest(url, "POST", jsonMenu);  
    
            if (null != jsonObject) {  
                if (0 != jsonObject.getInt("errcode")) {  
                    result = jsonObject.getInt("errcode"); 
                    System.out.println("创建菜单失败errcode:"+jsonObject.getInt("errcode")+"errmsg:"+jsonObject.getString("errmsg"));
    //              log.error("创建菜单失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
                }  
            }  
    
            return result;  
        } 
    }
    

    MyX509TrustManager.java

    /** 
     * 证书信任管理器(用于https请求) 
     */  
    public class MyX509TrustManager implements X509TrustManager{
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
        }  
    
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
        }  
    
        public X509Certificate[] getAcceptedIssuers() {  
            return null;  
        }  
    }
    

    运行MenuManager.java的main方法,就可以成功创建菜单。
    随后与用户交互时候,可以通过key值,分别实现逻辑功能。

    展开全文
  • 上一篇《微信开发学习总结(一)——微信开发环境搭建》我们已经完成了微信开发的准备工作,准备工作完成之后,就要开始步入正题了。 一、微信公众平台的基本原理  在开始做之前,先简单介绍了微信公众平台的基本...
  • 承接之前的流程,在完成服务器绑定和获取access_token之后,本文主要讲述如何实现微信自定义菜单。开始之前 1、自定义菜单最多包括3个一级菜单,每个一级菜单最多包含5个二级菜单。 2、一级菜单最多4个汉字,二级...
  • (一)微信公众号开发之VS远程调试 (二)微信公众号开发之基础梳理 (三)微信公众号开发之自动消息回复和自定义菜单 前言 上一篇我们大致讲解了下微信公众号开发的基本原理和流程概述。本章主要是对文本消息...
  • C#微信开发

    2017-12-24 10:35:37
    C#开发微信门户及应用教程   作者:伍华聪   C#开发微信门户及应用(1)--开始使用微信接口 6 1、微信账号 6 2、微信菜单定义 7 3、接入微信的链接处理 8 4、使用开发方式创建菜单 14 5、我创建的菜单案例 17 C#...
  • 微信公众号自定义菜单创建及响应 一配置相关工具类: 1.证书信任管理器(用于https请求) package com.jcxx.saas.wxapi.CustomMenuUtil; import javax.net.ssl.X509TrustManager; import java.security.cert....
  • 原文:C#开发微信门户及应用(26)-公众号微信素材管理微信公众号最新修改了素材的管理模式,提供了两类素材的管理:临时素材和永久素材的管理,原先的素材管理就是临时素材管理,永久素材可以永久保留在微信服务器上,...
  • 微信公众帐号开发-自定义菜单的创建及菜单事件响应的实例
  • 写在前:在做这一块时,先看一下 公众平台开发文档(点击进入):在创建菜单时,都是基于JSON传输数据,所以要用到JSON,下载相关包 点击下载:公众平台开发文档上有...3、创建自定义菜单后,由于微信客户端缓存,需要2...
  • 微信公众号主要有以下几个步骤 微信公众号的通讯机制 微信公众号简介 1.注册微信公众号 2.注册测试公众号 3.搭建微信本地调试环境 1)下载客户端natapp: 2)安装natapp: 4.微信公众号接入(校验签名) 第1步中...
  • 我们来了解一下 ...自定义菜单创建接口: http请求方式:POST(请使用https协议) https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN 自定义菜单查询接口: http请求方式:GET ...
  • 微信网页开发 素材管理 图文消息留言管理 用户管理 帐号管理 数据统计 微信卡券 微信门店 微信小店 智能接口 微信设备功能 新版客服功能 微信摇一摇周边 微信连Wi-Fi 微信扫一扫 微信发票 &lt;...
1 2 3 4 5 ... 20
收藏数 469
精华内容 187
关键字:

微信开发菜单 指定素材