Java 知识体系

一张图看清 Java 技术栈全貌，理解每个知识点在体系中的位置与关联关系。

一、全景架构图

┌─────────────────────────────────────────────────────────────────────────────┐
│                           Java 知识体系全景图                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        放弃篇：面试与踩坑                             │   │
│  │              面试八股  │  常见坑  │  终极总结                         │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        无为篇：工程实践                               │   │
│  │              最佳实践  │  代码规范  │  设计模式                        │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        修仙篇：架构思维                               │   │
│  │              源码解读  │  框架设计  │  架构思维                        │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        无敌篇：分布式架构                             │   │
│  │       微服务  │  分布式  │  高并发  │  性能调优                        │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        高级篇：框架与中间件                           │   │
│  │     Spring  │  Spring Boot  │  MyBatis  │  数据库  │  Redis  │  MQ   │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        原理篇：JVM 底层                               │   │
│  │        JVM  │  类加载  │  垃圾回收  │  内存模型                        │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        进阶篇：语言特性深挖                           │   │
│  │     泛型  │  反射  │  代理  │  注解  │  多线程  │  网络编程  │  JUC  │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    ▲                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        基础篇：Java 核心                              │   │
│  │  Java语法  │  面向对象  │  异常处理  │  集合  │  IO  │  Lambda与Stream │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

二、知识依赖关系

每个知识点不是孤立的，它们之间存在层层递进的依赖关系。理解这些依赖，才能知道"先学什么，后学什么"。

2.1 纵向依赖链（自底向上）

Java语法 → 面向对象 → 异常处理 → 集合 → IO → Lambda/Stream
                                      ↓
                                   泛型 ──────→ 反射 ──→ 代理
                                      ↓                     ↓
                                   注解 ←──────────────────┘
                                      ↓
                                   多线程 → JUC → 网络编程
                                      ↓
                                   JVM → 类加载 → 垃圾回收 → 内存模型
                                      ↓
                              Spring → Spring Boot → MyBatis → 数据库 → Redis → MQ
                                      ↓
                              微服务 → 分布式 → 高并发 → 性能调优
                                      ↓
                              源码解读 → 框架设计 → 架构思维
                                      ↓
                              最佳实践 → 代码规范 → 设计模式

2.2 关键依赖解读

依赖关系	为什么
集合 → 泛型	集合框架大量使用泛型，List<String> 就是泛型最直观的应用
泛型 + 反射 → 代理	动态代理通过反射调用方法，泛型擦除影响代理的运行时行为
反射 + 代理 → 注解	注解处理器通过反射读取注解，Spring AOP 用代理实现注解驱动
多线程 → JUC	JUC 是多线程的高级工具包，建立在 Thread/synchronized 基础上
JVM + 类加载 → Spring	Spring 的 Bean 容器本质是类加载和反射的综合应用
Spring + 多线程 → 微服务	微服务以 Spring Boot 为基础，并发处理是高并发的前提
代理 + 反射 → MyBatis	MyBatis 的 Mapper 接口通过 JDK 动态代理生成实现
数据库 → 分布式	分布式事务、分库分表建立在数据库基础之上
集合 + 多线程 → Redis	Redis 的数据结构是集合在内存中的延伸，并发控制基于 JUC

三、学习路线图

阶段一：入门（0→1 年）—— 能写代码

第1步：Java语法 → 变量、运算符、流程控制、数组
第2步：面向对象 → 封装、继承、多态、抽象类、接口、内部类
第3步：异常处理 → try-catch、受检/非受检、try-with-resources
第4步：集合 → ArrayList、HashMap、fail-fast、ConcurrentHashMap
第5步：IO → BIO、NIO、零拷贝、序列化
第6步：Lambda与Stream → 函数式编程、Stream API、Optional

目标： 独立完成 CRUD 功能，理解 Java 核心 API。

阶段二：进阶（1→3 年）—— 能写好的代码

第7步：泛型 → 类型擦除、通配符、PECS 原则
第8步：反射 → Class、Method、Field、setAccessible、性能
第9步：代理 → JDK 动态代理、CGLIB、Spring AOP 原理
第10步：注解 → 元注解、自定义注解、编译期/运行时处理
第11步：多线程 → 线程生命周期、synchronized、volatile、线程池
第12步：JUC → Lock、AQS、CountDownLatch、BlockingQueue、ConcurrentHashMap
第13步：网络编程 → TCP/IP、Socket、Netty、半包粘包

目标： 理解框架底层原理，能写出高性能、线程安全的代码。

阶段三：深入（3→5 年）—— 能造轮子

第14步：JVM → 内存区域、JIT、参数调优
第15步：类加载 → 双亲委派、SPI、自定义类加载器
第16步：垃圾回收 → 可达性分析、G1、ZGC、GC 调优
第17步：内存模型 → happens-before、volatile 屏障、CAS
第18步：Spring → IoC 容器、AOP、事务传播、Bean 生命周期
第19步：Spring Boot → 自动配置、起步依赖、Actuator
第20步：MyBatis → 动态 SQL、缓存、插件机制
第21步：数据库 → 索引、事务隔离、MVCC、SQL 优化

目标： 理解 JVM 底层，能进行性能调优、框架定制。

阶段四：架构（5+ 年）—— 能设计系统

第22步：Redis → 数据结构、持久化、集群、缓存问题
第23步：消息队列 → RocketMQ、Kafka、事务消息、幂等
第24步：微服务 → 拆分原则、Spring Cloud、CAP
第25步：分布式 → 分布式锁、分布式事务、分布式 ID
第26步：高并发 → 缓存策略、分库分表、限流熔断
第27步：性能调优 → JVM/DB/代码多维度调优、Arthas

目标： 独立设计分布式系统架构，解决高并发、高可用问题。

阶段五：大师（终极）—— 能传道授业

第28步：源码解读 → Spring IoC/AOP 源码、MyBatis 源码
第29步：框架设计 → SPI、模板方法、责任链、手写 ORM/RPC
第30步：架构思维 → SOLID、DDD、六边形架构、CQRS、ADR
第31步：设计模式 → 单例、工厂、策略、观察者、装饰器、代理
第32步：最佳实践 → 命名、异常处理、空处理、并发、日志
第33步：代码规范 → 阿里巴巴规范、Code Review
第34步：面试八股 + 常见坑 → 高频面试题、20+ 常见坑点

目标： 形成完整的知识体系，能指导团队、设计框架。

四、知识点横向关联网络

4.1 以"Spring"为中心的关联

                    ┌──────────────┐
                    │   反射       │ ← Bean 实例化、@Autowired 注入
                    │   代理       │ ← AOP 切面、事务代理
                    │   注解       │ ← @Service、@Transactional
        ┌───────────┤   泛型       │ ← List<Bean>、ApplicationEvent<T>
        │           │   多线程     │ ← @Async、线程池
        │           │   JVM       │ ← Bean 生命周期、内存管理
        │           └──────────────┘
        ▼
   ┌─────────┐
   │ Spring  │
   └─────────┘
        │
        ├──→ Spring Boot：自动配置、起步依赖（注解 + SPI + 条件装配）
        ├──→ MyBatis：Mapper 代理（JDK 动态代理）、事务集成（AOP）
        ├──→ Redis：Spring Cache 抽象（@Cacheable → AOP 拦截）
        ├──→ MQ：消息监听（注解驱动）、事务消息（分布式事务）
        ├──→ 微服务：Spring Cloud（基于 Spring Boot 的生态）
        ├──→ 分布式：Seata 分布式事务（AOP 拦截 + 全局事务协调）
        └──→ 高并发：线程池配置、异步处理、缓存策略

4.2 以"多线程"为中心的关联

                    ┌──────────────┐
                    │   JVM        │ ← 内存模型（happens-before）、锁升级
                    │   集合       │ ← ConcurrentHashMap、BlockingQueue
                    │   代理       │ ← AOP 切面线程安全
        ┌───────────┤   JUC        │ ← Lock、AQS、线程池
        │           │   Redis      │ ← 分布式锁（Redisson）、缓存并发
        │           │   数据库     │ ← 事务隔离、MVCC、行锁
        │           └──────────────┘
        ▼
   ┌─────────┐
   │ 多线程   │
   └─────────┘
        │
        ├──→ JUC：Lock、CountDownLatch、Semaphore、ForkJoinPool
        ├──→ 高并发：线程池调优、异步处理、CompletableFuture
        ├──→ 分布式锁：Redis RedLock、Zookeeper 临时顺序节点
        ├──→ 性能调优：死锁排查、线程 dump 分析、锁竞争优化
        └──→ 设计模式：Future 模式、生产者-消费者、读写锁分离

4.3 以"数据库"为中心的关联

                    ┌──────────────┐
                    │   集合       │ ← 数据结构类比（B+Tree vs HashMap）
                    │   MyBatis    │ ← SQL 映射、缓存、插件
                    │   Spring     │ ← 事务管理、DataSource 配置
        ┌───────────┤   JVM        │ ← 连接池内存、GC 对响应时间的影响
        │           │   多线程     │ ← 连接池并发、事务隔离
        │           │   设计模式   │ ← 连接池（享元模式）、ORM（桥接模式）
        │           └──────────────┘
        ▼
   ┌─────────┐
   │ 数据库   │
   └─────────┘
        │
        ├──→ Redis：缓存策略（Cache Aside）、缓存穿透/击穿/雪崩
        ├──→ 分布式：分库分表、分布式事务（TCC、Saga、Seata）
        ├──→ 高并发：读写分离、连接池优化、慢查询优化
        ├──→ MQ：异步写入、最终一致性、事务消息
        └──→ 性能调优：EXPLAIN、索引优化、SQL 重写

4.4 以"设计模式"为中心的关联

设计模式不是孤立的知识点，它贯穿整个 Java 技术栈：

Singleton    → Spring Bean 默认作用域、枚举单例、DCL
Factory      → BeanFactory、SqlSessionFactory、ThreadFactory
Builder      → Lombok @Builder、StringBuilder、OkHttp Request
Proxy        → JDK 动态代理、CGLIB、Spring AOP、MyBatis Mapper
Strategy     → 线程池拒绝策略、负载均衡策略、排序算法
Observer     → Spring Event、MQ 消费者、Zookeeper Watcher
Template     → JdbcTemplate、RestTemplate、RedisTemplate
Decorator    → IO 流（BufferedInputStream）、Collections.synchronizedList
Chain of Resp→ Filter 链、Interceptor 链、MyBatis 插件链
Adapter      → Spring MVC HandlerAdapter、SLF4J 日志门面

五、技术栈分层对照

┌──────────────────────────────────────────────────────────────────┐
│                      应用层（Application）                        │
│   微服务  │  分布式  │  高并发  │  性能调优                        │
├──────────────────────────────────────────────────────────────────┤
│                      框架层（Framework）                          │
│   Spring  │  Spring Boot  │  MyBatis  │  设计模式                  │
├──────────────────────────────────────────────────────────────────┤
│                      中间件层（Middleware）                        │
│   Redis  │  RocketMQ/Kafka  │  数据库  │  Nginx                    │
├──────────────────────────────────────────────────────────────────┤
│                      运行时层（Runtime）                           │
│   JVM  │  类加载  │  垃圾回收  │  内存模型  │  JIT               │
├──────────────────────────────────────────────────────────────────┤
│                      语言层（Language）                            │
│   语法  │  面向对象  │  异常  │  集合  │  IO  │  Lambda/Stream   │
│   泛型  │  反射  │  代理  │  注解  │  多线程  │  JUC  │  网络    │
├──────────────────────────────────────────────────────────────────┤
│                      工程层（Engineering）                         │
│   最佳实践  │  代码规范  │  架构思维  │  源码解读  │  框架设计      │
└──────────────────────────────────────────────────────────────────┘

阅读顺序： 语言层 → 运行时层 → 框架层 → 中间件层 → 应用层 → 工程层。每一层都是上一层的基础，跳过会埋坑。

六、知识关联速查表

我要学	前置知识	关联知识	通向
泛型	集合	反射、代理	框架设计
反射	面向对象、泛型	代理、注解	Spring IoC、MyBatis
代理	反射	Spring AOP	MyBatis Mapper、RPC
注解	反射	Spring	框架设计
多线程	面向对象	JUC、JVM 内存模型	高并发、性能调优
JUC	多线程	集合	高并发、分布式锁
JVM	语法、面向对象	类加载、GC、内存模型	性能调优
GC	JVM	内存模型	性能调优
Spring	反射、代理、注解	Spring Boot、MyBatis	微服务
MyBatis	代理、数据库	Spring	分布式
数据库	集合	Redis、MyBatis	分布式、高并发
Redis	集合、多线程	数据库	高并发、分布式锁
MQ	多线程、网络编程	分布式	微服务、高并发
微服务	Spring Boot	分布式、高并发	架构思维
分布式	数据库、多线程	微服务、高并发	架构思维
高并发	多线程、Redis、MQ	分布式、性能调优	架构思维
设计模式	面向对象、代理	Spring、MyBatis	框架设计
源码解读	Spring、MyBatis、JVM	框架设计	架构思维

七、学习建议

7.1 不要跳级

很多人急着学微服务、分布式，但连 HashMap 原理、JVM 内存模型都不清楚。结果是：面试一问就倒，线上出问题不会排查。基础不牢，地动山摇。

7.2 带着问题学

每个知识点都应该回答三个问题：

1. 为什么需要它？ —— 它解决了什么问题？没有它之前是怎么做的？
2. 怎么实现的？ —— 底层原理是什么？核心机制是怎样的？
3. 用在哪里？ —— 哪些框架/场景用到了？我怎么用？

7.3 交叉验证

知识之间是相互关联的。学完 Spring 再回头看反射和代理，学完 Redis 再回头看集合和线程安全，会发现豁然开朗。别怕重复，每次回看都有新收获。

7.4 动手实践

• 基础篇：每个 API 写一遍
• 进阶篇：看源码，写 Demo
• 原理篇：调 JVM 参数，看 GC 日志
• 框架篇：手写 Mini 框架
• 分布式篇：本地搭环境，跑通流程

---

体系的力量： 孤立的知识点是散落的珍珠，知识体系是串起珍珠的线。有了体系，你看到的不是 34 个知识点，而是一张可以随时调用的思维网络。