Spring Framework 7 and Spring Boot 4 Basic to Advanced
Spring Framework 7 and Spring Boot 4 Basic to Advanced is a course in building web applications and APIs with current Spring on Java, from dependency injection, Spring Data JPA, Spring MVC with Thymeleaf, Spring Security and testing to RESTful APIs and Docker. It suits Java developers and teams maintaining older Spring systems that need upgrading.
- Duration30 hours · 5 days
- FormatOnsite / live online
- Next roundOn request
- CertificateIncluded
Course overview
Spring remains the main framework for enterprise Java systems, from web applications and back-office systems to APIs. Yet many examples still rely on Spring Framework 5 and Spring Boot 2, with javax packages, RestTemplate and configuration styles that have since changed. Teams starting a new project or upgrading an existing one need to understand both the core of Spring, such as dependency injection, and the current practice of Spring Boot 4 and Spring Framework 7.
This course takes learners from the basics to real-world use with Spring Boot 4.1, Spring Framework 7 and Java 25 LTS: IoC and dependency injection guided by SOLID, configuration and profiles, data access with Spring Data JPA and Hibernate with transactions and Flyway, and web applications with Spring MVC and Thymeleaf, including forms, validation and file upload. Learners secure the application with Spring Security, write tests with JUnit and Testcontainers, build RESTful APIs, call external APIs with RestClient, compare WebFlux with virtual threads, and ship with Docker and CI, finishing with a capstone project.
What you’ll gain
- Create Spring Boot 4 projects on Java 25 and understand what has changed since Spring 5
- Use IoC, dependency injection, configuration and profiles correctly, guided by SOLID
- Access data with Spring Data JPA and Hibernate, with transactions and Flyway
- Build web applications with Spring MVC and Thymeleaf, with forms, validation and exception handling
- Secure applications with Spring Security and write unit and integration tests
- Build and consume RESTful APIs with RestClient, and understand the WebFlux and virtual thread options
- Build Docker images and set up CI for a project
Who this course is for
- Java developers who want to start using Spring Boot in real work
- Developers maintaining Spring 5 or Spring Boot 2 systems who need to plan an upgrade
- Java EE or Jakarta EE developers who want to move to Spring
- Students and IT teams who want back-end skills in Java
Prerequisites
- Good Java and object-oriented programming skills, such as classes, interfaces and collections
- Basic HTML, CSS and JavaScript
- Basic database and SQL knowledge, for example MySQL, PostgreSQL, SQL Server or Oracle
- Some experience of servlets or Java web development helps but is not required
- A laptop that can run a JDK, Docker Desktop and an IDE, with permission to install software
Curriculum
Course Details
This course is the 2026 edition of Spring Framework Basic to Advanced, rewritten for Spring Boot 4.1, Spring Framework 7 and Java 25 LTS. It runs for 5 days, 6 hours per day (30 hours in total, 09:00-16:00), as lectures with labs on a single project that grows each day. Intermediate level. Day one covers the core of Spring, including dependency injection and configuration. Day two covers data access with Spring Data JPA and getting started with Spring
MVC. Day three covers a CRUD web application with security and tests. Day four covers building and consuming RESTful APIs and an introduction to WebFlux and virtual threads. Day five covers JWT-secured APIs, observability, Docker and CI, finishing with a capstone. The course uses Java, unlike RESTful API with Spring Boot and Kotlin, and does not cover microservices, which have their own course. Learners take home the source code for every lab and a checklist for upgrading existing Spring systems.
Day 1 The Core of Spring and Configuration
Section 1: Lab: Getting Started with Spring in 2026
- The Spring ecosystem: Framework, Boot, Data, Security, and what has changed since Spring 5
- Java 25 LTS, the Jakarta EE namespace and Jackson 3
- Creating a project from Spring Initializr with Maven or Gradle
- Project structure, starters, auto-configuration and DevTools
- Lab: a first web application with a controller and a Thymeleaf page
Section 2: Lab: IoC and Dependency Injection
- The IoC container, ApplicationContext and beans
- Constructor injection, and why field injection should be avoided
- @Component, @Service, @Repository and component scanning
- Choosing beans with @Qualifier and @Primary
- Lab: write code without Spring, then refactor it to dependency injection and compare
Section 3: Lab: SOLID, Configuration and the Bean Lifecycle
- The five SOLID principles and designing services in Spring
- @Configuration and @Bean in Java config, and reading XML config in legacy systems
- Bean scopes: singleton, prototype and request
- The bean lifecycle and start-up and shutdown callbacks
- Lab: switch the implementation of a notification service by environment
Section 4: Lab: External Configuration and Profiles
- application.properties versus application.yml
- Property precedence, environment variables and command-line arguments
- @ConfigurationProperties with Java records and validation
- Profiles for dev, test and prod, and keeping secrets safe
- Lab: make the application behave differently per profile without code changes
Day 2 Data Access and Getting Started with Spring MVC
Section 5: Lab: Spring Data JPA and Hibernate
- Entities, IDs and mapping one-to-many and many-to-many relationships
- Correct equals and hashCode for entities
- JpaRepository and basic CRUD
- Spring Boot Docker Compose support for running the database during development
- Lab: a book catalogue data model (Book, Author and Publisher) with starting data
Section 6: Lab: Queries, Pagination and Projections
- Derived query methods and @Query with JPQL
- Pagination and sorting with Pageable
- Projections with Java records to fetch only the data you need
- The N+1 query problem and fixing it with fetch joins and entity graphs
- Lab: a paged book search page without redundant queries
Section 7: Lab: Transactions and Database Migrations
- @Transactional, propagation and rollback rules
- Read-only transactions and common mistakes
- Managing the schema with Flyway instead of letting Hibernate create tables
- Configuring PostgreSQL or MySQL for each profile
- Lab: add columns and starting data with a Flyway migration
Section 8: Lab: Spring MVC and Thymeleaf
- DispatcherServlet, controllers, models and views
- @GetMapping, @PathVariable and @RequestParam
- Thymeleaf templates, layouts and fragments
- Using Bootstrap through WebJars and static resources
- Lab: book list and book detail pages
Day 3 CRUD Web Application, Security and Testing
Section 9: Lab: Forms, CRUD and Validation
- Handling form posts with command objects and DTOs
- Creating, updating and deleting data with redirect after save
- Bean Validation with @Valid, @NotBlank and custom constraints
- Showing error messages and supporting several languages with MessageSource
- Lab: forms for adding and editing books with their authors
Section 10: Lab: File Upload and Exception Handling
- Drop-downs from enums and reference data
- Uploading images with MultipartFile and limiting file size
- @ExceptionHandler, @ControllerAdvice and @ResponseStatus
- User-friendly 404 and 500 error pages
- Lab: upload book cover images and handle invalid IDs
Section 11: Lab: Spring Security
- SecurityFilterChain and configuring HttpSecurity
- Form login, logout and hashing passwords with a PasswordEncoder
- UserDetailsService with users from the database
- Role-based access at URL and method level, and CSRF protection
- Lab: a login system that separates regular users from administrators
Section 12: Lab: Testing Spring Applications
- Unit tests with JUnit and Mockito
- @WebMvcTest with MockMvc and MockMvcTester
- @DataJpaTest for testing repositories
- Integration tests against a real database with Testcontainers and @ServiceConnection
- Lab: tests for the book catalogue's controllers, services and repositories
Day 4 RESTful APIs and Calling External Services
Section 13: Lab: RESTful Web Services with Spring MVC
- REST principles and the Richardson Maturity Model
- @RestController with GET, POST, PUT, PATCH and DELETE
- DTOs as Java records and mapping them to entities
- ResponseEntity, status codes and testing with Postman or Bruno
- Lab: a customer and product category API covering every method
Section 14: Lab: Error Responses, API Versioning and API Documentation
- Standard error responses with ProblemDetail following RFC 9457
- @RestControllerAdvice for central API error handling
- API versioning with the new Spring Framework 7 support
- OpenAPI documentation and Swagger UI with springdoc-openapi
- Lab: add version 2 of an API without affecting existing clients
Section 15: Lab: Calling External APIs with RestClient
- RestClient in place of the deprecated RestTemplate
- HTTP service clients with interfaces and @HttpExchange
- Handling timeouts, errors and retries
- Migrating existing RestTemplate code step by step
- Lab: enrich product data from an external API
Section 16: Reactive and Virtual Threads
- An overview of reactive programming, Mono and Flux
- Which workloads suit Spring WebFlux and WebClient
- Virtual threads with spring.threads.virtual.enabled on Java 21 and later
- Choosing between Spring MVC, virtual threads and WebFlux
- Lab: measure many concurrent API calls the traditional way against virtual threads
Day 5 API Security, Production Readiness and Capstone
Section 17: Lab: Securing APIs with JWT
- Sessions versus tokens, and when to use each
- OAuth2 Resource Server and validating JWTs
- Authorisation by scope and role
- CORS and separate security filter chains for web pages and APIs
- Lab: issue tokens and protect administrator endpoints
Section 18: Lab: Actuator, Observability and Logging
- Spring Boot Actuator: health, info and metrics
- Micrometer and sending metrics to a monitoring system
- Structured logging in JSON format
- Securing endpoints before going to production
- Lab: a health check and a metrics dashboard for the application
Section 19: Lab: Build, Docker and CI
- Executable JARs and JVM settings
- Building Docker images with Buildpacks or a Dockerfile
- An overview of GraalVM native images and the trade-offs
- CI with GitHub Actions: build, test and create the image
- Lab: a pipeline that runs the tests on every push and produces a deployable image
Section 20: Workshop: Capstone Web Application and API
- Choosing a brief, such as a meeting room booking or inventory system
- Designing entities, services, web pages and the API
- Completing JPA, validation, security and tests
- Building a Docker image and running it with docker-compose
- Presenting the result, reviewing code together and planning the upgrade of existing Spring systems
Schedule & training options
For individuals — public rounds
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
For organisations — in-house / private
- Tailor the content to your team’s tools and projects
- Your dates, at your office or live online
- Quotation with tax ID for procurement
Instructors
Frequently asked questions
What is dependency injection in Spring?
Dependency injection means the Spring container creates objects (beans) and supplies the dependencies a class needs, instead of the class creating them itself with new. Classes depend on interfaces rather than concrete classes, so you can swap implementations and unit test with mocks easily. Constructor injection is the recommended style, and in current Spring a single constructor needs no @Autowired. @Qualifier and @Primary choose between several beans of the same type.
How do you start building a web application with Spring Boot?
Start at Spring Initializr (start.spring.io) and choose Maven or Gradle and a Java version; Spring Boot 4 needs Java 17 or later, and the latest LTS is recommended. Add the dependencies you need, such as Spring Web, Spring Data JPA, Thymeleaf and a database driver. Open the project in an IDE such as IntelliJ IDEA or VS Code, create entities and repositories, write controllers that handle requests and pass data to templates, then run the main class annotated with @SpringBootApplication, which includes an embedded web server.
What are the SOLID principles of object-oriented design?
SOLID is five object-oriented design principles: Single Responsibility, one class has one job; Open/Closed, extend behaviour without changing existing code; Liskov Substitution, a subclass must be usable wherever its parent is; Interface Segregation, keep interfaces small and focused; and Dependency Inversion, depend on abstractions rather than concrete classes, which is the idea behind Spring's dependency injection.
Who is the Spring Framework 7 and Spring Boot 4 Basic to Advanced course for, and what should I know beforehand?
It suits Java developers who want to use Spring Boot in real work, teams running Spring 5 or Spring Boot 2 who need to plan an upgrade, and Jakarta EE developers moving to Spring. You should have good Java and object-oriented skills, basic HTML, CSS, JavaScript and SQL, and a laptop that can run a JDK, Docker Desktop and an IDE. Servlet experience helps but is not required.
What will I be able to do after the Spring Framework 7 and Spring Boot 4 Basic to Advanced course?
You will be able to create Spring Boot 4 projects on Java 25, use dependency injection, configuration and profiles correctly, access data with Spring Data JPA, transactions and Flyway, build web applications with Spring MVC and Thymeleaf, secure them with Spring Security, test with JUnit and Testcontainers, build and consume RESTful APIs with RestClient, produce Docker images with CI, and plan the upgrade of existing Spring systems. Participants receive a Certificate of Completion.
Can the Spring Framework 7 and Spring Boot 4 Basic to Advanced course be run in-house for our team?
Yes. It can be run in-house for your team, with examples adapted to your own work, such as practising an upgrade of the older Spring code the team runs or using a capstone brief based on a real system. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.