Latest 130 Spring Interview Questions

Introduction

Are you preparing for a Spring framework interview? Well, you’re in the right place! Spring is a widely used Java framework that simplifies the development of enterprise-level applications. To help you ace your interview, we’ve compiled a list of commonly asked Spring interview questions. From the basics of dependency injection and inversion of control to advanced topics like AOP and Spring MVC, we’ve got you covered. Whether you’re a beginner or an experienced developer, these questions will test your knowledge and ensure you’re well-prepared. So, let’s dive in and explore the world of Spring together!

Basic Questions

1. What is Spring Framework?

The Spring Framework is an open-source Java platform that provides comprehensive infrastructure support for developing Java applications. It enables developers to build enterprise-level applications with ease by offering features like dependency injection, aspect-oriented programming, and seamless integration with various technologies.

Example:
Let’s create a simple Spring application that demonstrates dependency injection:

// Service interface
public interface GreetingService {
    String greet();
}

// Service implementation
public class GreetingServiceImpl implements GreetingService {
    @Override
    public String greet() {
        return "Hello, World!";
    }
}

// Client class
public class GreetingClient {
    private GreetingService greetingService;

    public void setGreetingService(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void printGreeting() {
        System.out.println(greetingService.greet());
    }
}

In the example above, we have a simple GreetingService interface and its implementation GreetingServiceImpl. The GreetingClient class depends on the GreetingService interface and can be injected with different implementations at runtime using Spring.

2. What are the key features of the Spring Framework?

The key features of the Spring Framework include:

1. Dependency Injection (DI): The framework promotes loose coupling by allowing objects to be wired together through configuration rather than hard-coding dependencies. This makes the application more maintainable and testable.
2. Aspect-Oriented Programming (AOP): Spring supports AOP, which enables separating cross-cutting concerns (e.g., logging, security) from the core business logic, resulting in cleaner and modular code.
3. IoC Container: The Inversion of Control (IoC) container manages the creation and lifecycle of objects, resolving their dependencies and providing them when requested.
4. Spring MVC: Spring provides a web framework, Spring MVC, for building web applications in a model-view-controller architecture.
5. Spring Boot: Spring Boot is a sub-project of Spring that simplifies the configuration and deployment of Spring applications, providing a production-ready setup with minimal manual configuration.
6. Spring Data: It simplifies data access by providing a consistent and easy-to-use approach to work with databases and other data sources.
7. Spring Security: This module offers robust security features to protect Spring-based applications.
8. Transaction Management: Spring provides a consistent and straightforward API for managing transactions in both single and distributed environments.
9. Testing Support: Spring offers excellent support for testing, making it easy to write unit and integration tests for Spring-based applications.
10. JDBC Integration: Spring provides integration with JDBC to work with relational databases efficiently.

3. Explain the concept of Dependency Injection.

Dependency Injection (DI) is a design pattern used in the Spring Framework to achieve loose coupling between classes. It allows the objects to be created and wired together by an external entity (the container) rather than hard-coding the dependencies within the classes themselves.

Example:

// Service interface
public interface GreetingService {
    String greet();
}

// Service implementation
public class GreetingServiceImpl implements GreetingService {
    @Override
    public String greet() {
        return "Hello, World!";
    }
}

// Client class with Dependency Injection
public class GreetingClient {
    private GreetingService greetingService;

    // Constructor Injection
    public GreetingClient(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    // Setter Injection
    public void setGreetingService(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void printGreeting() {
        System.out.println(greetingService.greet());
    }
}

In this example, GreetingClient depends on the GreetingService interface. Rather than creating an instance of GreetingServiceImpl directly inside the GreetingClient class, we use Dependency Injection.

There are two ways of Dependency Injection demonstrated in the example:

• Constructor Injection: We pass the GreetingService implementation as a parameter to the constructor of GreetingClient.
• Setter Injection: We use a setter method (setGreetingService()) to inject the GreetingService implementation into the GreetingClient.

4. What is Inversion of Control (IoC)?

Inversion of Control (IoC) is a design principle implemented in the Spring Framework that allows the control of object creation and dependency management to be shifted from the application code to the Spring container. In other words, instead of the objects creating and managing their dependencies, the framework (container) takes control of creating and injecting the required dependencies.

Example:

// Service interface
public interface GreetingService {
    String greet();
}

// Service implementation
public class GreetingServiceImpl implements GreetingService {
    @Override
    public String greet() {
        return "Hello, World!";
    }
}

// GreetingClient class without IoC
public class GreetingClient {
    private GreetingService greetingService;

    public GreetingClient() {
        // Dependency created manually within the class
        greetingService = new GreetingServiceImpl();
    }

    public void printGreeting() {
        System.out.println(greetingService.greet());
    }
}

In the above code snippet, the GreetingClient class creates an instance of GreetingServiceImpl manually within its constructor, which results in a tight coupling between GreetingClient and GreetingServiceImpl. If we want to change the implementation of GreetingService, we would need to modify the GreetingClient class.

Now, let’s see the same example using IoC (dependency injection):

// GreetingClient class with IoC using constructor injection
public class GreetingClient {
    private GreetingService greetingService;

    // Constructor Injection
    public GreetingClient(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void printGreeting() {
        System.out.println(greetingService.greet());
    }
}

In this modified version, the control of creating the GreetingServiceImpl object is moved outside the GreetingClient class. Instead, we pass the implementation of GreetingService as a parameter to the constructor of GreetingClient. This way, the control of object creation and dependency management is “inverted” to the Spring container.

5. What are the different modules in Spring?

The Spring Framework is divided into several modules, each serving a specific purpose. Some of the key modules in Spring are:

1. Spring Core Container: This module provides the fundamental functionality of the Spring Framework, including dependency injection and the IoC container.
2. Spring AOP: This module supports Aspect-Oriented Programming (AOP) and allows for cross-cutting concerns to be addressed separately from the business logic.
3. Spring MVC: This module provides the Spring web framework for building web applications in a model-view-controller architecture.
4. Spring Data Access/Integration: This module includes support for JDBC, ORM frameworks like Hibernate, JPA, and other data access and integration technologies.
5. Spring Security: This module provides security features to secure Spring-based applications.
6. Spring Test: This module offers testing support for Spring applications.

Example:
Let’s focus on the Spring Core Container module with a relevant code example:

// Service interface
public interface GreetingService {
    String greet();
}

// Service implementation
public class GreetingServiceImpl implements GreetingService {
    @Override
    public String greet() {
        return "Hello, World!";
    }
}

// Main class using Spring Core Container
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        // Create an application context using XML configuration
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // Get the bean instance from the context
        GreetingService greetingService = context.getBean("greetingService", GreetingService.class);

        // Use the bean
        System.out.println(greetingService.greet());
    }
}

In this example, we demonstrate the usage of the Spring Core Container module. The applicationContext.xml file contains the configuration for the application context. It defines a bean with the name “greetingService” and specifies the class GreetingServiceImpl as its implementation.

6. What is a Spring Bean?

In the Spring Framework, a “Spring Bean” is an object that is managed by the Spring IoC container. These beans are created, configured, and assembled by the container based on the configuration metadata, which can be either XML or Java annotations.

Example:
Let’s create a simple Spring bean and configure it using annotations:

import org.springframework.stereotype.Component;

// Spring Bean
@Component("myBean")
public class MyBean {
    public void sayHello() {
        System.out.println("Hello, Spring Bean!");
    }
}

In this example, the MyBean class is annotated with @Component, which tells Spring that this class should be treated as a Spring Bean. The name “myBean” is given as a value to the @Component annotation, which will be used as the bean’s identifier within the Spring container.

7. What are the different scopes of a Spring Bean?

In Spring, beans can have different scopes that determine the lifecycle and visibility of the bean within the container. The common scopes available for Spring beans are:

1. Singleton: The default scope. Only one instance of the bean is created, and it is shared across the entire Spring container.
2. Prototype: A new instance is created each time the bean is requested. Each instance is independent of the others.
3. Request: A new instance is created for each HTTP request in a web application.
4. Session: A new instance is created for each HTTP session in a web application.
5. Global Session: Similar to the “session” scope but only valid in a portlet context.
6. Application: A single instance is created for the entire lifecycle of a web application.
7. WebSocket: A new instance is created for each WebSocket connection.

Example (Using XML configuration):