JDK11新特性教程：轻松入门与实战-原创手记-慕课网

概述

本文提供了关于JDK11新特性教程的全面介绍，涵盖了本地变量类型推断、HTTP客户端改进、移除Java EE和CORBA模块以及私有密钥加密支持等内容。JDK 11作为长期支持版本，带来了多项重要更新，旨在提升开发效率和应用稳定性。文章还通过示例代码详细演示了这些新特性的实际应用。

JDK11新特性教程：轻松入门与实战

JDK11简介

JDK11发布背景

Java Development Kit (JDK) 11是Java平台的一个重要版本，它继续了OpenJDK社区对Java平台的月度发布计划。自Java 9引入模块系统以来，Java开发进入了一个新的阶段，JDK 11是这个阶段的一个重要里程碑。它的发布标志着长期支持（LTS）版本的开始，这意味着它将获得更长的支持周期，从而帮助企业和开发者更加稳定地使用和部署Java程序。

JDK11主要更新内容概述

JDK 11包含了多个新特性和改进，下面列出了一些主要的更新内容：

本地变量类型推断：允许使用var关键字简化变量声明。
HTTP客户端改进：提供了更强大、更灵活的HTTP客户端API。
移除Java EE和CORBA模块：这些模块在JDK 11中被移除，因为它们已经迁移到了外部项目。
私有密钥加密支持：提供了对私有密钥加密的支持。
其他改进：还包括了一些对垃圾回收器、类文件格式、平台运行时等方面的小改进。

引用本地变量

本地变量声明与使用

在Java中，本地变量是在方法内部声明并使用的变量。与全局变量不同，本地变量仅在方法内部有效。JDK 11引入了本地变量类型的推断功能，允许开发者使用var关键字声明变量时不需要显式指定其类型。

示例代码演示

下面的代码示例展示了如何使用var关键字声明本地变量：

public class LocalVariableDemo {
    public static void main(String[] args) {
        // 声明一个整型变量
        var num = 10;

        // 声明一个字符串变量
        var message = "Hello, World!";

        // 输出变量值
        System.out.println("Number: " + num);
        System.out.println("Message: " + message);
    }
}

在上面的示例中，var关键字被用来声明两个变量：一个整型变量num和一个字符串变量message。编译器会根据赋值表达式自动推断变量类型。

这种方法使得代码更加简洁，减少了冗余的类型声明。然而，需要注意的是，使用var时，编译器必须能够确定变量的类型。如果赋值表达式中包含复杂的类型推断，可能会导致编译错误。

移除Java EE和CORBA模块

模块移除原因解析

Java EE和CORBA模块在JDK 11中被移除，这是由于这两个模块的功能已经迁移到了外部项目。Java EE模块的功能被移入了Jakarta EE，而CORBA模块则被迁移到了其他开源项目中。这些迁移是Java社区为了更好地组织和维护Java平台的各个部分而作出的决定。

对现有项目的影响分析

对于已经使用Java EE和CORBA模块的项目来说，这些模块的移除可能会带来一些影响。具体来说：

Java EE模块：如果项目依赖于Java EE模块，那么这些功能现在需要通过Jakarta EE提供的组件来实现。这意味着项目可能需要更新依赖和配置，以使用新的Jakarta EE API。
CORBA模块：如果项目依赖于CORBA模块，那么这些功能现在需要通过其他实现CORBA功能的项目或库来实现。开发者可能需要寻找替代方案或迁移现有代码以适应这些变化。

为了适应这些变化，项目可以采取以下步骤：

迁移至Jakarta EE：对于依赖于Java EE模块的项目，可以迁移至Jakarta EE项目。这通常涉及更新依赖项和配置文件，以使用新的Jakarta EE API。
寻找替代CORBA实现：对于依赖于CORBA模块的项目，可以寻找其他实现CORBA功能的库或项目。例如，Apache TAO是一个流行的CORBA实现，可以作为替代方案。

// 示例：迁移至Jakarta EE
import jakarta.ws.rs.client.Client;
import jakarta.ws.rs.client.ClientBuilder;
import jakarta.ws.rs.client.WebTarget;

public class JakartaEEDemo {
    public static void main(String[] args) {
        // 创建Jakarta EE客户端
        Client client = ClientBuilder.newClient();
        WebTarget target = client.target("https://api.example.com/data");

        // 发送请求并处理响应
        String response = target.request().get(String.class);
        System.out.println("Response: " + response);

        // 关闭客户端
        client.close();
    }
}

HTTP客户端API改进

HTTP客户端API简介

在JDK 11中，HTTP客户端API得到了改进。新的API提供了更强大、更灵活的方式来执行HTTP请求。新API使用了java.net.http.*包中的类，这些类提供了更多的配置选项和更高级的功能。

新特性详解与示例

1. 请求构建

新的HTTP客户端API允许开发者构建HTTP请求，并指定请求的详细配置，如请求方法、URL、请求体等。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class HttpClientDemo {
    public static void main(String[] args) {
        // 创建HttpClient实例
        HttpClient client = HttpClient.newHttpClient();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .build();

        // 发送请求
        CompletableFuture<HttpResponse<String>> responseFuture = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        // 处理响应
        responseFuture.thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

在上面的示例中，HttpClient实例用于发送HTTP请求。HttpRequest对象用于构建请求，包括指定请求方法、URL和请求体。CompletableFuture用于异步处理响应。

2. 异步处理

新的HTTP客户端API支持异步处理，允许开发者使用CompletableFuture异步发送请求并处理响应。这对于需要高并发性能的应用程序尤为重要。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class AsyncHttpClientDemo {
    public static void main(String[] args) {
        // 创建HttpClient实例
        HttpClient client = HttpClient.newHttpClient();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .build();

        // 发送异步请求
        CompletableFuture<HttpResponse<String>> responseFuture = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        // 处理响应
        responseFuture.thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

在上面的示例中，sendAsync方法用于异步发送请求，而CompletableFuture用于处理响应。

3. 响应处理

新的HTTP客户端API提供了多种处理响应的方法。例如，可以使用HttpResponse.BodyHandlers来处理响应体，包括字符串、字节数组等。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class HttpResponseProcessingDemo {
    public static void main(String[] args) {
        // 创建HttpClient实例
        HttpClient client = HttpClient.newHttpClient();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .build();

        // 发送请求并处理响应
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

在上面的示例中，HttpResponse.BodyHandlers.ofString()用于将响应体处理为字符串。

4. 自定义配置

新的HTTP客户端API允许开发者自定义请求的配置，包括超时时间、连接池设置等。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class CustomConfigDemo {
    public static void main(String[] args) {
        // 创建HttpClient实例，并设置超时时间
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1)
                .followRedirects(HttpClient.Redirect.ALWAYS)
                .build();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .build();

        // 发送请求
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

在上面的示例中，HttpClient.newBuilder()方法用于创建一个自定义配置的HttpClient实例，包括设置HTTP版本和重定向策略。

私有密钥加密支持

私有密钥加密的基本概念

私有密钥加密（也称为对称加密）是一种加密技术，其中相同的密钥用于加密和解密数据。这种类型的加密算法速度快，但需要确保密钥的安全传输。常见的私有密钥加密算法包括AES（高级加密标准）、DES（数据加密标准）等。

如何在JDK11中实现加密功能

在JDK 11中，可以使用javax.crypto包中的类来实现私有密钥加密。下面的示例代码展示了如何使用AES算法进行加密和解密。

加密示例代码

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class AESEncryptionDemo {
    public static void main(String[] args) {
        try {
            // 生成AES密钥
            KeyGenerator keyGen = KeyGenerator.getInstance("AES");
            keyGen.init(128);
            SecretKey secretKey = keyGen.generateKey();
            byte[] key = secretKey.getEncoded();

            // 初始化加密器
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"));

            // 要加密的字符串
            String originalString = "Hello, World!";
            byte[] originalBytes = originalString.getBytes();

            // 加密
            byte[] encryptedBytes = cipher.doFinal(originalBytes);
            String encryptedString = Base64.getEncoder().encodeToString(encryptedBytes);

            System.out.println("Original String: " + originalString);
            System.out.println("Encrypted String: " + encryptedString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，KeyGenerator类用于生成AES密钥，Cipher类用于执行加密操作。加密后的数据以Base64格式输出。

解密示例代码

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESDecryptionDemo {
    public static void main(String[] args) {
        try {
            // 加密密钥
            String secretKeyString = "Q1W2eE3dD5fG6hH9jJ0kK3lL4mN5nN7pP8qR0sT1uU2vV3wX4yZ5aA6bB7cC8dE9fF0gG1hH2iI3jJ4kK5lL6mM7nN8oP9qQ0rR1sS2tT3uU4vV5wW6xX7yY8zZ";
            byte[] key = Base64.getDecoder().decode(secretKeyString);

            // 初始化解密器
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"));

            // 加密后的字符串
            String encryptedString = "U2FsdGVkX1+1234567890abcdef";
            byte[] encryptedBytes = Base64.getDecoder().decode(encryptedString);

            // 解密
            byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
            String decryptedString = new String(decryptedBytes);

            System.out.println("Encrypted String: " + encryptedString);
            System.out.println("Decrypted String: " + decryptedString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，Cipher类用于执行解密操作。解密后的数据以字符串形式输出。

通过上述示例，您可以了解如何使用JDK 11中的javax.crypto包来实现AES加密和解密功能。这为您的应用程序提供了强大的数据保护能力。

实战演练：JDK11新特性应用实例

选取某一个新特性进行实战演练

在本节中，我们将选取HTTP客户端API改进作为实战演练的内容。我们将通过构建一个简单的HTTP客户端来演示如何使用这些新特性。

结合实际编写代码示例

1. 创建一个HTTP客户端

首先，我们将创建一个简单的HTTP客户端，用于发送GET请求并处理响应。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class SimpleHTTPClient {
    public static void main(String[] args) {
        // 创建HttpClient实例
        HttpClient client = HttpClient.newHttpClient();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .build();

        // 发送请求并处理响应
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

2. 增加超时和重定向配置

接下来，我们将对HTTP客户端进行更复杂的配置，包括设置超时时间和处理重定向。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class ConfigurableHTTPClient {
    public static void main(String[] args) {
        // 创建HttpClient实例，并设置超时时间
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1)
                .followRedirects(HttpClient.Redirect.ALWAYS)
                .build();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .timeout(Duration.ofSeconds(10)) // 设置超时时间
                .build();

        // 发送请求
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

在上面的示例中，HttpClient.newBuilder()方法用于创建一个自定义配置的HttpClient实例，包括设置HTTP版本、重定向策略和超时时间。

3. 处理HTTP响应

最后，我们将演示如何处理HTTP响应中的头部信息和状态码。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class ResponseHandlingDemo {
    public static void main(String[] args) {
        // 创建HttpClient实例
        HttpClient client = HttpClient.newHttpClient();

        // 创建一个HttpRequest对象
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET() // 指定请求方法为GET
                .build();

        // 发送请求并处理响应
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .thenCompose(response -> {
                    System.out.println("Response Status: " + response.statusCode());
                    System.out.println("Response Headers: " + response.headers().map());
                    return CompletableFuture.completedFuture(response);
                })
                .join();
    }
}

在上面的示例中，我们使用HttpResponse::body获取响应体，并使用response.statusCode()和response.headers().map()来获取响应的状态码和头部信息。

通过以上步骤，我们可以看到如何使用JDK 11中的HTTP客户端API来构建一个功能丰富的HTTP客户端。这些示例展示了如何通过自定义配置和响应处理来增强客户端的功能。