Written By : ISHTEK
Title :
Spring singleton

Description :
Spring Container Example
More...

Written By : ISHTEK
Title :
Spring Features Updates News

Description :
Bringing To Page
More...

Written By : ISHTEK
Title :
Spring Service

Description :
Web Service Example
More...

Written By : ISHTEK
Title :
Spring WebService

Description :
Example Code Discussed
More...

Written By : Amit
Title :
Spring Web MVC

Description :
Example code discussed
More...

Written By : ISHTEK
Title :
Spring Remote Stateless SessionBean

Description :
Calling SessionBean Example code
More...

Written By : ISHTEK
Title :
Spring Local Stateless SessionBean

Description :
Calling Local SessionBean Example code
More...

Written By : guddu
Title :
Struts 2 Spring

Description :
Integration Example and Details
More...

Commented By ->
Amit

Friends!!

Please find here with my comment, some of the questions may be asked
in an interview session for SpringFramework .

Please correct me if any of these questions/corresponding answer
is not correct/applicable.

Spring interview question 1:
How can Circular dependencies occur while using Sprin IOC, give an example?

Spring interview answer :
If a bean has another bean as argument type in constructor, and vice versa
(the later bean has the former bean as argument type passed in constructor),
then a Circular dependencies can occur. In this circular dependency, Spring will
throw BeanCurrentlyInCreateionException, if the constructor injection is used.

Spring interview question 2:
How to avoid BeanCurrentlyInCreateionException being thrown at runtime,
or how to avoid a circular dependency to be found by Spring at runtime?

Spring interview answer :
One way is to avoid using constructor injection, instead going for setter
injection will be good idea (of course one has to look at other aspects
of the requirement as well before deciding which type of injection to be
used), to avoid BeanCurrentlyInCreateionException from Spring at runtime.

Spring interview question 3:
While using SpringFramework, can a bean be declared as anonymous?

Spring interview answer :
Yes, it is possible to define bean as anonymous, by defining bean inside 
<property> and inside <constructor-arg> tags when defined within
bean tag.

Spring interview question 4:
What is the default scope for the Bean that is defined as anonymous?

Spring interview answer :
Scope is prototype for any bean defined anonymous within property and constructor
tags.

Spring interview question 5:
What are the various Spring elements those can be used with Java Collection types
such as List, Set, Map and Properties?

Spring interview answer :

<list>, <set>, <map> and <props> tags can be with these 
Java Collection types, such as List, Set, Map and Properties.

Commented By ->
Amit

Spring Interview Question :
Which version onwards Spring has Annotation support?

Spring Interview Answer :
Spring version 2.5 onwards has the annotation based configuration
support.

Spring Interview Question :
How do you configure in your application that uses Spring
for using annotation based POJO or Bean coding?

Spring Interview Answer
Generally the Spring configuration XML file, if has a tag as

>config:annotation-config< where config is the schema definition
for the spring context URI such as 
http://www.springframework.org/schema/context

Spring Interview Question
Which annotation that can be along with a constructor, field, setter method
or config methods for enabling Spring' dependency injection along with bean?

Spring Interview answer
@Autowired can be used along with a constructor, field, setter method
or config methods of bean for enabling Spring' dependency injection.

Spring interview question
What is a config method of a bean, can you please elaborate it a bit more,
how is it applicable to any argument(s) of the config method?

Spring interview answer
config method are the custom methods not of setter type, and it can have
any arbitrary number of argument(s) and each of the argument(s) will 
be autowired with matching bean in the Spring container.

Let me show an example showing how to auto wire dependency
beans by using @Autowired annotation and this is using
Spring Framework 3.0 version.

After creating a very simple example with basic Spring
configuration file and setting some of the bean definition
I could able to grasp how this @Autowired annotation works
to some extend. If interested I shall show this in below
writing, please read on if interested.

There will a custom example class as SampleBean and it uses
two custom example class files such as Example and Config
and one java.util.Properties class file.

let us look at the SampleBean as follows:
example.SampleBean
package example;

import java.util.Properties;

public class SampleBean {
  @org.springframework.beans.factory.annotation.Autowired
  private Example example;
  private Config confg;
  private Properties props;
  @org.springframework.beans.factory.annotation.Autowired
  public void configMethod(Config config, Properties prop) {
    confg = config;
    props = prop;
    System.out.println("config method is called:"+config+"\t"+prop);
  }
  public Example getExample() {
	  return example;
  }
  public Properties getProps() {
	  return props;
  }
}

While the Example class and Config class are just simple
POJO with a private variable.

example.Example
package example;
public class Example
{
  private String name = "test value";
  public void setName(String argName) {
    name = argName;
  }
  public String getName() {
    return name;
  }
}
and
example.Config
package example;

public class Config {
  public String logFile;
  
}

Now it is very logical to look at the Spring configuration
file for the Spring Container, as shown below:
sample.xml
<?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:ctx="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">
  <ctx:annotation-config/>
  <bean id="configuration" class="example.Config"/>
  <bean id="config" class="example.Config"/>
  <bean id="prop" class="java.util.Properties"/> 
  <bean id="example1" class="example.Example"/>
  <bean id="sample" class="example.SampleBean">
  </bean>
</beans>

When I ran this example with a test harness/client class as shown
below:

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

import example.*;
public class Client
{
  public Client() {
    try{
      ClassPathXmlApplicationContext appCtx = 
           new ClassPathXmlApplicationContext("sample.xml");
      SampleBean sb = (SampleBean) appCtx.getBean("sample");
      System.out.println(sb.getExample().getName());
    } catch(Exception ex) {
      ex.printStackTrace();
    }
  }
  public static void main(String args[]) {
    new Client();
  }
}


Output of this Client class after execution, on console I found as 

config method is called:example.Config@15fadcf	{}
test value

This depicts that the private instance variable example of the SampleBean
is auto wired and got the example.Example object injected to it.
And the configMethod method is also got called by autowired annotation.
In this case as there are two bean definition for the Config class
is defined, so Spring choose the one with the id same as the configMethod
argument name. If I remove one bean definition for the Config bean, then
irrespective of the id, always one bean instance will be autowired to this
configMethod of SampleBean.
But if i define two bean definition of the Config bean with different id 
but none same as the argument name of the configMethod, then there will be
a run time exception raised as follows:


org.springframework.beans.factory.BeanCreationException:
.....
.....
Could not autowire method: public void 
    example.SampleBean.configMethod(example.Config,java.util.Properties);
    nested exception is 
    org.springframework.beans.factory.NoSuchBeanDefinitionException: 
    No unique bean of type [example.Config] is defined: expected single
    matching bean but found 2: [configuration, config1]
.....
.....


The above exception I received/seen on console when I ran this example
with the following sample.xml file as Spring configuration file:

sample.xml
<?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:ctx="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">
  <ctx:annotation-config/>
  <bean id="configuration" class="example.Config"/>
  <bean id="config" class="example.Config"/>
  <bean id="prop" class="java.util.Properties"/> 
  <bean id="example1" class="example.Example"/>
  <bean id="sample" class="example.SampleBean">
  </bean>
</beans>

Commented By ->
Amit

Spring Interview questions with answer added in this page on 23rd Feb
2010

Spring Interview Question 1:
What is the exception class that is provided by Spring Framework
while working with data access mechanisms such as JDBC, 
Hibernate, JDO or JPA ?

Answer:
org.springframework.dao.DataAccessException is the root exception
that should used while using Spring's support for data access
layer.

Spring interview question 2:
Spring's DataAccessException is checked or unchecked exception?

Answer:
Spring's DataAccessException is unchecked exception.

Spring's interview question 3:
Is there any Spring's support for datasource that can be used
while testing data access related code outside of J2EE/JEE
container?

Answer:
package org.springframework.jdbc.datasource has many class
files and out of which I have used DriverManagerDataSource
along with Spring's DAO for mocking up data access related
code so as to be able to test code in non J2EE/JEE container,
while using javax.sql.DataSource related API.

Commented By ->
Amit

Some of these interview questions on Spring Framework
(version 3.0) as mentioned below:

1: Can the Controller implementation from Spring MVC Web module be able
   to write to the response stream directly ?

Answer :
   Yes, the Controller implementation that is provided by developer
   while using Spring's Web module, should be able to write content
   directly using the response object/stream.

2: Can you be able to use Spring Framework version 3.0 along with other
   web application frameworks like Struts, JSF etc?

Answer :

   Yes, one can integrate Spring with Struts and JSF by loading
   Spring's application context by using listener 
   (org.springframework.web.context.ContextLoaderListener) from 
   Spring Framework and it is to be loaded at server startup, by 
   defining this listener in web application deployment descriptor.

3: What are the different beans, those can be created while working
   with Spring's WebApplicationContext ?

Answer :

   Beans such as controller bean, handler mapping bean, view resolver
   bean, locale resolver bean, theme resolver bean, multipart file
   resolver bean (while working with file upload using HTML form), 
   exception hanlder resolver bean etc.

4: What are the different bean scopes those are possible with 
   Spring Framework as of 3.0 version?

Answer :
   
   As of Spring 3.0, bean's scope can fall in any one of these types,
   as follows:
   session scope, singleton scope, prototype scope, request, 
   global session and thread scope, custom defined scope as well.

Visitor/User referred related external URL:
(Visible upon review and approved by this site Administrator)

Terms of Use and Disclaimer :

This web site provides some of the information about various technologies, example 
code, tips, tutorials etc. Like any printed materials, content of these pages may 
become out of date over a period of time. Therefore all visitor/users of this web 
site are requested/advised to refer to the originating parties/sources for the 
latest changes and happenings for detailed information. This information is not 
intended to be a substitute for the original reference provided by the originating 
parties/sources.

By accessing and using this website in any ways, including, without
limitation, browsing the website pages, using any information, using any content and/or 
downloading any materials, you agree to and are bound by the terms of use 
described in this page and Usage Terms and Conditions. 
If you do not agree to all of 
the terms and conditions contained in the terms of use described in this
page and Usage Terms and Conditions, do not use this 
website in any manner. If you are using the website on behalf of your 
employer, you represent that you are authorized to accept these Terms of Use 
on your employer's behalf.

All Trademarks are property of their respective owner. Appropriate measure is being
taken for providing accurate and up-to-date information but like any printed materials,
these blog(s)/contents may eventually be outdated one day, so if you are using any 
of these information, please refer original content/documentation from respective sources. 
And under no circumstances shall the Author of these contents and/or this web site
be liable for any loss, damage, expense incurred or suffered which is claimed to have
occurred because of usage of the contents of this web site.
If you have any questions/queries/feedback/suggestions then please write to this web
site owner at contact.