21.What are the common implementations of the Application Context ?

   The three commonly used implementation of 'Application Context' are

• ClassPathXmlApplicationContext : It Loads context definition from an XML file located in the classpath, treating context definitions as classpath resources. The application context is loaded from the application's classpath by using the code .

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
• FileSystemXmlApplicationContext : It loads context definition from an XML file in the filesystem. The application context is loaded from the file system by using the code .

ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");
• XmlWebApplicationContext : It loads context definition from an XML file contained within a web application.

22. How is a typical spring implementation look like ?

• An interface that defines the functions.

• An Implementation that contains properties, its setter and getter methods, functions etc.,

• Spring AOP (Aspect Oriented Programming)

• A XML file called Spring configuration file.

• Client program that uses the function.

23. What is the typical Bean life cycle in Spring Bean Factory Container ?

   Bean life cycle in Spring Bean Factory Container is as follows:

:

• The spring container finds the bean’s definition from the XML file and instantiates the bean.

• Using the dependency injection, spring populates all of the properties as specified in the bean definition

• If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.

• If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.

• If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called.

• If an init-method is specified for the bean, it will be called.

• Finally, if there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

24. What do you mean by Bean wiring ?

The act of creating associations between application components (beans) within the Spring container is reffered to as Bean wiring.

25. What do you mean by Auto Wiring?

   The Spring container is able to autowire relationships between collaborating beans. This means that it is possible to automatically let Spring resolve collaborators (other beans) for your bean by inspecting the contents of the BeanFactory. The autowiring functionality has five modes.

• no

• byName

• byType

• constructor

• autodirect

26. What is DelegatingVariableResolver?

       Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard Java Server Faces managed beans mechanism which lets you use JSF and Spring together. This variable resolver is called as DelegatingVariableResolver

27. How to integrate Java Server Faces (JSF) with Spring?

   JSF and Spring do share some of the same features, most noticeably in the area of IOC services. By declaring JSF managed-beans in the faces-config.xml configuration file, you allow the FacesServlet to instantiate that bean at startup. Your JSF pages have access to these beans and all of their properties. We can integrate JSF and Spring in two ways:

• DelegatingVariableResolver: Spring comes with a JSF variable resolver that lets you use JSF and Spring together.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
   "http://www.springframework.org/dtd/spring-beans.dtd">

<faces-config>
   <application>
      <variable-resolver>
         org.springframework.web.jsf.DelegatingVariableResolver
      </variable-resolver>
   </application>
</faces-config>



The DelegatingVariableResolver will first delegate value lookups to the default resolver of the underlying JSF implementation, and then to Spring's 'business context' WebApplicationContext. This allows one to easily inject dependencies into one's JSF-managed beans.

• FacesContextUtils:custom VariableResolver works well when mapping one's properties to beans in faces-config.xml, but at times one may need to grab a bean explicitly. The FacesContextUtils class makes this easy. It is similar to WebApplicationContextUtils, except that it takes a FacesContext parameter rather than a ServletContext parameter.

ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());

28. What is Java Server Faces (JSF) - Spring integration mechanism?

Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard JavaServer Faces managed beans mechanism. When asked to resolve a variable name, the following algorithm is performed:

• Does a bean with the specified name already exist in some scope (request, session, application)? If so, return it
• Is there a standard JavaServer Faces managed bean definition for this variable name? If so, invoke it in the usual way, and return the bean that was created.
• Is there configuration information for this variable name in the Spring WebApplicationContext for this application? If so, use it to create and configure an instance, and return that instance to the caller.
• If there is no managed bean or Spring definition for this variable name, return null instead.
• BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.

As a result of this algorithm, you can transparently use either JavaServer Faces or Spring facilities to create beans on demand.

29. What is Significance of JSF- Spring integration ?

Spring - JSF integration is useful when an event handler wishes to explicitly invoke the bean factory to create beans on demand, such as a bean that encapsulates the business logic to be performed when a submit button is pressed.

30. How to integrate your Struts application with Spring?

To integrate your Struts application with Spring, we have two options:

Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set their dependencies in a Spring context file.

Subclass Spring's ActionSupport classes and grab your Spring-managed beans explicitly using a getWebApplicationContext() method.

31.What is Spring Framework? What are it’s main modules?

The Spring Framework is a Java platform that provides comprehensive infrastructure support for developing Java applications.
Spring handles the infrastructure part so you can focus on your application part.
Inside itself, Spring Framework codifies formalized design patterns as first-class objects
that you can integrate into your own application(s) without worrying too much about how they work in backend.
At present, Spring Framework consists of features organized into about 20 modules.
These modules are grouped into Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming),
Instrumentation, Messaging, and Test, as shown in the following diagram.

32.Difference between BeanFactory and ApplicationContext?

A BeanFactory is like a factory class that contains a collection of beans.
The BeanFactory holds Bean Definitions of multiple beans within itself and then instantiates the bean whenever asked for by clients.
BeanFactory is able to create associations between collaborating objects as they are instantiated.
This removes the burden of configuration from bean itself and the beans client.
BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods. On the surface, an application context is same as a bean factory.
Both load bean definitions, wire beans together, and dispense beans upon request.
But it also provides:
A means for resolving text messages, including support for internationalization.
A generic way to load file resources.
Events to beans that are registered as listeners.
The three commonly used implementations of ApplicationContext are:
ClassPathXmlApplicationContext : It Loads context definition from an XML file located in the classpath, treating context definitions as classpath resources.
The application context is loaded from the application’s classpath by using the code.
ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);
FileSystemXmlApplicationContext : It loads context definition from an XML file in the filesystem.
The application context is loaded from the file system by using the code.
ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);
XmlWebApplicationContext : It loads context definition from an XML file contained within a web application.

33.What is Spring XML-Based Configuration?

In Spring framework, dependencies and the services needed by beans are specified in configuration files,
which are typically in an XML format.
These configuration files usually start with tag and contain a lot of bean definitions AND application specific configuration options.
The main goal of Spring XML Configuration is to have all the Spring components configured by using xml files.
This means that there will not be present any other type of Spring Configuration (like annotations or configuration via Java classes).
A Spring XML Configuration uses Spring namespaces to make available the sets of XML tags used in the configuration;
the main Spring namespaces are: context, beans, jdbc, tx, aop, mvc, aso.

And simplest web.xml file to make your application load configuration file and configure the runtime components for you is below where you configure only DispatcherServlet.

Archetype Created Web Application

spring

org.springframework.web.servlet.DispatcherServlet

1


spring
/

34.What is Spring Annotation-based Configuration?

Starting from Spring 2.5 it became possible to configure the dependency injection using annotations.
So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself
by using annotations on the relevant class, method, or field declaration.
Annotation injection is performed before XML injection, thus the latter configuration will override the
former for properties wired through both approaches.
Annotation wiring is not turned on in the Spring container by default.
So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file.
So consider to have following configuration file in case you want to use any annotation in your Spring application.



Once is configured, you can start annotating your code to indicate
that Spring should automatically wire values into properties, methods, and constructors.
Few important annotations which you will be using in this type of configuration are :
@Required : The @Required annotation applies to bean property setter methods.
@Autowired : The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties.
@Qualifier : The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired.
JSR-250 Annotations : Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations.

35.How can you inject a Java Collection in Spring? Give example?

Spring offers four types of collection configuration elements which are as follows:
: This helps in wiring ie injecting a list of values, allowing duplicates.
: This helps in wiring a set of values but without any duplicates.

36.Explain @Required annotation with example?

In a production-scale application, there may be hundreds or thousands of beans declared in the IoC container,
and the dependencies between them are often very complicated.
One of the shortcomings of setter injection is that it’s very hard for you to check if all required properties have been set or not.
To overcome this problem, you can set “dependency-check” attribute of and set one of four attributes i.e. none, simple, objects or all (none is default option).
In real life application, you will not be interested in checking all the bean properties configured in your context files.
Rather you would like to check if particular set of properties have been set or not in some specific beans only.
Spring’s dependency checking feature using “dependency-check” attribute, will not able to help you in this case.
So solve this problem, you can use @Required annotation.
To Use the @Required annotation over setter method of bean property in class file as below:
public class EmployeeFactoryBean extends AbstractFactoryBean