1 / 37

Matt Wheeler

Introduction to Spring. Matt Wheeler. Notes. This is a training NOT a presentation Please ask questions Prerequisites Introduction to Java Stack Basic Java and XML skills Installed LdsTech IDE (or other equivalent – good luck there ;). Overview.

gyan
Télécharger la présentation

Matt Wheeler

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 • Installed LdsTech IDE (or other equivalent – good luck there ;)

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

  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/ • Documentation: http://www.springsource.org/documentation • Forum: http://forum.springsource.org/ • Jira: https://jira.springsource.org/secure/Dashboard.jspa

  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. Spring Container / Application Context • Spring container / application context contains instances of objects • Spring managed object instances are called beans • Spring manages the creation, configuration, and destruction of these beans • Beans are defined for use in the application context • The definitions are a template for creating new bean instances • Bean definitions can be provided to Spring: • In xml • Using annotations • In Java code

  12. Defining Beans • Bean definition (beans.xml) <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean class="org.lds.training.SomeBean" /> <!-- more bean definitions go here --> </beans> • Application Context ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); SomeBeansomeBean = context.getBean(SomeBean.class); someBean.callMethod();

  13. Defining beans • Each bean has a unique id • If none is provided, Spring will create one • Class should contain fully qualified package and name of the object <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="someBean" class="org.lds.training.SomeBean" /> <!-- more bean definitions go here --> </beans>

  14. Defining Beans • Bean definition (beans.xml) <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <!– defines an id by which the bean can be uniquely referenced --> <bean id="someBean" class="org.lds.training.SomeBean" /> </beans> • Application Context ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); SomeBeansomeBean = context.getBean("someBean", SomeBean.class); someBean.callMethod();

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

  16. Dependency Injection Dependency Injection (DI) & Inversion of Control (IoC)

  17. Object Dependencies • This is where your Spring investment starts to pay dividends • Most objects cannot do much by themselves • They depend on other objects to accomplish some tasks • For instance if an object wanted to insert something into a database it will need a connection to accomplish this • Most objects have properties that should be configurable • For example if you have an object that times out after a certain period, you might want to be able to configure the timeout period • Additionally, what if two objects need the same object dependency • For instance a data source might be used by many objects to persist data

  18. Inversion of Control (IoC) the Concept • Container injects dependencies when (or right after) the bean is created • Inverse of bean controlling instantiation and/or location of its dependencies • Objects instead obtain dependencies through • Constructor arguments • Setter arguments

  19. Inversion of Control (IoC) the Concept • Managing dependencies on other beans • Dependency lookup vs. Dependency Injection //dependency lookup public class Lookup { private SomeBeansomeBean; public SomeBeanfindBean(Container container) { //or new SomeBean("some param values"); return (SomeBean) container.getBean("someBean"); } } //dependency injection public class Injection { private SomeBeansomeBean; public void setSomeBean(SomeBeansomeBean) { this.someBean = someBean; } }

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

  21. Dependency Injection (DI) • Two basic types of injection • Setter injection • Constructor injection

  22. DI (setter injection) • Say we have the 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); } } <bean id="rabbit" class="org.lds.training.Rabbit"> <property name="favoriteFood"value="lettuce" /> </bean>

  23. DI (constructor injection) • Say we have the following Rabbit class • Example public class Rabbit { private String favoriteFood; public Rabbit(String favoriteFood) { this.favoriteFood = favoriteFood; } public void printFavoriteFood() { System.out.println(favoriteFood); } } <bean id="rabbit" class="org.lds.farm.Rabbit"> <constructor-arg value="lettuce" /> </bean>

  24. 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/spring-framework-reference/html/beans.html#beans-collection-elements

  25. Constructor Injection vs. Setter Injection • Which should you use? • Rule of thumb – write the bean as though Spring were not managing it • If the bean will not operate without a particular member variable use constructor injection • Otherwise use setter injection • This is a change from the past • Let’s look at some more examples

  26. DI Collections • Say our rabbit has many favorite foods public class Rabbit { private Set<String> favoriteFoods; public void setFavoriteFoods(Set<String> favoriteFoods) { this.favoriteFoods = favoriteFoods; } public void printFavoriteFood() { for (String favoriteFoods : favoriteFood) { System.out.println(favoriteFood); } } } <bean id="rabbit" class="org.lds.farm.Rabbit"> <property name="favoriteFoods"> <set> <value>lettuce</value> <value>carrot</value> </set> </property> </bean>

  27. 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<Rabbit> rabbits; public void setRabbits(List<Rabbit> rabbits) { this.rabbits = rabbits; } } public class Rabbit { private String name; private float weight; public Rabbit(float weight) { this.weight = weight; } public void setName(String name) { this.name = name; } //… }

  28. Bean Reference Examples <bean id="rabbit" class="org.lds.training.Rabbit"> <constructor-arg name="weight" value=" 3.0" /> <property name="name" value="Bubba" /> </bean> <bean id="farm" class="org.lds.training.Farm"> <property name="rabbits"> <list> <ref bean="rabbit" /> <!– anonymous inner bean --> <bean class="org.lds.model.Rabbit"> <constructor-arg name="weight" value="2.5" /> </bean> </list> </property> </bean>

  29. More Examples public class Farm { private Rabbit prizeRabbit; public void setPrizeRabbit(Rabbit prizeRabbit) { this.prizeRabbit = prizeRabbit; } } • <bean id="prize" class="org.lds.model.Rabbit"> • <constructor-arg name="weight" value="12" /> • <property name="name" value="Queen Bee" /> • </bean> • <!– these are basically equivalent --> • <bean id="farm" class="org.lds.model.Farm"> • <property name="prizeRabbit" ref="prize" /> • </bean> • <bean id="farm" class="org.lds.model.Farm"> • <property name="prizeRabbit"> • <bean class="org.lds.model.Rabbit"> • <constructor-arg name="weight" value="12" /> • <property name="name" value="Queen Bee" /> • </bean> • </property> • </bean>

  30. Lab 2: Dependency Injection https://tech.lds.org/wiki/Introduction_to_Spring#Lab_2_Dependency_Injection

  31. Bean Scopes • Sometimes you want to be able to control the life of a bean • Bean scopes provide this ability • For instance, you may want a new instance of a bean every time it is requested, or you may want one instance for the entire application

  32. Available Bean Scopes

  33. Singleton Scope • Singleton - only one instance in a given context • Any time you request an instance of this bean you will get the single instance of this bean • For instance (if SomeBean is a singleton): • The new world context.getBean(SomeBean.class) == context.getBean(SomeBean.class) is true <!– singleton is the default so these two definitions are equivalent --> <bean id="whatever" class="org.lds.whatever.MyBean" /> <bean id="whatever" class="org.lds.whatever.MyBean" scope="singleton" />

  34. Prototype Scope • Equivalent to calling new every time an instance of a class is needed • Spring does not manage the lifecycle of prototype beans • For instance if SomeBean is prototype scope: • The configuration is as follows: context.getBean(SomeBean.class) == context.getBean(SomeBean.class) is false <bean id="whatever" class="org.lds.whatever.MyBean" scope="prototype" />

  35. Lab 3: Bean Scopes https://tech.lds.org/wiki/Introduction_to_Spring#Lab_3_Bean_Scopes

  36. Credit where credit is due • http://springsource.org • Spring Recipies 2nd Edition (Gary Mak, Josh Long and Daniel Rubio)

  37. Dedication • Mike Youngstrom and Bruce Campbell for their undying love and support through this process • And for reviewing and offering suggestions • And for Spencer Uresk and Mike Heath for the inspiration • And a special thanks to the rabbit farm who made this all possible

More Related