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

于 2024-10-07 06:00:00 发布
阅读量756 收藏 21
点赞数 30
分类专栏： Java学习 文章标签： java 学习 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z_344791576/article/details/142553763
版权

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

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

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，再到实战演练和性能优化。每一种技术都有其特定的应用场景和优势。合理使用这些技术可以显著提升程序的性能和稳定性。希望这篇文章能帮助你在网络编程的道路上更加自信和从容。如果你有任何疑问或想法，欢迎随时留言交流。让我们在编程的世界里，一起探索更多的可能性！

互动环节

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

墨瑾轩
关注
专栏目录
揭秘控制流的秘密：Java中的if, for, while，你真的会用吗？
qq_44771627的博客
07-10 295
在编程的浩瀚宇宙中，控制流语句如同星辰，引领着代码的航向。今天，我们将深入探讨Java中至关重要的控制流语句——ifforwhile，以及它们的变体。无论你是一名初学者，还是有着丰富经验的开发者，这篇文章都将带你领略控制流的深层魅力，让你的代码更加高效、优雅。
从搬砖工到架构师，Java全栈学习路线总结
热门推荐
zhangxia_的博客
05-07 2万+
Java 全栈开发技术是一种整合多种技术的开发方式，涉及众多领域，如：前端、后端、数据库等。Java 全栈开发技术的全面普及，使得该领域成为了就业和职业发展的焦点。为了快速入门 Java 全栈开发，我们可以从下面的路线开始学习。 Java 全栈开发需要不断地学习和实践，掌握优秀的编程习惯和实现技巧非常重要。在 Java 全栈开发的旅途中，我们需要关注技术的动态发展，随时更新自己的技能和知识体系。
【Java学习】5个技巧揭秘：Java中的常量，你真的用对了吗？
java专栏
09-28 1276
常量是值在程序运行过程中不会改变的变量。在Java中，通常使用final关键字来声明常量。一旦一个变量被声明为final，它的值就不能再被修改。示例代码// 声明并初始化一个常量// 错误：不能重新赋值深度解析常量的主要作用是确保某些值在整个程序中保持不变，从而提高代码的可读性和可维护性。例如，使用常量来表示数组的最大长度，可以避免硬编码带来的风险。
【Java学习】3大技巧揭秘：Java中的变量与常量，你真的用对了吗？
java专栏
09-28 846
变量是存储数据的容器，它的值可以在程序运行过程中发生变化。在Java中，声明变量时需要指定类型，这决定了它可以存储的数据种类。
Java编程基本功大揭秘 | 详解深入分析Java的并发编程多线程技术，掌握实战技巧【1】
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
06-28 788
有些线程由于其重要性，即使在遇到异常后也会选择继续执行，不受中断影响，在大多数情况下，线程会将中断视为一个请求其终止的信号，并据此作出相应处理。这种机制的一个实际应用是，我们可以通过替换处理器，使用日志API将未捕获的异常报告自动发送到日志文件中，从而实现自动化的异常跟踪与记录。检查当前正在执行命令的线程是否被中断，需要注意的是，这一操作是通过调用一个静态方法来实现的。：掌握编程基本功可以提高你的编程效率。当你熟悉基本的语法和常用的编程技巧时，你能够更快地编写代码，减少错误和调试的时间，提高开发效率。
大学生的福音，学习 Java 最强书单推荐，附学习方法
沉默王二
09-06 9113
妈妈再也不用担心我的学习了。
Java中一个类可以继承多个类吗？揭秘多重继承的秘密！
孤芳不自赏
07-07 6285
在竞争激烈的职场中，面试是展现自己的绝佳机会。面试题是雇主了解我们技能和潜力的窗口。让我们一起揭开面试题的面纱，探索如何在这个关键时刻展现出最好的自己。
大专学历想0基础学编程以后找工作可行吗 ?
weixin_51689029的博客
07-22 656
学前导读从传统关系型数据库入手，掌握数据迁移工具、BI数据可视化工具、SQL，对后续学习打下坚实基础。1.大数据数据开发基础MySQL8.0从入门到精通MySQL是整个IT基础课程，SQL贯穿整个IT人生，俗话说，SQL写的好，工作随便找。本课程从零到高阶全面讲解MySQL8.0，学习本课程之后可以具备基本开发所需的SQL水平。2022最新MySQL知识精讲+mysql实战案例_零基础mysql数据库入门到高级全套教程第二阶段大数据核心基础学前导读阶段一基础入门。...
黑马程序员笔记：小白必看——Java学习路线
Future_yzx的博客
07-24 557
Java面试宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发，jvm等java面试真题）以100+企业大厂真实高频Java面试真题为主干，辅以数据结构的可视化展示、算法的可视化展示，窥探底层的工具使用等等可视化手段，用直观、形象的方式展现复杂的知识内容，让学生更清晰、更容易地掌握这些Java面试题与Java知识点。同时在多通道的加持下，通过智能动态的通道评级、选举、降级、热插拔，增强了系统的健壮性，摆脱对单一通道的依赖，并且提供多种对接方式，满足企业内部的各种需求。
构建高效稳定网络：揭秘Java网络编程的5大核心策略
[构建高效稳定网络：揭秘Java网络编程的5大核心策略](https://cdn.educba.com/academy/wp-content/uploads/2023/01/Java-NIO-1.jpg) # 1. Java网络编程概述 ## 1.1 网络编程的重要性 网络编程是构建分布式系统和...
高效网络编程：Guava库10个实用技巧揭秘
[高效网络编程：Guava库10个实用技巧揭秘](https://opengraph.githubassets.com/8fa6dd12bf2e11e92e58e8098f1277431b6b3e0d7b70f61f4a41747f69991525/google/guava) # 1. Guava库概述与网络编程基础 网络编程是构建...
揭秘Java接口奥秘：从基础到高级应用的10大核心技巧
[揭秘Java接口奥秘：从基础到高级应用的10大核心技巧](https://i2.wp.com/javatechonline.com/wp-content/uploads/2021/05/Default-Method-1-1.jpg?w=972&ssl=1) # 1. Java接口的基本概念与特性 ## Java接口的定义...
【Java集合框架揭秘】：List转String的7个高效技巧，让你代码飞起来！
[【Java集合框架揭秘】：List转String的7个高效技巧，让你代码飞起来！](https://www.javastring.net/wp-content/uploads/java-string-join-multiple-array-elements.png) # 1. Java集合框架基础知识 Java集合框架...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 206
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 455
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 893
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 556
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 804
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

墨瑾轩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值