• 网络编程,UDP通信程序,TCP通信程序

    一、网络编程

    网络编程概述

    网络编程 :

            在网络[通信协议]下，不同计算机上运行的程序，可以进行[数据传输]

     

    思考：      

             A电脑中的QQ，发送消息给B电脑中的QQ。那么需要知道[哪些条件]才能发送？ 

                                                                           

                       在这个故事场景下，你要怎么样才能找到这个女孩并把钱取出来？      

     第一步：

              你要先找到这家银行，也就是银行的地址

     第二步：

              找到这个女孩在几号柜台工作

    第三步：

              按照银行的规则，填写取款单 

     在这个小故事中，找到这个女孩并成功取钱的要素有哪些？

    银行的地址                            ---- 银行的地址

    柜台号                                   ---- 通过柜台跟客户交流并处理业务

    填写取款单的规则                 ----填写取款单的规则

     网咯通信的关键三要素：

    IP地址：

            设备在网络中的地址，是唯一的标识。

    端口：

            应用程序在设备中唯一的标识。

    协议：

            数据在[网络中传输]的规则，常见的协议有UDP协议和TCP协议。

    IP

    IP：全称”互联网协议地址”，也称IP地址。是分配给上网设备的数字标签。常见的IP分类为：ipv4和ipv6

    IP域名:                                                                                                                                                

    IP地址： 

     IPv4：

    IPv6：

    由于互联网的蓬勃发展，IP地址的需求量愈来愈大，而IPv4的模式下[IP的总数]是有限的。

                  采用128位地址长度，分成8组。

     常用命令：

    ipconfig：查看本机IP地址

    ping { IP地址 }：检查网络是否连通

     特殊IP地址：

    127.0.0.1：是回送地址也称本地回环地址，可以代表本机的IP地址，一般用来测试使用

    总结：

            1.网络通信至少需要的元素：IP、端口、协议

            2.IP地址是做什么的：定位网络上的设备的，有IPv4和IPv6

            3.查看本机IP地址：ipconfig 查看是否与对方互通：【ping+IP】地址；例如：192.168.10.23

    加一个ipv4的分类,需要讲A-E,IP组成为:网络号 + 主机号 广域网 城域网 局域网

    最大的广域网是因特网  

    添加组播地址,广地址

    InetAddress： 代表IP地址               

    InetAddress 的使用:

    • 为了方便我们对IP地址的获取和操作，Java提供了一个类[InetAddress] 供我们使用
    • InetAddress：此类表示Internet协议（IP）地址

    方法名

    说明

    static InetAddress getByName​(String host)

    确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址

    String getHostName​()

    获取此IP地址的主机名

    String getHostAddress​()

    返回文本显示中的IP地址字符串

    1. package com.socketmodule.socketdemo1;
    2.  
    3. import java.net.InetAddress;
    4. import java.net.UnknownHostException;
    5.  
    6. //static InetAddress getByName(String host)
    7. //                          确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
    8. //String getHostName()     获取此IP地址的主机名
    9. //String getHostAddress()  返回文本显示中的IP地址字符串
    10. public class InetadressDemo1 {
    11.     public static void main(String[] args) throws UnknownHostException {
    12.         //getByName(String host)确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
    13.         InetAddress address = InetAddress.getByName("沉迷代码");
    14.         //String getHostName()     获取此IP地址的主机名
    15.         String hostName = address.getHostName();
    16.         System.out.println("主机名为" + hostName);
    17.         //String getHostAddress()  返回文本显示中的IP地址字符串
    18.         String ip = address.getHostAddress();
    19.         System.out.println("IP为" + ip);
    20.     }
    21. }

     

    端口 ：应用程序在设备中唯一的标识。

    • 标记正在计算机设备上运行的应用程序，被规定为一个16位的二进制，范围是0~65535。

    分类：

    • 周知端口：0~1023，被预先定义的知名应用占用（如：HTTP占用80，FTP占用21）
    • 注册端口：1024~49151，分配给用户进程或某些应用程序。
    • 动态端口：49152~65535，之所以称为动态端口，是因为它一般不固定分配某种进程，而是动态分配。

     端口号：用两个字节表示的整数，它的取值范围是0~65535。

    • 其中0~1023之间的端口号用于一些知名的网络服务或者应用。
    •  我们自己使用1024以上的端口号就可以了。

     注意：一个端口号只能被一个应用程序使用。

     协议：       计算机网络中，连接和通信的规则被称为网络通信协议

    通信协议：

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

    协议：

    开放式网络互连标准：OSI网络参考模型：

    OSI网络参考模型：全球 网络互联标准

    TCP/IP网络模型：事实上的国际标准

    UDP协议：

    •         用户数据报协议(User Datagram Protocol)
    •         UDP是面向无连接通信协议。(音频,视频,普通数据会使用用UDP,因为速度快,丢失一些数据没有太大的影响)

    •   速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据。 

    TCP协议 ：

    •         传输控制协议 (Transmission Control Protocol)
    •         TCP协议是面向连接的通信协议。
    •         速度慢，没有大小限制，数据安全。

     三次握手：目的是确认通信双方，收发消息都是正常没问题的 

      TCP协议：三次握手建立可靠连接 

    四次挥手：目的是确保双方数据的收发已经完成，没有数据丢失  

    TCP协议：四次握手断开连接

    小结： 

    • 网络编程：就是可以让[两台计算机]进行[数据交互]。

    网络编程三要素：

    •      IP：设备在网络中唯一的标识。  
    •      端口号：应用程序在设备中唯一的标识。
    •      协议：数据在传输过程中遵守的规则。

    总结：                  

    通讯协议是：

    • 计算机中，连接和通信数据的规则被称为网络通信协议。 

    TCP通信协议的特点：

    • 它是一种面向连接的可靠的通信协议。
    • 传输前：采用“三次握手”方式建立连接，点对点的通信，所以可靠。
    • 在连接中课进行大数据量的传输。
    • 通信效率较低

    UDP协议的特点是：

    • 用户数据报协议（User Datagram Protocol）
    • UDP是面向无连接，不可靠传输的通信协议。
    • 速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据。  

    UDP通信程序：

    DatagramSocket：用于创建客户端，服务端：

    DatagramPacket：创建数据包：

    UDP发送数据：

             发送礼物的步骤：

    1. package com.socketmodule.socketdemo2;
    2.  
    3.  
    4. import java.io.IOException;
    5. import java.net.*;
    6.  
    7. public class ClientDemo {
    8.     public static void main(String[] args) throws IOException {
    9.         //1.找码头
    10.         DatagramSocket ds = new DatagramSocket();
    11.         //2.打包礼物
    12.         //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
    13.         String s = "送给村长老丈人的礼物";
    14.         byte[] bytes = s.getBytes();
    15.         InetAddress address = InetAddress.getByName("127.0.0.1");
    16.         int port = 10000;
    17.         DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
    18.  
    19.  
    20.         //3.由码头发送包裹
    21.         ds.send(dp);
    22.  
    23.         //4.付钱走羊
    24.         ds.close();
    25.     }
    26. }

    UDP接收数据： 

    1. package com.socketmodule.socketdemo2;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6.  
    7. public class ServerDemo {
    8.     //注意点:
    9.         //1.要先运行接收端,再运行发送端
    10.         //2.如果接收端再启动之后,没有接收到数据,那么会死等(阻塞).
    11.         //3.在接收数据的时候,需要调用一个getLength方法,表示接收到了多少字节
    12.     public static void main(String[] args) throws IOException {
    13.         //1.找码头     ---- 表示接收端从10000端口接收数据的.
    14.         DatagramSocket ds = new DatagramSocket(10000);
    15.         //2,创建一个新的箱子
    16.         byte [] bytes = new byte[1024];
    17.         DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
    18.         //3.接收礼物,把礼物放到新的箱子中
    19.         System.out.println("-----------接收前----------");
    20.         ds.receive(dp);
    21.         System.out.println("------------接收后---------");
    22.         //4.从新的箱子里面获取礼物
    23.        // byte[] data = dp.getData();
    24.         int length = dp.getLength();
    25.         System.out.println(new String(bytes,0,length));
    26.         //5.拿完走羊
    27.         ds.close();
    28.     }
    29. }

    总结：

     

    接收端可以反复接收数据 

    步骤：

    1. package com.socketmodule.socketdemo3;
    2.  
    3. import java.io.IOException;
    4. import java.net.*;
    5. import java.util.Scanner;
    6.  
    7. public class ClientDemo {
    8.     public static void main(String[] args) throws IOException {
    9.         Scanner sc = new Scanner(System.in);
    10.         DatagramSocket ds = new DatagramSocket();
    11.         while (true) {
    12.             String s = sc.nextLine();
    13.             if("886".equals(s)){
    14.                 break;
    15.             }
    16.             byte[] bytes = s.getBytes();
    17.             InetAddress address = InetAddress.getByName("127.0.0.1");
    18.             int port = 10000;
    19.             DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
    20.  
    21.             ds.send(dp);
    22.         }
    23.  
    24.         ds.close();
    25.     }
    26. }
    1. package com.socketmodule.socketdemo3;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6.  
    7. public class ServerDemo {
    8.     public static void main(String[] args) throws IOException {
    9.         DatagramSocket ds = new DatagramSocket(10000);
    10.  
    11.         while (true) {
    12.             byte [] bytes = new byte[1024];
    13.             DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
    14.  
    15.             ds.receive(dp);
    16.  
    17.             byte[] data = dp.getData();
    18.             int length = dp.getLength();
    19.  
    20.             System.out.println(new String(data,0,length));
    21.         }
    22.  
    23.        // ds.close();
    24.     }
    25. }

     UDP的三种通信方式

            单播

            组播

            广播

     

     UDP通信组播代码实现

     组播地址：224.0.0.0 ~ 239.255.255.255  

                   其中224.0.0.0 ~ 224.0.0.255 为预留的组播地址

    单播的发送端

      ①创建发送端的Socket对象(DatagramSocket) 

    广播地址：255.255.255.255 

    1. package com.socketmodule.socketdemo4;
    2.  
    3. import java.io.IOException;
    4. import java.net.*;
    5.  
    6. public class ClinetDemo {
    7.     public static void main(String[] args) throws IOException {
    8.         DatagramSocket ds = new DatagramSocket();
    9.  
    10.         String s = "hello 组播";
    11.         byte[] bytes = s.getBytes();
    12.         InetAddress address = InetAddress.getByName("224.0.1.0");
    13.         int port = 10000;
    14.         DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
    15.  
    16.         ds.send(dp);
    17.  
    18.         ds.close();
    19.     }
    20. }
    1. package com.socketmodule.socketdemo4;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.InetAddress;
    6. import java.net.MulticastSocket;
    7.  
    8. public class ServerDemo {
    9.     public static void main(String[] args) throws IOException {
    10.         MulticastSocket ms = new MulticastSocket(10000);
    11.  
    12.         DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
    13.  
    14.  
    15.         //把当前计算机绑定一个组播地址,表示添加到这一组中.
    16.         ms.joinGroup(InetAddress.getByName("224.0.1.0"));
    17.  
    18.  
    19.         ms.receive(dp);
    20.  
    21.         byte[] data = dp.getData();
    22.         int length = dp.getLength();
    23.         System.out.println(new String(data,0,length));
    24.  
    25.         ms.close();
    26.     }
    27. }

     二、TCP通信程序：     

     

    TCP通信原理    

    TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象。

    通信之前要保证连接已经建立。

    通过Socket产生IO流来进行网络通信。

    TCP基于IO流,与UDP不区别(不需要整包)

     TCP发送数据步骤

    发送数据的步骤:

    ①创建客户端的Socket对象(Socket)与指定服务端连接

            Socket​(String host, int port)

    ②获取输出流，写数据

            OutputStream getOutputStream​()

    ③释放资源

             void close​()

     TCP接收数据

    接收数据的步骤:

    ①创建服务器端的Socket对象(ServerSocket)

    ②获取输入流，读数据，并把数据显示在控制台

    ③释放资源

    接收数据的步骤 :

    ①创建服务器端的Socket对象(ServerSocket)

            ServerSocket​(int port)

    ②监听客户端连接，返回一个Socket对象

             Socket accept​()

    ③获取输入流，读数据，并把数据显示在控制台

             InputStream getInputStream​()

    ④释放资源

            void close​()

    1. package com.socketmodule.socketdemo6;
    2.  
    3. import java.io.IOException;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6.  
    7. public class ClientDemo {
    8.     public static void main(String[] args) throws IOException {
    9.         //1,创建一个Socket对象
    10.         Socket socket = new Socket("127.0.0.1",10000);
    11.  
    12.         //2.获取一个IO流开始写数据
    13.         OutputStream os = socket.getOutputStream();
    14.         os.write("hello".getBytes());
    15.  
    16.         /*while(true){
    18.         }*/
    19.         //3.释放资源
    20.         os.close();
    21.         socket.close();
    22.     }
    23. }
    1. package com.socketmodule.socketdemo6;
    2.  
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7.  
    8. public class ServerDemo {
    9.     public static void main(String[] args) throws IOException {
    10.         //1. 创建Socket对象
    11.         ServerSocket ss = new ServerSocket(10000);
    12.         //2. 等待客户端连接
    13.         System.out.println(111);
    14.         Socket accept = ss.accept();
    15.         System.out.println(222);
    16.         //3.获得输入流对象
    17.         InputStream is = accept.getInputStream();
    18.         int b;
    19.         while((b = is.read()) != -1){
    20.             System.out.print((char) b);
    21.         }
    22.  
    23.         System.out.println("看看我执行了吗?");
    24.  
    25.         //4.释放资源
    26.         is.close();
    27.         ss.close();
    28.     }
    29. }

     

    TCP发送数据原理 

    发送数据的步骤:

     三次握手

     三次握手

    四次挥手 

    四次挥手

    TCP单发：

     

     TCP多发：

     

     

     

     

     

    TCP通信程序练习

    客户端：发送数据，接收服务器反馈

    服务器：接收数据，给出反馈 

     TCP通信原理

    TCP通信程序练习 

    客户端：将本地文件上传到服务器。接收服务器的反馈。

    服务器：接收客户端上传的文件，上传完毕之后给出反馈。

     

    1. package com.socketmodule.socketdemo7;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5.  
    6. public class ClientDemo {
    7.     public static void main(String[] args) throws IOException {
    8.         Socket socket = new Socket("127.0.0.1",35729);
    9.  
    10.         OutputStream os = socket.getOutputStream();
    11.         os.write("hello".getBytes());
    12.        // os.close();如果在这里关流,会导致整个socket都无法使用
    13.         socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响
    14.  
    15.  
    16.         /*InputStream is = socket.getInputStream();
    17.         int b;
    18.         while((b = is.read()) !=-1){
    19.             System.out.println((char) b);
    20.         }*/
    21.  
    22.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    23.         String line;
    24.         while((line = br.readLine())!=null){
    25.             System.out.println(line);
    26.         }
    27.         br.close();
    28.         os.close();
    29.         socket.close();
    30.     }
    31. }
    32.  
    33.  
    34. h
    35. e
    36. l
    37. l
    38. o
    39. 看看我执行了吗?
    40.  
    41. Process finished with exit code 0
    42.  
    43. ------------------------------------------
    44.  
    45.  
    46. package com.socketmodule.socketdemo7;
    47.  
    48. import java.io.*;
    49. import java.net.ServerSocket;
    50. import java.net.Socket;
    51.  
    52. public class ServerDemo {
    53.     public static void main(String[] args) throws IOException {
    54.         ServerSocket ss = new ServerSocket(35729);
    55.  
    56.         Socket accept = ss.accept();
    57.  
    58.         InputStream is = accept.getInputStream();
    59.         int b;
    60.         while((b = is.read())!=-1){
    61.             System.out.println((char) b);
    62.         }
    63.  
    64.         System.out.println("看看我执行了吗?");
    65.        /* OutputStream os = accept.getOutputStream();
    66.         os.write("你谁啊?".getBytes());*/
    67.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
    68.         bw.write("你谁啊?");
    69.         bw.newLine();
    70.         bw.flush();
    71.  
    72.         bw.close();
    73.         is.close();
    74.         accept.close();
    75.         ss.close();
    76.     }
    77. }
    78.  
    79. 你谁啊?
    80.  
    81. Process finished with exit code 0

    可见: TCP做聊天要比UDP麻烦一些

    TCP通信 

    1. package com.socketmodule.socketdemo8;
    2.  
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6.  
    7. public class ServerDemo {
    8.     public static void main(String[] args) throws IOException {
    9.         ServerSocket ss = new ServerSocket(35729);
    10.  
    11.         Socket accept = ss.accept();
    12.  
    13.         //网络中的流,从客户端读取数据的
    14.         BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
    15.         //本地的IO流,把数据写到本地中,实现永久化存储
    16.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day14\\ServerDir\\copy.jpg"));
    17.  
    18.         int b;
    19.         while((b = bis.read()) !=-1){
    20.             bos.write(b);
    21.         }
    22.         //将字节输入流FileInputStream   转成     字符输入流  Fliereader
    23.  
    24.         //通过转换流
    25.         InputStreamReader inputStreamReader = new InputStreamReader(accept.getInputStream());
    26.  
    27.         //通过缓冲输入字符流
    28.         BufferedReader br = new BufferedReader(inputStreamReader);
    29.  
    30.  
    31.         OutputStreamWriter outputStreamWriter = new OutputStreamWriter(accept.getOutputStream());
    32.         BufferedWriter bw = new BufferedWriter(outputStreamWriter);
    33.         bw.write("上传成功");
    34.         bw.newLine();
    35.         bw.flush();
    36.  
    37.         bos.close();
    38.         accept.close();
    39.         ss.close();
    40.  
    41.  
    42.     }
    43. }
    44.  
    45.  
    46. --------
    47.  
    48. package com.socketmodule.socketdemo8;
    49.  
    50. import java.io.*;
    51. import java.net.Socket;
    52.  
    53. public class ClientDemo {
    54.     public static void main(String[] args) throws IOException {
    55.         Socket socket = new Socket("127.0.0.1",35729);
    56.  
    57.         //是本地的流,用来读取本地文件的.
    58.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day14\\ClientDir\\1.jpg"));
    59.  
    60.         //写到服务器 --- 网络中的流
    61.         OutputStream os = socket.getOutputStream();
    62.         BufferedOutputStream bos = new BufferedOutputStream(os);
    63.  
    64.         int b;
    65.         while((b = bis.read())!=-1){
    66.             bos.write(b);//通过网络写到服务器中
    67.         }
    68.         bos.flush();
    69.         //给服务器一个结束标记,告诉服务器文件已经传输完毕
    70.         socket.shutdownOutput();
    71.  
    72.  
    73.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    74.         String line;
    75.         while((line = br.readLine()) !=null){
    76.             System.out.println(line);
    77.         }
    78.         bis.close();
    79.         socket.close();
    80.  
    81.  
    82.     }
    83. }

  • 相关阅读:
    【英语：语法基础】C1.日常对话-自我介绍
    从零开始：使用 Kubernetes 部署 Nginx 应用
    C++模板与STL（六）：内存空间配置器及内存池技术模拟
    Windows Server安全配置
    【PostgreSQL】日期操作
    Liunx文件目录操作命令（cd、pwd、ls、mkdir、rmdir）
    Python中list列表的常见操作
    国内机器人编程赛事大全介绍
    UE5.4新功能 - MotionDesign上手简介
    Redis的RDB与AOF持久化机制
  • 原文地址：https://blog.csdn.net/weixin_46589095/article/details/128157351