[Java]直播方案----[接入環信聊天室]+[騰訊雲直播]

時間 2019-11-08

標籤 java 直播方案聊天室騰訊欄目 Java 简体版

原文原文鏈接

辛辛苦苦寫的,轉載請註明一下,這點信任我想仍是有的吧,謝謝了。html

http://www.cnblogs.com/applerosa/p/7162268.html java

以前作了直播，一直沒時間寫,好不容易閒下來,因此總結記錄一下.git

須要注意的是，在獲取環信聊天室ID和騰訊雲三個推/拉流地址的時候，須要先去註冊，獲取所用開發者帳號。apache

因此這個教程所必須的東西:json

1.環信開發者帳號;api

2.騰訊雲開發者帳號;服務器

1、作直播，確定要有一個直播模型，這裏咱們用直播間來作示例：app

這裏只是作個基礎的演示,因此都是必須的字段,實際業務需求不同,酌情添加.dom

 1 CREATE TABLE `live_room` (
 2     `id` INT(32) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '精品直播主鍵',
 3     `room_title` VARCHAR(256) NOT NULL COMMENT '直播間標題',
 4     `room_desc` VARCHAR(256) NULL DEFAULT NULL COMMENT '直播間描述/簡介',
 5     `chatroom_id` VARCHAR(16) NULL DEFAULT NULL COMMENT '聊天室ID',
 6     `push_url` VARCHAR(256) NULL DEFAULT NULL COMMENT '推流地址',
 7     `pull_url` VARCHAR(256) NULL DEFAULT NULL COMMENT 'HTTP拉流地址',
 8     `pull_rtmp_url` VARCHAR(256) NULL DEFAULT NULL COMMENT 'RTMP拉流地址',
 9     `video_url` VARCHAR(255) NULL DEFAULT NULL COMMENT '錄播視頻url',
10     `status` TINYINT(2) UNSIGNED NOT NULL DEFAULT '0' COMMENT '直播狀態：0-初始化 1-直播中 2-已結束',
11     `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '建立時間',
12     PRIMARY KEY (`id`)
13 )
14 COLLATE='utf8mb4_general_ci'
15 ENGINE=InnoDB
16 ;

建表語句

大概就這樣的:socket

表結構貼出來了,其他的實體,操做語句什麼的就不貼了,代碼生成器就幫你搞定了.

這裏主要想說一下騰訊的三個推/拉流地址:

1.推流地址 push_url 就是你須要推送給騰訊的數據流地址,理論上能夠是視頻,也能夠是音頻;

2.HTTP拉流地址 pull_url 也就是APP拉流地址;

3.RTMP拉流地址 pull_rtmp_url 也就是咱們說的PC拉流地址.

另外補充一下錄播視頻 video_url 就是,若是咱們開通騰訊直播的時候,使用了錄播功能,在直播結束後,咱們能夠查詢到騰訊錄製的視頻文件地址,而後用來播放.

2、騰訊雲地址的獲取

先貼個騰訊雲直播的API地址:https://www.qcloud.com/document/product/267/7976?!preview=true&lang=zh

你們能夠點進去看看詳情.這裏就簡單說一下,能夠看到,他提供了兩種直播方式:

第一種是直播碼接入方式,這種模式呢,地址生成方便,地址由咱們後臺生成,要用的時候直接用就能夠,可靠性也高,因此這個例子中就是直播碼模式.

　　而後當第一次使用這個地址的時候,騰訊雲會檢測這個地址中包含的信息,看是否符合規則,符合規則就開始推流,開始直播.

第二種頻道模式,就是每次建立地址都要去騰訊請求,而後他生成可用的地址返回給你,而後你再存入庫,用的時候再拿出來用.

這是他官網上的比較:

其餘的你們能夠仔細看看官網,下面開整!

1. 拼接騰訊三個推拉流地址,下面是工具類,你們能夠直接拿去用.

關於詳細的生成規則,騰訊API有詳細說明:https://www.qcloud.com/document/product/267/7977?!preview=true&lang=zh

關於開發者信息的地址:https://console.qcloud.com/live/livecodemanage

由於這裏個人工具類中有相關帳號信息,因此你們到時候須要作相應替換.

上面的信息你們根據對應的替換就能夠

根據API中的介紹

下面是咱們就是咱們須要的結果了:

好了,下面貼工具類,記得按上面的規則替換信息.

import org.apache.log4j.Logger;

/**
 * 騰訊推流、拉流工具
 * 
 * @author lnexin@aliyun.com
 */
public class TecentCloudUtils {

    @SuppressWarnings("unused")
　　// 這就是個日誌,不須要的刪掉就好了 private static final Logger logger = Logger.getLogger(TecentCloudUtils.class);

    // 用於 生成推流防盜鏈的key
    public static final String key = "替換本身的開發者信息,謝謝!";

    public static final String bizid = "替換本身的開發者信息,謝謝!";

    public static final String APPID = "替換本身的開發者信息,謝謝!";

    // 用於主動查詢和被動通知的key:API鑑定key
    public static final String API_KEY = "替換本身的開發者信息,謝謝!";

    // API回調地址
    public static final String API_ADDRESS = "http://fcgi.video.qcloud.com/common_access";

    /**
     * 推流地址
     */
    public static final String PUSH_URL = "rtmp://" + bizid + ".livepush.myqcloud.com/live/" + bizid + "_";

    /**
     * PC拉流地址
     */
    public static final String PULL_RTMP_URL = "rtmp://" + bizid + ".liveplay.myqcloud.com/live/"+ bizid + "_";
    /**
     * app拉流地址
     */
    public static final String PULL_URL = "http://" + bizid + ".liveplay.myqcloud.com/live/"+ bizid + "_";

    /**
     * 這是推流防盜鏈的生成 KEY+ streamId + txTime
     * 
     * @param key
     *            防盜鏈使用的key
     * @param streamId
     *            一般爲直播碼.示例:bizid+房間id
     * @param txTime
     *            到期時間
     * @return
     * @author lnexin@aliyun.com
     */
    public static String getSafeUrl(String key, String streamId, long txTime) {
        String input = new StringBuilder().append(key).append(streamId).append(Long.toHexString(txTime).toUpperCase()).toString();

        String txSecret = null;

        txSecret = MD5Encode.stringToMD5(input);

        return txSecret == null ? "" : new StringBuilder().append("txSecret=").append(txSecret).append("&").append("txTime=").append(Long.toHexString(txTime).toUpperCase()).toString();
    }

    /**
     * 推流地址生成
     */
    public static String getPushUrl(String roomId) {
        Long now = System.currentTimeMillis() + 60L * 60L * 24L * 30L * 1000L;// 要轉成long類型，否則爲負數
        // 當前毫秒數+須要加上的時間毫秒數 = 過時時間毫秒數
        Long txTime = now / 1000;// 推流碼過時時間秒數

        String safeUrl = getSafeUrl(key, bizid + "_" + roomId, txTime);

        String realPushUrl = PUSH_URL + roomId + "?bizid=" + bizid + "&" + safeUrl;

        return realPushUrl;
    }

    /**
     * APP拉流地址得到
     */
    public static String getPullUrl(String owenrId) {
        String appPullUrl = PULL_URL + owenrId + ".flv";
        return appPullUrl;
    }

    /**
     * PC拉流地址得到
     */
    public static String getPullRtmpUrl(String owenrId) {
        String pullRtmpUrl = PULL_RTMP_URL + owenrId;
        return pullRtmpUrl;
    }

    /**
     * 獲取關閉直播的url關閉直播 須要發送請求給騰訊服務器,而後返回結果
     * 
     * @param id
     *            須要關閉的房間ID
     * @return 關閉直播的url
     * @author lnexin@aliyun.com
     * @date 2017年7月22日 下午2:54:14
     */
    public static String getCloseLiveUrl(String id) {
        // 此請求的有效時間
        Long current = System.currentTimeMillis() / 1000 + 10;
        // 生成sign簽名
        String sign = MD5Encode.stringToMD5(new StringBuffer().append(API_KEY).append(current).toString());
        // 生成須要關閉的直播碼
        String code = bizid + "_" + id;
        // 生成關閉的參數列表
        String params = new StringBuffer().append("&interface=Live_Channel_SetStatus").append("&Param.s.channel_id=").append(code).append("&Param.n.status=0").append("&t=").append(current).append("&sign=").append(sign).toString();

        // 拼接關閉URL
        String url = API_ADDRESS + "?appid=" + APPID + params;
        return url;
    }

    /**
     * 獲取錄播查詢請求地址
     * 
     * @param id
     * @return
     * @author lnexin@aliyun.com
     * @date 2017年7月22日 下午12:45:57
     */
    public static String getRecordUrl(String id) {
        Long current = (System.currentTimeMillis() + 60 * 60 * 24 * 1000) / 1000;
        String sign = MD5Encode.stringToMD5(new StringBuffer().append(API_KEY).append(current).toString());
        String code = bizid + "_" + id;
        String params = new StringBuffer().append("&interface=Live_Tape_GetFilelist").append("&Param.s.channel_id=").append(code).append("&t=").append(current).append("&sign=").append(sign).toString();

        // 拼接URL
        String url = API_ADDRESS + "?appid=" + APPID + params;
        return url;
    }

}

當你替換爲你本身對應的信息以後,就可使用這個工具類生成三個地址,和關閉地址,查詢錄播視頻地址了.如:

// 騰訊雲獲取推流地址、拉流地址
String pushUrl = TecentCloudUtils.getPushUrl(roomId);
String pullUrl = TecentCloudUtils.getPullUrl(roomId);
String pullRtmpUrl = TecentCloudUtils.getPullRtmpUrl(roomId);

這裏傳入的參數(roomId)只要是你這個直播間惟一標識就行,類型不重要的,是否是主鍵也不重要,你也能夠改爲其餘類型,目的只是爲了生成的地址不重複就好;

獲取的地址存入庫,要直播的時候拿出來用就能夠了.

這裏強調一下:

這個地址按規則生成之後,騰訊雲並沒有這個房間,只是在第一次使用的時候,咱們向這個地址推流,而後騰訊雲接受到這個地址,檢測地址中的信息,看是否符合規則,符合規則就在雲上建立直播間,而後開始推/拉流;

等於說咱們建立地址的時候,根本不須要和騰訊雲通信.

這裏補充一個上面工具中使用到的MD5工具，固然你們也能夠用本身的。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;

public class MD5Encode {
    
    public static String stringToMD5(String str) {

        try {
            byte[] strTemp = str.getBytes();
            MessageDigest mdTemp = MessageDigest.getInstance("MD5");
            mdTemp.update(strTemp);
            return toHexString(mdTemp.digest());
        } catch (Exception e) {
            return null;
        }
    }

    public static String fileNameToMD5(String fileName) {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(fileName);
            return streamToMD5(inputStream);
        } catch (Exception e) {
            return null;
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static String streamToMD5(InputStream inputStream) {
        try {
            MessageDigest mdTemp = MessageDigest.getInstance("MD5");
            byte[] buffer = new byte[1024];
            int numRead = 0;
            while ((numRead = inputStream.read(buffer)) > 0) {
                mdTemp.update(buffer, 0, numRead);
            }
            return toHexString(mdTemp.digest());
        } catch (Exception e) {
            return null;
        }
    }

    private static String toHexString(byte[] md) {
        char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'a', 'b', 'c', 'd', 'e', 'f' };
        int j = md.length;
        char str[] = new char[j * 2];
        for (int i = 0; i < j; i++) {
            byte byte0 = md[i];
            str[2 * i] = hexDigits[byte0 >>> 4 & 0xf];
            str[i * 2 + 1] = hexDigits[byte0 & 0xf];
        }
        return new String(str);
    }
}

MD5Encode

3、環信聊天室

既然是直播，咱們就須要清楚，咱們須要的是「聊天室」模式，就是從開始直播建立一個聊天室以後，每進入一個用戶，就加入這個聊天室，而後在聊天室中聊天，就是咱們常說的互動。

環信手冊:http://docs.easemob.com/im/100serverintegration/10intro

服務端集成:http://docs.easemob.com/im/live/server-integration

由於我這裏只須要一個聊天室ID因此就作了其他的輔助：如建立時驗證用戶權限，從返回信息中篩選出我須要的信息，多餘的功能你們能夠根據需求來刪減；

這裏有額外依賴：

<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</dependency>

<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>

關於log的依賴，你們也能夠刪除：

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.12</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>

Log4j的依賴

下面是主要工具類文件:(只複製這個必定會報錯)

import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.sf.json.JSONObject;

/**
 * 建立環信聊天室
 * @author lnexin@aliyun.com
 */
public class CreateChatRoom {
    
    private static final Logger logger = LoggerFactory.getLogger(CreateChatRoom.class);
    /**
     * 
     * @param roomsName 
     * @param desc
     * @param owner
     * @param userIds
     * @return
     * 
     * 注：服務器需求格式爲
     *          {"name":"testchatroom","description":"server create chatroom","maxusers":300,"owner":"jma1","members":["jma2","jma3"]}
     */
    public static String createChatRooms(String roomsName, String desc, String owner, List<String> userIds) {

        
        try {
            JSONObject params = new JSONObject();
            params.put("name", roomsName);
            params.put("description", desc);
            params.put("maxusers", 5000); // 聊天室成員最大數（包括羣主），值爲數值類型，默認值200，此屬性爲可選的
            params.put("owner", owner);

            if (userIds.size() > 0) {
                params.put("members", userIds);
            }

            JSONObject result = HttpTool.doPostsWithToken(HuanxinConstant.CHATROOM_URL, params.toString(), GetAdminToken.getToken());
            
            if(result.has("error_description")) {
                logger.error("錯誤信息：" + result.getString("error_description"));
            }

            JSONObject object = result.getJSONObject("data");

            //返回建立好的一個聊天室ID
            if (!(object.get("id") == null)) {
                return object.getString("id");
            }
        } catch (Exception e) {
            return null;
        }

        return null;
    }
    
    public static void main(String[] args) {
        List<String> userIds = new ArrayList<String>();
        String chatRoom = createChatRooms("600000的聊天室", "你們快來聊天", "600000", userIds);
        System.err.println(chatRoom);
    }
}

下面是其餘的一些輔助:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.protocol.Protocol;

import net.sf.json.JSONObject;

/**
 * 獲取管理員token
 * @author lnexin@aliyun.com
 * 
 */
public class GetAdminToken {
    
    private static String url = HuanxinConstant.TOKEN_APP_URL;
    private static String grant_type = HuanxinConstant.GRANT_TYPE;
    private static String client_id = HuanxinConstant.CLIENT_ID;
    private static String client_secret = HuanxinConstant.CLIENT_SECRET;
    
    
    public static String getToken() throws Exception{
        
        JSONObject params = new JSONObject();
        params.put("grant_type", grant_type);
        params.put("client_id", client_id);
        params.put("client_secret", client_secret);        
        
        String doPosts = doPosts(url, params.toString());
        
        JSONObject fromObject = JSONObject.fromObject(doPosts);
        return (String) fromObject.get("access_token");
    }
    
    @SuppressWarnings("deprecation")
    public static String doPosts(String url, String params) throws UnsupportedEncodingException {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);

        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        post.setRequestHeader("Content-Type", "application/json");
        
        if (params != null) {
            InputStream in = new ByteArrayInputStream(params.getBytes("utf-8"));
            post.setRequestBody(in);
        }

        try {
            client.executeMethod(post);
            return is2Str(post.getResponseBodyAsStream());
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            post.releaseConnection();
        }
        return null;
    }
    
    public static String is2Str(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int i = -1;
        while ((i = is.read()) != -1) {
            baos.write(i);
        }
        return baos.toString();
    }
}

GetAdminToken

/**
 * 註冊環信
 * @author lnexin@aliyun.com
 *
 */
public class HuanXinRegist {

    /**
     * 註冊環信新用戶
     * @param username 須要註冊的用戶名
     * @param password 須要註冊的密碼
     * @param nickName 須要註冊的暱稱
     * @return
     */
    public static boolean registerUser(String username, String password, String nickName) {

        try {
            JSONObject params = new JSONObject();
            params.put("username", username);
            params.put("password", password);
            params.put("nickname", nickName);

            int status = HttpTool.doPosts(HuanxinConstant.USERS_URL, params.toString(), GetAdminToken.getToken());
            if (status == 200) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }
}

HuanXinRegist

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.SocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;

public class MySSLSocketFactory implements ProtocolSocketFactory {
    private SSLContext sslcontext = null;

    private SSLContext createSSLContext() {
        SSLContext sslcontext = null;
        try {
            sslcontext = SSLContext.getInstance("SSL");
            sslcontext.init(null, new TrustManager[] { new TrustAnyTrustManager() }, new java.security.SecureRandom());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return sslcontext;
    }

    private SSLContext getSSLContext() {
        if (this.sslcontext == null) {
            this.sslcontext = createSSLContext();
        }
        return this.sslcontext;
    }

    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
    }

    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(host, port);
    }

    public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
    }

    public Socket createSocket(String host, int port, InetAddress localAddress, int localPort, HttpConnectionParams params) throws IOException,
            UnknownHostException, ConnectTimeoutException {
        if (params == null) {
            throw new IllegalArgumentException("Parameters may not be null");
        }
        int timeout = params.getConnectionTimeout();
        SocketFactory socketfactory = getSSLContext().getSocketFactory();
        if (timeout == 0) {
            return socketfactory.createSocket(host, port, localAddress, localPort);
        } else {
            Socket socket = socketfactory.createSocket();
            SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);
            SocketAddress remoteaddr = new InetSocketAddress(host, port);
            socket.bind(localaddr);
            socket.connect(remoteaddr, timeout);
            return socket;
        }
    }

    private static class TrustAnyTrustManager implements X509TrustManager {
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[] {};
        }
    }
}

MySSLSocketFactory

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.DeleteMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.commons.httpclient.protocol.Protocol;

import net.sf.json.JSONObject;

/**
 * HTTP請求工具
 * @author lnexin@aliyun.com
 *
 */
public class HttpTool {
    public static String is2Str(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int i = -1;
        while ((i = is.read()) != -1) {
            baos.write(i);
        }
        return baos.toString();
    }

    public static String doPosts(String url, NameValuePair[] nameValuePairs) {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);

        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        if (nameValuePairs != null) {
            post.setRequestBody(nameValuePairs);
        }

        try {
            client.executeMethod(post);
            return is2Str(post.getResponseBodyAsStream());
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            post.releaseConnection();
        }
        return null;
    }

    public static Object doPosts(String url) throws UnsupportedEncodingException {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);

        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        post.setRequestHeader("Content-Type", "application/json");

        try {
            client.executeMethod(post);
            return is2Str(post.getResponseBodyAsStream());
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            post.releaseConnection();
        }
        return null;
    }

    @SuppressWarnings("deprecation")
    public static int doPosts(String url, String params, String token) throws UnsupportedEncodingException {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);

        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        post.setRequestHeader("Content-Type", "application/json");
        if (token != null) {
            post.setRequestHeader("Authorization", "Bearer " + token);
        }
        if (params != null) {
            // post.setRequestBody(params);
            InputStream in = new ByteArrayInputStream(params.getBytes("utf-8"));
            post.setRequestBody(in);
        }

        try {
            client.executeMethod(post);
            return post.getStatusCode();
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            post.releaseConnection();
        }
        return 0;
    }

    public static int doDelete(String url, String token) {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);

        HttpClient client = new HttpClient();
        DeleteMethod delete = new DeleteMethod(url);
        if (token != null) {
            delete.setRequestHeader("Authorization", "Bearer " + token);
        }

        try {
            client.executeMethod(delete);
            return delete.getStatusCode();
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            delete.releaseConnection();
        }
        return 0;
    }

    @SuppressWarnings("deprecation")
    public static int doPuts(String url, String params, String token) throws UnsupportedEncodingException {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);

        HttpClient client = new HttpClient();
        PutMethod put = new PutMethod(url);
        if (token != null) {
            put.setRequestHeader("Authorization", "Bearer " + token);
        }
        if (params != null) {
            // put.setRequestBody(params);
            InputStream in = new ByteArrayInputStream(params.getBytes("utf-8"));
            put.setRequestBody(in);
        }

        try {
            client.executeMethod(put);
            return put.getStatusCode();
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            put.releaseConnection();
        }
        return 0;
    }

    public static String doPost(String url, NameValuePair[] nameValuePairs) {
        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        if (nameValuePairs != null) {
            post.setRequestBody(nameValuePairs);
        }

        try {
            client.executeMethod(post);
            return is2Str(post.getResponseBodyAsStream());
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            post.releaseConnection();
        }
        return null;
    }

    /**
     * 發送請求，建立房間
     * 
     * @author duxin
     * @param url
     *            請求地址
     * @param params
     *            服務器須要的一個json格式的數據：包括標題，簡介什麼的
     * @param token
     *            管理員的token數據
     * @return 返回一個建立好的房間結果(JSONObject格式)
     * @throws UnsupportedEncodingException
     */
    @SuppressWarnings("deprecation")
    public static JSONObject doPostsWithToken(String url, String params, String token) throws UnsupportedEncodingException {
        Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
        Protocol.registerProtocol("https", myhttps);
        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        post.setRequestHeader("Content-Type", "application/json");
        if (token != null) {
            post.setRequestHeader("Authorization", "Bearer " + token);
        }
        if (params != null) {
            // post.setRequestBody(params);
            InputStream in = new ByteArrayInputStream(params.getBytes("utf-8"));
            post.setRequestBody(in);
        }

        try {
            client.executeMethod(post);
            return is2Json(is2Str(post.getResponseBodyAsStream()));
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            post.releaseConnection();
        }
        return null;
    }

    public static JSONObject is2Json(String is) throws IOException {
        return JSONObject.fromObject(is);
    }
}

HttpTool

重要的來了,就是環信的開發者信息:

開發者信息查看:https://console.easemob.com/index.html 登錄以後進Home主頁

點擊應用名稱查看便可.

而後替換常量類中的數據

/**
 * 環信常量保存工具類
 * @author lnexin@aliyun.com
 */
public interface HuanxinConstant {
    
    public static final String CLIENT_ID = "替換本身的開發者信息,謝謝!";
    
    public static final String CLIENT_SECRET = "替換本身的開發者信息,謝謝!";
    
    public static final String GRANT_TYPE = "client_credentials";

    public static final String HUANXIN_URL = "https://a1.easemob.com/替換本身的開發者信息,謝謝!";

    public static final String TOKEN_APP_URL = HUANXIN_URL + "/token";
    
    public static final String INITIALIZE_PASSWORD = "替換本身的開發者信息,謝謝!";

    //用戶體系集成url
    public static final String USERS_URL = HUANXIN_URL + "/users";

    //環信消息url
    public static final String MESSAGES_URL = HUANXIN_URL + "/messages";

    //羣組url
    public static final String CHATGROUPS_URL = HUANXIN_URL + "/chatgroups";

    //羣組消息url
    public static final String CHATMESSAGES_URL = HUANXIN_URL + "/chatmessages";
    
    //聊天室url
    public static final String CHATROOM_URL = HUANXIN_URL + "/chatrooms";
    
}