Content
# Tool List
> Complete growth manual from Java beginner to AI engineer
[](.)
[](.)
[](.)
[](.)
[](.)
[](.)
[](.)
---
## Join the Community for Accelerated Growth
> **Scan the QR code to join the "AI Engineer Acceleration Community" knowledge planet and access in-depth content, source code analysis, practical projects, and 1-on-1 Q\&A**
<p align="center">
<a href="https://wx.zsxq.com/group/88882121514552" target="_blank"><img src="images/zsxq-qrcode.jpg" alt="Knowledge Planet QR Code" width="260"/></a>
</p>
**Benefits of joining:**
- Real records of interviews at top companies (ByteDance, Alibaba, Tencent, Meituan, JD, Didi)
- Weekly high-frequency interview questions and answer templates
- 1v1 resume modification service (helping you write highlights, not just template piling)
- AI Agent development from 0 to 1: RAG knowledge base / multi-Agent workflow / MCP practice
- Complete source code of enterprise-level Spring AI projects
- Employment cases and transformation experience sharing from alumni
---
## What Can This Project Help You With?
Unlike the common "memorizing interview questions" guides on the market, this project has three core focuses:
1. **Systematic growth, not fragmented brushing**: From basic programming to AI engineering, the four-layer system progresses step by step, with clear goals and paths at each step.
2. **Each knowledge point marked with AI era value**: Which technologies will still be core in 2026, which are about to be replaced by AI, and which need to be added - the document provides clear explanations.
3. **Exclusive AI transformation path for Java engineers**: Not a general AI tutorial, but the shortest transformation path designed specifically for engineers with a Java background, focusing on Spring AI / LangGraph4j / MCP, rather than the Python ecosystem.
---
## Four-Layer Growth System
```mermaid
flowchart TD
L0["Layer 0 · Programming Foundation\nJava Basics · OOP · Collections · MySQL Basics · Spring Boot\nGoal: 0 foundation → Junior Java Engineer"]
L1["Layer 1 · Java Engineering Foundation\nJVM · Concurrent Programming · Spring Source Code · MySQL Optimization · MyBatis\nGoal: In-depth understanding of underlying principles → Mid-level Java Engineer"]
L2["Layer 2 · Backend Engineering Advancement\nDistributed Systems · Microservices · Redis · Message Queues · High Availability Architecture\nGoal: Participate in architecture design → Senior Engineer"]
L3["Layer 3 · AI Engineer Transformation\nSpring AI · RAG · Agent · LangGraph4j · MCP · Vector Database\nGoal: Build enterprise-level AI applications → AI Engineer"]
L0 --> L1 --> L2 --> L3
style L0 fill:#607D8B,color:#fff,stroke:#455A64
style L1 fill:#1976D2,color:#fff,stroke:#0D47A1
style L2 fill:#F57C00,color:#fff,stroke:#E65100
style L3 fill:#7B1FA2,color:#fff,stroke:#4A148C
```
| Layer | Stage Name | Core Content | Reference Period | Target Position |
|------|------------|------------|------------|------------|
| Layer 0 | Programming Foundation | Java syntax, OOP, collections, MySQL basics, Spring Boot basics | 3~6 months | Junior Java Engineer |
| Layer 1 | Java Engineering Foundation | JVM, concurrent programming, Spring source code, MySQL optimization | 4~6 months | Mid-level Java Engineer |
| Layer 2 | Backend Engineering Advancement | Distributed systems, microservices, Redis, message queues, high availability architecture | 4~6 months | Senior/Architect |
| Layer 3 | AI Engineer Transformation | LLM basics, Spring AI, RAG, Agent, MCP | 3~6 months | AI Engineer |
---
## Three Quick Navigation Paths
### Path 1: Beginner Programmer (0 Foundation → Junior Engineer)
Suitable for: Programming beginners, career changers, and students
```mermaid
flowchart TD
S1["Java Basics\nOOP Characteristics · Collections Framework"]
S2["MySQL Basics\nSpring Basics · Spring Boot Basics"]
S3["MyBatis Basics · Git Usage\nComplete First CRUD Project"]
S4["Prepare for Junior Java Engineer Interview"]
S1 --> S2 --> S3 --> S4
style S1 fill:#43A047,color:#fff,stroke:#2E7D32
style S2 fill:#00897B,color:#fff,stroke:#00695C
style S3 fill:#0288D1,color:#fff,stroke:#01579B
style S4 fill:#5E35B1,color:#fff,stroke:#311B92
```
Detailed path document: [From Scratch: Beginner Programmer Growth Path](./docs/learning-path/01-beginner-to-junior.md)
---
### Path 2: Java Engineer Promotion (Junior → Senior)
Suitable for: 1~3 years of Java development experience, engineers looking to break through the bottleneck
```mermaid
flowchart TD
P1["In-depth JVM + Concurrent Programming\nLayer 1 Core"]
P2["Spring Source Code + MySQL Advanced\n+ MyBatis Source Code"]
P3["Redis Full Suite\n+ Message Queue Kafka / RocketMQ"]
P4["Distributed Systems + Microservices\n+ High Availability Architecture\nLayer 2 Core"]
P5["Charge into Top Company Senior Interview"]
P1 --> P2 --> P3 --> P4 --> P5
style P1 fill:#E53935,color:#fff,stroke:#B71C1C
style P2 fill:#FB8C00,color:#fff,stroke:#E65100
style P3 fill:#FDD835,color:#333,stroke:#F9A825
style P4 fill:#43A047,color:#fff,stroke:#1B5E20
style P5 fill:#8E24AA,color:#fff,stroke:#4A148C
```
Detailed path document: [Advanced Road: Mid-to-Senior Java Engineer Growth Path](./docs/learning-path/02-junior-to-senior.md)
---
### Path 3: AI Engineer Transformation (Java Engineer → AI Engineer)
Suitable for: Java backend engineers looking to transform into AI
```mermaid
flowchart TD
A1["LLM Basic Theory\n+ Prompt Engineering + Context Engineering"]
A2["Spring AI Basics\n+ Ollama Local Deployment"]
A3["RAG System Construction\n+ Vector Database"]
A4["Agent Development + LangGraph4j Workflow\n+ MCP Protocol + A2A Protocol"]
A5["Production-Level AI Application Deployment\n→ Competent AI Engineer Position"]
A1 --> A2 --> A3 --> A4 --> A5
style A1 fill:#1565C0,color:#fff,stroke:#0D47A1
style A2 fill:#0097A7,color:#fff,stroke:#006064
style A3 fill:#00838F,color:#fff,stroke:#004D40
style A4 fill:#2E7D32,color:#fff,stroke:#1B5E20
style A5 fill:#E65100,color:#fff,stroke:#BF360C
```
Detailed path document: [Transformation Path: Java Engineer → AI Engineer](./docs/learning-path/03-senior-to-ai-engineer.md)
---
## Core Differences from JavaGuide
| Comparison Dimension | JavaGuide | This Project |
|----------|-----------|--------|
| Positioning | Interview preparation | Systematic growth path + AI transformation |
| Audience | Java engineers preparing for job hopping | All stages from beginner to AI engineer |
| AI Content | None | Complete system of Spring AI / RAG / Agent / MCP |
| Learning Path | Based on knowledge points | Based on growth goals, clear path |
| AI Era Value Marking | None | Each module clearly marked with AI era core value |
| Code Examples | Less | Complete runnable Spring AI Demo |
| Transformation Support | None | Exclusive AI transformation path for Java engineers |
---
## Complete Directory Navigation
### Layer 0: Programming Foundation
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [Java Basics Core](./docs/java-basics/01-java-basics-core.md) | Data types, OOP, exceptions, generics, reflection | Reflection/generics widely used in AI frameworks, long-term core | ✅ |
| [Java Collections Framework Source Code](./docs/java-basics/02-collections-source.md) | ArrayList/LinkedList/HashMap/ConcurrentHashMap source code | Vector database clients and AI streaming processing rely on collection framework | ✅ |
| [Java Common Data Structures](./docs/data-structures-algorithms/01-data-structures.md) | Arrays, linked lists, stacks, queues, trees, heaps, graphs | Graph structure is the basis for understanding Agent workflow | ✅ |
| [Algorithmic Essentials](./docs/data-structures-algorithms/02-algorithms.md) | Sorting/searching/dynamic programming/backtracking/graph algorithms | AI-assisted programming era, understanding algorithms is more important than writing them | ✅ |
### Layer 1: Java Engineering Foundation
#### Concurrent Programming and Lock Mechanisms
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [Concurrent Programming Basics](./docs/concurrent-locks/01-concurrent-basics.md) | Thread lifecycle, thread pool, volatile, synchronized | Core capability for high-concurrency scenarios in AI inference services | ✅ |
| [In-depth Analysis of Java Lock Mechanisms](./docs/concurrent-locks/02-lock-mechanism.md) | Biased lock/lightweight lock/heavyweight lock/spin lock/lock upgrade process | Understand concurrency essence, write thread-safe AI applications | ✅ |
| [JUC Concurrent Toolkit](./docs/concurrent-locks/03-juc.md) | AQS source code/ReentrantLock/CountDownLatch/Semaphore | Streaming output (SSE) and asynchronous Agent scheduling are essential | ✅ |
| [JDK New Features (9~21)](./docs/concurrent-locks/04-jdk-new-features.md) | VirtualThread/Record/Sealed Class | Virtual threads are performance tools for high-concurrency AI services | ✅ |
#### Spring Family Bucket
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [Spring IoC/DI Source Code](./docs/spring/01-spring-ioc-source.md) | BeanFactory/ApplicationContext/Bean lifecycle | Spring AI's ChatClient relies on IoC container at the bottom | ✅ |
| [Spring AOP Source Code](./docs/spring/02-spring-aop-source.md) | Dynamic proxy/JDK proxy/CGLIB/aspect execution chain | Observability (Tracing/Logging) of AI applications relies on AOP | ✅ |
| [Spring Transaction Mechanism](./docs/spring/03-spring-transaction.md) | Transaction propagation/isolation level/@Transactional failure scenarios | Consistency guarantee for AI writing to vector database | ✅ |
| [Spring Startup Mechanism](./docs/spring/04-spring-startup.md) | 12 steps of refresh() source code analysis | Understand the loading principle of Spring AI AutoConfiguration | ✅ |
| [Spring Boot Auto-Configuration](./docs/springboot/01-auto-configuration.md) | @SpringBootApplication/SPI/AutoConfigurationImportSelector | All Spring AI components are injected via AutoConfig | ✅ |
| [Spring Boot Singleton and Circular Dependency](./docs/springboot/02-singleton-pattern.md) | Singleton Bean principle/three-level cache to resolve circular dependencies | Essential for checking circular dependencies in multi-bean collaboration of AI applications | ✅ |
#### MySQL Database
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [MySQL Basics and SQL](./docs/mysql/01-mysql-basics.md) | DDL/DML/DCL, SQL execution order | Metadata management of RAG system relies on MySQL | ✅ |
| [Index Principle: Clustered and Non-Clustered](./docs/mysql/02-index-clustered.md) | B+ tree structure/clustered index/covering index | Hybrid retrieval of vector and relational databases requires in-depth understanding of indexes | ✅ |
| [MySQL Transactions and Locks](./docs/mysql/03-transaction-lock.md) | MVCC/ACID/row lock/gap lock/deadlock | Long-term core, AI will not replace data consistency requirements | ✅ |
| [SQL Optimization and Execution Plan](./docs/mysql/04-sql-optimization.md) | EXPLAIN analysis/slow query/index failure | Performance bottleneck of AI applications often lies in the database layer | ✅ |
#### MyBatis
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [MyBatis Core Principle](./docs/mybatis/01-mybatis-core.md) | SqlSession/Executor/cache mechanism | Verification of correctness of AI-generated SQL requires understanding of underlying mechanism | ✅ |
| [MyBatis Source Code Analysis](./docs/mybatis/02-mybatis-source.md) | Configuration loading/SQL parsing/result mapping/plugin | Understanding plugin mechanism can extend AI-enhanced persistence capabilities | ✅ |
### Layer 2: Backend Engineering Advancement
#### Message Queue
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [Message Queue Selection and Comparison](./docs/message-queue/01-mq-comparison.md) | Core comparison of Kafka/RabbitMQ/RocketMQ | Asynchronous AI tasks (document processing/embedding calculation) are essential | ✅ |
| [In-depth Analysis of Kafka](./docs/message-queue/02-kafka.md) | Partition/Replica/consumer group/zero-copy | Core infrastructure of AI data pipeline | ✅ |
| [In-depth Analysis of RabbitMQ](./docs/message-queue/03-rabbitmq.md) | Exchange/Queue/message confirmation/dead letter queue | Common solution for AI task scheduling and asynchronous callback | ✅ |
| [In-depth Analysis of RocketMQ](./docs/message-queue/04-rocketmq.md) | Sequential messages/transaction messages/delayed messages | High-frequency selection for domestic AI application production environment | ✅ |
#### Redis · Distributed · Microservices · High Availability (Planned)
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| Redis full suite (data structures/persistence/cluster) | Cache penetration/distributed lock/publish-subscribe | Session cache/vector cache layer for AI applications | Planned |
| Distributed systems (CAP/distributed locks/ transactions) | Raft protocol/Seata/distributed ID | Distributed coordination basis for multi-Agent systems | Planned |
| Microservices (Spring Cloud Alibaba) | Nacos/Sentinel/Gateway | AI microservice gateway authentication/rate limiting | Planned |
| High availability design (rate limiting/circuit breaking/caching) | Resilience4j/multi-level caching | Fault-tolerant design for AI inference services | Planned |
### Layer 3: AI Engineer Transformation
| Document | Content | AI Era Value | Progress |
|------|------|-----------|------|
| [Ollama Local Large Model Deployment](./docs/ai-engineering/01-ollama-setup.md) | Installation/model management/API call/Docker deployment | Local deployment is a core requirement for enterprise AI landing | ✅ |
| [Spring AI + Ollama Integration](./docs/ai-engineering/02-spring-ai-integration.md) | ChatClient/multi-turn dialogue/RAG/Function Calling | Preferred framework for Java engineers to build AI applications | ✅ |
| [Spring AI Alibaba + LangGraph](./docs/ai-engineering/03-spring-ai-alibaba-langgraph.md) | Tongyi Qianwen access/LangGraph4j state machine/multi-agent | Preferred for domestic large factory landing, high job demand | ✅ |
| [LangChain4j Practice](./docs/ai-engineering/04-langchain4j.md) | AI Service interface/@Tool tool call/RAG pipeline | Important alternative for AI development in Java ecosystem | ✅ |
### Learning Path Navigation Document
| Document | Suitable Audience |
|------|----------|
| [From Scratch: Beginner Programmer Growth Path](./docs/learning-path/01-beginner-to-junior.md) | Zero programming foundation / Career changers |
| [Advanced Path: Mid-to-Senior Java Engineer Growth Path](./docs/learning-path/02-junior-to-senior.md) | 1～3 years of experience in Java development |
| [Transformation Path: Java Engineer → AI Engineer](./docs/learning-path/03-senior-to-ai-engineer.md) | Java foundation, wanting to switch to AI direction |
### Practical Code Demos
| Directory | Content |
|------|------|
| [code/algorithms/](./code/algorithms/) | Quick sort, merge sort, heap sort, dynamic programming, binary search, backtracking + N queens |
| [code/concurrent-demo/](./code/concurrent-demo/) | ThreadPoolExecutor, ReentrantLock, ReadWriteLock, CAS |
| [code/data-structures/](./code/data-structures/) | Linked list (LRU/reversal/palindrome), binary tree (DFS/BFS/LCA) |
| [code/spring-demo/](./code/spring-demo/) | Spring AI + Ollama complete demo (including RAG question and answer interface) |
### Interview Experience
| Chapter | Content |
|------|------|
| [High-Frequency Interview Questions Collection](./docs/interview-experience/01-high-frequency.md) | 100 high-frequency interview questions + standard answer templates |
| [Real Interview Experiences](./docs/interview-experience/02-interview-records.md) | Real interview experiences from ByteDance, Alibaba, Tencent, and Meituan |
---
## Quick Start Spring AI Demo
```bash
# 1. Install and start Ollama
brew install ollama && ollama serve
# 2. Pull models
ollama pull qwen2.5
ollama pull nomic-embed-text
# 3. Start Spring Boot application
cd code/spring-demo && mvn spring-boot:run
# 4. Load sample knowledge base
curl -X POST http://localhost:8080/api/rag/load-sample
# 5. Perform RAG question and answer
curl -X POST http://localhost:8080/api/rag/ask \
-H "Content-Type: application/json" \
-d '{"question": "What is the difference between HashMap and ConcurrentHashMap?"}'
```
---
## Contribution Guidelines
Welcome to submit issues and PRs! Contribution methods:
1. **Supplement documentation**: Create or improve `.md` files in the corresponding directory according to the existing format.
2. **Submit code examples**: Submit runnable example code under the `code/` directory.
3. **Error correction and revision**: Directly submit PRs if you find errors or unclear expressions.
4. **Learning path feedback**: Share your experience and suggestions after using this guide by opening an issue.
**Contribution norms:**
- Documentation is mainly in English, and code comments can be in both English and Chinese.
- Each knowledge point should be labeled with 'AI era value', explaining the importance of the technology in the AI era.
- Code examples should be runnable independently, with running instructions provided.
If this guide is helpful to you, please give it a Star, so more Java engineers can see this transformation path!
> For more in-depth content, interview experience sharing, resume modification, and AI practical project source code, scan the QR code to join the knowledge planet above.
