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.
<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.
<bean id="employee" class="com.dept.Employee">
<property name="manager" ref="manager" />
<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.
<bean id="employee" 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.
<bean id="employee" 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.
<bean id="employee" 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.
<bean id="employee" 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.