Java 9 模块化系统

概述

Java 9（2017年9月）最重要的特性是模块化系统（Project Jigsaw），同时也引入了许多实用的 API 改进。

模块化系统 (JPMS)

Java Platform Module System 将 JDK 和应用程序划分为模块，提供更好的封装性和依赖管理。

模块定义

在 src 目录下创建 module-info.java：

// module-info.java
module com.example.myapp {
    // 导出包（对外可见）
    exports com.example.myapp.api;
    
    // 导出包给特定模块
    exports com.example.myapp.internal to com.example.other;
    
    // 依赖其他模块
    requires java.sql;
    requires java.logging;
    
    // 传递依赖
    requires transitive java.xml;
    
    // 使用服务
    uses com.example.spi.MyService;
    
    // 提供服务实现
    provides com.example.spi.MyService with com.example.impl.MyServiceImpl;
    
    // 开放反射访问
    opens com.example.myapp.model to com.fasterxml.jackson.databind;
}

模块类型

类型	说明
命名模块	有 module-info.java 的模块
自动模块	放在模块路径上的普通 JAR
未命名模块	放在类路径上的 JAR

JDK 模块化

# 查看 JDK 模块
java --list-modules

# 常用模块
java.base      # 核心模块，自动依赖
java.sql       # JDBC
java.logging   # 日志
java.xml       # XML 处理
java.desktop   # AWT/Swing

JShell - 交互式编程

Java 的 REPL（Read-Eval-Print Loop）工具。

$ jshell

jshell> int x = 10
x ==> 10

jshell> x * 2
$2 ==> 20

jshell> String greet(String name) {
   ...>     return "Hello, " + name;
   ...> }
|  created method greet(String)

jshell> greet("Java")
$4 ==> "Hello, Java"

jshell> /list    # 列出所有代码
jshell> /vars    # 列出所有变量
jshell> /methods # 列出所有方法
jshell> /exit    # 退出

集合工厂方法

创建不可变集合的便捷方法。

// List
List<String> list = List.of("a", "b", "c");

// Set
Set<Integer> set = Set.of(1, 2, 3);

// Map
Map<String, Integer> map = Map.of(
    "one", 1,
    "two", 2,
    "three", 3
);

// 超过10个键值对使用 ofEntries
Map<String, Integer> largeMap = Map.ofEntries(
    Map.entry("one", 1),
    Map.entry("two", 2),
    // ...
);

// 注意：这些集合是不可变的
list.add("d");  // 抛出 UnsupportedOperationException

接口私有方法

public interface MyInterface {
    default void publicMethod() {
        privateMethod();
        privateStaticMethod();
    }
    
    // 私有方法
    private void privateMethod() {
        System.out.println("Private method");
    }
    
    // 私有静态方法
    private static void privateStaticMethod() {
        System.out.println("Private static method");
    }
}

Stream API 增强

// takeWhile - 获取满足条件的元素，遇到不满足的停止
Stream.of(1, 2, 3, 4, 5, 1, 2)
      .takeWhile(n -> n < 4)
      .forEach(System.out::println); // 1, 2, 3

// dropWhile - 丢弃满足条件的元素，遇到不满足的开始获取
Stream.of(1, 2, 3, 4, 5, 1, 2)
      .dropWhile(n -> n < 4)
      .forEach(System.out::println); // 4, 5, 1, 2

// ofNullable - 创建包含单个元素或空的流
Stream<String> stream = Stream.ofNullable(null); // 空流
Stream<String> stream2 = Stream.ofNullable("hello"); // 包含一个元素

// iterate 增强 - 带终止条件
Stream.iterate(1, n -> n < 100, n -> n * 2)
      .forEach(System.out::println); // 1, 2, 4, 8, 16, 32, 64

Optional 增强

Optional<String> optional = Optional.of("hello");

// ifPresentOrElse
optional.ifPresentOrElse(
    value -> System.out.println("Value: " + value),
    () -> System.out.println("Empty")
);

// or - 返回另一个 Optional
Optional<String> result = optional
    .filter(s -> s.length() > 10)
    .or(() -> Optional.of("default"));

// stream - 转换为 Stream
Stream<String> stream = optional.stream();

try-with-resources 增强

// Java 9 之前
BufferedReader reader1 = new BufferedReader(new FileReader("file.txt"));
try (BufferedReader r = reader1) {
    // 使用 reader
}

// Java 9 之后 - 可以使用 effectively final 变量
BufferedReader reader2 = new BufferedReader(new FileReader("file.txt"));
try (reader2) {  // 直接使用变量
    // 使用 reader
}

进程 API 增强

// 获取当前进程
ProcessHandle current = ProcessHandle.current();
System.out.println("PID: " + current.pid());

// 进程信息
ProcessHandle.Info info = current.info();
info.command().ifPresent(cmd -> System.out.println("Command: " + cmd));
info.startInstant().ifPresent(start -> System.out.println("Started: " + start));

// 获取所有进程
ProcessHandle.allProcesses()
    .filter(p -> p.info().command().isPresent())
    .limit(10)
    .forEach(p -> System.out.println(p.pid() + ": " + p.info().command().get()));

// 等待进程结束
Process process = new ProcessBuilder("ls", "-la").start();
process.toHandle().onExit().thenAccept(p -> 
    System.out.println("Process exited with: " + p.exitValue())
);

HTTP/2 Client (孵化)

// Java 9 中是孵化模块，Java 11 正式发布
HttpClient client = HttpClient.newHttpClient();

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

HttpResponse<String> response = client.send(request, 
    HttpResponse.BodyHandlers.ofString());

System.out.println(response.statusCode());
System.out.println(response.body());

其他改进

改进的 @Deprecated

@Deprecated(since = "9", forRemoval = true)
public void oldMethod() {
    // 标记从哪个版本开始废弃，是否将被移除
}

钻石操作符用于匿名类

// Java 9 之前不允许
// Java 9 之后可以
Comparator<String> comparator = new Comparator<>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
};

总结

特性	说明
模块化系统	更好的封装和依赖管理
JShell	交互式编程工具
集合工厂方法	便捷创建不可变集合
接口私有方法	接口内部代码复用
Stream 增强	takeWhile、dropWhile、ofNullable
Optional 增强	ifPresentOrElse、or、stream
进程 API	更强大的进程管理

Java 9 的模块化系统是 Java 平台的重大变革，虽然学习曲线较陡，但为大型应用提供了更好的架构支持。