JAVA + SPRING BOOT INTERVIEW PREP OUTLINE (3 YOE – LEAN VERSION)
SECTION 1: JAVA CORE (HIGH PRIORITY)
1. OOP Fundamentals
2. Encapsulation, Inheritance, Polymorphism, Abstraction
3. Real-world examples (important for interviews)
4. Composition vs Inheritance
5. SOLID principles (basic understanding)
6. Core Java Internals (Interview Focused)
7. JVM basics (Heap, Stack, Method Area – high level only)
8. Memory allocation (objects, references)
9. String Pool & immutability
10. Collections Framework (VERY IMPORTANT)
11. List vs Set vs Map (when to use what)
12. HashMap:
13. Internal working (bucket, hashing, collision)
14. equals() & hashCode() relation ⚠️
15. ArrayList vs LinkedList
16. HashSet vs TreeSet
17. Important Concepts
18. equals() vs ==
19. hashCode() contract
20. String vs StringBuilder vs StringBuffer
21. Wrapper classes & autoboxing
22. Exception Handling
23. Checked vs Unchecked exceptions
1
24. Custom exceptions (basic idea)
25. Best practices
SECTION 2: JAVA CONCURRENCY (JUST ENOUGH)
1. Basics
2. Thread vs Process
3. Thread lifecycle
4. Runnable vs Callable
5. Synchronization
6. synchronized keyword
7. Race condition (concept + example)
8. Deadlock (concept only)
9. Executors (IMPORTANT)
10. ExecutorService
11. Thread pools (why needed)
12. Future & Callable (basic usage)
👉 Focus on concepts + use cases, not low-level internals
SECTION 3: SPRING CORE (VERY IMPORTANT)
1. Core Concepts
2. Inversion of Control (IoC)
3. Dependency Injection (DI)
4. Why DI is useful (real-world reasoning)
5. Beans
6. Bean lifecycle (init → destroy) ⚠️
7. Bean scopes (singleton, prototype)
2
8. Annotations
9. @Component, @Service, @Repository
10. @Autowired (how dependency is injected)
11. Important Understanding
12. How Spring container works (high level)
13. Constructor vs field injection (which is better and why)
SECTION 4: SPRING MVC (CRITICAL)
1. Architecture
2. DispatcherServlet ⚠️ VERY IMPORTANT
3. End-to-end request flow: Request → DispatcherServlet → Controller → Service → Response
4. Components
5. @RestController
6. @RequestMapping / @GetMapping / @PostMapping
7. Request & Response handling
8. Filters vs Interceptors
9. When to use each (high-level difference)
SECTION 5: SPRING BOOT (CORE)
1. Basics
2. What is Spring Boot
3. Why it is used
4. Key Concepts
5. Auto-configuration (high-level idea)
3
6. @SpringBootApplication
7. Starter dependencies
8. Configuration
9. [Link] / [Link]
10. Profiles (dev, prod)
11. Application Lifecycle (Important)
12. What happens when Spring Boot app starts (high-level flow)
SECTION 6: REST API DESIGN (VERY IMPORTANT)
1. REST Principles
2. Statelessness
3. Resource-based design
4. HTTP Basics
5. Methods: GET, POST, PUT, DELETE
6. Status codes (200, 201, 400, 404, 500)
7. API Design
8. DTO vs Entity ⚠️
9. Request/Response structure
10. Validation basics
11. Best Practices
12. Clean URL design
13. Error handling
4
SECTION 7: DATABASE + JPA (IMPORTANT)
1. Basics
2. What is JPA
3. Hibernate as implementation
4. Entity Mapping
5. @Entity, @Id
6. Relationships:
7. OneToMany
8. ManyToOne
9. Fetching
10. Lazy vs Eager ⚠️
11. Transactions
12. @Transactional (why needed)
13. Performance Awareness
14. N+1 problem (concept + example)
SECTION 8: SECURITY (JUST ENOUGH)
1. Basics
2. Why security is needed
3. Spring Security
4. Authentication vs Authorization
5. JWT (IMPORTANT)
6. Login flow: User → Authenticate → Generate token → Use token in requests
👉 Focus on flow, not deep internals
5
SECTION 9: PRODUCTION BASICS (HIGH IMPACT)
1. Exception Handling
2. Global exception handling
3. Clean error responses
4. Logging
5. Why logging is important
6. Basic usage
7. Validation
8. Input validation basics
SECTION 10: PROJECT UNDERSTANDING (GAME CHANGER)
You MUST be able to explain:
1. Architecture
2. Controller → Service → Repository flow
3. Design Decisions
4. Why DTO?
5. Why layered architecture?
6. Real-World Thinking
7. What happens if traffic increases?
8. Where can your system fail?
9. Improvements
10. How would you scale?
11. What would you optimize?
6
FINAL NOTE:
Focus on: ✔ Depth over breadth
✔ Clear explanations
✔ Real-world reasoning
You do NOT need to know everything.
You need to explain what you know REALLY WELL.