微信公众号开发(十六):微信的一些其他的常用接口测试代码

247 篇文章 1 订阅
20 篇文章 0 订阅

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;
    。。。。
}
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值