day11【网络编程】

day11【网络编程】

主要内容

• 软件架构CS／BS
• 网络通信三要素
• TCP通信 协议UDP
• Socket套接字
• ServerSocket

教学目标

• 能够辨别UDP和TCP协议特点
• 能够说出TCP协议下两个常用类名称
• 能够编写TCP协议下字符串数据传输程序
• 能够理解TCP协议下文件上传案例
• 能够理解TCP协议下案例2

第一章 网络编程入门

1.1 软件结构

• C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。
  针对于C/S结构的软件，首先我们需要下载一个对应的客户端软件才能够去访问服务器，获取数据。

• B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

针对于B/S结构的软件，我们首先需要在电脑上安装浏览器，通过浏览器去访问服务器获取数据。

两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的相互通信的程序。需要注意的是：我们主要是学习如果基于网络完成编程，而不是学习网络。

网络：它只是一个概念，它需要通过其他的设备（ 网卡、网线、交换机、路由器、光纤、卫星 ），把通信终端的设备连接在一起。然后可以让这些设备之间进行通信交互。把这些中间设备和终端设备之间连接在一起，就组成了一个网络。而不同的设备会具体分工做不同的事情。

1.2 网络通信协议

• 网络通信协议：协议也称为规则。通信协议是计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。
  这就好比在道路中行驶的汽车一定要遵守交通规则一样，如果每个人在驾驶汽车时都不去遵守交通规则，那就一定会出现交通事故。

• TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

上图中，TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能。
链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。
网络层：网络层是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
传输层：主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议
应用层：主要负责应用程序的协议，例如HTTP协议、FTP协议等。

1.3 协议分类

通信的协议还是比较复杂的，java.net 包中包含的类和接口，它们提供低层次的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

java.net 包中提供了两种常见的网络协议的支持：

• UDP：用户数据报（数据报(Datagram):网络传输的基本单位 ）协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
  由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。
  例如公司组织视频会议，即使在开会的过程中出现小的卡顿和小的数据丢失，对会议的整体不会造成太大的影响。在例如听广播时，经常会出现信号不好卡顿，丢失数据等情况。
  但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。

特点:数据被限制在64kb以内，超出这个范围就不能发送了。比如使用QQ发送大量文字，发现会出现拒绝发送的情况，需要注意的是，不是QQ软件拒绝了我们。而是它使用的协议不允许发送这么数据。

• TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即两台终端传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
  在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

  • 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

    • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
    • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
    • 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。

    完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

1.4 网络编程三要素

协议

• 协议：计算机网络通信必须遵守的规则，已经介绍过了，不再赘述。

IP地址

• IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。

IP地址分类

• IPv4：是一个32位的二进制数，通常被分为4个字节，表示成a.b.c.d 的形式，例如192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
• IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。
  为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

常用命令

• 查看本机IP地址，在控制台输入：

  ipconfig

• 检查网络是否连通，在控制台输入：

  ping 空格 IP地址
  ping 220.181.57.216

特殊的IP地址

• 本机IP地址：127.0.0.1、localhost 。 本地回环地址。

端口号

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

• 端口号：用两个字节表示的整数，它的取值范围是0_{65535。其中，0}1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

常用端口号

1、80端口 网络端口：www.baidu.com:80 正确的网址 www.baidu.com:70错误的网址 打不开

2、数据库 端口： mysql：3306 Oracle：1521

3、Tomcat端口：8080

利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

第二章 TCP通信程序

2.1 概述

TCP通信：面向有链接的通信协议。客户端和服务端必须经过3次握手，才能安全通信。

TCP通信能实现两台计算机之间的数据交互，通信的两端要严格区分为客户端（Client）与服务端（Server）。

两端通信时步骤：

1、服务端应该先启动，处在运行状态。并且服务器不会主动请求客户端
2、客户端向服务器发送访问请求，然后建立一个逻辑连接通道。
3、在客户端和服务端的连接通道中有一个IO流对象。
4、客户端和服务端就可以使用连接通道中的IO对象进行读取和写出数据进行交互。
5、因为通信的数据不仅仅只有字符数据，所以连接通道中的IO是字节流对象。

在Java中，提供了两个类用于实现TCP通信程序：

1. 客户端：java.net.Socket 类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
2. 服务端：java.net.ServerSocket 类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。

2.2 Socket类

TCP通信的客户端：向服务端发送链接请求，给服务端发送数据，读取服务端回写的数据。

Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

构造方法

• public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。
  小贴士：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

构造举例，代码如下：

Socket client = new Socket("127.0.0.1", 6666);

成员方法

• public InputStream getInputStream() ： 返回此套接字的输入流。

  • 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
  • 关闭生成的InputStream也将关闭相关的Socket。

• public OutputStream getOutputStream() ： 返回此套接字的输出流。

  • 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
  • 关闭生成的OutputStream也将关闭相关的Socket。

• public void close() ：关闭此套接字。

  • 一旦一个socket被关闭，它不可再使用。
  • 关闭此socket也将关闭相关的InputStream和OutputStream 。

• public void shutdownOutput() ： 禁用此套接字的输出流。

  • 任何先前写出的数据将被发送，随后终止输出流。

• 实现步骤：
  1、创建一个Socket客户端对象，构造方法中指定要访问的服务器的地址和端口号。
  2、使用Socket对象中的getOutputStream()方法获取网络字节输出流对象
  3、使用获取的网络字节输出流对象给服务端发送数据。
  4、使用Socket对象中的getInputStream()方法获取网络字节输入流对象
  5、使用获取的网络字节输入流对象读取服务端回写的数据。
  6、关闭Socket，释放资源 void close() 关闭此套接字。
  特别注意：
  1、客户端和服务端交互的流对象，必须使用Socket对象获取的流。不能使用自己创建的流。
  2、客户端在给服务端发送请求时，如果服务端没有启动则会抛出异常。

客户端代码实现

/*
    TCP通信的客户端：向服务端发送链接请求，给服务端发送数据，读取服务端回写的数据。
    表示客户端的类：
        java.net.Socket。该类实现客户端套接字（也称为“套接字”）。 套接字是两台机器之间通讯的端点。
        套接字：包含了IP地址和端口号的网络单位（就是客户端的电脑）
    构造方法：
        Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。
             String host：服务器主机的名称/服务器的IP地址
             int port：服务器的端口号
    常用方法：
        InputStream getInputStream() 返回此套接字的输入流。
        OutputStream getOutputStream() 返回此套接字的输出流。
        void close() 关闭此套接字。
    实现步骤：
        1、创建一个Socket客户端对象，构造方法中指定要访问的服务器的地址和端口号。
        2、使用Socket对象中的getOutputStream()方法获取网络字节输出流对象
        3、使用获取的网络字节输出流对象给服务端发送数据。
        4、使用Socket对象中的getInputStream()方法获取网络字节输入流对象
        5、使用获取的网络字节输入流对象读取服务端回写的数据。
        6、关闭Socket，释放资源 void close() 关闭此套接字。
    特别注意：
        1、客户端和服务端进行交互的流对象，必须使用Socket对象获取的流。不能使用本地自己创建的流
        2、客户端在给服务端发送请求时，如果服务端没有启动则会抛出异常
 */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        // 1、创建一个Socket客户端对象，构造方法中指定要访问的服务器的地址和端口号。
        Socket socket = new Socket("127.0.0.1",8080);
        // 2、使用Socket对象中的getOutputStream()方法获取网络字节输出流对象
        OutputStream os = socket.getOutputStream();
        // 3、使用获取的网络字节输出流对象给服务端发送数据。
        os.write("服务端我来了！！".getBytes());
        //4、使用Socket对象中的getInputStream()方法获取网络字节输入流对象
        InputStream is = socket.getInputStream();
        int len = 0;
        byte[] bytes = new byte[1024];
        while( (len = is.read(bytes)) != -1 ) {
            System.out.println(new String(bytes,0,len));
        }
        // 6、关闭Socket，释放资源 void close() 关闭此套接字。
        socket.close();
    }
}

2.3 ServerSocket类

TCP通信的服务端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。

构造方法

• public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

构造举例，代码如下：

ServerSocket server = new ServerSocket(6666);

成员方法

• public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

  特别注意：
  服务端必须要明确当前是哪个客户端在请求服务器，所以服务端提供了一个方法：
  Socket accept() 获取访问服务端的客户端对象。
  服务端没有获取流对象的方法，在获取到了客户端对象之后，可以使用获取到的客户端对象获取流对象。
  服务器的实现步骤：
  1、创建服务器ServerSocket对象。指定端口号。
  2、使用服务器对象中的accept()方法获取请求服务器的Socket对象
  3、基于获取的Socket对象使用getInputStream()方法，获取网络输入流对象
  4、使用获取网络输入流对象，读取客户端发送的数据
  5、基于获取的Socket对象使用getOutputStream()方法，获取网络输出流对象
  6、使用获取的网络输出流对象，给客户端回写数据。
  7、服务器一般不关闭。 close() 关闭服务器。

服务端代码实现

/*
    TCP通信的服务端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
    表示服务器的类：
        java.net.ServerSocket：这个类实现了服务器套接字。
    构造方法：
        ServerSocket(int port) 创建绑定到指定端口的服务器套接字。
    特别注意：
        服务端必须要明确当前是哪个客户端在请求服务器，所以服务端提供了一个方法：
            Socket accept() 获取访问服务端的客户端对象。
        服务端没有获取流对象的方法，在获取到了客户端对象之后，可以使用获取到的客户端对象获取流对象。
    服务器的实现步骤：
        1、创建服务器ServerSocket对象。指定端口号。
        2、使用服务器对象中的accept()方法获取请求服务器的Socket对象
        3、基于获取的Socket对象使用getInputStream()方法，获取网络输入流对象
        4、使用获取网络输入流对象，读取客户端发送的数据
        5、基于获取的Socket对象使用getOutputStream()方法，获取网络输出流对象
        6、使用获取的网络输出流对象，给客户端回写数据。
        7、服务器一般不关闭。 close() 关闭服务器。

 */
public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 1、创建服务器ServerSocket对象。指定端口号。
        ServerSocket ss = new ServerSocket(8080);
        //2、使用服务器对象中的accept()方法获取请求服务器的Socket对象
        Socket accept = ss.accept();
        //3、基于获取的Socket对象使用getInputStream()方法，获取网络输入流对象
        InputStream is = accept.getInputStream();
        // 4、使用获取网络输入流对象，读取客户端发送的数据
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        //5、基于获取的Socket对象使用getOutputStream()方法，获取网络输出流对象
        OutputStream os = accept.getOutputStream();
        // 6、使用获取的网络输出流对象，给客户端回写数据。
        os.write("数据已经收到".getBytes());
        //7、服务器一般不关闭。 close() 关闭服务器。
        ss.close();
        accept.close();
    }
}

2.4 简单的TCP网络程序

TCP通信分析图解

1. 【服务端】启动,创建ServerSocket对象，等待连接。
2. 【客户端】启动,创建Socket对象，请求连接。
3. 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
5. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。

到此，客户端向服务端发送数据成功。

自此，服务端向客户端回写数据。

1. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
2. 【客户端】Scoket对象，获取InputStream，解析回写数据。
3. 【客户端】释放资源，断开连接。

第三章 综合案例

3.1 文件上传案例

文件上传分析图解

1. 【客户端】输入流，从硬盘读取文件数据到程序中。
2. 【客户端】输出流，写出文件数据到服务端。
3. 【服务端】输入流，读取文件数据到服务端程序。
4. 【服务端】输出流，写出文件数据到服务器硬盘中。

基本实现步骤

客户端文件上传步骤：
    1、客户端使用本地字节输入流从文件中读取需要上传的文件
    2、客户端获取网络字节流输出流，将读取到的上传文件写到服务器
    3、服务器使用accept()方法获取请求的客户端对象Socket
    4、服务器基于获取的Socket对象获取网络字节输入流对象
    5、服务端使用获取的网络输入流对象读取客户端发送的文件数据
    6、服务端使用本地字节输出流将读取到的文件数据写到服务端本地文件中
    7、服务端基于Socket对象获取网络字节输出流对象。
    8、服务端使用获取的网络输出流对象给客户端回写数据"上传成功"
    9、客户端获取网络输入流对象，读取服务端回发的数据
    10、释放资源

服务端实现：

/*
    服务端实现步骤：
        1、创建一个服务端对象 ServerSocket
        2、调用accept() 用来获取访问的客户端
        3、基于客户端对象调用 getInputStream() 获取网络输入流对象
        4、使用网络流读取客户端发送上传的数据
        5、创建本地的输出流对象，将读取到的上传文件，写到本地硬盘上
        6、获取网络输出流对象，给客户端回写上传的结果。
        7、释放资源
 */
public class UnloadServer {
    public static void main(String[] args) throws IOException {
        // 1、创建一个服务端对象 ServerSocket
        ServerSocket ss = new ServerSocket(9090);
            
        // 2、调用accept() 用来获取访问的客户端
        Socket accept = ss.accept();
        // 3、基于客户端对象调用 getInputStream() 获取网络输入流对象
        InputStream is = accept.getInputStream();
        // 4、使用网络流读取客户端发送上传的数据
        // 5、创建本地的输出流对象，将读取到的上传文件，写到本地硬盘上
        // 通过Socket对象获取对象的IP地址
        String host = accept.getInetAddress().getHostAddress();
        // 将需要保存的文件路径 封装成一个File对象
        File file = new File("e:\\demo\\" + host + ".jpg");
        int name = 1;
        // 判断当前文件是否已经存在
        while (file.exists()) {
            file = new File("e:\\demo\\" + host + "(" + name + ")" + ".jpg");
            name++;
        }

        FileOutputStream fos = new FileOutputStream(file);
        int len = 0;
        byte[] bytes = new byte[1024];

        while ((len = is.read(bytes)) != -1) {
            // 写到本地硬盘上
            fos.write(bytes, 0, len);
        }

        //System.out.println("文件上传......");
        
        // 6、获取网络输出流对象，给客户端回写上传的结果。
        accept.getOutputStream().write("上传成功！".getBytes());

        // 7、释放资源
        accept.close();
        fos.close();
    }
}

客户端实现：

/*
    上文文件：
        1、创建客户端对象Socket对象
        2、客户端内部创建一个字符输入流对象，读取需要上传的文件
        3、客户端基于服务端获取一个网络输出流对象
        4、通过获取的网络输出流对象，将读取到的需要上传的文件写到通道中
        5、客户端基于服务端获取一个网络输入流对象
        6、通过获取的网络输入流对象，读取服务端回写的数据 "上传成功" / "上传失败"
        7、释放资源
 */
public class UnloadClient {
    public static void main(String[] args) throws IOException {
        //1、创建客户端对象Socket对象
        Socket socket = new Socket("127.0.0.1",9090);
        // 2、客户端内部创建一个字符输入流对象，读取需要上传的文件
        FileInputStream fis = new FileInputStream("e:\\demo\\1.jpg");
        // 3、客户端基于服务端获取一个网络输出流对象
        OutputStream os = socket.getOutputStream();
        int len = 0;
        byte[] bytes = new byte[1024];
        while ( ( len = fis.read(bytes)) != -1 ) {
            // 4、通过获取的网络输出流对象，将读取到的需要上传的文件写到通道中
            os.write(bytes,0,len);
        }
        // 强制告诉服务端，数据已经全部发送完毕。
        socket.shutdownOutput();
        ///
        // 5、客户端基于服务端获取一个网络输入流对象
        InputStream is = socket.getInputStream();
        // 6、通过获取的网络输入流对象，读取服务端回写的数据 "上传成功" / "上传失败"
        byte[] buff = new byte[1024];
        int ch = is.read(buff);
        System.out.println(new String(buff,0,ch));
        // 7、释放资源
        socket.close();
        fis.close();
    }
}

文件上传优化分析

1. 文件名称写死的问题
   服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一，代码如下：

   // 通过Socket对象获取对象的IP地址
   String host = accept.getInetAddress().getHostAddress();
   // 将需要保存的文件路径 封装成一个File对象
   File file = new File(“e:\demo\” + host + “.jpg”);
   int name = 1;
   // 判断当前文件是否已经存在
   while (file.exists()) {
   file = new File(“e:\demo\” + host + “(” + name + “)” + “.jpg”);
   name++;
   }
   // 5、创建本地的输出流对象，将读取到的上传文件，写到本地硬盘上
   FileOutputStream fos = new FileOutputStream(file);

2. 循环接收的问题
   服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件，代码如下：

   // 每次接收新的连接,创建一个Socket
   while（true）{
   Socket accept = serverSocket.accept();
   …
   }

3. 效率问题
   服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化，代码如下：

   while（true）{
   Socket accept = serverSocket.accept();
   // accept 交给子线程处理.
   new Thread(() -> {
   …
   InputStream bis = accept.getInputStream();
   …
   }).start();
   }

优化实现

/*
    服务端实现步骤：
        1、创建一个服务端对象 ServerSocket
        2、调用accept() 用来获取访问的客户端
        3、基于客户端对象调用 getInputStream() 获取网络输入流对象
        4、使用网络流读取客户端发送上传的数据
        5、创建本地的输出流对象，将读取到的上传文件，写到本地硬盘上
        6、获取网络输出流对象，给客户端回写上传的结果。
        7、释放资源
 */
public class UnloadServer {
    public static void main(String[] args) throws IOException {
        // 1、创建一个服务端对象 ServerSocket
        ServerSocket ss = new ServerSocket(9090);
        while ( true ) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        // 2、调用accept() 用来获取访问的客户端
                        Socket accept = ss.accept();
                        // 3、基于客户端对象调用 getInputStream() 获取网络输入流对象
                        InputStream is = accept.getInputStream();
                        // 4、使用网络流读取客户端发送上传的数据
                        // 5、创建本地的输出流对象，将读取到的上传文件，写到本地硬盘上
                        // 通过Socket对象获取对象的IP地址
                        String host = accept.getInetAddress().getHostAddress();
                        // 将需要保存的文件路径 封装成一个File对象
                        File file = new File("e:\\demo\\" + host + ".jpg");
                        int name = 1;
                        // 判断当前文件是否已经存在
                        while (file.exists()) {
                            file = new File("e:\\demo\\" + host + "(" + name + ")" + ".jpg");
                            name++;
                        }

                        FileOutputStream fos = new FileOutputStream(file);
                        int len = 0;
                        byte[] bytes = new byte[1024];

                        while ((len = is.read(bytes)) != -1) {
                            // 写到本地硬盘上
                            fos.write(bytes, 0, len);
                        }

                        //System.out.println("文件上传......");
                        
                        // 6、获取网络输出流对象，给客户端回写上传的结果。
                        accept.getOutputStream().write("上传成功！".getBytes());

                        // 7、释放资源
                        accept.close();
                        fos.close();
                    }catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();

        }
    }
}

信息回写分析图解

前四步与基本文件上传一致.

1. 【服务端】获取输出流，回写数据。
2. 【客户端】获取输入流，解析回写数据。

回写实现

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/*
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);
                ) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                        bos.write(b, 0, len);
                    }

                    // 4.=======信息回写===========================
                    System.out.println("back ........");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();
                    //================================

                    //5. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

客户端实现：

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //2.写出数据.
        byte[] b  = new byte[1024 * 8 ];
        int len ;
        while (( len  = bis.read(b))!=-1) {
            bos.write(b, 0, len);
        }
      	// 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        // 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        // ============================

        // 4.释放资源
        socket.close();
        bis.close();
    }
}

3.2 模拟B\S服务器( 扩展知识点 )

模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。

案例分析

准备数据资料

准备页面数据，web文件夹。复制到我们的项目中，比如复制到day12中

服务端读取客户端请求代码实现

我们模拟服务器端，ServerSocket类监听端口，使用浏览器访问

public class BS_TCP_Server {
    public static void main(String[] args) throws IOException {
        // 创建服务端对象，指定端口号
        ServerSocket server = new ServerSocket(9090);
        // 获取客户端对象
        Socket socket = server.accept();
        // 基于客户端对象，获取输入流对象，读取客户端发送的请求数据
        InputStream is = socket.getInputStream();
        // 读取客户端发送的请求数据
        int len = 0;
        byte[] bytes = new byte[1024];
        while( (len = is.read(bytes)) != -1 ) {
            System.out.println(new String(bytes,0,len));
        }
    }
}

使用网页访问服务端

服务器读取的请求信息

读取到的请求分析

1、因为客户端请求的是打开服务端的一个网页，所以在请求信息中就包含想要访问的网页信息，也就是请求的信息的第一行数据。

2、作为服务端是需要根据客户端的请求，回写数据的。回写的数据就是客户端请求打开的网页。但是请求打开的网页信息只在第一行，所以我们需要以一次读取一行的方式，只读取第一行信息即可。

3、如果想要一次读取一行数据，就需要使用到字符输入缓冲流。而读取客户端发送的请求数据则需要使用，通过客户端对象获取的字节输入流对象。因此我们需要将获取的字节输入流对象转换为字符输入缓冲流对象。

BufferedReader br = new BufferedReader( new InputStreamReader( in ) );

4、使用转换后的字符输入缓冲流对象，读取一行数据即可。

String line = br.readLine();

5、分析读取到的第一行的请求数据，当中只有 是客户端真实的请求数据。因此需要对读取到的数据做一些处理，从而获取到客户端真实的请求数据。

6、先使用字符串中的方法split()以空格符号进行切割：将读取的一行数据分成3部分，而我们只需要获取到其中的中间部分即可。

String[] arr = line.split(" "); // 只需要使用数组中中间部分，即： arr[1]

7、但是在获取到数据的中间部分之后，我们发现客户端的请求信息中还多了一个"/“符号。所以我们也需要将多余的”/“符号去除，可以使用字符串中的截取方法，将”/"符号后面的内容全部截取出来。

String hemlpath = arr[1].substring(1); // 真实需要的请求信息

8、创建本地的字节输入流对象，将客户端请求打开的html网页从本地硬盘上读取到程序中。

9、使用基于客户端对象获取到的字节输出流对象，将读取到html文件数据回写给客户端对象。在将读取到的html文件写出之前，需要将下列数据先写出（固定写法，原因后期课程会讲解）

// 写入HTTP协议响应头,固定写法
os.write("HTTP/1.1 200 OK\r\n".getBytes());
os.write("Content-Type:text/html\r\n".getBytes());
// 必须要写入空行,否则浏览器不解析
os.write("\r\n".getBytes());

案例实现

服务端实现：

public class BS_TCP_Server {
    public static void main(String[] args) throws IOException {
        // 创建服务端对象，指定端口号
        ServerSocket server = new ServerSocket(9090);
        // 获取客户端对象
        Socket socket = server.accept();
        // 基于客户端对象，获取输入流对象，读取客户端发送的请求数据
        InputStream is = socket.getInputStream();

        // 将字节输入流对象转换为字符输入缓冲流对象
        BufferedReader br = new BufferedReader( new InputStreamReader(is));
        // 使用自符缓冲流对象读取客户端请求的第一行
        String line = br.readLine();
        // 调用split方法，将获取的请求数据切割为3部分
        String[] arr = line.split(" ");
        // 然后获取切割部分的第2部分，并将/号后面的内容截取
        String htmlpath = arr[1].substring(1);
        // 基于客户端获取字节输出流对象，将读取到的html文件回写给客户端
        OutputStream os = socket.getOutputStream();
        /*
            需要固定写出的数据，后期课程会进行讲解
         */
        // 写入HTTP协议响应头,固定写法
        os.write("HTTP/1.1 200 OK\r\n".getBytes());
        os.write("Content-Type:text/html\r\n".getBytes());
        // 必须要写入空行,否则浏览器不解析
        os.write("\r\n".getBytes());
        // 创建本地字节输入流对象，读取客户端需要访问打开的网页
        FileInputStream fis = new FileInputStream(htmlpath);

        int len = 0;
        byte[] bytes = new byte[1024];
        while(( len = fis.read(bytes)) != -1 ) {
            // 将读取到的html文件回写给客户端
            os.write(bytes,0,len);
        }
        // 释放资源
        socket.close();
        fis.close();
        server.close();
        os.close();
        br.close();
    }
}

访问效果

小贴士：不同的浏览器，内核不一样，解析效果有可能不一样。

发现浏览器中出现很多的叉子,说明浏览器没有读取到图片信息导致。

浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。

public class BS_TCP_Server {
    public static void main(String[] args) throws IOException {
        // 创建服务端对象，指定端口号
        ServerSocket server = new ServerSocket(9090);
        while( true ) {
            // 获取客户端对象
            Socket socket = server.accept();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 基于客户端对象，获取输入流对象，读取客户端发送的请求数据
                        InputStream is = socket.getInputStream();

                        // 将字节输入流对象转换为字符输入缓冲流对象
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        // 使用自符缓冲流对象读取客户端请求的第一行
                        String line = br.readLine();
                        // 调用split方法，将获取的请求数据切割为3部分
                        String[] arr = line.split(" ");
                        // 然后获取切割部分的第2部分，并将/号后面的内容截取
                        String htmlpath = arr[1].substring(1);
                        // 基于客户端获取字节输出流对象，将读取到的html文件回写给客户端
                        OutputStream os = socket.getOutputStream();
                /*
                    需要固定写出的数据，后期课程会进行讲解
                 */
                        // 写入HTTP协议响应头,固定写法
                        os.write("HTTP/1.1 200 OK\r\n".getBytes());
                        os.write("Content-Type:text/html\r\n".getBytes());
                        // 必须要写入空行,否则浏览器不解析
                        os.write("\r\n".getBytes());
                        // 创建本地字节输入流对象，读取客户端需要访问打开的网页
                        FileInputStream fis = new FileInputStream(htmlpath);

                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = fis.read(bytes)) != -1) {
                            // 将读取到的html文件回写给客户端
                            os.write(bytes, 0, len);
                        }
                        // 释放资源
                        socket.close();
                        fis.close();
                        os.close();
                        br.close();
                    }catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();

        }
        //server.close();
    }
}

访问效果：