Java處理多API請求的方法詳解

更新時間：2023年10月13日 15:39:38 作者：Mey

Java?中的并發(fā)是指語言并行運行多個線程的能力,允許同時執(zhí)行多個任務,

線程池和Executor框架

一種方法是使用線程池來管理固定數量的線程，這些線程可以處理傳入的請求。Java Executor 框架提供了一種方便的方法來實現(xiàn)這種方法，換句話說，使用線程池和 Executor 框架是在 Java 中實現(xiàn)并發(fā)和處理多個 API 請求的一種方法。

線程池管理固定數量的線程，可以有效利用系統(tǒng)資源，防止線程饑餓。

什么是執(zhí)行器框架？

Executor 框架是一個內置的 Java 框架，它提供了一種管理和執(zhí)行線程的方法。它是 java.util.concurrent 包的一部分，在 Java 5 中引入。

Executor 框架在低級 Thread 類上提供了更高級別的抽象，從而更容易并發(fā)執(zhí)行任務，而無需直接管理線程。它還提供了一種方法來管理線程池并重用它們來執(zhí)行多個任務，從而減少創(chuàng)建和銷毀線程的開銷。

Executor框架的核心接口是Executor接口，它定義了一個單一的方法execute(Runnable)。Executor 接口提供了一種提交 Runnable 任務以供執(zhí)行的方法。該框架還提供了一些子接口和類，可以用來實現(xiàn)不同類型的Executor，例如：

ExecutorService：一個 Executor，它提供管理終止的方法和可以生成用于跟蹤一個或多個異步任務進度的 Future 的方法。
ScheduledExecutorService：一個 ExecutorService，它可以安排命令在給定延遲后運行，或定期執(zhí)行。
ThreadPoolExecutor：一個 ExecutorService，它使用可能的多個池線程之一執(zhí)行每個提交的任務，通常使用 Executors 工廠方法配置。

使用 Executor 框架可以幫助您以高效的方式處理多個 API 請求，方法是管理線程并提供一種將它們重用于多個任務的方法，從而減少創(chuàng)建和銷毀線程的開銷。

下面是一個如何使用 Executor 框架高效處理多個 API 請求的示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorExample {
    public static void main(String[] args) {
        // Create a fixed thread pool with 5 threads
        ExecutorService executor = Executors.newFixedThreadPool(5);
        // Submit 10 tasks for execution
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    // Perform an API request here
                    // For example, using the OkHttp library:
                    // OkHttpClient client = new OkHttpClient();
                    // Request request = new Request.Builder()
                    //          .url("https://example.com/api/task" + taskId)
                    //          .build();
                    // Response response = client.newCall(request).execute();
                    // Do something with the response
                    System.out.println("Task " + taskId + " completed");
                }
            });
        }
        // Shut down the executor
        executor.shutdown();
    }
}

在本例中，我們使用Executors.newFixedThreadPool方法創(chuàng)建一個具有 5 個線程的固定線程池。然后，我們使用該executor.submit方法提交 10 個要執(zhí)行的任務。每個任務代表一個 API 請求，該請求將由線程池中的線程之一執(zhí)行。

提交所有任務后，shutdown()調用執(zhí)行器的方法，啟動線程池的關閉。池中的線程將執(zhí)行完提交的任務，然后終止。

請注意，在此示例中，我添加了一個用于發(fā)出 API 請求的虛擬代碼，它不起作用，您必須使用特定的庫（如 OkHttp 或 Retrofit）來進行 API 調用。

您可以在這個示例中看到，通過重用固定數量的線程并通過 Executor 框架管理任務的執(zhí)行，我們能夠并發(fā)且高效地處理多個 API 請求。

異步 I/O 庫

在 Java 中實現(xiàn)并發(fā)的另一種方法是通過使用異步 I/O (AIO) 庫，它允許非阻塞 I/O 操作，并且可以處理大量并發(fā)連接。

異步 I/O 庫是一個允許非阻塞 I/O 操作的庫，這意味著程序可以在等待 I/O 操作完成的同時繼續(xù)執(zhí)行其他任務。這在處理大量并發(fā)連接時很有用，例如在構建高性能服務器時。

Java 中異步 I/O 庫的一個例子是 Java NIO 包，自 Java 1.4 以來它是標準 Java 庫的一部分。它提供了一組用于執(zhí)行非阻塞 I/O 操作的類和接口。

下面是一個如何使用 Java NIO 包構建可以同時處理多個客戶端的簡單服務器的示例：

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 NioServer {
    public static void main(String[] args) throws IOException {
        // Open a selector
        Selector selector = Selector.open();
        // Open a server socket channel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(8080));
        serverSocket.configureBlocking(false);
        // Register the server socket channel with the selector
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            // Wait for events
            selector.select();
            // Iterate over the events
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // Handle a new connection
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel client = channel.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                }
                // Handle a read event
                if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int read = client.read(buffer);
                    if (read > 0) {
                        buffer.flip();
                        String message = new String(buffer.array(), 0, read);
                        System.out.println("Received: " + message);
                    }
                }
                iterator.remove();
            }
        }
    }
}

在這個例子中，我們首先打開一個Selector對象和一個ServerSocketChannel. 被ServerSocketChannel配置為非阻塞的并注冊到Selector. 然后我們進入一個無限循環(huán)，等待已注冊頻道上的事件。

當接受新連接時，我們SocketChannel為客戶端創(chuàng)建一個新連接并將其注冊到Selectorfor read 事件。當檢測到讀取事件時，我們將數據從客戶端讀取到緩沖區(qū)中并將其打印到控制臺。

可以看到，通過使用 Java NIO 包，我們可以同時處理多個客戶端，而不會阻塞程序的執(zhí)行。Selector以及ServerSocketChannel。

OkHttp 和 Retrofit

使用像 OkHttp 或 Retrofit 這樣的庫的概念也與并發(fā)密切相關，因為它抽象了底層網絡和線程實現(xiàn)，使開發(fā)人員可以輕松高效地處理多個請求。

OkHttp

OkHttp 是一個流行的 Java 庫，用于發(fā)出 HTTP 請求。它為執(zhí)行同步和異步請求提供了一個簡單高效的 API。它還包括連接池、透明 GZIP 壓縮和響應緩存等功能。

下面是如何使用 OkHttp 在多線程環(huán)境中發(fā)出異步 GET 請求的示例。

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
public class OkHttpAsyncExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/todos/1")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful()) {
                    throw new IOException("Unexpected code " + response);
                }
                String responseBody = response.body().string();
                System.out.println(responseBody);
            }
        });
    }
}

在這個例子中，我們首先創(chuàng)建一個實例，OkHttpClient它是線程安全的，可以被多個請求共享。然后我們創(chuàng)建一個新Request對象，指定我們要調用的 URL。

然后我們使用該enqueue方法異步執(zhí)行請求。該enqueue方法采用一個Callback對象，在請求完成或失敗時調用該對象。在此示例中，我們在成功時打印響應主體，在失敗時打印異常堆棧跟蹤。

當你有多個傳入的 API 請求時，你可以對所有請求使用同一個 OkHttpClient 實例，所有請求都將由 OkHttp 異步處理。該enqueue方法立即返回，允許您的應用程序在后臺獲取響應的同時繼續(xù)處理其他請求或任務。這有助于防止阻塞程序的執(zhí)行并確保在處理大量并發(fā)連接時具有良好的性能。

改裝

下面是如何使用 Retrofit 在多線程環(huán)境中發(fā)出異步 GET 請求的示例。

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class RetrofitAsyncExample {
    public static void main(String[] args) {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://jsonplaceholder.typicode.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        JsonPlaceholderApi jsonPlaceholderApi = retrofit.create(JsonPlaceholderApi.class);
        Call<Todo> call = jsonPlaceholderApi.getTodo(1);
        call.enqueue(new Callback<Todo>() {
            @Override
            public void onResponse(Call<Todo> call, Response<Todo> response) {
                if (!response.isSuccessful()) {
                    System.out.println("Unexpected code " + response);
                    return;
                }
                Todo todo = response.body();
                System.out.println(todo);
            }
            @Override
            public void onFailure(Call<Todo> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }
}
interface JsonPlaceholderApi {
    @GET("todos/{id}")
    Call<Todo> getTodo(@Path("id") int id);
}
class Todo {
    int userId;
    int id;
    String title;
    boolean completed;
    // getters and setters
}

在此示例中，我們首先Retrofit通過指定我們要調用的 API 的基本 URL 并添加一個 GSON 轉換器工廠來創(chuàng)建一個實例。JsonPlaceholderApi然后我們使用 Retrofit 的方法創(chuàng)建一個接口create的實現(xiàn)來獲取服務的實現(xiàn)。

然后我們調用getTodo接口的方法，傳遞我們要檢索的待辦事項的 ID。這將返回一個Call對象，我們可以使用該對象通過調用異步執(zhí)行請求enqueue。

該enqueue方法采用一個Callback對象，在請求完成或失敗時調用該對象。在此示例中，我們在成功時打印響應主體，在失敗時打印異常堆棧跟蹤。

當你有多個傳入的 API 請求時，你可以對所有請求使用相同的 Retrofit 實例，所有請求將由 Retrofit 異步處理。該enqueue方法立即返回，允許您的應用程序在后臺獲取響應的同時繼續(xù)處理其他請求或任務。這有助于防止阻塞程序的執(zhí)行并確保在處理大量并發(fā)連接時具有良好的性能。

總之，以高效方式處理多個 API 請求的概念與 Java 中的并發(fā)性密切相關，可以通過使用線程池、異步 I/O (AIO) 庫以及 OkHttp 或 Retrofit 等庫來實現(xiàn)。

以上就是Java處理多API請求的方法詳解的詳細內容，更多關于Java處理多API請求的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: