JDK11新特性教程：一步步学习指南

本文提供了全面的JDK11新特性教程，涵盖了局部变量类型推断、HTTP/2客户端改进、强制使用HTTPS等关键特性。通过详细解释和示例代码，帮助开发者理解和应用这些新特性，提高Java开发效率。

JDK 11是Java Development Kit (JDK) 的一个主要版本，于2018年9月25日发布。JDK 11是Java的一个长期支持版本，将持续获得支持和维护直到2026年。JDK 11不仅增强了现有功能，还引入了一些新的功能，如局部变量类型推断、HTTP/2客户端改进等。

JDK11的主要特性概述

JDK 11包含以下主要特性：

1. 局部变量类型推断
2. 强制使用HTTPS
3. HTTP/2客户端改进
4. 移除Java EE和CORBA模块
5. 新的垃圾收集器ZGC
6. 动态类文件常量
7. 其他JEP（JDK Enhancement Proposal）引入的特性

JDK11与之前的版本对比

与之前的版本相比，JDK 11的改进主要体现在性能和安全性方面。例如，局部变量类型推断使得代码更加简洁和易读，强制使用HTTPS提高了应用的安全性，而新的垃圾收集器ZGC则改进了垃圾收集的性能和延迟。

局部变量类型推断允许你在声明局部变量时省略变量类型。JDK 11引入了一个新的关键字 var，它可以让编译器自动推断变量类型。这使得代码更加简洁和易读。

什么是局部变量类型推断

局部变量类型推断是指在声明局部变量时，可以省略变量类型，由编译器自动推断出变量的实际类型。这主要通过使用 var 关键字实现。

如何使用var关键字

在JDK 11中，你可以使用 var 关键字来声明局部变量。编译器会根据变量的初始化表达式推断出变量的类型。

public class VariableInferenceExample {
    public static void main(String[] args) {
        var number = 42; // 编译器推断为int类型
        var message = "Hello, World!"; // 编译器推断为String类型
        var list = List.of(1, 2, 3); // 编译器推断为List<Integer>类型
    }
}

常见用法示例

以下是一些常见的局部变量类型推断的用法示例：

public class VariableInferenceUseCases {
    public static void main(String[] args) {
        // 使用var声明基本类型变量
        var x = 10; // 编译器推断为int类型
        var y = 20.5; // 编译器推断为double类型
        var z = true; // 编译器推断为boolean类型

        // 使用var声明对象类型变量
        var name = "John Doe"; // 编译器推断为String类型
        var age = 30; // 编译器推断为int类型
        var address = new Address("123 Main St", "Anytown", "12345"); // 编译器推断为Address类型

        // 使用var声明集合类型变量
        var numbers = List.of(1, 2, 3); // 编译器推断为List<Integer>类型
        var map = Map.of("key1", "value1", "key2", "value2"); // 编译器推断为Map<String, String>类型
    }
}

JDK 11引入了强制使用HTTPS的功能，这提高了应用的安全性，防止中间人攻击。

为什么要强制使用HTTPS

HTTPS提供了一种安全的方式来传输数据，它使用SSL/TLS协议来加密数据传输，从而保护数据传输的安全性。强制使用HTTPS可以防止中间人攻击，确保数据的安全传输。

如何配置JDK以启用HTTPS

要配置JDK以启用HTTPS，你需要创建一个HTTPS服务器并使用SSL/TLS证书。以下是一个简单的示例代码：

import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLContext;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import java.io.*;
import java.security.*;
import java.security.cert.X509Certificate;

public class HttpsServerExample {
    public static void main(String[] args) throws Exception {
        // 创建SSLContext对象
        SSLContext sslContext = SSLContext.getInstance("TLS");
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

        // 加载SSL证书
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(new FileInputStream("keystore.jks"), "password".toCharArray());
        keyManagerFactory.init(keyStore, "password".toCharArray());

        // 初始化SSLContext
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);

        // 创建SSLServerSocketFactory
        SSLServerSocketFactory sslServerSocketFactory = sslContext.getServerSocketFactory();

        // 创建SSLServerSocket并绑定端口
        SSLServerSocket sslServerSocket = (SSLServerSocket) sslServerSocketFactory.createServerSocket(8443);

        System.out.println("HTTPS server started on port 8443");

        // 创建Socket对象并接受客户端连接
        while (true) {
            try (Socket socket = sslServerSocket.accept();
                 PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("Received: " + inputLine);
                    out.println("Echo: " + inputLine);
                }
            }
        }
    }
}

HTTPS的基本概念

HTTPS是HTTP的安全版本，它使用SSL/TLS协议来加密数据传输。HTTPS提供了以下几项主要功能：

1. 数据加密：HTTPS使用SSL/TLS协议对数据进行加密，确保数据在传输过程中的安全性。
2. 身份验证：HTTPS使用SSL/TLS协议进行身份验证，确保客户端和服务器之间的身份真实性。
3. 完整性保护：HTTPS使用SSL/TLS协议对数据进行完整性保护，防止数据在传输过程中被篡改。

JDK 11对HTTP客户端的实现进行了改进，引入了对HTTP/2协议的支持。HTTP/2是一种在HTTP基础上进行改进的协议，它提高了应用的性能和效率。

HTTP/2客户端的新功能

HTTP/2客户端的新功能包括：

1. 多路复用：HTTP/2允许多个请求和响应在同一连接上并行传输，提高了应用的响应速度。
2. 头部压缩：HTTP/2使用HPACK算法对HTTP头部进行压缩，减少了数据传输量。
3. 服务器推送：HTTP/2允许服务器主动推送资源给客户端，减少了客户端的等待时间。

如何在JDK中使用HTTP/2客户端

要使用JDK中的HTTP/2客户端，你需要创建一个HTTP/2连接，并使用这个连接发送HTTP请求。以下是一个简单的示例代码：

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

public class Http2ClientExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建HTTP/2客户端
        HttpClient httpClient = HttpClient.newHttpClient();

        // 创建HTTP请求
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://example.com"))
                .build();

        // 发送HTTP请求并获取响应
        CompletableFuture<HttpResponse<String>> responseFuture = httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        // 获取响应结果
        HttpResponse<String> response = responseFuture.get();
        System.out.println("Status Code: " + response.statusCode());
        System.out.println("Body: " + response.body());
    }
}

示例代码解释

1. 创建HTTP/2客户端：使用 HttpClient.newHttpClient() 方法创建一个HTTP/2客户端。
2. 创建HTTP请求：使用 HttpRequest.newBuilder() 方法创建一个HTTP请求，并设置请求的URI。
3. 发送HTTP请求：使用 httpClient.sendAsync() 方法发送HTTP请求，并获取响应的Future对象。
4. 获取响应结果：使用 responseFuture.get() 方法获取响应的结果，输出响应的状态码和响应体。

JDK 11移除了Java EE和CORBA模块，这是为了减少JDK的大小和复杂性。

移除Java EE和CORBA模块的原因

Java EE和CORBA模块在过去的一些版本中经常被用作开发Web应用和企业级应用的工具。然而，随着Java EE被Java EE 8和Jakarta EE 8所取代，这些模块已经不再被广泛使用，因此JDK 11移除了这些模块。

对现有代码的影响

对于现有的使用Java EE和CORBA模块的代码，移除这些模块可能会影响代码的兼容性。如果代码依赖于这些模块，那么在迁移到JDK 11时，需要进行相应的代码迁移。

更新代码的建议

为了更新代码并确保其在JDK 11中正常运行，你可以采取以下措施：

1. 迁移代码：将代码迁移到新的Java EE或Jakarta EE标准中。
2. 使用第三方库：寻找并使用第三方库来替代Java EE和CORBA模块。
3. 更新依赖：更新项目中的依赖，确保它们与JDK 11兼容。

示例代码

以下是一个简单的迁移示例，假设你有一个使用Java EE的Servlet：

Java EE Servlet 示例

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class OldServletExample extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello, World!</h1>");
    }
}

迁移至Jakarta EE Servlet 示例

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

public class NewServletExample extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello, World!</h1>");
    }
}

除了上述主要特性，JDK 11还引入了一些其他的改进和新特性，包括新的垃圾收集器ZGC、动态类文件常量等。

新的垃圾收集器ZGC

ZGC（Z Garbage Collector）是JDK 11引入的一个新的垃圾收集器，它主要用于处理大内存环境下的垃圾收集。ZGC使用可伸缩的并发垃圾收集算法，可以减少垃圾收集的停顿时间和延迟。

动态类文件常量

动态类文件常量（Dynamic Class-File Constants）是JDK 11引入的一个新特性，它允许在运行时动态地创建类文件常量。这对于一些需要动态生成类文件的应用场景非常有用。

JEP（JDK Enhancement Proposal）的其他新特性

JDK 11还引入了一些其他的新特性，这些特性是通过JEP（JDK Enhancement Proposal）来实现的。以下是一些示例：

// JEP 333: Local-variable syntax for lambda parameter types
public class LambdaParameterTypeExample {
    public static void main(String[] args) {
        var str = "Hello, World!";
        var length = str::length; // 使用var声明lambda表达式的参数类型
        System.out.println(length.apply("Hello, World!"));
    }
}

// JEP 335: Aarch64 Port
public class Aarch64PortExample {
    public static void main(String[] args) {
        // Aarch64 Port相关代码
    }
}

// JEP 336: Shenandoah Garbage Collector
public class ShenandoahGCExample {
    public static void main(String[] args) {
        // Shenandoah GC相关代码
    }
}

这些示例展示了JDK 11中的一些其他新特性，包括局部变量语法、Aarch64架构支持和Shenandoah垃圾收集器。

JDK 11引入了许多新的特性和改进，这些特性不仅提高了Java应用的性能和安全性，还使得Java编程更加简洁和高效。通过学习和掌握这些新特性，你可以更好地利用JDK 11的优势，提高你的Java开发能力。