op 100 Spring Interview

Questions and Answers

(part 1)
October 24, 2019 by javabycode.com

1.What is Spring framework?

Spring is development framework for Java programming. It is an open source development

framework for Enterprise Java.
The core features of Spring Framework can be used in developing a Java Enterprise
application.

It has many extensions and jars for developing web applications on top of Java EE platform.
With Spring we can develop large-scale complex Java applications very easily. It is also
based on good design patterns like Dependency Injection, Aspect oriented programming
for developing extensible feature rich software.

2. What are the benefits of Spring framework in software development?

Many benefits of Spring framework are:
Lightweight Framework: Basic Spring framework is very small in size. It is easy to use and
does not add a lot of overhead on software. It just has 2 MB in basic version.
Container: Spring framework provides the basic container that creates and manages the
life cycle of application objects like Plain old Java objects (POJO). It also stores the
configuration files of application objects to be created.
Dependency Injection (DI): Spring provided loose coupling is application by Dependency
Injection. It uses Inversion of Control technique by which objects specify their
dependencies to Spring container instead of creating new objects themselves.
Aspect Oriented Programming (AOP): Spring framework promotes and provides support
for Aspect oriented programming in Java.
This helps in separating application business logic from system services that are common
across all the business logic. E.g. Logging can be a cross cutting concern in an Application.
Transaction Management: Spring provides a framework for transaction management. So a
developer does not have to implement it from scratch. Spring Transaction Management is
so powerful that we can scale it from one local transaction to global transactions in a
cluster.
MVC Framework: For Web applications, Spring provides MVC framework. This framework is
based on MVC design pattern andhas better features compared to other web frameworks.
Exception Handling: Spring also gives support for a common API to handle exceptions in
various technologies like- Hibernate, JDBC etc.

3. What are the modules in Core Container of Spring framework?

Spring framework has a Core Container. Modules in Core Container are:

 Core module
 Bean module
 Context module
 Spring Expression Language module

4.What are the modules in Data Access/Integration layer of Spring framework?

Modules in Data Access/Integration Layer of Spring framework are:

 JDBC module: An abstraction layer to remove tedious JDBC coding.

 ORM module Integration layers for Object Relational Mapping
 OXM module: An abstraction layer to support Object XML mapping.
 Java Messaging Service (JMS) module: Module for producing and consuming
messages.
 Transactions module: Transaction Management for POJO classes

5. What are the modules in Web layer of Spring framework?

Modules in Web Layer of Spring framework are:

 Web module: This provides basic web-oriented integration features.

 Servlet module: Support for Servlet Listeners.
 WebSocket module: Support for Web Socket style messaging.
 Portlet module: MVC implementation for Portlet environment.

6.What is the main use of Core Container module in Spring framework?

As the name suggests, Spring Core Container is the core of Spring framework. It gives
the basic functionality of the Spring. All the parts of Spring Framework are built on
top of Core Container.
Its main use is to provide Dependency Injection (DI) and Inversion of control (IOC)
features.

7.What kind of testing can be done in Spring Test Module?

Spring Test Module provides support for Unit testing as well as Integration testing of
Spring components. It allows using JUnit or TestNG testing frameworks. It also gives
ability to mock objects to use the test code.

8. What is the use of BeanFactory in Spring framework?

BeanFactory is the main class that helps in implementing Inversion of Control
pattern in Spring. It is based on the factory design pattern. It separates the
configuration and dependencies of an application from the rest of application code.
Implementations of BeanFactory like XmlBeanFactory class are used by applications
built with Spring.

9. Which is the most popular implementation of BeanFactory in Spring?

XMLBeanFactory is the most popular implementation of BeanFactory in Spring.

10.What is XMLBeanFactory in Spring framework?

XMLBeanFactory is one of the most useful implementation of BeanFactory in Spring.
This factory loads its beans based on the definitions mentioned in an XML file.
Spring container reads bean configuration metadata from an XML file and creates a
fully configured application with the help of XMLBeanFactory class.

11.What are the uses of AOP module in Spring framework?

AOP module is also known as Aspect Oriented Programming module. Its uses are:
Development of aspects in a Spring based application Provides interoperability
between Spring and other AOP frameworks Supports metadata programming to
Spring

12.What are the benefits of JDBC abstraction layer module in Spring framework?
Spring provides JDBC abstraction layer module. Main benefits of this module are:

 Helps in keeping the database code clean and simple.

 Prevents problems that result from a failure to close database resources.
 Provides a layer of useful exceptions on top of the error messages given by different
database servers.
Based on Spring’s AOP module
 Provides transaction management services for objects in a Spring application

13.How does Spring support Object Relational Mapping (ORM) integration?

Spring supports Object Relational Mapping (ORM) by providing ORM Module. This
module helps in integrating with popular ORM framework like Hibernate, JDO, and
iBATIS SQL Maps etc.
Transaction Management module of Spring framework supports all of these ORM
frameworks as well as JDBC.

14.How does Web module work in Spring framework?

Spring provides support for developing web application by using Web module. This
module is built on application context module that provides context for web-based
applications.
This module also supports web-oriented integration features liketransparently
handling multipart requests for uploading files, programmatically binding request
parameters to business objects etc.
This module also supports integration with popular web frameworks like Jakarta
Struts, JSF, and Tapestry etc.

15.What are the main uses of Spring MVC module?

Spring-webmvc module is also known as Web-servlet module. It is based on Web
Model View Controller pattern. Main uses of this module are:

 Integration of Spring with other MVC frameworks

 Supports IoC to provide clean separation of controller logic from business objects
 Provides clean separation between domain model code and web forms
 Allows developers to declaratively bind request parameters to business objects

16. What is the purpose of Spring configuration file?

Spring application can be configured by an XML file. This file contains information of
classes and how these classes are configured and introduced to each other.
Spring IoC container uses some kind of configuration metadata. This configuration
metadata represents how an application developer tells the Spring container to
instantiate, configure, and assemble the objects in your application. This
configuration metadata is stored in Spring configuration file.
The other ways of specifying configuration metadata are Java based configuration
and Annotation based configuration.

17.What is the purpose of Spring IoC container?

The Spring IoC Container is responsible for:

 Creating the objects

 Configuring the objects
 Managing dependency between objects (with dependency injection (DI))
 Wiring the objects together
 Managing complete lifecycle of objects

18.What is the main benefit of Inversion of Control (IOC) principle?

Inversion of Control (IOC) principle is the base of Spring framework. It supports
dependency injection in an application. With Dependency Injection, a programmer
has to write minimal code. It also makes easier to test an application.
Most important benefit is that it leads to loose coupling within objects. With loose
coupling it is easier to change the application with new requirements.
19.Does IOC containers support Eager Instantiation or Lazy loading of beans?
IOC Container in Spring supports both the approaches. Eager instantiation as well as
lazy loading of beans.

20. What are the benefits of ApplicationContext in Spring?

ApplicationContext in Spring provides following benefits:

 Bean factory methods: These are used to access application components

 Load File Resources: It helps in loading file resources in a generic fashion
 Publish Events: It enables publishing events to registered listeners
 Internationalization Support: Ability to resolve messages to support
internationalization
 Parent Context: Ability to inherit from a parent context

21.How will you implement ApplicationContext in Spring framework?

ApplicationContext in Spring can be implemented in one of the following three ways:
FileSystemXmlApplicationContext: If we want to load the definitions of beans from an
XML file then
FileSystemXmlApplicationContext is used. The full path of XML bean configuration file is
provided to the constructor.
ClassPathXmlApplicationContext: To loads the definitions of beans from an XML file in the
CLASSPATH, we use ClassPathXmlApplicationContext. It is used for application context
embedded in jars.
WebXmlApplicationContext: To provide configuration for a web application
WebXmlApplicationContext is used. While the application is running, it is read only. But it
can be reloaded if underlying application supports it.

22.Explain the difference between ApplicationContext and BeanFactory in Spring?

Main differences between ApplicationContext and BeanFactory are:
Automatic BeanPostProcessor registration: BeanFactory does not support
BeanPostProcessor registration. Whereas ApplicationContext support this.
Automatic BeanFactoryPostProcessor registration: BeanFactory also does not allow
Automatic BeanFactoryPostProcessor registration. Whereas ApplicationContext allows this.
MessageSource access: BeanFactory is not convenient for MessageSource access.
ApplicationContext is quite convenient for MessageSource access.
ApplicationEvent: We cannot publish ApplicationEvent with BeanFactory. But
ApplicationContext provides ability to publish ApplicationEvent.

23. Between ApplicationContext and BeanFactory which one is preferable to use in

Spring?
Spring documentation recommends using ApplicationContext in almost all the cases.
ApplicationContext has all the functionality of BeanFactory.
24.What are the main components of a typical Spring based application?
In a Spring based application, main components are:

 Spring configuration XML file: This is used to configure Spring application

 API Interfaces: Definition of API interfaces for functions provided by application
 Implementation: Application code with implementation of APIs
 Aspects: Spring Aspects implemented by application
 Client: Application at client side that is used for accessing functions

25.Explain Dependency Injection (DI) concept in Spring framework?

Dependency Injection is a software design pattern. It is used to implement Inversion
of Control (IOC) in Spring framework. As per this pattern, we do not create objects in
an application by calling new. Rather, we describe how an object should be created.
In this way creation of an object is not tightly coupled with another object.
A container is responsible for creating and wiring the objects. The container can call
injecting code and wire the objects as per the configuration at runtime.

26. What are the different roles in Dependency Injection (DI)?

There are four roles in Dependency Injection:

 Service object(s) to be used

 Client object that depends on the service
 Interface that defines how client uses services
 Injector responsible for constructing services and injecting them into client

27.Spring framework provides what kinds of Dependency Injection mechanism?

Spring framework provides two types of Dependency Injection mechanism:
Constructor-based Dependency Injection: Spring container can invoke a class
constructor with a number of arguments. This represents a dependency on other class.
Setter-based Dependency Injection: Spring container can call setter
method on a bean after creating it with a no-argument constructor or no-argument static
factory method to instantiate another bean.

28.In Spring framework, which Dependency Injection is better? Constructor-based DI

or Setter-based DI?
Spring framework provides support for both Constructor-based and Setter-based
Dependency Injection. There are different scenarios in which these options can be
used.
It is recommended to use Constructor-based DI for mandatory dependencies.
Whereas Setter-based DI is used for optional dependencies.

29.What are the advantages of Dependency Injection (DI)?

Dependency Injection (DI) pattern has following advantages:
Dependency Injection reduces coupling between a class and its dependencies.
With Dependency Injection (DI), we can do concurrent or independent software
development. Two teams can work parallel on classes that will be used by each
other.
In Dependency Injection (DI), the client can be configured in multiple ways. It needs
to just work with the given interface. Rest of the implementation can be changed
and configured for different features.
Dependency injection is also used to export a system’s configuration details into
configuration files. So we can configure same application run in different
environments based on configuration. E.g. Run in Test environment, UAT
environment, and Production environment.
Dependency Injection (DI) applications provide more ease and flexibility of testing.
These can be tested in isolation in Unit Test.
Dependency injection (DI) isolates client from the impact of design and
implementation changes. Therefore, it promotes reusability, testability and
maintainability.

30.What are the disadvantages of Dependency Injection (DI)?

Dependency Injection (DI) pattern has following disadvantages:
Most of the time Dependency Injection forces developers to use an injection
framework like Spring. This causes dependency on a framework.
With Dependency Injection, clients are dependent on the configuration data. This
becomes extra task for developers when the application does not need so many
custom configuration values.
Code is difficult to trace and read in Dependency Injection. DI separates behavior
from construction of objects.
Dependency injection increases complexity in the linkages between classes. It may
become harder to manage such complexity outside the implementation of a class.

31.What is a Spring Bean?

A Spring Bean is a plain old Java object (POJO) that is created and managed by a Spring
container.
There can be more than one bean in a Spring application. But all these Beans are
instantiated and assembled by Spring container.
Developer provides configuration metadata to Spring container for creating and managing
the lifecycle of Spring Bean.
In general a Spring Bean is singleton. Evert bean has an attribute named “singleton”. If its
value is true then bean is a singleton. If its value is false then bean is a prototype bean.
By default the value of this attribute is true. Therefore, by default all the beans in spring
framework are singleton in nature.

32. What does the definition of a Spring Bean contain?

A Spring Bean definition contains configuration metadata for bean. This
configuration metadata is used by Spring container to:

 Create the bean

 Manage its lifecycle
 Resolve its dependencies

33.What are the different ways to provide configuration metadata to a Spring

Container?
Spring supports three ways to provide configuration metadata to Spring Container:
XML based configuration: We can specify configuration data in an XML file.
Annotation-based configuration: We can use Annotations to specify configuration.
This was introduced in Spring 2.5.
Java-based configuration: This is introduced from Spring 3.0. We can embed
annotations like @Bean, @Import, @Configuration in Java code to specify configuration
metadata.

34. What are the different scopes of a Bean supported by Spring?

Spring framework support seven types of scopes for a Bean. Out of these only five
scopes are available for a web-aware ApplicationContext application:
singleton: This is the default scope of a bean. Under this scope, there is a single object
instance of bean per Spring IoC container.
prototype: Under this scope a single bean definition can have multiple object instances.
request: In this scope, a single bean definition remains tied to the lifecycle of a single HTTP
request. Each HTTP request will have its own instance of a bean for a single bean definition.
It is only valid in the context of a web-aware Spring ApplicationContext.
session: Under this scope, a single bean definition is tied to the lifecycle of an HTTP
Session. Each HTTP Session will have one instance of bean. It is also valid in the context of a
web-aware Spring ApplicationContext.
globalSession: This scope, ties a single bean definition to the lifecycle of a global HTTP
Session. It is generally valid in a Portlet context. It is also valid in the context of a web-aware
Spring ApplicationContext.
application: This scope, limits a single bean definition to the lifecycle of a ServletContext. It
is also valid in the context of a web-aware Spring ApplicationContext.
websocket: In this scope, a single bean definition is tied to the lifecycle of a WebSocket. It is
also valid in the context of a webaware Spring ApplicationContext.
35. How will you define the scope of a bean in Spring?
In configuration xml, we can specify the scope of bean in its definition. This is used
by container to decide the scope of bean in Spring.
E.g.

1 <bean id="userService"
class="com.um.UserService"
scope="prototype"/>
This is an example of userService bean with prototype scope.

36. Is it safe to assume that a Singleton bean is thread safe in Spring Framework?
No, Spring framework does not guarantee anything related to multithreaded
behavior of a singleton bean. Developer is responsible for dealing with concurrency
issues and maintaining thread safety of a singleton bean.

37. What are the design-patterns used in Spring framework?

Spring framework uses many Design patterns. Some of these patterns are:
Singleton – By default beans defined in spring config files are singleton. These are based
on Singleton pattern.
Template – This pattern is used in many classes likeJdbcTemplate, RestTemplate,
JmsTemplate, JpaTemplate etc.
Dependency Injection – This pattern is the core behind the design of BeanFactory and
ApplicationContext.
Proxy – Aspect Oriented Programming (AOP) heavily uses proxy design pattern.
Front Controller – DispatcherServlet in Spring is based on Front Controller pattern to
ensure that incoming requests are dispatched to other controllers.
Factory pattern – To create an instance of an object, BeanFactory is used. This is based on
Factory pattern.
View Helper – Spring has multiple options to separating core code from presentation in
views. Like- Custom JSP tags, Velocity macros etc.

38. What is the lifecycle of a Bean in Spring framework?

A Bean in Spring framework goes through following phases in its lifecycle.

Initialization and creation: Spring container gets the definition of Bean from XML file and
instantiates the Bean. It populates all the properties of Bean as mentioned in the bean
definition.
Setting the Behavior of Bean: In case a Bean implements BeanNameAware interface, Spring
uses setBeanName() method to pass the bean’s id. In case a Bean implements
BeanFactoryAware interface, Spring uses setBeanFactory() to pass the BeanFactory to
bean.
Post Processing: Spring container uses postProcesserBeforeInitialization() method to call
BeanPostProcessors associated with the bean. Spring calls afterPropertySet() method to
call the specific initialization methods.
In case there are any BeanPostProcessors of a bean, the postProcessAfterInitialization()
method is called.
Destruction: During the destruction of a bean, if bean implements DisposableBean, Spring
calls destroy() method.

39. What are the two main groups of methods in a Bean’s lifecycle?
A Bean in Spring has two main groups of lifecycle methods.
Initialization Callbacks: Once all the necessary properties of a Bean are set by the
container, Initialization Callback methods are used for performing initialization work. A
developer can implement method
afterPropertiesSet() for this work.
Destruction Callbacks: When the Container of a Bean is destroyed, it calls the methods in
DisposableBean to do any cleanup work. There is a method called destroy() that can be
used for this purpose to make Destruction Callbacks.
Recent recommendation from Spring is to not use these methods, since it can strongly
couple your code to Spring code.

40. Can we override main lifecycle methods of a Bean in Spring?

Yes, Spring framework allows developers to override the lifecycle methods of a Bean.
This is used for writing any custom behavior for Bean.

41. What are Inner beans in Spring?

A bean that is used as a property of another bean is known as Inner bean. It can be
defined as a <bean/> element in <property/> or <constructor-arg/> tags.
It is not mandatory for an Inner bean to have id or a name. These are always
anonymous.
Inner bean does not need a scope. By default it is of prototype scope.

42. How can we inject a Java Collection in Spring framework?

Spring promotes Dependency Injection (DI) in code. It gives support for injecting not
only objects but also collection of objects. We can inject collections like- list, set, map
etc. in Spring.
Following tags can be used for this purpose:
<list> : This type is used for injecting a list of values. In a <list> duplicates are
allowed.
<set> : This type is used for injecting a set of values. As per set property, duplicates
are not allowed.
<map> : This type is used for injecting name-value pairs in form of map. Name and
value can be of any type that is allowed for a map.
<props> : This type is used to inject a collection of String based name-value. It is like a
properties file.

43.What is Bean wiring in Spring?

A Spring container is responsible for injecting dependencies between beans. This
process of connecting beans is called wiring.
Developer mentions in configuration file, the dependencies between beans. And
Spring container reads these dependencies and wires the beans on creation.

44.What is Autowiring in Spring?

Autowiring is a feature of Spring in which container can automatically wire/connect
the beans by reading the configuration file.
Developer has to just define “autowire” attribute in a bean.
Spring resolves the dependencies automatically by looking at this attribute of beans
that are autowired.

45.What are the different modes of Autowiring supported by Spring?

There are five modes of Autowiring supported by Spring framework:
no: This is default setting for Autowiring. In this case, we use “ref” mode to mention
the explicit bean that is being referred for wiring.
E.g. In this example Employee bean refers Manager bean.

1 <bean id="employee"
2 class="com.dept.Employee">
3 <property name="manager"
4 ref="manager" />
</bean>
<bean id="manager"
class="com.dept.Manager" />
byName: In this case, Spring container tries to match beans by name during Autowiring. If
the name of a bean is same as the name of bean referred in autowire byname, then it
automatically wires it.
E.g. In following example, Manager bean is wired to Employee bean by Name.

1 <bean id="employee"
2 class="com.dept.Employee" autowire="byName"
/>
<bean id="manager"
class="com.dept.Manager" />
byType: In this case, Spring container check the properties of beans referred with attribute
byType. Then it matches the type of bean and wires. If it finds more than one such bean of
that type, it throws a fatal exception.
E.g. In following example, Manager bean is wired by type toEmployee bean.

1 <bean id="employee"
2 class="com.dept.Employee"
 autowire="byType" />
<bean id="manager"
class="com.dept.Manager" />
constructor: In this case, Spring container looks for byType attribute in constructor
argument. It tries to find the bean with exact name. If it finds more than one bean of same
name, it throws fatal exception.
This case is similar to byType case.
E.g. In following example “constructor” mode is used for autowiring.

1 <bean id="employee"
2 class="com.dept.Employee"
autowire="constructor" />
<bean id="manager"
class="com.dept.Manager" />
autodetect: This is an advanced mode for autowiring. In this case, by default Spring tries to
find a constructor match. If it does not find constructor then it uses autowire by Type.
E.g. This is an example of autodetect Autowiring.

1 <bean id="employee"
2 class="com.dept.Employee"
autowire="autodetect" />
<bean id="manager"
class="com.dept.Manager" />
46. What are the cases in which Autowiring may not work in Spring framework?
Autowiring is a great feature in Spring. It can be used in most of the cases. But there
are certain scenarios in which Autowiring may not work.
Explicit wiring: Since Autowiring is done by Spring, developer does not have full control on
specifying the exact class to be used. It is preferable to use Explicit wiring in case of full
control over wiring.
Primitive Data types: Autowiring does not allow wiring of properties that are based on
primitive data types like- int, float etc.

47.Is it allowed to inject null or empty String values in Spring?

Yes, Spring allows injecting null or empty String values.

48.What is a Java-based Configuration in Spring?

Spring allows for Java-based configuration in which a developer can specify
configuration by using Java-based annotations. This feature was introduced in Spring
3.0.
You can use annotations like- @Configuration, @Bean, @Import and @DependsOn in Java
classes for specifying the configuration.

49.What is the purpose of @Configuration annotation?

This annotation is used in a class to indicate that this is class is the primary source of
bean definitions. This class can also contain inter-bean dependencies that are
annotated by @Bean annotation.

50. What is the difference between Full @Configuration and ‘lite’ @Beans mode?
Spring allows for using @Bean annotation on methods that are declared in classes not
annotated with @Configuration. This is known as “lite” mode. In this mode, bean methods
can be declared in a @Component or a plain java class without any annotation.
In the “lite” mode, @Bean methods cannot declare inter-bean dependencies.
It is recommended that one @Bean method should not invoke another @Bean method in
‘lite’ mode.
Spring recommends that @Bean methods declared within @Configuration classes should be
used for full configuration. This kind of full mode can prevent many bugs.

51.In Spring framework, what is Annotation-based container configuration?

From Spring 2.5 version it is possible to provide configuration by using annotation.
To turn this configuration on, we need to mention <context:annotation-config/> in spring
XML file.
Now developer can use annotations like @Required, @Autowired, @Qualifier etc. in a class
file to specify the configuration for beans.

Spring container can use this information from annotation for creating and wiring the
beans.

52.How will you switch on Annotation based wiring in Spring?

To use Annotation based wiring, we need to turn on Annotation based configuration
in Spring.
By default, Annotation based configuration is switched off in Spring. To turn it is we
can specify <context:annotation-config/> element in Spring config file.
Once it is turned on, we can use @Autowired annotation or @Required annotation in a Java
class for wiring in Spring.

53. What is @Autowired annotation?

We can use @Autowired annotation to auto wire a bean on a setter method, constructor or
a field. @Autowired auto wiring is done by matching the data type.
Before using @Autowired annotation we have to register
AutowiredAnnotationBeanPostProcessor. This can be done by including
<context:annotation-config /> in bean configurat ion file.

54.What is @Required annotation?

We use @Required annotation to a property to check whether the property has been set or
not.
Spring container throws BeanInitializationException if the @Required annotated property is
not set.
When we use @Required annotation, we have to register
RequiredAnnotationBeanPostProcessor in Spring config file.

55.What are the two ways to enable RequiredAnnotationBeanPostProcessor in

Spring?
RequiredAnnotationBeanPostProcessor can be enabled in two ways in Spring:

Include <context:annotation-config /> Add Spring context and <context:annotation-config /> in

bean

configuration file.

E.g.

1 <beans
2 ...
3 xmlns:context="http://www.springframework.or
4 g/schema/context"
5 ...
6 http://www.springframework.org/schema/conte
7 xt
8 http://www.springframework.org/schema/conte
9 xt/spring-context-2.5.xsd">
10 ...
<context:annotation-config />
...
</beans>
Include RequiredAnnotationBeanPostProcessor in bean configuration file
E.g.

1 <beans
2 xmlns="http://www.springframework.org/schem
3 a/beans"
4 xmlns:xsi="http://www.w3.org/2001/XMLSchem
5 a-instance"
6 xsi:schemaLocation="http://www.springframew
7 ork.org/schema/beans
8 http://www.springframework.org/schema/beans
9 /spring-beans- 2.5.xsd">
10 <beanclass="org.springframework.beans.f
11 actory.annotation.RequiredAnnotationBean
12 P
13 <bean id="BookBean" class="com.foo.Book">
<property name="action" value="price" />
<property name="type" value="1" />
 </bean>
<bean id="AuthorBean"
class="com.foo.Author">
<property name="name" value="Rowling" />
</bean>
</beans>
56. What is @Qualifier annotation in Spring?
We use @Qualifier annotation to mark a bean as ready for auto wiring. This annotation is
used along with @Autowired annotation to specify the exact bean for auto wiring by Spring
container.

57.How Spring framework makes JDBC coding easier for developers?

Spring provides a mature JDBC framework to provide support for JDBC coding. Spring
JDBC handled resource management as well as error handling in a generic way. This
reduces the work of software developers.
They just have to write queries and related statements to fetch the data or to store
the data in database.

58.What is the purpose of JdbcTemplate?

Spring framework provides JdbcTemplate class that contains many convenient
methods for regular tasks like- converting data into primitives or objects, executing
prepared or callable statements etc.
This class makes it very easy to work with database in our Application and it also
provides good support for custom error handling in database access code.

59.What are the benefits of using Spring DAO?

Some of the benefits of using Spring DAO are:

1. It makes it easier to work on different data access methods likeJDBC, Hibernate etc.
2. It provides a consistent and common way to deal with different data access
methods.
3. Spring DAO makes it easier to switch between different data persistence
frameworks.
4. No need for catching framework specific exceptions.

60.What are the different ways to use Hibernate in Spring?

Spring provides two ways to use Hibernate:

5. We can extend HibernateDAOSupport and apply an AOP interceptor node to use

Hibernate.
6. We can also use HibernateTemplate and Callback to access Hibernate. This is based
on Inversion of Control.

61.What types of Object Relational Mapping (ORM) are supported by Spring?

Spring supports following Object Relational Mapping (ORM) frameworks:
 7. Hibernate
8. Java Persistence API (JPA)
9. TopLink
10. Java Data Objects (JDO)
11. Apache Object Relational Bridge (ORB)

62.How will you integrate Spring and Hibernate by using HibernateDaoSupport?

We can use following steps for integrating Spring and Hibernate:

12. Add dependencies for Spring and Hibernate in pom.xml

13. Implement DAO from HibernateDaoSupport
14. Use Hibernate functions via getHibernateTemplate() method

63. What are the different types of the Transaction Management supported by Spring
framework?
Spring framework provides support for two types of Transaction Management:

15. Programmatic: In this method, we have to manage Transaction by programming

explicitly. It provides flexibility to a developer, but it is not easier to maintain.
16. Declarative: In this approach, we can separate Transaction Management from the
Application Business code. We can use annotations or XML based configuration to
manage the transactions in declarative approach.

64.What are the benefits provided by Spring Framework’s Transaction Management?

Main benefits provided by Spring Transaction Management are:

17. Consistent: By using Spring Transaction management, we can use consistent

programming model across different transaction APIs like- JPA, JDBC, JTA, Hibernate,
JPA, JDO etc.
18. Simplicity: Spring TM provides simple API for managing the transaction
programmatically.
19. Declarative: Spring also supports annotation or xml based declarative transaction
management.
20. Integration: Spring Transaction management is easier to integrate with other data
access abstractions of Spring.

65.Given a choice between declarative and programmatic Transaction Management,

which method will you choose?
In Spring, Declarative Transaction Management is the preferred choice. This method
is very less invasive and it has very less impact in Application Business Logic.
Although Declarative method gives less flexibility than Programmatic method, it is
simpler to use and easier to maintain in long run.

66. What is Aspect Oriented Programming (AOP)

Aspect Oriented Programming (AOP) is a programming paradigm that promotes
programmers to develop code in different modules that can be parallel or in
crosscutting concerns. E.g. To develop banking software, one team can work on
business logic for Money withdrawal, Money deposit, Money Transfer etc.
The other team can work on Transaction Management for committing the
transaction across multiple accounts.
In an Auto company, one team can work on software to integrate with different
components of car. The other team can work on how all the components will send
signal and current information to a common dashboard.

67. What is an Aspect in Spring?

An Aspect is the core construct of AOP. It encapsulates the behavior that affects
multiple classes in a reusable module.
An Aspect can have a group of APIs that provide cross-cutting features. E.g. A logging
module can be an Aspect in an Application.
An application can have multiple of Aspects based on the different requirements.
An Aspect can be implemented by using annotation @Aspect on a class.

68.In Spring AOP, what is the main difference between a Concern and a Cross cutting
concern?
A Concern in Spring is the behavior or expectation from an application. It can be the
main feature that we want to implement in the application.
A Cross cutting concern is also a type of Concern. It is the feature or functionality
that is spread throughout the application in a thin way. E.g. Security, Logging,
Transaction Management etc. are cross cutting concerns in an application.

69.What is a Joinpoint in Spring AOP?

In Spring AOP, Joinpoint refers to a candidate point in application where we can plug
in an Aspect.
Joinpoint can be a method or an exception or a field getting modified.
This is the place where the code of an Aspect is inserted to add new behavior in the
existing execution flow.

70.What is an Advice in Spring AOP?

An Advice in Spring AOP, is an object containing the actual action that an Aspect
introduces.
An Advice is the code of cross cutting concern that gets executed.
There are multiple types of Advice in Spring AOP.
71.What are the different types of Advice in Spring AOP?
Spring AOP provides five kinds of Advice:

21. Before Advice: This type of advice runs just before a method executes. We can use
@Before annotation for this.
22. After (finally) Advice: This type of advice runs just after a method executes. Even if the
method fails, this advice will run. We can use @After annotation here.
23. After Returning Advice: This type of advice runs after a method executes successfully.
@AfterReturning annotation can be used here.
24. After Throwing Advice: This type of advice runs after a method executes and throws
an exception. The annotation to be used is @AfterThrowing.
25. Around Advice: This type of advice runs before and after the method is invoked. We
use @Around annotation for this.

72. What is a Pointcut in Spring AOP?

A Pointcut in Spring AOP refers to the group of one or more Joinpoints where an
advice can be applied.
We can apply Advice to any Joinpoint. But we want to limit the places where a
specific type of Advice should be applied. To achieve this we use Pointcut.
We can use class names, method names or regular expressions to specify the
Pointcuts for an Advice.

73. What is an Introduction in Spring AOP?

In Spring AOP we can declare additional methods or fields on behalf of a type. To do
this we use an Introduction. It is also known as inter-type declaration.
E.g. We can use an Introduction for making a bean implement IsModified interface.

74. What is a Target object in Spring AOP?

A Target object is the object that gets Advice from one or more Aspects. This is also
known as advised object.
In most cases it is a proxy object.

75.What is a Proxy in Spring AOP?

In Spring AOP, a Proxy is an object created by the AOP framework to implement
Aspect contracts. It is generally a JDK dynamic proxy or CGLIB proxy.

76. What are the different types of AutoProxy creators in Spring?

Spring AOP provides following standard types of Autoproxy creators:

26. BeanNameAutoProxyCreator: This is a BeanPostProcessor that creates AOP proxies

for beans automatically by matching names.
 27. DefaultAdvisorAutoProxyCreator: This creator is more powerful that other Proxy
Creators. This also applies eligible advisors automatically to bean in the current
context.
28. AbstractAdvisorAutoProxyCreator: This is the parent class of
DefaultAdvisorAutoProxyCreator. We can create our own auto-proxy creators by
extending this class.

77. What is Weaving in Spring AOP?

In Aspect oriented programming, linking Aspects with the other application types
creates an Advised object. This process is known as Weaving.
Without Weaving, we just have definition of Aspects. Weaving makes use realize full
potential of the AOP.
Weaving can be done at compile time, load time or at run time.

78.In Spring AOP, Weaving is done at compile time or run time?

Spring container performs Weaving at run time.

79.What is XML Schema-based Aspect implementation?

Spring allows for implementing Aspect by using regular classes and XML based
configurations. This is different from Annotation based Aspect implementation. But
it achieves the same goal of AOP.
We can use elements like

1 <aop:aspect id=”testAspect" ref="testBean" />

and <aop:pointcut id="testPointcut" />
in Spring XML config file.
To use this we need to import Spring AOP schema as follows:

1 <beans
2 xmlns="http://www.springframework.org/schem
3 a/beans"
4 xmlns:xsi="http://www.w3.org/2001/XMLSchem
5 a-instance"
6 xmlns:aop="http://www.springframework.org/sc
hema/aop"
xsi:schemaLocation="http://www.springframew
ork.org/schema/beans
http://www.springframework.org/schema/beans
/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/s
pring-aop-3.0.xsd">
80. What is Annotation-based aspect implementation in Spring AOP?
This is a declarative style AOP implementation. In this case, we use annotations like
@Aspect, @Pointcut, @Joinpoint etc. to annotate code with different types of AOP
elements.
This can be used Java 5 onwards, when the support for Annotations was introduced.

81. How does Spring MVC framework work?

Spring provides its own Model View Controller (MVC) framework for developing web
applications.
Spring MVC framework is based on Inversion of Control (IOC) principle. It separates
the business objects from controller.
It is designed around the DispatcherServlet that is responsible for dispatching
requests to relevant handlers.
Spring MVC framework also supports annotation based binding of request
parameters.

82.What is DispatcherServlet?
In Spring MVC, DispatcherServlet is the core servlet that is responsible for handling
all the requests and dispatching these to handlers.
Dispatcher servlet knows the mapping between the method to be called and the
browser request. It calls the specific method and combines the results with the
matching JSP to create an html document, and then sends it back to browser.
In case of RMI invocation, it sends back response to the client application.

83.Can we have more than one DispatcherServlet in Spring MVC?

Yes, a Spring MVC web application can have more than one DispatcherServlets.
Each DispatcherServlet has to operate in its own namespace. It has to load its own
ApplicationContext with mappings, handlers, etc.
Only the root application context will be shared among these Servlets.

84.What is WebApplicationContext in Spring MVC?

WebApplicationContext is the child of plain ApplicationContext. It is used in web
applications. It provides features to deal with webrelated components like-
controllers, view resolvers etc. A Web Application can have multiple
WebApplicationContext to handle requests.
Each DispatcherServlet is associated with one WebApplicationContext.

85.What is Controller in Spring MVC framework?

Controller is an interface in Spring MVC. It receives HttpServletRequest and

HttpServletResponse in web app just like an HttpServlet, but it is able to participate in an
MVC flow.
Controllers are similar to a Struts Action in a Struts based Web application.
Spring recommends that the implementation of Controller interface should be a reusable,
thread-safe class, capable of handling multiple HTTP requests throughout the lifecycle of
an application.
It is preferable to implement Controller by using a JavaBean. Controller interprets user
input and transforms it into a model. The model is represented to the user by a view.
Spring implements a controller in a very generic way. This enables us to create a wide
variety of controllers.
What is @Controller annotation in Spring MVC?
We use @ Controller annotation to indicate that a class is a Controller in Spring MVC.
The dispatcher in Spring scans for @Controller annotated classes for mapped methods and
detects @RequestMapping.

86. What is @RequestMapping annotation in Spring?

In Spring MVC, we use @RequestMapping annotation to map a web request to either
a class or a handler method.
In @RequestMapping we can specify the path of URL as well as HTTP method like-
GET, PUT, POST etc.
@RequestMapping also supports specifying HTTP Headers as attributes.
We can also map different media types produced by a controller in
@RequestMapping. We use HTTP Header Accepts for this purpose.
E.g.

1 @RequestMapping(
2 value = "/test/mapping",
3 method = GET,
4 headers = "Accept=application/json")
87.What are the main features of Spring MVC?
Spring MVC has following main features:

1. Clear separation of role: In Spring MVC, each role   like-   controller, validator, command
object, form
object, model object, DispatcherServlet, handler mapping, view resolver etc. is fulfilled by a
specialized object.
2. Reusability: Spring MVC promotes reusable business code that reduces the need for
duplication. We can use existing business objects as command or form objects instead of
copying them to extend a particular framework base class.
3. Flexible Model Transfer: Spring MVC Model transfer supports easy integration with other
view technologies as well.
4. Customizable binding and validation: In Spring MVC, we can to custom binding between
Requests and Controllers. Even validation can be done on non-String values as well.
5. JSP form tag library: From Spring 2.0, there is a powerful JSP form tag library that makes
writing forms in JSP pages much easier.
6. Customizable locale, time zone and theme resolution: Spring MVC supports
customization in locale, timezone etc.

88. What is the difference between a Singleton and Prototype bean in Spring?
Every bean in Spring has a scope that defines its existence timeframe in the
application.
Singleton scope for bean limits a bean to a single object instance per Spring IOC
container.
This single instance is limited to a specific ApplicationContext. If there are multiple
ApplicationContext then we can have more than one instance of bean.
By default all the beans in Spring framework are Singleton scope beans.
With Prototype scope a single bean definition can have multiple object instances in a
Spring container.
In prototype scope bean, the Spring IoC container creates new bean instance of the
object every time a request for that specific bean is made.

89.How will you decide which scopePrototype or Singleton to use for a bean in
Spring?
In general, we use prototype scope for all stateful beans and singleton scope for
stateless beans.
Since a stateless bean does not maintain any state, we can use the same object
instance again and again. Singleton scope bean serves the same purpose.
In a stateful bean, there is a need to maintain the state in each request, it is
necessary to use a new instance of object with each call. A Prototype scope bean
ensures that we get a new instance each time we request for the object.

90. What is the difference between Setter and Constructor based Dependency
Injection (DI) in Spring
framework?
Main differences between Setter and Constructor based Dependency Injection (DI) in
Spring are:
Priority: Setter based injection has higher priority than a constructor based injection
in Spring. If an application uses Setter as well as Constructor injection, Spring
container uses the Setter injection.
Partial dependency: We can inject partial dependency by using Setter injection. In
Constructor injection, it is not possible to do just a partial dependency injection.
E.g. If there are two properties in a class, we can use Setter method to inject just one
property in the class.
Flexibility: Setter injection gives more flexibility in introducing changes. One can
easily change the value by Setter injection. In case of Constructor injection a new
bean instance has to be created always.
Readability: Setter injection is more readable than Constructor injection. Generally
Setter method name is similar to dependency class being used in setter method.

91.What are the drawbacks of Setter based Dependency Injection (DI) in Spring?
Although Setter based Dependency Injection has higher priority than Constructor
based DI, there are some disadvantages of it.
No Guarantee: In Setter based DI, there is no guarantee that a certain dependency is
injected or not. We may have an object with partial or no dependency. Whereas in
Constructor based DI, an object in not created till the time all the dependencies are ready.
Security: One can use Setter based DI to override another dependency. This can cause
Security breach in a Spring application.
Circular Dependency: Setter based DI can cause circular dependency between objects.
Where as Constructor based DI will throw ObjectCurrentlyInCreationException if there is a
circular dependency during the creation of an object.

92. What are the differences between Dependency Injection (DI) and Factory Pattern?
Main differences between Dependency Injection (DI) and Factory Pattern are:
Coupling: Factory pattern adds tight coupling between an object, factory and dependency.
In case of DI, there is no coupling between objects. We just mention the dependencies on
different objects and container resolves and introduces these dependencies.
Easier Testing: DI is easier to test, since we can inject the mock objects as dependency in
Test environment. In case of Factory pattern, we need to create actual objects for testing.
Flexibility: DI allows for switching between different DI frameworks easily. It gives flexibility
in the choice of DI framework.
Container: DI always needs a container for injecting the dependencies. This leads to extra
overhead as well as extra code in your application. In factory pattern, you can just use POJO
classes to implement the application without any container.
Cleaner Code: DI code is much cleaner than Factory pattern based code. In DI, we do not
need to add extra code for factory methods.

93.In Spring framework, what is the difference between FileSystemResource and

ClassPathResource?
In Spring we can specify configuration by using a file or classpath.
In FileSystemResource we have to give absolute path / relative path of Spring
Configuration file spring-config.xml file.
In ClassPathResource Spring looks for Spring Configuration file spring-config.xml in
ClassPath. Therefore, developer has to include spring-config.xml in classpath.
ClassPathResource looks for configuration file in CLASSPATH, whereas FileSystemResource
looks for configuration file in file system.

94. Name some popular Spring framework annotations that you use in your project?
Spring has many Annotations to serve different purposes. For regular use we refer
following popular Spring annotations:
@Controller: This annotation is for creating controller classes in a Spring MVC project.
@RequestMapping: This annotation maps the URI to a controller handler method in Spring
MVC.
@ResponseBody: For sending an Object as response we use this annotation.
@PathVariable: To map dynamic values from a URI to handler method arguments, we use
this annotation.
@Autowired: This annotation indicates to Spring for auto-wiring dependencies in beans.
@Service: This annotation marks the service classes in Spring.
@Scope: We can define the scope of Spring bean by this annotation.
@Configuration: This an annotation for Java based Spring configuration.
@Aspect, @Before, @After, @Around, @Joinpoint, @Pointcut: These are the annotations in
Spring for AspectJ AOP.

95. How can you upload a file in Spring MVC Application?

In Spring MVC framework we can use MultipartResolver interface to upload a file. We
need to make configuration changes to make it work. After uploading the file, we
have to create Controller handler method to process the uploaded file in application.

96. What are the different types of events provided by Spring framework?
Spring framework provides following five events for Context:
ContextRefreshedEvent: Whenever ApplicationContext is initialized or refreshed, Spring
publishes this event. We can also raise it by using refresh() method on
ConfigurableApplicationContext interface.
ContextStartedEvent: When ApplicationContext is started using start() method on
ConfigurableApplicationContext interface, ContextStartedEvent is published. We can poll
database or restart
any stopped application after receiving this event.
ContextStoppedEvent: Spring publishes this event when ApplicationContext is stopped
using stop() method on ConfigurableApplicationContext interface. This is used for doing
any cleanup work.
ContextClosedEvent: Once the ApplicationContext is closed using close() method,
ContextClosedEvent is published. Once a context is closed, it is the last stage of its lifecycle.
After this it cannot be refreshed or restarted.
RequestHandledEvent: This is a web specific event that informs to all beans that an HTTP
request has been serviced.

97. What is the difference between DispatcherServlet and ContextLoaderListener in

Spring?
DispatcherServlet is the core of Spring MVC application. It loads Spring bean
configuration file and initialize all the beans mentioned in config file.
In case we have enabled annotations in Spring config file, it also scans the packages
and configures any bean annotated with @Component, @Controller, @Repository or
@Service annotations.
ContextLoaderListener is a listener to start up and shut down Spring’s root
WebApplicationContext. ContextLoaderListener links the lifecycle of ApplicationContext to
the lifecycle of the
ServletContext. It automates the creation of ApplicationContext. It can also be used to
define shared beans used across different spring contexts.

98. How will you handle exceptions in Spring MVC Framework?

Spring MVC Framework provides following mechanisms to help us achieve exception
handling:
Controller Based: A developer can define exception handler methods in a Controller class.
To do so, they have to annotate the methods with @ExceptionHandler annotation.
Global Exception Handler: Spring provides @ControllerAdvice annotation for exception
handling as cross-cutting concern. We can mark any class as global exception handler by
using this annotation.
HandlerExceptionResolver implementation: Spring Framework provides
HandlerExceptionResolver interface that can be implemented to create a global exception
handler.

99. What are the best practices of Spring Framework?

In Spring Framework, following are some of the best practices:
We can Divide spring bean configurations based on their concerns such as spring-
jdbc.xml, spring-security.xml.
It is better to avoid version numbers in schema reference. This makes sure that we
have the latest config files.
It is a good practice to configure bean dependencies as much as possible. Unless
there is a good reason, we try to avoid autowiring. For spring beans that are used in
multiple contexts in Spring MVC, we can create them in root context and initialize
with listener.
Spring framework provides many features and modules. We should just use what we
need for our application. An extra dependency has to be removed
For application properties, it is good to create a property file and read it in Spring
configuration file.
Annotations are useful for smaller applications, but for larger applications
annotations can become an overhead. It is easier to maintain if all the configurations
are in xml files.
When we are doing AOP, we have to make sure to keep the Joinpoint as narrow as
possible to avoid Advice on unwanted methods.
We should use right annotation for components or services. For services use @Service
and for DAO beans use @Repository. Dependency Injection (DI) has to be used when there
is real benefit. It should not be used just for the sake of loose coupling.

100. What is Spring Boot?

Spring Boot is a ready made solution to create Spring applications with production grade
features. It favors convention over configuration.
We can embed Tomcat or Jetty in in an application created with Spring Boot. Spring Boot
automatically configures Spring in an application.
It does not require any code generation or xml configuration. It is an easy solution to create
applications that can run stand-alone.

That’s all about Spring Interview Questions and Answers. You might study more about the
Spring framework tutorials

1. What is Hibernate framework?

Hibernate is a popular Object Relational Mapping (ORM) framework of Java. It helps
in mapping the Object Oriented Domain model to Relational Database tables.
Hibernate is a free software distributed under GNU license.

Hibernate also provides implementation of Java Persistence API (JPA).

In simple words, it is a framework to retrieve and store data from database tables from
Java.

2.What is an object Relational Mapping (ORM)?

Object Relational Mapping (ORM) is a programming technique to map data from a
relational database to Object oriented domain model. This is the core of Hibernate
framework.
In case of Java, most of the software is based on OOPS design. But the data stored in
Database is based on Relation Database Management System (RDBMS).
ORM helps in data retrieval in an Object Oriented way from an RDBMS. It reduces the
effort of developers in writing queries to access and insert data.

3.What is the purpose of Configuration Interface in Hibernate?

Configuration interface can be implemented in an application to specify the
properties and mapping documents for creating a SessionFactory in Hibernate.
By default, a new instance of Configuration uses properties mentioned in
hibernate.properties file.
Configuration is mainly an initialization time object that loads the properties in
helps in creating SessionFactory with these properties.
In short, Configuration interface is used for configuring Hibernate framework in an
application.

4.What is Object Relational Impedance Mismatch?

Object Relational Impedance Mismatch (ORIM) is also known as paradigm mismatch.
It means that Object model and Relational model do not work well with each other.
Relational model or a RDBMS represents data in tabular format like a spreadsheet.
Object model or OOPS represents the data as an inter-connected graph of objects.
Mixing these two models leads to various problems. The common name for these
issues is Object Relational Impedance Mismatch.

5.What are the main problems of Object Relational Impedance Mismatch?

Object model and Relational models (RDBMS) have following problems that are part
of Object Relational Impedance Mismatch:
Granularity: Object model is more granular than Relational model. There are more classes
in object model than the corresponding tables in relational model.
Inheritance: Object model supports inheritance. But Relational model does not have any
concept of inheritance.
Identity: Relational model has just one criteria for sameness of data. It is based on primary
key. In object model like Java we can have equals as well as == for sameness of objects.
Associations: In Object model associations are uni-directional. In RDBMS, there is a concept
of foreign key for association. Also multiplicity of a relationship is hard to judge by looking
at object model.
Data navigation: In Object model, you can move from one object to another object for
getting data. Egg. you can retrieve and Employee object, then go to its department object
and then get the employees in the department object. In RDBMS, we try to minimize the
SQL calls, so we get all the data by using joins.

6. What are the key characteristics of Hibernate?

Hibernate has following key characteristics:
Object/Relational Mapping (ORM): Hibernate provides ORM capabilities to developers. So
then can write code in Object model for connecting with data in Relational model.
JPA Provider: Hibernate provides an excellent implementation of Java Persistence API (JPA)
specification.
Idiomatic persistence: Hibernate provides persistence based on natural Object-oriented
idioms with full support for inheritance, polymorphism, association, composition, and the
Java collections framework. It can work with any data for persistence.
High Performance: Hibernate provides high level of performance supporting features like-
lazy initialization, multiple fetching strategies, optimistic locking etc. Hibernate does not
need its own database tables or fields. It can generate SQL at system initialization to
provide better performance at runtime.
Scalability: Hibernate works well in multi server clusters. It has built in scalability support. It
can work well for small projects as well as for large business software.
Reliable: Hibernate very reliable and stable framework. This is the reason for its worldwide
acceptance and popularity among developer community.
Extensible: Hibernate is quite generic in nature. It can be configured and extended as per
the use case of application.

7.Can you tell us about the core interfaces of Hibernate framework?

The core interfaces of Hibernate framework are as follows:
Configuration: Configuration interface can be implemented in an application to specify the
properties and mapping documents for creating a SessionFactory in Hibernate. Hibernate
application bootstraps by using this interface.
SessionFactory: In Hibernate, SessionFactory is used to create and manage Sessions.
Generally, there is one SessionFactory created for one database. It is a thread-safe
interface that works well in multithreaded applications.
Session: Session is a lightweight object that is used at runtime between a Java application
and Hibernate. It contains methods to create, read and delete operations for entity classes.
It is a basic class that abstracts the concept of persistence.
Transaction: This is an optional interface. It is a short lived object that is used for
encapsulating the overall work based on unit of work design pattern. A Session can have
multiple Transactions.
Query: This interface encapsulates the behavior of an objectoriented query in Hibernate. It
can accept parameters and execute the queries to fetch results. Same query can be
executed multiple times.
Criteria: This is a simplified API to retrieve objects by creating Criterion objects. It is very
easy to use for creating Search like features.

8.How will you map the columns of a DB table to the properties of a Java class in
Hibernate?
We can map the class properties and table columns by using one of the two ways:
XML: We can map the column of a table to the property of a class in XML file. It is generally
with extension hbm.xml
Annotation: We can also use annotations @Entity and @Table to map a column to the
property of a class.

9.Does Hibernate make it mandatory for a mapping file to have .hbm.xml extension?
No. It is a convention to have.hbm.xml extension in the name of a mapping file. It is
not a requirement enforced by Hibernate. We can use any other extension of our
convenience for this.

10. What are the steps for creating a SessionFactory in Hibernate?

Steps to create a SessionFactory in Hibernate are:
Configuration: First create a Configuration object. This will refer to the path of
configuration file.
Resource: Add config file resource to Configuration object.
Properties: Set properties in the Configuration object.
SessionFactory: Use Configuration object to build SessionFactory.
Egg.

1 Configuration config = new Configuration();

2 config.addResource(“testInstance/configuration.
3 hbm.xml”);
4 config.setProperties( System.getProperties() );
SessionFactory sessions =
config.buildSessionFactory();
11.Why do we use POJO in Hibernate?
POJO stands for Plain Old Java Objects. A POJO is java bean with getter and setter
methods for each property of the bean.
It is a simple class that encapsulates an object’s properties and provides access
through setters and getters.
Some of the reasons for using POJO in Hibernate are:
POJO emphasizes the fact that this class is a simple Java class, not a heavy class like
EJB.
POJO is a well-constructed class, so it works well with Hibernate proxies.
POJO also comes with a default constructor that makes it easier to persist with a
default constructor.

12. What is Hibernate Query Language (HQL)?

Hibernate Query Language is also known as HQL. It is an Object Oriented language.
But it is similar to SQL.
HQL works well with persistent objects and their properties. HQL does not work on
database tables. HQL queries are translated into native SQL queries specific to a
database.
HQL supports direct running of native SQL queries also. But it creates an issue in
Database portability.

13.How will you call a stored procedure in Hibernate?

Hibernate supports executing not only simple queries but also stored procedure of
database. There are three ways to call a stored procedure in Hibernate:
XML mapping file: We can declare the store procedure inside XML Mapping file.
 1 <!-- Employee.hbm.xml -->
2 ...
3 <hibernate-mapping>
4 <class
5 name="com.testHibernate.util.Employee"
6 table="employee" ...>
7 <id name="employeeId"
8 type="java.lang.Integer">
9 <column name=“EMPLOYEE_ID" />
10 <generator class="identity" />
11 </id>
12 <property name="employeeId" type="string">
13 <column name="EMPLOYEE_ID" length="10"
14 notnull="true" unique="true" />
15 </property>
16 </class>
17 <sql-query
18 name="callEmployeeStoreProcedure">
19 <return alias="employee"
class="com.testHibernate.util.Employee"/>
<![CDATA[CALL GetEmployees(:employeeId)]]>
</sql-query>
</hibernate-mapping>
We can call it with getNamedQuery().

1 Query query
2 =session.getNamedQuery("callEmployeeStorePr
3 ocedure")
4 .setParameter("employeeId", “1234”);
5 List result = query.list();
6 for(int i=0; i<result.size(); i++){
7 Employee employee =
(Employee)result.get(i);

System.out.println(employee.getEmployeeCode(
));
}
Native SQL: We can use Native SQL to call a store procedure query directly. In this example
GetEmployees() stored procedure is being called.

1 Query query = session.createSQLQuery("CALL

2 GetEmployees(:employeeId)")
3 .addEntity(Employee.class)
4 .setParameter("employeeId", “1234);
5 List result = query.list();
6 for(int i=0; i<result.size(); i++){
7 Employee employee = (Employee)
8 result.get(i);

System.out.println(employee.getEmployeeCode(
));
}
Use annotation: We can also mark out stored procedure with @NamedNativeQueries
annotation.

1 //Employee.java
2 @NamedNativeQueries({
3 @NamedNativeQuery(
4 name = "callEmployeeStoreProcedure",
5 query = "CALL GetEmployees(:employeeId)",
6 resultClass = Employee.class
7 )})
8 @Entity@Table(name = "employee")
9 public class Employee implements
10 java.io.Serializable {
...
Call it with getNamedQuery().

1 Query query =
2 session.getNamedQuery("callEmployeeStoreProc
3 edure")
4 .setParameter("employeeId", “1234”);
5 List result = query.list();
6 for(int i=0; i<result.size(); i++){
7 Employee employee =
(Employee)result.get(i);

System.out.println(employee.getEmployeeCode(
));
}
14. What is Criteria API in Hibernate?
Criteria is a simplified API in Hibernate to get entities from database by creating
Criterion objects.
It is a very intuitive and convenient approach for search features.
Users can specify different criteria for searching entities and Criteria API can handle
these.
Criterion instances are obtained through factory methods on Restrictions.

15. Why do we use HibernateTemplate?

This is a trap question. HibernateTemplate has been deprecated.
There were earlier good reasons to use HibernateTemplate. But now the trend has
changed towards not using it anymore.

16. How can you see SQL code generated by Hibernate on console?
To display the SQL generated by Hibernate, we have to turn on the show_sql flag.
This can be done in Hibernate configuration as follows:

1 <property
name=”show_sql”>true</property>
17. What are the different types of collections supported by Hibernate?
Hibernate supports following two types of collections:
Indexed Collections: List and Maps
Sorted Collections: java.util.SortedMap and java.util.SortedSet

18. What is the difference between session.save() and session.saveOrUpdate()

methods in Hibernate?
Save method first stores an object in the database. Then it persists the given
transient instance by assigning a generated identifier.
Finally, it returns the id of the entity that is just created. SaveOrUpdate() method
calls either save() or update() method. It selects one of these methods based on the
existence of identifier.
If an identifier exists for the entity then update() method is called. If there is no
identifier for the entity then save() method is called as mentioned earlier.

19. What are the advantages of Hibernate framework over JDBC?

Main advantages of Hibernate over JDBC are as follows:
Database Portability: Hibernate can be used with multiple types of database with easy
portability. In JDBC, developer has to write database specific native queries. These native
queries can reduce the database portability of the code.
Connection Pool: Hibernate handles connection pooling very well. JDBC requires
connection pooling to be defined by developer.
Complexity: Hibernate handles complex query scenarios very well with its internal API like
Criteria. So developer need not gain expertise in writing complex SQL queries. In JDBC
application developer writes most of the queries.

20. How can we get statistics of a SessionFactory in Hibernate?

In Hibernate we can get the statistics of a SessionFactory by using Statistics
interface. We can get information like Close Statement count, Collection Fetch count,
Collection Load count, Entity insert count etc.

21. What is the Transient state of an object in Hibernate?

When an object is just instantiated using the new operator but is not associated with
a Hibernate Session, then the object is in Transient state.
In Transient state, object does not have a persistent representation in database. Also
there is no identifier assigned to an object in Transient state.
An object in Transient state can be garbage collected if there is no reference pointing
to it.

22. What is the Detached state of an object in Hibernate?

An object is in detached state if it was persistent earlier but its Session is closed now.
Any reference to this object is still valid. We can even update this object. Later on we
can even attach an object in detached state to a new session and make it persistent.
Detached state is very useful in application transactions where a user takes some
time to finish the work.

23.What is the use of Dirty Checking in Hibernate?

Dirty Checking is very useful feature of Hibernate for write to database operations.
Hibernate monitors all the persistent objects for any changes. It can detect if an
object has been modified or not.
By Dirty Checking, only those fields of an object are updated that require any change
in them. It reduces the time-consuming database write operations.

24. What is the purpose of Callback interface in Hibernate?

Callback interface in Hibernate is mainly used for receiving notifications of different
events from an object.
Egg. We can use Callback to get the notification when an object is loaded into or
removed from database.

25. What are the different ORM levels in Hibernate?

There are following four different ORM levels in Hibernate:
Pure Relational ORM: At this level entire application is designed around the relational
model. All the operations are SQL based at this level.
Light Object Mapping: At this level entity classes are mapped manually to relational tables.
Business logic code is hidden from data access code. Applications with less number of
entities use this level.
Medium Object Mapping: In this case, application is designed around an object model.
Most of the SQL code is generated at compile time. Associations between objects are
supported by the persistence mechanism. Object-oriented expression language is used to
specify queries.
Full Object Mapping: This is one of the most sophisticated object modeling level. It supports
composition, inheritance, polymorphism and persistence. The persistent classes do not
inherit any special base class at this level. There are efficient fetching and caching
strategies implemented transparently to the application.

26. What are the different ways to configure a Hibernate application?

There are mainly two ways to configure Hibernate application:
XML based: We can define the Hibernate configuration in an XML file like
ibernate.cfg.xml file
Programming based: We can also use code logic to configure Hibernate in our
application.

27. What is Query Cache in Hibernate?

Hibernate provides Query Cache to improve the performance of queries that run
multiple times with same parameters.
At times Query Caching can reduce the performance of Transactional processing. By
default Query Cache is disabled in Hibernate.
It has to be used based on the benefits gained by it in performance of the queries in
an application.

28. What are the different types of Association mappings supported by Hibernate?
Hibernate supports following four types of Association mappings:
Unidirectional association: This kind of association works in only one
direction.Unidirectional association with join tables
Bidirectional association: This kind of association works in both directions. Bidirectional
association with join tables

29. What are the different types of Unidirectional Association mappings in

Hibernate?
In Hibernate there can be following three types of Unidirectional Association
mappings:

 Many to one
 One to one
 One to many

30. What is Unit of Work design pattern?

Unit of Work is a design pattern to define business transactions. A Unit of Work is a
list of ordered operations that we want to run on a database together. Either all of
these go together or none of these goes.
Most of the time, we use term business transaction in place of Unit of Work.
Egg. In case of money transfer from account A to B, the unit of work can be two
operation Debit account A and Credit account B in a sequence. Both these operations
should happen together and in right sequence.

31. In Hibernate, how can an object go in Detached state?

Once the session attached to an Object is closed, the object goes into Detached state.
An Object in Detached state can be attached to another session at a later point of
time.
This state is quite useful in concurrent applications that have long unit of work.

32. How will you order the results returned by a Criteria in Hibernate?
Hibernate provides an Order criterion that can be used to order the results. This can
be order objects based on their property in ascending or descending order. Class is
org.hibernate.criterion.Order. One example is as follows:
Egg.
 1 List employees =
2 session.createCriteria(Employee.class)
3 .add( Restrictions.like("name", "F%")
4 .addOrder( Order.asc("name") )
5 .addOrder( Order.desc("age") )
6 .setMaxResults(10)
.list();
33. How does Example criterion work in Hibernate?
In Hibernate, we can create an object with desired properties. Then we can use this
object to search for objects with similar object. For this we can use
org.hibernate.criterion.Example criterion.
Egg. First we create a sample book object of author Richard and category mystery.
Then we search for similar books.

1 Book book = new Book();

2 book.setAuthor(‘Richard’);
3 book.setCategory(Category.MYSTERY);
4 List results = session.createCriteria(Book.class)
5 .add( Example.create(book) )
6 .list();
34. How does Transaction management work in Hibernate?
In Hibernate we use Session interface to get a new transaction.
Once we get the transaction we can run business operations in that transaction. At
the end of successful business operations, we commit the transaction. In case of
failure, we rollback the transaction.
Sample code is a follows:

1 Session s = null;
2 Transaction trans = null;
3 try {
4 s = sessionFactory.openSession();
5 trans = s.beginTransaction();
6 doTheAction(s);
7 trans.commit();
8 } catch (RuntimeException exc) {
9 trans.rollback();
10 } finally {
11 s.close();
12 }
35. How can we mark an entity/collection as immutable in Hibernate?
In Hibernate, by default an entity or collection is mutable. We can add, delete or
update an entity/collection.
To mark an entity/collection as immutable, we can use one of the following:
@Immutable: We can use the annotation @Immutable to mark an entity/collection
immutable.
XML file: We can also set the property mutable=false in the XML file for an entity to make it
immutable.
36. What are the different options to retrieve an object from database in Hibernate?
In Hibernate, we can use one of the following options to retrieve objects from
database:
Identifier: We can use load() or get() method and pass the identifier like primary key to
fetch an object from database.
HQL: We can create a HQL query and get the object after executing the query.
Criteria API: We can use Criteria API to create the search conditions for getting the objects
from database.
Native SQL: We can write native SQL query for a database and just execute it to get the
data we want and convert it into desired object.

37. How can we auto-generate primary key in Hibernate?

We can use the primary key generation strategy of type GenerationType.AUTO to
auto-generate primary key while persisting an object in Hibernate.
Egg.

1 @Id
2 @GeneratedValue(strategy=GenerationType.AUT
3 O)
private int id;
We can leave it null/0 while persisting and Hibernate automatically generates a primary key
for us.
Sometimes, AUTO strategy refers to a SEQUENCE instead of an IDENTITY .

38. How will you re-attach an object in Detached state in Hibernate?

We can call one of the methods Session.update(), Session.saveOrUpdate(), or
Session.merge() to re-attach an object in detached state with another session in
Hibernate.

39. What is the first level of cache in Hibernate?

A Hibernate Session is the first level of cache for persistent data in a transaction.
The second level of cache is at JVM or SessionFactory level.

40. What are the different second level caches available in Hibernate?

In Hibernate, we can use different cache providers for implementing second level cache at
JVM/SessionFactory level. Some of these are:

 Hashtable
 EHCache
 OSCache
 SwarmCache
  JBoss Cache 1.x
 JBoss Cache 2

41. Which is the default transaction factory in Hibernate?

In Hibernate, default transaction factory is JDBCTransactionFactory. But we can
change it by setting the
property hibernate.transaction.factory_class.

42. What are the options to disable second level cache in Hibernate?
This is a trick question. By default Second level cache is already disabled in
Hibernate.
In case, your project is using a second level cache you can use one of the following
options to disable second level cache in Hibernate:
We can set hibernate.cache.use_second_level_cache to false.
We can use CacheMode.IGNORE to stop interaction between the session and second-level
cache. Session will interact with cache only to invalidate cache items when updates occur

43.What are the different fetching strategies in Hibernate?

Hibernate 3 onwards there are following fetching strategies to retrieve associated
objects:
Join fetching: In Join strategy Hibernate uses OUTER join to retrieve the associated
instance or collection in the same SELECT.
Select fetching: In Select strategy, Hibernate uses a second SELECT to retrieve the
associated entity or collection. We can explicitly disable lazy fetching by specifying
lazy=”false”. By default lazy fetching is true.
Subselect fetching: In Subselect strategy, Hibernate uses a second SELECT to retrieve the
associated collections for all entities retrieved in a previous query or fetch.
Batch fetching: In Batch strategy, Hibernate uses a single SELECT to retrieve a batch of
entity instances or collections by specifying a list of primary or foreign keys. This is a very
good performance optimization strategy for select fetching.

44. What is the difference between Immediate fetching and Lazy collection fetching?
In Immediate fetching an association, collection or attribute is retrieved at the same
time when the owner is loaded.But in Lazy collection fetching, a collection is fetched
only when an operation is invoked on that collection by client application.
This is the default fetching strategy for collections in Hibernate. Lazy fetching is
better from performance perspective.

45. What is ‘Extra lazy fetching’ in Hibernate?

In Extra lazy fetching, only individual elements of a collection are fetched from the
database when they are required.
In this strategy, Hibernate does not fetch the whole collection into memory unless it
is essential. It is a good fetching strategy for large collections of objects.

46. How can we check is a collection is initialized or not under Lazy Initialization
strategy?
Hibernate provides two convenient methods, Hibernate.initialize() and
Hibernate.isInitialized() to check whether a collection is initialized or not.
By using Hibernate.initialize() we can force the initialization of a collection in
Hibernate.

47. What are the different strategies for cache mapping in Hibernate?
Hibernate provides following strategies for cache mapping:
Read only: If an application requires caching only for read but not for write operations,
then we can use this strategy. It is very simple to use and give very good performance
benefit. It is also safe to use in a cluster environment.
Read/Write: If an application also needs caching for write operations, then we use
Read/Write strategy.
Read/write cache strategy should not be used if there is requirement for serializable
transaction isolation level. If we want to use it in a cluster environment, we need to
implement locking mechanism.
Nonstrict Read/Write: If an application only occasionally updates the data, then we can use
this strategy. It cannot be used in systems with serializable transaction isolation level
requirement.
Transactional: This strategy supports full transactional cache providers like JBoss
TreeCache.

48. What is the difference between a Set and a Bag in Hibernate?

A Bag in Hibernate is an unordered collection. It can have duplicate elements. When
we persist an object in a bag, there is no guarantee that bag will maintain any order.
A Set in Hibernate can only store unique objects. If we add the same element to set
second time, it just replaces the old one. By default a Set is unordered collection in
Hibernate.

49. How can we monitor the performance of Hibernate in an application?

We can use following ways to monitor Hibernate performance:
Monitoring SessionFactory: Since there is one SessionFactory in an application, we can
collect the statistics of a SessionFactory to monitor the performance. Hibernate provides
sessionFactory.getStatistics() method to get the statistics of SessionFactory. Hibernate can
also use JMX to publish metrics.
Metrics: In Hibernate we can also collect other metrics likenumber of open sessions,
retrieved JDBC connections, cache hit, miss etc.
These metrics give great insight into the performance of Hibernate. We can tune Hibernate
settings and strategies based on these metrics.

50. How can we check if an Object is in Persistent, Detached or Transient state in

Hibernate?
We can use following methods to check the state of an object in Hibernate:
Persistent State: If call to EntityManager.contains(object) returns true, the object is in
Persistent state.
Detached State: If the call to PersistenceUnitUtil.getIdentifier(object) returns identifier
property then the object is in detached state.
Transient State: If call to PersistenceUnitUtil.getIdentifier(object) returns null then object is
in Transient state. We can get access to PersistenceUnitUtil from the EntityManagerFactory
in Hibernate.

51. What is ‘the inverse side of association’ in a mapping?

Let us consider an example in which a customer can have multiple orders and for
every order there has to be a customer. In OO world, customer is the owner of order.
In SQL world, an Order has reference to customer id.
It is a bi-directional one to many mapping from customer to order. The inverse side
in this mapping is the owner of object. In this case customer is the owner or order.
Since an order cannot exist without a customer. But a customer can exist without an
order.
Also customer has no column to save order data. But an Order table can store
customer id, which is used for mapping.

52. What is ORM metadata?

ORM uses metadata for its internal work. ORM maintains metadata to generate code
used for accessing columns and tables.
ORM maps classes to tables and stores this information in Metadata. It maps fields in
classes to columns in tables. These kinds of mappings are also part of Metadata.
Application developers can also access Hibernate Metadata by using ClassMetadata
and CollectionMetadata interfaces and Type hierarchy.

53.What is the difference between load() and get() method in Hibernate?

In Hibernate, load() and get() methods are quite similar in functionality.
The main difference is that load() method will throw an ObjectNotFoundException if
row corresponding to an object is not found in the database.
On the other hand, get() method returns null value when an object is not found in
the database.
It is recommended that we should use load() method only when we are sure that
object exists in database.
54. When should we use get() method or load() method in Hibernate?
As a thumb rule we can follow these guidelines:
We should use get() method when we want to load an object.
We should use load() method when we need a reference to an object without running
extra SQL queries.

55. What is a derived property in Hibernate?

In Hibernate, a derived property is not mapped to any column of a database table. A
derived property is computed at runtime by evaluation of an expression. These are
read only properties.
Egg. In this example profitMargin is derived from salePrice and buyPrice.

1 <property name="profitMargin"
formula="( SELECT (i.salePrice – i.buyPrice)
FROM item i WHERE i.Id = Id)"/>
56. How can we use Named Query in Hibernate?
A Named SQL query is the HQL query that is associated with a string name and can
be referenced in the application by name. It can be used in following ways:
XML Mapping File: We can define it in XML mapping file.
Egg.

1 <query name="findBookByAuthor”>
2 <![CDATA[from Book s where s.author =
3 :author]]>
</query>
Annotation: We can also mark Named SQL with annotation.

1 @NamedQueries({
2 @NamedQuery(
3 name = "findBookByAuthor”,
4 query = "from Book s where s.author = :author”
5 )
6 })
57. What are the two locking strategies in Hibernate?
There are two popular locking strategies that can be used in Hibernate:
Optimistic: In Optimistic locking we assume that multiple transactions can complete
without affecting each other. So we let the transactions do their work without locking the
resources initially.
Just before the commit, we check if any of the resource has changed by another
transaction, then we throw exception and rollback the transaction.
Pessimistic: In Pessimistic locking we assume that concurrent transactions will conflict
while working with same resources. So a transaction has to first obtain lock on the
resources it wants to update.
The other transaction can proceed with same resource only after the lock has been
released by previous transaction.
58. What is the use of version number in Hibernate?
Version number is used in optimistic locking in Hibernate. When a transaction
modifies an object, it increments its version. Based on version number, second
transaction can determine if the object it has
read earlier has changed or not.
If the version number at the time of write is different than the version number at
the time of read, then we should not commit the transaction.

59. What is the use of session.lock() method in Hibernate?

Session.lock() is a deprecated method in Hibernate. We should not use it. Instead we
should call
buildLockRequest(LockMode).lock(entityName, object) method in Hibernate.

60. What inheritance mapping strategies are supported by Hibernate?

Hibernate supports following inheritance mapping strategies between classes and
tables:
Table per class hierarchy: In case of multiple types of books, we can have one book class
and one book table. We can store all child classes of book like- HardCoverBook,
PaperBackBook etc in same table book. But we can identify the subclasses by a BookType
column in Book table.
Table per subclass: In this case we can have separate table for each kind of book.
HardCoverBook table for HardCoverBook book class. PaperBackBook table for
PaperBackBook book class. And there will be a parent table, Book for Book class.
Table per concrete class: In this case also we have separate table for each kind of book. But
in this case we have even inherited properties defined inside each table. There is no parent
table Book for Book class, since it is not a concrete class.