Spring Boot

39 lessons · free to read

Build a real REST service: beans, config, controllers, JPA, tests and a runnable jar.

Take this course in the learning hub

Lessons

• What Spring Boot actually solvesKnow why Spring Boot exists and what it removes compared to plain Spring.
• Starters and the parent POMUnderstand how one starter dependency pulls a whole, version-aligned stack.
• Auto-configurationExplain how Boot configures beans from what is on the classpath, and how to override them.
• The IoC container and beansKnow what a bean is, who creates it, and the two ways to register one.
• Constructor injectionWire dependencies the way the Spring team recommends, and see why field injection loses.
• @Component, @Service, @RepositoryPick the right stereotype annotation and know which one adds real behaviour.
• application.yml and profilesExternalise settings, layer them per environment, and override anything at startup.
• Typed config with @ConfigurationPropertiesBind a group of YAML keys to a validated Java record instead of scattering @Value.
• Your first REST controllerMap HTTP verbs and paths to methods, and control status codes and response bodies.
• DTOs and request validationSeparate wire models from entities and reject bad input before it reaches your logic.
• Errors with @RestControllerAdviceTurn exceptions into consistent, standard JSON error responses in one place.
• Spring Data JPA repositoriesGet CRUD and derived queries for free, and know which JPA settings matter in production.
• Actuator and health checksExpose health, metrics and info endpoints safely, and wire them to Kubernetes probes.
• Testing: @SpringBootTest vs @WebMvcTestChoose the smallest context that proves your code works, and mock the rest.
• Packaging and running the jarBuild a self-contained executable jar, override settings at launch, and containerise it.
• How a request travels through Spring MVCFollow one HTTP request from the filter chain to your method and back out as JSON.
• JSON mapping with JacksonControl exactly what your API emits: dates, nulls, field names and secrets.
• Bean scopes and why state is a bugOne singleton serves every request thread, so a mutable field leaks data between users.
• Proxies: why self-invocation does nothingSee how @Transactional and @Cacheable are applied, and the call shape that silently skips them.
• Transactions with @TransactionalCommit several writes as one unit, and learn which exceptions actually roll back.
• Schema migrations with FlywayVersion the database in Git and stop letting ddl-auto edit production for you.
• Caching with @CacheableSkip expensive work with the cache abstraction, and evict entries before they go stale.
• Scheduled jobs and @Async methodsRun work on a timer or off the request thread, with pools you sized on purpose.
• Application events inside one serviceDecouple beans with published events, and fire side effects only after the commit.
• Calling another service with RestClientMake outbound HTTP calls with timeouts, status handling and a typed interface.
• Timeouts, retries and circuit breakersStop one failing dependency from taking your whole service down with it.
• Writing your own auto-configurationPackage shared setup as a starter so every service gets it by adding one dependency.
• What actually happens during context refreshThe twelve phases between SpringApplication.run and a context that is ready to serve.
• Why an auto-configuration did not fireRead the condition evaluation report instead of guessing which annotation is missing.
• Proxies: JDK, CGLIB, and what silently is not advisedWhy a final method loses its transaction and nothing warns you about it.
• Propagation, rollback rules and flush timingThe three transaction behaviours that surprise people in production.
• AOT processing and GraalVM native imagesWhat changes when the context is computed at build time instead of at startup.
• Virtual threads in a Spring Boot serviceWhen they help, when they pin, and what they do not fix.
• Metrics and tracing with the Observation APIOne instrumentation that produces a metric, a span and a log context together.
• Graceful shutdown and lifecycle orderingStop taking new work, finish what is in flight, then release resources - in that order.
• Property precedence and the Config Data APIWhich value actually wins, and where it came from.
• Measuring and cutting startup timeFind the slow beans instead of guessing, then decide what is safe to defer.
• Standard error responses with ProblemDetailRFC 7807, so every service in the estate returns errors in the same shape.
• Outbound HTTP: pools, timeouts and keep-aliveThe defaults that quietly cap your throughput or hang your threads.