Java 9模块化开发怎么写？新手入门代码实例与详细步骤指南

Java 9作为Oracle发布的JDK 9版本，引入了大量新特性和改进，旨在提升开发效率、模块化系统以及性能优化，对于开发者而言，掌握Java 9的写法不仅是适应新版本的基础，更能充分利用其带来的便利，本文将从模块系统、集合工厂方法、接口私有方法、HTTP客户端、JShell交互式工具等核心特性出发，结合具体代码示例，详细说明Java 9的实际开发写法。

模块系统：Java平台的基石性变革

Java 9最大的变化莫过于引入了Java平台模块系统（JPMS），通过module-info.java文件定义模块，明确模块间的依赖关系，解决“JAR地狱”问题并提升安全性。

在Java 9中，创建模块需在模块根目录下添加module-info.java文件，定义一个名为com.example.core的模块，依赖java.base（Java核心模块，默认依赖）和java.sql模块，并声明导出的包：

module com.example.core {
    requires java.sql;      // 声明依赖java.sql模块
    exports com.example.core.service;  // 导出包，允许其他模块访问
}

编译模块化程序时，需使用--module-source-path指定模块路径，并通过javac --module-path指定依赖模块的路径，运行模块化主类时，则需使用java --module-path和--module参数：

javac --module-source-path src -d out src/com.example.core/module-info.java src/com.example.core/com/example/core/service/ServiceImpl.java
java --module-path out --module com.example.core/com.example.core.service.ServiceImpl

模块系统强制封装内部实现，未导出的包（如com.example.core.impl）无法被外部模块访问,有效避免了非法依赖。

集合工厂方法：告别Collections工具类的冗余

Java 9之前，创建不可变集合需通过Collections.unmodifiableList()等方法，代码冗长且可读性差，Java 9引入了List.of()、Set.of()、Map.of()等工厂方法，支持直接创建不可变集合。

以List.of()为例，可一次性传入多个元素创建不可变List：

List<String> fruits = List.of("apple", "banana", "orange");  // 不可变List
// fruits.add("grape");  // 抛出UnsupportedOperationException异常

Set.of()同样简洁，且自动去重：

Set<Integer> numbers = Set.of(1, 2, 3, 3, 2, 1);  // 结果为[1, 2, 3]

Map.of()支持键值对参数，键值数量不超过10个时可使用Map.of(k1, v1, k2, v2, ...)，超过10个时需使用Map.ofEntries()：

Map<String, Integer> scores = Map.of("Alice", 90, "Bob", 85);  // 两个键值对
Map<String, Integer> moreScores = Map.ofEntries(
    Map.entry("Charlie", 88),
    Map.entry("David", 92)
);

这些工厂方法创建的集合具有线程安全、不可变的特点，适用于无需修改的场景,如配置信息存储。

接口私有方法：实现代码复用与封装

Java 8允许接口定义默认方法（default）和静态方法，但无法提供私有方法，导致默认方法间的代码复用性较差，Java 9引入了接口私有方法（包括私有实例方法和私有静态方法），支持在接口内部复用逻辑。

定义一个DataProcessor接口，包含多个默认方法，它们共同调用一个私有方法处理数据：

public interface DataProcessor {
    default void processText(String text) {
        String processed = doProcess(text);  // 调用私有方法
        System.out.println("Processed text: " + processed);
    }
    default void processBytes(byte[] bytes) {
        String processed = doProcess(new String(bytes));  // 复用私有方法
        System.out.println("Processed bytes: " + processed);
    }
    private String doProcess(String input) {  // 私有实例方法
        return input.trim().toUpperCase();
    }
    private static void log(String message) {  // 私有静态方法
        System.out.println("[DataProcessor] " + message);
    }
}

接口私有方法仅能在接口内部使用，外部无法访问，既实现了代码复用,又保持了接口的封装性。

HTTP客户端：现代化的网络请求工具

Java 9之前，Java开发者通常使用HttpURLConnection或第三方库（如Apache HttpClient）发送HTTP请求，Java 9引入了新的HTTP客户端（java.net.http包），支持HTTP/1.1、HTTP/2，并提供同步和异步请求能力。

同步请求示例

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class HttpSyncExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();  // 创建HTTP客户端
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.github.com/users/octocat"))
                .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Status code: " + response.statusCode());
        System.out.println("Response body: " + response.body());
    }
}

异步请求示例

异步请求通过HttpClient.sendAsync()方法返回CompletableFuture<HttpResponse>，支持非阻塞操作：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class HttpAsyncExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.github.com/users/octocat"))
                .build();
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)  // 处理响应体
                .thenAccept(System.out::println)  // 输出结果
                .join();  // 等待异步操作完成
    }
}

新的HTTP客户端支持WebSocket、请求/响应体处理器（如BodyHandlers.ofFile将响应写入文件）等高级功能，相比HttpURLConnection更简洁高效。

JShell：交互式编程与快速原型验证

Java 9引入了JShell（Java Shell），一个交互式命令行工具，允许开发者直接编写和执行Java代码片段，无需编译和运行完整程序，极大提升了学习和原型开发效率。

启动JShell只需在命令行执行jshell命令，进入交互环境后，可直接定义变量、方法、类：

jshell> int a = 10;
a ==> 10
jshell> int b = 20;
b ==> 20
jshell> int sum = a + b;
sum ==> 30
jshell> String greet(String name) {
   ...>     return "Hello, " + name;
   ...> }
|  创建方法 greet(String)
jshell> greet("JShell");
$ ==> Hello, JShell

JShell支持代码修改、变量查看、自动补全等功能，还提供/list查看历史代码、/exit退出环境等命令，对于学习Java语法或测试小段逻辑,JShell是高效工具。

其他重要特性与写法

多版本JAR包支持

Java 9支持在同一个JAR文件中包含不同Java版本的类文件，通过Multi-Release: true manifest属性标识，并在META-INF/versions/目录下存放特定版本的类，为Java 9和Java 8提供不同实现：

my.jar
├── META-INF/
│   ├── MANIFEST.MF (包含Multi-Release: true)
│   └── versions/
│       ├── 9/
│       │   └── com/example/MyClass.class (Java 9版本)
│       └── 8/
│           └── com/example/MyClass.class (Java 8版本)

运行时，JVM会根据当前版本自动选择合适的类文件。

Stream API改进

Java 9对Stream API进行了增强，新增takeWhile()、dropWhile()、iterate()等方法：

• takeWhile(Predicate predicate)：从开头开始，保留满足条件的最长元素序列；
• dropWhile(Predicate predicate)：从开头开始，丢弃满足条件的最长元素序列；
• iterate(T seed, Predicate hasNext, UnaryOperator next)：支持自定义终止条件的迭代。

示例：

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 1, 2);
List<Integer> result = numbers.stream()
        .takeWhile(n -> n < 4)  // 保留小于4的元素，遇到1时停止
        .collect(Collectors.toList());
// 结果: [1, 2, 3]

Java 9通过模块系统、集合工厂方法、接口私有方法、HTTP客户端等特性，显著提升了Java开发的模块化能力、代码简洁性和功能性，开发者掌握这些特性的写法后，不仅能写出更健壮、易维护的代码，还能充分利用JVM的优化能力，从模块化项目的构建到快速原型验证，Java 9为现代Java开发提供了更强大的工具支持,是迈向Java新版本的重要一步。