Spring Core Interview Questions and Answers

 1. What is Dependency Injection and how does it work in Spring?

Dependency Injection (DI) is a design pattern that allows us to remove the hard-coded dependencies and make our application loosely coupled, extendable, and maintainable. In the context of the Spring Framework, DI is a design pattern in which objects are not responsible for looking up their dependencies. Instead, dependencies are automatically provided by the Spring Container. 
In Spring, DI is implemented using the IoC (Inversion of Control) container. The IoC container is responsible for injecting dependencies through either Constructor, Setter, or Field Injection.


Here's a simple example:
@Component
public class ExampleClass {


    private DependencyClass dependency;


    @Autowired
    public ExampleClass(DependencyClass dependency) {
        this.dependency = dependency;
    }
}
In this example, `DependencyClass` is a Spring-managed bean that is automatically wired up with `ExampleClass`.

2. What are the benefits of using Dependency Injection?

- DI helps in decoupling the code, making the components independent of their dependencies.

- DI frameworks can automatically create objects, resolve dependencies and manage object lifecycles, reducing boilerplate code.

- It leads to a design where components are easy to test, maintain and extend.

- It makes the code easier to test because dependencies can be easily mocked or stubbed.
- It allows concurrent or independent development.
- It makes code more maintainable and flexible to changes.

3. What is the difference between constructor-based and setter-based Dependency Injection?

Constructor-based DI is accomplished when the container invokes a class constructor with a number of arguments, each representing a dependency. Setter-based DI is accomplished by the container calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

4. Can you give a scenario where one type of injection is preferable over the other?

Constructor injection is generally recommended for mandatory dependencies and setter injection for optional dependencies. This is because with constructor injection, the container will not allow an instance to be created if the required dependencies are not provided.

5. How does Spring handle circular dependencies?

Spring can handle circular dependencies between beans. If Bean A depends on Bean B and Bean B depends on Bean A, Spring resolves this by using setter injection or method injection, delaying the injection of one of the beans until both beans are initialized.

6. How can you define a bean in Spring?

You can define a bean in the Spring framework in several ways. The most common way is by using the `@Component` annotation or its specializations (`@Service`, `@Repository`, `@Controller`). You can also define beans using Java configuration (`@Configuration` and `@Bean` annotations) or XML configuration.

7. What is the role of the @Autowired annotation in Spring?

The `@Autowired` annotation is used to autowire spring bean on setter methods, instance variable, and constructor. When you use `@Autowired` on fields and pass the values for the fields using the property name, Spring will automatically assign those fields with the passed values.

8. How can you control the scope of a bean in Spring?

You can control the scope of a bean by using the `@Scope` annotation. The scopes supported by Spring are singleton, prototype, request, session, and application.

@Component
@Scope("prototype")
public class ExampleClass {
    // ...
}

9. What is the difference between @Component, @Service, @Repository, and @Controller in Spring?

These annotations are used to define beans in Spring, but they have different uses:


- `@Component`: This is a generic stereotype for any Spring-managed component.
- `@Service`: This annotation is used in the service layer where you write your business logic.
- `@Repository`: This annotation is used in the DAO layer for database communication.
- `@Controller`: This annotation is used in Spring MVC where you write your request handling logic.

10. How does Spring manage the lifecycle of a bean?

Spring manages the lifecycle of a bean from creation to destruction. It includes several stages like instantiation, initialization, usage, and destruction. Spring provides hooks for custom initialization and destruction methods: the `InitializingBean` and `DisposableBean` callback interfaces, custom `init()` and `destroy()` methods, and the `@PostConstruct` and `@PreDestroy` annotations.

@Component
public class ExampleBean implements InitializingBean, DisposableBean {


    @Override
    public void afterPropertiesSet() throws Exception {
        // Initialization logic
    }


    @Override
    public void destroy() throws Exception {
        // Cleanup logic
    }
}
In this example, `afterPropertiesSet()` is called after the bean's properties have been set, and `destroy()` is called when the bean is being destroyed

Additionally, you can use the `@PostConstruct` and `@PreDestroy` annotations for initialization and destruction callbacks:

@Component
public class ExampleBean {


    @PostConstruct
    public void init() {
        // Initialization logic
    }


    @PreDestroy
    public void cleanup() {
        // Cleanup logic
    }
}
In this example, `init()` is called after the bean's properties have been set, and `cleanup()` is called when the bean is being destroyed.

These lifecycle hooks can be used to perform any setup or cleanup tasks that your beans need.