Sokongan protokol HTTP2 Java 9 dan analisis API HTTP tidak menyekat

1. Pengenalan kepada HTTP/2

HTTP/2 bertujuan untuk mengurangkan kesakitan yang disebabkan oleh mengekalkan infrastruktur HTTP/1.1 yang kompleks dan mempunyai prestasi yang baik. Walaupun HTTP/2 masih serasi ke belakang dengan HTTP/1.1, ia bukan lagi protokol berasaskan teks.

Pemultipleksan HTTP/2 membolehkan sambungan tunggal mengendalikan berbilang aliran dwiarah, membolehkan pelanggan memuat turun berbilang sumber secara serentak melalui satu sambungan.

Protokol HTTP 1.x adalah berasaskan teks, jadi mesejnya sangat panjang. Kadangkala, set pengepala HTTP yang sama ditukar berulang kali. HTTP/2 mengekalkan Pengepala HTTP merentasi permintaan, menghapuskan pertukaran data berulang dan mengurangkan lebar jalur yang diperlukan untuk interaksi data.

Tolak Data HTTP/2

Anda mungkin berfikir bahawa tolakan data sebelah pelayan HTTP/2 adalah sejenis kesinambungan atau naik taraf kepada WebSockets, tetapi ini tidak berlaku. Walaupun WebSockets ialah kaedah komunikasi dupleks penuh antara klien dan pelayan supaya pelayan menghantar data kepada klien selepas sambungan TCP diwujudkan, HTTP/2 menawarkan penyelesaian yang berbeza.

HTTP/2 push secara aktif menghantar sumber kepada pelanggan tanpa memulakan permintaan sumber daripada perspektif pelanggan. Ini bermakna pelayan mungkin mengetahui dari satu permintaan sumber lain yang diperlukan oleh tapak web selanjutnya, dan boleh menghantar semuanya bersama-sama (lebih awal) lama sebelum pelanggan memulakan permintaan untuknya lagi.

Klien HTTP Java kini menyokong HTTP/2

• Jetty

• Netty

• OkHttp

• Vert.x

• Firefly

Tetapi dalam artikel ini, kami akan tidak memperkenalkan perisian klien Java ini, tetapi memperkenalkan sokongan HTTP/2 yang disediakan oleh Java9.

2. Pelanggan HTTP/2 Java 9

Mula-mula gunakan sintaks Java 9 untuk mengimport modul. jdk.incubator.httpclient

module com.springui.echo.client {
    requires jdk.incubator.httpclient;
}

HTTP Cient API baharu Java 9 mengikut corak pembina. HttpClient ialah titik masuk yang digunakan untuk mengendalikan permintaan HTTP Ia dibina dahulu dan kemudian digunakan.

HttpClient client = HttpClient
    .newBuilder()
    .version(Version.HTTP_2)  //支持HTTP2
    .build();

Menghantar permintaan dalam mod menyekat

Setelah kami mempunyai tika HttpClient, kita boleh menggunakannya untuk menghantar kejadian HttpRequest juga boleh dibuat menggunakan pembina.

HttpResponse<String> response = client.send(
    HttpRequest
        .newBuilder(TEST_URI)  //请求地址
        .POST(BodyProcessor.fromString("Hello world")) //POST报文数据
        .build(),
    BodyHandler.asString()  //请求响应数据处理，接收字符串
);

Selepas permintaan dihantar, benang akan disekat sehingga data respons diperolehi Ini sama dengan API HTTP dalam JAVA 8 dan sebelumnya. Walau bagaimanapun, Java 9 menyediakan kaedah permintaan penghantaran dan pemprosesan tanpa sekatan tak segerak, yang lebih sesuai untuk permintaan dan pemprosesan HTTP yang sangat serentak.

Menghantar permintaan dalam mod tidak menyekat (Java 9)

Dalam contoh di bawah, 10 integer rawak dihantar secara tidak segerak.

List<CompletableFuture<String>> responseFutures = 
        IntStream.of(1,2,3,4,5,6,7,8,9,10)  //10个整数形成IntStream，Java 8的语法
        .mapToObj(String::valueOf) //10个整数转换成字符串，Java 8的语法
        .map(message -> client.sendAsync( //将10个整数字符串作为内容，发送10个异步请求
                HttpRequest.newBuilder(TEST_URI)
                        .POST(HttpRequest.BodyProcessor.fromString(message))
                        .build(),
                HttpResponse.BodyHandler.asString()
             ).thenApply(HttpResponse::body)  //以CompletableFuture<HttpResponse.body()>作为流处理的返回值
        )
        .collect(Collectors.toList());  //将Stream转成List

Contoh di atas menggunakan API penstriman Stream Java 8 secara meluas Jika anda tidak biasa dengannya, anda boleh membaca beberapa artikel yang telah saya tulis sebelum ini.

Nilai pulangan kaedah sendAsync, CompletableFuture>, diproses selanjutnya menggunakan thenApply(HttpResponse::body), dan nilai pulangan akhir ialah CompletableFuture.

CompletableFuture ialah pengetahuan tentang pengaturcaraan tak segerak Java, yang mencetak hasil pemprosesan tak segerak serentak.

responseFutures.stream().forEach(future -> {
    LOGGER.info("Async response: " + future.getNow(null));
});

Anda akan melihat bahawa log cetakan akhir mungkin tidak diproses dalam urutan 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, kerana semua permintaan Ia dihantar secara tak segerak, dan hasil yang dikembalikan ialah hasil CompletableFuture yang digunakan untuk pemprosesan tak segerak.

3. Push-Promise Frames yang menyokong HTTP2

Semua contoh di atas boleh dilengkapkan di bawah protokol HTTP/1.1, tetapi API tak segerak tidak menyekat baharu ditambah dan HTTP/ 2 ciri. Jangan risau, API Klien Java 9 disepadukan paling rapat dengan HTTP/2: anda boleh menggunakan HTTP2 untuk menghantar permintaan dan mendapatkan berbilang hasil data tak segerak. (Sesetengah data ditolak terlebih dahulu, sudah tentu, ini memerlukan pelayan juga menyokong HTTP/2 untuk kerjasama)

Map<HttpRequest,CompletableFuture<HttpResponse<String>>> responses =
        client.sendAsync(    //注意这里只发送一次请求
          HttpRequest.newBuilder(TEST_URI)
                  .POST(HttpRequest.BodyProcessor.fromString(TEST_MESSAGE))
                  .build(),
          HttpResponse.MultiProcessor.asMap(    //多个资源的响应结果
                  request -> Optional.of(HttpResponse.BodyHandler.asString())
          )
).join();
responses.forEach((request, responseFuture) -> {
  LOGGER.info("Async response: " + responseFuture.getNow(null));
});

Dari perspektif Java 9, API klien HTTP/2 baharu kelihatan baik. Namun, penulis merasakan penggunaan teknologi berkaitan pada masa ini masih belum terlalu matang, saya rasa semua orang boleh mencubanya buat masa ini.

Atas ialah kandungan terperinci Sokongan protokol HTTP2 Java 9 dan analisis API HTTP tidak menyekat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!