基于Java Socket的自定义协议,实现Android与服务器的长连接(一)

一、基础知识准备

在正式给大家介绍自定义协议之前,我们先对网络传输和协议解析的相关知识点做一个基本的介绍,尽管这些知识点我们在学校里学过,但难免会有所遗忘,这里先做一个简单的介绍,以便对后文的内容理解更加顺畅。

wkiol1hflu6dkj_3aao1zsneebq652-jpg-wh_651x-s_3817930003

1. 网络七层协议

OSI的7层从上到下分别是:7 应用层、 6 表示层、 5 会话层、 4 传输层、 3 网络层、 2 数据链路层、 1 物理层;其中高层(即7、6、5、4层)定义了应用程序的功能,下面3层(即3、2、1层)主要面向通过网络的端到端的数据流。应用层常见的协议有:HTTP、FTP、SMTP等;常见的传输层有:TCP、UDP。本文主要是基于TCP自定义协议实现客户端与服务端的长连接。

2. Socket

Socket本质是编程接口(API),对TCP/IP的封装,TCP/IP也要提供可供程序员做网络开发所用的接口,这就是Socket编程接口,通常也称作”套接字”。套接字之间的连接过程可以分为三个步骤:客户端请求,服务端回复收到,客户端收到服务端的回复,即三次握手。连接成功时,应用程序两端都会产生一个Socket实例,操作这个实例完成所需的会话。对于一个网络连接来说,套接字是平等的,并没有差别,不因为在服务器端或在客户端而产生不同级别。

3. 位(bit)、字节(byte)

“位(bit)”是电子计算机中最小的数据单位。每一位的状态只能是0或1;“字节(Byte)”由8个二进制位构成(即1byte=8bit),它是存储空间的基本计量单位,它能表示到数值范围为0到255(即2的8次方减1);

4. 算术移位运算(符号位不变,低位补0)

  • 左移运算:1<<2,1的二进制位是1,向左移两位是100,转为十进制数即为4,所以1<<2的运算结果是4;
  • 右移运算:7>>2,7的二进制位是111,向右移两位是1,所以7>>2的运算结果是1 。

5. Java中各类型占字节数

  1. byte      8位,1个字节
  2. boolean   8位,1个字节
  3. char      16位,2个字节
  4. short     16位,2个字节
  5. int       32位,4个字节
  6. float     32位,4个字节
  7. double    64位,8个字节
  8. long      64位,8个字节

6. Java中socket相关函数

  • Socket构造函数
    • Socket(InetAddress address, int port)throws UnknownHostException, IOException
    • Socket(InetAddress address, int port, InetAddress localAddress, int localPort)throws IOException
    • Socket(String host, int port)throws UnknownHostException, IOException
    • Socket(String host, int port, InetAddress localAddress, int localPort)throws IOException
    • 还可以通过以下方式生成socket:

SocketFactory.getDefault().createSocket(String address, String port) throws ConnectException

  • Socket方法
    • getInetAddress(); // 远程服务端的IP地址
    • getPort(); // 远程服务端的端口
    • getLocalAddress(); // 本地客户端的IP地址
    • getLocalPort(); // 本地客户端的端口
    • getInputStream(); // 获得输入流
    • getOutStream(); // 获得输出流
  • Socket状态
    • isClosed(); // 连接是否已关闭,若关闭,返回true;否则返回false
    • isConnect(); // 如果曾经连接过,返回true;否则返回false
    • isBound(); // 如果Socket已经与本地一个端口绑定,返回true;否则返回false
    • 判断Socket的状态是否处于连接中
  1. boolean isConnected = socket.isConnected() && !socket.isClosed(); // 判断当前是否处于连接
  • ServerSocket构造函数
    • ServerSocket()throws IOException
    • ServerSocket(int port)throws IOException
    • ServerSocket(int port, int backlog)throws IOException
    • ServerSocket(int port, int backlog, InetAddress bindAddr)throws IOException
  • 服务端接收客户端的连接请求:
    • Socket socket = serverSocket.accept();

7. Java中常见流操作类

  • 输入流
    • InputStream
      • 抽象类,描述流的输入
    • ByteArrayInputStream
      • 从字节数组读取的输入流
    • BufferedInputStream
      • 缓冲输入流
    • FileInputStream
      • 从文件读入的输入流
    • ObjectInputStream
      • 对象输入流(所读写的对象必须实现Serializable接口)
    • DataInputStream
      • 包含了读取Java标准数据类型的输入流
  • 输出流
    • OutputStream
      • 抽象类,描述流的输入
    • ByteArrayOutputStream
      • 写入字节数组的输出流
    • BufferedOutputStream
      • 缓冲输出流
    • FileOutputStream
      • 写入文件的输出流
    • ObjectOutputStream
      • 对象输出流(所读写的对象必须实现Serializable接口)
    • DataOutputStream
      • 包含了写Java标准数据类型的输出流

二、一个简单的socket连接例子

注:先运行服务端代码的main函数,再运行客户端代码的main函数,即可看到打印连接成功

1. 客户端

  1. import java.net.Socket;
  2. /**
  3.  * Created by meishan on 16/12/1.
  4.  */
  5. public class Client {
  6.     public static void main(String[] args) throws Exception {
  7.         boolean isConnected;
  8.         String host = “127.0.0.1”;
  9.         int port = 1122;
  10.         Socket socket = null;
  11.         try {
  12.             socket = SocketFactory.getDefault().createSocket(host, port);
  13.             isConnected = true;
  14.             System.out.println(“连接成功!”);
  15.         } catch (ConnectException e) {
  16.             isConnected = false;
  17.             e.printStackTrace();
  18.             System.out.println(“连接失败!”);
  19.         }
  20.         if (!isConnected) {
  21.             return;
  22.         }
  23.         Thread.sleep(5000);
  24.         socket.close();
  25.         System.out.println(“断开连接!”);
  26.     }
  27. }

2. 服务端

  1. import java.io.IOException;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. /**
  5.  * Created by meishan on 16/12/1.
  6.  */
  7. public class Server {
  8.     private int port = 1122;
  9.     private ServerSocket serverSocket;
  10.     public Server() throws Exception {
  11.         serverSocket = new ServerSocket(port, 3);//显式设置连接请求队列的长度为3
  12.         System.out.println(“服务器启动!”);
  13.     }
  14.     public void service() {
  15.         while (true) {
  16.             Socket socket = null;
  17.             try {
  18.                 socket = serverSocket.accept();
  19.                 System.out.println(“New connection accepted “ + socket.getInetAddress() + “:” + socket.getPort());
  20.             } catch (IOException e) {
  21.                 e.printStackTrace();
  22.             } finally {
  23.                 if (socket != null) {
  24.                     try {
  25.                         socket.close();
  26.                     } catch (IOException e) {
  27.                         e.printStackTrace();
  28.                     }
  29.                 }
  30.             }
  31.         }
  32.     }
  33.     public static void main(String[] args) throws Exception {
  34.         Server server = new Server();
  35.         Thread.sleep(3000);
  36.         server.service();
  37.     }
  38. }

三、一个简单的自定义协议例子

例子中,数据包的定义:消息对象=包类型+包长度+消息内容

  • 包类型 byte 型
  • 包长度 int 型
  • 消息内容 byte[] 型

1. 客户端

  1. import java.io.DataOutputStream;
  2. import java.io.IOException;
  3. import java.io.OutputStream;
  4. import java.net.Socket;
  5. import java.net.UnknownHostException;
  6. import java.util.Scanner;
  7. /**
  8.  * Created by meishan on 16/12/1.
  9.  */
  10. public class Client {
  11.     public static void main(String[] args) {
  12.         try {
  13.             Socket client = new Socket(“127.0.0.1”, 9091);
  14.             OutputStream out = client.getOutputStream();
  15.             DataOutputStream outs = new DataOutputStream(out);
  16.             while (true) {
  17.                 Scanner scaner = new Scanner(System.in);
  18.                 genProtocol(outs, scaner.next());
  19.             }
  20.         } catch (UnknownHostException e) {
  21.             e.printStackTrace();
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26.     /**
  27.      * 构造协议
  28.      *
  29.      * @param out
  30.      * @param msg
  31.      * @throws IOException
  32.      */
  33.     private static void genProtocol(DataOutputStream out, String msg) throws IOException {
  34.         int type = 1;                          //消息类型
  35.         byte[] bytes = msg.getBytes();         //消息内容
  36.         int totalLen = 1 + 4 + bytes.length;   //消息长度
  37.         out.writeByte(type);                   //写入消息类型
  38.         out.writeInt(totalLen);                //写入消息长度
  39.         out.write(bytes);                      //写入消息内容
  40.         out.flush();
  41.     }
  42. }

2. 服务端

  1. import java.io.DataInputStream;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. /**
  7.  * Created by meishan on 16/12/1.
  8.  */
  9. public class Server {
  10.     public static void main(String[] args) {
  11.         try {
  12.             ServerSocket server = new ServerSocket(9091);
  13.             while (true) {
  14.                 Socket client = server.accept();
  15.                 System.out.println(“客户端” + client.getRemoteSocketAddress() + “连接成功”);
  16.                 parseProtocol(client);
  17.             }
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22.     /**
  23.      * 消息解析
  24.      *
  25.      * @param client
  26.      * @throws IOException
  27.      */
  28.     private static void parseProtocol(Socket client) throws IOException {
  29.         InputStream is = client.getInputStream();
  30.         DataInputStream dis = new DataInputStream(is); //读取Java标准数据类型的输入流
  31.         //协议解析
  32.         while (true) {
  33.             byte type = dis.readByte();               //读取消息类型
  34.             int totalLen = dis.readInt();             //读取消息长度
  35.             byte[] data = new byte[totalLen – 4 – 1]; //定义存放消息内容的字节数组
  36.             dis.readFully(data);                      //读取消息内容
  37.             String msg = new String(data);            //消息内容
  38.             System.out.println(“接收消息类型” + type);
  39.             System.out.println(“接收消息长度” + totalLen);
  40.             System.out.println(“发来的内容是:” + msg);
  41.         }
  42.     }
  43. }

四、总结

本文简单介绍了socket通信和自定义协议的相关知识点,为后续的深入做一些准备工作,下一篇文章《基于Java Socket的自定义协议,实现Android与服务器的长连接(二)》将通过一个实例来详细讲解自定义协议实现长连接通信。

未经允许不得转载:JX BLOG » 基于Java Socket的自定义协议,实现Android与服务器的长连接(一)

赞 (0)

评论 0

评论前必须登录!

登陆 注册