Download
matt wheeler n.
Skip this Video
Loading SlideShow in 5 Seconds..
Matt Wheeler PowerPoint Presentation
Download Presentation
Matt Wheeler

Matt Wheeler

67 Vues Download Presentation
Télécharger la présentation

Matt Wheeler

- - - - - - - - - - - - - - - - - - - - - - - - - - - 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

  3. Overview Learn the basics of the Spring Framework • http://www.springsource.org/documentation

  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

  5. Defining Beans • Define beans to be managed by Spring (IoC) container • Defined in xml (applicationContext.xml in the Stack) • Defined using annotations • Basic configuration <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 definitions go here --> </beans>

  6. Defining beans • Each bean should have • Unique name or preferrably id <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=“whatever” class=“org.lds.whatever.BeanName” /> </beans>

  7. Lab 1: Bean Creation https://tech.lds.org/wiki/Introduction_to_Spring#Lab_1_Bean_Creation

  8. 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

  9. Available Bean Scopes

  10. Singleton Scope • Remember these days • The new world public static synchronized MySingletongetInstance() { public static MySingletongetInstance() { if (_instance==null) { _instance = new MySingleton();   }   return _instance; } <!– 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” />

  11. 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: <bean id=“whatever” class=“org.lds.whatever.MyBean” scope=“prototype” />

  12. Web application scopes • Without Spring you would have to manage bean creation and lifecycles manually <bean id=“whatever” class=“org.lds.whatever.MyBean” scope=“request” /> <bean id=“whatever” class=“org.lds.whatever.MyBean” scope=“session” />

  13. Lab 2: Bean Scopes https://tech.lds.org/wiki/Introduction_to_Spring#Lab_2_Bean_Scopes

  14. Advantages of Inversion of Control (IoC) • Simplify component dependency and lifecycle management • Injection eliminates need for: • Calling new • Looking up dependencies • Decouples code from IoC container • Injection is easier – less code • Simplifies testing • Easier to maintain

  15. 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

  16. Inversion of Control (IoC) the Concept • Simplify component dependencies and lifecycle management • Dependency lookup vs. Dependency Injection //dependency lookup public class Lookup{ private Bean bean; public Bean findBean(Container container) { return (Bean) container.getBean(“someBean”); } } //dependency injection public class Injection { private Bean bean; public void setBean(Bean bean) { this.bean = bean; } }

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

  18. 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); } } <bean id=“rabbit” class=“org.lds.farm.Rabbit”> <property name=“favoriteFood” value=“lettuce” /> </bean>

  19. 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); } } <bean id=“rabbit” class=“org.lds.farm.Rabbit”> <constructor-arg value=“lettuce” /> </bean>

  20. 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

  21. DI Collections • Say our rabbit has many favorite foods public class Rabbit { private Set<String> favoriteFoods; public void setFavoriteFoods(List<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>

  22. DI Bean References • Lets expand our rabbit concept to an entire farm • And then modify our rabbit class just a hair public class Farm { private List<Rabbit> rabbits; public void setRabbits(List<Rabbit> 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; } //… }

  23. Bean Reference Examples <bean id=“rabbit” class=“org.lds.model.Rabbit”> <property name=“name” value=“Bubba” /> </bean> <bean id=“farm” class=“org.lds.model.Farm”> <property name=“rabbits”> <list> <ref bean=“rabbit” /> <!– anonymous inner bean --> <bean class=“org.lds.model.Rabbit”> <property name=“name” value=“Snowshoe” /> </bean> </list> </property> </bean>

  24. Another public class Farm { private Rabbit prizeRabbit; public void setPrizeRabbit(Rabbit prizeRabbit) { this.prizeRabbit = prizeRabbit; } } <bean id=“prize” class=“org.lds.model.Rabbit”> <property name=“name” value=“Queen Bee” /> </bean> <bean id=“farm” class=“org.lds.model.Farm”> <property name=“prizeRabbit” ref=“prize” /> </bean>

  25. Lab 3: Dependency Injection https://tech.lds.org/wiki/Introduction_to_Spring#Lab_3_Dependency_Injection

  26. Summary • Info • More info