移动开发首页业界资讯移动应用平台技术专题 输入您要搜索的内容 基于Java Socket的自定义协议，实现Android与服务器的长连接（二）

在阅读本文前需要对socket以及自定义协议有一个基本的了解，可以先查看上一篇文章《基于Java Socket的自定义协议，实现Android与服务器的长连接(一)》学习相关的基础知识点。

一、协议定义

上一篇文章中，我们对socket编程和自定义协议做了一个简单的了解，本文将在此基础上加以深入，来实现Android和服务器之间的长连接，现定义协议如下：

  • 数据类协议(Data)
    • 长度(length，32bit)
    • 版本号(version，8bit，前3位预留，后5位用于表示真正的版本号)
    • 数据类型(type，8bit，0表示数据)
    • 业务类型(pattion，8bit，0表示push，其他暂未定)
    • 数据格式(dtype，8bit，0表示json，其他暂未定)
    • 消息id(msgId，32bit)
    • 正文数据(data)
  • 数据ack类协议(DataAck)
    • 长度(length，32bit)
    • 版本号(version，8bit，前3位预留，后5位用于表示真正的版本号)
    • 数据类型(type，8bit，1表示数据ack)
    • ack消息id(ackMsgId，32bit)
    • 预留信息(unused)
  • 心跳类协议(ping)
    • 长度(length，32bit)
    • 版本号(version，8bit，前3位预留，后5位用于表示真正的版本号)
    • 数据类型(type，8bit，2表示心跳)
    • 心跳id(pingId，32bit，client上报取奇数，即1，3，5...，server下发取偶数，即0，2，4...)
    • 预留信息(unused)
  • 心跳ack类协议(pingAck)
    • 长度(length，32bit)
    • 版本号(version，8bit，前3位预留，后5位用于表示真正的版本号)
    • 数据类型(type，8bit，3表示心跳ack)
    • ack心跳id(pingId，32bit，client上报取奇数，即1，3，5...，server下发取偶数，即0，2，4...)
    • 预留信息(unused)

二、协议实现

从上述的协议定义中，我们可以看出，四种协议有共同的3个要素，分别是：长度、版本号、数据类型，那么我们可以先抽象出一个基本的协议，如下：

1. BasicProtocol

  1. import android.util.Log; 
  2.  
  3. import com.shandiangou.sdgprotocol.lib.Config; 
  4. import com.shandiangou.sdgprotocol.lib.ProtocolException; 
  5. import com.shandiangou.sdgprotocol.lib.SocketUtil; 
  6.  
  7. import java.io.ByteArrayOutputStream; 
  8.  
  9. /** 
  10.  * Created by meishan on 16/12/1. 
  11.  * <p> 
  12.  * 协议类型: 0表示数据，1表示数据Ack，2表示ping，3表示pingAck 
  13.  */ 
  14. public abstract class BasicProtocol { 
  15.  
  16.     // 长度均以字节（byte）为单位 
  17.     public static final int LENGTH_LEN = 4;       //记录整条数据长度数值的长度 
  18.     protected static final int VER_LEN = 1;       //协议的版本长度（其中前3位作为预留位，后5位作为版本号） 
  19.     protected static final int TYPE_LEN = 1;      //协议的数据类型长度 
  20.  
  21.     private int reserved = 0;                     //预留信息 
  22.     private int version = Config.VERSION;         //版本号 
  23.  
  24.     /** 
  25.      * 获取整条数据长度 
  26.      * 单位：字节（byte） 
  27.      * 
  28.      * @return 
  29.      */ 
  30.     protected int getLength() { 
  31.         return LENGTH_LEN + VER_LEN + TYPE_LEN; 
  32.     } 
  33.  
  34.     public int getReserved() { 
  35.         return reserved; 
  36.     } 
  37.  
  38.     public void setReserved(int reserved) { 
  39.         this.reserved = reserved; 
  40.     } 
  41.  
  42.     public int getVersion() { 
  43.         return version; 
  44.     } 
  45.  
  46.     public void setVersion(int version) { 
  47.         this.version = version; 
  48.     } 
  49.  
  50.     /** 
  51.      * 获取协议类型，由子类实现 
  52.      * 
  53.      * @return 
  54.      */ 
  55.     public abstract int getProtocolType(); 
  56.      
  57.     /** 
  58.      * 由预留值和版本号计算完整版本号的byte[]值 
  59.      * 
  60.      * @return 
  61.      */ 
  62.     private int getVer(byte r, byte v, int vLen) { 
  63.         int num = 0; 
  64.         int rLen = 8 - vLen; 
  65.         for (int i = 0; i < rLen; i++) { 
  66.             num += (((r >> (rLen - 1 - i)) & 0x1) << (7 - i)); 
  67.         } 
  68.         return num + v; 
  69.     } 
  70.  
  71.     /** 
  72.      * 拼接发送数据，此处拼接了协议版本、协议类型和数据长度，具体内容子类中再拼接 
  73.      * 按顺序拼接 
  74.      * 
  75.      * @return 
  76.      */ 
  77.     public byte[] genContentData() { 
  78.         byte[] length = SocketUtil.int2ByteArrays(getLength()); 
  79.         byte reserved = (byte) getReserved(); 
  80.         byte version = (byte) getVersion(); 
  81.         byte[] ver = {(byte) getVer(reserved, version, 5)}; 
  82.         byte[] type = {(byte) getProtocolType()}; 
  83.  
  84.         ByteArrayOutputStream baos = new ByteArrayOutputStream(LENGTH_LEN + VER_LEN + TYPE_LEN); 
  85.         baos.write(length, 0, LENGTH_LEN); 
  86.         baos.write(ver, 0, VER_LEN); 
  87.         baos.write(type, 0, TYPE_LEN); 
  88.         return baos.toByteArray(); 
  89.     } 
  90.  
  91.     /** 
  92.      * 解析出整条数据长度 
  93.      * 
  94.      * @param data 
  95.      * @return 
  96.      */ 
  97.     protected int parseLength(byte[] data) { 
  98.         return SocketUtil.byteArrayToInt(data, 0, LENGTH_LEN); 
  99.     } 
  100.  
  101.     /** 
  102.      * 解析出预留位 
  103.      * 
  104.      * @param data 
  105.      * @return 
  106.      */ 
  107.     protected int parseReserved(byte[] data) { 
  108.         byte r = data[LENGTH_LEN];//前4个字节（0，1，2，3）为数据长度的int值，与版本号组成一个字节 
  109.         return (r >> 5) & 0xFF; 
  110.     } 
  111.  
  112.     /** 
  113.      * 解析出版本号 
  114.      * 
  115.      * @param data 
  116.      * @return 
  117.      */ 
  118.     protected int parseVersion(byte[] data) { 
  119.         byte v = data[LENGTH_LEN]; //与预留位组成一个字节 
  120.         return ((v << 3) & 0xFF) >> 3; 
  121.     } 
  122.  
  123.     /** 
  124.      * 解析出协议类型 
  125.      * 
  126.      * @param data 
  127.      * @return 
  128.      */ 
  129.     public static int parseType(byte[] data) { 
  130.         byte t = data[LENGTH_LEN + VER_LEN];//前4个字节（0，1，2，3）为数据长度的int值，以及ver占一个字节 
  131.         return t & 0xFF; 
  132.     } 
  133.  
  134.     /** 
  135.      * 解析接收数据，此处解析了协议版本、协议类型和数据长度，具体内容子类中再解析 
  136.      * 
  137.      * @param data 
  138.      * @return 
  139.      * @throws ProtocolException 协议版本不一致，抛出异常 
  140.      */ 
  141.     public int parseContentData(byte[] data) throws ProtocolException { 
  142.         int reserved = parseReserved(data); 
  143.         int version = parseVersion(data); 
  144.         int protocolType = parseType(data); 
  145.         if (version != getVersion()) { 
  146.             throw new ProtocolException("input version is error: " + version); 
  147.         } 
  148.         return LENGTH_LEN + VER_LEN + TYPE_LEN; 
  149.     } 
  150.  
  151.     @Override 
  152.     public String toString() { 
  153.         return "Version: " + getVersion() + ", Type: " + getProtocolType(); 
  154.     } 
  155. }  

上述涉及到的Config类和SocketUtil类如下：

  1. /** 
  2.  * Created by meishan on 16/12/2. 
  3.  */ 
  4. public class Config { 
  5.  
  6.     public static final int VERSION = 1;                 //协议版本号 
  7.     public static final String ADDRESS = "10.17.64.237"; //服务器地址 
  8.     public static final int PORT = 9013;                 //服务器端口号 
  9.      
  10. }  
  1. import java.io.BufferedInputStream; 
  2. import java.io.BufferedOutputStream; 
  3. import java.io.IOException; 
  4. import java.io.InputStream; 
  5. import java.io.OutputStream; 
  6. import java.nio.ByteBuffer; 
  7. import java.util.HashMap; 
  8. import java.util.Map; 
  9.  
  10. /** 
  11.  * Created by meishan on 16/12/1. 
  12.  */ 
  13. public class SocketUtil { 
  14.  
  15.     private static Map<Integer, String> msgImp = new HashMap<>(); 
  16.  
  17.     static { 
  18.         msgImp.put(DataProtocol.PROTOCOL_TYPE, "com.shandiangou.sdgprotocol.lib.protocol.DataProtocol");       //0 
  19.         msgImp.put(DataAckProtocol.PROTOCOL_TYPE, "com.shandiangou.sdgprotocol.lib.protocol.DataAckProtocol"); //1 
  20.         msgImp.put(PingProtocol.PROTOCOL_TYPE, "com.shandiangou.sdgprotocol.lib.protocol.PingProtocol");       //2 
  21.         msgImp.put(PingAckProtocol.PROTOCOL_TYPE, "com.shandiangou.sdgprotocol.lib.protocol.PingAckProtocol"); //3 
  22.     } 
  23.  
  24.     /** 
  25.      * 解析数据内容 
  26.      * 
  27.      * @param data 
  28.      * @return 
  29.      */ 
  30.     public static BasicProtocol parseContentMsg(byte[] data) { 
  31.         int protocolType = BasicProtocol.parseType(data); 
  32.         String className = msgImp.get(protocolType); 
  33.         BasicProtocol basicProtocol; 
  34.         try { 
  35.             basicProtocol = (BasicProtocol) Class.forName(className).newInstance(); 
  36.             basicProtocol.parseContentData(data); 
  37.         } catch (Exception e) { 
  38.             basicProtocol = null; 
  39.             e.printStackTrace(); 
  40.         } 
  41.         return basicProtocol; 
  42.     } 
  43.  
  44.     /** 
  45.      * 读数据 
  46.      * 
  47.      * @param inputStream 
  48.      * @return 
  49.      * @throws SocketExceptions 
  50.      */ 
  51.     public static BasicProtocol readFromStream(InputStream inputStream) { 
  52.         BasicProtocol protocol; 
  53.         BufferedInputStream bis; 
  54.          
  55.         //header中保存的是整个数据的长度值，4个字节表示。在下述write2Stream方法中，会先写入header 
  56.         byte[] header = new byte[BasicProtocol.LENGTH_LEN]; 
  57.  
  58.         try { 
  59.             bis = new BufferedInputStream(inputStream); 
  60.  
  61.             int temp; 
  62.             int len = 0; 
  63.             while (len < header.length) { 
  64.                 temp = bis.read(header, len, header.length - len); 
  65.                 if (temp > 0) { 
  66.                     len += temp; 
  67.                 } else if (temp == -1) { 
  68.                     bis.close(); 
  69.                     return null; 
  70.                 } 
  71.             } 
  72.  
  73.             len = 0; 
  74.             int length = byteArrayToInt(header);//数据的长度值 
  75.             byte[] content = new byte[length]; 
  76.             while (len < length) { 
  77.                 temp = bis.read(content, len, length - len); 
  78.  
  79.                 if (temp > 0) { 
  80.                     len += temp; 
  81.                 } 
  82.             } 
  83.  
  84.             protocol = parseContentMsg(content); 
  85.         } catch (IOException e) { 
  86.             e.printStackTrace(); 
  87.             return null; 
  88.         } 
  89.  
  90.         return protocol; 
  91.     } 
  92.  
  93.     /** 
  94.      * 写数据 
  95.      * 
  96.      * @param protocol 
  97.      * @param outputStream 
  98.      */ 
  99.     public static void write2Stream(BasicProtocol protocol, OutputStream outputStream) { 
  100.         BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream); 
  101.         byte[] buffData = protocol.genContentData(); 
  102.         byte[] header = int2ByteArrays(buffData.length); 
  103.         try { 
  104.             bufferedOutputStream.write(header); 
  105.             bufferedOutputStream.write(buffData); 
  106.             bufferedOutputStream.flush(); 
  107.         } catch (IOException e) { 
  108.             e.printStackTrace(); 
  109.         } 
  110.     } 
  111.  
  112.     /** 
  113.      * 关闭输入流 
  114.      * 
  115.      * @param is 
  116.      */ 
  117.     public static void closeInputStream(InputStream is) { 
  118.         try { 
  119.             if (is != null) { 
  120.                 is.close(); 
  121.             } 
  122.         } catch (IOException e) { 
  123.             e.printStackTrace(); 
  124.         } 
  125.     } 
  126.  
  127.     /** 
  128.      * 关闭输出流 
  129.      * 
  130.      * @param os 
  131.      */ 
  132.     public static void closeOutputStream(OutputStream os) { 
  133.         try { 
  134.             if (os != null) { 
  135.                 os.close(); 
  136.             } 
  137.         } catch (IOException e) { 
  138.             e.printStackTrace(); 
  139.         } 
  140.     } 
  141.  
  142.     public static byte[] int2ByteArrays(int i) { 
  143.         byte[] result = new byte[4]; 
  144.         result[0] = (byte) ((i >> 24) & 0xFF); 
  145.         result[1] = (byte) ((i >> 16) & 0xFF); 
  146.         result[2] = (byte) ((i >> 8) & 0xFF); 
  147.         result[3] = (byte) (i & 0xFF); 
  148.         return result; 
  149.     } 
  150.  
  151.     public static int byteArrayToInt(byte[] b) { 
  152.         int intValue = 0; 
  153.         for (int i = 0; i < b.length; i++) { 
  154.             intValue += (b[i] & 0xFF) << (8 * (3 - i)); //int占4个字节（0，1，2，3） 
  155.         } 
  156.         return intValue; 
  157.     } 
  158.  
  159.     public static int byteArrayToInt(byte[] b, int byteOffset, int byteCount) { 
  160.         int intValue = 0; 
  161.         for (int i = byteOffset; i < (byteOffset + byteCount); i++) { 
  162.             intValue += (b[i] & 0xFF) << (8 * (3 - (i - byteOffset))); 
  163.         } 
  164.         return intValue; 
  165.     } 
  166.  
  167.     public static int bytes2Int(byte[] b, int byteOffset) { 
  168.         ByteBuffer byteBuffer = ByteBuffer.allocate(Integer.SIZE / Byte.SIZE); 
  169.         byteBuffer.put(b, byteOffset, 4); //占4个字节 
  170.         byteBuffer.flip(); 
  171.         return byteBuffer.getInt(); 
  172.     } 
  173. }  

接下来我们实现具体的协议。

2. DataProtocol

  1. import android.util.Log; 
  2.  
  3. import com.shandiangou.sdgprotocol.lib.ProtocolException; 
  4. import com.shandiangou.sdgprotocol.lib.SocketUtil; 
  5.  
  6. import java.io.ByteArrayOutputStream; 
  7. import java.io.Serializable; 
  8. import java.io.UnsupportedEncodingException; 
  9.  
  10. /** 
  11.  * Created by meishan on 16/12/1. 
  12.  */ 
  13. public class DataProtocol extends BasicProtocol implements Serializable { 
  14.  
  15.     public static final int PROTOCOL_TYPE = 0; 
  16.  
  17.     private static final int PATTION_LEN = 1; 
  18.     private static final int DTYPE_LEN = 1; 
  19.     private static final int MSGID_LEN = 4; 
  20.  
  21.     private int pattion; 
  22.     private int dtype; 
  23.     private int msgId; 
  24.  
  25.     private String data; 
  26.  
  27.     @Override 
  28.     public int getLength() { 
  29.         return super.getLength() + PATTION_LEN + DTYPE_LEN + MSGID_LEN + data.getBytes().length; 
  30.     } 
  31.  
  32.     @Override 
  33.     public int getProtocolType() { 
  34.         return PROTOCOL_TYPE; 
  35.     } 
  36.  
  37.     public int getPattion() { 
  38.         return pattion; 
  39.     } 
  40.  
  41.     public void setPattion(int pattion) { 
  42.         this.pattion = pattion; 
  43.     } 
  44.  
  45.     public int getDtype() { 
  46.         return dtype; 
  47.     } 
  48.  
  49.     public void setDtype(int dtype) { 
  50.         this.dtype = dtype; 
  51.     } 
  52.  
  53.     public void setMsgId(int msgId) { 
  54.         this.msgId = msgId; 
  55.     } 
  56.  
  57.     public int getMsgId() { 
  58.         return msgId; 
  59.     } 
  60.  
  61.     public String getData() { 
  62.         return data; 
  63.     } 
  64.  
  65.     public void setData(String data) { 
  66.         this.data = data; 
  67.     } 
  68.  
  69.     /** 
  70.      * 拼接发送数据 
  71.      * 
  72.      * @return 
  73.      */ 
  74.     @Override 
  75.     public byte[] genContentData() { 
  76.         byte[] base = super.genContentData(); 
  77.         byte[] pattion = {(byte) this.pattion}; 
  78.         byte[] dtype = {(byte) this.dtype}; 
  79.         byte[] msgid = SocketUtil.int2ByteArrays(this.msgId); 
  80.         byte[] data = this.data.getBytes(); 
  81.  
  82.         ByteArrayOutputStream baos = new ByteArrayOutputStream(getLength()); 
  83.         baos.write(base, 0, base.length);          //协议版本＋数据类型＋数据长度＋消息id 
  84.         baos.write(pattion, 0, PATTION_LEN);       //业务类型 
  85.         baos.write(dtype, 0, DTYPE_LEN);           //业务数据格式 
  86.         baos.write(msgid, 0, MSGID_LEN);           //消息id 
  87.         baos.write(data, 0, data.length);          //业务数据 
  88.         return baos.toByteArray(); 
  89.     } 
  90.  
  91.     /** 
  92.      * 解析接收数据，按顺序解析 
  93.      * 
  94.      * @param data 
  95.      * @return 
  96.      * @throws ProtocolException 
  97.      */ 
  98.     @Override 
  99.     public int parseContentData(byte[] data) throws ProtocolException { 
  100.         int pos = super.parseContentData(data); 
  101.  
  102.         //解析pattion 
  103.         pattion = data[pos] & 0xFF; 
  104.         pos += PATTION_LEN; 
  105.  
  106.         //解析dtype 
  107.         dtype = data[pos] & 0xFF; 
  108.         pos += DTYPE_LEN; 
  109.  
  110.         //解析msgId 
  111.         msgId = SocketUtil.byteArrayToInt(data, pos, MSGID_LEN); 
  112.         pos += MSGID_LEN; 
  113.  
  114.         //解析data 
  115.         try { 
  116.             this.data = new String(data, pos, data.length - pos, "utf-8"); 
  117.         } catch (UnsupportedEncodingException e) { 
  118.             e.printStackTrace(); 
  119.         } 
  120.  
  121.         return pos; 
  122.     } 
  123.  
  124.     @Override 
  125.     public String toString() { 
  126.         return "data: " + data; 
  127.     } 
  128. }  

3. DataAckProtocol

  1. import com.shandiangou.sdgprotocol.lib.ProtocolException; 
  2. import com.shandiangou.sdgprotocol.lib.SocketUtil; 
  3.  
  4. import java.io.ByteArrayOutputStream; 
  5. import java.io.UnsupportedEncodingException; 
  6.  
  7. /** 
  8.  * Created by meishan on 16/12/1. 
  9.  */ 
  10. public class DataAckProtocol extends BasicProtocol { 
  11.  
  12.     public static final int PROTOCOL_TYPE = 1; 
  13.  
  14.     private static final int ACKMSGID_LEN = 4; 
  15.  
  16.     private int ackMsgId; 
  17.  
  18.     private String unused; 
  19.  
  20.     @Override 
  21.     public int getLength() { 
  22.         return super.getLength() + ACKMSGID_LEN + unused.getBytes().length; 
  23.     } 
  24.  
  25.     @Override 
  26.     public int getProtocolType() { 
  27.         return PROTOCOL_TYPE; 
  28.     } 
  29.  
  30.     public int getAckMsgId() { 
  31.         return ackMsgId; 
  32.     } 
  33.  
  34.     public void setAckMsgId(int ackMsgId) { 
  35.         this.ackMsgId = ackMsgId; 
  36.     } 
  37.  
  38.     public String getUnused() { 
  39.         return unused; 
  40.     } 
  41.  
  42.     public void setUnused(String unused) { 
  43.         this.unused = unused; 
  44.     } 
  45.  
  46.     /** 
  47.      * 拼接发送数据 
  48.      * 
  49.      * @return 
  50.      */ 
  51.     @Override 
  52.     public byte[] genContentData() { 
  53.         byte[] base = super.genContentData(); 
  54.         byte[] ackMsgId = SocketUtil.int2ByteArrays(this.ackMsgId); 
  55.         byte[] unused = this.unused.getBytes(); 
  56.  
  57.         ByteArrayOutputStream baos = new ByteArrayOutputStream(getLength()); 
  58.         baos.write(base, 0, base.length);              //协议版本＋数据类型＋数据长度＋消息id 
  59.         baos.write(ackMsgId, 0, ACKMSGID_LEN);         //消息id 
  60.         baos.write(unused, 0, unused.length);          //unused 
  61.         return baos.toByteArray(); 
  62.     } 
  63.  
  64.     @Override 
  65.     public int parseContentData(byte[] data) throws ProtocolException { 
  66.         int pos = super.parseContentData(data); 
  67.  
  68.         //解析ackMsgId 
  69.         ackMsgId = SocketUtil.byteArrayToInt(data, pos, ACKMSGID_LEN); 
  70.         pos += ACKMSGID_LEN; 
  71.  
  72.         //解析unused 
  73.         try { 
  74.             unused = new String(data, pos, data.length - pos, "utf-8"); 
  75.         } catch (UnsupportedEncodingException e) { 
  76.             e.printStackTrace(); 
  77.         } 
  78.  
  79.         return pos; 
  80.     } 
  81.  
  82. }  

4. PingProtocol

  1. import com.shandiangou.sdgprotocol.lib.ProtocolException; 
  2. import com.shandiangou.sdgprotocol.lib.SocketUtil; 
  3.  
  4. import java.io.ByteArrayOutputStream; 
  5. import java.io.UnsupportedEncodingException; 
  6.  
  7. /** 
  8.  * Created by meishan on 16/12/1. 
  9.  */ 
  10. public class PingProtocol extends BasicProtocol { 
  11.  
  12.     public static final int PROTOCOL_TYPE = 2; 
  13.  
  14.     private static final int PINGID_LEN = 4; 
  15.  
  16.     private int pingId; 
  17.  
  18.     private String unused; 
  19.  
  20.     @Override 
  21.     public int getLength() { 
  22.         return super.getLength() + PINGID_LEN + unused.getBytes().length; 
  23.     } 
  24.  
  25.     @Override 
  26.     public int getProtocolType() { 
  27.         return PROTOCOL_TYPE; 
  28.     } 
  29.  
  30.     public int getPingId() { 
  31.         return pingId; 
  32.     } 
  33.  
  34.     public void setPingId(int pingId) { 
  35.         this.pingId = pingId; 
  36.     } 
  37.  
  38.     public String getUnused() { 
  39.         return unused; 
  40.     } 
  41.  
  42.     public void setUnused(String unused) { 
  43.         this.unused = unused; 
  44.     } 
  45.  
  46.     /** 
  47.      * 拼接发送数据 
  48.      * 
  49.      * @return 
  50.      */ 
  51.     @Override 
  52.     public byte[] genContentData() { 
  53.         byte[] base = super.genContentData(); 
  54.         byte[] pingId = SocketUtil.int2ByteArrays(this.pingId); 
  55.         byte[] unused = this.unused.getBytes(); 
  56.  
  57.         ByteArrayOutputStream baos = new ByteArrayOutputStream(getLength()); 
  58.         baos.write(base, 0, base.length);          //协议版本＋数据类型＋数据长度＋消息id 
  59.         baos.write(pingId, 0, PINGID_LEN);         //消息id 
  60.         baos.write(unused, 0, unused.length);            //unused 
  61.         return baos.toByteArray(); 
  62.     } 
  63.  
  64.     @Override 
  65.     public int parseContentData(byte[] data) throws ProtocolException { 
  66.         int pos = super.parseContentData(data); 
  67.  
  68.         //解析pingId 
  69.         pingId = SocketUtil.byteArrayToInt(data, pos, PINGID_LEN); 
  70.         pos += PINGID_LEN; 
  71.  
  72.         try { 
  73.             unused = new String(data, pos, data.length - pos, "utf-8"); 
  74.         } catch (UnsupportedEncodingException e) { 
  75.             e.printStackTrace(); 
  76.         } 
  77.  
  78.         return pos; 
  79.     } 
  80.  
  81. }  

5. PingAckProtocol

  1. import com.shandiangou.sdgprotocol.lib.ProtocolException; 
  2. import com.shandiangou.sdgprotocol.lib.SocketUtil; 
  3.  
  4. import java.io.ByteArrayOutputStream; 
  5. import java.io.UnsupportedEncodingException; 
  6.  
  7. /** 
  8.  * Created by meishan on 16/12/1. 
  9.  */ 
  10. public class PingAckProtocol extends BasicProtocol { 
  11.  
  12.     public static final int PROTOCOL_TYPE = 3; 
  13.  
  14.     private static final int ACKPINGID_LEN = 4; 
  15.  
  16.     private int ackPingId; 
  17.  
  18.     private String unused; 
  19.  
  20.     @Override 
  21.     public int getLength() { 
  22.         return super.getLength() + ACKPINGID_LEN + unused.getBytes().length; 
  23.     } 
  24.  
  25.     @Override 
  26.     public int getProtocolType() { 
  27.         return PROTOCOL_TYPE; 
  28.     } 
  29.  
  30.     public int getAckPingId() { 
  31.         return ackPingId; 
  32.     } 
  33.  
  34.     public void setAckPingId(int ackPingId) { 
  35.         this.ackPingId = ackPingId; 
  36.     } 
  37.  
  38.     public String getUnused() { 
  39.         return unused; 
  40.     } 
  41.  
  42.     public void setUnused(String unused) { 
  43.         this.unused = unused; 
  44.     } 
  45.  
  46.     /** 
  47.      * 拼接发送数据 
  48.      * 
  49.      * @return 
  50.      */ 
  51.     @Override 
  52.     public byte[] genContentData() { 
  53.         byte[] base = super.genContentData(); 
  54.         byte[] ackPingId = SocketUtil.int2ByteArrays(this.ackPingId); 
  55.         byte[] unused = this.unused.getBytes(); 
  56.  
  57.         ByteArrayOutputStream baos = new ByteArrayOutputStream(getLength()); 
  58.         baos.write(base, 0, base.length);                //协议版本＋数据类型＋数据长度＋消息id 
  59.         baos.write(ackPingId, 0, ACKPINGID_LEN);         //消息id 
  60.         baos.write(unused, 0, unused.length);            //unused 
  61.         return baos.toByteArray(); 
  62.     } 
  63.  
  64.     @Override 
  65.     public int parseContentData(byte[] data) throws ProtocolException { 
  66.         int pos = super.parseContentData(data); 
  67.  
  68.         //解析ackPingId 
  69.         ackPingId = SocketUtil.byteArrayToInt(data, pos, ACKPINGID_LEN); 
  70.         pos += ACKPINGID_LEN; 
  71.  
  72.         //解析unused 
  73.         try { 
  74.             unused = new String(data, pos, data.length - pos, "utf-8"); 
  75.         } catch (UnsupportedEncodingException e) { 
  76.             e.printStackTrace(); 
  77.         } 
  78.  
  79.         return pos; 
  80.     } 
  81.  
  82. }  

三、任务调度

上述已经给出了四种协议的实现，接下来我们将使用它们来实现app和服务端之间的通信，这里我们把数据的发送、接收和心跳分别用一个线程去实现，具体如下：

1. 客户端

  1. import android.os.Handler; 
  2. import android.os.Looper; 
  3. import android.os.Message; 
  4. import android.util.Log; 
  5.  
  6. import com.shandiangou.sdgprotocol.lib.protocol.BasicProtocol; 
  7. import com.shandiangou.sdgprotocol.lib.protocol.DataProtocol; 
  8. import com.shandiangou.sdgprotocol.lib.protocol.PingProtocol; 
  9.  
  10. import java.io.IOException; 
  11. import java.io.InputStream; 
  12. import java.io.OutputStream; 
  13. import java.net.ConnectException; 
  14. import java.net.Socket; 
  15. import java.util.concurrent.ConcurrentLinkedQueue; 
  16.  
  17. import javax.net.SocketFactory; 
  18.  
  19. /** 
  20.  * 写数据采用死循环，没有数据时wait，有新消息时notify 
  21.  * <p> 
  22.  * Created by meishan on 16/12/1. 
  23.  */ 
  24. public class ClientRequestTask implements Runnable { 
  25.  
  26.     private static final int SUCCESS = 100; 
  27.     private static final int FAILED = -1; 
  28.  
  29.     private boolean isLongConnection = true; 
  30.     private Handler mHandler; 
  31.     private SendTask mSendTask; 
  32.     private ReciveTask mReciveTask; 
  33.     private HeartBeatTask mHeartBeatTask; 
  34.     private Socket mSocket; 
  35.  
  36.     private boolean isSocketAvailable; 
  37.     private boolean closeSendTask; 
  38.  
  39.     protected volatile ConcurrentLinkedQueue<BasicProtocol> dataQueue = new ConcurrentLinkedQueue<>(); 
  40.  
  41.     public ClientRequestTask(RequestCallBack requestCallBacks) { 
  42.         mHandler = new MyHandler(requestCallBacks); 
  43.     } 
  44.  
  45.     @Override 
  46.     public void run() { 
  47.         try { 
  48.             try { 
  49.                 mSocket = SocketFactory.getDefault().createSocket(Config.ADDRESS, Config.PORT); 
  50. //                mSocket.setSoTimeout(10); 
  51.             } catch (ConnectException e) { 
  52.                 failedMessage(-1, "服务器连接异常，请检查网络"); 
  53.                 return; 
  54.             } 
  55.  
  56.             isSocketAvailable = true; 
  57.  
  58.             //开启接收线程 
  59.             mReciveTask = new ReciveTask(); 
  60.             mReciveTask.inputStream = mSocket.getInputStream(); 
  61.             mReciveTask.start(); 
  62.  
  63.             //开启发送线程 
  64.             mSendTask = new SendTask(); 
  65.             mSendTask.outputStream = mSocket.getOutputStream(); 
  66.             mSendTask.start(); 
  67.  
  68.             //开启心跳线程 
  69.             if (isLongConnection) { 
  70.                 mHeartBeatTask = new HeartBeatTask(); 
  71.                 mHeartBeatTask.outputStream = mSocket.getOutputStream(); 
  72.                 mHeartBeatTask.start(); 
  73.             } 
  74.         } catch (IOException e) { 
  75.             failedMessage(-1, "网络发生异常，请稍后重试"); 
  76.             e.printStackTrace(); 
  77.         } 
  78.     } 
  79.  
  80.     public void addRequest(DataProtocol data) { 
  81.         dataQueue.add(data); 
  82.         toNotifyAll(dataQueue);//有新增待发送数据，则唤醒发送线程 
  83.     } 
  84.  
  85.     public synchronized void stop() { 
  86.  
  87.         //关闭接收线程 
  88.         closeReciveTask(); 
  89.  
  90.         //关闭发送线程 
  91.         closeSendTask = true; 
  92.         toNotifyAll(dataQueue); 
  93.  
  94.         //关闭心跳线程 
  95.         closeHeartBeatTask(); 
  96.  
  97.         //关闭socket 
  98.         closeSocket(); 
  99.  
  100.         //清除数据 
  101.         clearData(); 
  102.  
  103.         failedMessage(-1, "断开连接"); 
  104.     } 
  105.  
  106.     /** 
  107.      * 关闭接收线程 
  108.      */ 
  109.     private void closeReciveTask() { 
  110.         if (mReciveTask != null) { 
  111.             mReciveTask.interrupt(); 
  112.             mReciveTask.isCancle = true; 
  113.             if (mReciveTask.inputStream != null) { 
  114.                 try { 
  115.                     if (isSocketAvailable && !mSocket.isClosed() && mSocket.isConnected()) { 
  116.                         mSocket.shutdownInput();//解决java.net.SocketException问题，需要先shutdownInput 
  117.                     } 
  118.                 } catch (IOException e) { 
  119.                     e.printStackTrace(); 
  120.                 } 
  121.                 SocketUtil.closeInputStream(mReciveTask.inputStream); 
  122.                 mReciveTask.inputStream = null; 
  123.             } 
  124.             mReciveTask = null; 
  125.         } 
  126.     } 
  127.  
  128.     /** 
  129.      * 关闭发送线程 
  130.      */ 
  131.     private void closeSendTask() { 
  132.         if (mSendTask != null) { 
  133.             mSendTask.isCancle = true; 
  134.             mSendTask.interrupt(); 
  135.             if (mSendTask.outputStream != null) { 
  136.                 synchronized (mSendTask.outputStream) {//防止写数据时停止，写完再停 
  137.                     SocketUtil.closeOutputStream(mSendTask.outputStream); 
  138.                     mSendTask.outputStream = null; 
  139.                 } 
  140.             } 
  141.             mSendTask = null; 
  142.         } 
  143.     } 
  144.  
  145.     /** 
  146.      * 关闭心跳线程 
  147.      */ 
  148.     private void closeHeartBeatTask() { 
  149.         if (mHeartBeatTask != null) { 
  150.             mHeartBeatTask.isCancle = true; 
  151.             if (mHeartBeatTask.outputStream != null) { 
  152.                 SocketUtil.closeOutputStream(mHeartBeatTask.outputStream); 
  153.                 mHeartBeatTask.outputStream = null; 
  154.             } 
  155.             mHeartBeatTask = null; 
  156.         } 
  157.     } 
  158.  
  159.     /** 
  160.      * 关闭socket 
  161.      */ 
  162.     private void closeSocket() { 
  163.         if (mSocket != null) { 
  164.             try { 
  165.                 mSocket.close(); 
  166.                 isSocketAvailable = false; 
  167.             } catch (IOException e) { 
  168.                 e.printStackTrace(); 
  169.             } 
  170.         } 
  171.     } 
  172.  
  173.     /** 
  174.      * 清除数据 
  175.      */ 
  176.     private void clearData() { 
  177.         dataQueue.clear(); 
  178.         isLongConnection = false; 
  179.     } 
  180.  
  181.     private void toWait(Object o) { 
  182.         synchronized (o) { 
  183.             try { 
  184.                 o.wait(); 
  185.             } catch (InterruptedException e) { 
  186.                 e.printStackTrace(); 
  187.             } 
  188.         } 
  189.     } 
  190.  
  191.     /** 
  192.      * notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后 
  193.      * 
  194.      * @param o 
  195.      */ 
  196.     protected void toNotifyAll(Object o) { 
  197.         synchronized (o) { 
  198.             o.notifyAll(); 
  199.         } 
  200.     } 
  201.  
  202.     private void failedMessage(int code, String msg) { 
  203.         Message message = mHandler.obtainMessage(FAILED); 
  204.         message.what = FAILED; 
  205.         message.arg1 = code; 
  206.         message.obj = msg; 
  207.         mHandler.sendMessage(message); 
  208.     } 
  209.  
  210.     private void successMessage(BasicProtocol protocol) { 
  211.         Message message = mHandler.obtainMessage(SUCCESS); 
  212.         message.what = SUCCESS; 
  213.         message.obj = protocol; 
  214.         mHandler.sendMessage(message); 
  215.     } 
  216.  
  217.     private boolean isConnected() { 
  218.         if (mSocket.isClosed() || !mSocket.isConnected()) { 
  219.             ClientRequestTask.this.stop(); 
  220.             return false; 
  221.         } 
  222.         return true; 
  223.     } 
  224.  
  225.     /** 
  226.      * 服务器返回处理，主线程运行 
  227.      */ 
  228.     public class MyHandler extends Handler { 
  229.  
  230.         private RequestCallBack mRequestCallBack; 
  231.  
  232.         public MyHandler(RequestCallBack callBack) { 
  233.             super(Looper.getMainLooper()); 
  234.             this.mRequestCallBack = callBack; 
  235.         } 
  236.  
  237.         @Override 
  238.         public void handleMessage(Message msg) { 
  239.             super.handleMessage(msg); 
  240.             switch (msg.what) { 
  241.                 case SUCCESS: 
  242.                     mRequestCallBack.onSuccess((BasicProtocol) msg.obj); 
  243.                     break; 
  244.                 case FAILED: 
  245.                     mRequestCallBack.onFailed(msg.arg1, (String) msg.obj); 
  246.                     break; 
  247.                 default: 
  248.                     break; 
  249.             } 
  250.         } 
  251.     } 
  252.  
  253.     /** 
  254.      * 数据接收线程 
  255.      */ 
  256.     public class ReciveTask extends Thread { 
  257.  
  258.         private boolean isCancle = false; 
  259.         private InputStream inputStream; 
  260.  
  261.         @Override 
  262.         public void run() { 
  263.             while (!isCancle) { 
  264.                 if (!isConnected()) { 
  265.                     break; 
  266.                 } 
  267.  
  268.                 if (inputStream != null) { 
  269.                     BasicProtocol reciverData = SocketUtil.readFromStream(inputStream); 
  270.                     if (reciverData != null) { 
  271.                         if (reciverData.getProtocolType() == 1 || reciverData.getProtocolType() == 3) { 
  272.                             successMessage(reciverData); 
  273.                         } 
  274.                     } else { 
  275.                         break; 
  276.                     } 
  277.                 } 
  278.             } 
  279.  
  280.             SocketUtil.closeInputStream(inputStream);//循环结束则退出输入流 
  281.         } 
  282.     } 
  283.  
  284.     /** 
  285.      * 数据发送线程 
  286.      * 当没有发送数据时让线程等待 
  287.      */ 
  288.     public class SendTask extends Thread { 
  289.  
  290.         private boolean isCancle = false; 
  291.         private OutputStream outputStream; 
  292.  
  293.         @Override 
  294.         public void run() { 
  295.             while (!isCancle) { 
  296.                 if (!isConnected()) { 
  297.                     break; 
  298.                 } 
  299.  
  300.                 BasicProtocol dataContent = dataQueue.poll(); 
  301.                 if (dataContent == null) { 
  302.                     toWait(dataQueue);//没有发送数据则等待 
  303.                     if (closeSendTask) { 
  304.                         closeSendTask();//notify()调用后，并不是马上就释放对象锁的，所以在此处中断发送线程 
  305.                     } 
  306.                 } else if (outputStream != null) { 
  307.                     synchronized (outputStream) { 
  308.                         SocketUtil.write2Stream(dataContent, outputStream); 
  309.                     } 
  310.                 } 
  311.             } 
  312.  
  313.             SocketUtil.closeOutputStream(outputStream);//循环结束则退出输出流 
  314.         } 
  315.     } 
  316.  
  317.     /** 
  318.      * 心跳实现，频率5秒 
  319.      * Created by meishan on 16/12/1. 
  320.      */ 
  321.     public class HeartBeatTask extends Thread { 
  322.  
  323.         private static final int REPEATTIME = 5000; 
  324.         private boolean isCancle = false; 
  325.         private OutputStream outputStream; 
  326.         private int pingId; 
  327.  
  328.         @Override 
  329.         public void run() { 
  330.             pingId = 1; 
  331.             while (!isCancle) { 
  332.                 if (!isConnected()) { 
  333.                     break; 
  334.                 } 
  335.  
  336.                 try { 
  337.                     mSocket.sendUrgentData(0xFF); 
  338.                 } catch (IOException e) { 
  339.                     isSocketAvailable = false; 
  340.                     ClientRequestTask.this.stop(); 
  341.                     break; 
  342.                 } 
  343.  
  344.                 if (outputStream != null) { 
  345.                     PingProtocol pingProtocol = new PingProtocol(); 
  346.                     pingProtocol.setPingId(pingId); 
  347.                     pingProtocol.setUnused("ping..."); 
  348.                     SocketUtil.write2Stream(pingProtocol, outputStream); 
  349.                     pingId = pingId + 2; 
  350.                 } 
  351.  
  352.                 try { 
  353.                     Thread.sleep(REPEATTIME); 
  354.                 } catch (InterruptedException e) { 
  355.                     e.printStackTrace(); 
  356.                 } 
  357.             } 
  358.  
  359.             SocketUtil.closeOutputStream(outputStream); 
  360.         } 
  361.     } 
  362. }  

其中涉及到的RequestCallBack接口如下：

  1. /** 
  2.  * Created by meishan on 16/12/1. 
  3.  */ 
  4. public interface RequestCallBack { 
  5.  
  6.     void onSuccess(BasicProtocol msg); 
  7.  
  8.     void onFailed(int errorCode, String msg); 
  9. }  

2. 服务端

  1. import java.io.DataInputStream; 
  2. import java.io.DataOutputStream; 
  3. import java.net.Socket; 
  4. import java.util.Iterator; 
  5. import java.util.concurrent.ConcurrentHashMap; 
  6. import java.util.concurrent.ConcurrentLinkedQueue; 
  7.  
  8. /** 
  9.  * Created by meishan on 16/12/1. 
  10.  */ 
  11. public class ServerResponseTask implements Runnable { 
  12.  
  13.     private ReciveTask reciveTask; 
  14.     private SendTask sendTask; 
  15.     private Socket socket; 
  16.     private ResponseCallback tBack; 
  17.  
  18.     private volatile ConcurrentLinkedQueue<BasicProtocol> dataQueue = new ConcurrentLinkedQueue<>(); 
  19.     private static ConcurrentHashMap<String, Socket> onLineClient = new ConcurrentHashMap<>(); 
  20.  
  21.     private String userIP; 
  22.  
  23.     public String getUserIP() { 
  24.         return userIP; 
  25.     } 
  26.  
  27.     public ServerResponseTask(Socket socket, ResponseCallback tBack) { 
  28.         this.socket = socket; 
  29.         this.tBack = tBack; 
  30.         this.userIP = socket.getInetAddress().getHostAddress(); 
  31.         System.out.println("用户IP地址：" + userIP); 
  32.     } 
  33.  
  34.     @Override 
  35.     public void run() { 
  36.         try { 
  37.             //开启接收线程 
  38.             reciveTask = new ReciveTask(); 
  39.             reciveTask.inputStream = new DataInputStream(socket.getInputStream()); 
  40.             reciveTask.start(); 
  41.  
  42.             //开启发送线程 
  43.             sendTask = new SendTask(); 
  44.             sendTask.outputStream = new DataOutputStream(socket.getOutputStream()); 
  45.             sendTask.start(); 
  46.         } catch (Exception e) { 
  47.             e.printStackTrace(); 
  48.         } 
  49.     } 
  50.  
  51.     public void stop() { 
  52.         if (reciveTask != null) { 
  53.             reciveTask.isCancle = true; 
  54.             reciveTask.interrupt(); 
  55.             if (reciveTask.inputStream != null) { 
  56.                 SocketUtil.closeInputStream(reciveTask.inputStream); 
  57.                 reciveTask.inputStream = null; 
  58.             } 
  59.             reciveTask = null; 
  60.         } 
  61.  
  62.         if (sendTask != null) { 
  63.             sendTask.isCancle = true; 
  64.             sendTask.interrupt(); 
  65.             if (sendTask.outputStream != null) { 
  66.                 synchronized (sendTask.outputStream) {//防止写数据时停止，写完再停 
  67.                     sendTask.outputStream = null; 
  68.                 } 
  69.             } 
  70.             sendTask = null; 
  71.         } 
  72.     } 
  73.  
  74.     public void addMessage(BasicProtocol data) { 
  75.         if (!isConnected()) { 
  76.             return; 
  77.         } 
  78.  
  79.         dataQueue.offer(data); 
  80.         toNotifyAll(dataQueue);//有新增待发送数据，则唤醒发送线程 
  81.     } 
  82.  
  83.     public Socket getConnectdClient(String clientID) { 
  84.         return onLineClient.get(clientID); 
  85.     } 
  86.  
  87.     /** 
  88.      * 打印已经链接的客户端 
  89.      */ 
  90.     public static void printAllClient() { 
  91.         if (onLineClient == null) { 
  92.             return; 
  93.         } 
  94.         Iterator<String> inter = onLineClient.keySet().iterator(); 
  95.         while (inter.hasNext()) { 
  96.             System.out.println("client:" + inter.next()); 
  97.         } 
  98.     } 
  99.  
  100.     public void toWaitAll(Object o) { 
  101.         synchronized (o) { 
  102.             try { 
  103.                 o.wait(); 
  104.             } catch (InterruptedException e) { 
  105.                 e.printStackTrace(); 
  106.             } 
  107.         } 
  108.     } 
  109.  
  110.     public void toNotifyAll(Object obj) { 
  111.         synchronized (obj) { 
  112.             obj.notifyAll(); 
  113.         } 
  114.     } 
  115.  
  116.     private boolean isConnected() { 
  117.         if (socket.isClosed() || !socket.isConnected()) { 
  118.             onLineClient.remove(userIP); 
  119.             ServerResponseTask.this.stop(); 
  120.             System.out.println("socket closed..."); 
  121.             return false; 
  122.         } 
  123.         return true; 
  124.     } 
  125.  
  126.     public class ReciveTask extends Thread { 
  127.  
  128.         private DataInputStream inputStream; 
  129.         private boolean isCancle; 
  130.  
  131.         @Override 
  132.         public void run() { 
  133.             while (!isCancle) { 
  134.                 if (!isConnected()) { 
  135.                     isCancle = true; 
  136.                     break; 
  137.                 } 
  138.  
  139.                 BasicProtocol clientData = SocketUtil.readFromStream(inputStream); 
  140.  
  141.                 if (clientData != null) { 
  142.                     if (clientData.getProtocolType() == 0) { 
  143.                         System.out.println("dtype: " + ((DataProtocol) clientData).getDtype() + ", pattion: " + ((DataProtocol) clientData).getPattion() + ", msgId: " + ((DataProtocol) clientData).getMsgId() + ", data: " + ((DataProtocol) clientData).getData()); 
  144.  
  145.                         DataAckProtocol dataAck = new DataAckProtocol(); 
  146.                         dataAck.setUnused("收到消息：" + ((DataProtocol) clientData).getData()); 
  147.                         dataQueue.offer(dataAck); 
  148.                         toNotifyAll(dataQueue); //唤醒发送线程 
  149.  
  150.                         tBack.targetIsOnline(userIP); 
  151.                     } else if (clientData.getProtocolType() == 2) { 
  152.                         System.out.println("pingId: " + ((PingProtocol) clientData).getPingId()); 
  153.  
  154.                         PingAckProtocol pingAck = new PingAckProtocol(); 
  155.                         pingAck.setUnused("收到心跳"); 
  156.                         dataQueue.offer(pingAck); 
  157.                         toNotifyAll(dataQueue); //唤醒发送线程 
  158.  
  159.                         tBack.targetIsOnline(userIP); 
  160.                     } 
  161.                 } else { 
  162.                     System.out.println("client is offline..."); 
  163.                     break; 
  164.                 } 
  165.             } 
  166.  
  167.             SocketUtil.closeInputStream(inputStream); 
  168.         } 
  169.     } 
  170.  
  171.     public class SendTask extends Thread { 
  172.  
  173.         private DataOutputStream outputStream; 
  174.         private boolean isCancle; 
  175.  
  176.         @Override 
  177.         public void run() { 
  178.             while (!isCancle) { 
  179.                 if (!isConnected()) { 
  180.                     isCancle = true; 
  181.                     break; 
  182.                 } 
  183.  
  184.                 BasicProtocol procotol = dataQueue.poll(); 
  185.                 if (procotol == null) { 
  186.                     toWaitAll(dataQueue); 
  187.                 } else if (outputStream != null) { 
  188.                     synchronized (outputStream) { 
  189.                         SocketUtil.write2Stream(procotol, outputStream); 
  190.                     } 
  191.                 } 
  192.             } 
  193.  
  194.             SocketUtil.closeOutputStream(outputStream); 
  195.         } 
  196.     } 

其中涉及到的ResponseCallback接口如下：

  1. /** 
  2.  * Created by meishan on 16/12/1. 
  3.  */ 
  4. public interface ResponseCallback { 
  5.  
  6.     void targetIsOffline(DataProtocol reciveMsg); 
  7.  
  8.     void targetIsOnline(String clientIp); 
  9. }  

上述代码中处理了几种情况下的异常，比如，建立连接后，服务端停止运行，此时客户端的输入流还在阻塞状态，怎么保证客户端不抛出异常，这些处理可以结合SocketUtil类来看。

四、调用封装

1. 客户端

import com.shandiangou.sdgprotocol.lib.protocol.DataProtocol;

  1. import com.shandiangou.sdgprotocol.lib.protocol.DataProtocol; 
  2.  
  3. /** 
  4.  * Created by meishan on 16/12/1. 
  5.  */ 
  6. public class ConnectionClient { 
  7.  
  8.     private boolean isClosed; 
  9.  
  10.     private ClientRequestTask mClientRequestTask; 
  11.  
  12.     public ConnectionClient(RequestCallBack requestCallBack) { 
  13.         mClientRequestTask = new ClientRequestTask(requestCallBack); 
  14.         new Thread(mClientRequestTask).start(); 
  15.     } 
  16.  
  17.     public void addNewRequest(DataProtocol data) { 
  18.         if (mClientRequestTask != null && !isClosed) 
  19.             mClientRequestTask.addRequest(data); 
  20.     } 
  21.  
  22.     public void closeConnect() { 
  23.         isClosed = true; 
  24.         mClientRequestTask.stop(); 
  25.     } 
  26. }  

2. 服务端

  1. import com.shandiangou.sdgprotocol.lib.protocol.DataProtocol; 
  2.  
  3. import java.io.IOException; 
  4. import java.net.ServerSocket; 
  5. import java.net.Socket; 
  6. import java.util.concurrent.ExecutorService; 
  7. import java.util.concurrent.Executors; 
  8.  
  9. /** 
  10.  * Created by meishan on 16/12/1. 
  11.  */ 
  12. public class ConnectionServer { 
  13.  
  14.     private static boolean isStart = true; 
  15.     private static ServerResponseTask serverResponseTask; 
  16.  
  17.     public ConnectionServer() { 
  18.  
  19.     } 
  20.  
  21.     public static void main(String[] args) { 
  22.  
  23.         ServerSocket serverSocket = null; 
  24.         ExecutorService executorService = Executors.newCachedThreadPool(); 
  25.         try { 
  26.             serverSocket = new ServerSocket(Config.PORT); 
  27.             while (isStart) { 
  28.                 Socket socket = serverSocket.accept(); 
  29.                 serverResponseTask = new ServerResponseTask(socket, 
  30.                         new ResponseCallback() { 
  31.  
  32.                             @Override 
  33.                             public void targetIsOffline(DataProtocol reciveMsg) {// 对方不在线 
  34.                                 if (reciveMsg != null) { 
  35.                                     System.out.println(reciveMsg.getData()); 
  36.                                 } 
  37.                             } 
  38.  
  39.                             @Override 
  40.                             public void targetIsOnline(String clientIp) { 
  41.                                 System.out.println(clientIp + " is onLine"); 
  42.                                 System.out.println("-----------------------------------------"); 
  43.                             } 
  44.                         }); 
  45.  
  46.                 if (socket.isConnected()) { 
  47.                     executorService.execute(serverResponseTask); 
  48.                 } 
  49.             } 
  50.  
  51.             serverSocket.close(); 
  52.  
  53.         } catch (IOException e) { 
  54.             e.printStackTrace(); 
  55.         } finally { 
  56.             if (serverSocket != null) { 
  57.                 try { 
  58.                     isStart = false; 
  59.                     serverSocket.close(); 
  60.                     if (serverSocket != null) 
  61.                         serverResponseTask.stop(); 
  62.                 } catch (IOException e) { 
  63.                     e.printStackTrace(); 
  64.                 } 
  65.             } 
  66.         } 
  67.     } 
  68. }  

总结

实现自定义协议的关键在于协议的拼装和解析，上述已给出了关键的代码，如果需要查看完整的代码以及demo，可以下载源码。

注意：先运行服务端demo的main函数，再查看本机的ip地址，然后修改客户端(android)代码中Config.java里面的ip地址，当然，要确保android手机和服务端在同一个局域里面，最后再打开客户端。

posted @ 2018-03-27 09:58  小b菜菜  阅读(294)  评论(0)  编辑  收藏  举报