Bootstrap

【Java学习】7大技巧揭秘网络编程基础，你真的会了吗？

🔥关注墨瑾轩，带你探索编程的奥秘！🚀
🔥超萌技术攻略，轻松晋级编程高手🚀
🔥技术宝库已备好，就等你来挖掘🚀
🔥订阅墨瑾轩，智趣学习不孤单🚀
🔥即刻启航，编程之旅更有趣🚀

在这里插入图片描述在这里插入图片描述

7大技巧揭秘网络编程基础，你真的会了吗？

前言

嘿，小伙伴们，你们好呀！今天我们要聊一聊网络编程的基础知识，这可是程序员必备的技能之一哦！网络编程听起来好像很高大上，其实只要掌握了几个核心概念和技巧，你也能轻松上手。废话不多说，让我们一起进入网络编程的世界吧！

1. 网络编程基础知识
1.1 什么是网络编程？

  • 定义：

    • 网络编程是指编写能够通过网络进行通信的程序。这些程序可以通过互联网或其他网络协议（如TCP/IP）进行数据交换。
    • 网络编程的核心在于客户端-服务器模型，其中一个程序（客户端）发起请求，另一个程序（服务器）响应请求。

  • 常用协议：

    • TCP（传输控制协议）：面向连接的协议，保证数据的可靠传输。
    • UDP（用户数据报协议）：无连接的协议，速度快但不保证数据的可靠性。
1.2 客户端-服务器模型

  • 基本概念：

    • 客户端：发起请求的一方。
    • 服务器：接收请求并处理的一方。
    • 套接字（Socket）：网络通信的端点，用于发送和接收数据。

  • 工作流程：

    1. 服务器启动并监听某个端口。
    2. 客户端连接到服务器的端口。
    3. 客户端发送请求。
    4. 服务器处理请求并返回响应。
    5. 客户端接收响应。
    6. 关闭连接。
2. TCP编程基础
2.1 服务器端编程

  • 示例代码：

    import java.io.*;
import java.net.*;

public class TCPServer {
    public static void main(String[] args) {
        int port = 12345; // 监听的端口号
        ServerSocket serverSocket = null;

        try {
            // 创建服务器套接字，绑定到指定端口
            serverSocket = new ServerSocket(port);
            System.out.println("Server started, listening on port " + port);

            while (true) {
                // 接受客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress());

                // 获取输入输出流
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

                // 读取客户端发送的数据
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("Received: " + inputLine);
                    // 发送响应
                    out.println("Echo: " + inputLine);
                }

                // 关闭连接
                clientSocket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  • 代码解析：

    • ServerSocket serverSocket = new ServerSocket(port)：创建服务器套接字，绑定到指定端口。
    • Socket clientSocket = serverSocket.accept()：接受客户端连接。
    • BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))：获取输入流，读取客户端发送的数据。
    • PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)：获取输出流，发送响应。
    • out.println("Echo: " + inputLine)：发送响应。
    • clientSocket.close()：关闭连接。
2.2 客户端编程

  • 示例代码：

    import java.io.*;
import java.net.*;

public class TCPClient {
    public static void main(String[] args) {
        String host = "localhost"; // 服务器地址
        int port = 12345; // 服务器端口号
        Socket socket = null;

        try {
            // 连接到服务器
            socket = new Socket(host, port);
            System.out.println("Connected to server at " + host + ":" + port);

            // 获取输入输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));

            // 发送数据
            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                // 读取响应
                System.out.println("Server response: " + in.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  • 代码解析：

    • Socket socket = new Socket(host, port)：连接到服务器。
    • PrintWriter out = new PrintWriter(socket.getOutputStream(), true)：获取输出流，发送数据。
    • BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))：获取输入流，读取响应。
    • out.println(userInput)：发送数据。
    • System.out.println("Server response: " + in.readLine())：读取响应。
    • socket.close()：关闭连接。
3. UDP编程基础
3.1 服务器端编程

  • 示例代码：

    import java.net.*;

public class UDPServer {
    public static void main(String[] args) {
        int port = 12345; // 监听的端口号
        DatagramSocket socket = null;

        try {
            // 创建服务器套接字，绑定到指定端口
            socket = new DatagramSocket(port);
            System.out.println("Server started, listening on port " + port);

            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);

            while (true) {
                // 接收数据包
                socket.receive(receivePacket);
                String received = new String(receivePacket.getData(), 0, receivePacket.getLength());
                System.out.println("Received: " + received);

                // 发送响应
                byte[] sendData = ("Echo: " + received).getBytes();
                InetAddress clientAddress = receivePacket.getAddress();
                int clientPort = receivePacket.getPort();
                DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, clientAddress, clientPort);
                socket.send(sendPacket);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                socket.close();
            }
        }
    }
}

  • 代码解析：

    • DatagramSocket socket = new DatagramSocket(port)：创建服务器套接字，绑定到指定端口。
    • DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length)：创建数据包，用于接收数据。
    • socket.receive(receivePacket)：接收数据包。
    • DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, clientAddress, clientPort)：创建数据包，用于发送响应。
    • socket.send(sendPacket)：发送响应。
3.2 客户端编程

  • 示例代码：

    import java.net.*;

public class UDPClient {
    public static void main(String[] args) {
        String host = "localhost"; // 服务器地址
        int port = 12345; // 服务器端口号
        DatagramSocket socket = null;

        try {
            // 创建客户端套接字
            socket = new DatagramSocket();
            System.out.println("Connected to server at " + host + ":" + port);

            // 发送数据
            String message = "Hello, Server!";
            byte[] sendData = message.getBytes();
            InetAddress serverAddress = InetAddress.getByName(host);
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, port);
            socket.send(sendPacket);

            // 接收响应
            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            socket.receive(receivePacket);
            String received = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Server response: " + received);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                socket.close();
            }
        }
    }
}

  • 代码解析：

    • DatagramSocket socket = new DatagramSocket()：创建客户端套接字。
    • DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, port)：创建数据包，用于发送数据。
    • socket.send(sendPacket)：发送数据。
    • DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length)：创建数据包，用于接收响应。
    • socket.receive(receivePacket)：接收响应。
4. 特别问题：刨根问题
4.1 多线程服务器

  • 问题背景：
    在实际应用中，服务器需要同时处理多个客户端的请求。单线程服务器只能依次处理请求，效率较低。多线程服务器可以同时处理多个请求，提高性能。

  • 示例代码：

    import java.io.*;
import java.net.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadedTCPServer {
    public static void main(String[] args) {
        int port = 12345; // 监听的端口号
        ServerSocket serverSocket = null;
        ExecutorService executor = Executors.newFixedThreadPool(10); // 创建线程池

        try {
            // 创建服务器套接字，绑定到指定端口
            serverSocket = new ServerSocket(port);
            System.out.println("Server started, listening on port " + port);

            while (true) {
                // 接受客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress());

                // 创建新线程处理客户端请求
                ClientHandler handler = new ClientHandler(clientSocket);
                executor.execute(handler);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            executor.shutdown();
        }
    }
}

class ClientHandler implements Runnable {
    private Socket clientSocket;

    public ClientHandler(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }

    @Override
    public void run() {
        try {
            // 获取输入输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

            // 读取客户端发送的数据
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println("Received: " + inputLine);
                // 发送响应
                out.println("Echo: " + inputLine);
            }

            // 关闭连接
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

  • 代码解析：

    • ExecutorService executor = Executors.newFixedThreadPool(10)：创建固定大小的线程池。
    • ClientHandler handler = new ClientHandler(clientSocket)：创建处理客户端请求的线程。
    • executor.execute(handler)：将处理任务提交到线程池。
    • ClientHandler类：实现Runnable接口，处理客户端请求。
4.2 非阻塞I/O

  • 问题背景：
    传统的阻塞I/O在读写数据时会阻塞当前线程，导致资源浪费。非阻塞I/O可以在没有数据可读或可写时立即返回，提高程序的响应速度。

  • 示例代码：

    import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NonBlockingTCPServer {
    public static void main(String[] args) throws IOException {
        int port = 12345; // 监听的端口号
        Selector selector = Selector.open();
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Server started, listening on port " + port);

        while (true) {
            selector.select();

            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (key.isAcceptable()) {
                    // 处理新的客户端连接
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("Client connected: " + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 处理读事件
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = client.read(buffer);

                    if (bytesRead == -1) {
                        // 客户端断开连接
                        client.close();
                        continue;
                    }

                    buffer.flip();
                    byte[] data = new byte[buffer.remaining()];
                    buffer.get(data);
                    String received = new String(data);
                    System.out.println("Received: " + received);

                    // 发送响应
                    String response = "Echo: " + received;
                    ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
                    client.write(responseBuffer);
                }
            }
        }
    }
}

  • 代码解析：

    • Selector selector = Selector.open()：创建选择器。
    • serverSocket.configureBlocking(false)：设置服务器套接字为非阻塞模式。
    • serverSocket.register(selector, SelectionKey.OP_ACCEPT)：注册服务器套接字，监听连接请求。
    • client.configureBlocking(false)：设置客户端套接字为非阻塞模式。
    • client.register(selector, SelectionKey.OP_READ)：注册客户端套接字，监听读事件。
    • ByteBuffer buffer = ByteBuffer.allocate(1024)：创建缓冲区，用于读取数据。
    • client.read(buffer)：读取数据。
    • client.write(responseBuffer)：发送响应。
5. 实战演练：聊天室应用

  • 问题背景：
    聊天室是一个典型的网络应用，涉及多个客户端和一个服务器。服务器负责转发客户端的消息，使所有客户端都能看到消息。

  • 服务器端代码：

    import java.io.*;
import java.net.*;
import java.util.*;

public class ChatServer {
    public static void main(String[] args) {
        int port = 12345; // 监听的端口号
        ServerSocket serverSocket = null;
        Map<Socket, PrintWriter> clients = new HashMap<>();

        try {
            // 创建服务器套接字，绑定到指定端口
            serverSocket = new ServerSocket(port);
            System.out.println("Chat server started, listening on port " + port);

            while (true) {
                // 接受客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress());

                // 获取输入输出流
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

                // 将客户端添加到列表
                clients.put(clientSocket, out);

                // 创建新线程处理客户端请求
                ClientHandler handler = new ClientHandler(clientSocket, in, clients);
                Thread thread = new Thread(handler);
                thread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ClientHandler implements Runnable {
    private Socket clientSocket;
    private BufferedReader in;
    private Map<Socket, PrintWriter> clients;

    public ClientHandler(Socket clientSocket, BufferedReader in, Map<Socket, PrintWriter> clients) {
        this.clientSocket = clientSocket;
        this.in = in;
        this.clients = clients;
    }

    @Override
    public void run() {
        try {
            // 读取客户端发送的数据
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println("Received: " + inputLine);

                // 广播消息给所有客户端
                for (PrintWriter out : clients.values()) {
                    out.println(inputLine);
                }
            }

            // 客户端断开连接
            clients.remove(clientSocket);
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

  • 客户端代码：

    import java.io.*;
import java.net.*;
import java.util.Scanner;

public class ChatClient {
    public static void main(String[] args) {
        String host = "localhost"; // 服务器地址
        int port = 12345; // 服务器端口号
        Socket socket = null;

        try {
            // 连接到服务器
            socket = new Socket(host, port);
            System.out.println("Connected to chat server at " + host + ":" + port);

            // 获取输入输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            Scanner scanner = new Scanner(System.in);

            // 创建新线程处理服务器消息
            Thread receiveThread = new Thread(() -> {
                try {
                    String serverMessage;
                    while ((serverMessage = in.readLine()) != null) {
                        System.out.println(serverMessage);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            receiveThread.start();

            // 发送消息
            while (true) {
                String message = scanner.nextLine();
                if (message.equalsIgnoreCase("exit")) {
                    break;
                }
                out.println(message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  • 代码解析：

    • ChatServer类：服务器端主类，负责接受客户端连接并创建新线程处理客户端请求。
    • ClientHandler类：实现Runnable接口，处理客户端请求，广播消息给所有客户端。
    • ChatClient类：客户端主类，连接到服务器，发送和接收消息。
6. 性能优化

  • 多线程：

    • 使用多线程可以同时处理多个客户端的请求，提高服务器的并发能力。
    • 但是需要注意线程安全问题，避免数据竞争。

  • 非阻塞I/O：

    • 非阻塞I/O可以在没有数据可读或可写时立即返回，提高程序的响应速度。
    • 适用于高并发场景，但实现复杂度较高。

  • 连接池：

    • 连接池可以复用已建立的连接，减少连接建立和销毁的开销。
    • 提高系统的整体性能。
7. 常见问题及解决方案

  • Q: 为什么我的服务器只能处理一个客户端请求？

    • A: 可能是因为你的服务器是单线程的。尝试使用多线程或非阻塞I/O来处理多个客户端请求。

  • Q: 如何处理大数据传输？

    • A: 可以使用缓冲区和循环读写的方式来处理大数据传输。例如，每次读取一部分数据，处理完后再读取下一部分。

  • Q: 如何确保数据的安全性？

    • A: 可以使用SSL/TLS协议来加密数据传输，确保数据的安全性。Java提供了SSLSocket和SSLServerSocket类来实现这一功能。
结论

通过今天的探讨，我们深入理解了网络编程的基础知识，从TCP和UDP编程到多线程服务器和非阻塞I/O，再到实战演练和性能优化。每一种技术都有其特定的应用场景和优势。合理使用这些技术可以显著提升程序的性能和稳定性。希望这篇文章能帮助你在网络编程的道路上更加自信和从容。如果你有任何疑问或想法，欢迎随时留言交流。让我们在编程的世界里，一起探索更多的可能性！

互动环节

如果你对网络编程有任何疑问，或者想了解更多关于网络编程的高级用法，欢迎在评论区留言。我们可以一起讨论，共同进步！

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
全角字符unicode码对应表
除了feign，推荐你另外4种http客户端
数据库开发：MySQL基础（二）
最全C语言个人笔记【第二章节-数据类型-运算符-位运算】
python--统计列表中不同元素的数量
Transformer训练过程、推理过程详解
提升大模型内容创作能力
单例模式之「双重校验锁」
Docker整合ELK+SpringBoot详解
【C++】string类（上）
;