Spring Interview Questions

Dear perusers, these Spring Interview Questions have been structured uncommonly to get you familiar with the idea of inquiries you may experience amid your meeting for the subject of Spring. According to my experience great questioners scarcely plan to make a specific inquiry amid your meeting, ordinarily questions begin with some essential idea of the subject and later they proceed with dependent on further exchange and what you answer:

Spring is an open source improvement system for big business Java. The center highlights of the Spring Framework can be utilized in building up any Java application, however there are expansions for building web applications over the Java EE stage. Spring system focuses to make J2EE advancement simpler to utilize and advance great programming practice by empowering a POJO-based programming model.

Following is the rundown of few of the incredible advantages of utilizing Spring Framework:

  • Lightweight − Spring is lightweight with regards to size and straightforwardness. The essential adaptation of spring system is around 2MB.

  • Inversion of control (IOC) − Loose coupling is accomplished in spring utilizing the method Inversion of Control. The articles give their conditions as opposed to making or searching for ward objects.

  • Aspect arranged (AOP) − Spring underpins Aspect situated programming and empowers durable improvement by isolating application business rationale from framework services.

  • Container − Spring contains and deals with the existence cycle and setup of utilization objects.

  • MVC Framework − Spring's web system is an all around planned web MVC structure, which gives an extraordinary choice to web structures, for example, Struts or other over designed or less mainstream web frameworks.

  • Transaction Management − Spring gives a steady exchange the board interface that can downsize to a neighborhood exchange (utilizing a solitary database, for instance) and scale up to worldwide exchanges (utilizing JTA, for example).

  • Exception Handling − Spring gives a helpful API to interpret innovation explicit special cases (tossed by JDBC, Hibernate, or JDO, for instance) into reliable, unchecked exceptions.

Following are the modules of the Spring framework:

  • Core module
  • Bean module
  • Context module
  • Expression Language module
  • JDBC module
  • ORM module
  • OXM module
  • Java Messaging Service(JMS) module
  • Transaction module
  • Web module
  • Web-Servlet module
  • Web-Struts module
  • Web-Portlet module

Spring arrangement record is a XML document. This record contains the classes data and portrays how these classes are arranged and acquainted with each other.

Inversion of Control (IoC) is a general idea, and it very well may be communicated from numerous points of view and Dependency Injection is simply one solid case of Inversion of Control.

This idea says that you don't make your articles yet depict how they ought to be made. You don't specifically associate your parts and administrations together in code yet portray which administrations are required by which segments in a setup record. A compartment (the IOC holder) is then in charge of snaring everything up.

Types of IoC are −

  • Constructor-based reliance injection − Constructor-based DI is cultivated when the holder summons a class constructor with various contentions, each speaking to a reliance on other class.

  • Setter-based reliance injection − Setter-based DI is practiced by the compartment calling setter strategies on your beans in the wake of summoning a no-contention constructor or no-contention static processing plant strategy to instantiate your bean.

Since you can blend both, Constructor-and Setter-based DI, it is a decent standard guideline to utilize constructor contentions for obligatory conditions and setters for discretionary conditions. Note that the utilization of a @Required explanation on a setter can be utilized to make setters required dependencies.

The principle advantages of IOC or reliance infusion are −

  • It limits the measure of code in your application.

  • It makes your application simple to test as it doesn't require any singletons or JNDI query systems in your unit test cases.

  • Loose coupling is advanced with insignificant exertion and least nosy mechanism.

  • IOC compartments bolster excited instantiation and languid stacking of services.

Aspect-arranged programming, or AOP, is a programming strategy that enables software engineers to modularize crosscutting concerns, or conduct that cuts over the commonplace divisions of obligation, for example, logging and exchange the executives. The center develop of AOP is the perspective, which typifies practices influencing various classes into reusable modules.

The Spring IoC makes the articles, wire them together, design them, and deal with their total lifecycle from creation till demolition. The Spring holder utilizes reliance infusion (DI) to deal with the segments that make up an application.

There are two kinds of IoC compartments −

  • Bean Factory container − This is the least complex compartment giving essential help to DI .The BeanFactory is normally favored where the assets are constrained like cell phones or applet based applications

  • Spring ApplicationContext Container − This holder includes more endeavor explicit usefulness, for example, the capacity to determine literary messages from a properties record and the capacity to distribute application occasions to intrigued occasion listeners.

The most ordinarily utilized BeanFactory usage is the XmlBeanFactory class. This compartment peruses the setup metadata from a XML document and uses it to make a completely arranged framework or application.

The three usually utilized execution of 'Utilization Context' are −

  • FileSystemXmlApplicationContext − This holder stacks the meanings of the beans from a XML document. Here you have to give the full way of the XML bean setup record to the constructor.

  • ClassPathXmlApplicationContext − This compartment stacks the meanings of the beans from a XML document. Here you don't have to give the full way of the XML record yet you have to set CLASSPATH appropriately on the grounds that this holder will look bean setup XML document in CLASSPATH.

  • WebXmlApplicationContext − This holder stacks the XML document with meanings of all beans from inside a web application.

Following are a portion of the distinctions −

  • Application settings give a way to settling instant messages, including support for i18n of those messages.

  • Application settings give a conventional method to stack document assets, for example, images.

  • Application settings can distribute occasions to beans that are enlisted as listeners.

  • Certain tasks on the compartment or beans in the holder, which must be taken care of in an automatic design with a bean industrial facility, can be dealt with definitively in an application context.

  • The application setting executes MessageSource, an interface used to get confined messages, with the real usage being pluggable.

The objects that structure the foundation of your application and that are overseen by the Spring IoC holder are called beans. A bean is an article that is instantiated, collected, and generally overseen by a Spring IoC compartment. These beans are made with the arrangement metadata that you supply to the compartment, for instance, as XML <bean/> definitions.

The bean definition contains the data called design metadata which is required for the compartment to know the followings −

  • How to make a bean
  • Bean's lifecycle details
  • Bean's dependencies

There are following three critical strategies to give arrangement metadata to the Spring Container −

  • XML based arrangement file.
  • Annotation-based configuration
  • Java-based configuration

Check the accompanying model −


<?xml variant = "1.0" encoding = "UTF-8"?> 

<beans xmlns = "http://www.springframework.org/outline/beans" 

xmlns:xsi = "http://www.w3.org/2001/XMLSchema-case" 

xsi:schemaLocation = "http://www.springframework.org/outline/beans 


<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"> 

<property name = "message" esteem = "Hi World!"/> 



When characterizing a <bean> in Spring, you have the alternative of proclaiming an extension for that bean. For instance, to drive Spring to create another bean case each time one is required, you ought to proclaim the bean's extension credit to be prototype. Comparable way on the off chance that you need Spring to restore a similar bean occasion each time one is required, you ought to pronounce the bean's degree ascribe to be singleton.

The Spring Framework bolsters following five extensions, three of which are accessible just on the off chance that you utilize a web-mindful ApplicationContext.

  • singleton − This degrees the bean definition to a solitary occasion for every Spring IoC container.

  • prototype − This degrees a solitary bean definition to have any number of article instances.

  • request − This extensions a bean definition to a HTTP ask. Just legitimate with regards to a web-mindful Spring ApplicationContext.

  • session − This degrees a bean definition to a HTTP session. Just legitimate with regards to a web-mindful Spring ApplicationContext.

  • global-session − This degrees a bean definition to a worldwide HTTP session. Just legitimate with regards to a web-mindful Spring ApplicationContext.

The default extent of bean is Singleton for Spring framework.

No, singleton beans are not string safe in Spring framework.

Following is grouping of a bean lifecycle in Spring −

  • Instantiate − First the spring compartment finds the bean's definition from the XML document and instantiates the bean..

  • Populate properties − Using the reliance infusion, spring populates the majority of the properties as determined in the bean definition.

  • Set Bean Name − If the bean actualizes BeanNameAware interface, spring passes the bean's id to setBeanName() method.

  • Set Bean factory − If Bean actualizes BeanFactoryAware interface, spring passes the beanfactory to setBeanFactory() method.

  • Pre Initialization − Also called postprocess of bean. In the event that there are any bean BeanPostProcessors related with the bean, Spring calls postProcesserBeforeInitialization() method.

  • Initialize beans − If the bean actualizes IntializingBean,its afterPropertySet() technique is called. On the off chance that the bean has init technique presentation, the predefined instatement strategy is called.

  • Post Initialization − If there are any BeanPostProcessors related with the bean, their postProcessAfterInitialization() strategies will be called.

  • Ready to use − Now the bean is prepared to use by the application.

  • Destroy − If the bean actualizes DisposableBean , it will call the decimate() strategy .

A <bean/> component inside the <property/> or <constructor-arg/> components characterizes a supposed inward bean. An internal bean definition does not require a characterized id or name; the holder overlooks these qualities. It likewise disregards the extension banner. Inward beans are constantly mysterious and they are constantly perused as prototypes.

Spring offers four kinds of gathering design components which are as per the following −

  • <list> − This aides in wiring for example infusing a rundown of qualities, permitting duplicates.

  • <set> − This aides in wiring a lot of esteems yet with no duplicates.

  • <map> − This can be utilized to infuse an accumulation of name-esteem sets where name and esteem can be of any type.

  • <props> − This can be utilized to infuse a gathering of name-esteem sets where the name and esteem are both Strings.

The Spring compartment can autowire connections between teaming up beans. This implies it is conceivable to consequently let Spring settle associates (different beans) for your bean by reviewing the substance of the BeanFactory without utilizing <constructor-arg> and <property> elements.

The autowiring usefulness has five modes which can be utilized to teach Spring holder to utilize autowiring for reliance infusion −

  • no − This is default setting which implies no autowiring and you should utilize express bean reference for wiring. You don't have anything to do uncommon for this wiring. This is the thing that you as of now have found in Dependency Injection chapter.

  • byName − Autowiring by property name. Spring compartment takes a gander at the properties of the beans on which autowire ascribe is set to byName in the XML design record. It at that point attempts to match and wire its properties with the beans characterized by similar names in the design file.

  • byType − Autowiring by property datatype. Spring holder takes a gander at the properties of the beans on which autowire ascribe is set to byType in the XML setup document. It at that point endeavors to match and wire a property if its sort matches with precisely one of the beans name in arrangement record. In the event that more than one such beans exist, a lethal special case is thrown.

  • constructor − Similar to byType, however type applies to constructor contentions. In the event that there isn't actually one bean of the constructor contention type in the holder, a lethal mistake is raised.

  • autodetect − Spring first attempts to wire utilizing autowire by constructor, on the off chance that it doesn't work, Spring attempts to autowire by byType.

Limitations of autowiring are −

  • Overriding possibility − You can even now indicate conditions utilizing <constructor-arg> and <property> settings which will dependably abrogate autowiring.

  • Primitive information types − You can't autowire supposed basic properties, for example, natives, Strings, and Classes.

  • Confusing nature − Autowiring is less precise than unequivocal wiring, so if conceivable incline toward utilizing express wiring.


An option to XML setups is given by explanation put together design which depends with respect to the bytecode metadata for wiring up parts rather than point section announcements. Rather than utilizing XML to depict a bean wiring, the designer moves the setup into the part class itself by utilizing explanations on the applicable class, strategy, or field declaration.

Annotation wiring isn't turned on in the Spring compartment as a matter of course. Thus, before we can utilize comment based wiring, we should empower it in our Spring arrangement record by designing <context:annotation-config/>.

This explanation essentially shows that the influenced bean property must be populated at design time, through an express property estimation in a bean definition or through autowiring. The compartment tosses BeanInitializationException if the influenced bean property has not been populated.

This explanation gives all the more fine-grained command over where and how autowiring ought to be practiced. The @Autowired comment can be utilized to autowire bean on the setter technique simply like @Required explanation, constructor, a property or strategies with self-assertive names as well as different arguments.

There might be a circumstance when you make more than one bean of a similar kind and need to wire just a single of them with a property, in such case you can utilize @Qualifier explanation alongside @Autowired to evacuate the perplexity by indicating which careful bean will be wired.

Spring has JSR-250 based explanations which incorporate @PostConstruct, @PreDestroy and @Resource annotations.

  • @PostConstruct − This explanation can be utilized as an other of introduction callback.

  • @PreDestroy − This explanation can be utilized as an other of obliteration callback.

  • @Resource − This explanation can be utilized on fields or setter strategies. The @Resource comment takes a 'name' quality which will be deciphered as the bean name to be infused. You can say, it pursues by-name autowiring semantics.

© Javacodegeeks 2018 -2019
All Right Reserved and you agree to have read and accepted our term and condition.

Python 3