Java - 网络编程

OLDERHARD2024-08-08 20:05

一、网络基础(网络的相关概念)
网络通信：

1.概念：两台设备之间通过网络实现数据传输

2.网络通信：将数据通过网络从一台设备传输到另一台设备

3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

网络：

1.概念：两台或多台设备通过一定物理设备连接起来构成了网络

2.根据网络的覆盖范围不同，对网络进行分类：

局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房

城域网：覆盖范围较大，可以覆盖一个城市

广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

ip地址

1.概念：用于唯一标识网络中的每台计算机

2.查看ip地址：ipconfig。

3.ip地址的表示形式：点分十进制 xx.xx.xx.xx(IPv4)

4.每一个十进制数的范围：0~255(IPv4)

5.ip地址的组成=网络地址+主机地址，比如：192.168.16.69(IPv4)

6.IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称为全世界的每一粒沙子编上一个地址。

7.IPv4是4个字节(32位)用十进制表示，IPv6是16个字节(128位)用16进制表示。由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍。

8.127.0.0.1表示本机地址。

9.IPv4地址分类：A,B,C,D,E

域名：

1.www.baibu.com

2.好处：为了方便记忆，解决记ip的困难

3.概念：将ip地址映射成域名

端口号：

1.概念：用于监听计算机上某个特定的网络程序

2.表示形式：以整数形式，范围0~65535 (2个字节)

  1. 0~1024已经被占用，比如：ssh:22、ftp:21、http:80、smtp:25

4.常见的网络程序端口号：

tomcat:8080、mysql:3306、oracle:1521、sqlserver:1433

网络通信协议

网络通信协议可以理解为通过网络传输数据的组织形式。即双方进行传输数据，得按照一定的组织形式也就是一定的规则，当对方接收的时候，才能正确读取数据信息，也才能按照相应的规则，响应你要的数据信息。(个人理解)

用户数据在传输的时候，会通过多层协议，进行包装(Appl,TCP,IP,以太网)。到达对方的时候，就是包装好的数据(以太网帧)，之后再根据协议，逐渐拆包，得到用户数据。

TCP/IP模型：应用层，传输层(TCP)，网络层(IP)，物理+数据链路层

协议(tcp/ip)

中文译名为传输控制协议，网络通讯协议，这个协议是Internet最基本的协议，Internet国际互联网络的基础。简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

TCP和UDP
TCP协议(传输控制协议)：

1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用"三次握手"，是可靠的

3.TCP协议进行通信的两个应用进程：客户端、服务端

4.在连接中可进行大数据量的传输

5.传输完毕，需释放已建立的连接，效率低

UDP协议(用户数据协议)：

1.将数据、源、目的 封装成数据包，不需要建立连接

2.每个数据包的大小限制在64K内

3.因无需连接，所以是不可靠的

4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快

二、InetAddress类

InetAddress 是 Java 中用于表示 IP 地址的类。它封装了 IP 地址（包括 IPv4 和 IPv6）以及可能的主机名。这个类提供了一些方法来获取 IP 地址和主机名之间的映射。
作用：通过这个类可以获取本机的信息(主机名/IP),通过域名获取远程服务器的IP。

相关方法

getLocalHost //获取本机的InetAddress对象

getByName //根据指定 主机名/域名 获取对应InetAddress对象

getHostName //获取InetAddress对象的主机名

getHostAddress //获取InetAddress对象的地址

java 复制代码 
public class info {
    public static void main(String[] args) throws UnknownHostException {

        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost); //LAPTOP-74LRE27/127.0.0.1
//        System.out.println(InetAddress.getByName("LAPTOP-74LRE27"));
        System.out.println(localHost.getHostName());//主机名
        System.out.println(localHost.getHostAddress());//IP

        InetAddress byName = InetAddress.getByName("www.baidu.com");
        System.out.println(byName);
        System.out.println(byName.getHostName());//域名
        System.out.println(byName.getHostAddress());//ip
    }
}

三、Socket编程

1.Socket开发网络应用程序 被广泛应用，以至于成为事实上的标准。

2.通信的双端都要有 Socket，Socket 是两台机器间通信的端点。

3.网络通信其实就是 Socket 间的通信。

4.Socket 允许程序把网络连接当成一个流，数据在两个 Socket 间通过IO传输。

5.一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

6.当我们需要通讯时(读写数据 ，会用到socket的两个方法：

socket.getOutputStream() //得到这个对应的输出流，用这个输出流往外写东西；

socket.getInputStream() //得到这个对应的输入流，用这个输入流读东西；

7.Socket 编程有两种编程方式，

TCP编程，可靠

UDP编程，不可靠

四、TCP编程(TCP网络通信编程)

1.基于客户端------服务端的网络通信

2.底层使用的是TCP/IP协议

3.应用场景举例：客户端发送数据，服务端接收并显示在控制台

4.基于 Socket的TCP编程

5.netstat指令

netstat -an ，可以查看当前主机网络情况，包括端口监听情况和网络连接情况

netstat -an | more ，可以分页显示

要求在 dos 控制台下执行

6.当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP 来分配的，是不确定的，是随机的。

应用案例1(使用字节流)

1.编写一个服务器端程序，和一个客户端程序；

2.服务器端在9999端口监听；

3.客户端连接到服务器端，发送"hello server"，然后退出；

4.服务器端接收到 客户端发送的信息，输出，并退出；
思路：
服务端： 在本机的9999端口监听，等待连接；当没有客户端连接9999端口时，程序会阻塞，等待连接；连接成功后，通过socket.getIntputStream()，读取客户端写入到数据通道的数据，显示。
**客户端：**连接服务端(IP，端口)；连接上后，会生成 Socket；通过socket.getOutputStream()这个输出流，写入数据到数据通道。

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999); //监视端口9999
        System.out.println("本机端口9999正在监视....");
        Socket accept = serverSocket.accept();  //等待连接，连接成功后才能继续程序
        System.out.println("连接成功");
        InputStream inputStream = accept.getInputStream();  //读取数据通道的数据
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        inputStream.close();    //关闭
        accept.close();
        serverSocket.close();
    }
}

public class user {
    public static void main(String[] args) throws IOException {
        //连接服务端，连接成功后，会返回 socket 对象，之后用socket的getOutputStream，写入到数据通道，等待服务端处理。
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
        socket.shutdownOutput();    //当写完后，要设置结束标志

        outputStream.close();   //关闭
        socket.close();
    }
}

应用案例2(使用字节流)

1.编写一个服务器端程序，和一个客户端程序；

2.服务器端在9999端口监听；

3.客户端连接到服务器端，发送"hello server"，接收服务器端回发的"hello user"，然后退出；

4.服务器端接收到 客户端发送的信息，输出，并发送"hello user"，再退出。

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket accept = serverSocket.accept();
        InputStream inputStream = accept.getInputStream();
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }


        OutputStream outputStream = accept.getOutputStream();
        outputStream.write("hello user".getBytes());
        accept.shutdownOutput();
        
        
        outputStream.close();
        inputStream.close();
        accept.close();
        serverSocket.close();
    }
}

public class user {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
        socket.shutdownOutput();


        InputStream inputStream = socket.getInputStream();
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }


        inputStream.close();
        outputStream.close();
        socket.close();
    }
}

应用案例3(使用字符流)

将应用案例2使用的字节流，改为字符流，用字符流来写入和读取。

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket accept = serverSocket.accept();

        InputStream inputStream = accept.getInputStream();
        BufferedReader bufferedReader= new BufferedReader(new InputStreamReader(inputStream,"utf-8"));
        String read=null;
        while ((read=bufferedReader.readLine())!=null){
            System.out.println(read);
        }

        OutputStream outputStream = accept.getOutputStream();
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream,"utf-8"));
        bufferedWriter.write("hello user");
        bufferedWriter.newLine();
        bufferedWriter.flush();     //如果用字符流写入的话，需要手动刷新，否则数据是不会写入到数据通道的
        accept.shutdownOutput();

        bufferedReader.close();
        bufferedWriter.close();
        accept.close();
        serverSocket.close();
    }
}

public class user {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream,"utf-8"));
        bufferedWriter.write("hello server");
        bufferedWriter.newLine();
        bufferedWriter.flush();     //如果使用字符流写入的话，需要手动刷新，否则数据是不会被写入到数据通道的
        socket.shutdownOutput();

        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream,"utf-8"));
        String read=null;
        while ((read=bufferedReader.readLine())!=null){
            System.out.println(read);
        }

        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
    }
}

应用案例4

1.编写一个服务端，和一个客户端

2.服务器端在8888端口监听

3.客户端连接到服务端，发送一张照片 (自定义)

4.服务器端接收到客户端发送的图片，保存到一个位置，发送"success"，再退出

5.客户端接收到服务端发送的"success"，并显示，再退出

6.使用BufferedInputStream和BufferedOutputStream等

跟上面的相比，没啥特别的 ，但是要记住一点，Buffered这种是缓冲流，每次在最后都要刷新一下，否则会造成文件信息缺失，Socket异常。

java 复制代码 
public class server{
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket accept = serverSocket.accept();
        //读取数据通道的数据，并储存
        InputStream inputStream = accept.getInputStream();
        BufferedInputStream bufferedInputStream=new BufferedInputStream(inputStream);
        String filePath="D:\\untitled1\\src\\preview.jpg";
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(filePath));
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedOutputStream.flush();

        //返回信息"success"
        OutputStream outputStream = accept.getOutputStream();
        BufferedOutputStream bufferedOutputStream1=new BufferedOutputStream(outputStream);
        bufferedOutputStream1.write("success".getBytes());
        bufferedOutputStream1.flush();
        accept.shutdownOutput();//结束标识

        bufferedOutputStream1.close();//关闭
        bufferedOutputStream.close();
        bufferedInputStream.close();
        accept.close();
        serverSocket.close();
    }
}
java 复制代码 
public class user{
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //将"图片"数据，传送到数据通道
        String filePath="C:\\Users\\OLDERHARD\\Pictures\\preview.jpg";
        BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream(filePath));
        OutputStream outputStream = socket.getOutputStream();
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);
        int len=0;
        byte[] bytes = new byte[1024];
        while ((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedOutputStream.flush();
        socket.shutdownOutput();//结束标识

        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bufferedInputStream1 =new BufferedInputStream(inputStream);
        while ((len=inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        bufferedInputStream1.close();
        bufferedInputStream.close();
        bufferedOutputStream.close();
        socket.close();
    }
}

五、UDP网络通信编程(UDP编程)

1.类 DatagramSocket 和 DategramPacket 实现了基于 UDP 协议网络程序

2.UDP数据报通过 DatagramSocket 发送和接收，系统不保证 UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

3.DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号

4.UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

5基本流程：

核心的两个类/对象 DatagramSocket 与 DatagramPacket

建立发送端，接收端

建立数据报,会被装包成 DatagramPacket对象

调用DatagramSocket的发送，接收方法

关闭DatagramSocket

6.UDP说明

没有明确的服务端和客户端，演变成数据的发送端和接收端；

接收数据和发送数据时通过 DatagramSocket对象完成；

将数据封装到DatagramPacket对象，装包；

当接收到 Datagrampacket 对象，需要进行拆包，取出数据；

应用案例

1.编写一个接收端A，和一个发送端B

2.接收端A在9999端口等待接收数据(receive)

3.发送端B向接收端A发送数据"hello，明天吃火锅~"

4.接收端A接收到发送端B发送的数据，回复"好的，明天见"，再退出

5.发送端接收回复数据，再退出

java 复制代码 
/*接收端*/
public class UDPA {
    public static void main(String[] args) throws IOException {
        DatagramSocket datagramSocket = new DatagramSocket(9999);
        byte[] bytes = new byte[1024];
        DatagramPacket Packet = new DatagramPacket(bytes,bytes.length);

        datagramSocket.receive(Packet);
        int length = Packet.getLength();    //实际接收到数据报的长度
        byte[] data = Packet.getData();
        System.out.println(new String(data,0,length, StandardCharsets.UTF_8));
        
        /*充当发送端*/
        byte[] bytes1 = "好的，明天见".getBytes();
        DatagramPacket Packet1 = new DatagramPacket(bytes1, bytes1.length, InetAddress.getLocalHost(), 9998);
        datagramSocket.send(Packet1);

        datagramSocket.close(); //关闭
    }
}
java 复制代码 
/*发送端*/
public class UDPB {
    public static void main(String[] args) throws IOException {
        DatagramSocket datagramSocket = new DatagramSocket(9998);
        byte[] bytes = "hello，明天吃火锅~".getBytes();
        DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),9999);
        datagramSocket.send(datagramPacket);

        /*充当接收端*/
        byte[] bytes1 = new byte[1024];
        DatagramPacket datagramPacket1 = new DatagramPacket(bytes1,bytes1.length);
        datagramSocket.receive(datagramPacket1);

        int length = datagramPacket1.getLength();
        byte[] data1 = datagramPacket1.getData();
        String s=new String(data1,0,length, StandardCharsets.UTF_8);
        System.out.println(s);

        datagramSocket.close();//关闭
    }
}
相关推荐
涔溪31 分钟前
HTTP TCP三次握手深入解析
网络·tcp/ip·http
憨子周31 分钟前
2M的带宽怎么怎么设置tcp滑动窗口以及连接池
java·网络·网络协议·tcp/ip
三菱-Liu2 小时前
三菱MR-J4-B伺服连接器和信号排列
网络·驱动开发·硬件工程·制造·mr
WeeJot嵌入式2 小时前
网络安全：挑战、策略与未来趋势
网络
霖雨2 小时前
使用Visual Studio Code 快速新建Net项目
java·ide·windows·vscode·编辑器
SRY122404192 小时前
javaSE面试题
java·开发语言·面试
Fiercezm2 小时前
JUC学习
java
无尽的大道3 小时前
Java 泛型详解：参数化类型的强大之处
java·开发语言
ZIM学编程3 小时前
Java基础Day-Sixteen
java·开发语言·windows
我不是星海3 小时前
1.集合体系补充（1）
java·数据结构
热门推荐
01聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03Windows10安装PCL1.14.0及点云配准04C++——超强级病毒代码05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07硬件预取之空间预取08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09Coze扣子平台完整体验和实践（附国内和国际版对比）10【SCS-CN】SCS-CN模型中CN值的确定