Java基础(二十四):网络编程

06-01 1270阅读

目录

  • 一、网络通信要素
    • 1、通信要素一:IP地址和域名
      • 1.1、IP地址
      • 1.2、域名
      • 2、通信要素二:端口号
      • 3、通信要素三:网络通信协议
      • 二、传输层协议:TCP与UDP协议
        • 1、TCP协议
        • 2、UDP协议
        • 3、三次握手
        • 4、四次挥手
        • 三、网络编程API
          • 1、InetAddress类
          • 2、Socket类
          • 3、TCP编程
          • 4、UDP编程
          • 5、URL编程

            一、网络通信要素

            1、通信要素一:IP地址和域名

            1.1、IP地址

            • IP地址:指互联网协议地址(Internet Protocol Address),俗称IP
            • IP地址用来给网络中的一台计算机设备做唯一的编号

              IP地址分类方式一

              • IPv4:是一个32位的二进制数,通常被分为4个字节
              • 表示成a.b.c.d 的形式,以点分十进制表示,例如192.168.65.100
              • 其中a、b、c、d都是0~255之间的十进制整数

                Java基础(二十四):网络编程

                • 这种方式最多可以表示42亿个。其中,30亿都在北美,亚洲4亿,中国2.9亿。2011年初已经用尽
                • IP地址 = 网络地址 +主机地址
                  • 网络地址:标识计算机或网络设备所在的网段
                  • 主机地址:标识特定主机或网络设备

                    Java基础(二十四):网络编程

                    • IPv6:为了扩大地址空间,拟通过IPv6重新定义地址空间,采用128位地址长度,共16个字节
                    • 8个无符号整数,每个整数用四个十六进制位表示,数之间用冒号:分开。比如:ABCD:EF01:2345:6789:ABCD:EF01:2345:6789

                      IP地址分类方式二

                      • 公网地址( 万维网使用)和 私有地址( 局域网使用)

                        1.2、域名

                        • Internet上的主机有两种方式表示地址:
                          • 域名(hostName):www.baidu.com
                          • IP 地址(hostAddress):202.108.35.210
                          • 域名解析:因为IP地址数字不便于记忆,因此出现了域名
                            • 域名容易记忆,当在连接网络时输入一个主机的域名后
                            • 域名服务器(DNS,Domain Name System,域名系统)负责将域名转化成IP地址

                              简单理解:

                              Java基础(二十四):网络编程

                              2、通信要素二:端口号

                              • 如果说IP地址可以唯一标识网络中的设备,那么端口号就可以唯一标识设备中的进程(应用程序)
                              • 不同的进程,设置不同的端口号
                              • 端口号:用两个字节表示的整数,它的取值范围是0~65535
                                • 公认端口:0~1023。被预先定义的服务通信占用,如:HTTP(80),FTP(21),Telnet(23)
                                • 注册端口:1024~49151。分配给用户进程或应用程序。如:Tomcat(8080),MySQL(3306),Oracle(1521)
                                • 动态/ 私有端口:49152~65535
                                • 如果端口号被另外一个服务或应用所占用,会导致当前程序启动失败

                                  3、通信要素三:网络通信协议

                                  • 网络通信协议:在计算机网络中,这些连接和通信的规则被称为网络通信协议
                                    • 它对数据的传输格式、传输速率、传输步骤、出错控制等做了统一规定
                                    • 通信双方必须同时遵守才能完成数据交换
                                    • 这里有两套参考模型:
                                      • OSI参考模型:模型过于理想化,未能在因特网上进行广泛推广
                                      • TCP/IP参考模型(或TCP/IP协议):事实上的国际标准

                                        Java基础(二十四):网络编程

                                        • TCP/IP协议: 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol),TCP/IP 以其两个主要协议:传输控制协议(TCP)和网络互联协议(IP)而得名

                                          Java基础(二十四):网络编程

                                          TCP/IP协议中的四层介绍:

                                          • 应用层:应用层决定了向用户提供应用服务时通信的活动。主要协议有:HTTP协议、FTP协议、SNMP(简单网络管理协议)、SMTP(简单邮件传输协议)和POP3(Post Office Protocol 3的简称,即邮局协议的第3个版)等
                                          • 传输层:主要使网络程序进行通信,在进行网络通信时,可以采用TCP协议,也可以采用UDP协议。TCP(Transmission Control Protocol)协议,即传输控制协议,是一种面向连接的、可靠的、基于字节流的传输层通信协议。UDP(User Datagram Protocol,用户数据报协议):是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务
                                          • 网络层:网络层是整个TCP/IP协议的核心,支持网间互连的数据通信。它主要用于将传输的数据进行分组,将分组数据发送到目标计算机或者网络。而IP协议是一种非常重要的协议。IP(internet protocal)又称为互联网协议。IP的责任就是把数据从源传送到目的地。它在源地址和目的地址之间传送一种称之为数据包的东西,它还提供对数据大小的重新组装功能,以适应不同网络对包大小的要求
                                          • 物理+数据链路层:链路层是用于定义物理传输通道,通常是对某些网络连接设备的驱动协议,例如针对光纤、网线提供的驱动

                                            Java基础(二十四):网络编程

                                            二、传输层协议:TCP与UDP协议

                                            • java.net 包中提供了两种常见的网络协议的支持:
                                              • UDP:用户数据报协议(User Datagram Protocol)
                                              • TCP:传输控制协议 (Transmission Control Protocol)

                                                1、TCP协议

                                                • TCP协议进行通信的两个应用进程:客户端、服务端
                                                • 使用TCP协议前,须先建立TCP连接,形成基于字节流的传输数据通道
                                                • 传输前,采用“三次握手”方式,点对点通信,是可靠的
                                                  • TCP协议使用重发机制,当一个通信实体发送一个消息给另一个通信实体后,需要收到另一个通信实体确认信息
                                                  • 如果没有收到另一个通信实体确认信息,则会再次重复刚才发送的消息
                                                  • 在连接中可进行大数据量的传输
                                                  • 传输完毕,需释放已建立的连接,效率低
                                                  • 适用场景:打电话

                                                    2、UDP协议

                                                    • UDP协议进行通信的两个应用进程:发送端、接收端
                                                    • 将数据、源、目的封装成数据包(传输的基本单位),不需要建立连接
                                                    • 发送不管对方是否准备好,接收方收到也不确认,不能保证数据的完整性,故是不可靠的
                                                    • 每个数据报的大小限制在64K内
                                                    • 发送数据结束时无需释放资源,开销小,通信效率高
                                                    • 适用场景:音频、视频和普通数据的传输。例如视频会议

                                                      3、三次握手

                                                      • TCP协议中,在发送数据的准备阶段,客户端与服务器之间的三次交互,以保证连接的可靠
                                                        • 第一次握手,客户端向服务器端发起TCP连接的请求(客户端请求连接)
                                                        • 第二次握手,服务器端发送针对客户端TCP连接请求的确认(服务端收到)
                                                        • 第三次握手,客户端发送确认的确认 (客户端知道服务端收到了)

                                                          Java基础(二十四):网络编程

                                                          4、四次挥手

                                                          • TCP协议中,在发送数据结束后,释放连接时需要经过四次挥手
                                                            • 第一次挥手:客户端向服务器端提出结束连接,让服务器做最后的准备工作。此时,客户端处于半关闭状态,即表示不再向服务器发送数据了,但是还可以接受数据(客户端请求关闭)
                                                            • 第二次挥手:服务器接收到客户端释放连接的请求后,会将最后的数据发给客户端。并告知上层的应用进程不再接收数据(服务端收到)
                                                            • 第三次挥手:服务器发送完数据后,会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了(服务端请求关闭)
                                                            • 第四次挥手:客户端接收到服务器最后的释放连接报文后,要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端,发送完最后的报文后,会等待2MSL,因为有可能服务器没有收到最后的报文,那么服务器迟迟没收到,就会再次给客户端发送释放连接的报文,此时客户端在等待时间范围内接收到,会重新发送最后的报文,并重新计时。如果等待2MSL后,没有收到,那么彻底断开(客户端收到)

                                                              三、网络编程API

                                                              1、InetAddress类

                                                              • InetAddress类主要表示IP地址,两个子类:Inet4Address、Inet6Address
                                                              • InetAddress 类没有提供公共的构造器,而是提供了如下几个静态方法来获取InetAddress实例
                                                                • public static InetAddress getLocalHost()
                                                                • public static InetAddress getByName(String host)
                                                                • public static InetAddress getByAddress(byte[] addr)
                                                                • InetAddress 提供了如下几个常用的方法
                                                                  • public String getHostAddress() :返回IP地址字符串
                                                                  • public String getHostName() :获取此IP地址的主机名或者域名
                                                                    public class TestInetAddress {
                                                                        public static void main(String[] args) throws Exception {
                                                                            //1. 获取本机的InetAddress 对象
                                                                            InetAddress localHost = InetAddress.getLocalHost();
                                                                            System.out.println(localHost);//DESKTOP-S4MP84S/192.168.12.1
                                                                            //2. 根据指定主机名 获取 InetAddress对象
                                                                            InetAddress host1 = InetAddress.getByName("DESKTOP-S4MP84S");
                                                                            System.out.println("host1=" + host1);//DESKTOP-S4MP84S/192.168.12.1
                                                                            //3. 根据域名返回 InetAddress对象, 比如 www.baidu.com 对应
                                                                            InetAddress host2 = InetAddress.getByName("www.baidu.com");
                                                                            System.out.println("host2=" + host2);//www.baidu.com / 110.242.68.4
                                                                            //4. 通过 InetAddress 对象,获取对应的地址
                                                                            String hostAddress = host2.getHostAddress();//IP 110.242.68.4
                                                                            System.out.println("host2 对应的ip = " + hostAddress);//110.242.68.4
                                                                            //5. 通过 InetAddress 对象,获取对应的主机名/或者的域名
                                                                            String hostName = host2.getHostName();
                                                                            System.out.println("host2对应的主机名/域名=" + hostName); // www.baidu.com
                                                                        }
                                                                    }
                                                                    

                                                                    2、Socket类

                                                                    • 网络上具有唯一标识的IP地址和端口号组合在一起构成唯一能识别的标识符套接字(Socket)
                                                                    • 通信的两端都要有Socket,是两台机器间通信的端点
                                                                    • Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输
                                                                    • 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端
                                                                    • Socket分类:
                                                                      • 流套接字(stream socket):使用TCP提供可依赖的字节流服务
                                                                      • 数据报套接字(datagram socket):使用UDP提供“尽力而为”的数据报服务

                                                                        3、TCP编程

                                                                        通信模型

                                                                        Java基础(二十四):网络编程

                                                                        开发步骤

                                                                        服务端:

                                                                        • ServerSocket(int port) :创建一个服务器端套接字ServerSocket,并绑定到指定端口上。用于监听客户端的请求
                                                                        • 调用ServerSocket对象accept()方法:监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字对象Socket
                                                                        • 调用该Socket 类对象的 getOutputStream() 和 getInputStream () :获取输出流和输入流,开始网络数据的发送和接收
                                                                        • 关闭Socket 对象:客户端访问结束,关闭通信套接字

                                                                          客户端:

                                                                          • Socket(InetAddress address, int port):根据指定服务端的IP地址和端口号构造Socket类对象
                                                                            • 若服务器端响应,则建立客户端到服务器的通信线路
                                                                            • 若连接失败,会出现异常
                                                                            • 打开连接到Socket的输入/ 出流:使用 getInputStream()方法获得输入流,使用getOutputStream()方法获得输出流,进行数据传输
                                                                              • 通过输入流读取服务器放入线路的信息(但不能读取自己放入线路的信息)
                                                                              • 通过输出流将信息写入线路
                                                                              • 关闭Socket:断开客户端到服务器的连接,释放线路

                                                                                例子:从客户端发送文件给服务端,服务端保存到本地。并返回“发送成功”给客户端

                                                                                服务端:

                                                                                • ServerSocket对象可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
                                                                                • 当没有客户端连接9090端口时,程序会一直阻塞, 等待连接
                                                                                  @Test
                                                                                  public void server() throws IOException {
                                                                                      // 1. 创建ServerSocket
                                                                                      int port = 9090;
                                                                                      ServerSocket serverSocket = new ServerSocket(port);
                                                                                      // 2. 接收来自于客户端的socket:accept()
                                                                                      Socket socket = serverSocket.accept();
                                                                                      // 3. 通过Socket获取一个输入流
                                                                                      InputStream is = socket.getInputStream();
                                                                                      // 4. 创建File类的实例、FileOutputStream的实例
                                                                                      File file = new File("pic_copy2.jpg");
                                                                                      FileOutputStream fos = new FileOutputStream(file);
                                                                                      // 5. 读写过程
                                                                                      byte[] buffer = new byte[1024];
                                                                                      int len;
                                                                                      while ((len = is.read(buffer)) != -1) {
                                                                                          fos.write(buffer, 0, len);
                                                                                      }
                                                                                      System.out.println("数据接收完毕");
                                                                                      // 6. 服务端发送数据给客户端
                                                                                      OutputStream os = socket.getOutputStream();
                                                                                      os.write("你的图片很漂亮,我接收到了".getBytes());
                                                                                      // 7. 关闭相关的Socket和流
                                                                                      os.close();
                                                                                      fos.close();
                                                                                      is.close();
                                                                                      socket.close();
                                                                                      serverSocket.close();
                                                                                  }
                                                                                  

                                                                                  客户端:

                                                                                  • socket.shutdownOutput():客户端表明不再继续发送数据,否则对方读操作会一直处于阻塞状态
                                                                                    @Test
                                                                                    public void client() throws IOException {
                                                                                        // 1. 创建Socket
                                                                                        // 指明对方(即为服务器端)的ip地址和端口号
                                                                                        InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
                                                                                        int port = 9090;
                                                                                        Socket socket = new Socket(inetAddress, port);
                                                                                        // 2. 创建File的实例、FileInputStream的实例
                                                                                        File file = new File("pic.jpg");
                                                                                        FileInputStream fis = new FileInputStream(file);
                                                                                        // 3. 通过Socket,获取输出流
                                                                                        OutputStream os = socket.getOutputStream();
                                                                                        // 4. 读写数据
                                                                                        byte[] buffer = new byte[1024];
                                                                                        int len;
                                                                                        while ((len = fis.read(buffer)) != -1) {
                                                                                            os.write(buffer, 0, len);
                                                                                        }
                                                                                        System.out.println("数据发送完毕");
                                                                                        // 客户端表明不再继续发送数据,否则对方读操作会一直处于阻塞状态
                                                                                        socket.shutdownOutput();
                                                                                        // 5. 接收来着于服务器端的数据
                                                                                        InputStream is = socket.getInputStream();
                                                                                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
                                                                                        byte[] buffer1 = new byte[5];
                                                                                        int len1;
                                                                                        while ((len1 = is.read(buffer1)) != -1) {
                                                                                            baos.write(buffer1, 0, len1);
                                                                                        }
                                                                                        System.out.println(baos.toString());
                                                                                        // 6. 关闭Socket和相关的流
                                                                                        baos.close();
                                                                                        is.close();
                                                                                        os.close();
                                                                                        fis.close();
                                                                                        socket.close();
                                                                                    }
                                                                                    

                                                                                    4、UDP编程

                                                                                    通信模型

                                                                                    • UDP(User Datagram Protocol,用户数据报协议):是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务,类似于短信、视频通话
                                                                                    • UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境,数据报大小限制在64K以下

                                                                                      Java基础(二十四):网络编程

                                                                                      开发步骤

                                                                                      发送端:

                                                                                      • 创建DatagramSocket:默认使用系统随机分配端口号
                                                                                      • 创建DatagramPacket:将要发送的数据用字节数组表示,并指定要发送的数据长度,接收方的IP地址和端口号
                                                                                      • 调用DatagramSocket对象的send方法:发送数据报DatagramPacket对象
                                                                                      • 关闭DatagramSocket对象:发送端程序结束,关闭通信套接字

                                                                                        接收端:

                                                                                        • 创建DatagramSocket:指定监听的端口号
                                                                                        • 创建DatagramPacket:指定接收数据用的字节数组,起到临时数据缓冲区的效果,并指定最大可以接收的数据长度
                                                                                        • 调用DatagramSocket的receive方法 :接收数据报DatagramPacket对象
                                                                                        • 关闭DatagramSocket :接收端程序结束,关闭通信套接字

                                                                                          例子:从客户端发送文件给服务端,服务端保存到本地。并返回“发送成功”给客户端

                                                                                          发送端:

                                                                                          @Test
                                                                                          public void sender() throws Exception {
                                                                                              // 1. 创建DatagramSocket的实例
                                                                                              DatagramSocket ds = new DatagramSocket();
                                                                                              // 2. 将数据、目的地的ip,目的地的端口号都封装在DatagramPacket数据报中
                                                                                              InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
                                                                                              int port = 9090;
                                                                                              byte[] bytes = "我是发送端".getBytes(StandardCharsets.UTF_8);
                                                                                              DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, inetAddress, port);
                                                                                              // 发送数据
                                                                                              ds.send(packet);
                                                                                              ds.close();
                                                                                          }
                                                                                          

                                                                                          接收端:

                                                                                          @Test
                                                                                          public void receiver() throws IOException {
                                                                                              // 1. 创建DatagramSocket的实例
                                                                                              int port = 9090;
                                                                                              DatagramSocket ds = new DatagramSocket(port);
                                                                                              // 2. 创建数据报的对象,用于接收发送端发送过来的数据
                                                                                              byte[] buffer = new byte[1024 * 64];
                                                                                              DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
                                                                                              // 3. 接收数据
                                                                                              ds.receive(packet);
                                                                                              // 4.获取数据,并打印到控制台上
                                                                                              String str = new String(packet.getData(), 0, packet.getLength());
                                                                                              System.out.println(str);
                                                                                              ds.close();
                                                                                          }
                                                                                          

                                                                                          5、URL编程

                                                                                          • URL(Uniform Resource Locator):统一资源定位符,它表示Internet上某一资源的地址
                                                                                            • 通过URL我们可以访问 Internet 上的各种网络资源,比如最常见的 www,ftp 站点
                                                                                            • 浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源
                                                                                            • URL的基本结构由5部分组成:://:/#片段名?参数列表
                                                                                            • URL类常用方法
                                                                                              • public final InputStream openStream():读取资源的数据
                                                                                              • public String getProtocol( ):获取该URL的协议名
                                                                                              • public String getHost( ):获取该URL的IP地址
                                                                                              • public String getPort( ):获取该URL的端口号
                                                                                              • public String getPath( ):获取该URL的文件路径
                                                                                              • public String getFile( ):获取该URL的文件名
                                                                                                @Test
                                                                                                public void test1() throws MalformedURLException {
                                                                                                    URL url = new URL("http://localhost:8080/examples/myTest.txt");
                                                                                                    System.out.println("协议 :" + url.getProtocol());
                                                                                                    System.out.println("ip地址 :" + url.getHost());
                                                                                                    System.out.println("端口 :" + url.getPort());
                                                                                                    System.out.println("文件路径 :" + url.getPath());
                                                                                                    System.out.println("文件名 :" + url.getFile());
                                                                                                    // 拷贝文件到指定目录
                                                                                                    InputStream inputStream = url.openStream();
                                                                                                    IOUtils.copy(inputStream, new FileOutputStream("/Users/xuchang/Documents/test.txt"));
                                                                                                }
                                                                                                

                                                                                                输出结果:

                                                                                                协议 :http
                                                                                                ip地址 :localhost
                                                                                                端口 :8080
                                                                                                文件路径 :/examples/myTest.txt
                                                                                                文件名 :/examples/myTest.txt
                                                                                                
免责声明:我们致力于保护作者版权,注重分享,被刊用文章因无法核实真实出处,未能及时与作者取得联系,或有版权异议的,请联系管理员,我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明:本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度,360,搜狗等多加搜索引擎自动关键词搜索配图,如有侵权的图片,请第一时间联系我们。

目录[+]

取消
微信二维码
微信二维码
支付宝二维码