第十二章：网络编程

一、什么是网络编程？

网络编程是指利用计算机网络实现程序之间通信的一种编程方式。在网络编程中，程序需要通过网络协议(如 TCP/IP)来进行通信，以实现不同计算机之间的数据传输。

网络编程的三个基本要素：

• IP地址：定位网络中的某台计算机
• 端口号port：定位计算机上的某个进程（某个应用）
• 通信协议

1.1 IP地址

• IP 地址用于唯一标识网络中的每一台计算机。在 Internet 上，使用 IPv4 或 IPv6 地址来表示 IP地址。通常IPv4 地址格式为xxx.xxx.xxx.xxx，其中每个 xxx 都表示一个 8 位的二进制数(每一个xxx的取值范围是0-255)，组合起来可以表示2~32 个不同的IP 地址。
• IPv4 地址的总数量是4294967296 个，但并不是所有的 Pv4 地址都可以使用。IPv4 地址被分为网络地址和主机地址两部分，前3个字节用于表示网络(省市区)，最后1个字节用于表示主机(家门牌)。而一些IP 地址被保留或者被私有机构使用，不能用于公网的地址分配。另外，一些IP 地址被用作多播地址，仅用于特定的应用场景。因此实际上可供使用的IPv4 地址数量要少于总数量，而且随着 IPv4 地址的逐渐枯竭，IPv6 地址已经开始逐渐普及，IPv6 地址数量更是相当巨大。
• IPv6使用16个字节表示IP地址(128位)，这样就解决了网络地址资源数量不够的问题。IPv6 地址由 8组 16 位十六进制数表示，每组之间用冒号分隔，如:3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
• 本机地址:127.0.0.1，主机名:localhost。
• 192.168.0.0-192.168.255.255为私有地址，属于非注册地址，专门为组织机构内部使用。

1.1.1 域名与DNS

• 域名：IP地址毕竟是数字表示，使用时不好记忆和书写，因此在IP地址的基础上又发展出一种符号化的地址方案，来代替数字型的IP地址。每一个符号化的地址都与特定的IP地址对应。这个与网络上的数字型IP地址相对应的字符型地址，就被称为域名。
  目前域名已经成为互联网品牌、网上商标保护必备的要素之一，除了识别功能外，还有引导、宣传等作用。如：www.baidu.com
• DNS在Internet上域名与IP地址之间是一对一(或者多对一)的，域名虽然便于人们记忆，但机器之间只能互相认识IP地址，它们之间的转换工作称为域名解析，域名解析需要由专门的域名解析服务器来完成，DNS(Domain Name System域名系统)就是进行域名解析的服务器，域名的最终指向是IP。

1.2 端口号port

• 不同的应用程序是通过端口号区分的。
• 端口号使用两个字节（无符号）表示的，它的取值范围是0-65535，而这些计算机端口可分为3大类：

① 公认端口：0-1023，被预先定义的服务通信占用（如：HTTP占用端口80，FTP占用端口21，Telnet占用端口23等）

②注册端口：1024-49151，分配给用户进程或应用程序。（如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等）

③动态/私有端口：49152-65535

• 通常情况下，服务器程序使用固定的端口号来监听客户端的请求，而客户端则使用随机端口连接服务器。
• IP地址和端口号的作用，如图所示: IP地址好比每个人的地址(门牌号)，端口好比是房间号。必须同时指定IP地址和端口号才能够正确的发送数据。

1.3 通信协议

• 通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则。就像两个人想要顺利沟通就必须使用同一种语言一样，如果一个人只懂英语而另外一个人只懂中文，这样就会造成没有共同语言而无法沟通。
• 在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
• 在计算机网络中，常用的协议有 TCP、UDP、HTTP、FTP 等。这些协议规定了数据传输的格式、传输方式和传输顺序等细节。其中，TCP(传输控制协议)是一种可靠的面向连接的协议，它提供数据传输的完整性保证;而 UDP(用户数据报协议)则是一种无连接的协议，传输效率高。在网络编程中，需要选取合适的协议类型来实现数据传输。

1.3.1 OSI参考模型

为了促进计算机网络的发展，国际标准化组织IS0(International 0rganization for Standardization)于1977年成立了一个委员会，在现有网络的基础上，提出了不基于具体机型、操作系统或公司的网络体系结构，称为开放系统互连参考模型，即0SI/RM (0pen System Interconnection Reference Model)。0SI 模型把网络通信的工作分为7层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。0SI七层协议模型如图所示:

1.3.2 TCP/IP参考模型

0SI参考模型的初衷是提供全世界范围的计算机网络都要遵循的统一标准，但是由于存在模型和协议自身的缺陷，迟迟没有成熟的产品推出。TCP/IP协议在实践中不断完善和发展取得成功，作为网络的基础，Internet的语言，可以说没有TCP/IP协议就没有互联网的今天。

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

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

1.3.3 模型区别

OSI参考模型是理论上的，而 TCP/IP 参考模型是实践上的。TCP/IP 参考模型被许多实际的协议(如 IP、TCP、HTTP 等)所支持和实现，而 0SI 参考模型则主要是作为理论框架和标准进行研究和讨论。

OSI参考模型是由国际标准化组织提出的网络通信协议框架，其中分为 7 层，各层之间明确了功能的划分，从物理层到应用层，逐层向上升，每层只对自己下一层提供服务，并依次封装和解封数据。0SI 参考模型是一种理论上的协议框架，用于描述计算机系统间的通信原理和规范。

TCP/IP 参考模型(也称互联网参考模型)是实际应用中最广泛的协议框架。它将网络协议划分为 4 层:网络接口层、网络层、传输层和应用层。TCP/IP 参考模型与 0SI参考模型之间有着相对应的层次结构，但是其中的每一层都是实际存在的协议，而不是纯粹的框架。TCP/IP 参考模型被广泛应用于互联网上，是计算机系统间进行通信的重要基础。

二、网络编程的基础类

2.1 InetAddress类

java.net.InetAddress类用来封装计算机的IP地址和DNS（没有端口信息），它包括一个主机名和一个IP地址，是java对IP地址的高层表示。大多数其他网络类都要用到这个类，包括Socket、ServerSocket、URL、DatagramSocket、DatagramPacket等

常用静态算法

• static InetAddress getLocalHost() 得到本机的InetAddress对象，其中封装了IP地址和主机名
• static Inethddress getByName(String host) 传入目标主机的名字或IP地址得到对应的InetAddress对象，其中封装了IP地址和主机名(底层会自动连接DNS服务器进行域名解析)

常用实例方法

• public String getHostAddress() 获取IP地址
• public String getHostName() 获取主机名

public class InetAddress {
    public static void main(String[] args) throws Exception{
        // 获取本机的IP地址和主机名的封装对象：InetAddress
        java.net.InetAddress ia = java.net.InetAddress.getLocalHost();
        System.out.println(ia);     // LAPTOP-BL8ETUDJ/122.207.146.26

        // 获取本机的IP地址
        String hostAddress = ia.getHostAddress();
        System.out.println("本机IP地址：" + hostAddress); // 本机IP地址：122.207.146.26

        // 获取本机的主机名
        String hostName = ia.getHostName();
        System.out.println("本机的主机名：" + hostName); // 本机的主机名：LAPTOP-BL8ETUDJ

        // 通过域名来获取InetAddress对象
        java.net.InetAddress ia2 = java.net.InetAddress.getByName("www.baidu.com");
        System.out.println(ia2.getHostName()); // www.baidu.com
        System.out.println(ia2.getHostAddress()); // 220.181.111.232        百度服务器的ip
    }
}

2.2 URL类

URL是统一资源定位符，对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。互联网上的每个文件都有一个唯一的URL，它包含的信息指出文件的位置以及浏览器应该怎么处理它。

URL由4部分组成:协议、存放资源的主机域名、端口号、资源文件名。如果未指定该端口号，则使用协议默认的端口。例如HTTP协议的默认端口为80。在浏览器中访问网页时，地址栏显示的地址就是URL。

URL标准格式为:<协议>://<域名或IP>:<端口>/<路径>。其中，<协议>://<域名或IP>是必需的，<端口>/<路径>有时可省略。如:https://www.baidu.com。

为了方便程序员编程，JDK中提供了URL类，该类的全名是java.net.URL，该类封装了大量复杂的涉及从远程站点获取信息的细节，可以使用它的各种方法来对URL对象进行分割、合并等处理。

URL类的构造方法

URL url= new URL("http://127.0.0.1:8080/oa/index.html?name=zhangsan#tip"); 

URL类的常用方法

/**
 * ClassName: URLTest01
 * Description:
 *      URL包括四部分：协议，IP地址，端口号，资源名称
 *      URL是网络中某个资源的地址。某个资源的唯一标识。
 *      通过URL是可以真实的定位到资源的。
 *      在Java中，java类库提供了一个URL类，来提供对URL的支持。
 *
 *      URL类的构造方法
 *          URL url = new URL("url");
 *
 *      URL类的常用方法
 *          url.getXxx();
 */

public class URLTest01 {
    public static void main(String[] args) throws Exception{
        // 创建URL类型的对象
        URL url = new URL("http://www.baidu.com:8888/oa/index.html?name=zhangsan&password=123#tip");    // #锚点
        // name=zhangsan&password=123 浏览器向服务器传送的数据

        // 获取URL中的信息
        String protocol = url.getProtocol();
        System.out.println("协议：" + protocol);

        // 获取资源路径   /oa/index.html
        String path = url.getPath();
        System.out.println("资源路径：" + path);

        // 获取默认端口（HTTP协议的默认端口是80）
        int defaultPort = url.getDefaultPort();
        System.out.println("默认端口：" + defaultPort);

        // 获取当前的端口
        int port = url.getPort();
        System.out.println("当前端口号：" + port);     // 8888

        // 获取URL中的IP地址
        String host = url.getHost();
        System.out.println("主机地址：" + host);     // www.baidu.com

        // 获取URL准备传送的数据
        String query = url.getQuery();
        System.out.println("需要提交给服务器的数据：" + query);

        // 获取锚点
        String ref = url.getRef();
        System.out.println("获取锚点：" + ref);     // tip

        // 获取 资源路径 + 数据
        String file = url.getFile();
        System.out.println("资源路径+数据：" + file);
    }
}

爬虫

使用URL类的openStream() 方法可以打开到此URL的连接并返回一个用于从该连接读入的InputStream， 实现最简单的网络爬虫。

public class URLTest02 {
    public static void main(String[] args) throws Exception{
        URL url = new URL("https://tianqi.qq.com/");
        InputStream inputStream = url.openStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        String s = null;
        while((s = br.readLine()) != null){
            System.out.println(s);
        }

        br.close();
    }
}

三、TCP与UDP协议

Socket套接字概述

① 我们开发的网络应用程序位于应用层，TCP和UDP属于传输层协议，在应用层如何使用传输层的服务呢?在应用层和传输层之间，则是使用套接Socket来进行分离。

② 套接字就像是传输层为应用层开的一个小口，应用程序通过这个小口向远程发送数据，或者接收远程发来的数据。而这个小口以内，也就是数据进入这个口之后，或者数据从这个口出来之前，是不知道也不需要知道的，也不会关心它如作传输，这属于网络其它层次工作。

③ Socket实际是传输层供给应用层的编程接口。Socket就是应用层与传输层之间的桥梁。使用Socket编程可以开发客户机和服务器应用程序，可以在本地网络上进行通信，也可通过Internet在全球范围内通信。

④TCP协议和UDP协议是传输层的两种协议。Socket是传输层供给应用层的编程接口，所以Socket编程就分为TCP编程和UDP编程两类。

TCP协议

① 使用TCP协议，须先建立TCP连接，形成传输数据通道，似于拨打电话

② 传输前，采用"三次握手"方式，属于点对点通信，是面向连接的，效率低

③ 仅支持单播传输，每条TCP传输连接只能有两个端点(客户端、服务端)

④ 两个端点的数据传输，采用的是"字节流"来传输，属于可靠的数据传输

⑤ 传输完毕，需释放已建立的连接，开销大，速度慢，适用于文件传输、邮件等。

UDP协议

① 采用数据报(数据、源、目的)的方式来传输，无需建立连接，类似于发短信。

② 每个数据报的大小限制在64K内，超出64k可以分为多个数据报来发送

③ 发送不管对方是否准备好，接收方即使收到也不确认，因此属于不可靠的。

④ 可以广播发送，也就是属于一对一、一对多和多对一连接的通信协议。

⑤ 发送数据结束时无需释放资源，开销小，速度快，适用于视频会议、直播等

描述	TCP	UDP
是否连接	面向连接	面向非连接
传输可靠性	可靠	不可靠
连接对象个数	一对一	一对一、一对多、多对一
传输方式	面向字节流	面向报文
传输速度	慢	快
应用场景	适用于可靠传输（文件传输、邮件等）	适用于实时应用（视频会议、直播等）

四、基于TCP协议的编程

TCP协议编程概述

① 套接字是一种进程间的数据交换机制，利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。

② 在网络通讯中，第一次主动发起通讯的程序被称作客户端(CIient)，而在第一次通讯中等待连接的程序被称作服务端(Server)。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。

③ 套接字与主机地址和端口号相关联，主机地址就是客户端或服务器程序所在的主机的IP地址，端口地址是指客户端或服务器程序使用的主机的通信端口。在客户端和服务器中，分别创建独立的Socket，并通过Socket的属性，将两个Socket进行连接，这样客户端和服务器通过套接字所建立连接并使用IO流进行通信。

4.1 Socket类概述

① Socket类实现客户端套接字(Client)，套接字是两台机器间通信的端点。

② Socket类构造方法:

public Socket(lnetAddress a,int p)  // 创建套接字并连接到指定IP的指定端口号

③ Socket类实例方法:

public lnetAddress getlnetAddress()     // 返回此套接字连接到的远程IP地址。
public InputStream getInputStream()     // 返回此套接字的输入流(接收网络消息)
public 0utputStream getOutputStream()   // 返回此套接字的输出流(发送网络消息)
public void shutdownlnput()             // 禁用此套接字的输入流
public void shutdown0utput()            // 禁用此套接字的输出流。
public synchronized void close()        // 关闭此套接字(默认会关闭IO流) 

4.2 ServerSocket类概述

① ServerSocket类用于实现服务器套接字(Server服务端)。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果

②ServerSocket构造方法:

public ServerSocket(int port)

③ ServerSocket实例方法:

public Socket accept()                    // 侦听要连接到此套接字并接受它

public InetAddress getlnetAddress()       // 返回此服务器套接字的本地地址

public void close()                       // 关闭此套接字

4.3 TCP单向通讯的实现

① Java语言的基于套接字编程分为服务端编程和客户端编程，其通信模型如图所示

② 服务器端实现步骤:

1.创建ServerSocket对象，绑定并监听端口;

2.通过accept监听客户端的请求;

3.建立连接后，通过输出输入流进行读写操作;

4.调用close()方法关闭资源。

③ 客户端实现步骤:

1.创建Socket对象，指定服务端的地址和端口号

2.建立连接后，通过输入输出流进行读写操作;

3.通过输出输入流获取服务器返回信息;

4.调用close()方法关闭资源。

注意:一定是先启动服务器程序，然后再启动客户端程序，先后循序千万别弄混了!

编码实现单向通信

Client(客户端)

public class Client {
    public static void main(String[] args) {
        Socket clientSocket = null;
        BufferedWriter bw = null;
        try {
            // 创建客户端套接字对象
            // 需要指定服务器的IP地址，和端口号
            InetAddress ia = InetAddress.getLocalHost();        // 本机的ip地址
            int port = 8888;
            clientSocket = new Socket(ia, port);

            // 客户端给服务器端发送消息
            // 客户端是输出流
            bw = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));

            // 发送消息
            /*while(true){
                bw.write("你好，最近身体怎么样啊！");
                bw.write("\n");
                bw.write("你收到消息了吗？");
                // 刷新
                bw.flush();
                // 延迟效果
                Thread.sleep(1000);
            }*/

            Scanner scanner = new Scanner(System.in);
            while(true){
                System.out.print("请输入您要发送的消息：");
                // 从键盘上接收的消息
                String msg = scanner.next();
                // 把消息发送给服务器
                bw.write(msg);
                bw.write("\n");

                // 刷新       缓冲流
                bw.flush();
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

服务器端（Server）

public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket clientSocket = null;
        BufferedReader br = null;
        try {
            // 先启动服务器端，启动服务器端后，这个应用肯定要对应一个端口。
            // 创建服务器端套接字对象
            int port = 8888;
            serverSocket = new ServerSocket(port);

            System.out.println("服务器正在启动，请稍后....");
            System.out.println("服务器启动成功，端口号" + port + "，等待客户端的请求！");
            
            // 开始接收客户端的请求
            clientSocket = serverSocket.accept();

            // 后续代码怎么写一会再说！
            // 服务器端接收消息，所以服务器端应该获取输入流。
            br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            // 开始读
            String s = null;
            while((s = br.readLine()) != null){
                System.out.println(s);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

            // 关闭服务器端套接字
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

五、基于UDP协议的编程

5.1 DatagramSocket类的概述

① DatagramSocket类作为基于UDP协议的Socket, 使用DatagramSocket类可以用于接收和发送数据，同时创建接收端时还需指定端口号。

② DatagramSocket的构造方法:

public DatagramSocket()                // 创建发送端的数据报套接字

public DatagramSocket(int port)        // 创建接收端的数据报套接字，并指定端口号

③ DatagramSocket的实例方法:

public void send(DatagramPacket p)        // 发送数据报

public void receive(DatagramPacket p)     // 接收数据报

public void close()                       // 关闭数据报套接字

④ DatagramPacket类负责把发送的数据打包(打包的数据为byte类型的数组)，并且创建发送端时需指定接收端的IP地址和端口

⑤ DatagramPacket的构造方法:

public DatagramPacket(byte buf[],int offset,int length)    // 创建接收端的数据报

public DatagramPacket (byte buf[], int offset, int length, InetAddress address, int port)
//创建发送端的数据报，并指定接收端的IP地址和端口号。

⑥ DatagramPacket的实例方法:

public synchronized byte[] getData()    // 返回数据报中存储的数据

public synchronized int getLength()    // 获得发送或接收数据报中的长度

编码实现单向通信

发送方

public class Send {
    public static void main(String[] args) throws Exception{
        DatagramSocket ds = new DatagramSocket();

        // 创建包
        byte[] bytes = "动力节点".getBytes();
        DatagramPacket dp = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getLocalHost(), 8888);

        // 发送消息
        ds.send(dp);

        ds.close();
    }
}

接收方

public class Receive {
    public static void main(String[] args) throws Exception{

        DatagramSocket ds = new DatagramSocket(8888);

        byte[] bytes = new byte[64 * 1024];
        // 准备一个包，这个包接收发送方的信息。
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

        // 程序执行到这里，停下来，等待发送方的发送。
        ds.receive(dp);

        // 程序执行到这里说明，已经完全将发送方发送的数据接收到了。
        // 从包中取出来数据。
        String msg = new String(bytes, 0, dp.getLength());
        System.out.println("接收到的发送方发过来的消息：" + msg);

        ds.close();
    }
}

编码实现双向通信

// 客户端：发送一个图片给服务器，接收服务器返回的消息。


// 服务器端：接收客户端发送过来的图片，回复消息给客户端

// 服务器端
public class TwoWayServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket clientSocket = null;
        BufferedInputStream bis = null;     // 用于从客户端读取数据的缓冲输入流（图片数据）
        BufferedOutputStream bos = null;    // 用于将图片数据写入本地文件的缓冲输出流
        BufferedWriter bw = null;           // 用于向客户端发送文本回复的缓冲写入流

        try {
            // 创建服务器套接字对象
            serverSocket = new ServerSocket(8888);
            System.out.println("服务器启动成功，正在接收客户端的请求！");

            // 开始接收客户端的请求   阻塞等待客户端连接
            clientSocket = serverSocket.accept();

            // 读取客户端发送的数据
            bis = new BufferedInputStream(clientSocket.getInputStream());

            // 将数据写入本地文件
            bos = new BufferedOutputStream(new FileOutputStream("./dog01.jpg"));

            // 开始读
            byte[] bytes = new byte[1024];
            int readCount = 0;
            while((readCount = bis.read(bytes)) != -1){
                // 把客户端发送过来的图片，保存到本地服务器中。
                bos.write(bytes, 0, readCount);
            }

            // 刷新，确保所有缓冲数据写入文件
            bos.flush();

            // 服务器接收完图片之后给客户端回个话
            bw = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));

            bw.write("你发的图片我已经收到了，真可爱！\n");

            bw.flush();

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

// 客户端
public class TwoWayClient {
    public static void main(String[] args) {
        Socket clientSocket = null;
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;
        BufferedReader br = null;
        try {
            // 创建客户端套接字对象
            clientSocket = new Socket(InetAddress.getLocalHost(), 8888);

            // 发送一张图片给服务器
            bos = new BufferedOutputStream(clientSocket.getOutputStream());

            // 开始写图片到服务器
            // 一边读一边写（读客户端本地硬盘上的图片）
            bis = new BufferedInputStream(new FileInputStream("D:/Java/JavaMe/Java2025/chapter12/src/com/powernode/javase/net/dog.jpg"));

            byte[] bytes = new byte[1024];
            int readCount = 0;
            while((readCount = bis.read(bytes)) != -1){
                bos.write(bytes, 0, readCount);
            }

            // 刷新
            bos.flush();

            // 关闭输出（输出结束）
            clientSocket.shutdownOutput();

            // 接收服务器响应回来的消息
            // clientSocket.getInputStream()：获取与服务器连接关联的输入流（InputStream），这个输入流用于读取服务器发送过来的数据
            // new InputStreamReader(...)：将字节输入流转换为字符输入流
            // new BufferedReader(...)：包装字符输入流，提供缓冲功能，并且支持readLine()方法，可以一次读取一行文本
            br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String s = null;
            while((s = br.readLine()) != null){
                System.out.println(s);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}