Spring ApplicationContext

In this tutorial we will know what is spring ApplicationContext and how to access it. There are numerous different ways to get a task done in Spring framework and that is one advantage of it.

What is

ApplicationContext

?

ApplicationContext

is an interface for providing configuration information to an application. There are multiple classes provided by springframework that implements this interface and helps us use configuration information in applications.

ApplicationContext

provides standard bean factory lifecycle capabilities. An important capability which we will be using in below code example is, class implementing

ApplicationContext

should scan for

ApplicationContextAware

beans and invoke

setApplicationContext

by passing an implementation of its instance.

ApplicationContext

vs

BeanFactory

BeanFactory

is a subset of

ApplicaitonContext

and provides lesser functionalities. When we need full capabilities with respect to configuration handling then we go for

ApplicationContext

.

How to access

ApplicationContext

inside a java bean?

To get access to

ApplicationContext

we should implement

ApplicationContextAware

interface in the respective java bean. It has a method,

void setApplicationContext(ApplicationContext applicationContext)
throws BeansException

The

ApplicationContext

implementation which we are using in our application will invoke this method and pass the concrete object for

AppplicationContext

. Using this we can get access to all the configuration information.

In the case of spring web application we have a utility class provided by spring framework called

WebApplicationContextUtils

.

ServletContext servletContext = this.getServletContext();

WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

We can use this utility to get application context but we need to provide the respective servletcontext as parameter. Following source code demonstrates how we can get access to application context even from inside a simple plain java bean where we don’t have access to servlet context.

Sample to Access ApplicationContext

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation=" http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 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">

<bean id="applicationContextUtils" class="com.javapapers.spring.ApplicationContextUtils"></bean>

<bean id="helloWorld" class="com.javapapers.spring.HelloWorld" />

<bean id="strHelloWorld" class="java.lang.String">
<constructor-arg value="Hello World" />
</bean>

</beans>

ApplicationContextUtils.java

We will create the following utility class, it implements

ApplicationContextAware

and provides the

setApplicationContext

which will be invoked by spring container and the

applicationContext

will be passed by it. We store it in a static variable and expose it through a get method so that it can be accessed all through the application.

package com.javapapers.spring;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class ApplicationContextUtils implements ApplicationContextAware {

private static ApplicationContext ctx;

@Override
public void setApplicationContext(ApplicationContext appContext)
throws BeansException {
ctx = appContext;

}

public static ApplicationContext getApplicationContext() {
return ctx;
}
}

HelloWorld.java

This is a simple java bean which uses our utility method to get access to the

ApplicationContext

.

package com.javapapers.spring;

import org.springframework.context.ApplicationContext;

public class HelloWorld {

public String getValueFromContext(String beanName) {
ApplicationContext appCtx = ApplicationContextUtils
.getApplicationContext();
String strFromContext = (String) appCtx.getBean(beanName);
return strFromContext;
}
}

TestAppContext.java

This example is based on a simple java application (not a web application). It uses

ClassPathXmlApplicationContext

which implements

ApplicationContext

.

package com.javapapers.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAppContext {

public static void main(String[] args) {
ApplicationContext appContext = new ClassPathXmlApplicationContext(
"META-INF/spring-context.xml");
HelloWorld hw = (HelloWorld) appContext.getBean("helloWorld");

String output = hw.getValueFromContext("strHelloWorld");
System.out.print(output);
}
}

Lazy-instantiation and

ApplicationContext

By default spring implementations of

ApplicationContext

eagerly instantiate all the singleton beans at startup. This helps us to ensure all the configuration and dependencies are intact. This default behaviour can be customized as below by just adding property

lazy-init=”true”

.

<bean id="lazy" class="com.javapapers.LazyBean" lazy-init="true"/>

When the

ApplicationContext

is starting up this bean will not be instantiated and configured.

Annotation Based Access

Spring 2.5 onwards we can autowire the

ApplicationContext

as well as

BeanFactory

as below,

private @Autowired ApplicationContext appContext;
private @Autowired BeanFactory beanFactory;