「JavaSE学习笔记08」网络编程

¶Chapter 14. 网络编程

网络编程，即使用编程语言实现多台计算机的通信。

¶14.1 计算机网络入门

当前节的知识点只是一个概述，更具体、详细的内容放在 计算机网络 中。

¶14.1.1 软件结构

• C/S结构（Client/Server结构）：指客户端与服务器结构，常见程序有QQ、迅雷等软件。
• B/S结构（Browser/Server结构）：指浏览器与服务器结构。

两种架构各有优势，无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

¶14.1.2 网络通信协议

• 网络通信协议：只有遵守这些规则，计算机之间才能进行通信。协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。

• TCP/IP（ TCP/IP 协议族 的简称）：传输控制协议/网际协议（Transmission Control Protocol / Internet Protocol），是网络通信模型，以及整个网络传输协议家族，为网际网络的基础通信架构。它将软件通信过程抽象化为四个抽象层，采取协议堆栈的方式，分别实现出不同通信协议。该协议家族的两个核心协议、最具代表性的协议为：TCP（传输控制协议）和IP（网际协议）。

  

¶14.1.3 协议分类

java.net包中包含的类和接口，提供低层次的通信细节。该包中提供了两种常见的网络协议的支持：

• UDP：用户数据报协议（User Datagram Protocol）。UDP协议是一个面向无连接的协议。传输数据时，不需建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在$64k$以内。由于无连接，故传输速度快，但容易丢失数据，日常应用于视频会议、QQ聊天等。

• TCP：传输控制协议（Transmission Control Protocol）。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。TCP协议中，在发送数据的准备阶段，客户端与服务器的三次交互，称为三次握手，以保证连接的可靠。

  • 第一次握手：客户端向服务器端发出连接请求，等待服务器确认。
  • 第二次握手：服务器端向客户端回送一个响应，通知客户端收到连接请求。
  • 第三次握手：客户端再次向服务器端发送确认信息，确认连接。

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

¶14.1.4 网络编程三要素

利用协议+IP地址+端口号 三元组，即可标识网络中的进程。而进程间的通信即可利用该标识与其他进程进行交互。

1. 协议

   定义通信规则。

   IP地址可以唯一标识网络中的设备，端口号可以唯一标识设备中的进程（应用程序）。

2. IP地址

   IP 指互联网协议地址（Internet Protocol Address），它用来给一个网络中的计算机设备做唯一的编号。而IP地址有如下分类：

   • IPv4：使用32位地址（4字节），故地址空间只有$2^{32}$个地址。通常采用点分十进制的格式：a.b.c.d，其中a、b、c、d均为0~255之间的十进制整数并用.分开，如192.168.56.100。
   • IPv6：使用128位地址，故地址空间支持$2^{128}(=16^{32})$个地址。它可以分为8组，用:进行分组，每组以4位十六进制方式表示，如 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789

   常用命令有：

   • 查看本机IP地址，在控制台输入：ipconfig 或者 通过控制面板

     

   • 检查网络是否连通，在控制台输入：ping IP地址（如ping 220.181.57.216）

3. 端口号

   端口号，是一个逻辑端口。它用两个字节表示的整数，其取整范围为[$0, 2^8\times2^8$]。其中[$0,1023$]之间的端口号用于一些知名的网络服务和应用。$1024$以上的端口则用于普通的应用程序。当网络软件一打开，操作系统便会为该网络软件分配一个随机的端口号。若端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

   常用端口号有：

   1. 80端口：网络端口
   2. 数据库：mysql：3306；oracle：1521
   3. Tomcat服务器：8080

举例：若我要和张三说话，我需要张三的地址来找到他（相当于通过IP找到指定计算机）；接着我要与张三的说话，而他用耳朵听我说话（相当于用特定端口接收）；而我们之间对话的语言，需要做好约定，彼此都能听懂（协议所起的作用）。

¶14.2 TCP通信程序

¶14.2.1 概述

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

两端通信时步骤：

1. 服务端程序，需事先启动！但服务端不能够主动连接客户端，需等待客户端的连接。这个连接当中包含IO对象（字节流对象）。
2. 客户端主动连接服务器端，连接成功后，客户端和服务器端可使用IO对象进行通信了。一个数据的交互则需要4个IO流对象

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

1. 客户端：用java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，等到服务端响应请求后，两者建立连接开始通信。

2. 服务端：用java.net.ServerSocket 类表示。创建 ServerSocket 对象，相当于开启一个服务，并等待客户端的连接。

   注意，服务端没有IO流，它使用每个客户端Socket中提供的IO流和客户端进行交互：

   • 服务端使用客户端的字节输入流读入客户端发送的数据。
   • 服务端使用客户端的字节输出流给客户端回写数据。

¶14.2.2 Socket 类

使用Socket 类，实现客户端套接字（套接字Socket，可以理解为插座，它包含了IP地址和端口号的网络单位）。

构造方法：

• public Socket(String host, int port)：创建套接字（Socket）对象，并将其连接到指定主机上的指定端口号。

  参数：

  • String host：服务器主机的名称/服务器的IP地址。
  • int port：服务器的端口号。

  如果指定的 host 是 null ，则相当于指定地址为回送地址。回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本 地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

成员方法

• public InputStream getInputStream()：返回此套接字的输入流。若此Scoket具有相关联的通道，则生成的InputStream的所有操作也关联该通道。关闭生成的InputStream也将关闭相关的Socket。
• public OutputStream getOutputStream()：返回此套接字的输出流。与上同理。
• public void close()：关闭此套接字。一个Socket被关闭，则不可再被使用
• public void shutdownOutput()：禁用此套接字的输出流。任何先前写出的数据将被发送，随后终止输出流。

¶14.2.3 ServerSocket 类

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

构造方法：

• public ServerSocket(int port)：创建绑定到特定端口port的服务器套接字

成员方法：

• public Socket accept()：侦听并接受连接，返回一个新的Socket对象，用于给客户端实现通信，该方法会一直阻塞到建立连接。由于服务端必须明确是哪个客户端发送请求，故可使用该方法以获取到发送请求的客户端对象Socket。

¶14.2.4 简单的TCP网络程序

TCP通信步骤：

1. 【服务端】启动，创建ServerSocket对象，等待连接。

2. 【客户端】启动，创建Socket对象，请求连接。

3. 【服务端】接收连接，调用accept()方法，并返回一个Socket对象。

4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。

5. 【服务端】Socket对象，获取InputStream，读入客户端发送的数据。

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

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

6. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。

7. 【客户端】Socket对象，获取InputStream，解析回写数据。

8. 【客户端】释放资源，断开连接。

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动，等待连接中....");
        ServerSocket ss = new ServerSocket(6666); //1.创建ServerSocket对象，绑定端口，开始等待连接
        Socket server = ss.accept(); //2.调用accept方法，以获取发送请求的客户端Socket
        InputStream is = server.getInputStream(); //3.通过Socket对象获取输入流，读入客户端发送的数据
		//4.一次性读入数据
        byte[] arr = new byte[1024];
        int len = is.read(arr); //读入至字节数组中
        String msg = new String(arr, 0, len); //解析数组，打印字符串信息
        System.out.println(msg); //打印字符串信息，供测试

        /* ---------------回写数据--------------- */
        OutputStream os = server.getOutputStream(); //5.通过Socket获取输出流
        os.write("Hey man, I am good!".getBytes()); //6.回写数据至客户端
		
        os.close();
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端发送数据！");
        Socket client = new Socket("localhost", 6666); //1.确定连接至哪个服务端
        OutputStream os = client.getOutputStream(); //2.获取输出流对象
        os.write("How do you do, TCP? I am coming!".getBytes()); //3.写出数据至服务端

        /* ---------------解析回写--------------- */
        InputStream in = client.getInputStream(); //4.获取输入流对象
        //5.读入回写的数据
        byte[] arr = new byte[100];
        int len = in.read(arr);
        System.out.println(new String(arr, 0, len)); //打印服务端回写的数据

        in.close();
        os.close();
        client.close();
    }
}

启动时，应该先运行服务端，再运行客户端（手速要快），顺序颠倒会导致抛出异常

ServerTCP运行结果：

ClientTCP运行结果：

¶14.3 综合案例

¶14.3.1 文件上传

①【客户端】输入流，从本地硬盘读入文件数据到程序中；

②【客户端】输出流，写出文件数据到服务端；

③【服务端】输入流，读入文件数据到服务端程序；

④【服务端】输出流，写出文件数据到服务器硬盘中。

一、初步实现

服务端初步代码实现：

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

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器已经启动....");
        ServerSocket serverSocket = new ServerSocket(8888); //1.创建服务端ServerSocket
        Socket apt = serverSocket.accept(); //2.建立连接
        //3.创建流对象
        BufferedInputStream bis = new BufferedInputStream(apt.getInputStream()); //获取输入流，读入文件数据
        File file = new File("D:\\uploadbyJava");
        //假定D盘即为服务器硬盘
        if(!file.exists()) file.mkdir(); //不存在该文件夹则创建它
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file + "\\copy.jpg"));//创建输出流，写出到服务器本地
        //4.读写数据
        byte[] b = new byte[1024 * 8];
        int len = 0;
        while((len = bis.read(b)) != -1){
            bos.write(b, 0, len);
        }
        //5.关闭资源
        bos.close();
        bis.close();
        apt.close();
        System.out.println("上传的文件已经保存！");
    }
}

客户端初步代码实现：

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

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        //1.创建流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\wall.jpg"));//1.1 创建输入流，读入本地硬盘的文件
        Socket socket = new Socket("127.0.0.1", 8888);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream()); //创建输出流，写出到服务端
        //2.读写数据
        int len = 0;
        byte[] b = new byte[1024 * 8];
        while((len = bis.read(b)) != -1){
            bos.write(b, 0, len);
            bos.flush(); 
            /* 注意！flush()在此处十分重要！它既能够保证将缓冲区刷新，又能够在下一轮循环中继续使用。*/            
        }
        System.out.println("文件发送完毕!");
        //3.释放资源
        bos.close();
        socket.close();
        bis.close();
        System.out.println("文件上传完毕!");
    }
}

客户端知道自己的文件什么时候读取完毕，可以自己停止。如果不使用 flush() 或者是视频中 shutdownOutput()，服务器不能够接收到文件结束的标记，也即无法知道何时停止，会不断地等待着（死循环）接收客户端read()中的内容，进入阻塞状态。

二、优化分析

1. 关于文件名称写死的问题

   为了在服务器硬盘中保存多个文件，不应将文件名称写死，如 xxx.jpg。可以使用系统时间+随机数来进行命名。

   String fileName = System.currentTimeMillis() + new Random().nextInt(999999)+".jpg";//文件名称
   FileOutputStream fis = new FileOutputStream(file + 
   "\\" + fileName); // 文件路径
   BufferedOutputStream bos = new BufferedOutputStream(fis);

2. 关于循环接收的问题

   服务端如果只保存一个文件就关闭的话，用户无法再进行文件上传，不符合实际。可使用循环进行改进，使得服务器一直处于监听状态，不断地接收不同用户的文件（注意，它不同于上面所述的阻塞状态）

   运行的时候，不需要手速了😂

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

3. 关于效率的问题

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

   while(true){
       Socket apt = serverSocket.accept();
       new Thread(() -> {
           //socket对象交给子线程处理进行读写操作，Runnable接口中只有一个run方法，使用lambda表达式简化格式
           InputStream bis = accept.getInputStream();
           //...
       })
   }

三、代码优化+信息回写

服务端代码：

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

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\uploadbyJava"); //假定D盘即为服务器硬盘，设置文件路径
        if(!file.exists()) file.mkdir(); //不存在该文件夹则创建它
        System.out.println("服务器已经启动....");
        ServerSocket serverSocket = new ServerSocket(8888); //1.创建服务端ServerSocket
		//2.循环接收，建立连接
        while(true){
            Socket apt = serverSocket.accept(); 
            String fileName = System.currentTimeMillis() + new Random().nextInt(999999)+".jpg"; //文件名
            /* 3.socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try(
                        BufferedInputStream bis = new BufferedInputStream(apt.getInputStream());//获取输入流对象
                        FileOutputStream fis = new FileOutputStream(file + "\\" + fileName); // 创建输出流对象，用于写出至服务器本地
                        BufferedOutputStream bos = new BufferedOutputStream(fis);
                ){ //读写数据
                    byte[] b = new byte[1024 * 8];
                    int len = 0;
                    while((len = bis.read(b)) != -1){
                        bos.write(b, 0, len);
                    }
					/* 4.信息回写 */
                    System.out.println("back....");
                    OutputStream out = apt.getOutputStream();
                    out.write("文件上传成功至服务器!".getBytes());
                    out.close();
					//关闭资源
                    apt.close();
                    System.out.println("上传的文件已经保存!");
                } catch (IOException e){
                    e.printStackTrace();
                }
            }).start(); //别忘记运行进程
        }
    }
}

客户端代码：

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

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        //1.创建流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\wall.jpg"));//创建输入流，读入本地硬盘的文件
        Socket socket = new Socket("127.0.0.1", 8888);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream()); //创建输出流，写出到服务端
        //2.读写数据
        int len = 0;
        byte[] b = new byte[1024 * 8];
        while((len = bis.read(b)) != -1){
            bos.write(b, 0, len);
            //bos.flush();
        }
        socket.shutdownOutput(); //关闭输出流，通知服务端，写出数据完毕
        System.out.println("文件发送完毕!");
		/* 3. 解析回写 */
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        // 4. 释放资源
        in.close();
        socket.close();
        bis.close();
    }
}

运行结果：

服务端运行窗口	客户端运行窗口	实际运行结果

¶14.3.2 模拟B/S服务器

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

要点：

1. 我们可以将页面数据放置到某个web文件夹中，服务器端程序启动时，在浏览器中输入地址：localhost:端口号/页面数据文件路径，如下图：

   

2. 服务器程序中字节输入流可读入浏览器发来的请求信息，类似于下图：

   

   其中，第一行为浏览器的请求信息，而 /web/index.html 正是浏览器想要请求的服务器端的资源，需要用字符串进行切割获取

3. 浏览器在得到响应信息后，便在页面进行数据的展示。

4. 浏览器遇到图片时，会开启一个线程进行单独的访问，因而需要在服务器端使用线程技术。

public class BS_ServerDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动，等待连接中....");
        ServerSocket server = new ServerSocket(8888);
        while(true){
            Socket socket = server.accept();
            new Thread(new Web(socket)).start(); //Web作为target，Thread对象才是真正的线程对象，需要调用start启动线程
        }
    }
    static class Web implements Runnable{ //实现Runnable接口，以创建线程
        private Socket socket;
        public Web(Socket socket){
            this.socket = socket;
        }
        public void run(){ //定义Runnable接口的实现类，需要覆写该接口的run方法
            try{
                BufferedReader readWb = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                //转换流读入浏览器请求的信息，类似于"GET, /basic-codes/NewModule/web/index.html, HTTP/1.1"
                String reqst = readWb.readLine();
                String[] arr = reqst.split(" "); //以空格字符作为分隔符，将上面的信息切割，我要取出其中的请求资源的路径
                System.out.println(Arrays.toString(arr));
                String realpath = arr[1].substring(1); //因为arr[1]="/basic-codes/NewModule/web/index.html"有多余的‘/’字符
                System.out.println(realpath);

                FileInputStream fis = new FileInputStream(realpath);
                System.out.println(fis);
                byte[] b= new byte[1024];
                int len = 0;
                OutputStream out = socket.getOutputStream();
                //字节输出流，接下来三行是固定的，将HTTP协议响应头写出给客户端
                out.write("HTTP/1.1 200 OK\r\n".getBytes());
                out.write("Content-Type:text/html\r\n".getBytes());
                out.write("\r\n".getBytes()); // 必须要写入空行,否则浏览器不解析
                while((len = fis.read(b)) != -1){ //读入（客户端所请求的）资源文件
                    out.write(b, 0, len);
                }
                fis.close();
                out.close();
                readWb.close();
                socket.close();
            } catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}