1. Introduction to Spring Matt Wheeler

2. Notes This is a training NOT a presentation Please ask questions Prerequisites – Introduction to Java Stack – Basic Java and XML skills

3. Overview Learn the basics of the Spring Framework Become familiar with Spring documentation http://www.springsource.org/documentation Learn basics of the Spring architecture Learn about bean creation Learn about bean scopes Learn about the application context Inversion of Control (IoC) Dependency Injection (DI)

4. Goals of the Spring Framework Simplify Java EE development Solve problems not addressed by Java EE Provide simple integration for best of breed technologies Provide modular/pluggable architecture – Use what you want – don’t use what you don’t http://www.springsource.org/about

5. Explore the Spring Ecosystem Main Page: http://www.springsource.org/http://www.springsource.org/ Documentation: http://www.springsource.org/documentation Forum: http://forum.springsource.org/http://forum.springsource.org/ Jira: https://jira.springsource.org/secure/Dashboard.j spa

6. Spring Framework Modified from http://static.springsource.org/spring/docs/3.1.0.M1/spring-framework-reference/html/images/spring-overview.png

7. Data Access Integration Data Access Integration layer includes: – JDBC (abstraction layer over native JDBC) – ORM (integration support for JPA, Hibernate, …) – Transaction support (declarative and programmatic)

8. Web Basic web integration features – File upload – Initialization of IoC container using servlet listeners – Contains Spring’s model view controller (MVC) implementation

9. Test Test module provides integration with test frameworks – JUnit – TestNG Provides ability to load test specific ApplicationContexts Also provides helpful mock objects

10. Core Container Core and Beans modules provide framework fundamentals – Inversion of Control (IoC) and Dependency Injection (DI) – BeanFactory provides factory pattern implementation for creating Java objects – Allows decoupling of configuration and dependencies from actual code

11. Application Context configuration file Objects managed by the Spring IoC container are called beans Objects must be defined to be managed by the Spring (IoC) container – Defined in xml (applicationContext.xml in the Stack) – Defined using annotations Definition contains “configuration metadata” – Template for creating beans and their dependencies

12. Loading the Application Context org.springframework.context.ApplicationContext interface represents the Spring IoC container Responsible for instantiating and assembling beans – Template for doing so is in the defined configuration metadata (xml, annotations, or Java code) The application context can be loaded as follows: ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); SomeBean someBean = (SomeBean) context.getBean("someBean"); someBean.callMethod();

13. Defining Beans When defined in xml the Spring configuration file looks like the following:

14. Defining beans Each bean should have – Unique id – Fully qualified package and name of the object

15. Lab 1: Bean Creation https://tech.lds.org/wiki/Introduction_to_Spring#L ab_1_Bean_Configuration

16. Bean Scopes Where Spring starts to pay dividends Sometimes you want to be able to control the life of a bean – Bean scopes provide this ability By default all beans are singletons

17. Available Bean Scopes ScopeDocumentation singletonCreates a single bean instance per IoC container (default) prototypeCreates a new instance every time a bean of the type is requested requestCreates a single instance per HTTP request. Only valid in a web application context. sessionCreates a single instance per HTTP session. Only valid in a web application context. globalSessionCreates a single instance per HTTP session. Only valid in a portal application.

18. Singleton Scope Remember these days The new world public static synchronized MySingleton getInstance() { public static MySingleton getInstance() { if (instance == null) { instance = new MySingleton(); } return instance; }

19. Prototype Scope Equivalent to calling new every time a an instance of a class is needed Spring does not manage he lifecycle of prototype bean The configuration is as follows:

20. Web application scopes Without Spring you would have to manage bean creation and lifecycles manually

21. Lab 2: Bean Scopes https://tech.lds.org/wiki/Introduction_to_Spring#L ab_2_Bean_Scopes

22. Inversion of Control (IoC) the Concept Objects define dependencies by: – Constructor arguments – Setter arguments – Arguments to factory method Container injects dependencies when the bean is created Inverse of bean controlling instantiation and/or location of its dependencies

23. Inversion of Control (IoC) the Concept Managing dependencies on other beans – Dependency lookup vs. Dependency Injection //dependency lookup public class Lookup { private SomeBean someBean; public SomeBean findBean(Container container) { return (SomeBean) container.getBean(“someBean”); } //dependency injection public class Injection { private SomeBean someBean; public void setSomeBean(SomeBean someBean) { this.someBean = someBean; }

24. Advantages of Inversion of Control (IoC) Simplifies component dependency and lifecycle management Eliminates need for: – Calling new or looking up dependencies Decouples code from IoC container Injection is easier – less code – easier to maintain Minimizes need for creational pattern implementation Simplifies testing

25. Inversion of Control (IoC) Heart of Spring Framework is the IoC container Two basic implementations of the IoC container – ApplicationContext – BeanFactory – BeanFactory is stripped down version of ApplicationContext We will exclusively focus on ApplicationContext

26. Dependency Injection (DI) Two basic types of injection – Setter injection – Constructor injection

27. DI (setter injection) Say we have to following Rabbit class Example public class Rabbit { private String favoriteFood; public void setFavoriteFood(String favoriteFood) { this.favoriteFood = favoriteFood; } public void printFavoriteFood() { System.out.println(favoriteFood); }

28. DI (constructor injection) Say we have to following Rabbit class Example public class Rabbit { private String favoriteFood; public Rabbit(String favoriteFood) { this.favoriteFood = favoriteFood; } public void printFavoriteFood() { System.out.println(favoriteFood); }

29. DI (continued) Ability to inject many data types – Lists, Sets, Properties, Maps (most collection types) – Other beans Lets us look at a few examples: – http://static.springsource.org/spring/docs/3.0.x/spri ng-framework-reference/html/beans.html#beans- collection-elements

30. DI Collections Say our rabbit has many favorite foods public class Rabbit { private Set favoriteFoods; public void setFavoriteFoods(List favoriteFoods) { this.favoriteFoods = favoriteFoods; } public void printFavoriteFood() { for (String favoriteFoods : favoriteFood) { System.out.println(favoriteFood); } lettuce carrot

31. DI Bean References Lets expand our rabbit concept to an entire farm And then modify our rabbit class as follows public class Farm { private List rabbits; public void setRabbits(List rabbits) { this.rabbits = rabbits; } public class Rabbit { private String name; public Rabbit(String name) { this.name = name; } public void setName(String name) { this.name = name; } //… }

32. Bean Reference Examples

33. Another public class Farm { private Rabbit prizeRabbit; public void setPrizeRabbit(Rabbit prizeRabbit) { this.prizeRabbit = prizeRabbit; }

34. Lab 3: Dependency Injection https://tech.lds.org/wiki/Introduction_to_Spring#L ab_3_Dependency_Injection

35. Summary Info More info