JDK11新特性详解入门教程

Java Development Kit 11 (JDK 11) 引入了多项新特性和改进，提升了 Java 代码的开发效率和性能。这些特性包括局部变量类型推断、HTTP Client API 以及移除 Java EE 和 CORBA 模块等，全面增强了 Java 开发体验。JDK 11 新特性不仅简化了开发流程，还提高了代码的安全性和性能。

Java Development Kit 11 (JDK 11) 是 Oracle 发布的长期支持版本（LTS），提供了许多新的功能和改进。JDK 11 引入了新的特性，如局部变量类型推断、HTTP Client API，以及移除了 Java EE 和 CORBA 模块等。这些改进不仅提升了开发效率，还增强了代码的安全性和性能。JDK 11 发布于 2018 年 9 月 25 日，是 Java SE 平台上一个重要的更新版本，旨在提供更好的开发体验和性能优化。

局部变量类型推断允许开发人员在声明局部变量时省略类型声明，让编译器根据变量赋值自动推断类型。这种特性可以使得代码更加简洁，但并不推荐在所有的局部变量声明中都使用，因为它可能会降低代码的可读性。

使用 var 关键字即可实现局部变量类型推断，例如：

public class VariableTypeInferenceExample {
    public static void main(String[] args) {
        // 传统方式
        String traditionalString = "Hello World";
        Integer traditionalInteger = 10;

        // 使用var关键字
        var string = "Hello World";
        var integer = 10;

        // 局部变量类型推断适用于各种类型，包括数组和自定义对象
        var numberArray = new int[]{1, 2, 3, 4, 5};
        var customObject = new CustomObject();
    }

    static class CustomObject {
        private String data;

        public CustomObject(String data) {
            this.data = data;
        }
    }
}

局部变量类型推断的优点

1. 简化代码：减少了冗余的类型声明，使得代码更加简洁。
2. 提高可读性：在一些情况下，使用 var 可以让代码更加清晰，特别是在使用复杂的泛型时。
3. 动态类型：在某些情况下，var 可以使得代码更加灵活，例如在处理匿名内部类时。

局部变量类型推断的缺点

1. 降低可读性：对于不熟悉 var 的开发人员，可能会降低代码的可读性。
2. 类型检查：在编译时，类型推断会由编译器完成，某些情况下可能会导致错误难以发现。
3. 编译时间：虽然现代编译器性能已经非常强大，但复杂的类型推断可能会增加编译时间。

局部变量类型推断的限制

• 使用 var 时，必须在声明变量的同时进行初始化，否则编译器会报错。
• var 不适用于方法返回类型、参数类型和泛型。

示例代码：

public class TypeInferenceExample {
    public static void main(String[] args) {
        var length = 10;
        var name = "John Doe";
        var myArray = new int[]{1, 2, 3};

        // 声明一个局部变量，但没有初始化
        // var unInitialized;  // 编译错误：变量未初始化

        // var 不能用于方法参数或返回类型
        // var printArray(var arr) { ... } // 编译错误：var 不能用于方法参数
        // public var getArray() { ... }    // 编译错误：var 不能用于方法返回类型
    }
}

示例：下面的代码展示了 var 关键字在不同数据类型中的使用。

public class VariableTypeInferenceExample {
    public static void main(String[] args) {
        var name = "John Doe";
        var age = 30;
        var numbers = new int[]{1, 2, 3, 4, 5};

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Numbers: " + java.util.Arrays.toString(numbers));
    }
}

JDK 11 引入了一个新的 HTTP 客户端 API，该 API 提供了一个标准化的方式来发送 HTTP 请求并获取响应。新的 HTTP 客户端 API 是一种非阻塞的 API，使用该 API 可以进行异步 HTTP 请求，从而提高应用程序的响应性和性能。

新的 HTTP Client API 的优点

1. 非阻塞：新的 HTTP 客户端 API 是非阻塞的，可以充分利用现代多核处理器的性能。
2. 可扩展性：该 API 设计得非常灵活，可以用于构建可扩展的和高并发的应用程序。
3. 标准化：新的 HTTP 客户端 API 提供了统一的接口来发送 HTTP 请求，简化了开发工作。

HTTP Client API 的使用

要使用新的 HTTP 客户端 API，首先需要创建一个 HttpClient 实例。HttpClient 提供了多种方法来发送 HTTP 请求，例如 send() 方法可以用于异步或同步请求。

下面是一个简单的示例，演示如何使用新的 HTTP 客户端 API 发送一个 HTTP GET 请求：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse.BodyHandlers;

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

        // 创建一个 HttpRequest
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com"))
            .build();

        try {
            // 发送请求并获取响应
            HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

            // 输出响应状态码和响应体
            System.out.println("Status code: " + response.statusCode());
            System.out.println("Response body: " + response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

HTTP Client API 的高级特性

• 支持异步操作：可以使用 sendAsync() 方法来发送异步请求，该方法返回一个 CompletableFuture<HttpResponse<T>>，可以使用 thenApply() 方法对响应进行处理。

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

public class AsyncHttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com"))
            .build();

        CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, BodyHandlers.ofString());
        future.thenApply(response -> {
            System.out.println("Status code: " + response.statusCode());
            System.out.println("Response body: " + response.body());
            return null;
        }).join();
    }
}

• 支持自定义请求体：可以使用 BodyPublishers 类来创建自定义请求体，例如 BodyPublishers.ofString() 和 BodyPublishers.ofByteArray()。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpClient.Version;
import java.net.http.HttpClient.Redirect;
import java.net.http.HttpClient.Redirect.JdkHttpURLConnection;

public class CustomBodyExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_1_1)
            .followRedirects(Redirect.ALWAYS)
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com"))
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString("{\"key\":\"value\"}"))
            .build();

        try {
            HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
            System.out.println("Status code: " + response.statusCode());
            System.out.println("Response body: " + response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Java EE 和 CORBA 模块在 JDK 11 中被移除，这意味着这些模块不再包含在 JDK 11 的默认安装中。这些模块之前在 JDK 中包含的原因是为了方便开发者开发基于 Java EE 和 CORBA 的应用程序。然而，随着 Java EE 被移交给 Eclipse Foundation，并更名为 Jakarta EE，Oracle 认为这些模块没有必要再包含在 JDK 中。

移除Java EE和CORBA模块的影响

1. 减少了JDK的体积：移除这些模块可以减少 JDK 的总体大小。
2. 简化了JDK的维护：Oracle 可以更专注于 JDK 中必要的部分。
3. 迁移成本：对于使用 Java EE 和 CORBA 的应用程序，可能需要进行迁移，以使用新的 Jakarta EE 和其他替代技术。

如何迁移Java EE应用程序

如果您的应用程序依赖于 Java EE 模块，可能需要将这些功能迁移到 Jakarta EE 或其他框架中。以下是迁移的一些建议：

1. Jakarta EE迁移：

   • Jakarta EE 提供了与 Java EE 兼容的 API，可以无缝迁移。
   • 可以使用流行的 Jakarta EE 应用服务器，如 WildFly 和 Payara。

2. 使用替代框架：

   • 对于某些功能，可以考虑使用流行的开源框架，如 Spring。
3. 迁移策略：
   • 首先，识别您的应用程序中使用的 Java EE 功能。
   • 然后，为每个功能选择适当的迁移策略。
   • 最后，逐步迁移，确保每个步骤都经过充分的测试。

示例：下面的代码展示了如何使用 Spring Boot 替代 Java EE 的依赖注入功能。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class AppConfig {

    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(org.springframework.context.annotation.Configuration corsRegistry) {
                corsRegistry.addMapping("/**").allowedOrigins("*");
            }
        };
    }

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

如何迁移CORBA应用程序

对于使用 CORBA 的应用程序，可以考虑以下迁移策略：

1. 使用替代技术：

   • 可以使用 RESTful API 或其他现代的分布式技术来替代 CORBA。
2. 迁移策略：
   • 逐步将旧的 CORBA 服务迁移到新的 RESTful API。
   • 为每个旧的 CORBA 接口编写对应的 RESTful API。
   • 确保新旧 API 之间的互操作性。

示例：下面的代码展示了如何使用 Spring Boot 替代 CORBA 服务。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class CorbaMigrationApplication {

    public static void main(String[] args) {
        SpringApplication.run(CorbaMigrationApplication.class, args);
    }

    @RestController
    public class CorbaService {

        @GetMapping("/corba/service")
        public String getCorbaService() {
            // 旧的CORBA服务逻辑
            return "Hello from CORBA!";
        }
    }
}

JDK 11 引入了对私有密钥加密（Private Key Encryption）功能的增强支持。这种增强支持主要体现在对 java.security.KeyPairGenerator, java.security.KeyPair 和 java.security.KeyPairGeneratorSpec 类的改进。这些改进使得生成和使用密钥对更加简单和安全。

私有密钥加密支持的优点

1. 安全性提升：新的加密功能提高了安全性，可以更好地保护敏感数据。
2. 灵活性增强：增强了对不同加密算法的支持，使得开发者有更多的选择。
3. 性能优化：改进了密钥生成和管理的性能，提高了应用程序的响应速度。

如何使用私有密钥加密功能

为了使用新的私有密钥加密功能，可以使用 KeyPairGenerator 类来生成密钥对，并使用 KeyPair 类来管理生成的密钥对。下面是一个示例，演示如何使用 KeyPairGenerator 生成 RSA 密钥对。

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;

public class PrivateKeyEncryptionExample {

    public static void main(String[] args) {
        try {
            // 创建一个KeyPairGenerator实例
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);  // 设置密钥长度为2048位

            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            // 输出公钥和私钥
            System.out.println("Public Key: " + keyPair.getPublic());
            System.out.println("Private Key: " + keyPair.getPrivate());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

加密和解密示例

使用生成的密钥对进行加密和解密的示例：

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.util.Base64;

public class EncryptionExample {

    public static void main(String[] args) {
        try {
            // 生成密钥对
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            // 加密
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
            String originalMessage = "Hello, World!";
            byte[] encryptedMessage = cipher.doFinal(originalMessage.getBytes());

            // 解密
            cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
            byte[] decryptedMessage = cipher.doFinal(encryptedMessage);

            // 输出结果
            System.out.println("Original Message: " + originalMessage);
            System.out.println("Encrypted Message: " + Base64.getEncoder().encodeToString(encryptedMessage));
            System.out.println("Decrypted Message: " + new String(decryptedMessage));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意事项

1. 密钥长度：密钥长度的选择应该根据安全性需求来定。较长的密钥可以提供更强的安全性，但也可能会影响性能。
2. 密钥管理：密钥的管理和保护非常重要，确保密钥不泄露，可以使用密码学安全的存储方式。

为了更好地理解和使用 JDK 11 的新特性，下面提供了一些示例代码，帮助您在实际项目中应用这些新特性。

示例一：使用局部变量类型推断

public class VariableTypeInferenceExample {
    public static void main(String[] args) {
        var name = "John Doe";
        var age = 30;
        var numbers = new int[]{1, 2, 3, 4, 5};

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Numbers: " + java.util.Arrays.toString(numbers));
    }
}

示例二：使用HTTP Client API发送GET请求

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpClient.Version;

public class HttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .version(Version.HTTP_1_1)
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com"))
            .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println("Status code: " + response.statusCode());
            System.out.println("Response body: " + response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

示例三：移除Java EE和CORBA模块后的迁移示例

// 示例代码展示如何使用Spring Boot来替代Java EE的依赖注入
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class JavaEEMigrationApplication {

    public static void main(String[] args) {
        SpringApplication.run(JavaEEMigrationApplication.class, args);
    }

    @RestController
    public class MyService {

        @GetMapping("/hello")
        public String sayHello() {
            return "Hello World!";
        }
    }
}

示例四：使用私有密钥加密功能

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.util.Base64;

public class EncryptionExample {
    public static void main(String[] args) {
        try {
            // 生成密钥对
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            // 加密
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
            String originalMessage = "Hello, World!";
            byte[] encryptedMessage = cipher.doFinal(originalMessage.getBytes());

            // 解密
            cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
            byte[] decryptedMessage = cipher.doFinal(encryptedMessage);

            // 输出结果
            System.out.println("Original Message: " + originalMessage);
            System.out.println("Encrypted Message: " + Base64.getEncoder().encodeToString(encryptedMessage));
            System.out.println("Decrypted Message: " + new String(decryptedMessage));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

总结

JDK 11 引入了许多新的特性和改进，通过局部变量类型推断、HTTP Client API、移除 Java EE 和 CORBA 模块以及增强的私有密钥加密支持等功能，使得 Java 开发变得更加简单和高效。通过上述示例代码，您可以更好地理解和应用这些新特性，从而提升您的 Java 应用程序的性能和安全性。