17. Spring Framework - Spring IoC - Advance

Nguyễn Hoàng Anh – [email protected] – ĐH KHTN - 2013

Nội dung trình bày

2-1. Creating Beans by Invoking a Static Factory Method

2-2. Creating Beans by Invoking an Instance Factory Method

2-3. Declaring Beans from Static Fields

2-4. Declaring Beans from Object Properties

2-5. Using the Spring Expression Language

2-6. Setting Bean Scopes

2


Nội dung trình bày

2-7. Customizing Bean Initialization and Destruction

2-8. Reducing XML Configuration with Java Config

2-9. Making Beans Aware of the Container

2-10. Loading External Resources

2-11. Creating Bean Post Processors

2-12. Externalizing Bean Configurations

3


2-1. CREATING BEANS BY INVOKING A STATIC FACTORY METHOD

4



Problem

– You would like to create a bean in the Spring IoC container by invoking a static factory method, whose purpose is to encapsulate the object-creation process in a static method.

– The client who requests an object can simply make a call to this method without knowing about the creation detail.

5



Solution

– Spring supports creating a bean by invoking a static factory method, which should be specified in the factory-method attribute.

6


1 2 3 4 5 6 7 8 9 10 11 12

package com.apress.springrecipes.shop; public class ProductCreator { public static Product createProduct(String productId) { if ("aaa".equals(productId)) { return new Battery("AAA", 2.5); } else if ("cdrw".equals(productId)) { return new Disc("CD-RW", 1.5); } throw new IllegalArgumentException("Unknown product"); } }

How It Works

7


1 2 3 4 5 6 7 8 9 10 11 12

<beans ...> <bean id="aaa" class="com.apress.springrecipes.shop.ProductCreator" factory-method="createProduct"> <constructor-arg value="aaa" /> </bean> <bean id="cdrw" class="com.apress.springrecipes.shop.ProductCreator" factory-method="createProduct"> <constructor-arg value="cdrw" /> </bean> </beans>

How It Works

8

1 2

Product aaa = ProductCreator.createProduct("aaa"); Product cdrw = ProductCreator.createProduct("cdrw");


2-2. CREATING BEANS BY INVOKING AN INSTANCE FACTORY METHOD

9



Problem

– You would like to create a bean in the Spring IoC container by invoking an instance factory method, whose purpose is to encapsulate the object-creation process in a method of another object instance.

– The client who requests an object can simply make a call to this method without knowing about the creation detail.

10



Solution

– Spring supports creating a bean by invoking an instance factory method.

– The bean instance should be specified in the factory-bean attribute, while the factory method should be specified in the factory method attribute.

11


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

package com.apress.springrecipes.shop; public class ProductCreator { private Map<String, Product> products; public void setProducts(Map<String, Product> products) { this.products = products; } public Product createProduct(String productId) { Product product = products.get(productId); if (product != null) { return product; } throw new IllegalArgumentException("Unknown product"); } }

How It Works

12


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

<beans ...> <bean id="productCreator" class="com.apress.springrecipes.shop.ProductCreator"> <property name="products"> <map> <entry key="aaa"> <bean class="com.apress.springrecipes.shop.Battery"> <property name="name" value="AAA" /> <property name="price" value="2.5" /> </bean> </entry> <entry key="cdrw"> <bean class="com.apress.springrecipes.shop.Disc"> <property name="name" value="CD-RW" /> <property name="price" value="1.5" /> </bean> </entry> </map> </property> </bean>

How It Works

13


1 2 3 4 5 6 7 8 9 10 11

<bean id="aaa" factory-bean="productCreator" factory-method="createProduct"> <constructor-arg value="aaa" /> </bean> <bean id="cdrw" factory-bean="productCreator" factory-method="createProduct"> <constructor-arg value="cdrw" /> </bean> </bean>

How It Works

14


1 2 3 4 5

ProductCreator productCreator = new ProductCreator(); productCreator.setProducts(...); Product aaa = productCreator.createProduct("aaa"); Product cdrw = productCreator.createProduct("cdrw");

How It Works

15


2-3. DECLARING BEANS FROM STATIC FIELDS

16



Problem

– You would like to declare a bean in the Spring IoC container from a static field.

– In Java, constant values are often declared as static fields.

17



Solution

– To declare a bean from a static field, you can make use of either the built-in factory bean FieldRetrievingFactoryBean, or the <util:contant>tag in Spring 2.x.

18


1 2 3 4 5 6 7

package com.apress.springrecipes.shop; public abstract class Product { public static final Product AAA = new Battery("AAA", 2.5); public static final Product CDRW = new Disc("CD-RW", 1.5); ... }

How It Works

19


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

<beans ...> <bean id="aaa" class="org.springframework.beans.factory.config. FieldRetrievingFactoryBean"> <property name="staticField"> <value>com.apress.springrecipes.shop.Product.AAA</value> </property> </bean> <bean id="cdrw" class="org.springframework.beans.factory.config. FieldRetrievingFactoryBean"> <property name="staticField"> <value>com.apress.springrecipes.shop.Product.CDRW</value> </property> </bean> </beans>

How It Works

20

1 2

Product aaa = com.apress.springrecipes.shop.Product.AAA; Product cdrw = com.apress.springrecipes.shop.Product.CDRW;


1 2 3 4 5 6 7 8

<beans ...> <bean id="com.apress.springrecipes.shop.Product.AAA" class="org.springframework.beans.factory.config. FieldRetrievingFactoryBean" /> <bean id="com.apress.springrecipes.shop.Product.CDRW" class="org.springframework.beans.factory.config. FieldRetrievingFactoryBean" /> </beans>

How It Works

21


1 2 3 4 5 6 7 8 9 10 11 12

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd"> <util:constant id="aaa" static-field="com.apress.springrecipes.shop.Product.AAA" /> <util:constant id="cdrw" static-field="com.apress.springrecipes.shop.Product.CDRW" /> </beans>

How It Works

22

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd






http://www.springframework.org/schema/util


http://www.springframework.org/schema/util/spring-util-3.0.xsd








2-4. DECLARING BEANS FROM OBJECT PROPERTIES

23



Problem

– You would like to declare a bean in the Spring IoC container from an object property or a nested property (i.e., a property path)

24



Solution

– To declare a bean from an object property or a property path, you can make use of either the built-in factory bean PropertyPathFactoryBean or the <util:property-path> tag in Spring 2.x.

25


1 2 3 4 5 6 7 8 9 10 11 12 13

package com.apress.springrecipes.shop; public class ProductRanking { private Product bestSeller; public Product getBestSeller() { return bestSeller; } public void setBestSeller(Product bestSeller) { this.bestSeller = bestSeller; } }

How It Works

26


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

<beans ...> <bean id="productRanking" class="com.apress.springrecipes.shop.ProductRanking"> <property name="bestSeller"> <bean class="com.apress.springrecipes.shop.Disc"> <property name="name" value="CD-RW" /> <property name="price" value="1.5" /> </bean> </property> </bean> <bean id="bestSeller" class="org.springframework.beans.factory.config. PropertyPathFactoryBean"> <property name="targetObject" ref="productRanking" /> <property name="propertyPath" value="bestSeller" /> </bean> </beans>

How It Works

27


1 2 3

<bean id="productRanking.bestSeller" class="org.springframework.beans.factory.config. PropertyPathFactoryBean" />

How It Works

28

1 Product bestSeller = productRanking.getBestSeller();


1 2 3 4 5 6 7 8 9 10 11

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd"> ... <util:property-path id="bestSeller" path="productRanking.bestSeller" /> </beans>

How It Works

29

















1 2 3 4 5 6 7 8 9

package com.apress.springrecipes.shop; public class Main { public static void main(String[] args) throws Exception { ... Product bestSeller = (Product) context.getBean("bestSeller"); System.out.println(bestSeller); } }

How It Works

30


2-5. USING THE SPRING EXPRESSION LANGUAGE

31



Problem

– You want to dynamically evaluate some condition or property and use it as the value configured in the IoC container.

– Or perhaps you need to defer evaluation of something not at design time but at runtime, as might be the case in a custom scope.

– Or you just need a way to add a strong expression language to your own application.

32



Solution

– Use Spring 3.0’s Spring Expression Language (SpEL), which provides functionality similar to the Unified EL from JSF and JSP, or Object Graph Navigation Language (OGNL).

– SpEL provides easy-to-use infrastructure that can be leveraged outside of the Spring container. Within the container, it can be used to make configuration much easier in a lot of cases.

33


2-6. SETTING BEAN SCOPES

34



Problem

– When you declare a bean in the configuration file, you are actually defining a template for bean creation, not an actual bean instance. When a bean is requested by the getBean() method or a reference from other beans.

– Spring will decide which bean instance should be returned according to the bean scope. Sometimes, you have to set an appropriate scope for a bean other than the default scope.

35



Solution

– Singleton

– Prototype

– Request

– Session

– GlobalSession

36


1 2 3 4 5 6 7 8 9 10 11 12 13

package com.apress.springrecipes.shop; public class ShoppingCart { private List<Product> items = new ArrayList<Product>(); public void addItem(Product item) { items.add(item); } public List<Product> getItems() { return items; } }

How It Works

37


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

<beans ...> <bean id="aaa" class="com.apress.springrecipes.shop.Battery"> <property name="name" value="AAA" /> <property name="price" value="2.5" /> </bean> <bean id="cdrw" class="com.apress.springrecipes.shop.Disc"> <property name="name" value="CD-RW" /> <property name="price" value="1.5" /> </bean> <bean id="dvdrw" class="com.apress.springrecipes.shop.Disc"> <property name="name" value="DVD-RW" /> <property name="price" value="3.0" /> </bean> <bean id="shoppingCart" class="com.apress.springrecipes.shop.ShoppingCart" /> </beans>

How It Works

38


1 2 3 4 5 6 7 8 9 10 11 12 13 14

public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Product aaa = (Product) context.getBean("aaa"); Product cdrw = (Product) context.getBean("cdrw"); Product dvdrw = (Product) context.getBean("dvdrw"); ShoppingCart cart1 = (ShoppingCart)context.getBean("shoppingCart"); cart1.addItem(aaa); cart1.addItem(cdrw); System.out.println("Shopping cart 1 contains " + cart1.getItems()); ShoppingCart cart2 = (ShoppingCart)context.getBean("shoppingCart"); cart2.addItem(dvdrw); System.out.println("Shopping cart 2 contains " + cart2.getItems());

How It Works

39

1 2

Shopping cart 1 contains [AAA 2.5, CD-RW 1.5] Shopping cart 2 contains [AAA 2.5, CD-RW 1.5, DVD-RW 3.0]


How It Works

40

1 2 3

<bean id="shoppingCart" class="com.apress.springrecipes.shop.ShoppingCart" scope="singleton" />

1 2 3

<bean id="shoppingCart" class="com.apress.springrecipes.shop.ShoppingCart" scope="prototype" />

1 2

Shopping cart 1 contains [AAA 2.5, CD-RW 1.5] Shopping cart 2 contains [DVD-RW 3.0]


2-7. CUSTOMIZING BEAN INITIALIZATION AND DESTRUCTION

41



Problem

– Many real-world components have to perform certain types of initialization tasks before they are ready to be used. Such tasks include opening a file, opening a network/database connection, allocating memory, and so on.

– They have to perform the corresponding destruction tasks at the end of their life cycle.

– You have a need to customize bean initialization and destruction in the Spring IoC container.

42



Solution

– The Spring IoC container is responsible for managing the life cycle of your beans, and it allows you to perform custom tasks at particular points of their life cycle.

– Your tasks should be encapsulated in callback methods for the Spring IoC container to call at a suitable time.

43



Solution

– 1. Create the bean instance either by a constructor or by a factory method.

– 2. Set the values and bean references to the bean properties.

– 3. Call the initialization callback methods.

– 4. The bean is ready to be used.

– 5. When the container is shut down, call the destruction callback methods.

44


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public class Cashier { private String name; private String path; private BufferedWriter writer; public void openFile() throws IOException { File logFile = new File(path, name + ".txt"); writer = new BufferedWriter(new OutputStreamWriter( new FileOutputStream(logFile, true))); } public void checkout(ShoppingCart cart) throws IOException { double total = 0; for (Product product : cart.getItems()) { total += product.getPrice(); } writer.write(new Date() + "\t" + total + "\r\n"); writer.flush(); } public void closeFile() throws IOException { writer.close(); }

How It Works

45


1 2 3 4 5 6 7

<beans ...> ... <bean id="cashier1" class="com.apress.springrecipes.shop.Cashier"> <property name="name" value="cashier1" /> <property name="path" value="c:/cashier" /> </bean> </beans>

How It Works

46


1 2 3 4 5 6 7 8

public class Main { public static void main(String[] args) throws Exception { ApplicationContext context = new FileSystemXmlApplicationContext("beans.xml"); Cashier cashier1 = (Cashier) context.getBean("cashier1"); cashier1.checkout(cart1); } }

How It Works

47


1 2 3 4 5 6 7 8 9 10

package com.apress.springrecipes.shop; public class Cashier { ... public void openFile() throws IOException { File logFile = new File(path, name + ".txt"); writer = new BufferedWriter(new OutputStreamWriter( new FileOutputStream(logFile, true))); } }

How It Works

48


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package com.apress.springrecipes.shop; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; public class Cashier implements InitializingBean, DisposableBean { . . . public void afterPropertiesSet() throws Exception { openFile(); } public void destroy() throws Exception { closeFile(); } }

InitializingBean and DisposableBean

49


1 2 3 4 5 6 7

<bean id="cashier1" class="com.apress.springrecipes.shop.Cashier" init-method="openFile" destroy-method="closeFile"> <property name="name" value="cashier1" /> <property name="path" value="c:/cashier" /> </bean>

init-method and destroy-method Attributes

50


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package com.apress.springrecipes.shop; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; public class Cashier { . . . @PostConstruct public void openFile() throws IOException { File logFile = new File(path, name + ".txt"); writer = new BufferedWriter(new OutputStreamWriter( new FileOutputStream(logFile, true))); } @PreDestroy public void closeFile() throws IOException { writer.close(); } }

@PostConstruct and @PreDestroy Annotations

51


1 2 3 4 5 6 7 8 9

<beans ...> <bean class="org.springframework.context.annotation. CommonAnnotationBeanPostProcessor" /> <bean id="cashier1" class="com.apress.springrecipes.shop.Cashier"> <property name="name" value="cashier1" /> <property name="path" value="c:/cashier" /> </bean> </beans>

@PostConstruct and @PreDestroy Annotations

52

1 2 3 4 5 6 7 8 9 10

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <context:annotation-config /> </beans>







http://www.springframework.org/schema/context

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd








2-8. REDUCING XML CONFIGURATION WITH JAVA CONFIG

53



Problem

– You enjoy the power of the DI container but want to override some of the configuration, or you simply want to move more configuration out of the XML format and into Java where you can better benefit from refactoring and type safety.

54



Solution

– You can use Java Config, a project which has been in incubation since early 2005 long before Google Guice hit the scene—and has recently been folded into the core framework.

55


1 2 3 4 5 6 7

ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("myApplicationContext.xml"); ... <context:annotation-config /> <context:component-scan base-package="com.my.base.package" /> ...

How It Works

56


1 2 3 4 5 6 7 8 9

@Configuration public class PersonConfiguration { @Bean public Person josh() { Person josh = new Person(); josh.setName("Josh"); return josh; } }

How It Works

57

1 2 3

<bean id="josh" class="com.apress.springrecipes.spring3.javaconfig.Person" p:name="Josh" />


How It Works

58

1 2 3 4 5 6 7 8

@Bean(name="theArtistFormerlyKnownAsJosh") public Person josh() { // … } ApplicationContext context = … ; Person person = context.getBean("theArtistFormerlyKnownAsJosh", Person.class);


How It Works

59

1 2 3 4 5 6

@Bean( initMethod = "startLife", destroyMethod = "die") public Person companyLawyer() { Person companyLawyer = new Person(); companyLawyer.setName("Alan Crane"); return companyLawyer; }

1 2 3 4 5 6 7

@Bean public Person companyLawyer() { Person companyLawyer = new Person(); companyLawyer.startLife() ; companyLawyer.setName("Alan Crane"); return companyLawyer; }


How It Works

60

1 2 3 4 5 6 7 8 9 10 11 12 13 14

@Configuration public class PetConfiguration { @Bean public Cat cat(){ return new Cat(); } @Bean public Person master(){ Person person = new Person() ; person.setPet( cat() ); return person; } // … }


How It Works

61

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

@Configuration @Import(AttorneyConfiguration.class) public class LawFirmConfiguration { @Value("#{denny}") private Attorney denny; @Value("#{alan}") private Attorney alan; @Value("#{shirley}") private Attorney shirley; @Bean public LawFirm bostonLegal() { LawFirm lawFirm = new LawFirm(); lawFirm.setLawyers(Arrays.asList(denny, alan, shirley)); lawFirm.setLocation("Boston"); return lawFirm; } }


2-9. MAKING BEANS AWARE OF THE CONTAINER

62



Problem

– A well-designed component should not have direct dependencies on its container. However, sometimes it’s necessary for your beans to be aware of the container’s resources.

63



Solution

– Your beans can be aware of the Spring IoC container’s resources by implementing certain “aware” interfaces, as shown in Table 2-3. Spring will inject the corresponding resources to your beans via the setter methods defined in these interfaces.

64



Solution

65



Solution

1. Create the bean instance either by a constructor or by a factory method.

2. Set the values and bean references to the bean properties.

3. Call the setter methods defined in the aware interfaces.

4. Call the initialization callback methods.

5. The bean is ready to be used.

6. When the container is shut down, call the destruction callback methods.

66


How It Works

67

1 2 3 4 5 6 7 8 9 10

package com.apress.springrecipes.shop; import org.springframework.beans.factory.BeanNameAware; public class Cashier implements BeanNameAware { . . . public void setBeanName(String beanName) { this.name = beanName; } }

1 2 3 4

<bean id="cashier1" class="com.apress.springrecipes.shop.Cashier"> <property name="path" value="c:/cashier" /> </bean>


2-10. LOADING EXTERNAL RESOURCES

68



Problem

– Sometimes, your application may need to read external resources (e.g., text files, XML files, properties file, or image files) from different locations (e.g., a file system, classpath, or URL).

– Usually, you have to deal with different APIs for loading resources from different locations.

69



Solution

– Spring’s resource loader provides a unified getResource() method for you to retrieve an external resource by a resource path. You can specify different prefixes for this path to load resources from different locations. To load a resource from a file system, you use the file prefix. To load a resource from the classpath, you use the classpath prefix. You may also specify a URL in this resource path.

70


How It Works

71

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class BannerLoader implements ResourceLoaderAware { private ResourceLoader resourceLoader; public void setResourceLoader(ResourceLoader resourceLoader) { this.resourceLoader = resourceLoader; } public void showBanner() throws IOException { Resource banner = resourceLoader.getResource("file:banner.txt"); InputStream in = banner.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(in)); while (true) { String line = reader.readLine(); if (line == null) break; System.out.println(line); } reader.close(); } }


How It Works

72

1 2 3

<bean id="bannerLoader" class="com.apress.springrecipes.shop.BannerLoader" init-method="showBanner" />


Resource Prefixes

Relative path : file:banner.txt

Absolute path: file:c:/shop/banner.txt

Classpath

– classpath:banner.txt

– classpath:com/apress/springrecipes/shop/banner.txt

URL

– http://springrecipes.apress.com/shop/banner.txt

73


Injecting Resources

74

1 2 3 4 5 6 7 8 9 10 11

public class BannerLoader { private Resource banner; public void setBanner(Resource banner) { this.banner = banner; } public void showBanner() throws IOException { InputStream in = banner.getInputStream(); ... } }


Injecting Resources

75

1 2 3 4 5 6 7 8 9

<bean id="bannerLoader" class="com.apress.springrecipes.shop.BannerLoader" init-method="showBanner"> <property name="banner"> <value> classpath:com/apress/springrecipes/shop/banner.txt </value> </property> </bean>


2-11. CREATING BEAN POST PROCESSORS

76



Problem

– You would like to register your own plug-ins in the Spring IoC container to process the bean instances during construction.

77



Solution

– A bean post processor allows additional bean processing before and after the initialization callback method. The main characteristic of a bean post processor is that it will process all the bean instances in the IoC container one by one, not just a single bean instance.

– Typically, bean post processors are used for checking the validity of bean properties or altering bean properties according to particular criteria.

78



Solution

1. Create the bean instance either by a constructor or by a factory method.

2. Set the values and bean references to the bean properties.

3. Call the setter methods defined in the aware interfaces.

4. Pass the bean instance to the postProcessBeforeInitialization() method of each bean post processor.

79



Solution

5. Call the initialization callback methods

6. Pass the bean instance to the postProcessAfterInitialization()method of each bean post processor.

7. The bean is ready to be used.

8. When the container is shut down, call the destruction callback methods.

80


How It Works

Suppose you would like to ensure that the logging path of Cashier exists before the logging file is open.

This is to avoid FileNotFoundException. As this is a common requirement for all components that require storage in the file system, you had better implement it in a general and reusable manner.

A bean post processor is an ideal choice to implement such a feature in Spring.

81


How It Works

82

1 2 3 4 5

package com.apress.springrecipes.shop; public interface StorageConfig { public String getPath(); }

1 2 3 4 5 6 7 8

package com.apress.springrecipes.shop; public class Cashier implements BeanNameAware, StorageConfig { public String getPath() { return path; } }


How It Works

83

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class PathCheckingBeanPostProcessor implements BeanPostProcessor { public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof StorageConfig) String path = ((StorageConfig) bean).getPath(); File file = new File(path); if (!file.exists()) { file.mkdirs(); } } return bean; } public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } }


How It Works

84

1 2 3 4 5 6 7 8 9 10 11 12

<beans ...> ... <bean class="com.apress.springrecipes.shop.PathCheckingBeanPostProcessor" /> <bean id="cashier1" class="com.apress.springrecipes.shop.Cashier" init-method="openFile" destroy-method="closeFile"> ... </bean> </beans>


How It Works

If the cashier bean relies on the JSR-250 annotations @PostConstruct and @PreDestroy, and also a CommonAnnotationBeanPostProcessor instance to call the initialization method, your PathCheckingBeanPostProcessor will not work properly.

Your bean post processor has a lower priority than CommonAnnotationBeanPostProcessor by default.

The initialization method will be called before your path checking.

85


How It Works

86

1 2 3 4 5 6 7 8 9 10 11 12

public class PathCheckingBeanPostProcessor implements BeanPostProcessor, PriorityOrdered { private int order; public int getOrder() { return order; } public void setOrder(int order) { this.order = order; } }


How It Works

87

1 2 3 4 5 6 7 8 9 10 11 12 13

<beans ...> ... <bean class="org.springframework.context.annotation. CommonAnnotationBeanPostProcessor" /> <bean class="com.apress.springrecipes.shop. PathCheckingBeanPostProcessor"> <property name="order" value="0" /> </bean> <bean id="cashier1" class="com.apress.springrecipes.shop.Cashier"> <property name="path" value="c:/cashier" /> </bean> </beans>


2-12. EXTERNALIZING BEAN CONFIGURATIONS

88



Problem

– When configuring beans in the configuration file, you must remember that it’s not a good practice to mix deployment details, such as the file path, server address, username, and password, with your bean configurations.

– Usually, the bean configurations are written by application developers while the deployment details are matters for the deployers or system administrators.

89



Solution

– Spring comes with a bean factory post processor called PropertyPlaceholderConfigurer for you to externalize part of the bean configurations into a properties file. You can use variables of the form ${var} in your bean configuration file.

– PropertyPlaceholderConfigurer will load the properties from a properties file and use them to replace the variables.

90


How It Works

91

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

config.properties cashier.path=c:/cashier ----------------------------------------------- <beans ...> ... <bean class="org.springframework.beans.factory.config. PropertyPlaceholderConfigurer"> <property name="location"> <value>config.properties</value> </property> </bean> <bean id="cashier1" class="com.apress.springrecipes.shop.Cashier"> <property name="path" value="${cashier.path}" /> </bean> </beans>


Summary

Various ways of creating a bean, which include invoking a constructor, invoking a static/instance factory method, using a factory bean, and retrieving it from a static field/object property.

Customize the initialization and destruction of your beans by specifying the corresponding callback methods.

Certain advanced IoC container features, such as externalizing bean configuration into properties files

92


Tài liệu tham khảo

Slide bài giảng này được trích từ sách:

– Spring Recipes: A Problem-Solution Approach by Gary Mak, Daniel Rubio and Josh Long (Sep 1, 2010).

93


HỎI VÀ ĐÁP

94

Documents

17. Spring Framework - Spring IoC - Advance