Spring Boot Tutorial
46 tutorials · 9 modules · learn them in order
Learning path9
01Set Up Java Properly: JDK, Environment Variables, and Your First Program02IoC and DI Explained: What Exactly Gets Inverted03AOP in Principle: Cross-Cutting Concerns and Proxies04Your First Spring Boot App: Hello World in Three Minutes05DispatcherServlet Internals: A Request's Full Journey06From Raw JDBC to JdbcTemplate: The Evolution of Data Access07Unit Testing: JUnit 5 and Mockito08Spring Security Internals: Filter Chain, Authentication, Authorization09Capstone 1: Requirements and Architecture
Install the JDK, configure Maven and write your first Spring program on solid ground.
01Set Up Java Properly: JDK, Environment Variables, and Your First ProgramHow JDK, JRE and JVM really relate, installation on all three platforms, what JAVA_HOME and PATH actually do, running multiple JDK versions, and the six traps almost every beginner hits.Beginner25′02Maven from Scratch: Coordinates, Dependency Mediation and Build LifecyclesMirrors via settings.xml, GAV coordinates and repositories, dependency scopes and mediation, the three build lifecycles and multi-module builds — every core Maven concept in one pass.Beginner46′03IntelliJ IDEA in Practice: Your First Java Project, Compile and RunFrom installing IDEA to running your first project: layout, SDK setup, breakpoints, Maven sync and six beginner traps handled in one pass.Beginner30′04What Spring Really Is: From the Pain of EJB to the Birth of IoCWhy does a 2003 framework still rule Java? From the lessons of EJB to an intuitive explanation of IoC, the Spring family map, and the real difference between Spring and Spring Boot.Beginner34′05Your First Spring Application: XML and Annotation WiringWithout Spring Boot: assemble a container with Maven and spring-context — XML bean declarations, annotation scanning, constructor and setter injection, scopes, and a clear comparison of both styles.Intermediate34′
BeanDefinition, the twelve steps of refresh(), bean lifecycle and the three-level cache — the IoC container taken apart.
01IoC and DI Explained: What Exactly Gets InvertedStarting from order code that explodes on every change: the three readings of IoC, three injection styles, DIP and the Hollywood Principle — the cornerstone for everything else in the kernel.Intermediate38′02BeanDefinition in Detail: The Registry Behind Every BeanA container manages definitions, not objects. Walk every core field of BeanDefinition, its three registration sources, parent merging and the exact moment post-processors rewrite it.Intermediate40′03The Boot Kernel: All Twelve Steps of refresh()Behind one line — new AnnotationConfigApplicationContext() — sit twelve precise steps. Walk every step of refresh(), its extension points and its source locations to see what really happens at startup.Advanced34′04The Complete Bean Lifecycle: From Instantiation to DestructionA bean passes eight phases and five callback types from birth to death. Each phase comes with source order and runnable verification — plus the classic question: at which step is the AOP proxy created?Advanced47′05Circular Dependencies and the Three-Level CacheA needs B and B needs A — why is Spring calm? The lookup order of the three caches, how early references get promoted, and the classic question of why three levels instead of two.Advanced44′
Proxy patterns, JDK vs CGLIB, and @AspectJ in full — see through Spring's cross-cutting magic.
01AOP in Principle: Cross-Cutting Concerns and ProxiesLogging, transactions and permission checks on every method — how does that repetition get extracted? From cross-cutting concerns to proxies, every AOP term explained with one diagram and one animation.Intermediate32′02Dynamic Proxies: JDK Proxy vs CGLIBWrite a JDK dynamic proxy by hand, dissect a CGLIB bytecode subclass, and settle performance, limitations and how Spring picks between them.Advanced42′03@AspectJ in Full: Pointcut Expressions and Five Advice TypesHow to write execution pointcuts, the order of five advice types, argument binding, and how multiple aspects queue up — every trap in aspect development, covered.Intermediate42′04Inside Spring AOP: The Auto-Proxy CreatorWhy does @Aspect just work? The answer hides in AnnotationAwareAspectJAutoProxyCreator — how it finds aspects, filters advisors, and picks a proxy factory, plus a complete self-check for dead aspects.Advanced48′05Four AOP Recipes: Logging, Permissions, Rate Limiting, CachingFour copy-ready aspects: annotation-driven audit logging, permission checks, a simple token-bucket limiter and caching — each with full code and the traps involved.Intermediate68′
The combined annotations, auto-configuration loading, conditional wiring and custom starters — how Boot just works.
01Your First Spring Boot App: Hello World in Three MinutesFrom start.spring.io to your first browser refresh: how the project is built, what every line of the main class means, where embedded Tomcat comes from and why web.xml is gone.Beginner47′02@SpringBootApplication: One Annotation, Three MeaningsOne annotation, three jobs: @SpringBootConfiguration, @EnableAutoConfiguration and @ComponentScan. Unpack each layer, plus scan boundaries, exclusions and where to put the main class.Intermediate52′03Auto-Configuration Internals: From spring.factories to AutoConfiguration.importsWhy does adding a starter hand you a DataSource and a transaction manager? Unpack the loading pipeline of AutoConfigurationImportSelector, the ordering of @AutoConfiguration and the condition toolbox.Advanced50′04Conditional Wiring in Full: Ten Questions About @ConditionalThe real brain behind auto-configuration is conditional wiring. From the @Conditional meta-annotation to the whole OnClass/OnMissingBean/OnProperty family, with evaluation order and debugging.Intermediate44′05Build Your Own Starter: From Zero to Auto-LoadedHow many modules and annotations does a real starter need? Build an SMS starter end to end: auto-configuration, conditions, configuration properties, the imports file and verification.Advanced54′06Configuration in Full: Properties, YAML, Binding and ProfilesConfig file precedence, loose binding and validation in @ConfigurationProperties, profile switching, encryption and externalization — every configuration question answered.Intermediate44′
A full request journey through DispatcherServlet, argument binding, RESTful conventions, validation and global exceptions.
01DispatcherServlet Internals: A Request's Full JourneyNine components relay one request: handler mapping, adapter invocation, argument resolution, return handling and message conversion — every step runnable in the WASM kernel.Advanced52′02Controller Details: Argument Binding, Return Values and ConversionHow many parameter styles can one handler method take? Where does data come from, how is it converted and validated? The full playground of controller inputs and outputs.Intermediate50′03RESTful API Design and a Unified Response EnvelopeWhat actually counts as RESTful? URL design, status-code semantics, idempotency and versioning — plus a production-grade response envelope and business exception system.Intermediate51′04Validation and a Global Exception StrategyFrom the JSR-303 annotation family to validation groups and custom validators, plus a @RestControllerAdvice safety net that kills "validation failed with 500".Intermediate63′05Filters, Interceptors and AOP: Order and PracticeThree mechanisms can all "intercept a request" — which one? From Tomcat's Filter to MVC's HandlerInterceptor to method-level AOP, one sequence diagram and a real login interceptor settle it.Intermediate61′
JDBC evolution, connection pools, MyBatis, JPA, transaction propagation and Redis caching.
01From Raw JDBC to JdbcTemplate: The Evolution of Data AccessStart from suffocating raw JDBC, refactor step by step to JdbcTemplate, and settle three fundamentals: SQL injection, resource leaks and exception translation.Intermediate63′02DataSource and HikariCP: Pool Internals and TuningWhy not open a connection per request? Why is HikariCP so fast? And how big should the pool be — pool internals, a parameter table and monitoring, turned into a tunable craft.Advanced42′03MyBatis in Practice: Mappers, Dynamic SQL and PagingStarting with mybatis-spring-boot-starter: the safety line between #{} and ${}, the dynamic SQL tag family, joins and paging — with both XML and annotation styles ready to copy.Intermediate63′04Spring Data JPA in Full: Repository Abstraction and JPQLThe persistence context and the four entity states, dirty checking and the flush moment, derived queries, @Query and JPQL, paging and dynamic criteria, N+1 and lazy loading, auditing and optimistic locking.Intermediate92′05Transactions Internals: How @Transactional Works and PropagatesWhy does one annotation commit or roll back for you? Proxy interception, connection binding to ThreadLocal, all seven propagation behaviors, dead-annotation scenarios and a peek at distributed transactions.Advanced51′06Redis and Spring Cache: The Caching Abstraction in PracticeFrom penetration, breakdown and avalanche to a complete Spring Cache + Redis setup: key design, serialization, expiry and the consistency trade-off.Intermediate56′
JUnit 5, integration testing, logging, the secrets of packaging and Docker deployment.
01Unit Testing: JUnit 5 and MockitoWhy tests feel like a burden, then JUnit 5 assertions, @Mock/@InjectMocks stubbing, parameterized tests and naming — with a runnable service-layer test suite.Intermediate56′02Integration Testing: @SpringBootTest and Slice TestsWhen do you need a real container? The four webEnvironment modes, @WebMvcTest/@DataJpaTest slices, MockMvc end-to-end assertions and Testcontainers for a real database.Intermediate50′03Logging: The SLF4J Facade and Logback in PracticeWhy facades matter, how to use levels, how to write logback-spring.xml, and how MDC carries a traceId across a request — turning logging from println into a searchable engineering capability.Intermediate61′04Packaging and Running: Fat Jars and Graceful ShutdownWhy does one jar run standalone? Open up the fat jar, meet LaunchedURLClassLoader, then add startup flags, graceful shutdown and a systemd unit.Intermediate33′05Docker Deployment: Image Layers and ComposeWrite a production-grade Dockerfile: multi-stage builds, slim images, layer caching — then bring up app + MySQL + Redis with a single Compose file.Intermediate72′
The Security filter chain, JWT/OAuth2, async pools, event-driven design and Actuator monitoring.
01Spring Security Internals: Filter Chain, Authentication, AuthorizationFifteen filters form one security chain where authentication and authorization each do their job — from FilterChainProxy down to SecurityFilterChain config, and why your API suddenly returns 401/403.Advanced36′02JWT and OAuth2: Stateless Authentication in PracticeOpen up JWT's three segments, sign and verify by hand, design dual-token refresh, then walk the OAuth2 authorization-code flow — the standard auth stack for SPA + API.Intermediate55′03Async Tasks, Thread Pools and SchedulingWhy is @Async bad by default? Custom executors, rejection policies, context propagation, graceful shutdown — then @Scheduled's three modes and duplicate execution in a cluster.Intermediate62′04Event-Driven Design: ApplicationEvent and Message QueuesFrom Spring built-in events to transactional and async listeners, then the RabbitMQ vs Kafka trade-off and reliable delivery with a local message table.Advanced80′05Actuator and Observability: Health, Metrics and MonitoringAfter enabling Actuator: custom health checks, exposing metrics to Prometheus, changing log levels at runtime and custom endpoints — making "what is happening in production" answerable.Intermediate60′
From requirements to CI/CD — independently deliver an advanced Spring Boot project.
01Capstone 1: Requirements and ArchitectureBeeOrder begins: turn vague requirements into user stories and acceptance criteria, then fix the domain model, module boundaries, technology choices and project layout.Advanced49′02Capstone 2: Data Modeling and API ContractsTurn the domain model into schema: full DDL, indexes and constraints, with reasons for every type choice; then turn the API list into contracts with DTO/VO layering, a response envelope, error codes, idempotency and paging.Advanced72′03Capstone 3: The Core Business (Transactions, Inventory, Idempotency)The full order flow: inventory check and deduction, order persistence, transaction boundaries, idempotency keys and optimistic locking against oversell, payment callbacks and timeout closing.Advanced70′04Capstone 4: Testing, CI/CD and Going LiveComplete quality and delivery for BeeOrder: a layered test strategy, a GitHub Actions pipeline, production Compose, graceful shutdown and probes, an Nginx reverse proxy, a go-live checklist and a load-testing primer.Advanced102′