devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java对接腾讯IM即时通话_java实现im通讯

作者：凡人多烦事01 | 2024-03-02 02:43:27

赞

踩

java实现im通讯

一：注册腾讯IM账号

基本配置 - 即时通信 IM - 控制台 (tencent.com)

获得必要的参数：SDKAppID和key(密钥)

 二：参考管饭API文档进行操作：

即时通信 IM 单发单聊消息-服务端 API-文档中心-腾讯云 (tencent.com)

 三：java中应用：

依赖：

  1.  
  2. <!--        腾讯云即时对话pom-->
  3.         <dependency>
  4.             <groupId>com.github.tencentyun</groupId>
  5.             <artifactId>tls-sig-api-v2</artifactId>
  6.             <version>2.0</version>
  7.         </dependency>

yml配置：

  1. #腾讯云IM即时通话配置
  2. IMConfig:
  3.   sdkAppId: 140？？？？？？
  4.   secretKey: 59c826？？？你自己的

HttpUtils封装

  1. import com.alibaba.fastjson.JSONObject;
  2. import org.apache.http.Consts;
  3. import org.apache.http.HttpEntity;
  4. import org.apache.http.HttpResponse;
  5. import org.apache.http.NameValuePair;
  6. import org.apache.http.client.HttpClient;
  7. import org.apache.http.client.entity.UrlEncodedFormEntity;
  8. import org.apache.http.client.methods.CloseableHttpResponse;
  9. import org.apache.http.client.methods.HttpGet;
  10. import org.apache.http.client.methods.HttpPost;
  11. import org.apache.http.entity.StringEntity;
  12. import org.apache.http.impl.client.CloseableHttpClient;
  13. import org.apache.http.impl.client.DefaultHttpClient;
  14. import org.apache.http.impl.client.HttpClients;
  15. import org.apache.http.message.BasicNameValuePair;
  16. import org.apache.http.util.EntityUtils;
  17.  
  18. import java.io.IOException;
  19. import java.util.ArrayList;
  20. import java.util.List;
  21. import java.util.Map;
  22.  
  23. public class HttpUtil {
  24.     private static final CloseableHttpClient httpclient = HttpClients.createDefault();
  25.  
  26.     /**
  27.      * 发送HttpGet请求
  28.      * @param url
  29.      * @return
  30.      */
  31.     public static String sendGet(String url) {
  32.  
  33.         HttpGet httpget = new HttpGet(url);
  34.         CloseableHttpResponse response = null;
  35.         try {
  36.             response = httpclient.execute(httpget);
  37.         } catch (IOException e1) {
  38.             e1.printStackTrace();
  39.         }
  40.         String result = null;
  41.         try {
  42.             HttpEntity entity = response.getEntity();
  43.             if (entity != null) {
  44.                 result = EntityUtils.toString(entity);
  45.             }
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         } finally {
  49.             try {
  50.                 response.close();
  51.             } catch (IOException e) {
  52.                 e.printStackTrace();
  53.             }
  54.         }
  55.         return result;
  56.     }
  57.  
  58.     /**
  59.      * 发送HttpPost请求，参数为map
  60.      * @param url
  61.      * @param map
  62.      * @return
  63.      */
  64.     public static String sendPost(String url, Map<String, String> map) {
  65.         List<NameValuePair> formparams = new ArrayList<NameValuePair>();
  66.         for (Map.Entry<String, String> entry : map.entrySet()) {
  67.             formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
  68.         }
  69.         UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
  70.         HttpPost httppost = new HttpPost(url);
  71.         httppost.setEntity(entity);
  72.         CloseableHttpResponse response = null;
  73.         try {
  74.             response = httpclient.execute(httppost);
  75.         } catch (IOException e) {
  76.             e.printStackTrace();
  77.         }
  78.         HttpEntity entity1 = response.getEntity();
  79.         String result = null;
  80.         try {
  81.             result = EntityUtils.toString(entity1);
  82.         } catch (Exception e) {
  83.             e.printStackTrace();
  84.         }
  85.         return result;
  86.     }
  87.  
  88.     /**
  89.      * 发送不带参数的HttpPost请求
  90.      * @param url
  91.      * @return
  92.      */
  93.     public static String sendPost(String url) {
  94.         HttpPost httppost = new HttpPost(url);
  95.         CloseableHttpResponse response = null;
  96.         try {
  97.             response = httpclient.execute(httppost);
  98.         } catch (IOException e) {
  99.             e.printStackTrace();
  100.         }
  101.         HttpEntity entity = response.getEntity();
  102.         String result = null;
  103.         try {
  104.             result = EntityUtils.toString(entity);
  105.         } catch (Exception e) {
  106.             e.printStackTrace();
  107.         }
  108.         return result;
  109.     }
  110.  
  111.     public static String doPost2(String url, JSONObject param) {
  112.         HttpPost httpPost = null;
  113.         String result = null;
  114.         try {
  115.             HttpClient client = new DefaultHttpClient();
  116.             httpPost = new HttpPost(url);
  117.             if (param != null) {
  118.                 StringEntity se = new StringEntity(param.toString(), "utf-8");
  119.                 httpPost.setEntity(se); // post方法中，加入json数据
  120.                 httpPost.setHeader("Content-Type", "application/json");
  121.                 httpPost.setHeader("Authorization", param.getString("authorization"));
  122.             }
  123.  
  124.             HttpResponse response = client.execute(httpPost);
  125.             if (response != null) {
  126.                 HttpEntity resEntity = response.getEntity();
  127.                 if (resEntity != null) {
  128.                     result = EntityUtils.toString(resEntity, "utf-8");
  129.                 }
  130.             }
  131.  
  132.         } catch (Exception ex) {
  133.             ex.printStackTrace();
  134.         }
  135.         return result;
  136.     }
  137. }

Redis封装：

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.*;
  3. import org.springframework.data.redis.support.atomic.RedisAtomicLong;
  4. import org.springframework.stereotype.Component;
  5.  
  6. import java.io.Serializable;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Set;
  10. import java.util.concurrent.TimeUnit;
  11.  
  12. @Component
  13. public class RedisServiceUtil {
  14.     @Autowired
  15.     private RedisTemplate redisTemplate;
  16.     /**
  17.      * 写入缓存
  18.      * @param key
  19.      * @param value
  20.      * @return
  21.      */
  22.     public boolean set(final String key, Object value) {
  23.         boolean result = false;
  24.         try {
  25.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  26.             operations.set(key, value);
  27.             result = true;
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.         return result;
  32.     }
  33.     /**
  34.      * 写入缓存设置时效时间
  35.      * @param key
  36.      * @param value
  37.      * @return
  38.      */
  39.     public boolean set(final String key, Object value, Long expireTime) {
  40.         boolean result = false;
  41.         try {
  42.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  43.             operations.set(key, value);
  44.             redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
  45.             result = true;
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.         return result;
  50.     }
  51.  
  52.     /**
  53.      * 设置指定键的过期时间
  54.      * @param key 键
  55.      * @param expireTime 过期时间
  56.      * @param timeUnit 时间单位
  57.      * @return true：成功
  58.      */
  59.     public boolean setExpire(final String key, Long expireTime, TimeUnit timeUnit) {
  60.         return redisTemplate.expire(key, expireTime, timeUnit);
  61.     }
  62.  
  63.     /**
  64.      * 批量删除对应的value
  65.      * @param keys
  66.      */
  67.     public void remove(final String... keys) {
  68.         for (String key : keys) {
  69.             remove(key);
  70.         }
  71.     }
  72.  
  73.     /**
  74.      * 删除对应的value
  75.      * @param key
  76.      */
  77.     public void remove(final String key) {
  78.         if (exists(key)) {
  79.             redisTemplate.delete(key);
  80.         }
  81.     }
  82.     /**
  83.      * 判断缓存中是否有对应的value
  84.      * @param key
  85.      * @return
  86.      */
  87.     public boolean exists(final String key) {
  88.         return redisTemplate.hasKey(key);
  89.     }
  90.     /**
  91.      * 读取缓存
  92.      * @param key
  93.      * @return
  94.      */
  95.     public <T> T get(final String key) {
  96.         Object result = null;
  97.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  98.         result = operations.get(key);
  99.         if (null == result) {
  100.             return null;
  101.         }
  102.         return (T)result;
  103.     }
  104.     /**
  105.      * 哈希 添加
  106.      * @param key
  107.      * @param hashKey
  108.      * @param value
  109.      */
  110.     public void hmSet(String key, Object hashKey, Object value) {
  111.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  112.         hash.put(key,hashKey,value);
  113.     }
  114.  
  115.     /**
  116.      * 以map集合的形式添加键值对
  117.      * @param key 键
  118.      * @param map Map
  119.      */
  120.     public void hPutAll(String key, Map<String, Object> map) {
  121.         redisTemplate.opsForHash().putAll(key, map);
  122.     }
  123.  
  124.     /**
  125.      * 哈希获取数据
  126.      * @param key
  127.      * @param hashKey
  128.      * @return
  129.      */
  130.     public Object hmGet(String key, Object hashKey) {
  131.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  132.         return hash.get(key,hashKey);
  133.     }
  134.  
  135.     /**
  136.      * 根据键获取到redis中存储的map
  137.      * @param key 键
  138.      * @return 键对应的map
  139.      */
  140.     public Map<String, Object> hGetAll(String key) {
  141.         return redisTemplate.opsForHash().entries(key);
  142.     }
  143.  
  144.     /**
  145.      * 自增/自减key对应map中的指定字段的long型数值
  146.      * @param key 键
  147.      * @param field key对应map中存储的字段
  148.      * @param increment 正数-自增；负数-自减
  149.      * @return 自增/自减后的数值
  150.      */
  151.     public Long hashIncrBy(String key, Object field, long increment) {
  152.         return redisTemplate.opsForHash().increment(key, field, increment);
  153.     }
  154.  
  155.     /**
  156.      * 自增/自减key对应map中的指定字段的double型数值
  157.      * @param key 键
  158.      * @param field key对应map中存储的字段
  159.      * @param delta 正数-自增；负数-自减
  160.      * @return 自增/自减后的数值
  161.      */
  162.     public Double hIncrByDouble(String key, Object field, double delta) {
  163.         return redisTemplate.opsForHash().increment(key, field, delta);
  164.     }
  165.  
  166.     /**
  167.      * 查询redis中指定字段是否存在
  168.      * @param key 键
  169.      * @param field key对应map中存储的字段
  170.      * @return true:存在
  171.      */
  172.     public boolean hashExists(String key, String field) {
  173.         return redisTemplate.opsForHash().hasKey(key, field);
  174.     }
  175.  
  176.     /**
  177.      * 列表添加
  178.      * @param k
  179.      * @param v
  180.      */
  181.     public void lPush(String k, Object v) {
  182.         ListOperations<String, Object> list = redisTemplate.opsForList();
  183.         list.rightPush(k,v);
  184.     }
  185.  
  186.     /**
  187.      * 列表获取
  188.      * @param k
  189.      * @param l
  190.      * @param l1
  191.      * @return
  192.      */
  193.     public List<Object> lRange(String k, long l, long l1) {
  194.         ListOperations<String, Object> list = redisTemplate.opsForList();
  195.         return list.range(k,l,l1);
  196.     }
  197.  
  198.     /**
  199.      * 集合添加
  200.      * @param key
  201.      * @param value
  202.      */
  203.     public void add(String key, Object value) {
  204.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  205.         set.add(key,value);
  206.     }
  207.  
  208.     /**
  209.      * 集合获取
  210.      * @param key
  211.      * @return
  212.      */
  213.     public Set<Object> setMembers(String key) {
  214.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  215.         return set.members(key);
  216.     }
  217.  
  218.     /**
  219.      * 有序集合添加
  220.      * @param key
  221.      * @param value
  222.      * @param scoure
  223.      */
  224.     public void zAdd(String key, Object value, double scoure) {
  225.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  226.         zset.add(key,value,scoure);
  227.     }
  228.  
  229.     /**
  230.      * 有序集合获取
  231.      * @param key
  232.      * @param scoure
  233.      * @param scoure1
  234.      * @return
  235.      */
  236.     public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
  237.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  238.         return zset.rangeByScore(key, scoure, scoure1);
  239.     }
  240.  
  241.     /**
  242.      * redis原子型自增
  243.      * */
  244.     public Long incr(String key){
  245.         RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
  246.         Long increment = entityIdCounter.getAndIncrement();
  247.         return increment;
  248.     }
  249. }

Api接口封装：

  1. package com.furnish.web.wn.enums.txim;
  2.  
  3.  
  4. /**
  5.  * @description: 腾讯im相关API接口
  6.  */
  7. public class TencentCloudImApiConstant {
  8.     /**
  9.      * 账号管理
  10.      */
  11.     public static class AccountManage {
  12.         /**导入单个帐号*/
  13.         public static final String ACCOUNT_IMPORT = "v4/im_open_login_svc/account_import";
  14.         /**导入多个帐号*/
  15.         public static final String MULTI_ACCOUNT_IMPORT = "v4/im_open_login_svc/account_import";
  16.         /**删除帐号*/
  17.         public static final String ACCOUNT_DELETE = "v4/im_open_login_svc/account_delete";
  18.         /**查询帐号*/
  19.         public static final String ACCOUNT_CHECK = "v4/im_open_login_svc/account_check";
  20.         /**失效帐号登录状态*/
  21.         public static final String ACCOUNT_KICK = "v4/im_open_login_svc/kick";
  22.         /**查询账号在线状态*/
  23.         public static final String ACCOUNT_QUERY_STATE = "v4/openim/querystate";
  24.     }
  25.  
  26.     /**
  27.      * 单聊消息
  28.      */
  29.     public static class SingleChatManage {
  30.         /**单发单聊消息*/
  31.         public static final String SEND_MSG = "v4/openim/sendmsg";
  32.         /**批量发单聊消息*/
  33.         public static final String BATCH_SEND_MSG = "v4/openim/batchsendmsg";
  34.         /**导入单聊消息*/
  35.         public static final String IMPORT_MSG = "v4/openim/importmsg";
  36.         /**查询单聊消息*/
  37.         public static final String ADMIN_GET_ROAM_MSG = "v4/openim/admin_getroammsg";
  38.         /**撤回单聊消息*/
  39.         public static final String ADMIN_MSG_WITH_DRAW = "v4/openim/admin_msgwithdraw";
  40.         /**设置单聊消息已读*/
  41.         public static final String ADMIN_SET_MSG_READ = "v4/openim/admin_set_msg_read";
  42.     }
  43.  
  44.     /**
  45.      * 全员推送
  46.      */
  47.     public static class AllPushManage {
  48.         /**全员推送*/
  49.         public static final String IM_PUSH = "v4/all_member_push/im_push";
  50.         /**设置应用属性名称*/
  51.         public static final String IM_SET_ATTR_NAME = "v4/all_member_push/im_set_attr_name";
  52.         /**获取应用属性名称*/
  53.         public static final String IM_GET_ATTR_NAME = "v4/all_member_push/im_get_attr_name";
  54.         /**获取用户属性*/
  55.         public static final String IM_GET_ATTR = "v4/all_member_push/im_get_attr";
  56.         /**设置用户属性*/
  57.         public static final String IM_SET_ATTR = "v4/all_member_push/im_set_attr";
  58.         /**删除用户属性*/
  59.         public static final String IM_REMOVE_ATTR = "v4/all_member_push/im_remove_attr";
  60.         /**获取用户标签*/
  61.         public static final String IM_GET_TAG = "v4/all_member_push/im_get_tag";
  62.         /**添加用户标签*/
  63.         public static final String IM_ADD_TAG = "v4/all_member_push/im_add_tag";
  64.         /**删除用户标签*/
  65.         public static final String IM_REMOVE_TAG = "v4/all_member_push/im_remove_tag";
  66.         /**删除用户所有标签*/
  67.         public static final String IM_REMOVE_ALL_TAGS = "v4/all_member_push/im_remove_all_tags";
  68.     }
  69.  
  70.     /**
  71.      * 资料管理
  72.      */
  73.     public static class PortraitManage {
  74.         /**设置资料*/
  75.         public static final String PORTRAIT_SET = "v4/profile/portrait_set";
  76.         /**拉取资料*/
  77.         public static final String PORTRAIT_GET = "v4/profile/portrait_get";
  78.     }
  79.  
  80.     /**
  81.      * 关系链管理
  82.      */
  83.     public static class RelationManage {
  84.         /**添加好友*/
  85.         public static final String FRIEND_ADD = "v4/sns/friend_add";
  86.         /**导入好友*/
  87.         public static final String FRIEND_IMPORT = "v4/sns/friend_import";
  88.         /**更新好友*/
  89.         public static final String FRIEND_UPDATE = "v4/sns/friend_update";
  90.         /**删除好友*/
  91.         public static final String FRIEND_DELETE = "v4/sns/friend_delete";
  92.         /**删除所有好友*/
  93.         public static final String FRIEND_DELETE_ALL = "v4/sns/friend_delete_all";
  94.         /**校验好友*/
  95.         public static final String FRIEND_CHECK = "v4/sns/friend_check";
  96.         /**拉取好友*/
  97.         public static final String FRIEND_GET = "v4/sns/friend_get";
  98.         /**拉取指定好友*/
  99.         public static final String FRIEND_GET_LIST = "v4/sns/friend_get_list";
  100.         /**添加黑名单*/
  101.         public static final String BLACK_LIST_ADD = "v4/sns/black_list_add";
  102.         /**删除黑名单*/
  103.         public static final String BLACK_LIST_DELETE = "v4/sns/black_list_delete";
  104.         /**拉取黑名单*/
  105.         public static final String BLACK_LIST_GET = "v4/sns/black_list_get";
  106.         /**校验黑名单*/
  107.         public static final String BLACK_LIST_CHECK = "v4/sns/black_list_check";
  108.         /**添加分组*/
  109.         public static final String GROUP_ADD = "v4/sns/group_add";
  110.         /**删除分组*/
  111.         public static final String GROUP_DELETE = "v4/sns/group_delete";
  112.         /**拉取分组*/
  113.         public static final String GROUP_GET = "v4/sns/group_get";
  114.     }
  115.  
  116.     /**
  117.      * 群组管理
  118.      */
  119.     public static class GroupManage {
  120.         /**创建群组*/
  121.         public static final String CREATE_GROUP = "v4/group_open_http_svc/create_group";
  122.         /**获取群详细资料*/
  123.         public static final String GET_GROUP_INFO = "v4/group_open_http_svc/get_group_info";
  124.         /**获取群成员详细资料*/
  125.         public static final String GET_GROUP_MEMBER_INFO = "v4/group_open_http_svc/get_group_member_info";
  126.         /**修改群基础资料*/
  127.         public static final String MODIFY_GROUP_BASE_INFO = "v4/group_open_http_svc/modify_group_base_info";
  128.         /**增加群成员*/
  129.         public static final String ADD_GROUP_MEMBER = "v4/group_open_http_svc/add_group_member";
  130.         /**删除群成员*/
  131.         public static final String DELETE_GROUP_MEMBER = "v4/group_open_http_svc/delete_group_member";
  132.         /**修改群成员资料*/
  133.         public static final String MODIFY_GROUP_MEMBER_INFO = "v4/group_open_http_svc/modify_group_member_info";
  134.         /**解散群组*/
  135.         public static final String DESTROY_GROUP = "v4/group_open_http_svc/destroy_group";
  136.         /**获取用户所加入的群组*/
  137.         public static final String GET_JOINED_GROUP_LIST = "v4/group_open_http_svc/get_joined_group_list";
  138.         /**查询用户在群组中的身份*/
  139.         public static final String GET_ROLE_IN_GROUP = "v4/group_open_http_svc/get_role_in_group";
  140.         /**批量禁言和取消禁言*/
  141.         public static final String FORBID_SEND_MSG = "v4/group_open_http_svc/forbid_send_msg";
  142.         /**获取被禁言群成员列表*/
  143.         public static final String GET_GROUP_SHUT_UIN = "v4/group_open_http_svc/get_group_shutted_uin";
  144.         /**在群组中发送普通消息*/
  145.         public static final String SEND_GROUP_MSG = "v4/group_open_http_svc/send_group_msg";
  146.         /**在群组中发送系统通知*/
  147.         public static final String SEND_GROUP_SYSTEM_NOTIFICATION = "v4/group_open_http_svc/send_group_system_notification";
  148.         /**撤回群消息*/
  149.         public static final String GROUP_MSG_RECALL = "v4/group_open_http_svc/group_msg_recall";
  150.         /**转让群主*/
  151.         public static final String CHANGE_GROUP_OWNER = "v4/group_open_http_svc/change_group_owner";
  152.         /**导入群基础资料*/
  153.         public static final String IMPORT_GROUP = "v4/group_open_http_svc/import_group";
  154.         /**导入群消息*/
  155.         public static final String IMPORT_GROUP_MSG = "v4/group_open_http_svc/import_group_msg";
  156.         /**导入群成员*/
  157.         public static final String IMPORT_GROUP_MEMBER = "v4/group_open_http_svc/import_group_member";
  158.         /**设置成员未读消息计数*/
  159.         public static final String SET_UNREAD_MSG_NUM = "v4/group_open_http_svc/set_unread_msg_num";
  160.         /**删除指定用户发送的消息*/
  161.         public static final String DELETE_GROUP_MSG_BY_SENDER = "v4/group_open_http_svc/delete_group_msg_by_sender";
  162.         /**拉取群历史消息*/
  163.         public static final String GROUP_MSG_GET_SIMPLE = "v4/group_open_http_svc/group_msg_get_simple";
  164.         /**获取直播群在线人数*/
  165.         public static final String GET_ONLINE_MEMBER_NUM = "v4/group_open_http_svc/get_online_member_num";
  166.     }
  167.  
  168.     /**
  169.      * 全局禁言管理
  170.      */
  171.     public static class AllSinentManage {
  172.         /**设置全局禁言*/
  173.         public static final String SET_NO_SPEAKING = "v4/openconfigsvr/setnospeaking";
  174.         /**查询全局禁言*/
  175.         public static final String GET_NO_SPEAKING = "v4/openconfigsvr/getnospeaking";
  176.     }
  177.  
  178.     /**
  179.      * 运营管理
  180.      */
  181.     public static class OperationManage {
  182.         /**拉取运营数据*/
  183.         public static final String GET_APP_INFO = "v4/openconfigsvr/getappinfo";
  184.         /**下载消息记录*/
  185.         public static final String GET_HISTORY = "v4/open_msg_svc/get_history";
  186.         /**获取服务器 IP 地址*/
  187.         public static final String GET_IP_LIST = "v4/ConfigSvc/GetIPList";
  188.     }
  189. }
  190.

腾讯Im相关常量：

  1.  
  2. /**
  3.  * @description: 腾讯im相关常量
  4.  */
  5. public class TencentCloudImConstant {
  6.     /**
  7.      * IM请求处理结果
  8.      */
  9.     public final static String ACTION_STATUS_OK = "OK";
  10.     public final static String ACTION_STATUS_FAIL = "FAIL";
  11.  
  12.     /**
  13.      * IM发消息是否同步到发送方（1-同步，2-不同步）
  14.      */
  15.     public final static Integer SYNC_OTHER_MACHINE_YES = 1;
  16.     public final static Integer SYNC_OTHER_MACHINE_NO = 2;
  17.  
  18.     /**
  19.      * IM消息对象类型：
  20.      * TIMTextElem	文本消息。
  21.      * TIMLocationElem	地理位置消息。
  22.      * TIMFaceElem	表情消息。
  23.      * TIMCustomElem	自定义消息，当接收方为 iOS 系统且应用处在后台时，此消息类型可携带除文本以外的字段到 APNs。一条组合消息中只能包含一个 TIMCustomElem 自定义消息元素。
  24.      * TIMSoundElem	语音消息。
  25.      * TIMImageElem	图像消息。
  26.      * TIMFileElem	文件消息。
  27.      * TIMVideoFileElem	视频消息。
  28.      */
  29.     public final static String TIM_TEXT_ELEM = "TIMTextElem";
  30.     public final static String TIM_LOCATION_ELEM = "TIMLocationElem";
  31.     public final static String TIM_FACE_ELEM = "TIMFaceElem";
  32.     public final static String TIM_CUSTOM_ELEM = "TIMCustomElem";
  33.     public final static String TIM_SOUND_ELEM = "TIMSoundElem";
  34.     public final static String TIM_IMAGE_ELEM = "TIMImageElem";
  35.     public final static String TIM_FILE_ELEM = "TIMFileElem";
  36.     public final static String TIM_VIDEOFILE_ELEM = "TIMVideoFileElem";
  37.  
  38.     /**
  39.      * 微信响应消息类型
  40.      * WX_MSG_TYPE_EVENT：事件类型，事件类型对应"user_enter_tempsession"表示建立会话
  41.      * WX_MSG_TYPE_TEXT：文本类型
  42.      * WX_MSG_TYPE_TEXT：图片类型
  43.      * WX_MSG_TYPE_TEXT：小程序卡片
  44.      */
  45.     public final static String WX_MSG_TYPE_EVENT = "event";
  46.     public final static String WX_MSG_TYPE_TEXT = "text";
  47.     public final static String WX_MSG_TYPE_IMAGE = "image";
  48.     public final static String WX_MSG_TYPE_APPLET_CARD = "miniprogrampage";
  49. }

功能配置：

  1. import com.alibaba.fastjson.JSONObject;
  2. import com.tencentyun.TLSSigAPIv2;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.apache.commons.lang3.RandomUtils;
  5. import org.apache.commons.lang3.StringUtils;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.stereotype.Component;
  9.  
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. import java.util.stream.Collectors;
  13.  
  14.  
  15. /**
  16.  * @description: 腾讯im基础配置
  17.  * @author: zyb
  18.  * @date: 2021/5/27 17:32
  19.  */
  20. @Slf4j
  21. @Component
  22. public class TencentCloudImUtil {
  23.     private static final String HTTPS_URL_PREFIX = "https://console.tim.qq.com/";
  24.     private static final String APP_MANAGER = "administrator";
  25.     private static final String REDIS_IM_USER_SIG = "silence:im_user_sig:";
  26.  
  27.     @Value("${IMConfig.sdkAppId}")
  28.     private long sdkAppId;
  29.     @Value("${IMConfig.secretKey}")
  30.     private String secretKey;
  31.  
  32.     @Autowired
  33.     private RedisServiceUtil redisServiceUtil;
  34.  
  35.     /**
  36.      * 获取腾讯云用户签名
  37.      */
  38.     public String getTxCloudUserSig() {
  39.         String userSig = redisServiceUtil.get(REDIS_IM_USER_SIG + APP_MANAGER);
  40.         if (StringUtils.isEmpty(userSig)) {
  41.             TLSSigAPIv2 tlsSigApi = new TLSSigAPIv2(sdkAppId, secretKey);
  42.             userSig = tlsSigApi.genUserSig(APP_MANAGER, 86400);
  43.             redisServiceUtil.set(REDIS_IM_USER_SIG + APP_MANAGER, userSig, 86400L);
  44.         }
  45.         return userSig;
  46.     }
  47.  
  48.     /**
  49.      * 获取腾讯im请求路径
  50.      */
  51.     private String getHttpsUrl(String imServiceApi, Integer random) {
  52.         return String.format("%s%s?sdkappid=%s&identifier=%s&usersig=%s&random=%s&contenttype=json",
  53.                 HTTPS_URL_PREFIX, imServiceApi, sdkAppId, APP_MANAGER, this.getTxCloudUserSig(), random);
  54.     }
  55.  
  56.     /**
  57.      * 导入单个账号
  58.      * @param userId 用户id
  59.      */
  60.     public void accountImport(String userId) {
  61.         accountImport(userId, null);
  62.     }
  63.  
  64.     public void accountImport(String userId, String userName) {
  65.         accountImport(userId, userName, null);
  66.     }
  67.  
  68.     public void accountImport(String userId, String userName, String faceUrl) {
  69.         Integer random = RandomUtils.nextInt(0, 999999999);
  70.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.AccountManage.ACCOUNT_IMPORT, random);
  71.         JSONObject jsonObject = new JSONObject();
  72.         jsonObject.put("Identifier", userId);
  73.         if (StringUtils.isNotEmpty(userName)) {
  74.             jsonObject.put("Nick", userName);
  75.         }
  76.         if (StringUtils.isNotEmpty(faceUrl)) {
  77.             jsonObject.put("FaceUrl", faceUrl);
  78.         }
  79.         log.info("腾讯云im导入单个账号，请求参数：{}", jsonObject.toString());
  80.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  81.         log.info("腾讯云im导入单个账号，返回结果：{}", result);
  82.     }
  83.  
  84.     /**
  85.      * 导入多个账号
  86.      * @param userIds 用户id集合
  87.      */
  88.     public void multiAccountImport(List<String> userIds) {
  89.         Integer random = RandomUtils.nextInt(0, 999999999);
  90.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.AccountManage.MULTI_ACCOUNT_IMPORT, random);
  91.         JSONObject jsonObject = new JSONObject();
  92.         jsonObject.put("Accounts", userIds);
  93.         log.info("腾讯云im导入多个账号，请求参数：{}", jsonObject.toString());
  94.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  95.         log.info("腾讯云im导入单个账户，返回结果：{}", result);
  96.     }
  97.  
  98.     /**
  99.      * 删除账号
  100.      * @param userIds 用户id集合
  101.      */
  102.     public void accountDelete(List<String> userIds) {
  103.         Integer random = RandomUtils.nextInt(0, 999999999);
  104.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.AccountManage.ACCOUNT_DELETE, random);
  105.         JSONObject jsonObject = new JSONObject();
  106.         jsonObject.put("DeleteItem", getUserIdJsonList(userIds));
  107.         log.info("腾讯云im删除账号，请求参数：{}", jsonObject.toString());
  108.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  109.         log.info("腾讯云im删除账户，返回结果：{}", result);
  110.     }
  111.  
  112.     /**
  113.      * 查询账号是否已经导入im
  114.      * @param userIds 用户id集合
  115.      */
  116.     public String accountCheck(List<String> userIds) {
  117.         Integer random = RandomUtils.nextInt(0, 999999999);
  118.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.AccountManage.ACCOUNT_CHECK, random);
  119.         JSONObject jsonObject = new JSONObject();
  120.         jsonObject.put("CheckItem", getUserIdJsonList(userIds));
  121.         log.info("腾讯云im查询账号，请求参数：{}", jsonObject.toString());
  122.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  123.         log.info("腾讯云im查询账号，返回结果：{}", result);
  124.         return result;
  125.     }
  126.  
  127.     private List<JSONObject> getUserIdJsonList(List<String> userIds) {
  128.         return userIds.stream().map(v -> {
  129.             JSONObject userIdJson = new JSONObject();
  130.             userIdJson.put("UserID", v);
  131.             return userIdJson;
  132.         }).collect(Collectors.toList());
  133.     }
  134.  
  135.     /**
  136.      * 单发单聊消息
  137.      * @param syncOtherMachine 是否同步消息到发送方（1-同步，2-不同步）
  138.      * @param fromUserId 发送方用户id
  139.      * @param toUserId 接收方用户id
  140.      * @param msgType 消息对象类型
  141.      * @param msgContent 消息内容
  142.      */
  143.     public String sendMsg(Integer syncOtherMachine, String fromUserId, String toUserId, String msgType, String msgContent) {
  144.         Integer random = RandomUtils.nextInt(0, 999999999);
  145.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.SingleChatManage.SEND_MSG, random);
  146.         JSONObject jsonObject = new JSONObject();
  147.         jsonObject.put("SyncOtherMachine", syncOtherMachine);
  148.         if (StringUtils.isNotEmpty(fromUserId)) {
  149.             // 发送方不为空表示指定发送用户，为空表示为管理员发送消息
  150.             jsonObject.put("From_Account", fromUserId);
  151.         }
  152.         jsonObject.put("To_Account", toUserId);
  153.         jsonObject.put("MsgRandom", random);
  154.         List<JSONObject> msgBody = getMsgBody(msgType, msgContent);
  155.         jsonObject.put("MsgBody", msgBody);
  156.         log.info("腾讯云im单发单聊消息，请求参数：{}", jsonObject.toString());
  157.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  158.         log.info("腾讯云im单发单聊消息，返回结果：{}", result);
  159.         return result;
  160.     }
  161.  
  162.     /**
  163.      * 批量发单聊消息
  164.      * @param syncOtherMachine 是否同步消息到发送方（1-同步，2-不同步）
  165.      * @param fromUserId 发送方用户id
  166.      * @param toUserIds 接收方用户id集合
  167.      * @param msgType 消息对象类型
  168.      * @param msgContent 消息内容
  169.      */
  170.     public String batchSendMsg(Integer syncOtherMachine, String fromUserId, List<String> toUserIds, String msgType, String msgContent) {
  171.         Integer random = RandomUtils.nextInt(0, 999999999);
  172.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.SingleChatManage.BATCH_SEND_MSG, random);
  173.         JSONObject jsonObject = new JSONObject();
  174.         jsonObject.put("SyncOtherMachine", syncOtherMachine);
  175.         if (StringUtils.isNotEmpty(fromUserId)) {
  176.             // 发送方不为空表示指定发送用户，为空表示为管理员发送消息
  177.             jsonObject.put("From_Account", fromUserId);
  178.         }
  179.         jsonObject.put("To_Account", toUserIds);
  180.         jsonObject.put("MsgRandom", random);
  181.         List<JSONObject> msgBody = getMsgBody(msgType, msgContent);
  182.         jsonObject.put("MsgBody", msgBody);
  183.         log.info("腾讯云im批量发单聊消息，请求参数：{}", jsonObject.toString());
  184.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  185.         log.info("腾讯云im批量发单聊消息，返回结果：{}", result);
  186.         return result;
  187.     }
  188.  
  189.  
  190.     /**
  191.      * 拼接发送消息内容
  192.      * @param msgType 消息类型
  193.      * @param msgContent 发送消息内容
  194.      * @return 消息内容
  195.      */
  196.     private List<JSONObject> getMsgBody(String msgType, String msgContent) {
  197.         List<JSONObject> msgBody = new ArrayList<>();
  198.         if (msgType.equals(TencentCloudImConstant.TIM_TEXT_ELEM)) {
  199.             // 文本类型
  200.             JSONObject msgBodyJson = new JSONObject();
  201.             msgBodyJson.put("MsgType", msgType);
  202.             JSONObject msgContentObj = new JSONObject();
  203.             msgContentObj.put("Text", msgContent);
  204.             msgBodyJson.put("MsgContent", msgContentObj);
  205.             msgBody.add(msgBodyJson);
  206.         }
  207.         return msgBody;
  208.     }
  209.  
  210.     /**
  211.      * 查询单聊消息
  212.      * @param fromUserId 发送方用户id
  213.      * @param toUserId 接收方用户id
  214.      * @param maxCnt 查询条数
  215.      * @param startTime 起始时间（单位：秒）
  216.      * @param endTime 结束时间（单位：秒）
  217.      * @param lastMsgKey 最后一条消息的 MsgKey
  218.      * @return 单聊消息列表
  219.      */
  220.     public String adminGetRoamMsg(String fromUserId, String toUserId, Integer maxCnt, Long startTime, Long endTime, String lastMsgKey) {
  221.         Integer random = RandomUtils.nextInt(0, 999999999);
  222.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.SingleChatManage.ADMIN_GET_ROAM_MSG, random);
  223.         JSONObject jsonObject = new JSONObject();
  224.         jsonObject.put("From_Account", fromUserId);
  225.         jsonObject.put("To_Account", toUserId);
  226.         jsonObject.put("MaxCnt", maxCnt);
  227.         jsonObject.put("MinTime", startTime);
  228.         jsonObject.put("MaxTime", endTime);
  229.         if (StringUtils.isNotEmpty(lastMsgKey)){
  230.             jsonObject.put("LastMsgKey", lastMsgKey);
  231.         }
  232.         log.info("腾讯云im查询单聊消息，请求参数：{}", jsonObject.toString());
  233.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  234.         log.info("腾讯云im查询单聊消息，返回结果：{}", result);
  235.         return result;
  236.     }
  237.  
  238.     /**
  239.      * 撤回单聊消息
  240.      * @param fromUserId 发送方用户id
  241.      * @param toUserId 接收方用户id
  242.      * @param msgKey MsgKey
  243.      */
  244.     public void adminMsgWithDraw(String fromUserId, String toUserId, String msgKey) {
  245.         Integer random = RandomUtils.nextInt(0, 999999999);
  246.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.SingleChatManage.ADMIN_MSG_WITH_DRAW, random);
  247.         JSONObject jsonObject = new JSONObject();
  248.         jsonObject.put("From_Account", fromUserId);
  249.         jsonObject.put("To_Account", toUserId);
  250.         jsonObject.put("MsgKey", msgKey);
  251.         log.info("腾讯云im撤回单聊消息，请求参数：{}", jsonObject.toString());
  252.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  253.         log.info("腾讯云im撤回单聊消息，返回结果：{}", result);
  254.     }
  255.  
  256.     /**
  257.      * 设置单聊消息已读
  258.      * @param reportUserId 读取消息的用户
  259.      * @param peerUserId 发送消息的用户
  260.      */
  261.     public void adminSetMsgRead(String reportUserId, String peerUserId) {
  262.         Integer random = RandomUtils.nextInt(0, 999999999);
  263.         String httpsUrl = getHttpsUrl(TencentCloudImApiConstant.SingleChatManage.ADMIN_SET_MSG_READ, random);
  264.         JSONObject jsonObject = new JSONObject();
  265.         jsonObject.put("Report_Account", reportUserId);
  266.         jsonObject.put("Peer_Account", peerUserId);
  267.         log.info("腾讯云im设置单聊消息已读，请求参数：{}", jsonObject.toString());
  268.         String result = HttpUtil.doPost2(httpsUrl, jsonObject);
  269.         log.info("腾讯云im设置单聊消息已读，返回结果：{}", result);
  270.     }
  271. }

接口调用：

  1. import com.furnish.web.wn.enums.txim.TencentCloudImUtil;
  2. import io.swagger.annotations.Api;
  3. import io.swagger.annotations.ApiImplicitParam;
  4. import io.swagger.annotations.ApiImplicitParams;
  5. import io.swagger.annotations.ApiOperation;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import java.util.*;
  12.  
  13. @RestController
  14. @RequestMapping("/wnapp")
  15. @Api(tags = "腾讯IM实时对话")
  16. public class TXController {
  17.  
  18.     @Autowired
  19.     private TencentCloudImUtil tencentCloudImUtil;
  20.  
  21.     @GetMapping("/contextLoads")
  22.     @ApiOperation("获取userSig")
  23.     public String contextLoads() {
  24.         String userSig = tencentCloudImUtil.getTxCloudUserSig();
  25.         System.out.println(userSig);
  26.         return userSig;
  27.     }
  28.  
  29.     /**
  30.      * 查询单聊消息
  31.      * @param fromUserId 发送方用户id
  32.      * @param toUserId 接收方用户id
  33.      * @param maxCnt 查询条数
  34.      * @param startTime 起始时间（单位：秒）
  35.      * @param endTime 结束时间（单位：秒）
  36.      * @param lastMsgKey 最后一条消息的 MsgKey  可以为null
  37.      * @return 单聊消息列表
  38.      */
  39.     @GetMapping("/testSendIMMsg")
  40.     @ApiOperation("查询单聊消息")
  41.     @ApiImplicitParams({
  42.             @ApiImplicitParam(name = "fromUserId", value = "发送方用户id", dataType = "String", dataTypeClass = Integer.class),
  43.             @ApiImplicitParam(name = "toUserId", value = "接收方用户id", dataType = "String", dataTypeClass = String.class),
  44.             @ApiImplicitParam(name = "maxCnt", value = "查询条数", dataType = "Integer", dataTypeClass = Integer.class),
  45.             @ApiImplicitParam(name = "startTime", value = "起始时间（单位：秒）", dataType = "Long", dataTypeClass = Long.class),
  46.             @ApiImplicitParam(name = "endTime", value = "结束时间（单位：秒）", dataType = "Long", dataTypeClass = Long.class),
  47.             @ApiImplicitParam(name = "lastMsgKey", value = "最后一条消息的 MsgKey  可以为null", dataType = "String", dataTypeClass = String.class)
  48.     })
  49.     public String testSendIMMsg(String fromUserId,String toUserId,Integer maxCnt,Long startTime,Long endTime,String lastMsgKey){
  50.         Calendar cale = Calendar.getInstance();
  51.         cale.setTime(new Date());
  52.         cale.set(Calendar.HOUR_OF_DAY, 0);
  53.         cale.set(Calendar.MINUTE, 0);
  54.         cale.set(Calendar.SECOND, 0);
  55. //        Date beginTime = cale.getTime();
  56.         String s = tencentCloudImUtil.adminGetRoamMsg(fromUserId, toUserId, maxCnt, startTime, endTime, lastMsgKey);
  57.         return s;
  58.     }
  59.  
  60.     /**
  61.      * 查询账号是否已经导入im
  62.      * @param userIds 用户id集合
  63.      */
  64.     @GetMapping("/testAccount")
  65.     @ApiOperation("查询账号是否已经导入im")
  66.     @ApiImplicitParam(name = "userIds",value = "用户id集合")
  67.     public String testAccount(List<String> userIds){
  68.  
  69.         String accountCheck = tencentCloudImUtil.accountCheck(userIds);
  70.         System.out.println(accountCheck);
  71.         return accountCheck;
  72.     }
  73.  
  74.     /**
  75.      * 单发单聊消息
  76.      * @param syncOtherMachine 是否同步消息到发送方（1-同步，2-不同步）
  77.      * @param fromUserId 发送方用户id
  78.      * @param toUserId 接收方用户id
  79.      * @param msgType 消息对象类型
  80.      * @param msgContent 消息内容
  81.      */
  82.     @GetMapping("/sendMsg")
  83.     @ApiOperation("单发单聊消息")
  84.     @ApiImplicitParams({
  85.             @ApiImplicitParam(name = "syncOtherMachine", value = "是否同步消息到发送方（1-同步，2-不同步）", dataType = "Integer", dataTypeClass = Integer.class),
  86.             @ApiImplicitParam(name = "fromUserId", value = "发送方用户id", dataType = "String", dataTypeClass = String.class),
  87.             @ApiImplicitParam(name = "toUserId", value = "接收方用户id", dataType = "String", dataTypeClass = String.class),
  88.             @ApiImplicitParam(name = "msgType", value = "消息对象类型", dataType = "String", dataTypeClass = String.class),
  89.             @ApiImplicitParam(name = "msgContent", value = "消息内容", dataType = "String", dataTypeClass = String.class)
  90.     })
  91.     public String sendMsg(Integer syncOtherMachine,String fromUserId,String toUserId,String msgType,String msgContent){
  92.  
  93.         String sendMsg = tencentCloudImUtil.sendMsg(syncOtherMachine,fromUserId,toUserId,msgType,msgContent);
  94.         System.out.println(sendMsg);
  95.         return sendMsg;
  96.     }
  97.  
  98.     /**
  99.      * 撤回单聊消息
  100.      * 发送方用户id
  101.      * 接收方用户id
  102.      * MsgKey
  103.      */
  104.     @GetMapping("/adminMsgWithDraw")
  105.     @ApiOperation("撤回单聊消息")
  106.     @ApiImplicitParams({
  107.             @ApiImplicitParam(name = "fromUserId", value = "发送方用户id", dataType = "String", dataTypeClass = String.class),
  108.             @ApiImplicitParam(name = "toUserId", value = "接收方用户id", dataType = "String", dataTypeClass = String.class),
  109.             @ApiImplicitParam(name = "msgKey", value = "当前信息key", dataType = "String", dataTypeClass = String.class)
  110.     })
  111.     public void adminMsgWithDraw(String fromUserId,String toUserId,String msgKey){
  112.         tencentCloudImUtil.adminMsgWithDraw(fromUserId, toUserId, msgKey);
  113.     }
  114.  
  115.     /**
  116.      * 设置单聊消息已读
  117.      * @param reportUserId 读取消息的用户
  118.      * @param peerUserId 发送消息的用户
  119.      */
  120.     @GetMapping("/adminSetMsgRead")
  121.     @ApiOperation("设置单聊消息已读")
  122.     @ApiImplicitParams({
  123.             @ApiImplicitParam(name = "reportUserId", value = "读取消息的用户", dataType = "String", dataTypeClass = String.class),
  124.             @ApiImplicitParam(name = "peerUserId", value = "发送消息的用户", dataType = "String", dataTypeClass = String.class)
  125.     })
  126.     public void adminSetMsgRead(String reportUserId,String peerUserId){
  127.         tencentCloudImUtil.adminSetMsgRead(reportUserId,peerUserId);
  128.     }
  129.  
  130.     /**
  131.      * 删除账号
  132.      * @param userIds  账号集合
  133.      */
  134.     @GetMapping("/accountDelete")
  135.     @ApiOperation("删除账号")
  136.     @ApiImplicitParam(name = "userIds",value = "账号集合")
  137.     public void accountDelete(List<String> userIds){
  138.         tencentCloudImUtil.accountDelete(userIds);
  139.  
  140.     }
  141. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/178596
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号