一篇文章带你了解网络编程（总结）

目录

一、概述

二、网络分层

1、网络体系结构

1.1、OSI参考模型

1.2、TCP/IP参考模型

2、网络协议

2.1、IP协议（Internet protocol）

2.2、TCP协议（Transmission Control Protocol）

2.3、UDP协议（User Datagram Protocol）

2.4、HTTP协议（Hypertext Transfer Protocol）

三、Java Socket网络编程

1、概述

2、整体流程

TCP网络程序实例

UDP网络程序实例

实现聊天室

URL实例

一、概述

计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。

网络编程就是编写程序使互联网的两个（或多个）设备之间进行数据传输。

二、网络分层

计算机网络分为网络协议和网络体系结构

1、网络体系结构

通过网络发送数据是一项复杂的操作，必须仔细地协调网络的物理特性以及所发送数据的逻辑特征。通过网络将数据从一台主机发送到另外的主机，这个过程是通过计算机网络通信来完成。

网络通信的不同方面被分解为多个层，层与层之间用接口连接。通信的双方具有相同的层次，层次实现的功能由协议数据单元（PDU）来描述。不同系统中的同一层构成对等层，对等层之间通过对等层协议进行通信，理解批次定义好的规则和约定。每一层表示为物理硬件（即线缆和电流）与所传输信息之间的不同抽象层次。在理论上，每一层只与紧挨其上和其下的层对话。将网络分层，这样就可以修改甚至替换某一层的软件，只要层与层之间的接口保持不变，就不会影响到其他层。

计算机网络体系结构是计算机网络层次和协议的集合，网络体系结构对计算机网络实现的功能，以及网络协议、层次、接口和服务进行了描述，但并不涉及具体的实现。接口是同一节点内相邻层之间交换信息的连接处，/也叫服务访问点（SAP）。

为了促进计算机网络的发展，国际标准化组织ISO在现有网络的基础上，提出了不基于具体机型、操作系统或公司的网络体系结构，称为开放系统互连参考模型，即OSI/RM（Open System Interconnection Reference Model）。

ISO制定的OSI参考模型过于庞大、复杂。与此相对，美国国防部提出了TCP/IP协议栈参考模型，简化了OSI参考模型，由于TCP/IP协议栈的简单，获得了广泛的应用，并成为后续因特网使用的参考模型。

1.1、OSI参考模型

 

OSI模型把网络通信的工作分为7层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。

• 物理层

  物理层处于OSI的最底层，是整个开放系统的基础。物理层涉及通信信道上传输的原始比特流（bits），它的功能主要是为数据端设备提供传送数据的通路以及传输数据。

• 数据链路层

  数据链路层的主要任务是实现计算机网络中相邻节点之间的可靠传输，把原始的、有差错的物理传输线加上数据链路协议以后，构成逻辑上可靠的数据链路。需要完成的功能有链路管理、成帧、差错控制以及流量控制等。其中成帧是对物理层的原始比特流进行界定，数据链路层也能够对帧的丢失进行处理。

• 网络层

  网络层涉及源主机节点到目的主机节点之间可靠的网络传输，它需要完成的功能主要包括路由选择、网络寻址、流量控制、拥塞控制、网络互连等。

• 传输层

  传输层起着承上启下的作用，涉及源端节点到目的端节点之间可靠的信息传输。传输层需要解决跨越网络连接的建立和释放，对底层不可靠的网络，建立连接时需要三次握手，释放连接时需要四次挥手。

• 会话层

  会话层的主要功能是负责应用程序之间建立、维持和中断会话，同时也提供对设备和结点之间的会话控制，协调系统和服务之间的交流，并通过提供单工、半双工和全双工3种不同的通信方式，使系统和服务之间有序地进行通信。

• 表示层

  表示层关心所传输数据信息的格式定义，其主要功能是把应用层提供的信息变换为能够共同理解的形式，提供字符代码、数据格式、控制信息格式、加密等的统一表示。

• 应用层

  应用层为OSI的最高层，是直接为应用进程提供服务的。其作用是在实现多个系统应用进程相互通信的同时，完成一系列业务处理所需的服务。

1.2、TCP/IP参考模型

 

TCP/IP，即Transmission Control Protocol/Internet Protocol的简写，中译名为传输控制协议/因特网互联协议，是Internet最基本的协议，Internet国际互联网络的基础。

TCP/IP协议是一个开放的网络协议簇，它的名字主要取自最重要的网络层IP协议和传输层TCP协议。TCP/IP协议定义了电子设备如何连入因特网，以及数据如何在它们之间传输的标准。TCP/IP参考模型采用4层的层级结构，每一层都呼叫它的下一层所提供的协议来完成自己的需求，这4个层次分别是：网络接口层、网络层（IP层）、传输层（TCP层）、应用层。

• 网络接口层

  TCP/IP协议对网络接口层没有给出具体的描述，网络接口层对应着OSI参考模型的物理层和数据链路层，所以，网络接口层既是传输数据的物理媒介，也可以为网络层提供一条准确无误的线路

• 网络层（IP层）

  网络层是整个TCP/IP协议栈的核心。它的功能是把分组发往目标网络或主机。同时，为了尽快地发送分组，可能需要沿不同的路径同时进行分组传递。因此，分组到达的顺序和发送的顺序可能不同，这就需要上层必须对分组进行排序。网络层除了需要完成路由的功能外，也可以完成将不同类型的网络（异构网）互连的任务。除此之外，互联网层还需要完成拥塞控制的功能。

• 传输层（TCP层）

  TCP层负责在应用进程之间建立端到端的连接和可靠通信，它只存在与端节点中。TCP层涉及两个协议，TCP和UDP。其中，TCP协议提供面向连接的服务，提供按字节流的有序、可靠传输，可以实现连接管理、差错控制、流量控制、拥塞控制等。UDP协议提供无连接的服务，用于不需要或无法实现面向连接的网络应用中。

• 应用层

  应用层为Internet中的各种网络应用提供服务。

2、网络协议

如同人与人之间相互交流是需要遵循一定的规则（如语言）一样，计算机之间能够进行相互通信是因为它们都共同遵守一定的规则，即网络协议。

OSI参考模型和TCP/IP模型在不同的层次中有许多不同的网络协议，如图所示：

网络协议之间的关系图如下：

2.1、IP协议（Internet protocol）

IP协议的作用在于把各种数据包准备无误的传递给对方，其中两个重要的条件是IP地址和MAC地址。由于IP地址是稀有资源，不可能每个人都拥有一个IP地址，所以我们通常的IP地址是路由器给我们生成的IP地址，路由器里面会记录我们的MAC地址。而MAC地址是全球唯一的。举例，IP地址就如同是我们居住小区的地址，而MAC地址就是我们住的那栋楼那个房间那个人。IP地址采用的IPv4格式，目前正在向IPv6过渡。

2.2、TCP协议（Transmission Control Protocol）

TCP（传输控制协议）是面向连接的传输层协议。TCP层是位于IP层之上，应用层之下的中间层。不同主机的应用层之间经常需要可靠的、像管道一样的连接，但是IP层不提供这样的流机制，而是提供不可靠的包交换。TCP协议采用字节流传输数据。

TCP的报文格式

TCP报文段包括协议首部和数据两部分，协议首部的固定部分是20个字节，首部的固定部分后面是选项部分。

下面是报文段首部各个字段的含义：

• 源端口号以及目的端口号

  各占2个字节，端口是传输层和应用层的服务接口，用于寻找发送端和接收端的进程，一般来讲，通过端口号和IP地址，可以唯一确定一个TCP连接，在网络编程中，通常被称为一个socket接口

• 序号

  Seq序号，占4个字节、32位。用来标识从TCP发送端向TCP接收端发送的数据字节流。发起方发送数据时对此进行标记。

• 确认序号

  Ack序号，占4个字节、32位。包含发送确认的一端所期望收到的下一个序号。只有ACK标记位为1时，确认序号字段才有效，因此，确认序号应该是上次已经成功收到数据字节序号加1，即Ack=Seq + 1。

• 数据偏移

  占4个字节，用于指出TCP首部长度，若不存在选项，则这个值为20字节，数据偏移的最大值为60字节。

• 保留

  占6位，为将来定义新的用途保留，现在一般置0。

• 标志位

  • URG(紧急)：为1时表明紧急指针字段有效，为0则忽略紧急指针。

  • ACK(确认)：为1时表明确认号字段有效，为0表示报文中不含确认信息，忽略确认号字段。

  • PSH(推送)：为1时接收方应尽快将这个报文段交给应用层，而不是在缓冲区排队。

  • RST(复位)：为1时表明TCP连接出现故障必须重建连接，用于重置由于主机崩溃或其他原因而出现错误的连接。或者用于拒绝非法的报文段和拒绝连接请求。

  • SYN(同步)：用于建立连接过程，在连接请求中，SYN=1和ACK=0表示该数据段没有使用捎带的确认域，而连接应答捎带一个确认，即SYN=1和ACK=1。

  • FIN(终止)：finish标志，用于释放连接，为1时表明发送端数据发送完毕要求释放连接

• 窗口

  占2个字节，用于流量控制和拥塞控制，表示当前接收缓冲区的大小。在计算机网络中，通常是用接收方的接收能力的大小来控制发送方的数据发送量。TCP连接的一端根据缓冲区大小确定自己的接收窗口值，告诉对方，使对方可以确定发送数据的字节数。

• 校验和

  奇偶校验，此校验和是对整个的 TCP 报文段，包括 TCP 头部和 TCP 数据，以 16 位字进行计算所得。由发送端计算和存储，并由接收端进行验证

• 紧急指针

  只有当 URG 标志置 1 时紧急指针才有效。紧急指针是一个正的偏移量，和顺序号字段中的值相加表示紧急数据最后一个字节的序号。 TCP 的紧急方式是发送端向另一端发送紧急数据的一种方式。

• 选项和填充

  最常见的可选字段是最长报文大小，又称为MSS（Maximum Segment Size），每个连接方通常都在通信的第一个报文段（为建立连接而设置SYN标志为1的那个段）中指明这个选项，它表示本端所能接受的最大报文段的长度。选项长度不一定是32位的整数倍，所以要加填充位，即在这个字段中加入额外的零，以保证TCP头是32的整数倍。

• 数据部分

  TCP 报文段中的数据部分是可选的。在一个连接建立和一个连接终止时，双方交换的报文段仅有 TCP 首部。如果一方没有数据要发送，也使用没有任何数据的首部来确认收到的数据。在处理超时的许多情况中，也会发送不带任何数据的报文段。

三次握手与四次挥手

三次握手

TCP是面向连接的协议，因此每个TCP连接都有3个阶段：连接建立、数据传送和连接释放。连接建立经历三个步骤，通常称为“三次握手”。

1、第一次握手（客户端发送请求）

客户机发送连接请求报文段到服务器，并进入SYN_SENT状态，等待服务器确认。发送连接请求报文段内容：SYN=1，seq=x；SYN=1意思是一个TCP的SYN标志位置为1的包，指明客户端打算连接的服务器的端口；seq=x表示客户端初始序号x，保存在包头的序列号（Sequence Number）字段里。

2、第二次握手（服务端回传确认）

服务器收到客户端连接请求报文，如果同意建立连接，向客户机发回确认报文段（ACK）应答，并为该TCP连接分配TCP缓存和变量。服务器发回确认报文段内容：SYN=1，ACK=1，seq=y，ack=x+1；SYN标志位和ACK标志位均为1，同时将确认序号（Acknowledgement Number）设置为客户的ISN加1，即x+1；seq=y为服务端初始序号y。

3、第三次握手（客户端回传确认）

客户机收到服务器的确认报文段后，向服务器给出确认报文段（ACK），并且也要给该连接分配缓存和变量。此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。客户端发回确认报文段内容：ACK=1，seq=x+1，ack=y+1；ACK=1为确认报文段；seq=x+1为客户端序号加1；ack=y+1,为服务器发来的ACK的初始序号字段+1

注：握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。

四次挥手

由于TCP连接是全双工的，因此每个方向都必须单独进行关闭。这原则是当一方完成它的数据发送任务后就能发送一个FIN来终止这个方向的连接。收到一个FIN只意味着这一方向上没有数据流动，一个TCP连接在收到一个FIN后仍能发送数据。首先进行关闭的一方将执行主动关闭，而另一方执行被动关闭。

1、TCP客户端发送一个FIN，用来关闭客户端到服务端的数据传送，客户端进入FIN_WAIT_1状态。发送报文段内容：FIN=1，seq=u；FIN=1表示请求切断连接；seq=u为客户端请求初始序号。

2、服务端收到这个FIN，它发回一个ACK给客户端，确认序号为收到的序号加1。和SYN一样，一个FIN将占用一个序号；服务端进入CLOSE_WAIT状态。发送报文段内容：ACK=1，seq=v，ack=u+1；ACK=1为确认报文；seq=v为服务器确认初始序号；ack=u+1为客户端初始序号加1。

3、服务器关闭客户端的连接后，发送一个FIN给客户端，服务端进入LAST_ACK状态。发送报文段内容：FIN=1，ACK=1，seq=w，ack=u+1；FIN=1为请求切断连接，ACK=1为确认报文，seq=w为服务端请求切断初始序号。

4、客户端收到FIN后，客户端进入TIME_WAIT状态，接着发回一个ACK报文给服务端确认，并将确认序号设置为收到序号加1，服务端进入CLOSED状态，完成四次挥手。发送报文内容：ACK=1，seq=u+1，ack=w+1；ACK=1为确认报文，seq=u+1为客户端初始序号加1，ack=w+1为服务器初始序号加1。

注：为什么连接的时候是三次握手，关闭的时候却是四次挥手？

因为当服务端收到客户端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当服务端收到FIN报文时，很可能并不会立即关闭socket，所以只能先回复一个ACK报文，告诉客户端，“你发的FIN报文，我收到了”。只有等到服务端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送，故需要四步挥手。

2.3、UDP协议（User Datagram Protocol）

UDP协议由两部分组成：首部和数据。其中，首部仅有8个字节，包括源端口和目的端口、长度（UDP用于数据报的长度）、校验和。

TCP和UDP的区别

1. TCP基于连接，UDP是无连接的；

2. 对系统资源的要求，TCP较多，UDP较少；

3. UDP程序结构较简单；

4. TCP是流模式，而UDP是数据报模式；

5. TCP保证数据正确性，而UDP可能丢包；TCP保证数据顺序，而UDP不保证；

 

2.4、HTTP协议（Hypertext Transfer Protocol）

HTTP，超文本传输协议，它是互联网上应用最为广泛的一种网络协议。HTTP是一种应用层协议，它是基于TCP协议之上的请求/响应式的协议。HTTP协议是Web浏览器和Web服务器之间通信的标准协议。HTTP指定客户端与服务器如何建立连接、客户端如何从服务器请求数据，服务器如何响应请求，以及最后如何关闭连接。HTTP连接使用TCP/IP来传输数据。

对于从客户端到服务器的每一个请求，都有4个步骤：

1. 默认情况下，客户端在端口80打开与服务器的一个TCP连接，URL中还可以指定其他端口。

2. 客户端向服务器发送消息，请求指定路径上的资源。这个资源包括一个首部，可选地（取决于请求的性质）还可以有一个空行，后面是这个请求的数据。

3. 服务器向客户端发送响应。响应以响应码开头，后面是包含数据的首部、一个空行以及所请求的文档或错误消息。

4. 服务器关闭连接。

现在使用的HTTP协议是HTTP/1.1版本，1997年之前采用的是HTTP1.0版本。HTTP连接在1.0版本中采用非持续连接工作方式，1.1版本采用的是持续连接工作方式，持续连接是指服务器在发送响应后仍然在一段时间内保持这条由TCP运输层协议建立起来的连接，使客户端和服务器可以继续在这条连接上传输HTTP报文。

是否采用持续连接工作方式，1.0中默认是关闭的，需要在HTTP头加入“Connection:Keep-Alive”，才能启用Keep-Alive。HTTP1.1中默认启用Keep-Alive，如果加入“Connection:close”，才关闭。目前大部分浏览器都是用HTTP1.1协议，也就是说默认都会发起Keep-Alive的连接请求了，所以是否能完成一个完整的Keep-Alive连接就看服务器设置情况。

HTTP 报文

HTTP协议是基于TCP协议之上的请求/响应式协议，HTTP报文主要有请求报文和响应报文两种。

HTTP请求报文的格式：

SP表示空格，cr lf表示回车和换行

HTTP请求报文由请求行、首部行和实体主体组成，由浏览器发送给服务器。下图是谷歌浏览器内访问服务器查看的HTTP请求例子：

HTTP响应报文格式，由状态行、首部行和实体主体组成：

HTTP响应报文例子：

HTTP请求方法和响应状态码

请求方法：

方法（操作）	含义
OPTION	请求一些选项的信息
GET	请求读取由 URL 所标志的信息
HEAD	请求读取由 URL 所标志的信息的首部
POST	给服务器添加信息
PUT	在指明的 URL 下存储一个文档
DELETE	删除 URL 指明的资源
TRACE	进行环回测试的请求报文
CONNECT	用于代理服务器

状态码：

状态码	含义	例子
1xx	通知信息	请求收到了或者正在处理
2xx	成功	接受或者知道了
3xx	重定向	表示要完成的请求还要采取进一步的动作
4xx	客户差错	请求中有语法错误或不能完成
5xx	服务器差错	服务器失效、无法响应或完成请求

HTTP和HTTPS的区别

HTTPS（全称：Hyper Text Transfer Protocol over Secure Socket Layer），是以安全为目标的HTTP通道，简单来说就是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。它是一个URL scheme（抽象标识符体系），句法类同http:体系，用于安全的HTTP数据传输。https:URL表明它使用了HTTP，但HTTPS存在不同于HTTP的默认端口及一个加密/身份验证层（在HTTP与TCP之间）。

超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息。HTTP协议以明文方式发送内容，不提供任何方式的数据加密，如果攻击者截取了Web浏览器和网站服务器之间的传输报文，就可以直接读懂其中的信息，因此HTTP协议不适合传输一些敏感信息，比如信用开号、密码等。

为了解决HTTP协议的这一缺陷，需要使用另一种协议：安全套接字层超文本传输协议HTTPS。为了数据传输的安全，HTTPS在HTTP的基础上加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密。

HTTPS和HTTP的区别主要为以下四点：

• https协议需要到ca申请证书，一般免费证书很少，需要缴费。

• http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。

• http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

• http的连接很简单，是无状态的；https协议是有ssl+http协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

HTTP和TCP/IP协议的关系

我们在传输数据时，可以只使用（传输层）TCP/IP协议，但是那样的话，如果没有应用层，便无法识别数据内容，如果想要使传输的数据有意义，则必须使用到应用层协议，应用层协议有很多，比如HTTP、FTP、TELNET等，也可以自己定义应用层协议。WEB使用HTTP协议作应用层协议，以封装HTTP文本信息，然后使用TCP/IP做传输层协议将它发到网络上

三、Java Socket网络编程

1、概述

Java的网络编程主要涉及到的内容是Socket编程。Socket，套接字，就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。

应用层通过传输层进行数据通信时，TCP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP/IP协议交互提供了套接字（Socket）接口。应用层可以和传输层通过Socket接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。

Socket，实际上是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议。实际上，Socket跟TCP/IP协议没有必然的关系，Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以说，Socket的出现，只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而形成了我们知道的一些最基本的函数接口，比如create、listen、accept、send、read和write等等。网络有一段关于socket和TCP/IP协议关系的说法比较容易理解：

“TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。这个就像操作系统会提供标准的编程接口，比如win32编程接口一样，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口。”

实际上，传输层的TCP是基于网络层的IP协议的，而应用层的HTTP协议又是基于传输层的TCP协议的，而Socket本身不算是协议，就像上面所说，它只是提供了一个针对TCP或者UDP编程的接口。socket是对端口通信开发的工具,它要更底层一些。

2、整体流程

Socket编程主要涉及到客户端和服务端两个方面，首先是在服务器端创建一个服务器套接字（ServerSocket），并把它附加到一个端口上，服务器从这个端口监听连接。端口号的范围是0到65536，但是0到1024是为特权服务保留的端口号，我们可以选择任意一个当前没有被其他进程使用的端口。

客户端请求与服务器进行连接的时候，根据服务器的域名或者IP地址，加上端口号，打开一个套接字。当服务器接受连接后，服务器和客户端之间的通信就像输入输出流一样进行操作。

实例一：

客户端输入正方形的边长，服务器端接收到后计算面积并返回给客户端

服务器

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServer {
    public static void main(String[] args) throws IOException {
        //端口号
        int port = 7000;
        //在端口上创建一个服务器套接字
        ServerSocket serverSocket = new ServerSocket(port);
        // 监听来自客户端的连接
        Socket accept = serverSocket.accept();
        DataInputStream dis = new DataInputStream(new BufferedInputStream(accept.getInputStream()));
        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(accept.getOutputStream()));

        do{
            double len = dis.readDouble();
            System.out.println("服务器端收到的边长数据为：" + len);
            double res = len * len;
            dos.writeDouble(res);
            dos.flush();
        }while (dis.readInt() != 0);

        accept.close();
        serverSocket.close();
    }
}

客户端

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class SocketClient {
    public static void main(String[] args) throws IOException {
        int port = 7000;
        String host = "localhost";

        // 创建一个套接字并将其连接到指定端口号
        Socket socket = new Socket(host, port);

        DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));

        Scanner scanner = new Scanner(System.in);

        boolean flag = false;

        while (!flag){
            System.out.println("请输入正方形的边长:");
            double len = scanner.nextDouble();

            dos.writeDouble(len);
            dos.flush();

            double area = dis.readDouble();

            System.out.println("服务器返回的计算面积为:" + area);

            while (true){
                System.out.println("继续计算？(Y/N)");
                String str = scanner.next();
                if (str.equalsIgnoreCase("N")){
                    dos.writeInt(0);
                    dos.flush();
                    flag = true;
                    break;
                }else if(str.equalsIgnoreCase("Y")){
                    dos.writeInt(1);
                    dos.flush();
                    break;
                }
            }
        }
        socket.close();
    }
}

实例二：

实例一是服务器端程序和客户端程序是一对一的关系，为了能让一个服务器端程序能同时为多个客户提供服务，可以使用多线程机制，每个客户端的请求都由一个独立的线程进行处理

改写后的服务器端程序：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SocketServer {
    public static void main(String[] args) throws IOException {
        //端口号
        int port = 7000;
        int clientNo = 1;

        ServerSocket serverSocket = new ServerSocket(port);

        // 创建线程池
        ExecutorService service = Executors.newCachedThreadPool();

        try{
            while (true){
                Socket accept = serverSocket.accept();
                service.execute(new SingleServer(accept,clientNo));
                clientNo++;
            }
        }finally {
            serverSocket.close();
        }
    }
}
class SingleServer implements Runnable{

    private Socket socket;
    private int clientNo;

    public SingleServer(Socket socket, int clientNo) {
        this.socket = socket;
        this.clientNo = clientNo;
    }

    @Override
    public void run() {
        try {

            DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
            DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
            do{
                double len = dis.readDouble();
                System.out.println("从客户端" + clientNo + "接收到的边长数据为：" + len);
                double res = len * len;
                dos.writeDouble(res);
                dos.flush();
            }while (dis.readInt() != 0);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            System.out.println("与客户端" + clientNo + "通信结束");
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

改进后的服务器端代码可以支持不断地并发响应网络中的客户请求。关键的地方在于多线程机制的运用，同时利用线程池可以改善服务器程序的性能。

TCP网络程序实例

服务端：

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServer {
    //接收消息
//    public static void main(String[] args) {
//        ServerSocket serverSocket=null;
//        Socket accept=null;
//        InputStream inputStream =null;
//        ByteArrayOutputStream baos = null;
//        try {
//            //建立地址
//            serverSocket = new ServerSocket(9999);
//            //等待连接
//            accept = serverSocket.accept();
//            //读取客户端的消息
//            inputStream = accept.getInputStream();
//
//            /*byte[] bytes = new byte[1024];
//            int len;
//            while ((len = inputStream.read(bytes)) != -1){
//                String msg = new String(bytes,0,len);
//                System.out.println(msg);
//            }*/
//
//            //管道流
//            baos = new ByteArrayOutputStream();
//            byte[] bytes = new byte[1024];
//            int len;
//            while ((len=inputStream.read(bytes))!= -1){
//                baos.write(bytes,0,len);
//            }
//            System.out.println(baos.toString());
//
//        } catch (IOException e) {
//            e.printStackTrace();
//        }finally {
//            //关闭资源
//            if (baos != null){
//                try {
//                    baos.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//
//            if (inputStream != null){
//                try {
//                    inputStream.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//
//            if (accept != null){
//                try {
//                    accept.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//
//            if (serverSocket != null){
//                try {
//                    serverSocket.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//
//        }
//    }

    //接收文件
    public static void main(String[] args) throws Exception {
        //创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //监听连接
        Socket accept = serverSocket.accept();
        //获取输入流
        InputStream inputStream = accept.getInputStream();
        //文件输出
        FileOutputStream fileOutputStream = new FileOutputStream(new File("newfilename"));
        byte[] bytes = new byte[1024];
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }

        //当接收完后通知客户端
        OutputStream outputStream = accept.getOutputStream();
        outputStream.write("已接收，可以断开连接".getBytes());

        //关闭
        fileOutputStream.close();
        inputStream.close();
        accept.close();
        serverSocket.close();
    }
}

客户端：

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClient {
    //消息发送
//    public static void main(String[] args) {
//        Socket socket = null;
//        OutputStream outputStream = null;
//        try {
//            //获取服务器的地址，端口号
//            InetAddress byName = InetAddress.getByName("127.0.0.1");
//            int port = 9999;
//            //建立连接
//            socket = new Socket(byName,port);
//            //发送消息 IO 流
//            outputStream = socket.getOutputStream();
//            outputStream.write("你好！！！".getBytes());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }finally {
//            if (outputStream != null){
//                try {
//                    outputStream.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//            if (socket != null){
//                try {
//                    socket.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }
//    }
    //文件传输
    public static void main(String[] args) throws Exception {
        //创建连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //创建输出
        OutputStream outputStream = socket.getOutputStream();

        //读取文件
        FileInputStream fileInputStream = new FileInputStream(new File("filename"));
        //写出文件
        byte[] bytes = new byte[1024];
        int len;
        while ((len=fileInputStream.read(bytes))!= -1){
            outputStream.write(bytes,0,len);
        }

        //传输完毕
        socket.shutdownOutput();

        //确认服务器接收完毕，才断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int length;
        while ((length=inputStream.read(buffer))!= -1){
            byteArrayOutputStream.write(buffer,0,length);
        }
        System.out.println(byteArrayOutputStream.toString());

        //关闭资源
        fileInputStream.close();
        outputStream.close();
        socket.close();
    }
}

UDP网络程序实例

发送端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
//不需要连接服务器
public class UdpClient {
    public static void main(String[] args) throws Exception {
        //建立Socket
        DatagramSocket datagramSocket = new DatagramSocket();

        //建包
        String msg = "hello,world";

        //接收者
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        //发送
        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
        //发送包
        datagramSocket.send(datagramPacket);

        //关闭
        datagramSocket.close();
    }
}

接受端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
//需要等待发送端连接
public class UdpServer {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket datagramSocket = new DatagramSocket(9090);
        //接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
        datagramSocket.receive(datagramPacket);

        System.out.println(datagramPacket.getAddress().getHostAddress());
        System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));

        //关闭
        datagramSocket.close();
    }
}

实现聊天室

发送端：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class UdpSend implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public UdpSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true){
            try {
                String data  = reader.readLine();
                byte[] datas = data.getBytes();

                DatagramPacket datagramPacket = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));

                socket.send(datagramPacket);

                if (data.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收端：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public UdpReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            socket=new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                //接收
                byte[] container = new byte[1024];
                DatagramPacket datagramPacket = new DatagramPacket(container,0,container.length);
                socket.receive(datagramPacket);//阻塞式接收包裹

                //断开连接
                byte[] data = datagramPacket.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.println(msgFrom + ":" +receiveData);
                if (receiveData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

客户A：

public class ClientA {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new UdpSend(7777,"localhost",9999)).start();
        new Thread(new UdpReceive(8888,"B")).start();
    }
}

客户B：

public class ClientB {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new UdpSend(5555,"localhost",8888)).start();
        new Thread(new UdpReceive(9999,"A")).start();
    }
}

URL实例

URL对象代表统一资源定位器，是指向互联网“资源”的指针。它是用协议名、主机、端口和资源组成，即满足如下格式：

protocol://host:port/resourceName

通过URL对象的一些方法可以访问该URL对应的资源：

 public static void main(String[] args) throws MalformedURLException {
     URL url = new URL("https://baike.baidu.com/item/Java/85979?fr=aladdin");
     System.out.println(url.getProtocol());//协议
     System.out.println(url.getHost());//主机名
     System.out.println(url.getPort());//端口号
     System.out.println(url.getPath());//全路径
     System.out.println(url.getFile());//URL的资源名
     System.out.println(url.getQuery());//参数
 }

网络资源下载：

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class URLDown {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://avatar.csdnimg.cn/2/5/B/1_weixin_44544465_1571274021.jpg");

        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fileOutputStream = new FileOutputStream("01.jpg");

        byte[] b = new byte[1024];
        int len;
        while ((len=inputStream.read(b))!=-1){
            fileOutputStream.write(b,0,len);
        }

        fileOutputStream.close();
        inputStream.close();
        urlConnection.disconnect();
    }
}

参考：https://www.cnblogs.com/swordfall/p/10781281.html