Spring 5 Essentials-Core Spring and Spring Boot

Live Classroom
Duration: 5 days
Live Virtual Classroom
Duration: 5 days
Pattern figure


During this three day course, participants explore the basic Spring framework, discovering concepts such as Inversion of Control, Dependency Injection and also work with containers and basic components. The course examines the improved Spring 5.x configuration management options such as XML, annotations, JavaConfig and Spring expression language. The course discusses areas of persistence and transactions, and the development of tests using JUnit 5 (Jupiter), accessing data using JDBC, Hibernate and the use of Spring Data. The course also explores Spring Boot briefly to help participants understand the configuration of Spring based applications in today’s microservices world.

What You'll Learn

  • Explain the issues associated with complex frameworks such as JEE and how Spring addresses those issues
  • Understand the relationships between Spring and JEE, AOP, IOC, JDBC, Hibernate, JSF, Struts, JMS, and EJBs.
  • Write applications that take advantage of the Spring container and the declarative nature of assembling simple components into applications.
  • Understand how to configure the framework with XML, annotations and JavaConfig as well as explore the advantages of each option.
  • Understand and work on integrating persistence into a Spring application.
  • Explain Spring’s support for transactions and caching
  • Developing unit and integration tests using the Spring TestContext Framework
  • Learn the various API’s for the development of data-access components
  • Apply the Spring-Data framework to simplify the implementation of the data access layers
  • Configure a ‘simple’ Spring based application using Spring Boot


  • Understand the value of Spring
  • Explore Dependency Injection (DI) and Inversion of Control (IoC)
  • Configuring collaborators
  • Understand built-in property editors

  • Discover the Spring Container
  • Introduce the various ways to configure the Spring context
  • Initialize the Spring container
  • Accessing beans in the Spring container
  • Configure beans using XML
  • Resolving bean dependencies using XML

  • Use Spring’s special factory beans
  • Re-use bean definitions in the configuration file using the “parent” bean concept
  • Use property placeholders in the configuration file
  • Create custom property editors
  • Become familiar with container post-processors

  • Introduce Spring annotation for defining dependencies
  • The @Autowired annotation
  • Stereotyping Annotations
  • Enabling and filtering the component scan
  • Qualifying injection points
  • Lifecycle annotations
  • The @Value annotation

  • Introduce Java-based configuration
  • The @Configuration and @Bean annotations
  • Define bean dependencies
  • Define bean scopes
  • Bootstrapping Java Config context
  • Injection in Configuration classes

  • Registering BeanFactoryPostProcessor
  • The Environment API
  • Using context Profiles
  • Conditionally loading beans and configurations
  • Using properties in Java based configuration
  • The DependsOn and Lazy annotations

  • Introduce the Spring Expression Language
  • SpEL literals and operations
  • Accessing bean properties
  • Read property values

  • Introduce ApplicationContext events
  • Creating Event listeners
  • Defining and publishing events
  • The @EventListener annotation
  • Asynchronous method invocations
  • Defining the Executor

  • Schedule tasks within Spring context
  • The @Scheduled annotation
  • Programmatically define tasks
  • Introduce the @Enable… annotations
  • Conditionally import configurations
  • The ImportSelector interface
  • The ImportBeanDefinitionRegistrar interface

  • Spring on the Module path
  • ‘Classpath’ scanning in Java 9

  • Unit testing using Mock objects
  • Unit testing supporting classes
  • Overview of Integration Testing
  • Managing the context in tests
  • Supporting JDBC tests
  • Test Annotations (@BootstrapWith, @ContextConfiguration, etc.)
  • JUnit 5 test cases

  • Setup a project using Spring Boot
  • ‘Setup’ a simple DataSource
  • Use the Java Persistence API to persist entity state
  • ‘Define’ the dependencies
  • The Spring initializer
  • Configuration by Exception

  • Overview of DAO Implementations
  • Programmatic Transaction Support
  • Declarative Transaction Support
  • The @Transactional annotation
  • Transaction Propagation

  • JdbcDaoSupport – JDBC DAO Implementation
  • The jdbcTemplate
  • Exception Handling
  • Operation Classes

  • Introduce Spring Data
  • Configuring Spring Data
  • Handling transactions

  • Defining CRUD operations for an entity
  • Introduce Query methods
  • The @Query annotation
  • Named Queries
Ripple wave

Who should attend

The course is highly recommended for –
  • Java Spring Boot developers
  • Java developers
  • Microservices engineers
  • Full stack developers
  • Back-end developers
  • Software developers
  • Application developers
  • Software engineers


Participants need to have practical basic Java development experience.

Interested in this Course?

    Ready to recode your DNA for GenAI?
    Discover how Cognixia can help.

    Get in Touch
    Pattern figure
    Ripple wave