BeanFactoryPostProcessor in Spring

Customizing beans with BeanPostProcessors

In previous chapter we have been seen that how to Customizing beans with BeanPostProcessors:
A   bean   post-processor   is   a    java   class   which   implements    the org.springframework.beans.factory.config.BeanPostProcessor interface, which consists of two callback methods 
(postProcessAfterInitialization(Object bean, String beanName) & postProcessBeforeInitialization(Object bean, String beanName)).

When such a class is registered as a post-processor with the BeanFactory, for each bean instance that is created by the BeanFactory, the post-processor will get a callback from the BeanFactory before any initialization methods (afterPropertiesSet and any declared init method) are called, and also afterwords.

Customizing bean factories with BeanFactoryPostProcessors
A   bean   factory    post-processor    is    a    java   class    which   implements   the org.springframework.beans.factory.config.BeanFactoryPostProcessor interface. It is executed manually (in the case of the BeanFactory) or automatically (in the case of the ApplicationContext) to apply changes of some sort to an entire BeanFactory, after it has been constructed.
 Spring includes a number of pre-existing bean factory post-processors, such as given below

PropertyResourceConfigurer and PropertyPlaceHolderConfigurer – implemented as a bean factory post-processor, is used to externalize some property values from a BeanFactory definition, into another separate file in Java Properties format. This is useful to allow to developer to declare some key property as properties file. As given below example show the database connection related information in the following property file.
Now in the bean configuration file has the dataSource bean as below.

<bean class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" id="dataSource">
  <property name="driverClassName" value="${jdbc.driverClassName}">
  <property name="url" value="${jdbc.url}">
  <property name="username" value="${jdbc.username}">
  <property name="password" value="${jdbc.password}">

To use this with a BeanFactory, the bean factory post-processor is manually executed on it:

XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("spring.xml"));
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.setLocation(new FileSystemResource(""));

To use this with a ApplicationContext, the bean factory post-processor is automatically executed on it:

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Now see the full running application which using BeanFactoryPostProcessor interceptor to config the BeanFactory at time of initialization.

package com.dineshonjava.sdnext.beanFactoryPP.tutorial;

public class Triangle
 private Point pointA;
 private Point pointB;
 private Point pointC;
  * @param pointA the pointA to set
 public void setPointA(Point pointA) {
  this.pointA = pointA;

  * @param pointB the pointB to set
 public void setPointB(Point pointB) {
  this.pointB = pointB;

  * @param pointC the pointC to set
 public void setPointC(Point pointC) {
  this.pointC = pointC;

 public void draw()
System.out.println("PointA is ("+pointA.getX()+", "+pointA.getY()+")");
System.out.println("PointB is ("+pointB.getX()+", "+pointB.getY()+")");
System.out.println("PointC is ("+pointC.getX()+", "+pointC.getY()+")");

package com.dineshonjava.sdnext.beanFactoryPP.tutorial;

public class Point
 private int x;
 private int y;
  * @return the x
 public int getX() {
  return x;
  * @param x the x to set
 public void setX(int x) {
  this.x = x;
  * @return the y
 public int getY() {
  return y;
  * @param y the y to set
 public void setY(int y) {
  this.y = y;
Now define the bean configuration file.


<beans xmlns:aop="" xmlns:p="" xmlns:security="" xmlns:tx="" xmlns:xsi="" xmlns="" xsi:schemalocation="">
<bean autowire="byName" class="com.dineshonjava.sdnext.beanFactoryPP.tutorial.Triangle" id="triangle"></bean>
<bean class="com.dineshonjava.sdnext.beanFactoryPP.tutorial.Point" id="pointA">
   <property name="x" value="0"></property>
   <property name="y" value="0"></property>
<bean class="com.dineshonjava.sdnext.beanFactoryPP.tutorial.Point" id="pointB">
   <property name="x" value="-20"></property>
   <property name="y" value="0"></property>
<bean class="com.dineshonjava.sdnext.beanFactoryPP.tutorial.Point" id="pointC">
   <property name="x" value="${pointC.x}"></property>
   <property name="y" value="${pointC.y}"></property>
<bean class="com.dineshonjava.sdnext.beanFactoryPP.tutorial.BeanFactoryPPDemo"></bean>
In the above configuration file, bean id “pointC” have the two properties x and y the value of these two properties read from the property file ( given below

Now define a class which implement the BeanFactoryPostProcessor interface for the config the bean factory at the time of initialization with given property file value.

package com.dineshonjava.sdnext.beanFactoryPP.tutorial;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

public class BeanFactoryPPDemo implements BeanFactoryPostProcessor  
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
 PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();  
 cfg.setLocation(new FileSystemResource(""));  
 System.out.println("Bean factory post processor is initialized");
If every thing is Ok then run the following main application file and see the console.

package com.dineshonjava.sdnext.beanFactoryPP.tutorial;

import org.springframework.context.ApplicationContext;

 * @author Dinesh Rajput
public class DrawingApp 
  * @param args
 public static void main(String[] args) 
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Triangle triangle = (Triangle) context.getBean("triangle");

Jul 5, 2012 12:43:27 AM prepareRefresh
INFO: Refreshing startup date [Thu Jul 05 00:43:27 IST 2012]; root of context hierarchy
Jul 5, 2012 12:43:27 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring.xml]
Jul 5, 2012 12:43:27 AM loadProperties
INFO: Loading properties file from file [F:my]

Bean factory post processor is initialized

Jul 5, 2012 12:43:27 AM preInstantiateSingletons

INFO: Pre-instantiating singletons in defining beans [triangle,pointA,pointB,pointC,com.dineshonjava.sdnext.beanFactoryPP.tutorial.BeanFactoryPPDemo#0]; root of factory hierarchy
PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)

See the project structure for that application.
BeanFactoryPostProcessor in Spring

In Next Chapter we will discuss about the Coding To Interfaces in Spring.
Spring Related Topics you may like

  1. Spring Interview Questions and Answers
  2. Spring AOP Interview Questions and Answers
  3. Spring MVC Interview Questions
  4. Spring Security Interview Questions and Answers
  5. Spring REST Interview Questions and Answers
  6. Spring Boot Interview Questions and Answers
  7. Spring Boot Microservices Interview Questions and Answers
  8. Dependency Injection (DI) in Spring
  9. Spring IoC Container
  10. What is Bean Factory in Spring
  11. ApplicationContext in Spring
  12. Bean Autowiring in Spring
  13. Spring Bean Scopes
  14. Create Custom Bean Scope in Spring Example
  15. Using ApplicationContextAware in Spring
  16. Spring Bean Life Cycle and Callbacks
  17. BeanPostProcessor in Spring
  18. BeanFactoryPostProcessor in Spring
  19. Annotations in Spring and Based Configuration
  20. Spring JSR-250 Annotations
  21. JSR 330 Annotations in Spring
  22. Spring @Component, @Repository, @Service and @Controller Stereotype Annotations
  23. Method injection with Spring using Lookup method property
  24. Spring AOP-Introduction to Aspect Oriented Programming
  25. @Aspect Annotation in Spring
  26. Spring AOP AspectJ @Before Annotation Advice Example
  27. Spring AOP Before Advice Example using XML Config
  28. Spring AOP AspectJ @After Annotation Advice Example
  29. Spring AOP After Advice Example using XML Config
  30. Spring AOP AspectJ @AfterReturning Annotation Advice Example
  31. Spring AOP After-Returning Advice Example using XML Config
  32. Spring AOP AspectJ @AfterThrowing Annotation Advice Example
  33. Spring AOP After Throwing Advice Example using XML Config
  34. Spring AOP AspectJ @Around Annotation Advice Example
  35. Spring AOP Around Advice Example using XML Config
  36. Spring AOP Proxies in Spring
  37. Spring AOP Transaction Management in Hibernate
  38. Spring Transaction Management
  39. Spring Declarative Transaction Management Example
  40. Spring AOP-Ordering of Aspects with Example
  41. Spring Security Java Based Configuration with Example
  42. Spring Security XML Namespace Configuration Example
                          << Previous || Next >>