Spring
Framework
The Spring Framework provides a
comprehensive programming and
configuration model for modern
Java-based enterprise applications
• Open Source
• Light Weight
• Multi-Tier
• Modular
• Enterprise Application framework
• A key element of Spring is infrastructural support at the
application level: Spring focuses on the "plumbing" of
enterprise applications so that teams can focus on
application-level business logic, without unnecessary ties
to specific deployment environments.
More is
Better… I always believed there's a fine line between love and hate.
2
Spring
modules
3
Spring core
Container
Is an IOC Implementation
Inversion
of
IOC is design Principle, that
describes to have an external
Control?
entity to create and wire the
objects, Here the wiring is done by
using a concept DI.
“In object-oriented design, the
dependency inversion principle refers to
a specific form of decoupling software
modules.
Dependency
When following this principle, the
conventional dependency relationships
Injection?
established from high-level, policy-
setting modules to low-level,
dependency modules are reversed, thus
rendering high-level modules
independent of the low-level module
implementation details”
Source Wiki
Software
Requirement
Spring Tool Suite Java 8 +
7
Types of DI
Constructor Based Dependency Injection
Setter Based Dependency Injection
Spring
Container
Configuration
XML Based Configuration
Java Based Configuration
XML Based
Spring support XML Schema Definition to
Configuration
configure spring container using this style.
It can be useful to have bean definitions
span multiple XML files.
<beans>
XML Based
<bean>
<import>
<alias>
Configuration
</beans>
This allows to define a spring bean
<bean>
definition , This definition carry the
concrete information for the spring
container such that the container can
create and manage the spring bean.
Spring Bean ?
A Java Object created and/or managed by
the Spring container.
• A Spring IoC container manages one or more beans. These
beans are created with the configuration metadata that
you supply to the container (for example, in the form of
XML <bean/> definitions).
• Naming beans
• Instantiating beans
– By Executing Constructor
– By Executing Static Factory Method
– By Executing Non-Static Factory Method
Bean
Overview
13
<bean class=“…”>
Any one among this
<constructor-arg >
<value> <ref> <null>
<list> <set> <map>
Instantiation <array> <bean> <props>
with a </constructor-arg>
Constructor </bean>
14
<constructor-arg value=“” ref=“” type=“” name=“” index=“” >
• Constructor argument resolution matching occurs by
using the argument’s type. If no potential ambiguity exists
in the constructor arguments of a bean definition,
• the order in which the constructor arguments are defined
in a bean definition is the order in which those arguments
are supplied to the appropriate constructor when the bean
is being instantiated
Constructor • Constructor argument type matching
Argument
Resolution • Constructor argument index ,The index is zero-based.
• Constructor argument name 15
<bean class=“…” factory-method=“ …“
How to configure the arguments of the factory method?
Static Factory
Method
</bean>
16
<bean factory-bean=“…” factory-method=“ …“
How to configure the arguments of the factory method?
Non-Static
Factory
Method
</bean>
17
• Abstract bean Definition
• Bean Definition Inheritance
• Setter Base Dependency Injection
• Circular Dependency
• P Namespace spring 2.0
More • C Namespace spring 3.0
configuration • Util Namespace spring 2.0
18
• Depends on config
• Implement InitializingBean interface
• Using init-method attribute of <bean> tag
• Using JSR 250 annotation @PostConstruct
Spring Bean
Initialization
19
• Implement DisposableBean interface
• Using destroy-method attribute of <bean> tag
• Using JSR 250 annotation @PreDestroy
Spring Bean
Destruction
20
• singleton ( from 1.0 )
• prototype (from 1.0 )
• request ( from spring 2.0 )
• session
• application
• global session ( portlet )
• websocket ( new from spring 4.x )
Bean Scope • thread ( new from spring 3.0 )
• Scoped Bean Dependencies
21
• ApplicationContextAware
• ApplicationEventPublisherAware
• BeanClassLoaderAware
• BeanFactoryAware
• BeanNameAware
• EnvironmentAware
Aware
• MessageSourceAware
Interfaces
• ResourceLoaderAware
• ServletConfigAware
22
• ServletContextAware
• BeanPostProcessor
Container
Extension • BeanFactoryPostprocessor
Points
23
• Spring 2.0
– @Required
• spring 2.5
– @Autowired , @Value
– Jsr 250 Annotation
• @PostConstruct , @PreDestroy
Using
• @Resource
• Spring 3.0
Annotation – Jsr 330 Annotation
24
• @Named, @Inject , @Qualifier
• @Scope , @Singleton
• @Component and Further Stereotype Annotations
• Using Meta-annotations and Composed Annotations
• Automatically Detecting Classes and Registering Bean
Definitions
Classpath
Scanning and • Providing a Scope for Autodetected Components
Managed • Naming Autodetected Components
Components
• Providing Qualifier Metadata with Annotations
25
• @Bean & @Configuration
• @Bean Annotation
– Declaring a Bean
– Bean Dependencies
– Receiving Lifecycle Callbacks
– Specifying Bean Scope
– Customizing Bean Naming
– Bean Aliasing
Java Based
– Bean Description
• Instantiating the Spring Container by
Configuration
Using AnnotationConfigApplicationContext
– Simple Construction
– Building the Container Programmatically by Using 26
register(Class<?>…)
– Enabling Component Scanning with scan(String…)
• @Configuration Annotation
– Injecting Inter-bean Dependencies
– How Java-based Configuration Works Internally
• Composing Java-based Configurations
– Using the @Import Annotation
– Combining Java and XML Configuration
• @ImportResource("classpath:/com/acme/properties-
config.xml")
Java Based
Configuration
27
