java网络编程

🕗 发布于 2024-11-17 10:15 java tcp/ip udp

网络编程概述

java实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。即里面有类包，直接调用就可以了。

软件架构：

C/S架构，客户端和服务端
B/S架构，浏览器和服务器

无论哪种架构，都离不开网络的支持，网络编程，即在一定的协议下，实现两台计算机的通信的程序。
实际上一些C/S也融合了B/S，所以有未更新的客户端也能看到新的功能页面。

网络基础

网络编程的目的，直接或间接的通过网络协议与其他计算机实现数据交换，进行通讯。

实现网络通信，解决的问题：

如何准确定位网络上的一台主机或多台主机？-》IP地址
如何定位主机上特定的应用？-》端口号
如何可靠、高效的进行传输？-》规范网络通信协议

通信要素：IP地址和域名

IP：互联网协议地址，给网络中的设备作唯一的编号。

IP地址分类方式：IPV4，IPV6

了解IPV4和IPV6
公网地址和私有地址
- 192.168.开头的就是私有地址

本地回路地址：127.0.0.1就代表了本地本机IP地址了，不用ipconfig去查了。

域名解析：连接网络时输入主机域名，域名服务器Domain Name System将域名转化为IP地址，才能和主机建立连续

端口号：唯一标识设备中的进程

网络通信协议：常使用TCP/IP四层协议

InetAddress类的一个实例就代表一个具体的IP地址

掌握两个实例，如下示例：

public class InetAddressTest {
    public static void main(String[] args) {
        // 实例化
        try {
            InetAddress inet1 = InetAddress.getByName("192.168.1.1");
            System.out.println(inet1);

            InetAddress inet2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inet2);

            // 获取本机地址
            InetAddress inet3 = InetAddress.getLocalHost();
            System.out.println(inet3);
            
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

    }
}

掌握两个方法：

// 获取域名
            String hostName = inet2.getHostName();
            String address = inet2.getHostAddress();// 获取ip地址
            System.out.println(hostName);
            System.out.println(address);

TCP与UDP协议剖析，TCP编程

java.net提供了低层次的通信细节，提供了常见的网络协议的支持：

UDP，用户数据表协议，
TCP，传输控制协议，

TCP三次握手：发送数据的准备阶段，客户端与服务端的三次交互，以保证连接的可靠性

第一次，客户端向服务端发起连接请求
第二次握手，服务端发送针对客户端TCP请求的确认
第三次，客户端发送确认的确认

TCP，释放时经过4次挥手，

Socket类：网络上具有唯一标识的IP地址和端口号组合在一起构成唯一能识别的标识符套接字socket。

网络通信实际就是socket间的通信。

TCP示例-客户端发送内容给服务端

package com.atguigu02.tcpudp;

import org.testng.annotations.Test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * @DESC: 客户端发送内容给服务端，服务端将内容输出
 * 先启动服务端，再启动客户端
 */
public class TCPTest1 {
    // 客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        try {
            // 创建一个socket
//            InetAddress inetAddress = InetAddress.getByName("192.168.1.1");
            InetAddress inetAddress = InetAddress.getLocalHost();
            int port = 8989;
            socket = new Socket(inetAddress, port);

            // 发送数据
            os = socket.getOutputStream();
            os.write("你好客户端发来的数据".getBytes(StandardCharsets.UTF_8));


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭socket

            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os != null) {

                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    // 服务端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        Socket socket = null; // 阻塞式的方法
        InputStream is = null;
        try {
            // 创建ServerSocket
            int port = 8989; // 与客户端中请求的服务端的端口号一样
            serverSocket = new ServerSocket(port);


            // 调用accept方法，接受客户端的socket
            socket = serverSocket.accept();
            System.out.println("服务端已开启");

            // 接收数据
            is = socket.getInputStream();
            // 回顾io流接收数据
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                // 字符串
                String s = new String(buffer, 0, len);
                System.out.println(s);

            }
            System.out.println("\n数据接收完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭socket serversocket
            try {
                if (socket != null) {

                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (serverSocket != null) {

                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {

                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

如图所示：
在这里插入图片描述
注意服务端接收那里，字节流一般不处理文本文件，引入字节数组输出流，下面是修改的，

 // 下面是修正后的接收内容
            byte[] buffer = new byte[5];
            int len;
            ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 内部维护了一个byte数组
            while ((len = is.read(buffer)) != -1){
                baos.write(buffer, 0,  len);
            }
            System.out.println(baos.toString());
            System.out.println("\n数据接收完毕");

客户端发送文件给服务端

还是同样的流程，注意读写过程需要掌握。

package com.atguigu02.tcpudp;

import org.testng.annotations.Test;

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

/**
 * @DESC: 客户端发送文件给服务端
 */
public class TCPTest2 {
    @Test
    public void client() {
        Socket socket = null;
        FileInputStream fis = null;
        OutputStream os = null;
        try {
            // 创建socket
            // socket需要服务端的ip地址或者域名，以及端口号
            // 获取ip，定义端口号
            InetAddress localHost = InetAddress.getLocalHost();
//        InetAddress localHost = InetAddress.getByName('127.0.0.1');
            int port = 9090;
            socket = new Socket(localHost, port);

            // 创建File的实例，FileInputStream的实例
            File file = new File("E://mycodes//ideaProject//shangguigujavastudy//JavaSECode//chapter16_net//src//test.png");
            // 创建输入流
            fis = new FileInputStream(file);

            // 通过Socket获取输出流
            os = socket.getOutputStream();
            // 读写数据
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer)) != -1) {
                // 写数据
                os.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("客户端数据发送完毕");
            // 关闭socket和其他流
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    @Test
    public void server() {
        ServerSocket serverSocket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            // 创建serverSocket
            int port = 9090;
            serverSocket = new ServerSocket(port);
            // 接收来自客户端的socket
            Socket accept = serverSocket.accept();
            // 获取一个输入流
            is = accept.getInputStream();
            // 同样也是文件，需要保存到服务端当中，使用到输出流保存
            File file = new File("E://mycodes//ideaProject//shangguigujavastudy//JavaSECode//chapter16_net//src//test_server.png");
            fos = new FileOutputStream(file);
            // 读写过程，把接受到的写进去
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) != -1){
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("服务端接收文件成功");
            // 关闭相关的socket和流
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端发送文件给服务端并返回信息给客户端

客户端标记不再发送数据了，接收服务端返回的数据。

package com.atguigu02.tcpudp;

import org.testng.annotations.Test;

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

/**
 * @DESC: 客户端发送文件给服务端
 */
public class TCPTest3 {
    @Test
    public void client() {
        Socket socket = null;
        FileInputStream fis = null;
        OutputStream os = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            // 创建socket
            // socket需要服务端的ip地址或者域名，以及端口号
            // 获取ip，定义端口号
            InetAddress localHost = InetAddress.getLocalHost();
//        InetAddress localHost = InetAddress.getByName('127.0.0.1');
            int port = 9090;
            socket = new Socket(localHost, port);

            // 创建File的实例，FileInputStream的实例
            File file = new File("E://mycodes//ideaProject//shangguigujavastudy//JavaSECode//chapter16_net//src//test.png");
            // 创建输入流
            fis = new FileInputStream(file);

            // 通过Socket获取输出流
            os = socket.getOutputStream();
            // 读写数据
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer)) != -1) {
                // 写数据
                os.write(buffer, 0, len);
            }
            System.out.println("客户端数据发送完毕");

            // 接收来自服务端的信息，应该是输入流
            // 接收服务端的信息，应该先表示自己不再发送数据了
            socket.shutdownOutput();
            is = socket.getInputStream();
            // 使用ByteArrayOutputStream防止乱码，内部维护了一个byte字节数组
            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());



        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 关闭socket和其他流
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    @Test
    public void server() {
        ServerSocket serverSocket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            // 创建serverSocket
            int port = 9090;
            serverSocket = new ServerSocket(port);
            // 接收来自客户端的socket
            Socket accept = serverSocket.accept();
            // 获取一个输入流
            is = accept.getInputStream();
            // 同样也是文件，需要保存到服务端当中，使用到输出流保存
            File file = new File("E://mycodes//ideaProject//shangguigujavastudy//JavaSECode//chapter16_net//src//test_server.png");
            fos = new FileOutputStream(file);
            // 读写过程，把接受到的写进去
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) != -1){
                fos.write(buffer, 0, len);
            }
            // 上面循环结束是可以通过客户端的socket的关闭从而结束的，而当客户端没有关socket，则while循环没有跳出，服务端就卡在这了
            // 在客户端socket标记一下就可以跳出来

            // 考虑返回信息给客户端，利用接收到的socket写输出流
            os = accept.getOutputStream();
            os.write("你的图片我收到了，很漂亮".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            System.out.println("服务端接收文件成功");
            // 关闭相关的socket和流
            try {
                os.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

原文地址：https://blog.csdn.net/Misnearch/article/details/143275685

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Scratch 015生日贺卡（下）
下一篇：变分自编码器（VAE, Variational Autoencoder）

Java项目实战II基于Java+Spring Boot+MySQL的共享汽车管理系统(源码+数据库+文档)
在共享经济蓬勃发展的背景下，共享汽车作为一种新型的出行方式，正逐渐改变着人们的出行习惯。然而，随着共享汽车市场规模的不断扩大，车辆管理、用户服务、数据安全等问题日益凸显，传统的管理方式已难以满足当前的
阅读更多2024-11-19
【青牛科技】汽车收音机调频中频放大器——D1145
无线麦克风对讲机。
阅读更多2024-11-19
鸿蒙中位置权限和相机权限
State permissionsMessage: string | Resource = "\"获取当前位置\"需获取定位权限才能正常使用"this.perm
阅读更多2024-11-19
UE5 第一人称射击项目学习（二）
然后，把子弹的向前向量提升（在ue5的标准向量是以1cm为单位，所以虽然子弹跟随视角发射，但是速度太慢），从生成Actor的return Value处拉一根线，获取向前向量乘1000.运行程序，按
阅读更多2024-11-19
【软考】系统架构设计师-数据库设计基础
数据库设计基础知识
阅读更多2024-11-19
MongoDB 监控：确保数据库性能和可靠性
MongoDB 是一个流行的开源 NoSQL 数据库，以其灵活的文档模型和强大的查询语言而闻名。然而，为了确保 MongoDB 的性能和可靠性，监控是至关重要的。本文将讨论 MongoDB 监控的重要
阅读更多2024-11-19
电脑插入U盘，电脑显示新增了，但是双击却显示请将磁盘插入
`CHKDSK 无法供 RAW 驱动器使用` 表明内存卡的文件系统已损坏或丢失，当前处于 **RAW 文件系统** 状态。RAW 表示文件系统无法识别，可能由以下原因导致：
阅读更多2024-11-19
【论文阅读】InstructIR: High-Quality Image Restoration Following Human Instructions
图像恢复是一个基本问题，旨在从退化的图像中恢复出高质量的清晰图像。All-In-One 图像恢复模型能够利用退化特定的信息作为提示，引导恢复模型有效地恢复多种类型和不同程度的退化图像。本研究提出了首个
阅读更多2024-11-19
【Next】字体修改
next/font 包括任何字体文件的内置自动自托管。首先从 next/font/google 导入您想要使用的字体作为函数。（可以按住 ctrl 点进去 google 查看所有字体）然后导入该字体函
阅读更多2024-11-19
Springboot基于GIS的旅游信息管理系统
项目编号：springbootA100基于GIS的旅游信息管理系统是在旅游业迅速发展、旅游需求日益多样化的背景下应运而生的一套综合性信息管理平台，它通过整合旅游资源、提供实时信息、优化服务流程，旨在为
阅读更多2024-11-19