Spring interview questions

The differences between Bean Factory and Application Context are as follows:

• Bean Factory is an interface defined in org.springframework.beansfactory.BeanFactory, while Application Context is an interface defined, is org.springframework.context.ApplicationContext
• While the former uses lazy initialization the latter uses aggressive initialization
• While the former explicitly provide for resource object using the syntax the latter creates and manages resource objects on its own
• The former doesn’t support internationalization while the latter does.
• The former doesn’t support annotation-based dependency while the latter does.

AOP or Aspect oriented programming is a technique in programming with the help of which programmers can modularize the crosscutting concerns or change the behavior that cuts across the various divisions of responsibility. Some of the examples of crosscutting concerns are logging well as transaction management. The center of AOP is an aspect. This encapsulates behaviors that can affect multiple classes into modules that can be reused.

An Action, which is taken by any aspect at a particular join point, is called an Advice. AOPs use an advice as an interceptor that maintains a train of interceptors near the join point.
Various types of advice are as follows:

• Before: These are types of advices, which get executed before the join point methods and can be configured using @Before annotation mark.
• After returning: These are the types of advices which get executed after the join point methods completes executing and the annotation mark used to configure it is @AfterReturning
• After throwing:  These are the types of advices that execute only and only if join point method returns by exiting an exception and annotation mark used to configure it is @AfterThrowing.
• After (finally): These are the types of advices which gets executed after a join point method, not concerning whether the method’s exit normally or exceptional return and it can be configured using @After annotation mark.
• Around: These are the types of advices that get executed before and after a join point and can be configured using the @Around annotation mark.

The objects, which are most important for the user’s application and are managed by the containers of Spring IoC are called beans. A bean is an object that is initialized, put together, and is managed by a Spring IoC container. The beans are created with the help of configuration metadata that are supplied to the container by the users.

The Spring Framework makes use of five scopes. Three of these scopes are valid only if it is in the form of a web-aware Application Context.

• Singleton: This is the scope that the bean defines to a single instance for each Spring IoC container.
• Prototype: This is the scopes that a bean defines to have any number of object instances.
• Request: This is the scopes that a bean defines as per HTTP requests. This is valid in the form of a web-aware Spring Application Context
• Session: This is the scopes that a bean defines to an HTTP session. This is valid in the form of a web-aware Spring Application Context
• Global-session: This is the scopes that a bean defines to a global HTTP session. This is valid in the form of a web-aware Spring Application Context.

One can configure spring into an application using three different ways. They are:

• Using XML Configuration
• Using Annotation configuration
• Using Java configuration

Following are the disadvantages of auto wiring:

• Overriding possibility – Despite using auto wiring one can still use dependencies like <property> and <constructor-arg> settings, which always can override auto wiring.
• Primitive data types − one cannot auto wire some simple properties like classes, strings, and primitives etc.
• Confusing nature – Auto wiring is less exact than explicit wiring and thus it is not preferred if explicit wiring can be used.

A module in spring which contains a set of APIs, which provides for crosscutting requirements is an Aspect. For example, a module that is used in logging is called AOP aspect for logging. Any application can have as many aspects as per requirement.

Join point is a point in an application where one can initialize an AOP aspect. One can also define it as the exact place in the application where an action is said to take place while using spring framework.

The bean definition is made of the information called configuration metadata, which is required by the container to have knowledge about the followings −

• How bean can be created
• Details about the bean’s lifecycle

On what factors Bean’s lifecycle depends

Pointcut is a collection of one or more join points where one advice can be executed. One can specify pointcut using patterns as well as expressions.

Weaving is the process by which aspects can be linked with other application objects for creating the required object.