socket的原理和使用

淩亂°似流年 2022-06-11 00:56 255阅读 0赞

前言

  • Socket的使用在 Android网络编程中非常重要
  • 今天我将带大家全面了解 Socket 及 其使用方法 
  1. --------------------

目录

目录

1.网络基础

1.1 计算机网络分层

计算机网络分为五层：物理层、数据链路层、网络层、运输层、应用层

计算机网络

其中：

  • 网络层：负责根据IP找到目的地址的主机
  • 运输层：通过端口把数据传到目的主机的目的进程，来实现进程与进程之间的通信

1.2 端口号（PORT）

端口号规定为16位，即允许一个IP主机有2的16次方65535个不同的端口。其中：

  • 0~1023：分配给系统的端口号 
  1. > 我们不可以乱用

  • 1024~49151：登记端口号，主要是让第三方应用使用

    但是必须在IANA（互联网数字分配机构）按照规定手续登记，

  • 49152~65535：短暂端口号，是留给客户进程选择暂时使用，一个进程使用完就可以供其他进程使用。

在Socket使用时，可以用1024~65535的端口号

1.3 C/S结构

  • 定义：即客户端/服务器结构，是软件系统体系结构
  • 作用：充分利用两端硬件环境的优势，将任务合理分配到Client端和Server端来实现，降低了系统的通讯开销。 
  1. > Socket正是使用这种结构建立连接的，一个套接字接客户端，一个套接字接服务器。

如图： Socket架构
可以看出，Socket的使用可以基于TCP或者UDP协议。

1.4 TCP协议

  • 定义：Transmission Control Protocol，即传输控制协议，是一种传输层通信协议 
  1. > 基于TCP的应用层协议有FTP、Telnet、SMTP、HTTP、POP3与DNS。

  • 特点：面向连接、面向字节流、全双工通信、可靠

    • 面向连接：指的是要使用TCP传输数据，必须先建立TCP连接，传输完成后释放连接，就像打电话一样必须先拨号建立一条连接，打完后挂机释放连接。
    • 全双工通信：即一旦建立了TCP连接，通信双方可以在任何时候都能发送数据。
    • 可靠的：指的是通过TCP连接传送的数据，无差错，不丢失，不重复，并且按序到达。
    • 面向字节流：流，指的是流入到进程或从进程流出的字符序列。简单来说，虽然有时候要传输的数据流太大，TCP报文长度有限制，不能一次传输完，要把它分为好几个数据块，但是由于可靠性保证，接收方可以按顺序接收数据块然后重新组成分块之前的数据流，所以TCP看起来就像直接互相传输字节流一样，面向字节流。
  • TCP建立连接
    必须进行三次握手：若A要与B进行连接，则必须 
  1.  *  第一次握手：建立连接。客户端发送连接请求报文段，将SYN位置为1，Sequence Number为x；然后，客户端进入SYN\_SEND状态，等待服务器的确认。即A发送信息给B
  2.  *  第二次握手：服务器收到客户端的SYN报文段，需要对这个SYN报文段进行确认。即B收到连接信息后向A返回确认信息
  3.  *  第三次握手：客户端收到服务器的（SYN+ACK）报文段，并向服务器发送ACK报文段。即A收到确认信息后再次向B返回确认连接信息  
  6. > 此时，A告诉自己上层连接建立；B收到连接信息后告诉上层连接建立。

TCP三次握手

这样就完成TCP三次握手 = 一条TCP连接建立完成 = 可以开始发送数据

  1. 三次握手期间任何一次未收到对面回复都要重发。
  2. 最后一个确认报文段发送完毕以后，客户端和服务器端都进入ESTABLISHED状态。

为什么TCP建立连接需要三次握手？

答：防止服务器端因为接收了早已失效的连接请求报文从而一直等待客户端请求，从而浪费资源

  • “已失效的连接请求报文段”的产生在这样一种情况下：Client发出的第一个连接请求报文段并没有丢失，而是在某个网络结点长时间的滞留了，以致延误到连接释放以后的某个时间才到达server。
  • 这是一个早已失效的报文段。但Server收到此失效的连接请求报文段后，就误认为是Client再次发出的一个新的连接请求。
  • 于是就向Client发出确认报文段，同意建立连接。
  • 假设不采用“三次握手”：只要Server发出确认，新的连接就建立了。
  • 由于现在Client并没有发出建立连接的请求，因此不会向Server发送数据。
  • 但Server却以为新的运输连接已经建立，并一直等待Client发来数据。>- 这样，Server的资源就白白浪费掉了。

采用“三次握手”的办法可以防止上述现象发生：

  • Client不会向Server的确认发出确认
  • Server由于收不到确认，就知道Client并没有要求建立连接
  • 所以Server不会等待Client发送数据，资源就没有被浪费

  • TCP释放连接
    TCP释放连接需要四次挥手过程，现在假设A主动释放连接：（数据传输结束后，通信的双方都可释放连接）

    • 第一次挥手：A发送释放信息到B；（发出去之后，A->B发送数据这条路径就断了）
    • 第二次挥手：B收到A的释放信息之后，回复确认释放的信息：我同意你的释放连接请求
    • 第三次挥手：B发送“请求释放连接“信息给A

    • 第四次挥手：A收到B发送的信息后向B发送确认释放信息：我同意你的释放连接请求

      B收到确认信息后就会正式关闭连接；
      A等待2MSL后依然没有收到回复，则证明B端已正常关闭，于是A关闭连接

TCp四次握手

为什么TCP释放连接需要四次挥手？

为了保证双方都能通知对方“需要释放连接”，即在释放连接后都无法接收或发送消息给对方

  • 需要明确的是：TCP是全双工模式，这意味着是双向都可以发送、接收的
  • 释放连接的定义是：双方都无法接收或发送消息给对方，是双向的
  • 当主机1发出“释放连接请求”（FIN报文段）时，只是表示主机1已经没有数据要发送 / 数据已经全部发送完毕； 
  1. > 但是，这个时候主机1还是可以接受来自主机2的数据。
  • 当主机2返回“确认释放连接”信息（ACK报文段）时，表示它已经知道主机1没有数据发送了
    但此时主机2还是可以发送数据给主机1
  • 当主机2也发送了FIN报文段时，即告诉主机1我也没有数据要发送了
    此时，主机1和2已经无法进行通信：主机1无法发送数据给主机2，主机2也无法发送数据给主机1，此时，TCP的连接才算释放
1.5 UDP协议

  • 定义：User Datagram Protocol，即用户数据报协议，是一种传输层通信协议。

    基于UDP的应用层协议有TFTP、SNMP与DNS。

  • 特点：无连接的、不可靠的、面向报文、没有拥塞控制

    • 无连接的：和TCP要建立连接不同，UDP传输数据不需要建立连接，就像写信，在信封写上收信人名称、地址就可以交给邮局发送了，至于能不能送到，就要看邮局的送信能力和送信过程的困难程度了。
    • 不可靠的：因为UDP发出去的数据包发出去就不管了，不管它会不会到达，所以很可能会出现丢包现象，使传输的数据出错。
    • 面向报文：数据报文，就相当于一个数据包，应用层交给UDP多大的数据包，UDP就照样发送，不会像TCP那样拆分。
    • 没有拥塞控制：拥塞，是指到达通信子网中某一部分的分组数量过多，使得该部分网络来不及处理，以致引起这部分乃至整个网络性能下降的现象，严重时甚至会导致网络通信业务陷入停顿，即出现死锁现象，就像交通堵塞一样。TCP建立连接后如果发送的数据因为信道质量的原因不能到达目的地，它会不断重发，有可能导致越来越塞，所以需要一个复杂的原理来控制拥塞。而UDP就没有这个烦恼，发出去就不管了。
  • 应用场景
    很多的实时应用（如IP电话、实时视频会议、某些多人同时在线游戏等）要求源主机以很定的速率发送数据，并且允许在网络发生拥塞时候丢失一些数据，但是要求不能有太大的延时，UDP就刚好适合这种要求。所以说，只有不适合的技术，没有真正没用的技术。
1.6 HTTP协议

详情请看我写的另外一篇文章你需要了解的HTTP知识都在这里了！

2. Socket定义

  • 即套接字，是一个对 TCP / IP协议进行封装 的编程调用接口（API）

    1. 即通过Socket，我们才能在Andorid平台上通过 TCP/IP协议进行开发
    2. Socket不是一种协议，而是一个编程调用接口（API），属于传输层（主要解决数据如何在网络中传输）

  • 成对出现，一对套接字：

    Socket ={(IP地址1:PORT端口号)，(IP地址2:PORT端口号)}

  1.    1 
  5.    1

3. 原理

Socket的使用类型主要有两种：

  • 流套接字（streamsocket） ：基于 TCP协议，采用 流的方式 提供可靠的字节流服务
  • 数据报套接字(datagramsocket)：基于 UDP协议，采用 数据报文 提供数据打包发送的服务

具体原理图如下：

原理图

4. Socket 与 Http 对比

  • Socket属于传输层，因为 TCP / IP协议属于传输层，解决的是数据如何在网络中传输的问题
  • HTTP协议 属于 应用层，解决的是如何包装数据

由于二者不属于同一层面，所以本来是没有可比性的。但随着发展，默认的Http里封装了下面几层的使用，所以才会出现Socket & HTTP协议的对比：（主要是工作方式的不同）：

  • Http：采用 请求—响应 方式。

    1. 即建立网络连接后，当 客户端 向 服务器 发送请求后，服务器端才能向客户端返回数据。
    2. 可理解为：是客户端有需要才进行通信

  • Socket：采用 服务器主动发送数据 的方式

    1. 即建立网络连接后，服务器可主动发送消息给客户端，而不需要由客户端向服务器发送请求
    2. 可理解为：是服务器端有需要才进行通信

5. 使用步骤

  • Socket可基于TCP或者UDP协议，但TCP更加常用

  • 所以下面的使用步骤 & 实例的Socket将基于TCP协议

    // 步骤1：创建客户端 & 服务器的连接

    1. // 创建Socket对象 & 指定服务端的IP及端口号 
    2. Socket socket = new Socket("192.168.1.32", 1989);  
    4. // 判断客户端和服务器是否连接成功  
    5. socket.isConnected());
  1. // 步骤2：客户端 & 服务器 通信
  2. // 通信包括：客户端 接收服务器的数据 & 发送数据 到 服务器
  4.     <-- 操作1：接收服务器的数据 -->
  6.             // 步骤1：创建输入流对象InputStream
  7.             InputStream is = socket.getInputStream() 
  9.             // 步骤2：创建输入流读取器对象 并传入输入流对象
  10.             // 该对象作用：获取服务器返回的数据
  11.             InputStreamReader isr = new InputStreamReader(is);
  12.             BufferedReader br = new BufferedReader(isr);
  14.             // 步骤3：通过输入流读取器对象 接收服务器发送过来的数据
  15.             br.readLine()；
  18.     <-- 操作2：发送数据 到 服务器 -->                  
  20.             // 步骤1：从Socket 获得输出流对象OutputStream
  21.             // 该对象作用：发送数据
  22.             OutputStream outputStream = socket.getOutputStream(); 
  24.             // 步骤2：写入需要发送的数据到输出流对象中
  25.             outputStream.write（（"Carson_Ho"+"\n"）.getBytes("utf-8")）；
  26.             // 特别注意：数据的结尾加上换行符才可让服务器端的readline()停止阻塞
  28.             // 步骤3：发送数据到服务端 
  29.             outputStream.flush();  
  32. // 步骤3：断开客户端 & 服务器 连接
  34.              os.close();
  35.             // 断开 客户端发送到服务器 的连接，即关闭输出流对象OutputStream
  37.             br.close();
  38.             // 断开 服务器发送到客户端 的连接，即关闭输入流读取器对象BufferedReader
  40.             socket.close();
  41.             // 最终关闭整个Socket连接
  44.    1 
  45.    2 
  46.    3 
  47.    4 
  48.    5 
  49.    6 
  50.    7 
  51.    8 
  52.    9 
  53.    10 
  54.    11 
  55.    12 
  56.    13 
  57.    14 
  58.    15 
  59.    16 
  60.    17 
  61.    18 
  62.    19 
  63.    20 
  64.    21 
  65.    22 
  66.    23 
  67.    24 
  68.    25 
  69.    26 
  70.    27 
  71.    28 
  72.    29 
  73.    30 
  74.    31 
  75.    32 
  76.    33 
  77.    34 
  78.    35 
  79.    36 
  80.    37 
  81.    38 
  82.    39 
  83.    40 
  84.    41 
  85.    42 
  86.    43 
  87.    44 
  88.    45 
  89.    46 
  90.    47 
  91.    48 
  92.    49 
  93.    50 
  94.    51 
  98.    1 
  99.    2 
  100.    3 
  101.    4 
  102.    5 
  103.    6 
  104.    7 
  105.    8 
  106.    9 
  107.    10 
  108.    11 
  109.    12 
  110.    13 
  111.    14 
  112.    15 
  113.    16 
  114.    17 
  115.    18 
  116.    19 
  117.    20 
  118.    21 
  119.    22 
  120.    23 
  121.    24 
  122.    25 
  123.    26 
  124.    27 
  125.    28 
  126.    29 
  127.    30 
  128.    31 
  129.    32 
  130.    33 
  131.    34 
  132.    35 
  133.    36 
  134.    37 
  135.    38 
  136.    39 
  137.    40 
  138.    41 
  139.    42 
  140.    43 
  141.    44 
  142.    45 
  143.    46 
  144.    47 
  145.    48 
  146.    49 
  147.    50 
  148.    51

6. 具体实例

  • 实例 Demo 代码包括：客户端 & 服务器
  • 本文着重讲解客户端，服务器仅采用最简单的写法进行展示

6.1 客户端 实现

步骤1：加入网络权限

  1. <uses-permission android:name="android.permission.INTERNET" />
  4.    1 
  8.    1

步骤2：主布局界面设置

包括创建Socket连接、客户端 & 服务器通信的按钮

  1. <Button
  2.         android:id="@+id/connect"
  3.         android:layout_width="match_parent"
  4.         android:layout_height="wrap_content"
  5.         android:text="connect" />
  7.     <Button
  8.         android:id="@+id/disconnect"
  9.         android:layout_width="match_parent"
  10.         android:layout_height="wrap_content"
  11.         android:text="disconnect" />
  13.     <TextView
  14.         android:id="@+id/receive_message"
  15.         android:layout_width="match_parent"
  16.         android:layout_height="wrap_content" />
  18.     <Button
  19.         android:id="@+id/Receive"
  20.         android:layout_width="match_parent"
  21.         android:layout_height="wrap_content"
  22.         android:text="Receive from message" />
  24.     <EditText
  25.         android:id="@+id/edit"
  26.         android:layout_width="match_parent"
  27.         android:layout_height="wrap_content" />
  29.     <Button
  30.         android:id="@+id/send"
  31.         android:layout_width="match_parent"
  32.         android:layout_height="wrap_content"
  33.         android:text="send"/>
  37.    1 
  38.    2 
  39.    3 
  40.    4 
  41.    5 
  42.    6 
  43.    7 
  44.    8 
  45.    9 
  46.    10 
  47.    11 
  48.    12 
  49.    13 
  50.    14 
  51.    15 
  52.    16 
  53.    17 
  54.    18 
  55.    19 
  56.    20 
  57.    21 
  58.    22 
  59.    23 
  60.    24 
  61.    25 
  62.    26 
  63.    27 
  64.    28 
  65.    29 
  66.    30 
  67.    31 
  68.    32 
  69.    33 
  70.    34 
  74.    1 
  75.    2 
  76.    3 
  77.    4 
  78.    5 
  79.    6 
  80.    7 
  81.    8 
  82.    9 
  83.    10 
  84.    11 
  85.    12 
  86.    13 
  87.    14 
  88.    15 
  89.    16 
  90.    17 
  91.    18 
  92.    19 
  93.    20 
  94.    21 
  95.    22 
  96.    23 
  97.    24 
  98.    25 
  99.    26 
  100.    27 
  101.    28 
  102.    29 
  103.    30 
  104.    31 
  105.    32 
  106.    33 
  107.    34

步骤3：创建Socket连接、客户端 & 服务器通信

具体请看注释

MainActivity.Java

  1. package scut.carson_ho.socket_carson;
  3. import android.os.Bundle;
  4. import android.os.Handler;
  5. import android.os.Message;
  6. import android.support.v7.app.AppCompatActivity;
  7. import android.view.View;
  8. import android.widget.Button;
  9. import android.widget.EditText;
  10. import android.widget.TextView;
  12. import java.io.BufferedReader;
  13. import java.io.IOException;
  14. import java.io.InputStream;
  15. import java.io.InputStreamReader;
  16. import java.io.OutputStream;
  17. import java.net.Socket;
  18. import java.util.concurrent.ExecutorService;
  19. import java.util.concurrent.Executors;
  21. public class MainActivity extends AppCompatActivity {
  24.     /**
  25.      * 主 变量
  26.      */
  28.     // 主线程Handler
  29.     // 用于将从服务器获取的消息显示出来
  30.     private Handler mMainHandler;
  32.     // Socket变量
  33.     private Socket socket;
  35.     // 线程池
  36.     // 为了方便展示,此处直接采用线程池进行线程管理,而没有一个个开线程
  37.     private ExecutorService mThreadPool;
  39.     /**
  40.      * 接收服务器消息 变量
  41.      */
  42.     // 输入流对象
  43.     InputStream is;
  45.     // 输入流读取器对象
  46.     InputStreamReader isr ;
  47.     BufferedReader br ;
  49.     // 接收服务器发送过来的消息
  50.     String response;
  53.     /**
  54.      * 发送消息到服务器 变量
  55.      */
  56.     // 输出流对象
  57.     OutputStream outputStream;
  59.     /**
  60.      * 按钮 变量
  61.      */
  63.     // 连接 断开连接 发送数据到服务器 的按钮变量
  64.     private Button btnConnect, btnDisconnect, btnSend;
  66.     // 显示接收服务器消息 按钮
  67.     private TextView Receive,receive_message;
  69.     // 输入需要发送的消息 输入框
  70.     private EditText mEdit;
  72.     @Override
  73.     protected void onCreate(Bundle savedInstanceState) {
  74.         super.onCreate(savedInstanceState);
  75.         setContentView(R.layout.activity_main);
  77.         /**
  78.          * 初始化操作
  79.          */
  81.         // 初始化所有按钮
  82.         btnConnect = (Button) findViewById(R.id.connect);
  83.         btnDisconnect = (Button) findViewById(R.id.disconnect);
  84.         btnSend = (Button) findViewById(R.id.send);
  85.         mEdit = (EditText) findViewById(R.id.edit);
  86.         receive_message = (TextView) findViewById(R.id.receive_message);
  87.         Receive = (Button) findViewById(R.id.Receive);
  89.         // 初始化线程池
  90.         mThreadPool = Executors.newCachedThreadPool();
  93.         // 实例化主线程,用于更新接收过来的消息
  94.         mMainHandler = new Handler() {
  95.             @Override
  96.             public void handleMessage(Message msg) {
  97.                 switch (msg.what) {
  98.                     case 0:
  99.                         receive_message.setText(response);
  100.                         break;
  101.                 }
  102.             }
  103.         };
  106.         /**
  107.          * 创建客户端 & 服务器的连接
  108.          */
  109.         btnConnect.setOnClickListener(new View.OnClickListener() {
  110.             @Override
  111.             public void onClick(View v) {
  113.                 // 利用线程池直接开启一个线程 & 执行该线程
  114.                 mThreadPool.execute(new Runnable() {
  115.                     @Override
  116.                     public void run() {
  118.                         try {
  120.                             // 创建Socket对象 & 指定服务端的IP 及 端口号
  121.                             socket = new Socket("192.168.1.172", 8989);
  123.                             // 判断客户端和服务器是否连接成功
  124.                             System.out.println(socket.isConnected());
  126.                         } catch (IOException e) {
  127.                             e.printStackTrace();
  128.                         }
  130.                     }
  131.                 });
  133.             }
  134.         });
  136.         /**
  137.          * 接收 服务器消息
  138.          */
  139.         Receive.setOnClickListener(new View.OnClickListener() {
  140.             @Override
  141.             public void onClick(View v) {
  143.                 // 利用线程池直接开启一个线程 & 执行该线程
  144.                 mThreadPool.execute(new Runnable() {
  145.                     @Override
  146.                     public void run() {
  148.                           try {
  149.                             // 步骤1：创建输入流对象InputStream
  150.                             is = socket.getInputStream();
  152.                               // 步骤2：创建输入流读取器对象 并传入输入流对象
  153.                               // 该对象作用：获取服务器返回的数据
  154.                               isr = new InputStreamReader(is);
  155.                               br = new BufferedReader(isr);
  157.                               // 步骤3：通过输入流读取器对象 接收服务器发送过来的数据
  158.                               response = br.readLine();
  160.                               // 步骤4:通知主线程,将接收的消息显示到界面
  161.                               Message msg = Message.obtain();
  162.                               msg.what = 0;
  163.                               mMainHandler.sendMessage(msg);
  165.                         } catch (IOException e) {
  166.                             e.printStackTrace();
  167.                         }
  169.                     }
  170.                 });
  172.             }
  173.         });
  176.         /**
  177.          * 发送消息 给 服务器
  178.          */
  179.         btnSend.setOnClickListener(new View.OnClickListener() {
  180.             @Override
  181.             public void onClick(View v) {
  183.                 // 利用线程池直接开启一个线程 & 执行该线程
  184.                 mThreadPool.execute(new Runnable() {
  185.                     @Override
  186.                     public void run() {
  188.                         try {
  189.                             // 步骤1：从Socket 获得输出流对象OutputStream
  190.                             // 该对象作用：发送数据
  191.                             outputStream = socket.getOutputStream();
  193.                             // 步骤2：写入需要发送的数据到输出流对象中
  194.                             outputStream.write((mEdit.getText().toString()+"\n").getBytes("utf-8"));
  195.                             // 特别注意：数据的结尾加上换行符才可让服务器端的readline()停止阻塞
  197.                             // 步骤3：发送数据到服务端
  198.                             outputStream.flush();
  200.                         } catch (IOException e) {
  201.                             e.printStackTrace();
  202.                         }
  204.                     }
  205.                 });
  207.             }
  208.         });
  211.         /**
  212.          * 断开客户端 & 服务器的连接
  213.          */
  214.         btnDisconnect.setOnClickListener(new View.OnClickListener() {
  215.             @Override
  216.             public void onClick(View v) {
  218.                 try {
  219.                     // 断开 客户端发送到服务器 的连接，即关闭输出流对象OutputStream
  220.                     outputStream.close();
  222.                     // 断开 服务器发送到客户端 的连接，即关闭输入流读取器对象BufferedReader
  223.                     br.close();
  225.                     // 最终关闭整个Socket连接
  226.                     socket.close();
  228.                     // 判断客户端和服务器是否已经断开连接
  229.                     System.out.println(socket.isConnected());
  231.                 } catch (IOException e) {
  232.                     e.printStackTrace();
  233.                 }
  235.             }
  236.         });
  239.     }
  240. }
  245.    1 
  246.    2 
  247.    3 
  248.    4 
  249.    5 
  250.    6 
  251.    7 
  252.    8 
  253.    9 
  254.    10 
  255.    11 
  256.    12 
  257.    13 
  258.    14 
  259.    15 
  260.    16 
  261.    17 
  262.    18 
  263.    19 
  264.    20 
  265.    21 
  266.    22 
  267.    23 
  268.    24 
  269.    25 
  270.    26 
  271.    27 
  272.    28 
  273.    29 
  274.    30 
  275.    31 
  276.    32 
  277.    33 
  278.    34 
  279.    35 
  280.    36 
  281.    37 
  282.    38 
  283.    39 
  284.    40 
  285.    41 
  286.    42 
  287.    43 
  288.    44 
  289.    45 
  290.    46 
  291.    47 
  292.    48 
  293.    49 
  294.    50 
  295.    51 
  296.    52 
  297.    53 
  298.    54 
  299.    55 
  300.    56 
  301.    57 
  302.    58 
  303.    59 
  304.    60 
  305.    61 
  306.    62 
  307.    63 
  308.    64 
  309.    65 
  310.    66 
  311.    67 
  312.    68 
  313.    69 
  314.    70 
  315.    71 
  316.    72 
  317.    73 
  318.    74 
  319.    75 
  320.    76 
  321.    77 
  322.    78 
  323.    79 
  324.    80 
  325.    81 
  326.    82 
  327.    83 
  328.    84 
  329.    85 
  330.    86 
  331.    87 
  332.    88 
  333.    89 
  334.    90 
  335.    91 
  336.    92 
  337.    93 
  338.    94 
  339.    95 
  340.    96 
  341.    97 
  342.    98 
  343.    99 
  344.    100 
  345.    101 
  346.    102 
  347.    103 
  348.    104 
  349.    105 
  350.    106 
  351.    107 
  352.    108 
  353.    109 
  354.    110 
  355.    111 
  356.    112 
  357.    113 
  358.    114 
  359.    115 
  360.    116 
  361.    117 
  362.    118 
  363.    119 
  364.    120 
  365.    121 
  366.    122 
  367.    123 
  368.    124 
  369.    125 
  370.    126 
  371.    127 
  372.    128 
  373.    129 
  374.    130 
  375.    131 
  376.    132 
  377.    133 
  378.    134 
  379.    135 
  380.    136 
  381.    137 
  382.    138 
  383.    139 
  384.    140 
  385.    141 
  386.    142 
  387.    143 
  388.    144 
  389.    145 
  390.    146 
  391.    147 
  392.    148 
  393.    149 
  394.    150 
  395.    151 
  396.    152 
  397.    153 
  398.    154 
  399.    155 
  400.    156 
  401.    157 
  402.    158 
  403.    159 
  404.    160 
  405.    161 
  406.    162 
  407.    163 
  408.    164 
  409.    165 
  410.    166 
  411.    167 
  412.    168 
  413.    169 
  414.    170 
  415.    171 
  416.    172 
  417.    173 
  418.    174 
  419.    175 
  420.    176 
  421.    177 
  422.    178 
  423.    179 
  424.    180 
  425.    181 
  426.    182 
  427.    183 
  428.    184 
  429.    185 
  430.    186 
  431.    187 
  432.    188 
  433.    189 
  434.    190 
  435.    191 
  436.    192 
  437.    193 
  438.    194 
  439.    195 
  440.    196 
  441.    197 
  442.    198 
  443.    199 
  444.    200 
  445.    201 
  446.    202 
  447.    203 
  448.    204 
  449.    205 
  450.    206 
  451.    207 
  452.    208 
  453.    209 
  454.    210 
  455.    211 
  456.    212 
  457.    213 
  458.    214 
  459.    215 
  460.    216 
  461.    217 
  462.    218 
  463.    219 
  464.    220 
  465.    221 
  466.    222 
  467.    223 
  468.    224 
  469.    225 
  470.    226 
  471.    227 
  472.    228 
  473.    229 
  474.    230 
  475.    231 
  476.    232 
  477.    233 
  478.    234 
  479.    235 
  480.    236 
  481.    237 
  482.    238 
  483.    239 
  484.    240 
  485.    241 
  489.    1 
  490.    2 
  491.    3 
  492.    4 
  493.    5 
  494.    6 
  495.    7 
  496.    8 
  497.    9 
  498.    10 
  499.    11 
  500.    12 
  501.    13 
  502.    14 
  503.    15 
  504.    16 
  505.    17 
  506.    18 
  507.    19 
  508.    20 
  509.    21 
  510.    22 
  511.    23 
  512.    24 
  513.    25 
  514.    26 
  515.    27 
  516.    28 
  517.    29 
  518.    30 
  519.    31 
  520.    32 
  521.    33 
  522.    34 
  523.    35 
  524.    36 
  525.    37 
  526.    38 
  527.    39 
  528.    40 
  529.    41 
  530.    42 
  531.    43 
  532.    44 
  533.    45 
  534.    46 
  535.    47 
  536.    48 
  537.    49 
  538.    50 
  539.    51 
  540.    52 
  541.    53 
  542.    54 
  543.    55 
  544.    56 
  545.    57 
  546.    58 
  547.    59 
  548.    60 
  549.    61 
  550.    62 
  551.    63 
  552.    64 
  553.    65 
  554.    66 
  555.    67 
  556.    68 
  557.    69 
  558.    70 
  559.    71 
  560.    72 
  561.    73 
  562.    74 
  563.    75 
  564.    76 
  565.    77 
  566.    78 
  567.    79 
  568.    80 
  569.    81 
  570.    82 
  571.    83 
  572.    84 
  573.    85 
  574.    86 
  575.    87 
  576.    88 
  577.    89 
  578.    90 
  579.    91 
  580.    92 
  581.    93 
  582.    94 
  583.    95 
  584.    96 
  585.    97 
  586.    98 
  587.    99 
  588.    100 
  589.    101 
  590.    102 
  591.    103 
  592.    104 
  593.    105 
  594.    106 
  595.    107 
  596.    108 
  597.    109 
  598.    110 
  599.    111 
  600.    112 
  601.    113 
  602.    114 
  603.    115 
  604.    116 
  605.    117 
  606.    118 
  607.    119 
  608.    120 
  609.    121 
  610.    122 
  611.    123 
  612.    124 
  613.    125 
  614.    126 
  615.    127 
  616.    128 
  617.    129 
  618.    130 
  619.    131 
  620.    132 
  621.    133 
  622.    134 
  623.    135 
  624.    136 
  625.    137 
  626.    138 
  627.    139 
  628.    140 
  629.    141 
  630.    142 
  631.    143 
  632.    144 
  633.    145 
  634.    146 
  635.    147 
  636.    148 
  637.    149 
  638.    150 
  639.    151 
  640.    152 
  641.    153 
  642.    154 
  643.    155 
  644.    156 
  645.    157 
  646.    158 
  647.    159 
  648.    160 
  649.    161 
  650.    162 
  651.    163 
  652.    164 
  653.    165 
  654.    166 
  655.    167 
  656.    168 
  657.    169 
  658.    170 
  659.    171 
  660.    172 
  661.    173 
  662.    174 
  663.    175 
  664.    176 
  665.    177 
  666.    178 
  667.    179 
  668.    180 
  669.    181 
  670.    182 
  671.    183 
  672.    184 
  673.    185 
  674.    186 
  675.    187 
  676.    188 
  677.    189 
  678.    190 
  679.    191 
  680.    192 
  681.    193 
  682.    194 
  683.    195 
  684.    196 
  685.    197 
  686.    198 
  687.    199 
  688.    200 
  689.    201 
  690.    202 
  691.    203 
  692.    204 
  693.    205 
  694.    206 
  695.    207 
  696.    208 
  697.    209 
  698.    210 
  699.    211 
  700.    212 
  701.    213 
  702.    214 
  703.    215 
  704.    216 
  705.    217 
  706.    218 
  707.    219 
  708.    220 
  709.    221 
  710.    222 
  711.    223 
  712.    224 
  713.    225 
  714.    226 
  715.    227 
  716.    228 
  717.    229 
  718.    230 
  719.    231 
  720.    232 
  721.    233 
  722.    234 
  723.    235 
  724.    236 
  725.    237 
  726.    238 
  727.    239 
  728.    240 
  729.    241

6.2 服务器 实现

  • 因本文主要讲解客户端，所以服务器仅仅是为了配合客户端展示；
  • 为了简化服务器使用，此处采用Mina框架
  1. 服务器代码请在eclipse平台运行
  2. 按照我的步骤一步步实现就可以无脑运行了

步骤1：导入Mina包

请直接移步到百度网盘：下载链接（密码: q73e）

示意图

步骤2：创建服务器线程
TestHandler.java

  1. package mina;
  2. // 导入包
  4. public class TestHandler extends IoHandlerAdapter {
  7.     @Override
  8.     public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
  9.         System.out.println("exceptionCaught: " + cause);
  10.     }
  12.     @Override
  13.     public void messageReceived(IoSession session, Object message) throws Exception {
  14.         System.out.println("recieve : " + (String) message);
  15.         session.write("hello I am server");
  16.     }
  18.     @Override
  19.     public void messageSent(IoSession session, Object message) throws Exception {
  21.     }
  23.     @Override
  24.     public void sessionClosed(IoSession session) throws Exception {
  25.         System.out.println("sessionClosed");
  26.     }
  28.     @Override
  29.     public void sessionOpened(IoSession session) throws Exception {
  30.         System.out.println("sessionOpen");
  31.     }
  33.     @Override
  34.     public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
  35.     }
  37. }
  41.    1 
  42.    2 
  43.    3 
  44.    4 
  45.    5 
  46.    6 
  47.    7 
  48.    8 
  49.    9 
  50.    10 
  51.    11 
  52.    12 
  53.    13 
  54.    14 
  55.    15 
  56.    16 
  57.    17 
  58.    18 
  59.    19 
  60.    20 
  61.    21 
  62.    22 
  63.    23 
  64.    24 
  65.    25 
  66.    26 
  67.    27 
  68.    28 
  69.    29 
  70.    30 
  71.    31 
  72.    32 
  73.    33 
  74.    34 
  75.    35 
  76.    36 
  77.    37 
  81.    1 
  82.    2 
  83.    3 
  84.    4 
  85.    5 
  86.    6 
  87.    7 
  88.    8 
  89.    9 
  90.    10 
  91.    11 
  92.    12 
  93.    13 
  94.    14 
  95.    15 
  96.    16 
  97.    17 
  98.    18 
  99.    19 
  100.    20 
  101.    21 
  102.    22 
  103.    23 
  104.    24 
  105.    25 
  106.    26 
  107.    27 
  108.    28 
  109.    29 
  110.    30 
  111.    31 
  112.    32 
  113.    33 
  114.    34 
  115.    35 
  116.    36 
  117.    37

步骤3：创建服务器主代码
TestHandler.java

  1. package mina;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  6. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  7. import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
  8. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
  10. public class TestServer {
  11.     public static void main(String[] args) {
  12.         NioSocketAcceptor acceptor = null;
  13.         try {
  14.             acceptor = new NioSocketAcceptor();
  15.             acceptor.setHandler(new TestHandler());
  16.             acceptor.getFilterChain().addLast("mFilter", new ProtocolCodecFilter(new TextLineCodecFactory()));
  17.             acceptor.setReuseAddress(true);
  18.             acceptor.bind(new InetSocketAddress(8989));
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  27.    1 
  28.    2 
  29.    3 
  30.    4 
  31.    5 
  32.    6 
  33.    7 
  34.    8 
  35.    9 
  36.    10 
  37.    11 
  38.    12 
  39.    13 
  40.    14 
  41.    15 
  42.    16 
  43.    17 
  44.    18 
  45.    19 
  46.    20 
  47.    21 
  48.    22 
  49.    23 
  50.    24 
  54.    1 
  55.    2 
  56.    3 
  57.    4 
  58.    5 
  59.    6 
  60.    7 
  61.    8 
  62.    9 
  63.    10 
  64.    11 
  65.    12 
  66.    13 
  67.    14 
  68.    15 
  69.    16 
  70.    17 
  71.    18 
  72.    19 
  73.    20 
  74.    21 
  75.    22 
  76.    23 
  77.    24

至此，客户端 & 服务器的代码均实现完毕。

发表评论

表情：
评论列表 （有 0 条评论，255人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Socket通信原理和实践

    我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ

    约定不等于承诺〃约定不等于承诺〃/ 0 赞/ 64 阅读

    相关 Socket通信原理和实践

    我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ

    浅浅的花香味﹌浅浅的花香味﹌/ 0 赞/ 280 阅读

    相关 Socket基本原理

    网络编程，一切皆Socket 一、一些总结 Http通信，应用层协议，之前看过okhttp的部分源码，主要是五层的拦截器逻辑，最终的通信方式是封装的一个使用o

    迈不过友情╰迈不过友情╰/ 0 赞/ 238 阅读

    相关 Socket通信原理

    对TCP/IP、UDP、Socket编程这些词你不会很陌生吧？随着网络技术的发展，这些词充斥着我们的耳朵。那么我想问： 1.         什么是TCP/IP

    - 日理万妓- 日理万妓/ 0 赞/ 343 阅读

    相关 Socket基本原理

                    一、Socket简介 1、套接字（socket）概念 套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。

    痛定思痛。痛定思痛。/ 0 赞/ 258 阅读