• 一文学会java网络编程


    1.java网络编程概述

    网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来。

    java.net 包中 J2SE 的 API 包含有类和接口,它们提供低层次的通信细节。你可以直接使用这些类和接口,来专注于解决问题,而不用关注通信细节。

    java.net 包中提供了两种常见的网络协议的支持:

    • TCP:TCP(英语:Transmission Control Protocol,传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议,TCP 层是位于 IP 层之上,应用层之下的中间层。TCP保障了两个应用程序之间的可靠通信。通常用于互联网协议,被称 TCP / IP。
    • UDP:UDP (英语:User Datagram Protocol,用户数据报协议),位于 OSI模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议,所以应用程序通常必须容许一些丢失、错误或重复的数据包。

    2.InetAddress类

    这个类表示互联网协议(IP)地址。下面演示了 Socket 编程时比较有用的方法:

    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    /**
     * InetAddress类演示
     */
    public class InetAddressTest {
        public static void main(String[] args) throws UnknownHostException {
            // 获取本机的InetAddress对象:主机名 + IP地址
            InetAddress localHost = InetAddress.getLocalHost();
            System.out.println(localHost);
    
            // 根据主机名获取InetAddress对象
            InetAddress host1 = InetAddress.getByName("Dahe-Windows11");
            System.out.println(host1);
    
            // 根据域名获取InetAddress对象
            InetAddress host2 = InetAddress.getByName("www.baidu.com");
            System.out.println(host2);
    
            // 通过InetAddress对象获取对应的地址
            String hostAddress = host2.getHostAddress();
            System.out.println(hostAddress);
    
            // 通过InetAddress对象获取主机名或者域名
            String hostName = host2.getHostName();
            System.out.println(hostName);
        }
    }
    ------------------------
    输出:
    XXX-WindowsXX/192.168.0.1
    XXX-WindowsXX/192.168.0.1
    www.baidu.com/39.156.66.18
    39.156.66.18
    www.baidu.com
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    3.Socket 编程

    套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字,并尝试连接服务器的套接字。

    当连接建立时,服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。

    java.net.Socket 类代表一个套接字,并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端,并与他们建立连接的机制。

    以下步骤在两台计算机之间使用套接字建立TCP连接时会出现:

    • 服务器实例化一个 ServerSocket 对象,表示通过服务器上的端口通信。
    • 服务器调用 ServerSocket 类的 accept() 方法,该方法将一直等待,直到客户端连接到服务器上给定的端口。
    • 服务器正在等待时,一个客户端实例化一个 Socket 对象,指定服务器名称和端口号来请求连接。
    • Socket 类的构造函数试图将客户端连接到指定的服务器和端口号。如果通信被建立,则在客户端创建一个 Socket对象能够与服务器进行通信。
    • 在服务器端,accept() 方法返回服务器上一个新的 socket 引用,该 socket 连接到客户端的 socket

    连接建立后,通过使用 I/O 流在进行通信,每一个socket都有一个输出流和一个输入流,客户端的输出流连接到服务器端的输入流,而客户端的输入流连接到服务器端的输出流。

    TCP 是一个双向的通信协议,因此数据可以通过两个数据流在同一时间发送


    4.TCP编程

    TCP字节流编程

    我们来模拟一个服务端和客户端通信的过程:

    服务端:

    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 服务端
     */
    public class SocketServer {
        public static void main(String[] args) throws IOException {
            // 在本地的9999端口进行监听
            // 细节:需要确保9999端口处于空闲状态
            ServerSocket serverSocket = new ServerSocket(9999);
            // 没有客户端链接时,会阻塞,等待链接
            // 有客户端链接,则会返回一个Socket对象
            Socket socket = serverSocket.accept();
            // 通过输入流获取客户端发来的数据
            InputStream inputStream = socket.getInputStream();
            // 读取内容
            byte[] buf = new byte[1024];
            int readLne = 0;
            while ((readLne = inputStream.read(buf)) != -1) {
                System.out.println(new String(buf, 0, readLne));
            }
            // 关闭资源
            inputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    客户端:

    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * 客户端
     */
    public class SocketClient {
        public static void main(String[] args) throws IOException {
            // 链接服务端,由于是测试程序,直接获取本机的地址即可
            // 链接本机的9999端口,链接成功会返回一个Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            // 创建流向服务器端发送数据
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("Hello Server".getBytes());
            // 关闭输出流对象和socket
            outputStream.close();
            socket.close();
            System.out.println("客户端退出!");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    同时运行服务端和客户端,该示例代码,客户端会向服务端发送一个流信息:Hello Server

    接下来,我们来看一个更为复杂的例子:实现客户端和服务端的双通信🎈

    服务端:

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 服务端
     */
    public class SocketServer {
        public static void main(String[] args) throws IOException {
            // 在本地的9999端口进行监听
            // 细节:需要确保9999端口处于空闲状态
            ServerSocket serverSocket = new ServerSocket(9999);
            // 没有客户端链接时,会阻塞,等待链接
            // 有客户端链接,则会返回一个Socket对象
            Socket socket = serverSocket.accept();
            // 通过输入流获取客户端发来的数据
            InputStream inputStream = socket.getInputStream();
            // 读取内容
            byte[] buf = new byte[1024];
            int readLne = 0;
            while ((readLne = inputStream.read(buf)) != -1) {
                System.out.println(new String(buf, 0, readLne));
            }
            // 向客户端回送消息
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("hello,client".getBytes());
            // 设置结束标记
            socket.shutdownOutput();
            // 关闭资源
            inputStream.close();
            outputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    客户端:

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * 客户端
     */
    public class SocketClient {
        public static void main(String[] args) throws IOException {
            // 链接服务端,由于是测试程序,直接获取本机的地址即可
            // 链接本机的9999端口,链接成功会返回一个Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            // 创建流向服务器端发送数据
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("Hello Server".getBytes());
            // 设置结束标记
            socket.shutdownOutput();
            // 获取服务端的回送数据
            InputStream inputStream = socket.getInputStream();
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = inputStream.read(buf)) != -1) {
                System.out.println(new String(buf, 0, readLen));
            }
            // 关闭输出流对象和socket
            outputStream.close();
            socket.close();
            System.out.println("客户端退出!");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    需要注意:双端通信需要设置结束标记,否则会相互等待,陷入僵持❌

    TCP字符流编程

    字符流编程,需要使用转换流的技术🐼

    直接上代码:

    客户端:

    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * 基于字符流的TCP编程
     * 客户端
     */
    
    public class CharacterSocketClient {
        public static void main(String[] args) throws IOException {
            // 链接服务端,由于是测试程序,直接获取本机的地址即可
            // 链接本机的9999端口,链接成功会返回一个Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            // 创建流向服务器端发送数据
            OutputStream outputStream = socket.getOutputStream();
            // 使用IO转换流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
            bw.write("hello,server 字符流");
            // 插入换行符,表示写入的内容结束
            bw.newLine();
            // 使用字符流,必须手动刷新,否则数据将不会写入通道
            bw.flush();
            // 设置结束标记
            socket.shutdownOutput();
            // 获取服务端的回送数据
            InputStream inputStream = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String s = br.readLine();
            System.out.println(s);
            // 关闭输出流对象和socket
            br.close();
            bw.close();
            outputStream.close();
            socket.close();
            System.out.println("客户端退出!");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    服务端:

    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 基于字符流的TCP编程
     * 服务端
     */
    
    public class CharacterSocketServer {
        public static void main(String[] args) throws IOException {
            // 在本地的9999端口进行监听
            // 细节:需要确保9999端口处于空闲状态
            ServerSocket serverSocket = new ServerSocket(9999);
            // 没有客户端链接时,会阻塞,等待链接
            // 有客户端链接,则会返回一个Socket对象
            Socket socket = serverSocket.accept();
            // 通过输入流获取客户端发来的数据
            InputStream inputStream = socket.getInputStream();
            // IO转换流
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            // 必须使用readLine方式来读
            String s = br.readLine();
            System.out.println(s);
            // 向客户端回送消息
            OutputStream outputStream = socket.getOutputStream();
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
            bw.write("Hello,Client 字符流");
            bw.newLine();
            bw.flush();
            // 关闭资源
            br.close();
            bw.close();
            inputStream.close();
            outputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    5.网络上传文件

    服务端代码:

    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 文件上传,服务端
     */
    public class TCPFileUploadServer {
        public static void main(String[] args) throws Exception {
            ServerSocket serverSocket = new ServerSocket(8888);
            Socket socket = serverSocket.accept();
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            byte[] bytes = StreamUtils.streamToByteArray(bis);
            String destFilePath = "networkprogramming\\tcp\\color.jpg";
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
            bos.write(bytes);
            bos.close();
            // 关闭资源
            bis.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    客户端代码:

    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * 文件上传,客户端
     */
    public class TCPFileUploadClient {
        public static void main(String[] args) throws Exception {
            Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
            // 创建读取磁盘文件的输入流
            String filePath = "D:\\color.jpg";
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
            // 此时的bytes就是文件的字节内容
            byte[] bytes = StreamUtils.streamToByteArray(bis);
            // 通过socket获取到输出流,将bytes数据发送给服务端
            BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
            bos.write(bytes);
            bis.close();
            // 写入数据结束标记
            socket.shutdownOutput();
            // 关闭资源
            bos.close();
            socket.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    6.TCP文件下载

    客户端代码:

    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.util.Scanner;
    
    /**
     * TCP文件下载客户端
     */
    public class TCPFileDownloadClient {
        public static void main(String[] args) throws Exception {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入下载文件名:");
            String downloadFileName = scanner.next();
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(downloadFileName.getBytes());
            // 设置写入结束标志
            socket.shutdownOutput();
            // 接受服务器返回的文件字节数组
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            byte[] bytes = StreamUtils.streamToByteArray(bis);
            // 将文件写入磁盘
            String filePath = "D:\\" + downloadFileName + ".jpg";
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
            bos.write(bytes);
            bos.close();
            socket.close();
            outputStream.close();
            bis.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    服务端代码:

    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * TCP文件下载服务端
     */
    public class TCPFileDownloadServer {
        public static void main(String[] args) throws Exception {
            ServerSocket serverSocket = new ServerSocket(9999);
            Socket socket = serverSocket.accept();
            // 读取客户端发送的要下载的文件名称
            InputStream inputStream = socket.getInputStream();
            byte[] b = new byte[1024];
            int len = 0;
            // 客户端要下载的文件名
            String downloadFileName = "";
            while ((len = inputStream.read(b)) != -1) {
                downloadFileName += new String(b, 0, len);
            }
    
            // 提供给客户端下载的实际文件名
            String resFileName = "";
            if ("color".equals(downloadFileName)) {
                resFileName = "networkprogramming\\tcp\\color.jpg";
            } else {
                resFileName = "networkprogramming\\tcp\\fish.jpg";
            }
    
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(resFileName));
            // 使用工具类将文件保存到一个字节数组中
            byte[] bytes = StreamUtils.streamToByteArray(bis);
            BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
            // 写入到数据通道,返回给客户端
            bos.write(bytes);
            socket.shutdownOutput();
            inputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
  • 相关阅读:
    Wi-Fi连接握手包抓包
    KVM虚拟化技术学习-基础入门
    数字硬件建模SystemVerilog-循环语句
    Google Earth Engine APP ——Forest Health监测APP(可下载)
    【RL+Transformer综述】A Survey on Transformers in Reinforcement Learning论文笔记
    12.PGL图学习之项目实践(UniMP算法实现论文节点分类、新冠疫苗项目实战,助力疫情)[系列九]
    C++项目实战-高并发服务器详析
    2021年度全球CSS报告新鲜出炉,JavaScript调查推迟到明年
    数学建模 -- 灰色预测模型
    CRC原理介绍及STM32 CRC外设的使用
  • 原文地址:https://blog.csdn.net/Gherbirthday0916/article/details/126199402