Spring boot interview questions

Here are some common Java Spring Boot interview questions that you may encounter:

1. What is Spring Boot, and how is it different from Spring Framework?

Spring Boot is a framework built on top of the Spring Framework that simplifies the process of creating and deploying Spring-based applications. It provides a set of opinionated defaults and auto-configurations that help developers get started with Spring development quickly and easily. Spring Boot is different from Spring Framework in that it provides a set of pre-configured components and starter dependencies, whereas Spring Framework requires more configuration and setup.

Here's an example to illustrate the difference between Spring Boot and Spring Framework:

Let's say you want to build a web application using Spring Framework. In order to do so, you would need to configure a variety of components, such as a web server, a database connection, and a view resolver. You would need to write a lot of boilerplate code to configure these components and get them working together.

On the other hand, if you were to use Spring Boot to build the same web application, you would be able to start with a set of pre-configured components and starter dependencies that would take care of most of the configuration for you. For example, you could use the "spring-boot-starter-web" dependency to get a pre-configured Tomcat server, and the "spring-boot-starter-data-jpa" dependency to get a pre-configured JPA (Java Persistence API) data access layer. This would significantly reduce the amount of code you would need to write, and make it easier to get your application up and running quickly.

In summary, Spring Boot is built on top of Spring Framework and provides a simpler and more streamlined way to build Spring-based applications, while Spring Framework provides a comprehensive set of tools and features for building enterprise-level applications.

2.What is the role of application.properties (or application.yml) file in Spring Boot?

The application.properties (or application.yml) file is a configuration file used in Spring Boot to configure various aspects of the application. It is located in the src/main/resources directory of the project and is loaded by the Spring Boot framework at runtime.

The application.properties file is a key-value based configuration file, while application.yml is a YAML file-based configuration file. Both files are used to configure properties for the application, such as server port, database connection details, logging settings, etc. Here's an example of a basic application.properties file:

# Server settings
server.port=8080
server.context-path=/myapp

# Database settings
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword

# Logging settings
logging.level.org.springframework=DEBUG

In the example above, we have set the server port to 8080 and the context path to /myapp. We have also configured the database connection details for a MySQL database and set the logging level to DEBUG for Spring Framework packages.

Using the application.properties or application.yml file allows developers to externalize configuration settings from the application code, which makes it easier to configure and manage the application in different environments. Additionally, Spring Boot provides a wide range of properties and settings that can be configured through these files, which makes it easier to customize the application behavior without having to write additional code.

In summary, the application.properties or application.yml file plays a key role in Spring Boot application configuration, and it allows developers to configure various aspects of the application behavior without having to write additional code.

3. What is the difference between @Component, @Service, and @Repository annotations in Spring Boot?

In Spring Boot, @Component, @Service, and @Repository are three of the most commonly used annotations for registering beans in the Spring container. While all three annotations are used to mark a class as a Spring bean, there are some subtle differences between them.

@Component is a generic stereotype annotation that can be used to annotate any class as a Spring component. It is typically used to mark a class as a bean that can be injected into other Spring components.

@Component
public class MyComponent {
    // ...
}

@Service is a specialization of the @Component annotation and is typically used to annotate classes that perform a service-like function in the application. This can include classes that implement business logic or perform data access operations.

@Service
public class MyService {
    // ...
}

@Repository is another specialization of the @Component annotation and is used to annotate classes that perform data access operations. It is typically used in conjunction with Spring's Data Access Object (DAO) pattern.

@Repository
public class MyRepository {
    // ...
}

While all three annotations serve a similar purpose of registering a class as a Spring bean, using the appropriate annotation helps to convey the intended purpose of the bean and can help with code organization and readability.

n summary, @Component, @Service, and @Repository are annotations used to register classes as Spring beans, with @Service and @Repository being specializations of @Component. @Service is typically used to annotate classes that provide business logic or services, while @Repository is used to annotate classes that perform data access operations.