Volume

Java

44 notes·26h to read

Language Fundamentals

OOPs ConceptsEncapsulation, inheritance, polymorphism, abstraction, interfaces, abstract classes, access modifiers, and the SOLID principles in Java.35m
Java 8 FeaturesDefault & static methods in interfaces, functional interfaces, lambda expressions, method references, and the Streams API for declarative data processing.30m
Java Streams, DecodedA field guide for the Python/JS native — the conveyor-belt mental model, stream anatomy (source, intermediate, terminal), a map/filter Rosetta Stone, Collectors, DSA patterns, and the gotchas interviewers probe.40m

Design & Patterns

Object Class, equals/hashCode & SOLIDThe Object superclass and its inherited methods, overriding equals() and hashCode() correctly (including the instanceof vs getClass() trap), the equals/hashCode contract, HashSet internals, and the five SOLID principles.35m
Sorting — Comparable & ComparatorNatural ordering with Comparable, custom ordering with Comparator, Collections.sort(), lambda comparators, and multi-field sorting strategies.30m
Low Level Design — OOP & UMLObject-oriented design in practice — turning requirements into classes, UML class diagrams, and class relationships: association, aggregation, composition & inheritance.45m
SOLID Principles — ISP, DIP & LSPThe three SOLID principles that fight coupling hardest: Interface Segregation (split fat contracts), Dependency Inversion (depend on abstractions, not concretions), and Liskov Substitution (subtype must not surprise the base). Includes diagrams, analogies, and interview Q&A.35m
Factory Method PatternThe Factory Method creational pattern — intent, structure, when to use it, implementation with abstract creators, and real-world Java examples.30m
Creational Design PatternsFactory Method, Builder, and Singleton from the ground up — the principle of encapsulating what varies, the step-by-step Builder with immutability, thread-safety traps in Singleton, and when to reach for each pattern.40m

Data & I/O

File Handling & XNewsJava I/O streams, FileReader/FileWriter, BufferedReader, the File class, reading & writing text files, and the XNews file-processing project.30m
JDBC & TransactionsJava Database Connectivity — architecture, the 6 connection steps, CRUD, PreparedStatement, and transaction control with COMMIT & ROLLBACK.30m
JSON & JacksonJSON syntax, the Jackson ObjectMapper, serialization & deserialization, annotations (@JsonProperty, @JsonIgnore), and working with generic types.30m
HTTP, REST & RestTemplateHTTP protocol fundamentals, REST architecture, Spring RestTemplate for GET/POST/PUT/DELETE, exchange(), and ResponseEntity handling.30m

Concurrency

Intro to ThreadsProgram vs. process vs. thread, concurrency & parallelism, Runnable, core thread methods, the thread life cycle, and parallelization performance.30m
Thread SynchronizationRace conditions, synchronized & monitors, volatile, ReentrantLock, Semaphore, ReadWriteLock, wait()/notify(), and the Producer-Consumer pattern.30m
Thread Pools & ExecutorServiceWhy pools beat raw threads, the ExecutorService, submitting Callable tasks, retrieving results with Future, pool sizing, and graceful shutdown.30m

Spring Boot Framework

Introduction to Spring BootWhy Spring Boot exists, Spring vs Spring Boot, the core Spring concepts, scaffolding a project with the Spring Initializr (start.spring.io), and writing your first Hello World controller.30m
Spring Core — IoC & Dependency InjectionThe problem of tight coupling, Inversion of Control and Dependency Injection, the Spring container and ApplicationContext, Java-based config, @Bean vs @Component, and choosing a DI type. Includes interview Q&A.45m
REST API Backend, Beneath the HoodWhat every backend actually does — address vs port, anatomy of a request URL, the client → server flow, and proving it all by hand from the terminal. The plumbing underneath a Spring REST controller.30m
Test Doubles & MockitoTesting Spring code in isolation — the family of test doubles (dummy, stub, spy, mock, fake), and Mockito for stubbing collaborators, verifying interactions, and writing fast unit tests. Includes interview Q&A.35m
Spring Data JPA — From Object to TableThe persistence stack from controller to database, wiring MySQL to Spring Boot, turning a class into a table with @Entity, mapping relationships, and getting free CRUD from JpaRepository. Includes interview Q&A.45m
NoSQL, MongoDB & Spring DataWhere relational databases start to hurt, what NoSQL actually means, the shift from tables to documents, why MongoDB specifically, CRUD against a collection, and the Spring Data MongoDB layer. Includes interview Q&A.35m
Logging in Spring BootHow an application keeps a written record of what it did. Why println fails, Log4j's three moving parts, the level volume-knob, SLF4J as the facade Spring Boot actually uses, configuration in application.properties, and the Actuator live dashboard. Includes microexercises and interview Q&A.25m
Spring Security — Basic AuthHow an API stops guarding nothing and starts checking who you are and what you may do. Authentication vs authorization, the Spring Security filter chain, a request's journey through the guard, Basic Auth setup, and role-based access control. Includes microexercises and interview Q&A.40m
JWT Authentication with Spring SecurityWhy Basic Auth resends credentials every time and how a stateless token fixes it. What a JSON Web Token is, its header/payload/signature and how the signature buys trust, the end-to-end auth flow, wiring JWT into Spring Boot, minting a token at login, validating it on every request, and role-based authorization. Includes microexercises and interview Q&A.45m

Spring Boot by Building

The Layer MapThe map for the whole workshop: controllers, services, repositories, models, JPA, Lombok, Mockito, dependency injection, and where each concern belongs.25m
From an empty folder to a running endpointGenerate TaskFlow, inspect the project skeleton, run the app, add a first REST endpoint, and verify the full generate-run-hit loop.35m
Controller -> Service -> Repository, wiredGrow TaskFlow into controller, service, repository, and model layers, with constructor injection wiring the app without manual new calls.40m
Real data with JPA, H2 & LombokReplace the in-memory repository with Spring Data JPA, inspect generated SQL with H2, use Lombok carefully, and switch H2 from memory to file persistence.45m
Proving it works: Mockito & slice testsTest service rules with Mockito and controller HTTP behavior with MockMvc, using modern @MockitoBean for Spring web-slice dependencies.40m
Logging: SLF4J, Logback & Log4jAdd useful logs to TaskFlow, understand facade vs engine, tune levels from config, and connect logging back to interface-driven design.25m
From requirements to a blueprintTurn plain-English specs into entities, operations, layers, abstractions, and a build order before opening the IDE.35m
Design in action: blueprint to working codeBuild SpendLog from blueprint to code, using an AlertService interface and multiple implementations to make interface-based design concrete.45m
API Boundaries: DTOs, Validation & ErrorsSeparate entity shape from API shape with request/response DTOs, reject invalid input with Bean Validation, and centralize error responses with @RestControllerAdvice.35m
Relationships & TransactionsGrow TaskFlow into users, projects, and tasks; map object references to foreign keys; add owner-scoped queries; and use @Transactional for real units of work.40m
Security: Spring Security & Basic AuthAdd a security filter chain, BCrypt password hashing, users, roles, Basic Auth, and authorization rules on top of the TaskFlow ownership model.45m
Stateless auth with JWTReplace Basic Auth with a learning-focused JWT flow: login issues a signed token, a request filter verifies it, and existing role rules keep working.45m
TaskFlow Integration SprintFading-scaffold practice on the existing TaskFlow project: clear checks first, then vaguer missions that force layer triage, recall, and independent implementation.60m
Build from scratchIndependent capstones with specs, acceptance checks, task breakdowns, and hidden guidance so the learner can transfer Spring Boot skills to new projects.90m

Spring Boot learning path

Foundation retrieval reviewAn attempt-first review of Spring Boot's purpose, dependency direction, HTTP flow, and first endpoint.20m
Core concepts retrieval reviewAn attempt-first review of layers, persistence, API boundaries, transactions, security, and tests.25m
Applied skills retrieval reviewAn attempt-first review of testing, observability, authentication, ownership, and a TaskFlow change.25m
Spring mock round 1 — core backend fundamentalsA 30-minute mock interview covering core Spring concepts, debugging, and an API design trade-off.2m
Spring mock round 2 — production trade-offsA 45-minute mock interview covering persistence, transactions, testing, security, and system trade-offs.2m