Java面试黄金宝典36

已于 2025-04-05 11:24:05 修改
阅读量831 收藏 9
点赞数 17
CC 4.0 BY-SA版权
分类专栏： Java面试黄金宝典 文章标签： java 面试 排序算法 面经 算法 职场和发展
于 2025-04-05 11:21:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ylfhpy/article/details/147008977

1. 数据库行锁适用场景

 

行锁是数据库中一种锁定粒度较小的锁机制，它仅对当前操作涉及的行进行加锁。以下是其常见适用场景：

  1. 高并发下的数据更新：在多用户同时对同一表的不同行进行更新操作时，行锁能保证数据的一致性。例如电商系统中，多个用户同时购买不同商品，对商品库存表的不同行进行更新，使用行锁可避免数据冲突。
  2. 数据的部分修改：当仅需修改表中的某几行数据时，使用行锁能减少对其他行的影响，提升并发性能。比如在用户信息表中，只修改特定用户的部分信息。
  • 定义

数据库行锁是数据库管理系统（DBMS）提供的一种锁机制，用于在并发环境下控制对数据库表中特定行的访问。当一个事务对某一行加锁后，其他事务在该锁释放之前无法对该行进行写操作，但读操作（在共享锁的情况下）通常不受影响，以此保证数据的一致性和完整性。

  • 要点
  1. 适用于高并发下的数据更新场景，保障数据一致性。
  2. 可减少对其他行的影响，提高并发性能。
  3. 注意锁的持有时间，避免长时间持有锁导致性能下降。
  • 应用

在金融交易系统中，账户余额的更新操作需要保证数据的一致性。当多个用户同时进行转账操作时，对涉及的账户行加行锁，可防止出现数据不一致的情况，如余额错误等。

代码示例（以 MySQL 为例）

sql

-- 开启事务
START TRANSACTION;

-- 对特定行加行锁
SELECT * FROM account WHERE account_id = 1 FOR UPDATE;

-- 模拟更新操作
UPDATE account SET balance = balance - 100 WHERE account_id = 1;

-- 提交事务
COMMIT;

 

2. HTTP 请求报文、HTTP 响应报文

 

  1. HTTP 请求报文：由请求行、请求头和请求体三部分构成。请求行包含请求方法（如 GET、POST 等）、请求的 URL 和 HTTP 协议版本；请求头包含一系列键值对，用于传递请求的附加信息，如用户代理、请求的内容类型等；请求体可选，用于传递请求的数据，如表单数据、JSON 数据等。
  2. HTTP 响应报文：由状态行、响应头和响应体三部分构成。状态行包含 HTTP 协议版本、状态码和状态描述；响应头包含一系列键值对，用于传递响应的附加信息，如服务器类型、响应的内容类型等；响应体包含服务器返回的数据，如 HTML 页面、JSON 数据等。
  • 定义

HTTP 请求报文是客户端向服务器发送请求时使用的消息格式，用于描述客户端的请求信息和数据。HTTP 响应报文是服务器接收到客户端请求后，返回给客户端的消息格式，用于描述请求的处理结果和返回的数据。

  • 要点
  1. 理解请求报文和响应报文的组成结构。
  2. 掌握常见请求头和响应头的含义。
  3. 注意请求体和响应体的数据格式。
  • 应用

在 Web 开发中，前端页面通过发送 HTTP 请求报文向服务器请求数据，服务器处理请求后返回 HTTP 响应报文，前端根据响应报文渲染页面。例如，在电商网站中，用户点击商品详情页，前端发送请求获取商品信息，服务器返回商品信息的响应。

代码示例（Java 使用 HttpURLConnection 发送请求并获取响应）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println("Response Body: " + response.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

3. HTTP 报文头部（请求头和响应头）

 

  • 常见请求头：
    1. User - Agent：用于标识客户端的类型和版本，如浏览器类型、操作系统等。
    2. Accept：指定客户端能够接受的响应内容类型，如 text/html、application/json 等。
    3. Content - Type：指定请求体的内容类型，如 application/x - www - form - urlencoded、application/json 等。
    4. Cookie：用于在客户端和服务器之间传递会话信息。
  • 常见响应头：
    1. Server：标识服务器的类型和版本。
    2. Content - Type：指定响应体的内容类型。
    3. Set - Cookie：用于在客户端设置 cookie。
    4. Cache - Control：控制缓存的策略，如 no - cache、max - age 等。
  • 定义

HTTP 报文头部是 HTTP 请求报文和响应报文的一部分，由一系列键值对组成，用于传递与请求或响应相关的附加信息。这些信息可以影响请求的处理方式、响应的缓存策略、客户端和服务器的行为等。

  • 要点
  1. 熟悉常见请求头和响应头的含义和用途。
  2. 能够根据业务需求设置合适的请求头和处理响应头。
  • 应用

在前后端分离的开发中，通过设置合适的请求头和处理响应头，可以实现跨域请求、缓存控制等功能。例如，在开发一个移动端应用时，通过设置 User - Agent 让服务器识别客户端类型，返回合适的响应。

代码示例（Java 设置请求头和获取响应头）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;
import java.util.Map;

public class HttpHeaderExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            // 设置请求头
            connection.setRequestProperty("User - Agent", "MyApp/1.0");

            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            // 获取响应头
            Map<String, List<String>> headers = connection.getHeaderFields();
            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println("Response Body: " + response.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

4. HTTP 请求方法

 

  1. GET：用于从服务器获取资源，请求参数通常附加在 URL 后面。
  2. POST：用于向服务器提交数据，请求参数通常放在请求体中。
  3. PUT：用于更新服务器上的资源，如果资源不存在则创建。
  4. DELETE：用于删除服务器上的资源。
  5. HEAD：与 GET 方法类似，但只返回响应头，不返回响应体，用于获取资源的元信息。
  6. OPTIONS：用于获取服务器支持的请求方法和其他相关信息。
  • 定义

HTTP 请求方法是客户端向服务器发送请求时使用的指令，用于指定请求的操作类型。不同的请求方法具有不同的语义和用途，服务器根据请求方法来决定如何处理请求。

  • 要点
  1. 理解不同请求方法的语义和用途。
  2. 根据业务需求选择合适的请求方法。
  • 应用

在 RESTful 架构中，通常使用不同的 HTTP 请求方法来实现对资源的增删改查操作。例如，在一个博客系统中，使用 GET 方法获取文章列表，使用 POST 方法发布新文章，使用 PUT 方法更新文章内容，使用 DELETE 方法删除文章。

代码示例（Java 使用不同请求方法）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpMethodExample {
    public static void main(String[] args) {
        try {
            // GET 请求
            URL getUrl = new URL("https://www.example.com/api/articles");
            HttpURLConnection getConnection = (HttpURLConnection) getUrl.openConnection();
            getConnection.setRequestMethod("GET");
            int getResponseCode = getConnection.getResponseCode();
            System.out.println("GET Response Code: " + getResponseCode);

            // POST 请求
            URL postUrl = new URL("https://www.example.com/api/articles");
            HttpURLConnection postConnection = (HttpURLConnection) postUrl.openConnection();
            postConnection.setRequestMethod("POST");
            postConnection.setRequestProperty("Content - Type", "application/json");
            postConnection.setDoOutput(true);
            String postData = "{\"title\": \"New Article\", \"content\": \"This is a new article.\"}";
            OutputStream os = postConnection.getOutputStream();
            os.write(postData.getBytes());
            os.flush();
            os.close();
            int postResponseCode = postConnection.getResponseCode();
            System.out.println("POST Response Code: " + postResponseCode);

            // PUT 请求
            URL putUrl = new URL("https://www.example.com/api/articles/1");
            HttpURLConnection putConnection = (HttpURLConnection) putUrl.openConnection();
            putConnection.setRequestMethod("PUT");
            putConnection.setRequestProperty("Content - Type", "application/json");
            putConnection.setDoOutput(true);
            String putData = "{\"title\": \"Updated Article\", \"content\": \"This is an updated article.\"}";
            OutputStream putOs = putConnection.getOutputStream();
            putOs.write(putData.getBytes());
            putOs.flush();
            putOs.close();
            int putResponseCode = putConnection.getResponseCode();
            System.out.println("PUT Response Code: " + putResponseCode);

            // DELETE 请求
            URL deleteUrl = new URL("https://www.example.com/api/articles/1");
            HttpURLConnection deleteConnection = (HttpURLConnection) deleteUrl.openConnection();
            deleteConnection.setRequestMethod("DELETE");
            int deleteResponseCode = deleteConnection.getResponseCode();
            System.out.println("DELETE Response Code: " + deleteResponseCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

5. HTTP 请求过程

 

一个完整的 HTTP 请求过程通常包含以下步骤：

  1. DNS 解析：客户端依据请求的域名，通过 DNS 服务器将域名解析为对应的 IP 地址。
  2. TCP 连接：客户端使用解析得到的 IP 地址和端口号，与服务器建立 TCP 连接。
  3. HTTP 请求发送：客户端向服务器发送 HTTP 请求报文，包含请求行、请求头和请求体。
  4. 服务器处理请求：服务器接收到请求后，进行解析和处理，根据请求的内容生成响应报文。
  5. HTTP 响应返回：服务器将生成的响应报文发送给客户端，包含状态行、响应头和响应体。
  6. TCP 连接关闭：客户端和服务器关闭 TCP 连接。
  • 定义

HTTP 请求过程是指客户端与服务器之间通过 HTTP 协议进行通信的一系列步骤，从客户端发起请求开始，到服务器返回响应结束。这个过程涉及到 DNS 解析、TCP 连接建立、HTTP 报文传输、服务器处理请求和响应返回等环节。

  • 要点
  1. 理解 HTTP 请求过程的各个步骤。
  2. 注意 DNS 解析、TCP 连接和 HTTP 请求的顺序和关系。
  • 应用

在网络爬虫开发中，需要模拟 HTTP 请求过程来获取网页内容。通过了解 HTTP 请求过程，可以更好地处理网络请求，提高爬虫的效率和稳定性。

代码示例（Java 模拟 HTTP 请求过程）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.net.URL;

public class HttpProcessExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            // DNS 解析
            InetAddress address = InetAddress.getByName(url.getHost());
            System.out.println("IP Address: " + address.getHostAddress());

            // TCP 连接
            Socket socket = new Socket(address, 80);

            // HTTP 请求发送
            String request = "GET / HTTP/1.1\r\n";
            request += "Host: " + url.getHost() + "\r\n";
            request += "Connection: close\r\n\r\n";
            socket.getOutputStream().write(request.getBytes());

            // 读取 HTTP 响应
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();

            // TCP 连接关闭
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

6. GET 和 POST 区别

 

  • 参数传递方式：
    1. GET：请求参数附加在 URL 后面，以键值对的形式出现，多个参数之间用 & 分隔。
    2. POST：请求参数放在请求体中，不显示在 URL 上。
  • 安全性：
    1. GET：由于参数暴露在 URL 上，安全性较低，不适合传递敏感信息。
    2. POST：参数放在请求体中，相对更安全。
  • 数据长度限制：
    1. GET：URL 有长度限制，因此 GET 请求传递的数据长度有限。
    2. POST：理论上对数据长度没有限制。
  • 缓存性：
    1. GET：通常可以被缓存，因为请求的资源是固定的。
    2. POST：一般不会被缓存。
  • 定义

GET 和 POST 是 HTTP 协议中两种常用的请求方法，它们在参数传递方式、安全性、数据长度限制和缓存性等方面存在差异。GET 方法主要用于从服务器获取资源，POST 方法主要用于向服务器提交数据。

  • 要点
  1. 理解 GET 和 POST 在参数传递、安全性、数据长度和缓存性等方面的区别。
  2. 根据业务需求选择合适的请求方法。
  • 应用

在登录页面中，由于涉及到用户的敏感信息（如密码），通常使用 POST 方法提交表单，以保证信息的安全性。而在搜索页面中，使用 GET 方法可以方便用户分享搜索链接，同时也可以利用缓存提高性能。

代码示例（Java 发送 GET 和 POST 请求）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;

public class GetPostExample {
    public static void main(String[] args) {
        try {
            // GET 请求
            String getUrl = "https://www.example.com/search?keyword=" + URLEncoder.encode("java", "UTF - 8");
            URL url = new URL(getUrl);
            HttpURLConnection getConnection = (HttpURLConnection) url.openConnection();
            getConnection.setRequestMethod("GET");
            int getResponseCode = getConnection.getResponseCode();
            System.out.println("GET Response Code: " + getResponseCode);

            BufferedReader getReader = new BufferedReader(new InputStreamReader(getConnection.getInputStream()));
            String getLine;
            StringBuilder getResponse = new StringBuilder();
            while ((getLine = getReader.readLine()) != null) {
                getResponse.append(getLine);
            }
            getReader.close();
            System.out.println("GET Response Body: " + getResponse.toString());

            // POST 请求
            URL postUrl = new URL("https://www.example.com/login");
            HttpURLConnection postConnection = (HttpURLConnection) postUrl.openConnection();
            postConnection.setRequestMethod("POST");
            postConnection.setRequestProperty("Content - Type", "application/x - www - form - urlencoded");
            postConnection.setDoOutput(true);
            String postData = "username=test&password=123456";
            OutputStream os = postConnection.getOutputStream();
            os.write(postData.getBytes());
            os.flush();
            os.close();
            int postResponseCode = postConnection.getResponseCode();
            System.out.println("POST Response Code: " + postResponseCode);

            BufferedReader postReader = new BufferedReader(new InputStreamReader(postConnection.getInputStream()));
            String postLine;
            StringBuilder postResponse = new StringBuilder();
            while ((postLine = postReader.readLine()) != null) {
                postResponse.append(postLine);
            }
            postReader.close();
            System.out.println("POST Response Body: " + postResponse.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

7. HTTP 状态码

 

HTTP 状态码用于表示 HTTP 请求的结果，由三位数字组成，分为以下几类：

  • 1xx（信息性状态码）：表示请求已被接收，继续处理。例如，100 Continue 表示客户端可以继续发送请求体。
  • 2xx（成功状态码）：表示请求已成功处理。例如，200 OK 表示请求成功，201 Created 表示资源已成功创建。
  • 3xx（重定向状态码）：表示需要进一步的操作才能完成请求。例如，301 Moved Permanently 表示资源已永久移动，302 Found 表示资源临时移动。
  • 4xx（客户端错误状态码）：表示客户端请求有错误。例如，400 Bad Request 表示请求语法错误，404 Not Found 表示请求的资源不存在。
  • 5xx（服务器错误状态码）：表示服务器在处理请求时发生错误。例如，500 Internal Server Error 表示服务器内部错误，503 Service Unavailable 表示服务器暂时不可用。

  • 定义

HTTP 状态码是服务器在响应 HTTP 请求时返回的三位数字代码，用于表示请求的处理结果。不同的状态码类别和具体代码传达了不同的信息，客户端可以根据状态码采取相应的处理措施。

  • 要点
  1. 熟悉常见 HTTP 状态码的含义。
  2. 能够根据状态码判断请求的结果，并进行相应的处理。
  • 应用

在 Web 开发中，根据不同的业务逻辑返回合适的状态码，有助于客户端正确处理响应。例如，在用户请求一个不存在的页面时，服务器返回 404 Not Found 状态码，让客户端知道请求的资源不存在。

代码示例（Java 根据状态码处理响应）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpStatusCodeExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            switch (responseCode / 100) {
                case 2:
                    System.out.println("Request succeeded.");
                    BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                    String line;
                    StringBuilder response = new StringBuilder();
                    while ((line = reader.readLine()) != null) {
                        response.append(line);
                    }
                    reader.close();
                    System.out.println("Response Body: " + response.toString());
                    break;
                case 3:
                    System.out.println("Redirecting...");
                    break;
                case 4:
                    System.out.println("Client error: " + responseCode);
                    break;
                case 5:
                    System.out.println("Server error: " + responseCode);
                    break;
                default:
                    System.out.println("Unknown status code: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

8. HTTP 长连接、短连接，HTTP 协议是无状态

 

  1. HTTP 短连接：客户端和服务器在完成一次请求 - 响应后，立即关闭 TCP 连接。每次请求都需要重新建立 TCP 连接，开销较大。
  2. HTTP 长连接：客户端和服务器在完成一次请求 - 响应后，不立即关闭 TCP 连接，而是保持连接一段时间，后续的请求可以复用该连接，减少了 TCP 连接的建立和关闭开销。
  3. HTTP 协议是无状态：指 HTTP 协议本身不记录客户端和服务器之间的交互状态。每次请求都是独立的，服务器无法知道客户端之前的请求信息。为了实现状态管理，通常使用 cookie、session 等技术。
  • 定义

HTTP 短连接是一种每次请求都建立新的 TCP 连接，请求完成后立即关闭连接的通信方式。HTTP 长连接是在一次 TCP 连接上可以进行多次请求 - 响应交互，连接在一段时间内保持打开的通信方式。HTTP 协议的无状态特性意味着服务器不会在不同请求之间保留客户端的状态信息。

  • 要点
  1. 理解 HTTP 短连接和长连接的区别和优缺点。
  2. 掌握 HTTP 协议无状态的概念和实现状态管理的方法。
  • 应用

在高并发的 Web 应用中，使用 HTTP 长连接可以减少 TCP 连接的建立和关闭开销，提高系统的性能。而在一些对安全性要求较高的场景中，使用 cookie 和 session 可以实现用户的身份验证和状态管理。

代码示例（Java 使用 HTTP 长连接）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpLongConnectionExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            // 设置长连接
            connection.setRequestProperty("Connection", "keep - alive");

            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println("Response Body: " + response.toString());

            // 再次使用该连接发送请求
            connection.setRequestMethod("GET");
            int secondResponseCode = connection.getResponseCode();
            System.out.println("Second Response Code: " + secondResponseCode);

            BufferedReader secondReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String secondLine;
            StringBuilder secondResponse = new StringBuilder();
            while ((secondLine = secondReader.readLine()) != null) {
                secondResponse.append(secondLine);
            }
            secondReader.close();

            System.out.println("Second Response Body: " + secondResponse.toString());

            // 关闭连接
            connection.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

9. HTTP1.1 与 HTTP1.0 的区别

 

  • 持久连接：
    1. HTTP1.0：默认使用短连接，每次请求都需要重新建立 TCP 连接。
    2. HTTP1.1：默认使用长连接，支持在一个 TCP 连接上发送多个请求，减少了连接建立和关闭的开销。
  • 请求头压缩：
    1. HTTP1.0：没有请求头压缩机制。
    2. HTTP1.1：引入了 Transfer - Encoding 和 Content - Encoding 等头信息，支持请求头和响应体的压缩，减少了数据传输量。
  • 请求方法和状态码：
    1. HTTP1.1：增加了一些新的请求方法（如 PUT、DELETE 等）和状态码，提供了更丰富的语义和功能。
  • 缓存机制：
    1. HTTP1.1：引入了更强大的缓存机制，如 Cache - Control 和 ETag 等，提高了缓存的效率和灵活性。
  • 定义

HTTP1.0 是 HTTP 协议的早期版本，它基于短连接，功能相对简单。HTTP1.1 是在 HTTP1.0 基础上进行改进和扩展的版本，引入了持久连接、请求头压缩、新的请求方法和状态码以及更强大的缓存机制，提高了性能和功能。

  • 要点
  1. 理解 HTTP1.1 在持久连接、请求头压缩、请求方法和状态码、缓存机制等方面的改进。
  2. 掌握这些改进对性能和功能的影响。
  • 应用

在现代 Web 开发中，大多数服务器和客户端都支持 HTTP1.1 协议。使用 HTTP1.1 的持久连接和缓存机制可以显著提高网站的性能和用户体验。例如，在电商网站中，通过缓存商品信息可以减少服务器的负载，提高页面加载速度。

代码示例（Java 使用 HTTP1.1 持久连接和缓存）

java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class Http11Example {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            // 使用 HTTP1.1 持久连接
            connection.setRequestProperty("Connection", "keep - alive");
            // 设置缓存控制
            connection.setRequestProperty("Cache - Control", "max - age=3600");

            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println("Response Body: " + response.toString());

            // 再次使用该连接发送请求
            connection.setRequestMethod("GET");
            int secondResponseCode = connection.getResponseCode();
            System.out.println("Second Response Code: " + secondResponseCode);

            BufferedReader secondReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String secondLine;
            StringBuilder secondResponse = new StringBuilder();
            while ((secondLine = secondReader.readLine()) != null) {
                secondResponse.append(secondLine);
            }
            secondReader.close();

            System.out.println("Second Response Body: " + secondResponse.toString());

            // 关闭连接
            connection.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

10. HTTP2.0 与 HTTP1.0 的区别

 

  • 二进制分帧：
    1. HTTP1.0：基于文本格式传输数据，解析效率低。
    2. HTTP2.0：采用二进制分帧的方式传输数据，将请求和响应拆分成多个二进制帧，提高了解析效率和传输性能。
  • 多路复用：
    1. HTTP1.0：同一时间只能处理一个请求，需要排队等待。
    2. HTTP2.0：支持多路复用，允许在一个 TCP 连接上同时发送多个请求和接收多个响应，提高了并发性能。
  • 头部压缩：
    1. HTTP1.0：没有头部压缩机制，请求头信息会占用大量的带宽。
    2. HTTP2.0：使用 HPACK 算法对请求头进行压缩，减少了头部信息的传输量。
  • 服务器推送：
    1. HTTP1.0：服务器只能被动响应客户端的请求。
    2. HTTP2.0：支持服务器推送，服务器可以主动向客户端发送资源，提前缓存到客户端，提高了页面加载速度。
  • 定义

HTTP1.0 是早期的 HTTP 协议版本，采用文本格式传输数据，功能和性能有限。HTTP2.0 是 HTTP 协议的新一代版本，通过引入二进制分帧、多路复用、头部压缩和服务器推送等特性，提高了传输性能、并发性能和页面加载速度。

  • 要点
  1. 理解 HTTP2.0 在二进制分帧、多路复用、头部压缩和服务器推送等方面的改进。
  2. 掌握这些改进对性能和用户体验的影响。
  • 应用

在高性能的 Web 应用中，如大型电商网站、视频网站等，使用 HTTP2.0 协议可以显著提高页面加载速度和用户体验。通过服务器推送，服务器可以提前将用户可能需要的资源发送到客户端，减少用户等待时间。

代码示例（Java 使用 okHttp 库支持 HTTP2.0）

java

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.io.IOException;

public class Http2Example {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
               .url("https://www.example.com")
               .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println("Response Code: " + response.code());
                System.out.println("Response Body: " + response.body().string());
            } else {
                System.out.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在运行上述代码前，需要在项目中添加 OkHttp 库的依赖。如果你使用的是 Maven 项目，可以在 pom.xml 中添加以下依赖：

xml

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.3</version>
</dependency>

 

 友情提示：本文已经整理成文档，可以到如下链接免积分下载阅读

https://download.csdn.net/download/ylfhpy/90568156

Java面试黄金宝典48
ylfhpy的博客
04-11 836
例如，在一个企业级 Java 项目中，不同的模块可能依赖于同一个库的不同版本，通过解决 Maven 冲突可以确保所有模块使用相同的、兼容的库版本。在分布式架构里，数据会分散存储在多个节点上，由于网络延迟、节点故障等因素，数据可能出现不一致的情况。过滤敏感评论是指通过建立敏感词库，将用户输入的评论与敏感词库进行匹配，如果匹配到敏感词，则对评论进行相应的处理，如替换、屏蔽等。：不但复制对象的成员变量值，当遇到指针类型的成员变量时，会另外开辟一块新的内存空间，接着把原指针指向的内容复制到新的内存空间。
Java面试黄金宝典46
ylfhpy的博客
04-10 643
Python 全局解释器锁（Global Interpreter Lock，GIL）是 Python 解释器中的一个互斥锁，确保同一时刻只有一个线程在解释器中执行 Python 字节码，以此保障 Python 内存管理的线程安全。其本质是自动化的数据采集过程。：Git 通过对象存储和引用管理代码版本，每次提交生成包含元数据和文件快照的提交对象，分支和标签是对提交对象的引用。：项目中的权限管理是根据用户角色和权限，控制用户对系统资源访问的机制，通常通过用户认证、角色分配和权限控制实现。
Java面试黄金宝典12
ylfhpy的博客
03-23 982
同时，不同的类加载器可以实现不同的加载策略，从而满足不同的应用场景需求，像在模块化开发中，每个模块可以使用独立的类加载器来加载自身的类。JVM 调优的核心是根据应用程序的内存使用情况和性能需求，合理分配资源，减少垃圾回收的频率和时间，提高程序的响应速度和吞吐量。Java 堆的实现是基于分代收集的思想，根据对象的存活时间将内存划分为不同的区域，不同的区域采用不同的垃圾回收算法，以提高垃圾回收的效率。例如，在类的方法中调用另一个类的方法时，最初使用的是符号引用，解析阶段会将其转换为实际的内存地址引用。
Java面试黄金宝典19
ylfhpy的博客
03-28 3325
它与快速排序算法有关，利用了快速排序中分区的思想，通过不断缩小搜索范围，只在包含目标元素的那一部分继续进行分区操作，从而避免对整个数组进行排序。通过二分查找在较短的数组上找到一个合适的分割点，使得两个数组分割后的左右两部分元素个数相等，并且左边部分的最大值小于等于右边部分的最小值，从而计算出两个有序数组的中位数。从三维数组的某个角开始，根据元素的大小关系，在三个维度上进行移动，直到找到目标元素或超出数组范围。利用二分查找的思想，通过比较中间元素和最右边元素的大小关系，不断缩小搜索范围，找到翻转点的下标。
Java面试黄金宝典33
ylfhpy的博客
04-04 3436
在游戏排行榜系统中，找出排名第三的玩家分数。：记录数据库的所有操作，包括用户登录、数据查询、插入、更新、删除等，以便在发生安全事件时进行审计和追溯。：在在线银行系统中，用户登录时需要输入用户名、密码和短信验证码进行身份验证，并且不同用户角色（如普通用户、管理员）具有不同的操作权限。：在高并发的电商系统中，使用 MySQL 5.7 的多线程复制可以更快地将主库的数据同步到从库，确保数据的一致性。：在设计用户信息表时，将用户的联系方式拆分为手机号码、电子邮箱等单独的字段，而不是将多个联系方式放在一个字段中。
Java面试黄金宝典21
ylfhpy的博客
03-29 782
然后找到这个异或结果中任意一位为 1 的位，根据这一位是否为 1 将数组中的元素分为两组，这样这两个只出现一次的数就会被分到不同的组中，最后分别对这两组元素进行异或运算，得到这两个只出现一次的数。对于一个数组，从第一个位置开始，依次将每个元素放到该位置，然后递归地对剩余的元素进行全排列，在递归过程中，若发现当前的选择无法得到有效的解，则回溯到上一步，尝试其他选择。根据异或运算的交换律和结合律，对数组中的所有元素进行异或运算，相同的元素异或结果为 0，最终剩下的就是只出现一次的数。
Java面试黄金宝典18
ylfhpy的博客
03-27 984
定义图算法是用于处理图数据结构的一系列算法。图由顶点和边构成，图算法能够解决图的遍历、最短路径、连通性、拓扑排序等问题。常见图算法深度优先搜索（DFS）：沿着图的深度遍历节点，尽可能深地搜索分支。广度优先搜索（BFS）：从起始节点开始，逐层地访问节点。Dijkstra 算法：用于求解单源最短路径问题。Floyd - Warshall 算法：用于求解所有节点对之间的最短路径问题。Kruskal 算法和 Prim 算法：用于求解最小生成树问题。应用社交网络分析：如好友推荐、社区发现。地图导航。
Java面试黄金宝典37
ylfhpy的博客
04-06 892
TCP 连接在不同阶段处于不同状态，主要有 CLOSED、LISTEN、SYN_SENT、SYN_RCVD、ESTABLISHED、FIN_WAIT_1、FIN_WAIT_2、CLOSE_WAIT、LAST_ACK、TIME_WAIT 等，状态根据不同事件转移，如建立连接、发送数据、接收数据、关闭连接等。滑动窗口机制是 TCP 流量控制和可靠性传输的核心机制，发送方维护发送窗口，接收方维护接收窗口，发送方根据接收方窗口大小调整发送窗口，确保发送数据不超过接收方接收能力。
Java面试黄金宝典31
ylfhpy的博客
04-03 662
next - key 锁是 GAP 锁和记录锁的组合，它不仅锁定索引记录本身，还锁定该记录之前的间隙。：GAP 锁是 MySQL 中 InnoDB 存储引擎在可重复读隔离级别下使用的一种锁，用于锁定索引记录之间的间隙，防止其他事务在这些间隙中插入新的记录，从而避免幻读问题。：事务在执行过程中分为两个阶段，第一阶段是扩展阶段，事务可以申请任何需要的锁，但不能释放已获得的锁；：分为不同的级别，如一级封锁协议可防止丢失修改，二级封锁协议在一级基础上可防止读 “脏” 数据，三级封锁协议能防止不可重复读。
Java面试黄金宝典：数据结构与算法实现详解
03-27
适合人群：具备一定编程基础，尤其是准备参加 Java 技术面试的研发人员。 使用场景及目标：帮助开发者深入理解常见数据结构和算法的工作原理，掌握其实现技巧，提升解决问题的能力。适用于面试准备和技术能力提升。 ...
Java面试黄金宝典：经典排序算法与数据结构详解
03-31
适合人群：准备参加Java相关岗位面试的技术人员，尤其是希望深入了解排序算法和常见数据结构的求职者。 使用场景及目标：帮助面试者掌握各种排序算法的工作原理、优缺点及适用场景，熟悉常用数据结构的特点和实现...
Java面试黄金宝典：经典算法与数据结构实现详解
03-26
内容概要：本文档详细介绍了 Java 编程中常见的面试题目及其解决方案，涵盖了二分查找、哈希表、位图、最小堆、自定义排序、快速排序、堆排序、括号匹配等多个经典算法和数据结构的应用。具体包括：如何在增序数组中...
【Java数据库开发】Java面试黄金宝典：数据库核心技术详解与应用实例
04-04
内容概要：本文档《Java面试黄金宝典33.docx》涵盖了多个与Java开发及数据库操作相关的知识点。首先介绍了存取控制、触发器、存储过程和游标的定义、要点及其应用实例，其中包括Java代码示例来演示如何实现存取控制...
Java面试黄金宝典：经典算法与数据结构详解及其应用场景
03-29
适合人群：具备一定编程基础，尤其是准备 Java 技术面试的研发人员和技术爱好者。 使用场景及目标：①帮助读者掌握常见算法和数据结构的基本概念和实现方法；②提供实际应用场景，加深对算法的理解和运用能力；③为...
模板的初阶
2401_88326089的博客
07-15 758
本文介绍 C++ 模板技术：函数模板和类模板通过类型参数化实现代码复用，前者可自动或显式实例化，后者需显式指定类型。模板优先精确匹配，普通函数支持自动类型转换。以 swap 和 Stack 为例说明其减少重复代码的优势，及声明定义分离的特殊语法。模板是泛型编程核心，能提升效率。
Java：继承和多态（必会知识点整理）
2301_80332713的博客
07-14 1170
继承 多态 向上转型 向下转型 方法重写 方法重载 super关键字 动态绑定 封装访问控制 构造方法规则
C++ Primer（第5版）- Chapter 7. Classes -003
skylijf的专栏
07-14 631
类似地，类的设计者也是为其用户设计并实现一个类的人。在这种情况下，类的用户是程序员，而非应用程序的最终使用者（）的函数是成员函数。我们的类不需要定义赋值运算，其原因将在7.1.5节（第267页）中介绍。由于在第14.1节（第555页）将要解释的原因，执行加法（）应用程序的用户，则意指运行该应用程序的书店管理者。类的用户，指的是使用此类的程序员。）决定了是指那种类型的用户。现在，我们先为这些运算定义普通的（命名的。）（参见1.5.2节，第23页），并且支持。程序员常把运行其程序的人称作用户（
Java Stream流详解
Broken_x的博客
07-14 1667
Java Stream流详解：从基础到原理 摘要 Java 8引入的Stream流是集合操作的函数式抽象，通过无存储、惰性计算等特性，构建高效的数据处理流水线。Stream解决了传统集合操作的三大痛点：简化代码（消除迭代样板）、提升可读性（声明式编程）、支持并行计算（Fork/Join框架）。使用流程分为创建Stream、中间操作（如filter/map）和终端操作（如collect/reduce）三步，支持链式调用和延迟执行。Stream API统一了不同数据源的处理方式，其底层通过Spliterator
非控制器（如 Service、工具类）中便捷地获取当前 HTTP 请求的上下文信息
最新发布
weixin_42456784的博客
07-16 842
Spring的RequestContextHolder工具类允许在Service层或工具类中直接获取当前HTTP请求上下文，无需通过参数传递。它基于ThreadLocal存储请求对象，提供静态方法获取HttpServletRequest/Response。适用于获取请求头、IP等场景，但需注意：1)仅Web线程有效，异步环境需额外处理；2)过度使用会增加代码耦合；3)线程安全但异步操作需手动传递上下文。该工具虽便利，但应合理使用以避免增加测试难度和系统耦合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值