騰訊會議API接入

最近項目需要對接騰訊會議，所以提前預研一下騰訊會議的API的接入方式。

一、     產品購買

進入頁面https://meeting.tencent.com/buy.html（騰訊雲會議購買頁面）

騰訊雲會議分為：個人版、商業版、企業版。這里介紹企業版的接入。

如果需要雲會議室，可以同時購買騰訊會議 Rooms。如想了解詳情請聯系騰訊會議客戶平台。

 

二、     個人中心配置

1、獲取騰訊會議sdk配置

進入頁面：https://meeting.tencent.com使用購買騰訊會議服務時使用的手機號進行登錄操作。

1)      進入個人中心

2)      進入REST API頁面

3)      點擊添加應用

4)      應用狀態改為已啟用

5)      添加完成后會生成對應的：AppID、 SDKID、SecretID、SecretKey

 

2、騰訊會議室及Rooms配置

Romms下載地址：https://meeting.tencent.com/download-rooms-page.html

【前提】購買了Rooms付費賬號

1)      進入個人中心

2)      點擊會議室管理（會議室）

3)      添加會議室並將預定狀態修改為（開放預定）

4)      在會議平板上安裝rooms客戶端

 

三、代碼接入

 1、授權、鑒權（鑒權的方式有兩種：企業自建應用鑒權（JWT）、第三方應用鑒權（OAuth2.0）），這里只介紹企業自建應用鑒權（JWT）。

騰訊接口調用請求頭簽名生成工具：

import lombok.extern.slf4j.Slf4j;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * @author dongliang7
 * 
 * @ClassName SignUtil.java
 * @description: 騰訊接口調用請求頭簽名生成工具
 * @createTime 2021年11月19日 08:45:00
 */
@Slf4j
public class SignUtil {

    static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    static final Charset UTF_8 = StandardCharsets.UTF_8;

    public static String bytesToHex(byte[] bytes) {

        char[] buf = new char[bytes.length * 2];
        int index = 0;
        for (byte b : bytes) {
            buf[index++] = HEX_CHAR[b >>> 4 & 0xf];
            buf[index++] = HEX_CHAR[b & 0xf];
        }

        return new String(buf);
    }

    /**
     * 獲取簽名
     * @param signVo 簽名實體類
     * @return
     */
    public static String getSign(SignVo signVo) {
        try {
            String contentCharset = "UTF-8";
            String hmacAlgorithm = "HmacSHA256";
            String tobeSig = signVo.getMethod() + "\nX-TC-Key=" + signVo.getSecretId() + "&X-TC-Nonce="
                    +  signVo.getNonce() + "&X-TC-Timestamp=" + signVo.getTimestamp() + "\n"
                    + signVo.getUri() + "\n" + signVo.getBody();
            Mac mac = Mac.getInstance(hmacAlgorithm);
            byte[] hash;
            SecretKeySpec spec = new SecretKeySpec(signVo.getSecretKey().getBytes(UTF_8), mac.getAlgorithm());
            mac.init(spec);
            hash = mac.doFinal(tobeSig.getBytes(contentCharset));
            String hexHash = bytesToHex(hash);
            log.info("hexHash -> " + hexHash);
            String sig = new String(Base64.getEncoder().encode(hexHash.getBytes(contentCharset)));
            log.info("sig -> " + sig);
            return sig;
        } catch (Exception e) {
            log.info("ERROR OCCURED");
            throw new RuntimeException(e.getCause());
        }
    }
}

請求頭參數封裝工具類：

import org.springframework.http.HttpMethod;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Random;

/**
 * @author dongliang7
 * 
 * @ClassName RequestHeaderUtil.java
 * @description: 請求頭參數封裝工具類
 * @createTime 2021年11月19日 13:44:00
 */
public class RequestHeaderUtil {

    //獲取數據庫加載的 騰訊會議靜態配置
    public static TencentSdkConfig sdkConfig =  TenCentSdkConfig.tencentSdkConfig;
    /**
     * 組建 header
     * @param body 請求體
     * @param httpMethod 請求方法 GET POST .....
     * @param uri 請求路徑
     * @return 返回請求頭
     */
    public static HeadVo getHeader(String body, HttpMethod httpMethod, String uri) {
        // 1、隨機正整數字符串
        String randomStr = String.valueOf(new Random().nextInt(999999));
        // 2、獲取時間戳字符串
        long seconds = LocalDateTime.now().atZone(ZoneId.systemDefault()).toEpochSecond();
        String dateTimeStr = String.valueOf(seconds);
        //3、構建簽名對象
        if(null == sdkConfig){
            return null;
        }
        SignVo signVo = SignVo.Builder.create().withNonce(randomStr).withSecretId(sdkConfig.getSecretId())
                .withTimestamp(dateTimeStr).withSecretKey(sdkConfig.getSecretKey())
                .withBody(body).withMethod(httpMethod.name()).withUri(uri).build();
        //4、獲取簽名字符串
        String sign = SignUtil.getSign(signVo);
        HeadVo headVo = HeadVo.Builder.create().withNonce(signVo.getNonce()).withTimestamp(signVo.getTimestamp())
                .withAppId(sdkConfig.getAppId()).withSdkId(sdkConfig.getSdkId()).withKey(sdkConfig.getSecretId())
                .withSignature(sign).withRegistered("1").build();
        return headVo;
    }
}

請求方法及參數封裝：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpMethod;

import java.util.Map;

/**
 * @author dongliang7
 * 
 * @ClassName TencentMeetingProcess.java
 * @description: 請求方法及參數封裝
 * @createTime 2021年11月22日 14:39:00
 */
@Slf4j
public class TencentMeetingProcess {

    /**
     * POST 請求封裝
     * @param uri 請求路徑
     * @param requestBody 請求體
     * @param <T>
     * @return 返回接口調用結果
     */
    public static<T> HttpResponse postProcess(String uri , T requestBody){
        String url = Constant.HOST.concat(uri);
        String body = JSON.toJSONString(requestBody);
        HeadVo header = RequestHeaderUtil.getHeader(body, HttpMethod.POST, uri);
        Map<String, String> headMap = fromHeadVo(header);
        log.info("tencentMeeting the http post url ---" + url);
        log.info("request tencentMeeting header --->" + JSON.toJSONString(headMap));
        HttpResponse httpResponse = OKHttpClient.httpPostJson(url, headMap, body);
        return httpResponse;
    }

    /**
     * PUT 請求封裝
     * @param uri 請求路徑
     * @param requestBody 請求體
     * @param <T>
     * @return 返回接口調用結果
     */
    public static<T> HttpResponse putProcess(String uri ,T requestBody){
        String url = Constant.HOST.concat(uri);
        String body = JSON.toJSONString(requestBody);
        HeadVo header = RequestHeaderUtil.getHeader(body, HttpMethod.PUT, uri);
        Map<String, String> headMap = fromHeadVo(header);
        log.info("tencentMeeting the http put url ---" + url);
        log.info("request tencentMeeting header --->" + JSON.toJSONString(headMap));
        HttpResponse httpResponse = OKHttpClient.httpPutJson(url, headMap, body);
        return httpResponse;
    }

    /**
     * GET 請求封裝
     * @param uri 請求路徑
     * @return 返回接口調用結果
     */
    public static HttpResponse getProcess(String uri){
        String url = Constant.HOST.concat(uri);
        HeadVo header = RequestHeaderUtil.getHeader(Constant.NULL_CHAR_STR, HttpMethod.GET, uri);
        Map<String, String> headMap = fromHeadVo(header);
        log.info("tencentMeeting the http get url ---" + url);
        log.info("request tencentMeeting header --->" + JSON.toJSONString(headMap));
        HttpResponse httpResponse = OKHttpClient.httpGet(url, headMap);
        return httpResponse;
    }



    /**
     * DELETE 請求封裝
     * @param uri 請求路徑
     * @return 返回接口調用結果
     */
    public static HttpResponse deleteProcess(String uri){
        String url = Constant.HOST.concat(uri);
        HeadVo header = RequestHeaderUtil.getHeader(Constant.NULL_CHAR_STR, HttpMethod.DELETE, uri);
        Map<String, String> headMap = fromHeadVo(header);
        log.info("tencentMeeting the http delete url ---" + url);
        log.info("request tencentMeeting header --->" + JSON.toJSONString(headMap));
        HttpResponse httpResponse = OKHttpClient.httpDelete(url, headMap);
        return httpResponse;
    }

    /**
     * 將實體類轉換成Map集合
     * @param headVo 請求head公參實體
     * @return 返回map集合
     */
    public static Map<String, String> fromHeadVo(HeadVo headVo) {
        return JSON.parseObject(JSON.toJSONString(headVo), new TypeReference<Map<String, String>>() {});
    }
}

OkHttpClient封裝三方接口調用工具：

/**
 * @author dongliang7
 * 
 * @ClassName OKHttpClient.java
 * @description: OkHttpClient封裝三方接口調用工具
 * @createTime 2021年11月19日 10:05:00
 */
public class OKHttpClient {

    private static final Logger log = LoggerFactory.getLogger(OKHttpClient.class);

    private static final String JSON_CHARSET_UTF_8 = "application/json; charset=utf-8";
    //創建 OkHttpClient 不進行SSL（證書）驗證
    private static final OkHttpClient okHttpClient = SSLSocketClient.getUnsafeOkHttpClient();


    /**
     * Http GET 請求 不帶請求頭
     * @param url 請求路徑
     * @return 返回請求結果
     */
    public static HttpResponse httpGet(String url) {
        if(StringUtils.isBlank(url)){
            log.error("http GET 請求過程中url為null!");
            return new HttpResponse();
        }
        Request.Builder builder = new Request.Builder();
        Request request = builder.get().url(url).build();
        HttpResponse httpResponse = new HttpResponse();
        try {
            Response response = okHttpClient.newCall(request).execute();
            ResponseBody responseBody = response.body();
            httpResponse.setResponseBody(responseBody.string());
            httpResponse.setResponseCode(response.code());
            if (response.code() == 200) {
                log.info("http GET 請求成功; [url={}]", url);
            } else {
                log.warn("Http GET 請求失敗; [errorCode = {} , url={}]," +
                        "responseBody={}]", response.code(), url, httpResponse.getResponseBody());
            }
        } catch (IOException e) {
            throw new RuntimeException("同步http GET 請求失敗,url:" + url, e);
        }
        return httpResponse;
    }

    /**
     * Http GET 請求 帶請求頭
     * @param url 請求路徑
     * @param headers 請求頭
     * @return 返回請求結果
     */
    public static HttpResponse httpGet(String url, Map<String, String> headers) {
        if (CollectionUtils.isEmpty(headers)) {
            return httpGet(url);
        }
        Request.Builder builder = new Request.Builder();
        headers.forEach(builder::header);
        Request request = builder.get().url(url).build();
        HttpResponse httpResponse = new HttpResponse();
        try {
            Response response = okHttpClient.newCall(request).execute();
            ResponseBody responseBody = response.body();
            httpResponse.setResponseBody(responseBody.string());
            httpResponse.setResponseCode(response.code());
            if (response.code() == 200) {
                log.info("Http GET 請求成功; [url={},responseBody={}]", url, httpResponse.getResponseBody());
            } else {
                log.warn("Http GET 請求失敗; [errorCode = {} , url={}, " +
                        "responseBody={}]", response.code(), url, httpResponse.getResponseBody());
            }
        } catch (IOException e) {
            throw new RuntimeException("同步http GET 請求失敗,url:" + url, e);
        }
        return httpResponse;
    }

    /**
     * Http POST請求 不帶請求頭
     * @param url  請求路徑
     * @param json 請求體 body
     * @return 返回請求結果
     */
    public static HttpResponse httpPostJson(String url, String json) {
        if(StringUtils.isBlank(url)){
            log.error("Http POST 請求過程中url為null!");
            return new HttpResponse();
        }
        MediaType mediaType = MediaType.parse(JSON_CHARSET_UTF_8);
        RequestBody body = RequestBody.create(json,  mediaType);
        Request.Builder requestBuilder = new Request.Builder().url(url);
        Request request = requestBuilder.post(body).build();
        HttpResponse httpResponse = new HttpResponse();
        try {
            Response response = okHttpClient.newCall(request).execute();
            ResponseBody responseBody = response.body();
            httpResponse.setResponseBody(responseBody.string());
            httpResponse.setResponseCode(response.code());
            if (response.code() == 200) {
                log.info("Http POST 請求成功; [url={}, requestContent={}]", url, json);
            } else {
                log.warn("Http POST 請求失敗; [ errorCode = {}, url={}, " +
                        "param={}]", response.code(), url, json);
            }
        } catch (IOException e) {
            throw new RuntimeException("同步http請求失敗,url:" + url, e);
        }
        return httpResponse;
    }

    /**
     * HTTP POST請求 帶請求頭
     * @param url 請求路徑
     * @param headers 請求頭
     * @param json 請求體 body
     * @return 返回請求結果
     */
    public static HttpResponse httpPostJson(String url, Map<String, String> headers, String json) {
        //校驗是否需要請求頭 ， 如果需要直接執行 ， 如果不需要則調用
        if (CollectionUtils.isEmpty(headers)) {
            return httpPostJson(url, json);
        }
        MediaType mediaType = MediaType.parse(JSON_CHARSET_UTF_8);
        RequestBody body = RequestBody.create(json,mediaType);
        Request.Builder requestBuilder = new Request.Builder().url(url);
        headers.forEach(requestBuilder::addHeader);
        Request request = requestBuilder.post(body).build();
        HttpResponse httpResponse = new HttpResponse();
        try {
            Response response = okHttpClient.newCall(request).execute();
            ResponseBody responseBody = response.body();
            httpResponse.setResponseBody(responseBody.string());
            httpResponse.setResponseCode(response.code());
            if (response.code() == 200) {
                log.info("Http POST 請求成功; [url={},responseBody={}]", url, httpResponse.getResponseBody());
            } else {
                log.warn("Http POST 請求失敗 ; [ errorCode = {}, url={},"
                        + " param={},responseBody ={}]", response.code(), url, json, httpResponse.getResponseBody());
            }
        } catch (IOException e) {
            throw new RuntimeException("同步http POST 請求失敗,url:" + url, e);
        }
        return httpResponse;
    }


    /**
     *  HTTP PUT 請求 帶請求頭
     * @param url 請求路徑
     * @param headers 請求頭
     * @param json 請求體
     * @return 返回 put 請求響應體
     */
    public static HttpResponse httpPutJson(String url, Map<String, String> headers, String json) {
        MediaType mediaType = MediaType.parse(JSON_CHARSET_UTF_8);
        RequestBody body = RequestBody.create(json,mediaType);
        Request.Builder requestBuilder = new Request.Builder().url(url);
        headers.forEach(requestBuilder::addHeader);
        Request request = requestBuilder.put(body).build();
        HttpResponse httpResponse = new HttpResponse();
        try {
            Response response = okHttpClient.newCall(request).execute();
            ResponseBody responseBody = response.body();
            httpResponse.setResponseBody(responseBody.string());
            httpResponse.setResponseCode(response.code());
            if (response.code() == 200) {
                log.info("Http PUT 請求成功; [url={},responseBody={}]", url, httpResponse.getResponseBody());
            } else {
                log.warn("Http PUT 請求失敗 ; [ errorCode = {}, url={}," + " param={},responseBody ={}]", response.code(), url, json, httpResponse.getResponseBody());
            }
        } catch (IOException e) {
            throw new RuntimeException("同步http PUT 請求失敗,url:" + url, e);
        }
        return httpResponse;
    }



    /**
     * Http DELETE 請求 帶請求頭
     * @param url 請求路徑
     * @param headers 請求頭
     * @return 返回請求結果
     */
    public static HttpResponse httpDelete(String url, Map<String, String> headers) {
        Request.Builder builder = new Request.Builder();
        headers.forEach(builder::header);
        Request request = builder.delete().url(url).build();
        HttpResponse httpResponse = new HttpResponse();
        try {
            Response response = okHttpClient.newCall(request).execute();
            ResponseBody responseBody = response.body();
            httpResponse.setResponseBody(responseBody.string());
            httpResponse.setResponseCode(response.code());
            if (response.code() == 200) {
                log.info("Http DELETE 請求成功; [url={},responseBody={}]", url, httpResponse.getResponseBody());
            } else {
                log.warn("Http DELETE 請求失敗; [errorCode = {} , url={}, " + "responseBody={}]", response.code(), url, httpResponse.getResponseBody());
            }
        } catch (IOException e) {
            throw new RuntimeException("同步http DELETE 請求失敗,url:" + url, e);
        }
        return httpResponse;
    }
}

創建 OkHttpClient 不進行SSL（證書）驗證：

import lombok.extern.slf4j.Slf4j;
import okhttp3.OkHttpClient;

import javax.net.ssl.*;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

/**
 * @author dongliang7
 * 
 * @ClassName SSLSocketClient.java
 * @description: 創建 OkHttpClient 不進行SSL（證書）驗證
 * @createTime 2021年11月19日 09:50:00
 */
@Slf4j
public class SSLSocketClient {

    public static OkHttpClient getUnsafeOkHttpClient() {
        try {
            // 創建不驗證證書鏈的信任管理器
            final TrustManager[] trustAllCerts = new TrustManager[]{
                new X509TrustManager() {
                    @Override
                    public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
                    @Override
                    public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
                    @Override
                    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                        return new java.security.cert.X509Certificate[]{};
                    }
                }
            };
            if (trustAllCerts.length != 1 || !(trustAllCerts[0] instanceof X509TrustManager)) {
                throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustAllCerts));
            }
            X509TrustManager x509TrustManager = (X509TrustManager) trustAllCerts[0];

            // 安裝全信任信任管理器
            final SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
            // 使用我們完全信任的管理器創建 ssl 套接字工廠
            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            OkHttpClient.Builder builder = new OkHttpClient.Builder()
                    .connectTimeout(60 , TimeUnit.SECONDS).readTimeout(60 , TimeUnit.SECONDS).writeTimeout(120 , TimeUnit.SECONDS);
            builder.sslSocketFactory(sslSocketFactory , x509TrustManager);
            builder.hostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });
            OkHttpClient okHttpClient = builder.build();
            return okHttpClient;
        } catch (Exception e) {
            log.error("創建OkHttpClient不進行SSL（證書）驗證失敗：{}", e.getMessage());
            throw new RuntimeException(e);
        }
    }
}

騰訊會議API調用 會議管理業務處理層：

/**
 * @author dongliang7
 * 
 * @ClassName MeetingsServiceImpl.java
 * @description: 騰訊會議API調用  會議管理業務處理層
 * @createTime 2021年11月24日 09:51:00
 */
@Service
@Slf4j
public class MeetingsApi {
    private final String baseUri = "/v1/meetings";

    /**
     * 創建會議
     *
     * @param createMeetingReqVo
     * @return
     */
    public HttpResponse scheduleMeeting(CreateMeetingReqVo createMeetingReqVo) {
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(baseUri, createMeetingReqVo);
        return httpResponse;
    }

    /**
     * 通過 meetingId 查詢會議
     *
     * @param queryMeetingByIdRegVo
     * @return
     */
    public HttpResponse queryMeetingInfo(QueryMeetingByIdRegVo queryMeetingByIdRegVo) {
        String uri = baseUri.concat("/").concat(queryMeetingByIdRegVo.getMeetingId()).concat("?userid=")
                .concat(queryMeetingByIdRegVo.getUserId()).concat("&instanceid=")
                .concat(String.valueOf(queryMeetingByIdRegVo.getInstanceId()));
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse;
    }

    /**
     * 取消會議
     *
     * @param cancelMeetingReqVo
     * @return
     */
    public HttpResponse cancelMeeting(CancelMeetingReqVo cancelMeetingReqVo) {
        String uri = baseUri.concat("/").concat(cancelMeetingReqVo.getMeetingId()).concat("/").concat("cancel");
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, cancelMeetingReqVo);
        return httpResponse;
    }

    /**
     * 修改會議
     *
     * @param createMeetingReqVo
     * @return
     */
    public HttpResponse editMeeting(CreateMeetingReqVo createMeetingReqVo, String meetingId) {
        String uri = baseUri.concat("/").concat(meetingId);
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, createMeetingReqVo);
        return httpResponse;
    }

    /**
     * 查詢會議列表
     *
     * @param queryMeetingInfoListVo
     * @return
     */
    public QueryMeetingInfoResVo queryMeetingInfoList(QueryMeetingInfoListVo queryMeetingInfoListVo) {
        String uri = baseUri.concat("?").concat("userid=").concat(queryMeetingInfoListVo.getUserId())
                .concat("&instanceid=").concat(String.valueOf(queryMeetingInfoListVo.getInstanceId()));
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return JSON.parseObject(httpResponse.getResponseBody().toString(), QueryMeetingInfoResVo.class);
    }

    /**
     * 查詢參會人員
     * @param reqVo
     * @return
     */
    public QueryMeetingParticipantsResVo queryMeetingParticipants(QueryMeetingParticipantsReqVo reqVo) {
        String uri = baseUri.concat("/").concat(reqVo.getMeetingId()).concat("/participants?userid=").concat(reqVo.getUserId());
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return JSON.parseObject(httpResponse.getResponseBody().toString(), QueryMeetingParticipantsResVo.class);
    }

    /**
     * 設置會議邀請成員
     * @param meetingInviteesVo
     * @return
     */
    public String setUpMeetingInvitees(MeetingInviteesVo meetingInviteesVo) {
        //https://api.meeting.qq.com/v1/meetings/{meeting_id}/invitees
        String uri = baseUri.concat("/").concat(meetingInviteesVo.getMeetingId()).concat("/invitees");
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, meetingInviteesVo);
        return httpResponse.getResponseCode().toString();
    }
}

騰訊會議API調用 會議室業務處理層：

/**
 * @author dongliang7
 * 
 * @ClassName RoomsServiceImpl.java
 * @description:  騰訊會議API調用 會議室業務處理層
 * @createTime 2021年11月24日 10:14:00
 */
@Service
@Slf4j
public class RoomsApi {
    private final String baseUri = "/v1/meeting-rooms";

    /**
     * 查詢賬戶下 Rooms 資源
     * @return
     */
    public HttpResponse roomsInventory() {
        String uri = "/v1/rooms-inventory";
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse;
    }

    /**
     * 查詢會議室列表
     * @return
     */
    public HttpResponse meetingRooms(Integer page , Integer pageSize) {
        ///v1/meeting-rooms?page={page}&page_size={page_size}&meeting_room_name={meeting_room_name}
        String uri = baseUri.concat("?page=").concat(String.valueOf(page)).concat("&page_size=").concat(String.valueOf(pageSize));
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse;
    }

    /**
     * 生成設備激活碼
     * @param activeCodeVo
     * @return
     */
    public Map<String, Object> activeCode(ActiveCodeVo activeCodeVo) {
        String uri = baseUri.concat("/").concat(activeCodeVo.getMeetingRoomId()).concat("/active-code");
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, activeCodeVo);
        return JSON.parseObject(httpResponse.getResponseBody().toString(), Map.class);
    }

    /**
     * 查詢會議室詳情
     * @param meetingRoomId
     * @return
     */
    public HttpResponse queryMeetingRoomInfo(String meetingRoomId) {
        String uri = baseUri.concat("/").concat(meetingRoomId);
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse;
    }

    /**
     * 查詢設備列表
     * @param queryDeviceListVo
     * @return
     */
    public Map<String, Object> queryDeviceList(QueryDeviceListVo queryDeviceListVo) {
        //https://api.meeting.qq.com/v1/devices?page={page}&page_size={page_size}&meeting_room_name={meeting_room_name}
        String uri = "/v1/devices".concat("?page=").concat(String.valueOf(queryDeviceListVo.getPage()))
                .concat("&page_size=").concat(String.valueOf(queryDeviceListVo.getPageSize()))
                .concat("&meeting_room_name=").concat(queryDeviceListVo.getMeetingRoomName());
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return JSON.parseObject(httpResponse.getResponseBody().toString(), Map.class);
    }

    /**
     * 預定會議室
     * @param bookRoomsVo
     * @return
     */
    public HttpResponse bookRooms(BookRoomsVo bookRoomsVo) {
        String uri = "/v1/meetings/".concat(bookRoomsVo.getMeetingId()).concat("/book-rooms");
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, bookRoomsVo);
        return httpResponse;
    }

    /**
     * 釋放會議室
     * @param bookRoomsVo
     * @return
     */
    public HttpResponse releaseRooms(BookRoomsVo bookRoomsVo) {
        //https://api.meeting.qq.com/v1/meetings/{meeting_id}/release-rooms
        String uri = "/v1/meetings/".concat(bookRoomsVo.getMeetingId()).concat("/release-rooms");
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, bookRoomsVo);
        return httpResponse;
    }
}

騰訊會議API調用 用戶業務處理層：

/**
 * @author dongliang7
 * 
 * @ClassName UsersServiceImpl.java
 * @description: 騰訊會議API調用 用戶業務處理層
 * @createTime 2021年11月24日 10:19:00
 */
@Service
@Slf4j
public class UsersApi {
    private final String userUri = "/v1/users";

    /**
     * 創建用戶
     * @param userCreateVo
     */
    public HttpResponse createUser(UserCreateVo userCreateVo) {
        String uri = userUri;
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, userCreateVo);
        return httpResponse;
    }

    /**
     * 通過 userid 更新用戶
     * @param userUpdateVo
     * @return
     */
    public HttpResponse updateUser(UserUpdateVo userUpdateVo) {
        String uri = userUri.concat("/").concat(userUpdateVo.getUserid());
        HttpResponse httpResponse = TencentMeetingProcess.putProcess(uri, userUpdateVo);
        return httpResponse;
    }

    /**
     * 查詢用戶詳情
     * @param userId
     * @return
     */
    public HttpResponse queryUserInfoDetail(String userId) {
        String uri = userUri.concat("/").concat(userId);
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse;
    }

    /**
     * 查詢用戶列表
     * @param page
     * @param pageSize
     * @return
     */
    public QueryUserInfoList queryUserInfoList(Integer page, Integer pageSize) {
        String uri = userUri.concat("/list?page=").concat(String.valueOf(page))
                .concat("&page_size=").concat(String.valueOf(pageSize));
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return JSON.parseObject(httpResponse.getResponseBody().toString(), QueryUserInfoList.class);
    }

    /**
     * 通過 userid 刪除用戶
     * @param userDeleteVo
     * @return
     */
    public HttpResponse deleteUser(UserDeleteVo userDeleteVo) {
        String uri = userUri.concat("/").concat(userDeleteVo.getUserId());
        HttpResponse httpResponse = TencentMeetingProcess.deleteProcess(uri);
        return httpResponse;
    }

    /**
     *  查詢個人會議號配置信息
     * @param userId
     * @param instanceId
     * @return
     */
    public String getMeetingPmiConfig(String userId, String instanceId) {
        //GET https://api.meeting.qq.com/v1/pmi-meetings/pmi-config?userid=tester&instanceid=1
        String uri = "/v1/pmi-meetings/pmi-config".concat("?userid=").concat(userId).concat("&instanceid=").concat(instanceId);
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse.getResponseBody().toString();
    }

    /**
     * 設置企業成員發起會議的權限
     * @param authorizedUsersVo
     * @return
     */
    public String setUpAuthorizedUsers(AuthorizedUsersVo authorizedUsersVo) {
        //POST https://api.meeting.qq.com/v1/corp-resource/book-meeting/authorized-users
        String uri = "/v1/corp-resource/book-meeting/authorized-users";
        HttpResponse httpResponse = TencentMeetingProcess.postProcess(uri, authorizedUsersVo);
        return httpResponse.getResponseBody().toString();
    }

    /**
     * 查詢企業下可發起會議的成員列表
     * @param queryAuthorizedUsersVo
     * @return
     */
    public String queryAuthorizedUsers(QueryAuthorizedUsersVo queryAuthorizedUsersVo) {
        //GET v1/corp-resource/book-meeting/authorized-users?operator_userid={operator_userid}&page={page}&page_size={page_size}
        String uri = "/v1/corp-resource/book-meeting/authorized-users?operator_userid="
                .concat(queryAuthorizedUsersVo.getOperatorUserId())
                .concat("&page=").concat(String.valueOf(queryAuthorizedUsersVo.getPage()))
                .concat("&page_size=").concat(String.valueOf(queryAuthorizedUsersVo.getPageSize()));
        HttpResponse httpResponse = TencentMeetingProcess.getProcess(uri);
        return httpResponse.getResponseBody().toString();
    }
}

 代碼地址GitHub：https://github.com/dongl-dl/tencent-meeting-api