【Java学习】- 网络编程

最新推荐文章于 2022-04-29 08:52:18 发布

༄迷恋࿐

最新推荐文章于 2022-04-29 08:52:18 发布

阅读量129

点赞数

分类专栏：笔记 # Java 文章标签：网络 java socket

本文链接：https://blog.csdn.net/qq_45528435/article/details/116379633

版权

笔记同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

Java

14 篇文章 0 订阅

订阅专栏

N13 网络编程

作者：迷恋

一、概述

计算机网络

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程的目的

无线电台…传播交流信息，数据交换，通信

想要达到这个效果需要什么

1、如何准确的定位网路上的一台主机 192.168.43.1 端口：定位到这个计算机上的某个资源
2、找到了这个主机，如何传输数据？

javaweb：网页编程 B/S
网络编程：TCP/IP C/S

二、网络编程的三要素

1、网络通信协议

（见下方通信协议）

2、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 windows
ifconfig macOS

检查⽹络是否连通，在控制台输⼊：

ping 空格 IP地址
ping 112.80.248.76

特殊的IP地址

本机IP地址： 127.0.0.1、localhost。

域名：代替记忆IP

www.baidu.com

一些基本的IP地址类代码：InetAddress

package demo43;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress2 = InetAddress.getLocalHost();
            System.out.println(inetAddress2);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);

            //查询网站ip地址
            InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress4);

            //常用方法
            System.out.println(inetAddress4.getAddress());
            System.out.println(inetAddress4.getCanonicalHostName());//规范的名字
            System.out.println(inetAddress4.getHostAddress());//ip
            System.out.println(inetAddress4.getHostName());//域名
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述

3、端口

所谓的端口，就好像是门牌号一样，客户端可以通过ip地址找到对应的服务器端，但是服务器端是有很多端口的，每个应用程序对应一个端口号，通过类似门牌号的端口号，客户端才能真正的访问到该服务器。为了对端口进行区分，将每个端口进行了编号，这就是端口号。

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

如果说IP地址可以唯⼀标识⽹络中的设备，那么端⼝号就可以唯⼀标识设备中的进程（应⽤程序）了。

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

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

TCP ，UDP都有65535，两端口号不冲突，TCP用了600，UDP可再用600，但是同协议下，端口号不能冲突。

端口分类

公有端口 0-1023
- HTTP ：80
- HTTPS：443
- FTP：21
- Telent：23
程序注册端口：1024-49151，分配给用户或者程序
- Tomcat：8080
- MySQL：3306
- Oracle：1521
动态、私有：49152-65535

一些命令：

netstat -ano # 查看所有的端口
netstat -ano|findstr "5900" #查看指定的端口
tasklist|findstr "8696" #查看指定PID的进程（PID不是端口）

InetSocketAddress:

package demo43;

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress1 = new InetSocketAddress("127.0.0.1",6666);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost",6666);
        System.out.println(inetSocketAddress1);
        System.out.println(inetSocketAddress2);

        System.out.println(inetSocketAddress1.getAddress());
        System.out.println(inetSocketAddress1.getHostName());//地址
        System.out.println(inetSocketAddress1.getPort());//端口
    }
}

运行结果：
在这里插入图片描述

三、通信协议

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

TCP/IP参考模型：

在这里插入图片描述
上图中，TCP/IP协议中的四层分别是应⽤层、传输层、⽹络层和链路层，每层分别负责不同的通信功能。

链路层：链路层是⽤于定义物理传输通道，通常是对某些⽹络连接设备的驱动协议，例如针对光纤、⽹线提供的驱动。
⽹络层：⽹络层是整个TCP/IP协议的核⼼，它主要⽤于将传输的数据进⾏分组，将分组数据发送到⽬标计算机或者⽹络。
运输层：主要使⽹络程序进⾏通信，在进⾏⽹络通信时，可以采⽤TCP协议，也可以采⽤UDP协议。
应⽤层：主要负责应⽤程序的协议，例如HTTP协议、FTP协议等。

协议分类

通信的协议还是⽐较复杂的， java.net包中包含的类和接⼝，它们提供低层次的通信细节。我们可以直接使⽤这些类和接⼝，来专注于⽹络程序开发，⽽不⽤考虑通信的细节。
java.net包中提供了两种常⻅的⽹络协议的⽀持：

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

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

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

特点:数据被限制在64kb以内，超出这个范围就不能发送了。
数据报(Datagram):⽹络传输的基本单位
TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是⾯向连接的通信协议，即传输数据之前，在发送端和接收端建⽴逻辑连接，然后再传输数据，它提供了两台计算机之间可靠⽆差错的数据传输。

在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握⼿”。
- 三次握⼿：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
  - 第⼀次握⼿，客户端向服务器端发出连接请求，等待服务器确认。
  - 第⼆次握⼿，服务器端向客户端回送⼀个响应，通知客户端收到了连接请求。
  - 第三次握⼿，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。
完成三次握⼿，连接建⽴后，客户端和服务器就可以开始进⾏数据传输了。由于这种⾯向连接的特性，TCP协议可以保证传输数据的安全，所以应⽤⼗分⼴泛，例如下载⽂件、浏览⽹⻚等。

四、TCP通信程序

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

两端通信时步骤：

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

在Java中，提供了两个类⽤于实现TCP通信程序：
3. 客户端：java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请求，两者建⽴连接开始通信。
4. 服务端：java.net.ServerSocket类表示。创建 ServerSocket 对象，相当于开启⼀个服务，并等待客户端的连接。

1、Socket类

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()：禁⽤此套接字的输出流。

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

2、 ServerSocket类

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

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

构造举例，代码如下：

ServerSocket server = new ServerSocket(6666);

成员⽅法

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

3、简单的TCP网络程序

TCP通信分析图解

【服务端】启动,创建ServerSocket对象，等待连接。
【客户端】启动,创建Socket对象，请求连接。
【服务端】接收连接,调⽤accept⽅法，并返回⼀个Socket对象。
【客户端】Socket对象，获取OutputStream，向服务端写出数据。
【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。

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

在这里插入图片描述

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

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

客户端向服务器发送数据

服务端：

public class ServerTCP {
	public static void main(String[] args) throws IOException {
		 System.out.println("服务端启动 , 等待连接 .... ");
		 // 1.创建 ServerSocket对象，绑定端⼝，开始等待连接
		 ServerSocket ss = new ServerSocket(6666);
		 
		 // 2.接收连接 accept ⽅法, 返回 socket 对象.
		 Socket server = ss.accept();
		 
		 // 3.通过socket 获取输⼊流
		 InputStream is = server.getInputStream();
		 
		 // 4.⼀次性读取数据
		 // 4.1 创建字节数组
		 byte[] b = new byte[1024];
		 
		 // 4.2 据读取到字节数组中.
		 int len = is.read(b)；
		 
		 // 4.3 解析数组,打印字符串信息
		 String msg = new String(b, 0, len);
		 System.out.println(msg);
		 
		 //5.关闭资源.
		 is.close();
		 server.close();
	 }
}

客户端：

public class ClientTCP {
	 public static void main(String[] args) throws Exception {
		 System.out.println("客户端 发送数据");
		 
		 // 1.创建 Socket ( ip , port ) , 确定连接到哪⾥.
		 Socket client = new Socket("localhost", 6666);
		 
		 // 2.获取流对象 . 输出流
		 OutputStream os = client.getOutputStream();
		 
		 // 3.写出数据.
		 os.write("亲，我是tcp客户端操作".getBytes());
		 
		 // 4. 关闭资源 .
		 os.close();
		 client.close();
	 } 
 }

服务器向客户端回写数据

服务端：

public class ServerTCP {
	 public static void main(String[] args) throws IOException {
		 System.out.println("服务端启动 , 等待连接 .... ");
		 
		 // 1.创建 ServerSocket对象，绑定端⼝，开始等待连接
		 ServerSocket ss = new ServerSocket(6666);
		 
		 // 2.接收连接 accept ⽅法, 返回 socket 对象.
		 Socket server = ss.accept();
		 
		 // 3.通过socket 获取输⼊流
		 InputStream is = server.getInputStream();
		 
		 // 4.⼀次性读取数据
		 // 4.1 创建字节数组
		 byte[] b = new byte[1024];
		 
		 // 4.2 据读取到字节数组中.
		 int len = is.read(b)；
		 
		 // 4.3 解析数组,打印字符串信息
		 String msg = new String(b, 0, len);
		 System.out.println(msg);
		 
		 // =================回写数据=======================
		 // 5. 通过 socket 获取输出流
		 OutputStream out = server.getOutputStream();
		 
		 // 6. 回写数据
		 out.write("亲，我是tcp服务端。".getBytes());
		 
		 // 7.关闭资源.
		 out.close();
		 is.close();
		 server.close();
	 }
}

客户端：

public class ClientTCP {
	 public static void main(String[] args) throws Exception {
		 System.out.println("客户端 发送数据");
		 
		 // 1.创建 Socket ( ip , port ) , 确定连接到哪⾥.
		 Socket client = new Socket("localhost", 6666);
		 
		 // 2.通过Scoket,获取输出流对象
		 OutputStream os = client.getOutputStream();
		 
		 // 3.写出数据.
		 os.write("亲，我是tcp客户端".getBytes());
		 // ==============解析回写=========================
		 
		 // 4. 通过Scoket,获取 输⼊流对象
		 InputStream in = client.getInputStream();
		 
		 // 5. 读取数据数据
		 byte[] b = new byte[100];
		 int len = in.read(b);
		 System.out.println(new String(b, 0, len));
		 
		 // 6. 关闭资源 .
		 in.close();
		 os.close();
		 client.close();
	 } 
 }

五、文件上传

⽂件上传分析图解

【客户端】输⼊流，从硬盘读取⽂件数据到程序中。
【客户端】输出流，写出⽂件数据到服务端。
【服务端】输⼊流，读取⽂件数据到服务端程序。
【服务端】输出流，写出⽂件数据到服务器硬盘中。

基本实现

服务端：

public class FileUpload_Server {
	 public static void main(String[] args) throws IOException {
		 System.out.println("服务器 启动..... ");
		 
		 // 1. 创建服务端ServerSocket
		 ServerSocket serverSocket = new ServerSocket(6666);
		 
		 // 2. 建⽴连接
		 Socket accept = serverSocket.accept();
		 
		 // 3. 创建流对象
		 // 3.1 获取输⼊流,读取⽂件数据
		 BufferedInputStream bis = new
		BufferedInputStream(accept.getInputStream());
		
		 // 3.2 创建输出流,保存到本地 .
		 BufferedOutputStream bos = new BufferedOutputStream(new
		FileOutputStream("copy.jpg"));
		
		 // 4. 读写数据
		 byte[] b = new byte[1024 * 8];
		 int len;
		 while ((len = bis.read(b)) != -1) {
			 bos.write(b, 0, len);
		 }
		 
		 //5. 关闭 资源
		 bos.close();
		 bis.close();
		 accept.close();
		 System.out.println("⽂件上传已保存");
	 }
}

客户端：

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);
			 bos.flush();
		 }
		 System.out.println("⽂件发送完毕");
		 
		 // 3.释放资源
		 bos.close();
		 socket.close();
		 bis.close();
		 System.out.println("⽂件上传完毕 ");
	 } 
 }

文件上传优化分析

1、⽂件名称写死的问题

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

FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg")
// ⽂件名称
BufferedOutputStream bos = new BufferedOutputStream(fis);

2.、循环接收的问题

服务端，指保存⼀个⽂件就关闭了，之后的⽤户⽆法再上传，这是不符合实际的，使⽤循环改进，可以不断的接收不同⽤户的⽂件，代码如下：

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

3、效率问题

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

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

优化实现

public class FileUapload_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. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("⽂件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

信息回写分析图解

前四步与基本⽂件上传⼀致.
5. 【服务端】获取输出流，回写数据。
6. 【客户端】获取输⼊流，解析回写数据。
在这里插入图片描述

回写实现

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);
		 }
		 //刷新缓冲区，强制写入文件
		 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));
		 in.close();
		 // ============================
		 
		 // 4.释放资源
		 socket.close();
		 bis.close();
	 }
}