About the course
The Spring Framework is the leading platform for building enterprise-level Java applications, offering a flexible and comprehensive model that simplifies complex development. This 5-day intensive, hands-on training course provides a deep dive into Spring Framework 6, the latest major version built on Java 17+ and Jakarta EE 9/10+.
You'll gain a thorough understanding of core Spring principles, including the Spring Container, Dependency Injection (DI) with modern JavaConfig and Annotations, and the Bean Lifecycle. The course covers essential features like Spring Expression Language (SpEL), Validation, and Externalising Properties, alongside robust Spring Test support with JUnit 5.x.
Furthermore, we'll explore key enterprise capabilities: simplified data access with Spring Data (JDBC, JPA/Hibernate), messaging with Spring JMS, comprehensive Spring Transaction Management, and powerful cross-cutting concern handling with Spring AOP. You'll also master web development using Spring Web MVC, building and consuming RESTful Services with modern clients. This course provides a foundational understanding of the Spring Framework's capabilities, essential for any modern Java enterprise development.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain the motivation and purpose of the modern Spring Framework (Spring 6) and understand its core components and advantages in enterprise Java development.
- Understand the fundamental concepts of Spring Beans and the Spring Container, and configure beans using modern approaches (Annotations, JavaConfig).
- Master Dependency Injection (DI) and wire beans together effectively using modern configuration styles.
- Understand the Spring Bean Lifecycle, utilise Spring Expression Language (SpEL) and Validation, and work with the Spring Environment and Profiles for application adaptability.
- Utilise Spring's support for Data Access, including JDBC Templates and DAO patterns, and integrate with ORM technologies.
- Integrate messaging capabilities into applications using Spring JMS.
- Understand and implement Aspect-Oriented Programming (AOP) using Spring AOP.
- Implement and manage Transactions using Spring's declarative and programmatic transaction management capabilities.
- Build web applications using Spring Web MVC.
- Develop RESTful Services using Spring and understand modern approaches to consuming REST services (RestClient/WebClient).
- Effectively test Spring applications using the Spring Test framework and JUnit 5.x.
- Understand concepts like Bean Factories and externalizing configuration properties.
-
This 5-day intensive hands-on training course is designed for Java software developers who want to gain a deep understanding of the Spring Framework, particularly using modern Spring 6 practices. It is ideal for:
Java Developers new to the Spring Framework who want to learn its core principles and capabilities using current standards, starting with a Java 17+ baseline.
Developers working on existing applications built directly on the Spring Framework (without Spring Boot) who need to understand its architecture and modules and potentially modernise them using Spring 6.
Architects needing a thorough understanding of the foundational Spring Framework concepts that underpin the entire Spring ecosystem, including Spring Boot.
Developers who prefer to understand the details of how Spring handles various concerns before or alongside using Spring Boot.
-
Participants should have attended our Java programming training course or have equivalent experience:
Experience developing applications using the Java programming language is essential. Familiarity with Java 17 or later is required for Spring Framework 6.
A basic understanding of web development concepts (HTTP, MVC, REST), database concepts (SQL, ORM basics), and messaging concepts is beneficial.
-
This Spring Framework course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Spring Framework Introduction
Motivation behind Spring and its role in enterprise Java development.
What is Spring and the concept of The Spring Framework.
An overview of The Spring Core module.
Where you can effectively use Spring in application development.
Why use Spring: Benefits and advantages.
Why not use Spring: Considerations and alternatives (briefly).
Spring Framework 6: Key features and Java 17+ / Jakarta EE baseline.
Spring Beans
Introduction to Spring Beans as the fundamental building blocks of a Spring application.
Understanding the Spring Container: Exploring the roles of BeanFactory and ApplicationContext.
Creating a Simple Spring Application using modern configuration.
Understanding what happens in a Spring application's startup and execution flow.
Spring Configuration
Approaches to Bean configurations: Focusing on modern practices.
Using Spring Annotations for configuration (@Component, @Configuration, @Bean, etc.).
The Java Config approach for defining beans programmatically using @Configuration classes.
The Lambda approach for defining beans using Java 8+ lambdas within @Configuration classes.
Understanding Bean Scoping (singleton, prototype, web scopes).
Mixing XML and annotations (Brief introduction for understanding existing codebases, noting modern preference for JavaConfig/Annotations).
Lab: Configuring Spring Beans using Annotations and JavaConfig.
Dependency Injection (DI)
Understanding the concepts of Inversion of Control (IoC) and Dependency Injection (DI).
Spring Dependency Injection mechanisms (Constructor, Setter, Field Injection).
Wiring Beans together using Annotations (@Autowired, @Inject).
Wiring Beans together using JavaConfig methods.
Wiring Collections (lists, sets, maps) using configuration.
Autowiring considerations.
Lab: Implementing Dependency Injection using Annotations and JavaConfig.
Bean Lifecycle and Core Features
Look at the Spring Bean Lifecycle in detail.
Explore lifecycle interfaces (InitializingBean, DisposableBean) and annotations (@PostConstruct, @PreDestroy).
Understand PostProcessors (BeanPostProcessor, BeanFactoryPostProcessor).
Defining POJO init and destroy methods.
Introduce Spring Expression Language (SpEL) and its usage in Spring configuration and annotations.
Spring Validation support using Bean Validation (JSR 380) and integration with Spring.
Externalizing configuration properties using Property files and the @Value annotation.
Spring Environment and Profiles
Introduce the need for different Environments (dev, test, prod) in applications.
Understanding the Spring Environment abstraction.
Working with Spring Profiles for environment-specific configurations using annotations (@Profile).
Defining profiles in JavaConfig.
Setting the active Profile.
Using Multiple active Profiles.
Defining a Default Profile.
Lab: Configuring and using Spring Profiles and externalized properties.
Spring Data
Introduction to Spring Data project and its goal of simplifying data access.
Data Access Objects (DAO) concepts and the Spring DAO support.
Spring and JDBC: Working with databases using JDBC Templates.
Using Spring JDBC Templates for streamlined JDBC operations.
Spring DAO Exception Hierarchy.
Using Object Mappers for mapping between JDBC results and Java objects.
Integrating with ORM technologies like JPA/Hibernate using Spring Data JPA (overview of repository pattern).
Lab: Implementing data access using Spring JDBC Template or Spring Data JPA.
Spring JMS
Basic idea of message queues and messaging patterns (point-to-point, publish and subscribe).
Integrating a message server (e.g., ActiveMQ, RabbitMQ) with Spring Framework.
JMS (Java Message Service) API overview and Spring's JMS support.
Spring JMS Development: Sending and receiving messages.
Using a Spring POJO bean as a message consumer.
Lab: Implementing basic messaging with Spring JMS.
Spring Transaction Management
Introduction to Spring Transaction management and its benefits.
Understanding Declarative Transaction Management using the @Transactional annotation.
Transaction Managers in Spring.
Transaction Propagation levels.
Isolation levels.
Spring configuration for Declarative Transaction Management (Annotations and JavaConfig).
Programmatically controlling a Transaction using PlatformTransactionManager or TransactionTemplate.
Lab: Implementing and configuring declarative transaction management.
Spring AOP
Motivation for Aspect Oriented Programming (AOP) and addressing cross-cutting concerns.
AOP in general: Concepts (Aspects, Join Points, Advice, Pointcuts, Weaving).
Spring AOP: Proxy-based AOP.
Spring AOP Terminology revisited.
Building in AOP interceptors.
Creating your own Aspect using Spring AOP (focus on AspectJ annotation style).
Applying a custom aspect in an application.
Lab: Implementing a simple Aspect using Spring AOP annotations.
Spring Web MVC
Introduce Spring Web MVC framework for building web applications.
Present the flow through the MVC architecture.
Creating a simple Web MVC application using modern configuration.
Defining a Controller and handling requests using annotations (@Controller, @RequestMapping).
Handling view resolution.
Building and Deploying MVC applications.
Java Config for Web MVC configuration (configuring DispatcherServlet via code using AbstractAnnotationConfigDispatcherServletInitializer).
Lab: Building a basic Spring Web MVC application using JavaConfig.
Spring Rest
Introduction to Web Services and What is REST.
Spring REST support for building RESTful services using @RestController.
Building a Spring REST application.
Lab: Building a simple RESTful service with Spring Framework 6.
Spring Rest Client
Introduce Spring REST Clients: Consuming external REST services.
Focus on modern clients in Spring Framework 6:
RestClient: The modern blocking client (introduced in Spring 6.1).
WebClient: The modern non-blocking/reactive client (introduced in Spring 5).
Note: RestTemplate is in maintenance mode and should be avoided in new development.
Configuration for modern REST clients with JavaConfig.
Lab: Consuming an external REST service using RestClient or WebClient.
Spring Test
Introduce Testing with Spring and the benefits of Spring's test support.
Highlight Test Support in Spring Framework 6.
Using JUnit 5.x as the primary testing framework.
Integration of Spring and JUnit 5 using @ExtendWith(SpringExtension.class).
Lab: Writing unit and integration tests for Spring components using Spring Test and JUnit 5.
-
Spring Framework Documentation: The official documentation for the Spring Framework. Ensure you are viewing the documentation for the current stable version (Spring 6+).
Spring Data Documentation: The official documentation for the Spring Data project (relevant modules like JPA, JDBC).
Spring Transaction Management Documentation: Part of the Spring Framework documentation.
Spring AOP Documentation: Part of the Spring Framework documentation.
Spring JMS Documentation: Part of the Spring Framework documentation.
Spring Web MVC Documentation: Part of the Spring Framework documentation.
Spring RestClient Documentation: Official documentation for the modern blocking HTTP client.
Spring WebClient Documentation: Official documentation for the modern non-blocking/reactive HTTP client.
Spring Test Documentation: Part of the Spring Framework documentation.
JUnit 5 Documentation: Official documentation for the JUnit 5 testing framework.
Trusted by
