Master Spring and develop best-practice backends
Learn how to design end-to-end Java applications using the Spring framework and its essential gas pedal, Spring Boot. This training course is aimed at developers and architects who want to acquire operational mastery of the Spring ecosystem to build professional, robust and maintainable applications.
Through a progressive, hands-on approach, you'll explore the fundamentals of Spring Core (dependency injection, bean management, AOP), data access with JDBC and JPA, transaction management, creating high-performance REST APIs with Spring MVC, and developing server-side views.
You'll also discover how to exploit modern development and deployment tools: execution via Spring Boot, creation of OCI images, compatibility with virtual threads and exposure of testable and scalable services.
This course will give you a better understanding of the architectural choices made by Spring, and enable you to effectively integrate this framework into your current or future Java projects.
Is it for you ?
Developers and architects.
Prerequisites
This course requires a sound knowledge of the basics of Java programming (principles of object-oriented programming, generic types, annotations, lambda expressions) and experience of working with Eclipse or IntelliJ.
What You'll Walk Away With
- ✓ Design modular applications using Spring Core with dependency injection and configuration management
- ✓ Access and manage data with JDBC, JPA, and Spring Data following best practices
- ✓ Build robust REST APIs with Spring MVC, including validation, exception handling, and testing
- ✓ Implement advanced features (AOP, caching, scheduling, profiles) to enhance application quality
- ✓ Deploy and structure Spring Boot applications using scalable and maintainable n-tier architectures
Training content
1 Introduction
- Reminder of good design practices.
- Patterns at the heart of the Spring framework: singleton, prototype, strategy, proxy, factory.
- Essential Spring framework components: core, data access, webmvc.
- Relationship between Spring framework and Spring boot.
- The development environment.
- Deployment strategies: JAR, OCI image, native application.
2 Managing beans with Spring Core
- The ApplicationContext.
- Declaring a Spring bean.
- Profiles and the @Conditional annotation.
- Dependency injection.
- Accessing properties.
- Callbacks.
- Testing a Spring bean, coupling with Junit.
- Task scheduling.
- Bean supervision with JMX.
- Interceptors: cache, transaction, AOP.
- Automatic configuration.
Practical application: creating a n-tier application with Spring Core and Spring boot.
3 Data access and transaction management
- Reminders, best practices (non-blocking I/O, ACID principles, connection pool, CAP theorem).
- Spring's contribution: implementation of the unit-of-work pattern.
- Access to relational databases with JdbcClient.
- Coupling with Jakarta persistence API (JPA).
- Transactional demarcation with PlatformTransactionManager.
- Introduction to Spring Data.
Practical application: accessing relational database data with Spring, applying transactions.
4 REST API with Spring MVC
- Using the embedded web server.
- Enabling non-blocking I/O with virtual threads.
- Best practices for designing a REST API.
- Writing a controller.
- Validation.
- Exception handling.
- Testing a REST API with MockMVC.
Putting it into practice: developing an API exposing the business layer developed previously, consuming REST web services via an HTML/JavaScript frontend.
5 Server-side GUI with Spring MVC
- Views, the role of the template engine.
- The model.
- Exception handling.
- Validation.
- Message internationalization.
Practical application: create an MVC frontend to expose the business layer developed above.
📌 Practical information
Our training sessions are offered in Montreal or Quebec City, in person or in a virtual classroom. Dates and locations are specified when you select your session below. If you have any questions, check out our FAQ.
