首页 简介 模块化 并发 安全 网络 XML JDBC 反射 序列化 JVM 面试 FAQ 相关

Java核心技术 卷II(第11版)|深度解析与实战指南

《Java核心技术 卷II:高级特性》(第11版,英文原版名:Core Java Volume II—Advanced Features)由经典技术作者Cay S. Horstmann最新修订,全面覆盖JDK 11核心高级特性,是中高级Java开发者不可或缺的权威技术指南。本书以模块化系统、并发编程、网络编程、安全机制、XML与数据库集成、反射与动态代理等为核心主线,结合真实项目场景与企业级实践,深入剖析Java高级开发中的关键问题与最佳实践。

与第10版相比,第11版全面重构以适配JDK 11 LTS版本,新增模块化系统(JPMS)详解、HTTP Client API(支持HTTP/2)、本地变量类型推断(var)在高级场景中的应用、时间与日期API(java.time)深度实践、ZGC与 Shenandoah垃圾收集器对比分析等前沿内容,同时删除已废弃的旧API(如旧版URL流处理、CORBA支持),确保内容与当前工业界技术栈高度同步。

本书内容不仅适用于准备技术面试的开发者,更是企业级Java应用架构师、系统优化工程师、微服务研发团队的必备参考手册。我们在此基础上进一步整合社区高频问题与实战经验,构建系统性知识图谱,帮助读者从“会用”进阶到“懂原理、能调优、敢设计”。

⚠️ 提示:本书面向具备Java SE基础的读者,建议前置掌握集合框架、异常处理、I/O流、面向对象设计等核心内容。若为初学者,请先学习《Java核心技术 卷I:基础知识》(第11版)。

📖 书籍结构与内容概览

全书共14章,围绕JDK 11高级特性展开,结构清晰、层层递进,逻辑严谨。各章核心内容如下:

⚡第1章:模块化系统

深入解析JPMS(Java Platform Module System),包括module-info.java定义、模块依赖管理、服务加载机制、模块路径与类路径混合使用策略。

⚙️第2章:并发编程进阶

涵盖CompletableFuture异步编程、ForkJoinPool并行计算、并行流与并行数组、线程池调优、并发容器深度对比(ConcurrentHashMap、ConcurrentSkipListMap等)。

🔒
🔒第3章:安全机制

详解Java安全架构(JAAS、JCA、JCE、JSSE)、数字签名、证书管理、加密算法(AES、RSA、SHA-256)、SSL/TLS连接实现、权限控制(AccessController)。

🌐第4章:网络编程

重点介绍新一代HTTP Client(支持HTTP/2、WebSocket、响应式流)、NIO.2异步通道、Unix域套接字、代理透明处理、连接池优化。

📋第5章:XML与JSON处理

对比DOM/SAX/StAX解析器、JAXB 2.3迁移指南、Jackson与Gson在企业级序列化中的选型策略、Schema验证、XSLT转换。

💾第6章:数据库连接

JDBC 4.3新特性、连接池(HikariCP)深度集成、异步查询、事务隔离级别实战、SQL注入防护、二级缓存设计。

🔍第7章:反射与动态代理

MethodHandles与MethodType、LambdaMetafactory原理、动态代理(JDK Proxy vs CGLIB)、注解处理器(APT)开发、Spring AOP底层机制解密。

📦第8章:序列化机制

自定义Externalizable、Java 12新增的Switch表达式序列化兼容性、跨版本兼容策略、Kryo与Protobuf替代方案对比、安全反序列化防护。

此外,第9章讲解国际化与本地化(ResourceBundle、MessageFormat、PluralRules),第10章深入JVM内部(字节码结构、类加载机制、JVM参数调优),第11章介绍GUI高级主题(JavaFX集成、CSS样式、事件模型),第12章探讨性能监控(JFR、JMC、Arthas),第13章讲解测试框架(JUnit 5架构、Mockito增强),第14章提供完整项目案例(模块化微服务架构设计与实现)。

特别值得强调的是,本书所有示例代码均在JDK 11.0.2环境中验证通过,并标注了各API的since版本与废弃状态,避免读者踩坑。例如:旧版javax.xml.bind.DatatypeConverter在JDK 9中被标记为废弃,推荐改用java.util.Base64或javax.xml.bind.DatatypeConverter(需显式添加依赖模块java.xml.bind)。

📦 模块化系统(JPMS)深度解析

JDK 9引入的模块化系统(JPMS)是Java平台近20年来最重大的架构变革之一,旨在解决类路径混乱、JAR冲突、启动性能低下等长期痛点。其核心目标为:

⚙️

模块定义核心语法

每个模块必须包含module-info.java文件,定义模块名称、依赖、导出包、开放模块等:

module com.example.app { requires java.sql; requires transitive com.fasterxml.jackson.core; exports com.example.app.service; opens com.example.app.config to java.sql; uses com.example.app.spi.PluginProvider; provides com.example.app.spi.PluginProvider with com.example.app.impl.DemoPlugin; }

关键点说明:

⚠️ 注意:模块化与类路径(Class-Path)混合使用时,非模块化JAR被视为“自动模块”(Automatic Module),模块名为JAR文件名(去版本号、去.jar后缀),例如com.google.gson-2.8.9.jar → com.google.gson。但自动模块默认开放所有包,削弱封装性,应尽量避免。

模块路径(Module-Path)与类路径(Class-Path)共存时,JVM遵循“先模块路径后类路径”原则加载类。例如:java -p mods;lib -m com.example.app/com.example.app.Main中,mods为模块目录,lib为类路径目录。

模块化系统虽带来诸多优势,但迁移成本较高。企业级应用需逐步改造:优先将核心库模块化,再扩展至应用层;对第三方依赖不足的模块,可保留为自动模块或使用requires static声明可选依赖。

⚡ 并发编程:CompletableFuture与并行流

Java 8引入的CompletableFuture是异步编程的里程碑,支持函数式组合、异常处理、超时控制等高级特性。相比传统Future的阻塞get(),CompletableFuture提供非阻塞回调(thenApply、thenAccept、thenRun)与异常恢复(exceptionally、handle)机制。

链式组合与组合操作

通过thenCompose实现异步链(避免嵌套回调),thenCombine合并两个异步结果:

CompletableFuture future1 = CompletableFuture .supplyAsync(() -> fetchUser()); CompletableFuture future2 = CompletableFuture .supplyAsync(() -> fetchOrders()); // 串行依赖:order依赖user CompletableFuture chain = future1 .thenCompose(user -> future2.thenApply(orders -> user + " → " + orders)); // 并行合并:user与orders并行执行 CompletableFuture combined = future1 .thenCombine(future2, (u, o) -> "User: " + u + ", Orders: " + o);

注意:默认使用ForkJoinPool.commonPool(),线程数 = CPU核心数 - 1。高并发场景建议自定义Executor:

ExecutorService executor = Executors.newFixedThreadPool(16); CompletableFuture custom = CompletableFuture .supplyAsync(() -> heavyTask(), executor);

异常处理策略

CompletableFuture提供多种异常处理方式:

  • exceptionally(Function):捕获异常并返回默认值
  • handle(BiFunction):统一处理成功/失败结果
  • whenComplete(BiConsumer):仅触发副作用(不改变结果)
CompletableFuture result = CompletableFuture .supplyAsync(() -> { throw new RuntimeException("Network error"); }) .exceptionally(ex -> "Fallback: " + ex.getMessage());

实际案例:远程API调用超时降级

CompletableFuture apiCall = httpGET("https://api.example.com/data") .orTimeout(3, TimeUnit.SECONDS) .handle((res, ex) -> ex != null ? getCacheData() : res);

超时控制与取消

JDK 9新增orTimeout与completeOnTimeout:

  • orTimeout(duration, unit):超时后抛出CompletionException
  • completeOnTimeout(value, duration, unit):超时后返回默认值

结合cancel(true)可中断线程:

CompletableFuture future = CompletableFuture .supplyAsync(() -> { try { Thread.sleep(5000); } catch (InterruptedException e) {} return "Done"; }); future.completeOnTimeout("Timeout!", 2, TimeUnit.SECONDS); future.cancel(true); // 中断执行线程

并行流(Parallel Streams)与线程池

并行流底层依赖ForkJoinPool,但存在两大缺陷:

  1. 所有并行流共享commonPool线程池,IO密集型任务可能阻塞CPU密集型任务
  2. 线程数固定,无法动态调整

解决方案:自定义ForkJoinPool

ForkJoinPool customPool = new ForkJoinPool(8); // 指定线程数 customPool.submit(() -> list.parallelStream() .map(this::expensiveOperation) .collect(Collectors.toList()));

注意:并行流不适用于小数据集(<1000元素),且线程安全问题需额外处理(避免共享可变状态)。

高级技巧:使用CompletableFuture.delayedExecutor实现延迟执行,或结合CompletableFuture.allOf实现“等待全部完成”场景(如多数据源聚合):

List> futures = services.stream() .map(service -> CompletableFuture.runAsync(() -> service.call())) .collect(Collectors.toList()); CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])) .thenRun(() -> System.out.println("All services called"));

🔒 安全机制:加密、签名与访问控制

Java安全架构(JCA/JCE/JSSE/JAAS)提供分层安全能力:

🛡️

数字签名与验证

使用SHA256withRSA签名,防止数据篡改:

// 生成密钥对 KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(2048); KeyPair keyPair = kpg.generateKeyPair(); // 签名 Signature sig = Signature.getInstance("SHA256withRSA"); sig.initSign(keyPair.getPrivate()); sig.update(data); byte[] signature = sig.sign(); // 验证 sig.initVerify(keyPair.getPublic()); sig.update(data); boolean valid = sig.verify(signature); // true表示验证通过

访问控制(AccessController)实现最小权限原则:

// 定义权限:读取指定文件 FilePermission perm = new FilePermission("/home/user/data.txt", "read"); AccessControlContext context = AccessController.getContext(); AccessController.checkPermission(perm); // 无权限则抛AccessControlException // 自定义权限检查 PermissionCollection perms = new Permissions(); perms.add(perm); AccessControlContext restrictedContext = new AccessControlContext( new ProtectionDomain[] { new ProtectionDomain(null, perms) }); AccessController.doPrivileged(() -> { Files.readAllLines(Paths.get("/home/user/data.txt")); }, restrictedContext);

SSL/TLS连接需配置信任库(TrustStore)与密钥库(KeyStore):

// 加载信任库(仅信任CA签发的证书) KeyStore trustStore = KeyStore.getInstance("JKS"); trustStore.load(new FileInputStream("truststore.jks"), "changeit".toCharArray()); // 初始化SSLContext TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509"); tmf.init(trustStore); SSLContext sslContext = SSLContext.getInstance("TLSv1.3"); sslContext.init(null, tmf.getTrustManagers(), null); // 创建HTTPS连接 HttpsURLConnection conn = (HttpsURLConnection) new URL("https://secure.example.com") .openConnection(); conn.setSSLSocketFactory(sslContext.getSocketFactory());
⚠️ 注意:JDK 9起默认启用TLS 1.3,但部分旧服务器仅支持TLS 1.2。可通过System.setProperty("https.protocols", "TLSv1.2")降级。此外,避免硬编码密码,建议使用java.security.AuthProvider从环境变量或密钥管理服务获取。

🌐 新一代HTTP Client:支持HTTP/2与WebSocket

JDK 11正式引入java.net.http模块,替代过时的HttpURLConnection,支持HTTP/2、异步请求、响应式流(Reactive Streams)与WebSocket。

同步GET/POST请求

// 构建HTTP客户端 HttpClient client = HttpClient.newBuilder() .version(HttpClient.Version.HTTP_2) .build(); // 发送同步请求 HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.example.com/users/123")) .GET() .build(); HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); System.out.println("Status: " + response.statusCode()); System.out.println("Body: " + response.body());

POST请求需设置Content-Type与请求体:

HttpRequest post = HttpRequest.newBuilder() .uri(URI.create("https://api.example.com/users")) .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"Alice\"}")) .header("Content-Type", "application/json") .build(); HttpResponse postResponse = client.send(post, HttpResponse.BodyHandlers.ofString());

异步请求与流式处理

异步请求返回CompletableFuture,支持链式处理:

client.sendAsync(request, HttpResponse.BodyHandlers.ofString()) .thenApply(HttpResponse::body) .thenAccept(System.out::println) .exceptionally(ex -> "Error: " + ex.getMessage()) .join();

大文件下载使用流式BodyHandler:

client.sendAsync(request, HttpResponse.BodyHandlers.ofByteArray()) .thenApply(HttpResponse::body) .thenAccept(bytes -> { try (FileOutputStream fos = new FileOutputStream("download.bin")) { fos.write(bytes); } });

WebSocket客户端示例:

HttpClient client = HttpClient.newHttpClient(); CompletableFuture wsFuture = client.newWebSocketBuilder() .uri(URI.create("wss://echo.websocket.org")) .buildAsync();

WebSocket双向通信

client.newWebSocketBuilder() .uri(URI.create("wss://echo.websocket.org")) .buildAsync() .thenAccept(ws -> { ws.sendText("Hello WebSocket", true); ws.sendBinary(ByteBuffer.wrap(new byte[]{1,2,3}), true); ws.sendPing(ByteBuffer.allocate(0)); ws.onText((msg, last) -> System.out.println("Received: " + msg)); ws.onBinary((data, last) -> System.out.println("Binary: " + data.remaining())); ws.onClose((code, reason) -> System.out.println("Closed: " + code)); ws.sendClose(1000, "Goodbye"); });

代理配置示例:

HttpClient client = HttpClient.newBuilder() .proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 8080))) .authenticator(Authenticator.getDefault()) .build();

性能优化建议:

📋 XML处理:从DOM到StAX的演进

Java XML处理API历经多次迭代,各方案对比如下:

方案 内存占用 速度 适用场景 JDK版本
DOM(Document Object Model) 高(全加载内存) 慢 小文档、需随机访问节点 JDK 1.4
SAX(Simple API for XML) 低(流式解析) 快 大文档、仅顺序读取 JDK 1.4
StAX(Streaming API for XML) 低 快 大文档、需拉式解析 JDK 1.6
JAXB(Java Architecture for XML Binding) 中 中 对象 ↔ XML 映射 JDK 1.6(JDK 9废弃,需添加依赖)

StAX示例(拉式解析):

XMLInputFactory factory = XMLInputFactory.newInstance(); XMLStreamReader reader = factory.createXMLStreamReader( new FileInputStream("data.xml"), "UTF-8"); while (reader.hasNext()) { int event = reader.next(); if (event == XMLStreamConstants.START_ELEMENT) { if ("user".equals(reader.getLocalName())) { System.out.println("Found user: " + reader.getAttributeValue(0)); } } } reader.close();

JAXB 2.3迁移指南(JDK 9+需添加依赖):

// 添加Maven依赖 javax.xml.bind jaxb-api 2.3.1 org.glassfish.jaxb jaxb-runtime 2.3.1 // 使用示例 JAXBContext context = JAXBContext.newInstance(User.class); Marshaller marshaller = context.createMarshaller(); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); marshaller.marshal(user, System.out);
⚠️ 注意:JAXB 2.3已移除javax.xml.bind.DatatypeConverter的Base64方法(JDK 9废弃),改用java.util.Base64:
// 旧方式(JDK 8) String encoded = DatatypeConverter.printBase64Binary(data); // 新方式(JDK 9+) String encoded = Base64.getEncoder().encodeToString(data);

Schema验证确保XML结构合法性:

SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); Schema schema = sf.newSchema(new File("user.xsd")); Validator validator = schema.newValidator(); validator.validate(new StreamSource(new File("user.xml"))); // 验证失败则抛SAXException

💾 JDBC 4.3:异步查询与连接池集成

JDBC 4.3(JDK 8+)引入异步查询支持,通过Connection的createStatement(int, int, int)指定异步模式,或使用Statement.executeAsync()(需驱动支持)。

⚡

异步查询示例

Connection conn = dataSource.getConnection(); Statement stmt = conn.createStatement(); Future future = stmt.executeQueryAsync("SELECT * FROM users"); // 主线程继续执行其他任务 doSomethingElse(); // 获取结果 ResultSet rs = future.get(); while (rs.next()) { System.out.println(rs.getString("name")); }

HikariCP连接池配置(企业级推荐):

HikariConfig config = new HikariConfig(); config.setJdbcUrl("jdbc:mysql://localhost:3306/app"); config.setUsername("root"); config.setPassword("password"); config.setMaximumPoolSize(20); config.setMinimumIdle(5); config.setConnectionTimeout(30000); config.setIdleTimeout(600000); config.setMaxLifetime(1800000); HikariDataSource dataSource = new HikariDataSource(config); Connection conn = dataSource.getConnection();

连接池关键参数说明:

事务隔离级别控制:

conn.setAutoCommit(false); // 手动控制事务 conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); try { // 执行SQL stmt.executeUpdate("UPDATE accounts SET balance = balance - 100 WHERE id = 1"); stmt.executeUpdate("UPDATE accounts SET balance = balance + 100 WHERE id = 2"); conn.commit(); } catch (SQLException e) { conn.rollback(); throw e; }

防止SQL注入的正确方式(使用PreparedStatement):

PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE email = ?"); pstmt.setString(1, "alice@example.com"); ResultSet rs = pstmt.executeQuery();

🔍 反射与动态代理:从基础到高级

反射(Reflection)是Java动态性的核心,但性能开销较大。JDK 9起新增MethodHandles与MethodType提供更高效的反射调用(接近直接调用性能)。

MethodHandles:高效反射调用

// 获取目标方法的MethodHandle Lookup lookup = MethodHandles.lookup(); MethodHandle mh = lookup.findVirtual(String.class, "length", MethodType.methodType(int.class)); // 调用方法 Object result = mh.invoke("Hello"); // 返回5 // 绑定接收者(类似闭包) MethodHandle bound = MethodHandles.insertArguments(mh, 0, "World"); Object result2 = bound.invoke(); // 返回5

性能对比:MethodHandles调用比传统反射快2-5倍,接近直接调用(JMH基准测试数据)。

动态代理:JDK Proxy vs CGLIB

特性 JDK Proxy CGLIB
实现方式 基于接口代理 基于继承代理(生成子类)
性能 高(JDK原生) 中(需字节码生成)
限制 目标类必须实现接口 目标类不能是final,方法不能是final
典型应用 Spring AOP(接口代理) Spring AOP(类代理)、Hibernate延迟加载

JDK Proxy示例:

InvocationHandler handler = (proxy, method, args) -> { System.out.println("Before: " + method.getName()); Object result = method.invoke(target, args); System.out.println("After: " + method.getName()); return result; }; MyInterface proxy = (MyInterface) Proxy.newProxyInstance( getClass().getClassLoader(), new Class[]{MyInterface.class}, handler);

注解处理器(APT)开发

APT在编译期扫描注解并生成代码,典型应用:Dagger 2、Butter Knife、Lombok。

@SupportedAnnotationTypes("com.example.GenerateLogger") @SupportedSourceVersion(SourceVersion.RELEASE_11) public class LoggerProcessor extends AbstractProcessor { @Override public boolean process(Set annotations, RoundEnvironment roundEnv) { for (Element element : roundEnv.getElementsAnnotatedWith(GenerateLogger.class)) { // 生成Logger类代码 String className = element.getSimpleName() + "Logger"; // 使用Filer写入文件 // ... } return true; } }
⚠️ 注意:反射绕过封装性可能导致安全漏洞(如通过反射访问私有字段)。JDK 9起引入--illegal-access=deny参数禁用默认反射访问(仅允许模块内部访问)。

📦 序列化机制:安全与跨版本兼容

Java原生序列化存在两大风险:

解决方案:

  1. 实现Externalizable替代Serializable,完全控制序列化过程
  2. 显式声明serialVersionUID(推荐使用JDK工具serialver生成)
  3. 添加readObject与writeObject自定义逻辑
  4. 对敏感字段使用transient关键字排除
public class User implements Externalizable { private String name; private transient String password; // 敏感字段不序列化 @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeUTF(name); // password不写入 } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { name = in.readUTF(); // password需重新赋值(如从配置读取) } }

跨版本兼容策略:

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); // 处理旧版本缺失字段 if (email == null) { email = "unknown@example.com"; // 默认值 } }

替代方案对比:

方案 兼容性 性能 跨语言 安全
Java原生序列化 差 低 否 ❌ 高风险
Kryo 中 高 否 ⚠️ 需白名单
Protobuf 优 高 ✅ 是 ✅ 安全
Jackson(JSON) 优 中 ✅ 是 ✅ 安全

Protobuf示例:

message User { required string name = 1; optional string email = 2; } // 生成Java代码后使用 User user = User.newBuilder() .setName("Alice") .setEmail("alice@example.com") .build(); byte[] bytes = user.toByteArray(); // 序列化 User parsed = User.parseFrom(bytes); // 反序列化

⚙️ JVM内部:类加载与性能调优

JVM类加载机制分为五阶段:加载 → 验证 → 准备 → 解析 → 初始化

加载

通过类加载器(Bootstrap/Extension/Application)将.class文件读入内存,生成Class对象

验证

确保字节码符合JVM规范(文件格式、元数据、字节码、符号引用验证)

准备

为静态变量分配内存并设置默认初始值(如int→0,引用→null)

解析

将常量池中的符号引用替换为直接引用(如类、字段、方法的内存地址)

初始化

执行类构造器<clinit>(静态变量赋值 + static代码块)

JVM调优关键参数:

参数 说明 推荐值
-Xms/-Xmx 堆初始/最大大小 建议相等(避免动态扩容)
-XX:MetaspaceSize 元空间初始大小 根据类数量调整(如256m)
-XX:MaxGCPauseMillis GC最大暂停时间(ms) 根据SLA设置(如200ms)
-XX:+UseG1GC 使用G1垃圾收集器 大内存堆(>4GB)首选
-XX:+UseStringDeduplication 启用字符串去重 字符串密集型应用

GC日志分析工具:

典型调优案例:

# 生产环境推荐配置 java -Xms2g -Xmx2g \ -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m \ -XX:+UseG1GC -XX:MaxGCPauseMillis=200 \ -XX:+UseStringDeduplication \ -Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags \ -jar app.jar

性能监控命令:

🎓 高频面试题精讲

基于社区调研,整理以下10大高频考点(附深度解答):

1. 模块化系统

Q:模块化与OSGi有何区别?

A:OSGi是动态模块化框架(运行时加载/卸载模块),而JPMS是静态模块系统(启动时确定依赖,无热部署)。JPMS更轻量,适合JDK自身模块化,OSGi适合应用层动态管理。

2. CompletableFuture

Q:thenApply与thenCompose区别?

A:thenApply返回F(包装嵌套),thenCompose返回F(扁平化)。例如:Future f1 = f.thenApply(s -> s.length()) vs Future f2 = f.thenCompose(s -> CompletableFuture.completedFuture(s.length()))。

3. HTTP/2

Q:HTTP/2相比HTTP/1.1核心改进?

A:二进制分帧、多路复用(单连接并发请求)、头部压缩(HPACK)、服务器推送(Server Push)。但需TLS加密(浏览器强制要求),非对称加密开销需权衡。

4. 安全机制

Q:数字签名与摘要(Hash)区别?

A:摘要(如SHA-256)是单向函数,用于校验数据完整性;数字签名是摘要 + 私钥加密,提供完整性 + 身份认证 + 不可否认性。

5. JDBC

Q:Connection与Statement的生命周期关系?

A:Statement必须依赖Connection存在。关闭Connection时自动关闭其创建的所有Statement。但建议手动关闭Statement(使用try-with-resources),避免连接池泄漏。

6. 反射

Q:为什么反射比直接调用慢?

A:反射需动态解析符号、安全检查、类型转换。JDK 9起MethodHandles通过内联缓存(Inline Cache)优化,性能接近直接调用(JMH测试:反射调用10ns vs MethodHandles 1.2ns vs 直接调用1ns)。

7. 序列化

Q:Externalizable与Serializable性能对比?

A:Externalizable避免默认序列化机制的反射开销,性能高30%-50%。但需手动处理所有字段,开发成本高。推荐:简单对象用Serializable(加serialVersionUID),高性能场景用Externalizable或Protobuf。

8. JVM调优

Q:G1与ZGC适用场景?

A:G1适合中等内存堆(4-32GB),停顿时间可控(<10ms);ZGC(JDK 11实验版,JDK 15正式)适合超大内存堆(TB级),停顿时间<1ms,但吞吐量略低。

9. 并发编程

Q:并行流底层线程池问题?

A:所有并行流共享ForkJoinPool.commonPool(),若其中一个任务阻塞(如IO),会导致其他任务排队。解决方案:ForkJoinPool.commonPool().submit(() -> list.parallelStream().forEach(...))或自定义ForkJoinPool。

10. XML处理

Q:StAX与SAX谁更灵活?

A:StAX是拉式解析(Iterator模式),可随时停止/跳过;SAX是推式解析(Observer模式),事件驱动。StAX更易用,适合复杂逻辑;SAX内存占用更低,适合超大文件。

💡 提示:面试时不仅要回答“是什么”,更要说明“为什么”与“如何选型”。例如:提到“为什么用G1而非CMS?”时,应补充“CMS已废弃(JDK 14),且G1支持并行GC与混合GC,更适合大内存堆”。

❓ 常见问题解答

开发环境配置

Q:JDK 11安装后如何验证模块化支持?

A:运行java --list-modules | findstr java.sql,若输出java.sql@11.0.2则支持。模块列表可通过java --list-modules查看。

Q:如何解决“找不到模块”错误?

A:检查module-info.java是否正确声明requires,确认模块路径(-p)包含模块目录,或添加依赖JAR至模块路径。

模块化迁移

Q:旧项目如何逐步模块化?

A:分阶段迁移:

  1. 将核心库模块化(如util、model)
  2. 用requires static声明可选依赖
  3. 对第三方JAR创建自动模块(requires gson)
  4. 最后重构应用模块

Q:如何处理自动模块与命名冲突?

A:显式指定模块名(requires com.fasterxml.jackson.core),或使用Automatic-Module-Name在JAR的MANIFEST.MF中声明。

生产部署

Q:如何构建精简JRE?

A:使用jlink工具:

jlink --module-path $JAVA_HOME/jmods;mods \ --add-modules com.example.app \ --strip-debug \ --compress 2 \ --output jre-minimal

Q:如何排查模块化启动失败?

A:添加--add-opens java.base/java.lang=ALL-UNNAMED临时开放模块(仅调试用),或使用--show-module-resolution查看模块解析过程。