Spring Core Tutorials

What is Spring Framework? Kick Start Example.

What are different ways to configure spring application? What configuration metadata is used for?

Configure and wire Spring beans using JavaConfig annotation @Configuration. Using multiple configuration classes. Bootstrapping Spring container with JavaConfig.

splitting up large configuration classes

Injecting beans in @Configuration classes

Achieving modularization by importing other configuration classes using @Import.

@Bean annotation example

Exploring elements of @Bean

@Autowire example

Using JSR-330 @Inject annotation

Using @Autowired on methods other than constructors and setters

Spring auto wiring types with an example project.

Autowire.NO Example

Autowire.BY_TYPE example

Autowire.BY_NAME Example

Inject beans by name to avoid conflict or if we just want to recognize a bean by name, with example project.

Inject beans by name using JSR-250 annotation, @Resource.

Using @Inject + @Qualifier

@Inject and @Named Example

Spring using @Primary annotation to resolve ambiguity at configuration level, with example project.

Using generics as autowiring qualifiers, with example project.

Types of dependency injection i.e. constructor-based, setter-based and field-based.

What is implicit constructor injection?

Constructor bases implicit DI in @Configuration

The @Bean methods and their inter-dependencies.

Understanding when @PostConstruct and @PreDestroy are called. Other ways to get these callbacks.

Initialization and destruction lifecycle callbacks Using 'initMethod' and 'destroyMethod' of @Bean annotation

Initialization and destruction lifecycle callbacks By Implementing InitializingBean and DisposableBean

Lazy Initializing of Beans, using @Lazy annotation. When to use @Lazy. Example project.

How @Lazy can be used at injection points?

Configuring explicit bean loading order to avoid side effects in particular scenarios, with example project.

What are different bean scopes. Using @Scope, Core scopes Singleton and Prototype in details with an example project.

Understanding singleton bean with example

Understanding Prototype Bean with example

An example to show how prototype bean can contain a session information.

Spring JavaConfig using with Component Scan. @ComponentScan Example project.

@ComponentScan#basePackages Example

@ComponentScan#basePackageClasses Example

Understanding @ComponentScan#includeFilters and @ComponentScan#excludeFilters attributes

@ComponentScan#includeFilters example

@ComponentScan#excludeFilters example

Using @ComponentScan#includeFilters with FilterType Annotation

Using @ComponentScan#excludeFilters with FilterType Annotation

How classes annotated with @Component, can define new beans and register them with the Spring container.

Using Filter element of @ComponentScan.

Creating Beans of Arrays and Collections

Arrays and Collections of Beans

Using @Qualifier for selection of array/collection/map elements

Ordering Arrays/List with @Order annotation

Ordering Arrays/List via Ordered interface

Using @Qualifier and @Order at the same time

What are circular dependencies?

Spring example of avoiding circular dependencies error via setters

Spring example of avoiding circular dependencies error via @Lazy

Different aspects and options of dependency checking during startup time.

Include/exclude @Bean registration based on programmatic conditions.

Example demonstrating how Spring (4.2) supports Java 8 default methods.

ObjectProvider examples.

Spring 5.0 new ObjectProvider methods

Spring 5.1 new method in ObjectProvider

The problem with injecting beans with shorted-lived scope, for example Prototype bean into Singleton bean. Example project to demonstrate the problem.

Injecting ApplicationContext into a bean. A solution to injecting short-lived scoped bean into a long-lived scoped bean, with example project.

Implementing ApplicationContextAware. A solution to injecting short-lived scoped bean into a long-lived scoped bean.

Using Spring @Lookup . A better solution for injecting narrower scoped bean into a wider scoped bean, with example project.

This is another way to solve the problem of injecting a short-lived scoped bean into long-lived scoped bean.

Injecting JDK interface based proxy object using proxyMode=ScopedProxyMode.INTERFACES of @Scope annotation.

Using JSR 330 Provider to inject shorter-lived scoped bean.

Example using Spring's ObjectProvider to inject Prototype Bean into Singleton bean

Using Java 8 Functions to solve Incompatible Bean Scopes problem.

Using Spring Profiles. Demonstrating the concept of profiles with an example project.

Obtaining properties from underlying system

How to add user defined property source?

@PropertySource annotation example

Injecting Spring's Environment to access properties.

@Value Example

@Value + expression language

Spring support of using Java application args.

Basics of how Spring handles resources.

Using ResourceLoader as a bean

Injecting Resource Example

Include/exclude @Bean registration based on programmatic conditions.

Event handling provided by spring core framework

Custom Events Examples

Using @EventListener#value with multiple events

@EventListener#condition example

Transforming to other events

How Spring bean creation and manipulation is based on standard JavaBeans? Understanding BeanWrapper interface

How to set nested beans by using BeanWrapper?

DirectFieldAccessor Example.

Spring specific way to obtain BeanInfo and PropertyDescriptor

How to copy properties from one bean to another?

Getting Method instance via String based signatures

How PropertyEditor is used in Spring for type conversion?

Use of property editors via BeanWrapper without Spring Container

How property editors are used when XML configuration is used to initialize beans?

Implicit type conversion with @Value annotation via PropertyEditors

Core Data binding. What is DataBinder? The difference between using DataBinder and BeanWrapper.

Different ways to validate beans in Spring at core level.

Spring Validation example by using Validator interface

Performing JSR 349/303 annotation based validations in Spring.

JSR 349/303 annotation based validations and Spring specific validation mechanism via Validator interface

Understanding how MessageCodesResolver is used.

Creating constraint annotation in Spring Core.

Performing method validation at Core level.

Spring ConversionService for general type conversion. Different ways to create converters. Using ConversionService with DataBinder.

Complete list of Spring's built-in converter list

ConversionService + ApplicationContext

Creating and registring a custom converter

Understanding Converter Factory

Custom ConverterFactory example

Understanding Generic Converter.

Understanding ConditionalGenericConverter

DataBinder with DefaultConversionService example.

Spring Formatters on core level for rendering formatted string.

How to find Spring built-in formatter list?

Using DefaultFormattingConversionService with ApplicationContext

Spring Custom Formatter Example

How to use DefaultFormattingConversionService with DataBinder?

What is annotation based formatting in Spring? Using Spring provided annotation for formatting. Creating custom annotation and binding it with a Formatter using AnnotationFormatterFactory.

Spring Core thread execution abstraction. Getting familiar with interfaces: TaskExecutor, AsyncTaskExecutor and AsyncListenableTaskExecutor along with their implementations.

Getting familiar with interface TaskScheduler and it's implementations.

Using annotations @Async and @EnableAsync for annotation based task execution.

Using annotations @Scheduled and @EnableScheduling for annotation based task scheduling.

Working with BeanFactory and BeanDefinition to dynamically register objects as Spring bean.

Spring 5 BeanDefinitionCustomizer and GenericApplicationContext new methods

How configuration classes can be imported programmatically by using ImportSelector interface?

The difference between DeferredImportSelector and ImportSelector.

Using interface ImportBeanDefinitionRegistrar instance with @Import to dynamically register beans.

@AliasFor Examples.

How logging in spring works? What is default logging?

How to use log4j as a JCL runtime implementation in Spring?

How to use log4j2 as a JCL runtime implementation in Spring?

How to use SLF4J in Spring?

Spring + Logback

Using Spring TestContext Framework to do unit and integration testing.

Using @ActiveProfiles to load a specific profile in a JUnit test.

ActiveProfilesResolver example.

Using @ContextConfiguration initializers to initialize the context for tests.

Using @TestPropertySource to load specific properties files in a JUnit test.

Using @TestPropertySource with properties attribute to .

How to use @TestPropertySource to load properties from default location?

Using @IfProfileValue to ignore tests when a specific property value is not present.

Using ProfileValueSource and @ProfileValueSourceConfiguration to specify a custom strategy to retrieve profile values.

Understanding tests context configuration inheritance.

Using SpringClassRule and SpringMethodRule.

What is TestExecutionListener? How can we use it?