This document provides an overview of Spring frameworks history and key concepts such as inversion of control (IOC) and dependency injection (DI). It discusses different ways to configure Spring applications using XML, Java configuration, and annotations. Key topics include constructor versus setter injection, autowiring, and examples of implementing IOC using XML and Java configurations. The document recommends starting with Spring Tool Suite and moving to more preferred approaches with Java configuration and Spring Boot.

1. SPRING ESSENTIALS 1
Introduction to Spring and XML Configuration
(Spring Series 01)
Presenter: Heartin Jacob Kanikathottu

2. TOPICS
• History and Need for Spring
• Inversion of Control (IoC) and Dependency Injection (DI)
• Different Ways to Configure Spring 4 Applications
• Writing Spring Programs Using XML Configuration
• Constructor Injection and Setter Injection
• Autowiring
• Java Configuration and Annotations

3. HISTORY
• 1999 – EJB 1.1
• 2002 - Rod Johnson, released the Spring framework with his book
• 2003 – First version of Spring framework released.
• 2004 - First milestone release of Spring framework (1.0)
• 2006 - Spring 2.0, simplified the XML config files.
• 2007 - Spring 2.5, introduced annotation configurations.
• 2012 - Spring 3.2, Java configuration, Java 7, Hibernate 4, Servlet 3.0.
• 2014 - Spring 4.0, Java 8, Spring Boot.

4. INVERSION OF CONTROL (IOC) AND
DEPENDENCY INJECTION (DI)
• Inversion of Control is a pattern where the controls of dependencies are moved out
usually from program components to container.
• Two ways to achieve IOC:
• Dependency lookup is the looking up of dependencies using container provided services,
like a JNDI lookup.
• Dependency injection is the process of injecting the dependencies of your class from
outside of the class.
• Note: DI is always preferred.

5. DI – SETTER VS. CONSTRUCTOR
• Setter Injection
• Advantage : Allows re-configuring of the components after its creation.
• Disadvantage: Might not be suitable if the order of invocation of setter methods is important.
• Constructor Injection
• Advantage : component will be in a consistent state ready to use immediately after its
creation.
• Disadvantages :
• Will not be able to reconfigure the component, unless setters are also present.
• Constructor injection cannot handle circular dependency: if two objects depend on the other through
constructor injection, both objects will not be created as both cannot be created without the other.

6. CONFIGURING SPRING 4 APPLICATIONS
• You can configure a Spring application entirely using xml configuration or using a
Java configuration.
• Annotation s can be used along with both XML and Java configurations.
• Java configuration is the most preferred approach in newer projects as:
• Can keep configurations at one centralized place (compared to all annotations approach)
• Can make use of Java compiler to check configs (compared to xml approach)
• Can use any of the Java language features to write any kind of (even complex) bean
configurations (compared to xml approach)

7. CONFIGURING SPRING 4 APPLICATIONS
(CONTD…)
• Though annotations and Java configuration are the preferred approaches, xml
configurations might be handy in cases such as:
• We do not have access to the classes to write annotations.
• Some libraries (or some versions) might not support Java configurations completely.
• Some features might be significantly more difficult to do in Java configuration than on
XML due to various shortcuts and features available with XML configurations.

8. GETTING STARTED
• Spring Tool Suite (STS) / Intellij IDEA
• Any IDE (E.g. Eclipse) through Maven/ Gradle.
• Manual download of jars
• Not preferred
• Spring Boot (STS/Intellij/start.spring.io)
• Most preferred.

9. FIRST SPRING PROGRAM USING
XML CONFIGURATION
• Problem Summary
• Create a simple class, JJWriter.java, with a single method write. Create a simple spring
config file, called spring.xml with a simple bean definition for JJWriter;:
• Maven dependency: spring-context
• Bean Definition: <bean id="jjwriter" class="com.example.JJWriter"> </bean>
• Loading xml config file and getting bean (from test class):
• AbstractApplicationContext context= new ClassPathXmlApplicationContext("spring.xml");
• JJWriter writer = context.getBean("jjwriter", JJWriter.class);

10. FIRST SPRING PROGRAM USING
XML CONFIGURATION (CONTD…)
• Add a variable called data of type String to any of the class and do DI from bean def.
• <property name = "data" value="Sample Data"/> or
• <constructor-arg type="java.lang.String" value="Sample Data"></constructor-arg>
• Extended Problem Summary
• Create JJWriter.java, with a single method write and two subclasses – JJDatabaseWriter.java
and JJFileWriter.java – both overriding the write method.
• Bean definition: Bean Definition: <bean id="jjwriter" class="com.example. JJDatabaseWriter
"> </bean>
• Replace JJDatabaseWriter with JJFileWriter and execute again.

11. OBJECT INJECTION EXAMPLE
• Problem Statement
• Create a Point class with x and y coordinates, and then a Line class that has two Point objects.
Let Spring to inject the Point objects into the Line object based on bean definitions.
• Bean Definitions:
• <bean id="line" class="com.example.Line">
<property name="pointA" ref = "point1"></property>
<property name="pointB" ref = "point2"></property> </bean>
<bean id="point1" class="com.example.Point">
<property name="x" value ="1"></property>
<property name="y" value ="1"></property> </bean>
…

12. AUTOWIRING WITH XML CONFIGURATION
• Let spring to intelligently guess some of the bean injection without needing to
configure explicitly.
• Based on the type of the bean, name of the bean, and constructor of the bean.
• <bean id="line" class="com.example.Line“autowire="byName">
• Four ways to autowire:
• autowire="byName”
• autowire="byType”
• autowire="constructor“
• autowire="no” (the default)

13. JAVA CONFIGURATION
• Config class needs to be annotated with @Configuration.
• @Bean can be specified over a method that return a bean:
• @Bean (name = "jjwriter")
public JJWriter getJJWriter()
• We can load a config class as:
• ApplicationContext context = new
AnnotationConfigApplicationContext(DemoConfig.class);
• Config class can import other java configs using @Import and other non-java configs
using @ImportResource.

14. ANNOTATIONS
• @Component indicates that an annotated class is a "component".
• @ComponentScan annotation can be used to specify the packages that need to be
scanned for components.
• @Repository, @Service and @Controller can be used instead of @Component based on
actual application layer you are developing.
• @Autowired annotation provide autowiring over properties, setters and constructors
• @Qualifier annotation can be used with @Autowired to do autowiring by name.
• @Resource and @Inject are Java annotations similar to @Autowired. However,
@Resource, can specify autowiring by name instead of using @Qualifier annotation.

15. WHAT NEXT?
• Please complete doing examples for all concepts mentioned.
• We will go deep into Java Configurations, Annotations, Profiles, Junit Testing and
eventually start with Spring Boot.

16. RESOURCES & REFERENCES
• https://spring.io/docs
• http://javajee.com/spring-framework-4-essentials