Android网络 | Socket（Eclipse--Java）

• **在现实网络传输应用中，

通常使用TCP、IP或UDP这3种协议实现数据传输。

在传输数据的过程中，
需要通过一个双向的通信连接实现数据的交互。

在这个传输过程中，
通常将这个双向链路的一端称为Socket，
一个Socket通常由一个IP地址和一个端口号来确定。

在整个数据传输过程中，Socket的作用是巨大的。
在Java编程应用中，Socket是Java网络编程的核心。**

Socket基础

• **在网络编程中有两个主要的问题，

一个是如何准确地定位网络上一台或多台主机，
另一个就是找到主机后如何可靠高效地进行数据传输。

在TCP/IP协议中
IP层主要负责网络主机的定位，数据传输的路由，
由IP地址可以唯一地确定Internet上的一台主机。
TCP层则
提供面向应用的可靠（TCP）的
或非可靠（UDP）的数据传输机制，
这是网络编程的主要对象，
一般不需要关心IP 层是如何处理数据的。

目前较为流行的网络编程模型是客户机/服务器（C/S）结构。
即通信双方，一方作为服务器
等待（另一方作为的）客户提出请求并予以响应。
客户则在需要服务时向服务器提出申请。

服务器一般作为守护进程 始终运行，
监听网络端口，
一旦有客户请求，就会启动一个服务进程来响应该客户，
同时自己继续监听服务端口，
使后来的客户也能及时得到服务。**

TCP/IP协议基础

• **TCP/IP是Transmission Control Protocol/Internet Protocol的简写，

中译名为传输控制协议/因特网协议，
又名网络通信协议，
是Internet最基本的协议、Internet国际互联网络的基础，

由网络层的IP协议和
传输层的TCP协议组成。

TCP/IP定义了电子设备如何连入因特网，
以及数据如何在它们之间传输的标准。

TCP/IP协议采用了4层的层级结构，
每一层都呼叫它的下一层所提供的协议来完成自己的需求。

也就是说，
TCP负责发现传输的问题，
一旦发现问题便发出信号要求重新传输，
直到所有数据安全正确地传输到目的地。
而IP的功能是给因特网的每一台电脑规定一个地址。

TCP/IP协议不是TCP和IP这两个协议的合称，
而是指因特网整个TCP/IP协议簇。

从协议分层模型方面来讲，TCP/IP由4个层次组成，
分别是网络接口层、网络层、传输层、应用层。
**

• **其实TCP/IP协议并不完全符合OSI（Open System Interconnect）的7层参考模型，

OSI是传统的开放式系统互连参考模型，
是一种通信协议的7层抽象的参考模型，
其中每一层执行某一特定任务。
该模型的目的是
使各种硬件在相同的层次上相互通信。

这7层是
物理层、数据链路层（网络接口层）、
网络层（网络层）、
传送层（传输层）、
会话层、表示层和应用层（应用层）。
而TCP/IP协议采用了4层的层级结构，
每一层都呼叫它的下一层所提供的网络来完成自己的需求。

由于ARPANET的设计者注重的是网络互联，
允许通信子网（网络接口层）采用已有的或是将来有的各种协议，
所以这个层次中没有提供专门的协议。

实际上，
TCP/IP协议可以通过网络接口层连接到任何网络上，
例如X.25交换网或IEEE802局域网。**

UDP协议

• **UDP是User Datagram Protocol的简称，

是一种无连接的协议，
每个数据报都是一个独立的信息，
包括完整的源地址或目的地址，
它在网络上以任何可能的路径传往目的地，
因此能否到达目的地，
到达目的地的时间以及内容的正确性都是不能被保证的。

在现实网络数据传输过程中，
大多数功能是由TCP协议和UDP协议实现。**

• **（1）TCP协议

面向连接的协议，
在Socket之间进行数据传输之前必然要建立连接，
所以在TCP中需要连接时间。

TCP传输数据大小限制，
一旦连接建立起来，
双方的Socket就可以按统一的格式传输大的数据。
TCP是一个可靠的协议，
它确保接收方完全正确地获取发送方所发送的全部数据。**

• **（2）UDP协议

每个数据报中都给出了完整的地址信息，
因此无需要建立发送方和接收方的连接。

UDP传输数据时是有大小限制的，
每个被传输的数据报必须限定在64KB之内。

UDP是一个不可靠的协议，
发送方所发送的数据报并不一定以相同的次序到达接收方。**

TCP、UDP选择的决定因素

• **（1）TCP在网络通信上有极强的生命力，

例如远程连接（Telnet）和文件传输（FTP）
都需要不定长度的数据被可靠地传输。
但是可靠的传输是要付出代价的，
对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，
因此TCP传输的效率不如UDP高。**

• **（2）UDP 操作简单，而且仅需要较少的监护，

因此通常用于局域网高可靠性的分散系统中Client/Server 应用程序。
例如视频会议系统，
并不要求音频视频数据 绝对的正确，
只要保证连贯性就可以了，
这种情况下显然使用UDP会更合理一些，
因为TCP和UDP都能达到这个保证连贯性的门槛，
但是TCP却要多占用更多的计算机资源，
杀鸡焉用牛刀呢，
所有这种情况不用TCP，用UDP。**

基于Socket的Java网络编程

• **网络上的两个程序通过一个双向的通信连接实现数据的交换，

这个双向链路的一端称为一个Socket。**

• Socket通常用来实现客户方和服务方的连接。
  
• **Socket是TCP/IP协议的一个十分流行的编程方式，

一个Socket由一个IP地址和一个端口号 唯一确定。
但是，
Socket所支持的协议种类也不光TCP/IP一种，
因此两者之间是没有必然联系的。
在Java环境下，
Socket编程主要是指基于TCP/IP协议的网络编程。**

1.Socket通信的过程

• **Server端Listen（监听）某个端口是否有连接请求，

Client端向Server 端发出Connect（连接）请求，
Server端向Client端发回Accept（接收）消息，
一个连接就建立起来了。**

• Server端和Client端都可以通过Send、Write等方法与对方通信。
• **在Java网络编程应用中，

对于一个功能齐全的Socket来说，
其工作过程包含如下所示的基本步骤。
（1）创建ServerSocket和Socket；
（2）打开连接到Socket的输入/输出流；
（3）按照一定的协议对Socket进行读/写操作；
（4）关闭IO流和Socket。**

2.创建Socket

• **在Java网络编程应用中，

包java.net中提供了两个类Socket和ServerSocket，
分别用来表示双向连接的客户端和服务端。
这是两个封装得非常好的类，
其中包含了如下所示的构造方法：**

• Socket(InetAddress address, int port)；
• Socket(InetAddress address, int port, boolean stream)；
• Socket(String host, int prot)；
• Socket(String host, int prot, boolean stream)；
• Socket(SocketImpl impl)；
• Socket(String host, int port, InetAddress localAddr, int localPort)；
• Socket(InetAddress address, int port, InetAddress localAddr, int localPort)；
• ServerSocket(int port)；
• ServerSocket(int port, int backlog)；
• ServerSocket(int port, int backlog, InetAddress bindAddr)
• **在上述构造方法中，

参数address、host和port分别是
双向连接中另一方的IP地址、主机名和端口号，
stream指明Socket是流Socket还是数据报Socket，
localPort表示本地主机的端口号，
localAddr和bindAddr是本地机器的地址（ServerSocket的主机地址），
impl是Socket的父类，
既可以用来创建ServerSocket又可以用来创建Socket。**
例如：

    Socket client = new Socket("127.0.0.1", 80);
    ServerSocket server = new ServerSocket(80);

• **注意：

必须小心地选择端口，
每一个端口提供一种特定的服务，
只有给出正确的端口，才能获得相应的服务。

0～1023 的端口号为系统所保留，
例如
HTTP 服务的端口号为80,
Telnet服务的端口号为21,
FTP服务的端口号为23，
所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。
另外，
在创建Socket时如果发生错误，将产生 IOException，
在程序中必须对之做出处理。
所以在创建 Socket 或ServerSocket时必须捕获或抛出异常。**

TCP编程详解

• **TCP/IP通信协议是一种可靠的网络协议，

能够在通信的两端各建立一个Socket，
从而在通信的两端之间形成网络虚拟链路。

一旦建立了虚拟的网络链路，
两端的程序就可以通过虚拟链路进行通信。

Java语言对TCP网络通信提供了良好的封装，
通过Socket对象代表两端的通信端口，
并通过Socket产生的IO流进行网络通信。

这里先笔记Java应用中TCP编程的基本知识，
为后面的Android编程打下基础。**

使用ServerSocket

在Java程序中，

• **使用

类ServerSocket 接受其他通信实体的连接请求。
对象ServerSocket的功能是监听来自客户端的Socket连接，
如果没有连接则会一直处于等待状态。**

• **在类ServerSocket中包含了如下监听客户端连接请求的方法：

Socket accept()：如果接收到一个客户端Socket的连接请求，
该方法将返回一个与客户端Socket对应的Socket，
否则该方法将一直处于等待状态，线程也被阻塞。**

• **为了创建ServerSocket对象，

ServerSocket类为我们提供了如下构造器：**

- **`ServerSocket(int port)`：

用指定的端口port创建一个ServerSocket，
该端口应该是有一个有效的端口整数值0～65535。**

- **`ServerSocket(int port,int backlog)`：

增加一个用来改变连接队列长度的参数backlog。**

- **`ServerSocket(int port,int backlog,InetAddress localAddr)`：

在机器（服务器、本机等）存在多个IP地址的情况下，
允许通过localAddr这个参数
来指定将ServerSocket绑定到指定的IP地址。**

• **当使用ServerSocket后，

需要使用ServerSocket中的方法close()关闭该ServerSocket。**

• **在通常情况下，

因为服务器不会只接受一个客户端请求，
而是会不断地接受来自客户端的所有请求，
所以可以通过循环来不断地调用ServerSocket中的方法accept()。**

• 例如下面的代码。

    //创建一个ServerSocket，用于监听客户端Socket的连接请求
    ServerSocket ss = new ServerSocket(30000);
    //采用循环不断接受来自客户端的请求
    while (true)
    {
    //每当接受到客户端Socket的请求，服务器端也对应产生一个Socket
    Socket s = ss.accept();
    //下面就可以使用Socket进行通信了
    ...
    }

• **在上述代码中，

创建的ServerSocket没有指定IP地址，
该ServerSocket会绑定到本机默认的IP地址。

在代码中使用30000作为该ServerSocket的端口号，
通常推荐使用10000以上的端口，
主要是为了避免与其他应用程序的通用端口 冲突。**

使用Socket

• **在客户端可以使用Socket的构造器

实现`和指定服务器的连接`，
在Socket中可以使用如下两个构造器：**

- **`Socket(InetAddress/String remoteAddress, int port)`：

创建连接到指定远程主机、远程端口的Socket，
该构造器没有指定本地地址、本地端口，
本地IP地址和端口使用默认值。**

- **`Socket(InetAddress/String remoteAddress, int port, InetAddress localAddr, int localPort)`：

创建连接到指定远程主机、远程端口的Socket，
并指定本地IP地址和本地端口号，
适用于本地主机有多个IP地址的情形。**

• **在使用上述构造器指定远程主机时，

既可使用InetAddress来指定，也可以使用String对象指定，
在Java中通常使用String对象指定远程IP，例如192.168.2.23。
当本地主机只有一个IP地址时，建议使用第一个方法，简单方便。
例如下面的代码：**

    //创建连接到本机、30000端口的Socket
    Socket s = new Socket("127.0.0.1" , 30000);

• **当程序执行上述代码后会连接到指定服务器，

让服务器端的ServerSocket的方法accept()向下执行，
于是服务器端和客户端就产生一对互相连接的Socket。
上述代码连接到“远程主机”的IP地址是127.0.0.1，
此IP地址总是代表本机的IP地址。
这里例程的服务器端、客户端都是在本机运行，
所以Socket连接到远程主机的IP地址使用127.0.0.1。**

• **当客户端、服务器端产生对应的Socket之后，

程序无须再区分服务器端和客户端，
而是通过各自的Socket进行通信。**

• 在Socket中提供如下两个方法获取输入流和输出流：

  • InputStream getInputStream()：

返回该Socket对象 对应的输入流，
让程序通过该输入流从Socket中取出数据。

- `OutputStream getOutputStream()`：

返回该 Socket对象 对应的输出流，
让程序通过该输出流 向Socket中输出数据。

• TCP协议的服务器端例程：

public class Server
{
    public static void main(String[] args)
        throws IOException
    {
        //创建一个ServerSocket，用于监听客户端Socket的连接请求
        ServerSocket myss = new ServerSocket(30001);
        //采用循环不断接受来自客户端的请求
        while (true)
        {
          //每当接受到客户端Socket的请求，服务器端也对应产生一个Socket
          Socket s = myss.accept();
          //将Socket对应的输出流包装成PrintStream
          PrintStream ps = new PrintStream(s.getOutputStream());
          //进行普通IO操作
          ps.println("凌川江雪！");
          ps.println("望川霄云！");
          ps.println("万年太久，只争朝夕！");
          ps.println("人间正道是沧桑！");
          ps.println("穷善其身，达济天下！");
          
          //关闭输出流，关闭Socket
          ps.close();
          s.close();
        }
    }
}

• 上述代码建立了ServerSocket监听，

并且使用Socket获取了输出流，
执行后不会显示任何信息。

• 对应的TCP协议的客户端例程：

public class Client {

    public static void main(String[] args)  throws IOException
    {
        Socket socket = new Socket("127.0.0.1" , 30001);
        //将Socket对应的输入流包装成BufferedReader
        BufferedReader br = new BufferedReader(
          new InputStreamReader(socket.getInputStream()));
        
        //进行普通IO操作         
        StringBuilder response = new StringBuilder();
        String line;
        
        //一行一行地读取并加进stringbuilder
        while((line = br.readLine()) != null){
            response.append(line + "\n");
        }
        
        System.out.println("来自服务器的数据：" + "\n" + response.toString());  
        
        //关闭输入流、Socket
        br.close();
        socket.close();
    }

}

• 上述代码使用Socket建立了与指定IP、指定端口的连接，

并使用Socket获取输入流读取数据，
之后处理一下数据然后打印在工作台。
先运行服务端Class，再运行客户端Class，运行结果：

• 由此可见，

一旦使用ServerSocket和Socket建立网络连接之后，
程序通过网络通信与普通IO并没有太大的区别。
如果先运行上面程序中的Server 类，
将看到服务器一直处于等待状态，
因为服务器使用了死循环来接受来自客户端的请求；
再运行Client类，
将可看到程序输出“来自服务器的数据：...！”，
这表明客户端和服务器端通信成功。

TCP中的多线程

• **刚刚实操的例程中，

Server和Client只是进行了简单的通信操作，
当服务器接收到客户端连接之后，服务器向客户端输出一个字符串，
而客户端也只是读取服务器的字符串后就退出了。**

• **在实际应用中，

客户端可能需要和服务器端保持长时间通信，
即服务器需要不断地读取客户端数据，
并向客户端写入数据，
客户端也需要不断地读取服务器数据，
并向服务器写入数据。**

• **当使用readLine()方法读取数据时，

如果在该方法成功返回之前线程被阻塞，则程序无法继续执行。
所以服务器很有必要为每个Socket 单独启动一条线程，
每条线程 负责与一个客户端进行通信。**

• **另外，

因为客户端读取服务器数据的线程同样会被阻塞，
所以系统应该单独 启动一条线程，
该组线程专门负责读取服务器数据。**

• **假设要开发一个聊天室程序，

在服务器端应该包含多条线程，
其中每个Socket对应一条线程，

该线程负责
读取 Socket 对应输入流的数据
（从客户端发送过来的数据），

并将读到的数据
向每个Socket输出流发送一遍
（将一个客户端 发送的数据 “广播” 给 其他客户端 ）；**

• **因此需要在服务器端使用List来保存所有的Socket。

在具体实现时，
为服务器提供了如下两个类：
创建ServerSocket监听的主类。
处理每个Socket通信的线程类。**

1/4 接下来介绍具体实现流程，首先看下面的IServer Class：

public class IServer
{
    //定义保存所有Socket的ArrayList
    public static ArrayList<Socket> socketList = new ArrayList<Socket>();

    public static void main(String[] args) 
        throws IOException
    {
        ServerSocket ss = new ServerSocket(30000);
        while(true)
        {
            //此行代码会阻塞，将一直等待别人的连接
            Socket s = ss.accept();
            socketList.add(s);
            //每当客户端连接后启动一条ServerThread线程为该客户端服务
            new Thread(new Serverxian(s)).start();
        }
    }
}

** IServer类中，
服务器端（ServerSocket ）只负责接受 客户端Socket的 连接请求，
每当 客户端Socket连接到该 ServerSocket之后，
程序将 客户端对应的Socket（客户Socket的对面一端）加入 socketList集合中 保存，
并为该 Socket启动一条 线程（ Serverxian），
该 线程负责 处理 该Socket所有 的 通信任务。
小结：
IServer类完成的业务是：
1.接收 客户端Socket，
2.保存 对应返回的Socket，
3.启动 处理线程。**

2/4 接着看服务器端线程类文件：

package liao.server;
import java.io.*;
import java.net.*;
import java.util.*;

//负责处理每个线程通信的线程类
public class Serverxian implements Runnable 
{
    //定义当前线程所处理的Socket
    Socket s = null;
    
    //该线程所处理的Socket所对应的输入流读取器
    BufferedReader br = null;
    
    public Serverxian(Socket s)
        throws IOException
    {
        this.s = s;
        //初始化该Socket对应的输入流
        br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    }
    
    public void run()
    {
        try
        {
            String content = null;
            
            //采用循环不断从Socket中读取客户端发送过来的数据
            while ((content = readFromClient()) != null)
            {
                
                //遍历socketList中的每个Socket，
                //将读到的内容向每个Socket发送一次
                for (Socket s : IServer.socketList)
                {
                     //将Socket对应的输出流包装成PrintStream
                    PrintStream ps = new PrintStream(s.getOutputStream());
                    ps.println(content);
                }
            }
        }
        catch (IOException e)
        {
            //e.printStackTrace();
        }
    }
    
    //定义读取客户端数据的方法
    private String readFromClient()
    {
        try
        {
            return br.readLine();    
        }
        //如果捕捉到异常，表明该Socket对应的客户端已经关闭
        catch (IOException e)
        {
            //删除该Socket。
            IServer.socketList.remove(s);
        }
        return null;
    }
}

Serverxian类（服务器端线程类）中，
注意是线程类，继承Runnable，重写run方法
会不断读取客户端数据，

在获取时使用方法readFromClient()来读取客户端数据。
如果读取数据过程中捕获到 IOException异常，
则说明此Socket对应的客户端Socket出现了问题，
程序就会将此Socket从socketList中删除。

当服务器线程读到客户端数据之后会遍历整个socketList集合，
并将该数据向socketList集合中的每个Socket发送一次，
该服务器线程将把从Socket中读到的数据
向socketList中的每个Socket转发一次。

• **上述代码能够不断获取Socket输入流中的内容，

当获取Socket输入流中的内容后，
直接将这些内容打印在控制台。

先运行上面程序中的类IServer，
该类运行后作为本应用的服务器，不会看到任何输出。接着可以运行多个 IClient——相当于启动多个聊天室客户端登录该服务器，此时在任何一个客户端通过键盘输入一些内容后单击“回车”键，将可看到所有客户端（包括自己）都会在控制台收到刚刚输入的内容，这就简单实现了一个聊天室的功能。**

• **运行结果如下动图所示：

[（这个链接是
在Eclipse上，同时运行多个java程序，
用不同的console显示运行信息的方法）](https://blog.csdn.net/dear_alice_moon/article/details/78274538)
图中展现的是：已经启动服务端，
同时启动两个客户端，
来回切换客户端进行“聊天”，
客户端由于服务端的socket传输，
可以相互收到彼此的信息；**