What is ApplicationContext? What are its implementations?

Tweet

ApplicationContext, like BeanFactory, is also used to represent Spring Container. It is built upon BeanFactory interface.

BeanFactory provides basic functionality while ApplicationContext provides advance features to our spring applications which make them enterprise level applications, like i18n, event publishing, JNDI access, EJB integration, Remoting etc.

ApplicationContext is always preferred over BeanFactory and is suitable for J2EE Applications. ApplicationContext includes all functionality of the BeanFactory.

ApplicationContext and Singleton beans:

While using BeanFactory, beans get instantiated when they get requested first time, like in getBean("bean_id") method, not when object of BeanFactory itself gets created. This is known as lazy-instantiation.

But while using ApplicationContext, singleton beans does not get created lazily. By default, ApplicationContext immediately instantiates the singleton beans and wire/set its properties as it's object itself gets created. So ApplicationContext loads singleton beans eagerly (pre-instantiated).

Example:

ApplicationContext acObj=new ClassPathXmlApplicationContext("beanconfig.xml");

MyBean beanObj=(MyBean)acObj.getBean("mybean");

beanObj.someMethod();

In above example we have created an ApplicationContext object acObj using one if its implementations ClassPathXmlApplicationContext which loads the configuration from source beanconfig.xml under classpath.

If we had used BeanFactory here, mybean would get instantiated when the method getBean(mybean) would  be called.

But here with ApplicationContext, instantiation of bean with id mybean does not get delayed until getBean() method is called. If scope of the bean mybean  is declared in configuration file as singleton, it will be immediately instantiated when we create ApplicationContext object acObj. So when getBean() would be called, mybean would already have got loaded and its dependencies set.

We can change this default behavior so that ApplicationContext does not load singleton beans eagerly by using  lazy-init attribute as:

<bean id="mybean" class="x.y.z..MyBean" lazy-init="true"/>

A lazy-initialized bean tells the Spring to create a bean instance when it is first requested, rather than at the time of creation of ApplicationContext object.

Implementations of ApplicationContext:

There are many implementations of ApplicationContext interface. Important ones are:

1)  ClassPathXmlApplicationContext:

It loads bean definitions from XML files located in the classpath.

           

Example1:

ApplicationContext context = new ClassPathXmlApplicationContext("myconfig.xml");

Example2:  Loading configuration from multiple files under classpath.

ApplicationContext context = new ClassPathXmlApplicationContext(

newString[]{"servicesconfig.xml","daoconfig.xml"});

2) FileSystemXmlApplicationContext:

            It loads bean definitions from XML files in the file system.

           

Example:        

           

ApplicationContext context = new FileSystemXmlApplicationContext("c:/myconfig.xml");

3)XmlWebApplicationContext:

XmlWebApplicationContext is used to represent Spring Container for web applications.By defalut Spring creates object of XmlWebApplicationContext class to represent application context/spring container for web applications.

It loads bean definitions from an XML file contained within a web application. By default it loads the configuration from file "/WEB-INF/applicationContext.xml".

If we want to load bean definitions from more than one xml files we can specify their locations in  contextConfigLocation  parameter of ContextLoaderListener or DispatcherServlet in web.xml.Read more about this here.

XmlWebApplicationContext is an implementation of WebApplicationContext interface which in turn extends ApplicationContext interface.

4)AnnotationConfigApplicationContext:

AnnotationConfigApplicationContext class is used when we are using Java-based configuration for the bean definitions instead of Xml files.

In above ApplicationContext implementations (ClassPathXmlApplicationContext, FileSystemXmlApplicationContext) we have supplied bean configuration from xml configuration files. AnnotationConfigApplicationContext class is used to create Spring container which takes bean definitions from java classes annotated with @Configuration, instead of xml files.

It is introduced in Spring 3.0.

Example:

public static void main(String[]args){

/* Creating Spring IoC Container Without XML configuration file*/

ApplicationContext context= new AnnotationConfigApplicationContext(MyConfig.class);

MyBean beanObj = context.getBean(MyBean.class);

beanObj.someMethod();

}

In above code, AnnotationConfigApplicationContext is accepting MyConfig class as input. Here we are obtaining bean definitions from a java class named MyConfig annotated with @Configuration, instead of a Xml file. MyConfig class is described as:

@Configuration

public class MyConfig{

            @Bean

            public MyBean myBeanId(){

            return new MyBean();

            }

}

By giving @Configuration annotation we are treating Myconfig class as  <beans></beans>  tag of xml file.

By giving @Bean annotation we are treating myBean() method as  <bean id="..." class="..."/>

Name of myBeanId() method will be treated as bean id.

Both @Configuration and @Bean are also introduced in Spring 3.0.

5)AnnotationConfigWebApplicationContext:

Like XmlWebApplicationContext is web counterpart for the ClassPathXmlApplicationContext and FileSystemXmlApplicationContext and is used to create application context for web  applications, similarly, AnnotationConfigWebApplicationContext is web counterpart for AnnotationConfigApplicationContext.

AnnotationConfigWebApplicationContext is used to create application context for web applications by using java clases as input for bean definitions instead of xml files.

By default Spring use XmlWebApplicationContext (an implementation of WebApplicationContext) for creating spring container in web applications. But we can change this default value to AnnotationConfigWebApplicationContext by changing the value of contextClass parameter of ContextLoaderListener or DispatcherServlet in web.xml as shown below:

For ContextLoaderListener:

<web-app>

<context-param>

<param-name>contextClass</param-name> 

<param-value>   

org.springframework.web.context.support.AnnotationConfigWebApplicationContext

</param-value> 

</context-param> 

<context-param>

<param-name>contextConfigLocation</param-name> 

<!--MyConfig must be annotated with @Configuration-->

<param-value> MyConfig</param-value>

</context-param>

<listener>

<listener-class> org.springframework.web.context.ContextLoaderListener </listener-class>

</listener> 

</web-app> 

For  DispatcherServlet:

<web-app>

<servlet>

<servlet-name>mydispatcher</servlet-name>

<servlet-class > org.springframework.web.servlet.DispatcherServlet

</servlet-class>

<init-param> 

<param-name>contextClass</param-name> 

<param-value>            

 org.springframework.web.context.support.AnnotationConfigWebApplicationContext     

</param-value>

</init-param> 

<init-param>   

<param-name>contextConfigLocation</param-name>    

<!--MyConfig must be class annotated with @Configuration-->

<param-value> MyConfig </param-value>

</init-param>

</servlet>

<servlet-mapping> 

<servlet-name>mydispatcher</servlet-name>    

<url-pattern>*.htm</url-pattern>

</servlet-mapping>

</web-app>

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Tweet

What is Bean Factory and XmlBeanFactory?

Tweet

BeanFactory is represented by org.springframework.beans.factory.BeanFactory interface.It is the main and the basic  way to access the Spring container.Other ways to access the spring container such as ApplicationContext,ListableBeanFactory, ConfigurableBeanFactory etc. are built upon this BeanFactory interface (extends/implements BeanFactory interface).

BeanFactory interface provides basic functionality for the Spring Container like:

1)It provides DI / IOC mechanism for the Spring.

2)It is built upon Factory Design Pattern.

3)It loads the beans definitions and their property descriptions from some configuration source (for example, from XML configuration  file) .

4)Instantiates the beans when they are requested like beanfactory_obj.getBean("beanId").

5)Wire dependencies and properties for the beans according to their configuration defined in configuration source while instantiating the beans.

6)Manage the bean life cycle by bean lifecycle interfaces and calling initialization and destruction methods.

(Note that BeanFactory does not create the objects of beans immediately when it loads the configuration for beans from configuration source.Only bean definitions and their property descriptions are loaded. Beans themselves are instantiated  and their properties are set only when they are requested such as by getBean() method.)

BeanFactory Implementations:

The most important BeanFactory implementation is –org.springframework.beans.factory.xml.XmlBeanFactory.It reads bean definitions from an XML file.

Constructor for XmlBeanFactory:

XmlBeanFactory(Resource resource)

Example1:

BeanFactory bfObj = new XmlBeanFactory(new FileSystemResource ("c:/beansconfig.xml"));

MyBean beanObj= (MyBean) bfObj.getBean("mybean");

In above code BeanFactory object bfObj is representing a Spring IOC container.

XmlBeanFactory constructor takes an implementation of Resource interface as an argument.

Here we have used FileSystemResource which is one of the implementations of Resource interface.

The Resource interface has many implementaions. Two mainly used are:

1)org.springframework.core.io.FileSystemResource:
              Loads the resource from underlying file system.

2)org.springframework.core.io.ClassPathResource:
              Loads the resource from classpath(shown below).

Purpose of FileSystemResource is to provide the xml file with the given name from underlying file system to XmlBeanFactory.

Now,  bfObj represents a Spring Container which has loaded the bean definitions from the beansconfig.xml file.

At this point only beans definitions got loaded but bean themselves are not instantiated yet.

At the second line,

MyBean beanObj = (MyBean) bfObj.getBean("mybean");

We are requesting from spring container a bean with id "mybean". BeanFactory will read bean definition of a bean with id "mybean" from beansconfig.xml file, instantiates it and return a reference to that. Thus BeanFactory loads the beans lazily.

Example2:

ClassPathResource resorce = new ClassPathResource ("beansconfig.xml");

BeanFactory factory = new XmlBeanFactory(resource);

Example3:

ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(

        new String[] {"applicationContext.xml", "applicationContext-part2.xml"});

// an ApplicationContext is also  a BeanFactory.

BeanFactory factory = (BeanFactory) appContext;

Example4:

BeanFactory factory = new XmlBeanFactory(new FileInputStream("beansconfig.xml"));???

Note: BeanFactory is not recomended for use in latest Spring versions. It is there only for backward compatability. ApplicationContext is preferred over this because ApplicationContext provides more advance level features which makes an application enterprise level application.

I would like to know your comments and if you liked the article then please share it on social networking buttons.

Tweet