22 java 网络编程简介

2020-05-15 08:48 336人阅读评论(0)

文章目录

网络编程

一、网络编程入门

1. 软件结构
2. 网络通信协议
3. 协议分类
4. 网络编程的三要素

二、TCP通信程序

1. 概述
2. TCP通信的客户端代码实现
3. TCP通信的服务器端代码实现

三、综合案例：文件上传

1. 文件上传的原理
2. 文件上传案例的客户端
3. 文件上传案例的服务器端
4. 文件上传案例阻塞问题
5. 文件上传案例优化

网络编程

一、网络编程入门

1. 软件结构

C/S结构 ：全称为 Client/Server 结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。
B/S结构 ：全称为 Browser/Server 结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

2. 网络通信协议

**网络通信协议：**通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet 最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

3. 协议分类

UDP：用户数据报协议(User Datagram Protocol)。UDP 是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用 UDP 协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用 UDP 协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

但是在使用 UDP 协议传送数据时，由于 UDP 的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用 UDP 协议。 UDP 的交换过程如下图所示。

特点:数据被限制在64kb以内，超出这个范围就不能发送了。

数据报(Datagram):网络传输的基本单位
TCP：传输控制协议 (Transmission Control Protocol)。TCP 协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

在 TCP 连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
  - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  - 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  - 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。

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

4. 网络编程的三要素

协议
- 计算机网络通信必须遵守的规则。
IP地址
- IP地址：指互联网协议地址（Internet Protocol Address），俗称 IP。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  
# 或  
ifconfig
```
  - 检查网络是否连通，在控制台输入：
```
# ping 空格 IP地址
ping 220.181.57.216
```
- 特殊的IP地址
  - 本机IP地址：127.0.0.1、localhost 。
端口号
- 网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？
  
  如果说**IP地址可以唯一标识网络中的设备，那么端口号**就可以唯一标识设备中的进程（应用程序）了。
  - **端口号：用两个字节表示的整数，它的取值范围是0_{65535**。其中，0}1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。
  利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

二、TCP通信程序

1. 概述

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

两端通信时步骤：

服务端程序，需要事先启动，等待客户端的连接。
客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

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

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

2. TCP通信的客户端代码实现

**TCP通信的客户端：**向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据。
表示客户端的类：
- java.net.Socket：此类实现了客户端套接字，套接字是两台机器间通信的端点。
- 套接字：包含了IP地址和端口号的网络单位。
构造方法：
- Socket(String host, int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。
- 参数：
  - String host：服务器主机的名称/服务器的IP地址。
  - int port：服务器的端口号。
成员方法：
- OutputStream getOutputStream()返回此套接字的输出流。
- InputStream getInputStream()返回此套接字的输入流。
- void close()关闭套接字。
实现步骤：
1. 创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号。
2. 使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象。
3. 使用网络字节输出流OutputStream对象中的方法write，给服务器发送数据。
4. 使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象。
5. 使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据。
6. 释放资源（Socket）
注意：
- 客户端和服务器端进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象。
- 当我们创建客户端对象Socket的时候，就会去请求服务器，与服务器经过3次握手建立连接通路。
  - 如果服务器没有启动，那么就会抛出异常。
  - 如果服务器已经启动，那么就可以进行交互了。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1. 创建一个客户端对象`Socket`，构造方法绑定服务器的`IP`地址和端口号。
        Socket socket = new Socket("127.0.0.1",8888);

        //2. 使用`Socket`对象中的方法`getOutputStream()`获取网络字节输出流`OutputStream`对象。
        OutputStream os = socket.getOutputStream();

        //3. 使用网络字节输出流`OutputStream`对象中的方法`write`，给服务器发送数据。
        os.write("你好，服务器！".getBytes());

        //4. 使用`Socket`对象中的方法`getInputStream()`获取网络字节输入流`InputStream`对象。
        InputStream is = socket.getInputStream();

        //5. 使用网络字节输入流`InputStream`对象中的方法`read`，读取服务器回写的数据。
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));

        //6. 释放资源（`Socket`）
        socket.close();
    }
}

3. TCP通信的服务器端代码实现

**TCP通信的服务器端：**接收客户端的请求，读取客户端发送的数据，给客户端回写数据。
表示服务器的类：
- java.net.ServerSocket：此类实现服务器套接字。
构造方法：
- ServerSocket(int port)：创建绑定到特定端口的服务器套接字。
服务器端必须明确是哪一个客户端请求的服务器，所以可以使用accept方法获取到请求的客户端对象Socket。
成员方法：
- Socket accept()：侦听并接受到此套接字的连接。
实现步骤：
1. 创建服务器ServerSocket对象和系统要指定的端口号。
2. 使用ServerSocket对象中的方法accept获取到请求的客户端对象Socket。
3. 使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象。
4. 使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据。
5. 使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象。
6. 使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据。
7. 释放资源（Socket,ServerSocket）。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建服务器`ServerSocket`对象和系统要指定的端口号。
        ServerSocket server = new ServerSocket(8888);

        // 2. 使用`ServerSocket`对象中的方法`accept`获取到请求的客户端对象`Socket`。
        Socket socket = server.accept();

        // 3. 使用`Socket`对象中的方法`getInputStream()`获取网络字节输入流`InputStream`对象。
        InputStream is = socket.getInputStream();

        // 4. 使用网络字节输入流`InputStream`对象中的方法`read`，读取客户端发送的数据。
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));

        // 5. 使用`Socket`对象中的方法`getOutputStream()`获取网络字节输出流`OutputStream`对象。
        OutputStream os = socket.getOutputStream();

        // 6. 使用网络字节输出流`OutputStream`对象中的方法`write`，给客户端回写数据。
        os.write("收到谢谢！".getBytes());

        // 7. 释放资源（`Socket`,`ServerSocket`）。
        socket.close();
        server.close();
    }
}

三、综合案例：文件上传

1. 文件上传的原理

**原理：**客户端读取本地的文件，把文件上传到服务器，服务器再把上传的文件保存到服务器的硬盘上。
思路：
1. 客户端使用本地的字节输入流，读取要上传的文件。
2. 客户端使用网络字节输出流，把读取到的文件上传到服务器。
3. 服务器使用网络字节输入流，读取客户端上传的文件。
4. 服务器使用本地字节输出流，把读取到的文件，保存在服务器的硬盘上。
5. 服务器使用网络字节输出流，给客户端回写“上传成功”。
6. 客户端使用网络字节输入流，读取服务器回写的数据。
7. 释放资源。

2. 文件上传案例的客户端

客户端：读取本地文件，上传到服务器，读取服务器回写的数据。
明确：
- 数据源：/Users/zgl/Desktop/1.JPG
- 目的地：服务器
实现步骤：
1. 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源。
2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号。
3. 使用Socket对象中的方法getOutputStream，获取网络字节输出流OutputStream对象。
4. 使用本地字节输入流FileInputStream对象中的方法，读取本地文件。
5. 使用网络字节输出流Outputstream对象中的方法write，把读取到的文件上传到服务器。
6. 使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象。
7. 使用网络字节输入流InpurStream对象中的方法read读取服务器回写的数据。
8. 释放资源（FileInputStream，Socket）

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1. 创建一个本地字节输入流`FileInputStream`对象，构造方法中绑定要读取的数据源。
        FileInputStream fis = new FileInputStream("/Users/zgl/Desktop/1.JPG");

        //2. 创建一个客户端`Socket`对象，构造方法中绑定服务器的IP地址和端口号。
        Socket socket = new Socket("127.0.0.1",8888);

        //3. 使用`Socket`对象中的方法`getOutputStream`，获取网络字节输出流`OutputStream`对象。
        OutputStream os = socket.getOutputStream();

        //4. 使用本地字节输入流`FileInputStream`对象中的方法，读取本地文件。
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
            //5. 使用网络字节输出流`Outputstream`对象中的方法`write`，把读取到的文件上传到服务器。
            os.write(bytes,0,len);
        }
        
        //6. 使用`Socket`中的方法`getInputStream`，获取网络字节输入流`InputStream`对象。
        InputStream is = socket.getInputStream();

        //7. 使用网络字节输入流`InpurStream`对象中的方法`read`读取服务器回写的数据。
        while ((len = is.read(bytes)) != -1) {
            System.out.println(new String(bytes,0,len));
        }
        
        //8. 释放资源（`FileInputStream`，`Socket`）
        fis.close();
        os.close();
    }

}

3. 文件上传案例的服务器端

**服务器端：**读取客户端上传的文件，保存到服务器的硬盘，给客户端回写"上传成功"。
明确：
- 数据源：客户端上传的文件
- 目的地：/Users/zgl/Desktop/uploads/1.JPG
实现步骤：
1. 创建一个服务器ServerSocket对象，和系统要指定的端口号。
2. 使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象。
3. 使用Socket对象中的方法getInputStream，获取网络字节输入流InputStream对象。
4. 判断/Users/zgl/Desktop/uploads文件夹是否存在，不存在则创建。
5. 创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地。
6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件。
7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存在服务器的硬盘上。
8. 使用Socket对象中的方法getOutputStream，获取网络字节输出流OutputStream对象。
9. 使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"。
10. 释放资源(FileOutputStream,Socket,ServerSocket)。

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        //1. 创建一个服务器`ServerSocket`对象，和系统要指定的端口号。
        ServerSocket server = new ServerSocket(8888);

        //2. 使用`ServerSocket`对象中的方法`accept`，获取到请求的客户端`Socket`对象。
        Socket socket = server.accept();

        //3. 使用`Socket`对象中的方法`getInputStream`，获取网络字节输入流`InputStream`对象。
        InputStream is = socket.getInputStream();

        //4. 判断`/Users/zgl/Desktop/uploads`文件夹是否存在，不存在则创建。
        File file = new File("/Users/zgl/Desktop/uploads");
        if (!file.exists()) {
            file.mkdirs();
        }

        //5. 创建一个本地字节输出流`FileOutputStream`对象，构造方法中绑定要输出的目的地。
        FileOutputStream fos = new FileOutputStream(file + "/1.JPG");

        //6. 使用网络字节输入流`InputStream`对象中的方法`read`，读取客户端上传的文件。
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = is.read(bytes)) != -1) {
            //7. 使用本地字节输出流`FileOutputStream`对象中的方法`write`，把读取到的文件保存在服务器的硬盘上。
            fos.write(bytes,0,len);
        }

        //8. 使用`Socket`对象中的方法`getOutputStream`，获取网络字节输出流`OutputStream`对象。
        OutputStream os = socket.getOutputStream();

        //9. 使用网络字节输出流`OutputStream`对象中的方法`write`，给客户端回写"上传成功"。
        os.write("上传成功".getBytes());

        //10. 释放资源(`FileOutputStream`,`Socket`,`ServerSocket`)。
        fos.close();
        socket.close();
        server.close();
    }
}

4. 文件上传案例阻塞问题

上述的客户端及服务器端程序运行之后不会停止。
原因：
- 客户端读取本地文件，结束标记是-1，但是并不会将结束标记读取，也不会将结束标记写入服务器。
- 服务器端读取客户端上传的文件，永远不会读取到文件的结束标记，read方法进入到阻塞状态。

解决：

void shutdownOutput()禁用此套接字的输出流。
将该函数加入到客户端的while循环之后即可。

...
  while ((len = fis.read(bytes)) != -1) {
            //5. 使用网络字节输出流`Outputstream`对象中的方法`write`，把读取到的文件上传到服务器。
            os.write(bytes,0,len);
        }
  socket.shutdownOutput();

5. 文件上传案例优化

文件名称写死的问题

服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一。
循环接收的问题

服务端，只保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件。
效率问题

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

优化实现

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        //1. 创建一个服务器`ServerSocket`对象，和系统要指定的端口号。
        ServerSocket server = new ServerSocket(8888);

        //循环接收问题优化
        while (true) {
            //2. 使用`ServerSocket`对象中的方法`accept`，获取到请求的客户端`Socket`对象。
            Socket socket = server.accept();
            //效率问题优化
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //3. 使用`Socket`对象中的方法`getInputStream`，获取网络字节输入流`InputStream`对象。
                        InputStream is = socket.getInputStream();

                        //4. 判断`/Users/zgl/Desktop/uploads`文件夹是否存在，不存在则创建。
                        File file = new File("/Users/zgl/Desktop/uploads");
                        if (!file.exists()) {
                            file.mkdirs();
                        }

                        //优化文件命名问题
                        String filename = "zhuguli" + System.currentTimeMillis() + new Random().nextInt(9999) + ".JPG";

                        //5. 创建一个本地字节输出流`FileOutputStream`对象，构造方法中绑定要输出的目的地。
                        FileOutputStream fos = new FileOutputStream(file + "/" + filename);

                        //6. 使用网络字节输入流`InputStream`对象中的方法`read`，读取客户端上传的文件。
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = is.read(bytes)) != -1) {
                            //7. 使用本地字节输出流`FileOutputStream`对象中的方法`write`，把读取到的文件保存在服务器的硬盘上。
                            fos.write(bytes,0,len);
                        }

                        //8. 使用`Socket`对象中的方法`getOutputStream`，获取网络字节输出流`OutputStream`对象。
                        OutputStream os = socket.getOutputStream();

                        //9. 使用网络字节输出流`OutputStream`对象中的方法`write`，给客户端回写"上传成功"。
                        os.write("上传成功".getBytes());

                        //10. 释放资源(`FileOutputStream`,`Socket`,`ServerSocket`)。
                        fos.close();
                        socket.close();
                    } catch (IOException e) {
                        System.out.println(e);
                    }
                }
            }).start();

        }

        //循环接收，不需要关闭
        //server.close();
    }
}

转载：https://blog.csdn.net/weixin_44781238/article/details/106128622

查看评论

小言_互联网的博客