微信公众号开发（十六）：微信的一些其他的常用接口测试代码
OpenID是一个微信号在一个公众号中的唯一标识，客服接口需要有自己的客户端，用网页的话可能用Ajax实现客服和微信用户之间的实时对话。客服的时候可以发送文本、图片、音频等，但后面的多媒体文件需要使用多媒体上传下载接口，将文件再微信服务器过一遍，生成一个MediaID，微信用户发送图片音频就回复图片音频就是使用这个MediaID。
微网站其实和微信没有什么关系，只不过提供一个入口，你的粉丝可以轻松进入你的网站。通过回复关键字，回复有链接的图文，或者直接点击菜单（View）
/**
* 公众平台通用接口工具类*
* @author 熊诗言
* @date 2015-09-05
*/
public class WeiXinUtil {
private static Logger log = LoggerFactory.getLogger(WeiXinUtil.class);
//微信服务器地址
private final static String weixinAddress = "https://api.weixin.qq.com/cgi-bin/getcallbackip?access_token=ACCESS_TOKEN";
// 获取access_token 的接口地址（GET） 限200（次/天）
private final static String access_token_url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";
// 菜单创建（POST） 限100（次/天）
private static String menu_create_url = "https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN";
//客服接口网址
private static String kefuInterface = "https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=ACCESS_TOKEN";
//查询用户列表
private static String userList = "https://api.weixin.qq.com/cgi-bin/user/get?access_token=ACCESS_TOKEN&next_openid=NEXT_OPENID";
//查询用户分组
private static String queryGroup = "https://api.weixin.qq.com/cgi-bin/groups/get?access_token=ACCESS_TOKEN";
//创建分组
private static String createGroup = "https://api.weixin.qq.com/cgi-bin/groups/create?access_token=ACCESS_TOKEN";
//移动用户到分组
private static String moveUserToGroup = "https://api.weixin.qq.com/cgi-bin/groups/members/update?access_token=ACCESS_TOKEN";
//修改分组名
private static String updateGroup = "https://api.weixin.qq.com/cgi-bin/groups/update?access_token=ACCESS_TOKEN";
//查询用户所在分组
private static String userInGroup = "https://api.weixin.qq.com/cgi-bin/groups/getid?access_token=ACCESS_TOKEN";
/**
* 发起https 请求并获取结果
*
* @param requestUrl 请求地址
* @param requestMethod 请求方式（GET、POST）
* @param outputStr 提交的数据
* @return JSONObject(通过JSONObject.get(key)的方式获取json 对象的属性值)
*/
public static JSONObject httpsRequest(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) {
System.out.println("Weixin server connection timed out.");
} catch (Exception e) {
System.out.println("https request error:{"+e+"}");
}
return jsonObject;
}
/**
* 基于安全考虑获取微信服务器地址列表
* @param accessToken
* @return
*/
@SuppressWarnings("unchecked")
public static List<String> getWeiXinAddress(String accessToken){
String url = weixinAddress.replaceAll("ACCESS_TOKEN", accessToken);
JSONObject jsonObject = httpsRequest(url, "GET", null);
JSONArray array = jsonObject.getJSONArray("ip_list");
return JSONArray.toList(array, "", new JsonConfig());
}
/**
* 获取access_token，必须在自己的数据库中保存下获取的时间和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 = httpsRequest(requestUrl, "GET", null);
// 如果请求成功
if (null != jsonObject) {
try {
accessToken = new AccessToken();
accessToken.setToken(jsonObject.getString("access_token"));
accessToken.setExpiresIn(jsonObject.getInt("expires_in"));
log.info(jsonObject.getString("access_token")+"-----"+jsonObject.getInt("expires_in"));
} catch (JSONException e) {
accessToken = null;
// 获取token 失败
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(MenuBar 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 = httpsRequest(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;
}
/**
*
/**
* 给用户发送消息48小时内，客服接口是可以不断地给用户发消息
* 用户给公众号发送消息的时候才能调用这个接口
* 这些消息一般应该放在数据库中，用户基本信息也存在数据库中(包括openid)，当你需要给用户客服的时候，
* 打开一个用户列表界面（网页）选择某一个用户给他发送消息，就调用这个接口，之间的纽带就是openid
* @param message
*/
public static int toUser(String aceessToken,String openid,String message){
String url = kefuInterface.replaceAll("ACCESS_TOKEN", aceessToken);
KefuTextMessage kefuTextMessage = new KefuTextMessage();
kefuTextMessage.setTouser(openid);
kefuTextMessage.setText(new Text(message));
kefuTextMessage.setMsgtype("text");//可以省略，有默认值
String jsonKefu = JSONObject.fromObject(kefuTextMessage).toString();
// 调用接口创建菜单
JSONObject jsonObject = httpsRequest(url, "POST", jsonKefu);
return jsonObject.getInt("errcode");
}
/**
* 获取用户列表
* @param accessToken
* @param nextOpenid，一次最多返回10000 个，所以超过10000个的时候需要多次调用，不填就默认从第一个
* @return
*/
@SuppressWarnings("unchecked")
public static List<String> userList(String nextOpenid,String accessToken){
String url = userList.replaceAll("ACCESS_TOKEN", accessToken).replaceAll("NEXT_OPENID", nextOpenid);
//get方式
JSONObject jsonObject = httpsRequest(url, "GET",null);
List<String> list = new ArrayList<String>();
try {
System.out.println(jsonObject.toString());
JSONArray jsonArray = jsonObject.getJSONObject("data").getJSONArray("openid");
list = JSONArray.toList(jsonArray, "", new JsonConfig());
} catch (Exception e) {
e.printStackTrace();
System.out.println(jsonObject.getInt("errcode"));
}
return list;
}
/**
* 查询有哪些分组
* @param aceessToken
* @return
*/
@SuppressWarnings("unchecked")
public static List<Group> queryGroup(String accessToken) {
String url = queryGroup.replaceAll("ACCESS_TOKEN", accessToken);
//get方式
JSONObject jsonObject = httpsRequest(url, "GET",null);
System.out.println(jsonObject.toString());
JSONArray array=jsonObject.getJSONArray("groups");
List<Group> list = JSONArray.toList(array, new Group(), new JsonConfig());
return list;
}
/**
* 创建新分组
* @param name
* @param aceessToken
*/
public static int createGroup(String name,String aceessToken){
String url = createGroup.replaceAll("ACCESS_TOKEN", aceessToken);
JSONObject jsonObject = httpsRequest(url, "POST", "{\"group\":{\"name\":\""+name+"\"}}");
int result = 0;
try {
result = jsonObject.getJSONObject("group").getInt("id");//成功的话
} catch (Exception e) {
result = jsonObject.getInt("errcode");
}
return result;
}
/**
* 移动某个人到一个组
* @param openid
* @param groupid
* @param aceessToken
* @return
*/
public static int moveUserToGroup(String openid,int groupid,String aceessToken){
String url = moveUserToGroup.replaceAll("ACCESS_TOKEN", aceessToken);
JSONObject jsonObject = httpsRequest(url, "POST", "{\"openid\":\""+openid+"\",\"to_groupid\":"+groupid+"}");
return jsonObject.getInt("errcode");
}
/**
* 修改分组名
* @param groupid
* @param newName
* @param aceessToken
* @return
*/
public static int updateGroup(int groupid,String newName,String aceessToken){
String url = updateGroup.replaceAll("ACCESS_TOKEN", aceessToken);
JSONObject jsonObject = httpsRequest(url, "POST", "{\"group\":{\"id\":"+groupid+",\"name\":\""+newName+"\"}}");
return jsonObject.getInt("errcode");
}
/**
* 查询用户所在的分组。如何实现查询某个组的所有用户？【1，首先查询用户列表，再查询这个用户所在的分组得到，想想都完蛋；2，自己再数据库中建立用户管理，用户表中添加一个组id，做同步即可】
* @param openid
* @param aceessToken
* @return
*/
public static int userInGroup(String openid,String aceessToken){
String url = userInGroup.replaceAll("ACCESS_TOKEN", aceessToken);
JSONObject jsonObject = httpsRequest(url, "POST", "{\"openid\":\""+openid+"\"}");
int result = 0;
try {
result = jsonObject.getInt("groupid");//成功的话
} catch (Exception e) {
result = jsonObject.getInt("errcode");
}
return result;
}
/**
* 创建带参数的二维码图片，当用户扫描的时候，如果未关注就打开关注的界面进行关注，这个事件xml中也有sceneid，如果已经关注就推送scan事件
*/
public static void createParametered2DCode(String accessToken) {
String url = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=TOKEN";
url = url.replaceAll("TOKEN", accessToken);
//1生成ticket
JSONObject jsonObject = httpsRequest(url, "POST", "{\"action_name\": \"QR_LIMIT_SCENE\", \"action_info\": {\"scene\": {\"scene_id\": 102}}}");//这个场景是用户一扫瞄就把这个用户加入这个分组，你想干嘛就干嘛，这个值完全是你自己定的
String ticket = null;
try {
ticket = jsonObject.getString("ticket");
String codeUrl = jsonObject.getString("url");
System.out.println(codeUrl);//你自己使用这个url再用别的二维码生成器生成图片，用户一扫也能达到微信生成的二维码图片一样的效果
} catch (Exception e) {
int errorCode = jsonObject.getInt("errcode");
System.out.println("errcode="+errorCode);
}
//2使用ticket换取二维码图片
url = "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=TICKET";
url = url.replaceAll("TICKET", URLEncoder.encode(ticket));
System.out.println(url);//你就可以使用这个url获取图片
//httpsRequest(url, "GET", null);
}
/**
* 上传媒体文件，正常的情况下可能是这个流程：写个网页，进行上传到自己的服务器，自己的服务器上再往微信服务器上传
* @param accessToken 接口访问凭证
* @param type 媒体文件类型，分别有图片（image）、语音（voice）、视频（video），普通文件(file)
* @param media form-data中媒体文件标识，有filename、filelength、content-type等信息
* @param mediaFileUrl 媒体文件的url
* 上传的媒体文件限制
* 图片（image）:1MB，支持JPG格式
* 语音（voice）：2MB，播放长度不超过60s，支持AMR格式
* 视频（video）：10MB，支持MP4格式
* 普通文件（file）：10MB
* */
//media:9JcBNFhIAfxaXljA_cS9AzftPe6hh2PgL3qxvjkuXAqdQ6EV0Gy7Y0pjCIKEKmKI
public static WeixinMedia uploadMedia(String accessToken, String type, File file) {
WeixinMedia weixinMedia = null;
// 拼装请求地址
String uploadMediaUrl = "http://file.api.weixin.qq.com/cgi-bin/media/upload?access_token=ACCESS_TOKEN&type=TYPE";
uploadMediaUrl = uploadMediaUrl.replaceAll("ACCESS_TOKEN", accessToken).replaceAll("TYPE", type);
// 定义数据分隔符
String boundary = "------------7da2e536604c8";
try {
URL uploadUrl = new URL(uploadMediaUrl);
HttpURLConnection uploadConn = (HttpURLConnection) uploadUrl.openConnection();
uploadConn.setDoOutput(true);
uploadConn.setDoInput(true);
uploadConn.setRequestMethod("POST");
// 设置请求头Content-Type
uploadConn.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);
// 获取媒体文件上传的输出流（往微信服务器写数据）
OutputStream outputStream = uploadConn.getOutputStream();
// 从请求头中获取内容类型
String contentType = getFileContentType(file);
// 根据内容类型判断文件扩展名
String fileExt = getFileEndWitsh(contentType);
// 请求体开始
outputStream.write(("--" + boundary + "\r\n").getBytes());
outputStream.write(String.format("Content-Disposition: form-data; name=\"media\"; filename=\"file1%s\"\r\n", fileExt).getBytes());
outputStream.write(String.format("Content-Type: %s\r\n\r\n", contentType).getBytes());
// 获取媒体文件的输入流（读取文件）
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
byte[] buf = new byte[8096];
int size = 0;
while ((size = bis.read(buf)) != -1) {
// 将媒体文件写到输出流（往微信服务器写数据）
outputStream.write(buf, 0, size);
}
// 请求体结束
outputStream.write(("\r\n--" + boundary + "--\r\n").getBytes());
outputStream.close();
bis.close();
// 获取媒体文件上传的输入流（从微信服务器读数据）
InputStream inputStream = uploadConn.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
StringBuffer buffer = new StringBuffer();
String str = null;
while ((str = bufferedReader.readLine()) != null) {
buffer.append(str);
}
bufferedReader.close();
inputStreamReader.close();
// 释放资源
inputStream.close();
inputStream = null;
uploadConn.disconnect();
// 使用JSON-lib解析返回结果
JSONObject jsonObject = JSONObject.fromObject(buffer.toString());
// 测试打印结果
System.out.println("打印测试结果"+jsonObject);
weixinMedia = new WeixinMedia();
weixinMedia.setType(jsonObject.getString("type"));
// type等于 缩略图（thumb） 时的返回结果和其它类型不一样
if ("thumb".equals(type))
weixinMedia.setMedia_id(jsonObject.getString("thumb_media_id"));
else
weixinMedia.setMedia_id(jsonObject.getString("media_id"));
weixinMedia.setCreated_at(jsonObject.getInt("created_at"));
} catch (Exception e) {
weixinMedia = null;
String error = String.format("上传媒体文件失败：%s", e);
System.out.println(error);
}
return weixinMedia;
}
/**
* 获取媒体文件
* @param accessToken 接口访问凭证
* @param media_id 媒体文件id
* @param savePath 文件在服务器上的存储路径
* */
public static String downloadMedia(String accessToken,String fileExt, String mediaId, String savePath) {
String filePath = null;
// 拼接请求地址
String requestUrl = "http://file.api.weixin.qq.com/cgi-bin/media/get?access_token=ACCESS_TOKEN&media_id=MEDIA_ID";
requestUrl = requestUrl.replace("ACCESS_TOKEN", accessToken).replace("MEDIA_ID", mediaId);
System.out.println(requestUrl);
try {
URL url = new URL(requestUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoInput(true);
conn.setRequestMethod("GET");
if (!savePath.endsWith("/")) {
savePath += "/";
}
// 将mediaId作为文件名
filePath = savePath + mediaId + fileExt;
BufferedInputStream bis = new BufferedInputStream(conn.getInputStream());
FileOutputStream fos = new FileOutputStream(new File(filePath));
byte[] buf = new byte[8096];
int size = 0;
while ((size = bis.read(buf)) != -1)
fos.write(buf, 0, size);
fos.close();
bis.close();
conn.disconnect();
System.out.println("下载媒体文件成功");
} catch (Exception e) {
filePath = null;
String error = String.format("下载媒体文件失败：%s", e);
System.out.println(error);
}
return filePath;
}
static Map<String, String> map = new HashMap<String, String>();
static{
map.put("image/jpeg", ".jpg");
map.put("audio/mp3", ".mp3");
map.put("video/mpeg4", ".mp4");
}
private static String getFileEndWitsh(String contentType) {
return map.get(contentType);
}
public static String getFileContentType(File f)
{
return new MimetypesFileTypeMap().getContentType(f);
}
//群发接口比较简单 先不测了，注意的是图文消息需要先调用图文消息上传接口上传到服务器 ，群发之后会收到一个msgid，根据这个id可以取消群发
}
public class WeiXinInterfaceTest {
// 第三方用户唯一凭证
String appId = "wx56955e5a8b26b3ec";//wx58c053db3b78203a
// 第三方用户唯一凭证密钥
String appSecret = "d9c7190ee53079c2a92a711fb3219cdc";//d98c06e3f9182aeafe9f6b986b1a6063
String tokenString = "tCMbyU0D8rbf2eSPxIDNHxJWzKdyWKo0F8Gdcp5rtQ2kyP0Y2xmqA4xrCe7x6RDAwyHXjNKNJ0v25lhQkw0LQKiGmQaWW5uBfTujvOFMEyk";
@Test
public void testAccessToken(){
AccessToken accessToken = WeiXinUtil.getAccessToken(appId, appSecret);
tokenString=accessToken.getToken();//获取一次之后，将token保存在这个变量中，以后调用所有的函数都是这个
System.out.println(tokenString);
}
@Test
public void testGetWeiXinAddress(){
List<String> list = WeiXinUtil.getWeiXinAddress(tokenString);
for (String address : list) {
System.out.println(address);
}
}
@Test
public void testCreateMenu(){
// 调用接口创建菜单
int result = WeiXinUtil.createMenu(ContentUtil.getMenu(), tokenString);
// 判断菜单创建结果
if (0 == result)
System.out.println("菜单创建成功！");
else
System.out.println("菜单创建失败，错误码：" + result);
System.out.println("运行完成");
}
@Test
public void testKefu(){
// 调用接口创建菜单
int result = WeiXinUtil.toUser(tokenString,"oIsJrwWsPxzLW_lPpThdPv0ELcIU", "谢谢您的提醒和建议，我们会尽快改正");
//我的微信号
// 判断菜单创建结果
if (0 == result)
System.out.println("发送成功！");
else
System.out.println("发送失败，错误码：" + result);
System.out.println("运行完成");
}
@Test
public void testUserList(){
List<String> list = WeiXinUtil.userList("", tokenString);
for (String openid : list) {
System.out.println(openid);
}
}
@Test
public void testQueryGroup(){
List<Group> list = WeiXinUtil.queryGroup(tokenString);
for (Group group : list) {
System.out.println("id["+group.getId()+"]---"+group.getName()+"---count["+group.getCount()+"]");
}
}
@Test
public void testCreateGroup(){
int result = WeiXinUtil.createGroup("我喜欢的人",tokenString);
System.out.println(result);
}
@Test
public void testMoveUserToGroup(){
WeiXinUtil.moveUserToGroup("oIsJrwWsPxzLW_lPpThdPv0ELcIU", 101,tokenString);
}
@Test
public void testUpdateGroup(){
WeiXinUtil.updateGroup(100,"内测",tokenString);
}
@Test
public void testUserInGroup(){
int result = WeiXinUtil.userInGroup("oIsJrwWsPxzLW_lPpThdPv0ELcIU",tokenString);
System.out.println(result);
}
@Test
public void testCreateParametered2DCode(){
WeiXinUtil.createParametered2DCode(tokenString);
}
@Test
public void testUpMedia(){
/**
* 上传多媒体文件
*/
//地址 //D:\\Users\\熊诗言\\Desktop\\WeiXinDevelop\\WebRoot\\medias\\01.jpg
//http://localhost:8080/WeiXinDevelop/medias/01.jpg
String fileName = "D:\\Users\\熊诗言\\Desktop\\WeiXinDevelop\\WebRoot\\medias\\01.jpg";
WeixinMedia weixinMedia = WeiXinUtil.uploadMedia(tokenString, "image",new File(fileName));
//media_id
System.out.println("media_id："+weixinMedia.getMedia_id());
//类型
System.out.println("类型："+weixinMedia.getType());
//时间戳
System.out.println("时间戳："+weixinMedia.getCreated_at());
//打印结果
if(null!=weixinMedia){
System.out.println("上传成功！");
}else{
System.out.println("上传失败！");
}
}
@Test
public void testDownMedia(){
String filePath = WeiXinUtil.downloadMedia(tokenString, ".jpg","9JcBNFhIAfxaXljA_cS9AzftPe6hh2PgL3qxvjkuXAqdQ6EV0Gy7Y0pjCIKEKmKI", "F:/qycache");
System.out.println(filePath);
}
}
/**
证书信任管理器（用于https 请求）
*
* @author 熊诗言
* @date 2015-09-05
*/
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;
}
}
/**
* 微信通用接口凭证
*
* @author 熊诗言
* @date 2015-09-05
*/
public class AccessToken {
// 获取到的凭证
private String token;
// 凭证有效时间，单位：秒
private int expiresIn;
。。。。
}
/**
* 菜单
*整个菜单对象的封装，菜单对象包含多个菜单项（最多只能有3 个），这些菜单项
即可以是子菜单项（不含二级菜单的一级菜单），也可以是父菜单项（包含二级菜单的菜单
项），
* @author 熊诗言
* @date 2015-09-05
*/
public class MenuBar {
private Button[] button;
。。。。
}
/**
* 按钮的基类
*
* @author 熊诗言
* @date 2015-09-05
*/
public class Button {
private String name;
。。。。
}
/**
* 普通按钮（子按钮）
*没有子菜单的菜单项，有可能是二级
菜单项，也有可能是不含二级菜单的一级菜单。这类子菜单项一定会包含三个属性：type、
name 和key
* @author 熊诗言
* @date 2015-09-05
*/
public class CommonButton extends Button {
private String type;
private String key;
。。。
}
/**
* 复杂按钮（父按钮）
*包含有二级菜单项的一级菜单。这类菜单项
包含有二个属性：name 和sub_button，而sub_button 以是一个子菜单项数组
* @author 熊诗言
* @date 2015-09-05
*/
public class ComplexButton extends Button {
private Button[] sub_button;
.....
}
/**
* view 类型的菜单
*
* @author 熊诗言
* @date 2015-09-05
*/
public class ViewButton extends Button {
private String type;
private String url;
。。。。
}
public class KefuTextMessage {
private String touser;
private String msgtype = "text";
private Text text;
。。。。
}
public class Group{
private int id;
private String name;
private int count;
。。。
}
public class WeixinMedia {
private String type;
private String media_id;
private int created_at;
。。。。
}