Java企业微信开发_02_通讯录同步

一、本节要点

1.获取通讯录密钥

获取方式:

       登录企业微信—>管理工具—>通讯录同步助手—>开启“API接口同步”  ; 开启后,即可看到通讯录密钥,也可设置通讯录API的权限:读取或者编辑通讯录。

获取通讯录密钥的目的:

        通过企业ID(CorpId)和 通讯录密钥可以获取通讯录相关接口的使用凭证(AccessToken)。有了AccessToken,就可以使用通讯录相关接口了。

凭证的获取方式有两种(此处暂时存疑,以待勘误):

通讯录AccessToken:CorpId+通讯录密钥

其他AccessToken:CorpId+应用密钥

 2.json序列化

2.1序列化和反序列化的概念

把对象转换为字节序列的过程称为对象的序列化

把字节序列恢复为对象的过程称为对象的反序列化

2.2对象的序列化的目的

  1) 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;   2) 在网络上传送对象的字节序列。

2.3java序列化方式

(1)java原生序列化

(2)json序列化  

而json序列化可使用 ① json-lib

                                 ②fastJson

                                 ③gson

2.4json序列化与反序列化

这里我们采用gson来实现java对象的序列化,需要引入  gson-2.7.jar 包。

(1)简单的Jason

{
   "userid": "zhangsan",
   "name": "张三",
   "english_name": "jackzhang"
 
}

使用gson.toJson(user)即可将user对象顺序转成json字符串,如下

    Gson gson = new Gson(); 
    String jsonU1 =gson.toJson(user); 

(2)带数组的json

将department设为list<Integer>类型即可

{
   "userid": "zhangsan",
   "name": "张三",
   "english_name": "jackzhang"
   "department": [1, 2],

}

(3)包含子对象的json

以下代码为文本消息的json字符串,将text属性类型设为Text,Text类中包含content属性。然后使用 gson.toJson(user) 

{
   "msgtype" : "text",
   "agentid" : 1,
   "text" : {
       "content" : "你的快递已到,请携带工卡前往邮件中心领取。\n出发前可查看<a href=\"http://work.weixin.qq.com\">邮件中心视频实况</a>,聪明避开排队。"
   },
 
}

关于Json序列化,读者在 Java企业微信开发_05_消息推送之发送消息 这一节会有更深刻的理解,这一周将会继续总结。

3.企业微信开发思路

企业微信的开发大体可分为以下几步:

(1)封装实体类

       参考官方文档给出的请求包、回包(即响应包),封装对应的java实体类。

(2)java对象的序列化

       将java对象序列化为json格式的字符串

(3)获取AccessToken,拼接请求接口url

(4)调用接口发送http请求

封装好http请求方法:httpRequest(请求url, 请求方法POST/GET, 请求包);  

 1 /**
 2      * 1.发起https请求并获取结果 
 3      *  
 4      * @param requestUrl 请求地址 
 5      * @param requestMethod 请求方式(GET、POST) 
 6      * @param outputStr 提交的数据 
 7      * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值) 
 8      */  
 9     public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {  
10         JSONObject jsonObject = null;  
11         StringBuffer buffer = new StringBuffer();  
12         try {  
13             // 创建SSLContext对象,并使用我们指定的信任管理器初始化  
14             TrustManager[] tm = { new MyX509TrustManager() };  
15             SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");  
16             sslContext.init(null, tm, new java.security.SecureRandom());  
17             // 从上述SSLContext对象中得到SSLSocketFactory对象  
18             SSLSocketFactory ssf = sslContext.getSocketFactory();  
19 
20             URL url = new URL(requestUrl);  
21             HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();  
22             httpUrlConn.setSSLSocketFactory(ssf);  
23 
24             httpUrlConn.setDoOutput(true);  
25             httpUrlConn.setDoInput(true);  
26             httpUrlConn.setUseCaches(false);  
27             // 设置请求方式(GET/POST)  
28             httpUrlConn.setRequestMethod(requestMethod);  
29 
30             if ("GET".equalsIgnoreCase(requestMethod))  
31                 httpUrlConn.connect();  
32 
33             // 当有数据需要提交时  
34             if (null != outputStr) {  
35                 OutputStream outputStream = httpUrlConn.getOutputStream();  
36                 // 注意编码格式,防止中文乱码  
37                 outputStream.write(outputStr.getBytes("UTF-8"));  
38                 outputStream.close();  
39             }  
40 
41             // 将返回的输入流转换成字符串  
42             InputStream inputStream = httpUrlConn.getInputStream();  
43             InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");  
44             BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
45 
46             String str = null;  
47             while ((str = bufferedReader.readLine()) != null) {  
48                 buffer.append(str);  
49             }  
50             bufferedReader.close();  
51             inputStreamReader.close();  
52             // 释放资源  
53             inputStream.close();  
54             inputStream = null;  
55             httpUrlConn.disconnect();  
56             jsonObject = JSONObject.fromObject(buffer.toString());  
57         } catch (ConnectException ce) {  
58             log.error("Weixin server connection timed out.");  
59         } catch (Exception e) {  
60             log.error("https request error:{}", e);  
61         }  
62         return jsonObject;  
63     }  

二、代码实现

相关jar包:

2.1 工具类之微信参数封装类——WeiXinParamesUtil.java

此类封装了微信的相关参数,如企业id、应用凭证、通讯录凭证等。封装起来更易维护,实现一处修改多处改变。

 1 package com.ray.util;
 2 /**
 3  * 微信参数
 4  * @author shirayner
 5  *
 6  */
 7 public class WeiXinParamesUtil {
 8     //1.微信参数
 9     //token
10     public final static String token = "ray";
11     // encodingAESKey
12     public final static String encodingAESKey = "z2W9lyOAR1XjY8mopEmiSqib0TlBZzCFiCLp6IdS2Iv";
13     //企业ID
14     public final static String corpId = "ww92f5da92bb24696e";
15 
16     //应用的凭证密钥
17     public final static String agentSecret = "I73733veH3uCs6H_ijPvIq0skjTaOePsFF4MyCEi3Ag";
18     //通讯录秘钥
19     public final static String contactsSecret = "1m_9XP62YrXjSiYtL5ThbexiLVWBThukiK5sH7wm1TM";
20 
21     //企业应用的id,整型。可在应用的设置页面查看
22     public final static int agentId = 1000002;
23 
24 }

2.2 工具类之微信辅助类——WeiXinUtil.java

此类封装了http请求、https请求、获取accessToken的方法

  1 package com.ray.util;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.InputStream;
  5 import java.io.InputStreamReader;
  6 import java.io.OutputStream;
  7 import java.net.ConnectException;
  8 import java.net.HttpURLConnection;
  9 import java.net.URL;
 10 import javax.net.ssl.HttpsURLConnection;
 11 import javax.net.ssl.SSLContext;
 12 import javax.net.ssl.SSLSocketFactory;
 13 import javax.net.ssl.TrustManager;
 14 import org.slf4j.Logger;
 15 import org.slf4j.LoggerFactory;
 16 import com.ray.pojo.AccessToken;
 17 import net.sf.json.JSONException;
 18 import net.sf.json.JSONObject;
 19 
 20 public class WeiXinUtil {
 21 
 22     private static Logger log = LoggerFactory.getLogger(WeiXinUtil.class);  
 23     //微信的请求url
 24     //获取access_token的接口地址(GET) 限200(次/天)  
 25     public final static String access_token_url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={corpId}&corpsecret={corpsecret}";  
 26 
 27 
 28 
 29     /**
 30      * 1.发起https请求并获取结果 
 31      *  
 32      * @param requestUrl 请求地址 
 33      * @param requestMethod 请求方式(GET、POST) 
 34      * @param outputStr 提交的数据 
 35      * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值) 
 36      */  
 37     public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {  
 38         JSONObject jsonObject = null;  
 39         StringBuffer buffer = new StringBuffer();  
 40         try {  
 41             // 创建SSLContext对象,并使用我们指定的信任管理器初始化  
 42             TrustManager[] tm = { new MyX509TrustManager() };  
 43             SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");  
 44             sslContext.init(null, tm, new java.security.SecureRandom());  
 45             // 从上述SSLContext对象中得到SSLSocketFactory对象  
 46             SSLSocketFactory ssf = sslContext.getSocketFactory();  
 47 
 48             URL url = new URL(requestUrl);  
 49             HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();  
 50             httpUrlConn.setSSLSocketFactory(ssf);  
 51 
 52             httpUrlConn.setDoOutput(true);  
 53             httpUrlConn.setDoInput(true);  
 54             httpUrlConn.setUseCaches(false);  
 55             // 设置请求方式(GET/POST)  
 56             httpUrlConn.setRequestMethod(requestMethod);  
 57 
 58             if ("GET".equalsIgnoreCase(requestMethod))  
 59                 httpUrlConn.connect();  
 60 
 61             // 当有数据需要提交时  
 62             if (null != outputStr) {  
 63                 OutputStream outputStream = httpUrlConn.getOutputStream();  
 64                 // 注意编码格式,防止中文乱码  
 65                 outputStream.write(outputStr.getBytes("UTF-8"));  
 66                 outputStream.close();  
 67             }  
 68 
 69             // 将返回的输入流转换成字符串  
 70             InputStream inputStream = httpUrlConn.getInputStream();  
 71             InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");  
 72             BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
 73 
 74             String str = null;  
 75             while ((str = bufferedReader.readLine()) != null) {  
 76                 buffer.append(str);  
 77             }  
 78             bufferedReader.close();  
 79             inputStreamReader.close();  
 80             // 释放资源  
 81             inputStream.close();  
 82             inputStream = null;  
 83             httpUrlConn.disconnect();  
 84             jsonObject = JSONObject.fromObject(buffer.toString());  
 85         } catch (ConnectException ce) {  
 86             log.error("Weixin server connection timed out.");  
 87         } catch (Exception e) {  
 88             log.error("https request error:{}", e);  
 89         }  
 90         return jsonObject;  
 91     }  
 92 
 93     /** 
 94      * 2.发起http请求获取返回结果 
 95      *  
 96      * @param requestUrl 请求地址 
 97      * @return 
 98      */  
 99     public static String httpRequest(String requestUrl) {  
100         StringBuffer buffer = new StringBuffer();  
101         try {  
102             URL url = new URL(requestUrl);  
103             HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();  
104 
105             httpUrlConn.setDoOutput(false);  
106             httpUrlConn.setDoInput(true);  
107             httpUrlConn.setUseCaches(false);  
108 
109             httpUrlConn.setRequestMethod("GET");  
110             httpUrlConn.connect();  
111 
112             // 将返回的输入流转换成字符串  
113             InputStream inputStream = httpUrlConn.getInputStream();  
114             InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");  
115             BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
116 
117             String str = null;  
118             while ((str = bufferedReader.readLine()) != null) {  
119                 buffer.append(str);  
120             }  
121             bufferedReader.close();  
122             inputStreamReader.close();  
123             // 释放资源  
124             inputStream.close();  
125             inputStream = null;  
126             httpUrlConn.disconnect();  
127 
128         } catch (Exception e) {  
129         }  
130         return buffer.toString();  
131     }  
132 
133 
134     /** 
135      * 3.获取access_token 
136      *  
137      * @param appid 凭证 
138      * @param appsecret 密钥 
139      * @return 
140      */  
141     public static AccessToken getAccessToken(String appid, String appsecret) {  
142         AccessToken accessToken = null;  
143 
144         String requestUrl = access_token_url.replace("{corpId}", appid).replace("{corpsecret}", appsecret);  
145         JSONObject jsonObject = httpRequest(requestUrl, "GET", null);  
146         // 如果请求成功  
147         if (null != jsonObject) {  
148             try {  
149                 accessToken = new AccessToken();  
150                 accessToken.setToken(jsonObject.getString("access_token"));  
151                 accessToken.setExpiresIn(jsonObject.getInt("expires_in"));  
152             } catch (JSONException e) {  
153                 accessToken = null;  
154                 // 获取token失败  
155                 log.error("获取token失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
156             }  
157         }  
158         return accessToken;  
159     }  
160 
161 
162 }

发送https请求需要一个证书信任管理器,所以此类依赖于MyX509TrustManager.java

 1 package com.ray.util;  
 2   
 3 import java.security.cert.CertificateException;  
 4 import java.security.cert.X509Certificate;  
 5   
 6 import javax.net.ssl.X509TrustManager;  
 7   
 8 /** 
 9  * 证书信任管理器(用于https请求) 
10  *  
11  * @author liufeng 
12  * @date 2013-08-08 
13  */  
14 public class MyX509TrustManager implements X509TrustManager {  
15   
16     public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
17     }  
18   
19     public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
20     }  
21   
22     public X509Certificate[] getAcceptedIssuers() {  
23         return null;  
24     }  
25 }  

2.3 实体类之凭证封装类——AccessToken.java

 1 package com.ray.pojo;  
 2   
 3 /**
 4  * @desc  : 微信通用接口凭证 
 5  * 
 6  * @author: shirayner
 7  * @date  : 2017-8-20 下午9:35:11
 8  */
 9 public class AccessToken {  
10     // 获取到的凭证  
11     private String token;  
12     // 凭证有效时间,单位:秒  
13     private int expiresIn;  
14   
15     public String getToken() {  
16         return token;  
17     }  
18   
19     public void setToken(String token) {  
20         this.token = token;  
21     }  
22   
23     public int getExpiresIn() {  
24         return expiresIn;  
25     }  
26   
27     public void setExpiresIn(int expiresIn) {  
28         this.expiresIn = expiresIn;  
29     }  
30 }  

2.4 实体类之用户类——User.java

注:这两个实体类只添加了User的部分属性,如有需要,读者可根据官方文档自行添加相关属性。

 1 package com.ray.pojo;
 2 
 3 public class User {
 4     private String userid;
 5     private String name;
 6     private int department;
 7     private String mobile;
 8     private String email;
 9     private String position;
10     private String gender;
11     
12     public User(){};
13     public User(String userid, String name, int department, String mobile,
14             String email, String position, String gender) {
15         super();
16         this.userid = userid;
17         this.name = name;
18         this.department = department;
19         this.mobile = mobile;
20         this.email = email;
21         this.position = position;
22         this.gender = gender;
23     }
24     public String getUserid() {
25         return userid;
26     }
27     public void setUserid(String userid) {
28         this.userid = userid;
29     }
30     public String getName() {
31         return name;
32     }
33     public void setName(String name) {
34         this.name = name;
35     }
36 
37     public int getDepartment() {
38         return department;
39     }
40     public void setDepartment(int department) {
41         this.department = department;
42     }
43     public String getMobile() {
44         return mobile;
45     }
46     public void setMobile(String mobile) {
47         this.mobile = mobile;
48     }
49     public String getEmail() {
50         return email;
51     }
52     public void setEmail(String email) {
53         this.email = email;
54     }
55     public String getPosition() {
56         return position;
57     }
58     public void setPosition(String position) {
59         this.position = position;
60     }
61     public String getGender() {
62         return gender;
63     }
64     public void setGender(String gender) {
65         this.gender = gender;
66     }
67     @Override
68     public String toString() {
69         return "User [userid=" + userid + ", name=" + name + ", department="
70                 + department + ", mobile=" + mobile + ", email=" + email
71                 + ", position=" + position + ", gender=" + gender + "]";
72     }
73     
74     public String toJson(){
75          String str="{\"userid\": %s,\"name\": %s,\"department\": [1],\"mobile\": %s,\"email\": %s,\"gender\": %s}";  
76 
77         return String.format(str,this.userid,this.name,this.mobile,this.email,this.gender); 
78     }
79     
80     
81 }

2.5 实体类之部门类——Department.java

 1 package com.ray.pojo;
 2 
 3 public class Department {
 4     private int id ;
 5     private String name;
 6     private int parentid;
 7     private int order;
 8     
 9     
10     
11     public Department(int id, String name, int parentid) {
12         super();
13         this.id = id;
14         this.name = name;
15         this.parentid = parentid;
16     }
17     public int getId() {
18         return id;
19     }
20     public void setId(int id) {
21         this.id = id;
22     }
23     public String getName() {
24         return name;
25     }
26     public void setName(String name) {
27         this.name = name;
28     }
29     public int getParentid() {
30         return parentid;
31     }
32     public void setParentid(int parentid) {
33         this.parentid = parentid;
34     }
35     public int getOrder() {
36         return order;
37     }
38     public void setOrder(int order) {
39         this.order = order;
40     }
41     
42     
43 }

2.6 业务类之通讯录用户业务类——Contacts_UserService

  1 package com.ray.service;
  2 
  3 import java.util.HashMap;
  4 import java.util.List;
  5 import java.util.Map;
  6 
  7 import net.sf.json.JSONObject;
  8 
  9 import org.slf4j.Logger;
 10 import org.slf4j.LoggerFactory;
 11 
 12 import com.google.gson.Gson;
 13 import com.ray.pojo.User;
 14 import com.ray.test.UserTest;
 15 import com.ray.util.WeiXinUtil;
 16 
 17 public class Contacts_UserService {
 18     private static Logger log = LoggerFactory.getLogger(UserTest.class);  
 19 
 20     private  static  String createUser_url="https://qyapi.weixin.qq.com/cgi-bin/user/create?access_token=ACCESS_TOKEN";  
 21     private  static  String getUser_url="https://qyapi.weixin.qq.com/cgi-bin/user/get?access_token=ACCESS_TOKEN&userid=USERID";  
 22     private  static  String updateUser_url="https://qyapi.weixin.qq.com/cgi-bin/user/update?access_token=ACCESS_TOKEN";  
 23     private  static  String deleteUser_url="https://qyapi.weixin.qq.com/cgi-bin/user/delete?access_token=ACCESS_TOKEN&userid=USERID";  
 24     private  static  String batchdeleteUser_url="https://qyapi.weixin.qq.com/cgi-bin/user/batchdelete?access_token=ACCESS_TOKEN";  
 25     private  static  String getDepartmentUser_url="https://qyapi.weixin.qq.com/cgi-bin/user/simplelist?access_token=ACCESS_TOKEN&department_id=DEPARTMENT_ID&fetch_child=FETCH_CHILD";  
 26     private  static  String getDepartmentUserDetails_url="https://qyapi.weixin.qq.com/cgi-bin/user/list?access_token=ACCESS_TOKEN&department_id=DEPARTMENT_ID&fetch_child=FETCH_CHILD";  
 27 
 28     
 29     //1.创建成员
 30     public void createUser(String accessToken,User user) {
 31 
 32         //1.获取json字符串:将user对象转换为json字符串    
 33         Gson gson = new Gson(); 
 34         String jsonU1 =gson.toJson(user);      //使用gson.toJson(user)即可将user对象顺序转成json
 35         System.out.println("jsonU1:"+jsonU1);
 36 
 37 
 38         //2.获取请求的url  
 39         createUser_url=createUser_url.replace("ACCESS_TOKEN", accessToken);
 40 
 41         //3.调用接口,发送请求,创建成员
 42         JSONObject jsonObject = WeiXinUtil.httpRequest(createUser_url, "POST", jsonU1);  
 43         System.out.println("jsonObject:"+jsonObject.toString());
 44 
 45         //4.错误消息处理
 46         if (null != jsonObject) {  
 47             if (0 != jsonObject.getInt("errcode")) {  
 48                 log.error("创建成员失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 49             }  
 50         }  
 51     }
 52 
 53     //2.获取成员
 54     public void getUser(String accessToken,String userId) {
 55 
 56         //1.获取请求的url  
 57         getUser_url=getUser_url.replace("ACCESS_TOKEN", accessToken)
 58                 .replace("USERID", userId);
 59 
 60         //2.调用接口,发送请求,获取成员
 61         JSONObject jsonObject = WeiXinUtil.httpRequest(getUser_url, "GET", null);  
 62         System.out.println("jsonObject:"+jsonObject.toString());
 63 
 64         //3.错误消息处理
 65         if (null != jsonObject) {  
 66             if (0 != jsonObject.getInt("errcode")) {  
 67                 log.error("获取成员失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 68             }  
 69         }  
 70     }
 71 
 72     //3.更新成员
 73     public void updateUser(String accessToken,User user) {
 74 
 75         //1.获取json字符串:将user对象转换为json字符串    
 76         Gson gson = new Gson(); 
 77         String jsonU1 =gson.toJson(user);      //使用gson.toJson(user)即可将user对象顺序转成json
 78         System.out.println("jsonU1:"+jsonU1);
 79 
 80 
 81         //2.获取请求的url  
 82         updateUser_url=updateUser_url.replace("ACCESS_TOKEN", accessToken);
 83 
 84         //3.调用接口,发送请求,创建成员
 85         JSONObject jsonObject = WeiXinUtil.httpRequest(updateUser_url, "POST", jsonU1);  
 86         System.out.println("jsonObject:"+jsonObject.toString());
 87 
 88         //4.错误消息处理
 89         if (null != jsonObject) {  
 90             if (0 != jsonObject.getInt("errcode")) {  
 91                 log.error("更新成员失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 92             }  
 93         }  
 94     }
 95 
 96     //4.删除成员
 97     public void deleteUser(String accessToken,String userId) {    
 98 
 99         //1.获取请求的url  
100         deleteUser_url=deleteUser_url.replace("ACCESS_TOKEN", accessToken)
101                 .replace("USERID", userId);
102 
103         //2.调用接口,发送请求,删除成员
104         JSONObject jsonObject = WeiXinUtil.httpRequest(deleteUser_url, "GET", null);  
105         System.out.println("jsonObject:"+jsonObject.toString());
106 
107         //3.错误消息处理
108         if (null != jsonObject) {  
109             if (0 != jsonObject.getInt("errcode")) {  
110                 log.error("删除成员失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
111             }  
112         }  
113     }
114 
115     //5.批量删除成员
116     public void batchdeleteUser(String accessToken,List<String> userIdList){
117         //1.获取json字符串:将user对象转换为json字符串    
118         Map<String, Object> content = new HashMap<String, Object>();  
119         content.put("useridlist", userIdList);  
120 
121         Gson gson=new Gson();
122         String useridlist=gson.toJson(content);
123         System.out.println(useridlist);
124 
125         //2.获取请求的url  
126         batchdeleteUser_url=batchdeleteUser_url.replace("ACCESS_TOKEN", accessToken);
127 
128         //3.调用接口,发送请求,创建成员
129         JSONObject jsonObject = WeiXinUtil.httpRequest(batchdeleteUser_url, "POST", useridlist);  
130         System.out.println("jsonObject:"+jsonObject.toString());
131 
132         //4.错误消息处理
133         if (null != jsonObject) {  
134             if (0 != jsonObject.getInt("errcode")) {  
135                 log.error("批量删除成员失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
136             }  
137         }  
138     }
139 
140 
141     //6.获取部门成员
142     public void getDepartmentUser(String accessToken,String departmentId,String fetchChild) {
143 
144         //1.获取请求的url  
145         getDepartmentUser_url=getDepartmentUser_url.replace("ACCESS_TOKEN", accessToken)
146                 .replace("DEPARTMENT_ID", departmentId)
147                 .replace("FETCH_CHILD", fetchChild);
148 
149         //2.调用接口,发送请求,获取部门成员
150         JSONObject jsonObject = WeiXinUtil.httpRequest(getDepartmentUser_url, "GET", null);  
151         System.out.println("jsonObject:"+jsonObject.toString());
152 
153         //3.错误消息处理
154         if (null != jsonObject) {  
155             if (0 != jsonObject.getInt("errcode")) {  
156                 log.error("获取部门成员失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
157             }  
158         }  
159     }
160 
161 
162     //7.获取部门成员详情
163     public void getDepartmentUserDetails(String accessToken,String departmentId,String fetchChild) {
164         //1.获取请求的url  
165         getDepartmentUserDetails_url=getDepartmentUserDetails_url.replace("ACCESS_TOKEN", accessToken)
166                 .replace("DEPARTMENT_ID", departmentId)
167                 .replace("FETCH_CHILD", fetchChild);
168 
169         //2.调用接口,发送请求,获取部门成员
170         JSONObject jsonObject = WeiXinUtil.httpRequest(getDepartmentUserDetails_url, "GET", null);  
171         System.out.println("jsonObject:"+jsonObject.toString());
172 
173         //3.错误消息处理
174         if (null != jsonObject) {  
175             if (0 != jsonObject.getInt("errcode")) {  
176                 log.error("获取部门成员详情失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
177             }  
178         }  
179     }
180 
181 }

2.7 业务类之通讯录部门业务类

  1 package com.ray.service;
  2 
  3 import net.sf.json.JSONObject;
  4 import org.slf4j.Logger;
  5 import org.slf4j.LoggerFactory;
  6 import com.google.gson.Gson;
  7 import com.ray.pojo.Department;
  8 import com.ray.test.DepartmentTest;
  9 import com.ray.util.WeiXinUtil;
 10 
 11 public class Contacts_DepartmentService {
 12     private static Logger log = LoggerFactory.getLogger(DepartmentTest.class);  
 13 
 14     private  static  String createDepartment_url="https://qyapi.weixin.qq.com/cgi-bin/department/create?access_token=ACCESS_TOKEN";  
 15     private  static  String updateDepartment_url="https://qyapi.weixin.qq.com/cgi-bin/department/update?access_token=ACCESS_TOKEN";  
 16     private  static  String deleteDepartment_url="https://qyapi.weixin.qq.com/cgi-bin/department/delete?access_token=ACCESS_TOKEN&id=ID";  
 17     private  static  String getDepartmentList_url="https://qyapi.weixin.qq.com/cgi-bin/department/list?access_token=ACCESS_TOKEN&id=ID";  
 18 
 19     
 20     //1.创建部门
 21     public void createDepartment(String accessToken,Department department) {
 22 
 23         //1.获取json字符串:将Department对象转换为json字符串    
 24         Gson gson = new Gson(); 
 25         String jsonDepartment =gson.toJson(department);      //使用gson.toJson(jsonDepartment)即可将jsonDepartment对象顺序转成json
 26         System.out.println("jsonDepartment:"+jsonDepartment);
 27         //2.拼接请求的url
 28         createDepartment_url=createDepartment_url.replace("ACCESS_TOKEN", accessToken);
 29 
 30         //3.调用接口,发送请求,创建部门
 31         JSONObject jsonObject = WeiXinUtil.httpRequest(createDepartment_url, "POST", jsonDepartment);  
 32         System.out.println("jsonObject:"+jsonObject.toString());
 33         if (null != jsonObject) {  
 34             if (0 != jsonObject.getInt("errcode")) {  
 35 
 36                 log.error("创建部门失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 37             }  
 38         }  
 39     }
 40 
 41     //2.更新部门
 42     public void updateDepartment(String accessToken,Department department) {
 43 
 44         //1.获取json字符串:将Department对象转换为json字符串    
 45         Gson gson = new Gson(); 
 46         String jsonDepartment =gson.toJson(department);      //使用gson.toJson(jsonDepartment)即可将jsonDepartment对象顺序转成json
 47         System.out.println("jsonDepartment:"+jsonDepartment);
 48         //2.拼接请求的url
 49         updateDepartment_url=updateDepartment_url.replace("ACCESS_TOKEN", accessToken);
 50 
 51         //3.调用接口,发送请求,更新部门
 52         JSONObject jsonObject = WeiXinUtil.httpRequest(updateDepartment_url, "POST", jsonDepartment);  
 53         System.out.println("jsonObject:"+jsonObject.toString());
 54         if (null != jsonObject) {  
 55             if (0 != jsonObject.getInt("errcode")) {  
 56 
 57                 log.error("更新部门失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 58             }  
 59         }  
 60     }
 61     
 62 
 63     //3.删除部门
 64     public void deleteDepartment(String accessToken,String departmentId) {    
 65 
 66         //1.获取请求的url  
 67         deleteDepartment_url=deleteDepartment_url.replace("ACCESS_TOKEN", accessToken)
 68                 .replace("ID", departmentId);
 69 
 70         //2.调用接口,发送请求,删除部门
 71         JSONObject jsonObject = WeiXinUtil.httpRequest(deleteDepartment_url, "GET", null);  
 72         System.out.println("jsonObject:"+jsonObject.toString());
 73 
 74         //3.错误消息处理
 75         if (null != jsonObject) {  
 76             if (0 != jsonObject.getInt("errcode")) {  
 77                 log.error("删除部门失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 78             }  
 79         }  
 80     }
 81     
 82     
 83     
 84     //4.获取部门列表
 85     public void getDepartmentList(String accessToken,String departmentId) {
 86 
 87         //1.获取请求的url  
 88         getDepartmentList_url=getDepartmentList_url.replace("ACCESS_TOKEN", accessToken)
 89                 .replace("ID", departmentId);
 90 
 91         //2.调用接口,发送请求,获取成员
 92         JSONObject jsonObject = WeiXinUtil.httpRequest(getDepartmentList_url, "GET", null);  
 93         System.out.println("jsonObject:"+jsonObject.toString());
 94 
 95         //3.错误消息处理
 96         if (null != jsonObject) {  
 97             if (0 != jsonObject.getInt("errcode")) {  
 98                 log.error("获取部门列表 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));  
 99             }  
100         }  
101     }
102 
103 
104 }

2.8 测试类之用户测试类-UserTest.java

  1 package com.ray.test;
  2 
  3 import java.util.Arrays;
  4 import java.util.List;
  5 
  6 import org.junit.Test;
  7 
  8 import com.ray.pojo.User;
  9 import com.ray.service.Contacts_UserService;
 10 import com.ray.util.WeiXinParamesUtil;
 11 import com.ray.util.WeiXinUtil;
 12 
 13 /**
 14  * 成员管理
 15  * @author shirayner
 16  *
 17  *要注意的地方:
 18  *1.开启通讯录同步之后,才能进行通讯录的相关操作
 19  *2.对通讯录操作的凭证access_token,由企业id-cropId和通讯录秘钥secret(而不是应用秘钥)获取。
 20  *3.创建成员需要开启通讯录的编辑权限。(管理工具-通讯录同步)
 21  *4.java对象转json: 用gson.toJson(user)即可将user对象顺序转成json
 22  */
 23 
 24 public class UserTest {
 25 
 26     //1.创建成员
 27     @Test
 28     public void testCreateUser() {
 29         //1.创建user对象
 30         //User user = new User("3", "ray", 1,"13886086292","3057046319@qq.com","技术顾问","1");  
 31         User user = new User("4", "jack", 1,"13986086293","4057046319@qq.com","咨询顾问","1");  
 32         //User user = new User("5", "tom", 1,"14986086294","5057046319@qq.com","产品经理","1");  
 33 
 34         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
 35         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
 36         System.out.println("accessToken:"+accessToken);
 37 
 38         //3.创建成员
 39         Contacts_UserService cus=new Contacts_UserService();
 40         cus.createUser(accessToken,user);
 41 
 42     }
 43 
 44 
 45     //2.获取成员
 46     @Test
 47     public void testGetUser() {
 48         //1.获取userId
 49         //String userId="ShiRui";
 50         String userId="4";
 51 
 52         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
 53         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
 54         System.out.println("accessToken:"+accessToken);
 55 
 56         //3.获取成员
 57         Contacts_UserService cus=new Contacts_UserService();
 58         cus.getUser(userId, accessToken);
 59     }
 60 
 61     //3.更新成员
 62     @Test
 63     public void testUpdateUser() {
 64 
 65         //1.更改user对象信息
 66         //User user = new User("3", "ray", 1,"13886086292","3057046319@qq.com","技术顾问","1");  
 67         //User user = new User("4", "jack", 1,"13986086293","4057046319@qq.com","咨询顾问","1");  
 68         User user = new User("3", "ray", 1,"13889086292","3057946319@qq.com","咨询顾问","1");  
 69 
 70         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
 71         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
 72         System.out.println("accessToken:"+accessToken);
 73 
 74         //3.创建成员
 75         Contacts_UserService cus=new Contacts_UserService();
 76         cus.updateUser( accessToken,user);
 77 
 78     }
 79 
 80     //4.删除成员
 81     @Test
 82     public void testDeleteUser() {
 83         //1.获取userId
 84         //String userId="ShiRui";
 85         String userId="4";
 86 
 87         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
 88         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
 89         System.out.println("accessToken:"+accessToken);
 90 
 91         //3.创建成员
 92         Contacts_UserService cus=new Contacts_UserService();
 93         cus.deleteUser(userId, accessToken);
 94     }
 95 
 96 
 97     //5.批量删除成员
 98     @Test
 99     public void testbatchdeleteUser() {
100         //1.获取userIdList
101         String userId1="3";
102         String userId2="4";
103         List<String> userIdList = Arrays.asList(userId1, userId2);  //此时将userIdList转json,则结果为:["3","4"],会报错:{"errcode":40063,"errmsg":"some parameters are empty"}
104 
105         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
106         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
107         System.out.println("accessToken:"+accessToken);
108 
109         //3.批量删除成员
110         Contacts_UserService cus=new Contacts_UserService();
111         cus.batchdeleteUser(accessToken,userIdList);
112     }
113 
114 
115     //6.获取部门成员
116     @Test
117     public void testGetDepartmentUser() {
118         //1.获取部门ID以及是否获取子部门成员
119         String departmentId="1";
120         String fetchChild="0";
121 
122         //2.获取accessToken:根据企业id和通讯录密钥获取access_token,并拼接请求url
123         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
124         System.out.println("accessToken:"+accessToken);
125 
126         //3.获取部门成员
127         Contacts_UserService cus=new Contacts_UserService();
128         cus.getDepartmentUser(accessToken, departmentId, fetchChild);
129     }
130 
131 
132     //7.获取部门成员详情
133     @Test 
134     public void testGetDepartmentUserDetails() {
135         //1.获取部门ID以及是否获取子部门成员
136         String departmentId="1";
137         String fetchChild="0";
138 
139         //2.获取accessToken:根据企业id和通讯录密钥获取access_token,并拼接请求url
140         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
141         System.out.println("accessToken:"+accessToken);
142 
143         //3.获取部门成员
144         Contacts_UserService cus=new Contacts_UserService();
145         cus.getDepartmentUserDetails(accessToken, departmentId, fetchChild);
146     }
147 }

 2.9 测试类之部门测试类-DepartmentTest.java

 1 package com.ray.test;
 2 
 3 import org.junit.Test;
 4 import com.ray.pojo.Department;
 5 import com.ray.service.Contacts_DepartmentService;
 6 import com.ray.util.WeiXinParamesUtil;
 7 import com.ray.util.WeiXinUtil;
 8 
 9 /**
10  * 部门管理
11  * @author shirayner
12  *
13  *
14  */
15 
16 public class DepartmentTest {
17 
18 
19     //1.创建部门
20     @Test
21     public void testCreateDepartment() {
22         //1.创建Department对象,并将对象转换成json字符串  
23         Department department = new Department(3, "HEC武汉分公司", 2);  
24         //Department department = new Department(2, "HEC技术中心", 1);  
25 
26         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
27         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
28         System.out.println("accessToken:"+accessToken);
29 
30         //3.创建部门
31         Contacts_DepartmentService cds= new Contacts_DepartmentService();
32         cds.createDepartment(accessToken, department);
33     }
34 
35 
36     //2.更新部门
37     @Test
38     public void testUpdateDepartment() {
39         //1.创建Department对象,并将对象转换成json字符串  
40         Department department = new Department(2, "HEC技术服务中心", 1);  
41 
42 
43         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
44         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
45         System.out.println("accessToken:"+accessToken);
46 
47         //3.更新部门
48         Contacts_DepartmentService cds= new Contacts_DepartmentService();
49         cds.updateDepartment(accessToken, department);
50     }
51 
52     //3.删除部门
53     @Test
54     public void testDeleteDepartment() {
55         //1.获取userId
56         String departmentId="3";
57 
58         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
59         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
60         System.out.println("accessToken:"+accessToken);
61 
62         //3.删除部门
63         Contacts_DepartmentService cds= new Contacts_DepartmentService();
64         cds.deleteDepartment(accessToken, departmentId);
65     }
66 
67 
68     /**
69      * 4.获取部门列表
70      * 参数                  必须    说明
71      * access_token    是    调用接口凭证
72      * id                    否     部门id。获取指定部门及其下的子部门。 如果不填,默认获取全量组织架构
73      */
74     @Test
75     public void testGetDepartmentList() {
76         //1.获取departmentId
77         String departmentId="1";
78 
79         //2.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
80         String accessToken= WeiXinUtil.getAccessToken(WeiXinParamesUtil.corpId, WeiXinParamesUtil.contactsSecret).getToken();
81         System.out.println("accessToken:"+accessToken);
82 
83         //3.调用接口,发送请求,删除部门
84         Contacts_DepartmentService cds= new Contacts_DepartmentService();
85         cds.getDepartmentList(accessToken, departmentId);
86     }
87 
88 
89 }

三、参考资料

1.微信企业号官方开发文档:https://work.weixin.qq.com/api/doc#10016

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏个人分享

Hive metastore源码阅读(一)

  不要问我为什么,因为爱,哈哈哈哈。。。进入正题,最近做项目顺带学习了下hive metastore的源码,进行下知识总结。

2851
来自专栏木宛城主

PowerShell 获取Site Collection下被签出的文件

由于权限的设置,当文件被签出时导致别人不可见了,这对校验文件个数的人来说着实是件烦恼的事。幸好利用PowerShell,可以获取Site Collection下...

2037
来自专栏数据结构与算法

洛谷P2925 [USACO08DEC]干草出售Hay For Sale

题目描述 Farmer John suffered a terrible loss when giant Australian cockroaches ate ...

2984
来自专栏Spark生态圈

[Spark SQL] 源码解析之Optimizer

optimizer 以及之后的模块都只会在触发了action操作后才会执行。优化器是用来将Resolved LogicalPlan转化为optimized Lo...

1052
来自专栏小筱月

java 开发 face++ 人脸特征识别系统

首先要在 face++ 注册一个账号,并且创建一个应用,拿到 api key 和 api secret;

3131
来自专栏DT乱“码”

接口测试类(http,post请求)参数 json格式

package RMI; import java.io.BufferedReader; import java.io.DataOutputStream; im...

2459
来自专栏拂晓风起

jQuery 和 json 简单例子(注意callback函数的处理!!) (servlet返回json,jquery更新,java json)

1233
来自专栏Java 技术分享

Ajax 案例之三级联动

3446
来自专栏码匠的流水账

聊聊jesque的WorkerImpl与WorkerPool

Resque是一个使用redis来创建后台任务的ruby组件。而jesque是其java版本。通常用来做延时队列。

761
来自专栏函数式编程语言及工具

Akka(8): 分布式运算:Remoting-远程查找式

  Akka是一种消息驱动运算模式,它实现跨JVM程序运算的方式是通过能跨JVM的消息系统来调动分布在不同JVM上ActorSystem中的Actor进行运算,...

4369

扫码关注云+社区

领取腾讯云代金券