• Java基础（五）

    前言：本博客主要记录学习网络通信的基本知识以及网络编程的应用。

    网络编程

    基本的通信架构

    CS架构（Cilent客户端/Server服务端）

    BS架构（Browser浏览器/Server服务端）

    网络通信三要素

    网络通信三要素：IP地址、端口、协议

    IP地址

    作用：找到网络上的通信设备

    • IPv4
    • IPv6

    公网IP

    内网IP 192.168.0.0

    特殊的IP：127.0.0.1、localhost 代表本机

    Ping IP地址，查看网络是否连通

    InetAddress

    1. package learn14;
    2.  
    3. import java.net.InetAddress;
    4.  
    5. public class InetAddressTest {
    6.     public static void main(String[] args) throws Exception {
    7.         //获取本机IP地址对象
    8.         InetAddress ip1 = InetAddress.getLocalHost();
    9.         System.out.println(ip1.getHostName());
    10.         System.out.println(ip1.getHostAddress());
    11.         //获取指定IP或域名的IP地址对象
    12.         InetAddress ip2 = InetAddress.getByName("www.baidu.com");
    13.         System.out.println(ip2.getHostName());
    14.         System.out.println(ip2.getHostAddress());
    15.  
    16.         System.out.println(ip2.isReachable(10000));
    17.     }
    18. }

    端口

    作用：找到设备中的应用程序

    范围是0~65535

    分类：

    周知端口：0~1023，预先定义的知名应用占用（HTTP 80 FTP 81）

    注册端口：1024~49151，分配给进程或某些应用程序

    动态端口：49152~65535，不固定分配给某种进程

    自己开发的程序一般选择使用注册端口，且一个设备中不能出现两个程序的端口号一样，否则出错

    协议

    网络上通信的设备，事先规定的连接规则，以及传输数据的规则，被称为网络通信协议

    OSI网络参考模型

    TCP/IP网络模型

    传输层的2个通信协议

    UDP 用户数据报协议

    特点：无连接、不可靠协议

    应用：通信效率高，适合语音通话、视频直播

    TCP 通信协议

    特点：面向连接、可靠协议

    TCP主要有三个步骤实现可靠连接：三次握手建立连接，传输数据进行确认，四次握手断开连接。

    应用：通信效率相对不高，适合网页、文件下载、支付

    TCP 传输控制协议

    网络编程

    UDP通信

    客户端发送数据，服务端接受数据

    一次发送，一次接收

    1. package learn14;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5. import java.net.InetAddress;
    6.  
    7. public class Client {
    8.     public static void main(String[] args) throws Exception {
    9.         //创建客户端对象 (发数据)
    10.         DatagramSocket socket = new DatagramSocket(8888);
    11.         //创建数据包对象封装要发出去的数据
    12.         byte[] bytes = "hello,world".getBytes();
    13.         DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getLocalHost(), 6666);
    14.         socket.send(packet);
    15.         System.out.println("客户端数据发送完毕！");
    16.  
    17.         socket.close();
    18.  
    19.     }
    20. }
    1. package learn14;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5.  
    6. public class Server {
    7.     public static void main(String[] args) throws Exception {
    8.         System.out.println("服务端启动！");
    9.         //创建一个服务端对象
    10.         DatagramSocket socket = new DatagramSocket(6666);
    11.         //创建一个数据包对象
    12.         byte[] buffer = new byte[1024 * 64];
    13.         DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
    14.         //使用数据包来接受客户端发来的数据
    15.         socket.receive(packet);
    16.         //获取本次数据包接收的数据 接受多少打印出来
    17.         int len = packet.getLength();
    18.         String rs = new String(buffer, 0, len);
    19.         System.out.println(packet.getAddress().getHostAddress());
    20.         System.out.println(packet.getPort());
    21.         System.out.println(rs);
    22.     }
    23. }

    多次发送，多次接收

    1. package learn14;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5.  
    6. public class Server {
    7.     public static void main(String[] args) throws Exception {
    8.         System.out.println("服务端启动！");
    9.         //创建一个服务端对象
    10.         DatagramSocket socket = new DatagramSocket(6666);
    11.         //创建一个数据包对象
    12.         byte[] buffer = new byte[1024 * 64];
    13.         DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
    14.         //使用数据包来接受客户端发来的数据
    15.         while (true) {
    16.             socket.receive(packet);
    17.             //获取本次数据包接收的数据 接受多少打印出来
    18.             int len = packet.getLength();
    19.             String rs = new String(buffer, 0, len);
    20.             System.out.println(rs);
    21.             System.out.println(packet.getAddress().getHostAddress());
    22.             System.out.println(packet.getPort());
    23.         }
    24.     }
    25. }
    1. package learn14;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5. import java.net.InetAddress;
    6. import java.util.Scanner;
    7.  
    8. public class Client {
    9.     public static void main(String[] args) throws Exception {
    10.         //创建客户端对象 (发数据)
    11.         DatagramSocket socket = new DatagramSocket();
    12.         //创建数据包对象封装要发出去的数据
    13.         Scanner sc = new Scanner(System.in);
    14.         while (true) {
    15.             System.out.println("请说：");
    16.             String msg = sc.nextLine();
    17.             if ("exit".equals(msg)) {
    18.                 System.out.println("欢迎下次光临");
    19.                 socket.close();
    20.                 break;
    21.             }
    22.             byte[] bytes = msg.getBytes();
    23.             DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getLocalHost(), 6666);
    24.             socket.send(packet);
    25.         }
    26.  
    27.     }
    28. }

    需要配置下，多开几个客户端

    需要注意，端口号需要随机分配，否则会有以下报错

    TCP通信

    一次发送，一次接收

    1. package learn14;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6.  
    7. public class ClientTCP {
    8.     public static void main(String[] args) throws Exception {
    9.         //创建Socket对象
    10.         Socket socket = new Socket("127.0.0.1", 8888);
    11.         //从socket通信管道中得到一个字节输出流，用来发送数据给服务程序
    12.         OutputStream os = socket.getOutputStream();
    13.         //把低级的字节输出流包装成数据输出流
    14.         DataOutputStream dos = new DataOutputStream(os);
    15.         //写入数据
    16.         dos.writeUTF("hello!!!");
    17.         //释放连接资源
    18.         dos.close();
    19.         socket.close();
    20.     }
    21. }
    1. package learn14;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.net.ServerSocket;
    7. import java.net.Socket;
    8.  
    9. public class ServerTCP {
    10.     public static void main(String[] args) throws Exception {
    11.         System.out.println("服务端启动成功");
    12.         //创建ServerSocket对象
    13.         ServerSocket serverSocket = new ServerSocket(8888);
    14.         //使用ServerSocket对象
    15.         Socket socket = serverSocket.accept();
    16.         //从socket通信管道得到一个字节输入流
    17.         InputStream is = socket.getInputStream();
    18.         //把原始的字节输入流包装成数据输入流
    19.         DataInputStream dis = new DataInputStream(is);
    20.         //使用数据输入流读取客户端发送的消息
    21.         String rs = dis.readUTF();
    22.         System.out.println(rs);
    23.  
    24.         System.out.println(socket.getRemoteSocketAddress());
    25.         dis.close();
    26.         socket.close();
    27.     }
    28. }

    多次发送，多次接收

    1. package learn14;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7.  
    8. public class ClientTCP {
    9.     public static void main(String[] args) throws Exception {
    10.         //创建Socket对象
    11.         Socket socket = new Socket("127.0.0.1", 8888);
    12.         //从socket通信管道中得到一个字节输出流，用来发送数据给服务程序
    13.         OutputStream os = socket.getOutputStream();
    14.         //把低级的字节输出流包装成数据输出流
    15.         DataOutputStream dos = new DataOutputStream(os);
    16.         Scanner sc = new Scanner(System.in);
    17.         //写入数据
    18.         while (true) {
    19.             System.out.println("请说：");
    20.             String msg = sc.nextLine();
    21.             if ("exit".equals(msg)) {
    22.                 System.out.println("退出成功，欢迎下次光临！");
    23.                 dos.close();
    24.                 socket.close();
    25.                 break;
    26.             }
    27.             dos.writeUTF(msg);
    28.             dos.flush();
    29.         }
    30.     }
    31. }
    1. package learn14;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.net.ServerSocket;
    7. import java.net.Socket;
    8.  
    9. public class ServerTCP {
    10.     public static void main(String[] args) throws Exception {
    11.         System.out.println("服务端启动成功");
    12.         //创建ServerSocket对象
    13.         ServerSocket serverSocket = new ServerSocket(8888);
    14.         //使用ServerSocket对象
    15.         Socket socket = serverSocket.accept();
    16.         //从socket通信管道得到一个字节输入流
    17.         InputStream is = socket.getInputStream();
    18.         //把原始的字节输入流包装成数据输入流
    19.         DataInputStream dis = new DataInputStream(is);
    20.         //使用数据输入流读取客户端发送的消息
    21.         while (true) {
    22.             try {
    23.                 String rs = dis.readUTF();
    24.                 System.out.println(rs);
    25.                 System.out.println(socket.getRemoteSocketAddress());
    26.             } catch (IOException e) {
    27.                 System.out.println(socket.getRemoteSocketAddress() + "离线了");
    28.                 dis.close();
    29.                 socket.close();
    30.                 break;
    31.             }
    32.         }
    33.     }
    34. }

    多个客户端同时通信

    1. package learn14;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.InputStream;
    5. import java.net.Socket;
    6.  
    7. public class ServerReaderThead extends Thread {
    8.     private Socket socket;
    9.  
    10.     public ServerReaderThead(Socket socket) {
    11.         this.socket = socket;
    12.     }
    13.  
    14.     @Override
    15.     public void run() {
    16.         try {
    17.             InputStream is = socket.getInputStream();
    18.             DataInputStream dis = new DataInputStream(is);
    19.             while (true) {
    20.                 try {
    21.                     String msg = dis.readUTF();
    22.                     System.out.println(msg);
    23.                 } catch (Exception e) {
    24.                     System.out.println("有客户端下线了：" + socket.getRemoteSocketAddress());
    25.                     dis.close();
    26.                     socket.close();
    27.                     break;
    28.                 }
    29.             }
    30.         } catch (Exception e) {
    31.             e.printStackTrace();
    32.         }
    33.     }
    34. }
    1. package learn14;
    2.  
    3. import java.net.ServerSocket;
    4. import java.net.Socket;
    5.  
    6. public class ServerTCP {
    7.     public static void main(String[] args) throws Exception {
    8.         System.out.println("服务端启动成功");
    9.         //创建ServerSocket对象
    10.         ServerSocket serverSocket = new ServerSocket(8888);
    11.         //使用ServerSocket对象
    12.         while (true) {
    13.             Socket socket = serverSocket.accept();
    14.             System.out.println("客户端上线了："+socket.getRemoteSocketAddress());
    15.             //将通信管道交给独立的线程处理
    16.             new ServerReaderThead(socket).start();
    17.         }
    18.     }
    19. }
    1. package learn14;
    2.  
    3. import java.io.DataOutputStream;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7.  
    8. public class ClientTCP {
    9.     public static void main(String[] args) throws Exception {
    10.         //创建Socket对象
    11.         Socket socket = new Socket("127.0.0.1", 8888);
    12.         //从socket通信管道中得到一个字节输出流，用来发送数据给服务程序
    13.         OutputStream os = socket.getOutputStream();
    14.         //把低级的字节输出流包装成数据输出流
    15.         DataOutputStream dos = new DataOutputStream(os);
    16.         Scanner sc = new Scanner(System.in);
    17.         //写入数据
    18.         while (true) {
    19.             System.out.println("请说：");
    20.             String msg = sc.nextLine();
    21.             if ("exit".equals(msg)) {
    22.                 System.out.println("退出成功，欢迎下次光临！");
    23.                 dos.close();
    24.                 socket.close();
    25.                 break;
    26.             }
    27.             dos.writeUTF(msg);
    28.             dos.flush();
    29.         }
    30.     }
    31. }

  • 相关阅读:
    树大总结（王道+红皮书）
    TensorDataset和DataLoader使用
    python爬虫之feapder.AirSpider轻量爬虫案例：豆瓣
    机器学习开源工具BatteryML，一站式分析与预测电池性能
    安装 Ubuntu 桌面服务与谷歌浏览器
    Spring Cloud Alibaba+saas企业架构技术选型+架构全景业务图 + 架构典型部署方案
    Redis 篇
    [Ext JS]图片显示方式
    TikTok达人解锁的条件
    CH9101国产USB转异步串口芯片兼容替代PL2303GC/PL2303HXD/FT230X/FT232RQ/CY7C65213
  • 原文地址：https://blog.csdn.net/MRJJ_9/article/details/133198179