What you'll learn

Learn enough about one of the three pillars of the Spring framework - dependency injection.
Understand how a Spring application context can be configured and used.
Deep dive into the managed beans lifecycle.
Deep dive into the configuration of the managed beans.
Learn what is a proxy and which are the two techniques by which the Spring framework creates automatically proxies.
Get a solid foundation for continuing with the next Spring pillar - AOP.

Course content

6 sections • 37 lectures • 5h 35m total length

Introduction2:37
Contains a small description of the course and few recommendations about the incoming lectures.

Goal of the section1:11
Summary of the goal of this section.
DI with Google Guice6:09
In this lecture:
introduction to the Google Guice library - yet another powerful DI library
DI with Spring and XML configuration (1)7:07
In this lecture:
introduction of the application context
XML configuration of the application context (part 1)
DI with Spring and XML configuration (2)4:01
In this lecture:
introduction of the application context
XML configuration of the application context (part 2)
initial peek at the bean lifecycle
DI with Spring and Annotation based configuration (1)7:54
In this lecture:
enabling the annotation based configuration
initial peek at the bean post processors
introduction to several annotations - @Autowired, @Qualifier
DI with Spring and Annotation based configuration (2)8:30
In this lecture:
injecting list of dependencies with the same type
initial peek at JSR250
introducing several more annotations - @PostConstruct, @Value, @Configuration
externalising configurations
DI with Spring and Java based configuration7:00
In this lecture:
removal of the XML configurations
elaboration on the @Configuration annotation
introduction of the @Bean annotation
Classpath scanning3:00
In this lecture:
introduction of the component scan feature
introduction to the @ComponentScan annotation
DI with Spring and stereotype annotations10:17
In this lecture:
introduction to the stereotype annotations - @Repository, @Service, @Component, etc.
JSR-250 and JSR-33020:08
In this lecture:
what is a JSR?
introduction to JSR-250
introduction to JSR-330
how does the Spring framework supports these JSR-s?
XML vs annotation-based vs Java-based configuration7:19
In this lecture:
comparison between XML, annotation based an Java based configurations
pros
cons
DI in Spring - the basics
Assignment - refactoring a messy application9:05
In this lecture:
setting a final assignment for this section
solving of this assignment will confirm your understanding of the topics discussed up to now
Assignment - solution28:45
In this lecture:
a sample solution of the final assignment for this section.
Assignment - testing the solution34:11
In this lecture:
adding test cases for the sample solution

Goal of the section2:59
Summary of the goal of this section.
The lifecycle of a bean, init and destroy methods6:43
In this lecture:
introduction to the bean lifecycle
defining initialisation methods (@PostConstruct and InitializingBean)
defining destroy methods (@PreDestroy and DisposableBean)
The lifecycle of a bean, the "aware" interfaces6:58
In this lecture:
introduction of the "aware" interfaces - making our beans aware of their spring environment
the place of the "aware" interfaces in the lifecycle of the bean
BeanNameAware, ResourceLoaderAware, etc.
Customising the bean lifecycle - the BeanPostProcessor9:22
In this lecture:
introduction of the BeanPostProcessor
primer - wraping a bean into a proxy
Lifecycle events
Bean scopes - singleton and prototype12:08
In this lecture:
what is a bean scope
singleton beans
prototype beans
controlling the bean scope
Bean scopes - custom scopes15:38
In this lecture:
custom scopes
example with thread scope
Mixing bean scopes8:02
In this lecture:
mixing of bean scopes
singleton and prototype
prototype and singleton
Bean scopes
Lazy beans5:25
In this lecture:
eager beans
lazy beans
controlling the eagerness of a bean
The order of the beans9:12
In this lecture:
dependency between the beans (@DependsOn)
controlling the injection order of the beans
@Order and Ordered
Optional dependencies11:02
In this lecture:
what happens when we have no implementation for an injected interface
making a bean optional (injecting nulls)
support for the Optional class
Circular dependencies8:35
In this lecture:
introduction to circular dependencies
resolving circular dependencies
using @Lazy
using setter injection
circular dependencies are often a code smell
Miscellaneous bean challanges
Bean definitions9:35
In this lecture:
how does the ApplicationContext store bean definitions
introduction of the BeanDefinition
example - manual registration of a bean in a bean registry
Application context and events11:22
In this lecture:
ApplicationContext-s and events
creating custom events
ApplicationEvent and ApplicationEventPublisher
the application context own events
Test application contexts10:19
In this lecture:
creating an application context for testing purposes
configuring the test context (@ContextConfiguration)
replacing a real bean in the test context (@TestBean)
writing an integration test
The application context

Requirements

Knowledge or some experience of the Java programming language.
Basic familiarity with build tools like Gradle or Maven.
No Spring experience is necessary.
Vey basic skills for working with git and GitHub.

Description

Unlock the power of Spring Dependency Injection (DI)!

This course provides a comprehensive introduction to DI, one of the core concepts in the Spring Framework, allowing you to create, inject and troubleshoot your spring managed classes.

You’ll start with the fundamentals of Inversion of Control (IoC) . You’ll explore Spring’s IoC container, learn how to configure beans using XML configuration, annotations (@Component, @Autowired, @Qualifier, etc.), and Java-based configurations (@Bean, @Configuration). Through hands-on examples and exercises, you’ll implement different injection types and understand the role of Spring’s ApplicationContext in managing your beans.

You will see how Spring’s IoC container manages bean lifecycles and learn about bean scopes. You will learn how to combine different bean scopes and even implement your custom scope. You will tackle some more subtle cases like injection of multiple beans, handling of circular dependencies, optional dependencies and even more.

Finally you will learn about the proxy pattern and how the Spring framework creates proxies for us - JDK dynamic proxies and CGLIB proxies. This is very fundamental knowledge in order to continue learning about the second core concept in Spring - the Aspect Oriented Programming (AOP).

By the end of this course, you’ll have a strong grasp of DI principles and you will be ready to continue with AOP. A good choice for Java developers from all levels eager to deepen their knowledge in Spring!

Who this course is for:

Beginners in the Spring world.
All level developers that want to know more about the core spring framework.

What you'll learn

Explore related topics

Course content

Introduction1 lecture • 3min

Introduction to inversion of control (IoC) and dependency injection (DI)2 lectures • 9min

DI in action - the basics14 lectures • 2hr 35min

Spring managed Beans in depth14 lectures • 2hr 7min

The magic of proxies5 lectures • 40min

What is next?1 lecture • 2min

Requirements

Description

Who this course is for: