• 在现实网络传输应用中，
  通常使用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 接下来介绍具体实现流程，首先看下面的IServerClass：

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显示运行信息的方法）
  

  图中展现的是：已经启动服务端，
  同时启动两个客户端，
  来回切换客户端进行“聊天”，
  客户端由于服务端的socket传输，
  可以相互收到彼此的信息；