Top 25+ Spring Boot Interview Questions Answered | Your AI Prep Guide

The @SpringBootApplication annotation is a convenience annotation that combines three important annotations:

• @EnableAutoConfiguration : Enables Spring Boot's auto-configuration mechanism, which attempts to automatically configure your Spring application based on the dependencies present in the classpath.
• @ComponentScan : Enables component scanning, so Spring can find and register beans and components in your application.
• @Configuration : Indicates that the class can be used by the Spring IoC container as a source of bean definitions.

Example:

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

This annotation simplifies the configuration of Spring applications by bundling these commonly used annotations together.

In Spring Boot, you can configure a datasource by specifying the necessary properties in the application.properties or application.yml file. Here is an example using application.properties :

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Alternatively, you can use application.yml :

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Spring Boot will automatically configure the datasource based on these properties.

These annotations are used for marking classes as Spring-managed components, but each serves a different purpose:

• @Component : A generic stereotype annotation used to indicate a Spring-managed component. It can be used on any Spring bean.
• @Service : A specialization of @Component used to indicate that the class holds business logic. It is used to mark service layer classes.
• @Repository : A specialization of @Component used to indicate that the class interacts with the database. It is used to mark data access objects (DAOs). It also provides automatic exception translation for database exceptions.
• @Controller : A specialization of @Component used to indicate that the class handles web requests. It is typically used in the presentation layer (MVC controllers).

Example:

@Component
public class MyComponent {}

@Service
public class MyService {}

@Repository
public class MyRepository {}

@Controller
public class MyController {}

Spring Boot DevTools is a set of tools provided by Spring Boot to improve the development experience. Its main benefits include:

• Automatic Restart : Automatically restarts the application whenever there are changes in the classpath.
• LiveReload : Integrates with the LiveReload browser extension to automatically refresh the browser when resources change.
• Configurations for Development : Provides development-specific configurations, such as disabling template cache for Thymeleaf, Freemarker, etc.
• Remote Debugging : Supports remote debugging by tunneling HTTP traffic over a secure channel.

To include DevTools in your project, add the following dependency to your pom.xml or build.gradle :

    org.springframework.boot
    spring-boot-devtools

Spring Boot uses Apache Commons Logging for all internal logging, but it also provides default configurations for several logging frameworks, such as Java Util Logging, Log4J2, and Logback. By default, Spring Boot uses Logback for logging.

To configure logging, you can use the application.properties file. Here are some examples:

Set the logging level:

logging.level.org.springframework=DEBUG
logging.level.com.example.myapp=INFO

Change the log file location:

logging.file.name=app.log
logging.file.path=/var/logs

Specify a custom log pattern:

logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n

You can also use custom configuration files for Logback, Log4J2, etc., by placing them in the src/main/resources directory:

• Logback : logback-spring.xml
• Log4J2 : log4j2-spring.xml

There are several ways to run a Spring Boot application:

• From the Command Line : Using the java -jar command. For example:

  java -jar myapp-0.0.1-SNAPSHOT.jar

• Using Maven : By using the Spring Boot Maven plugin. You can run the application with:

  mvn spring-boot:run

• Using Gradle : By using the Spring Boot Gradle plugin. You can run the application with:

  gradle bootRun

• From an IDE : Most IDEs like IntelliJ IDEA, Eclipse, and STS (Spring Tool Suite) support running Spring Boot applications directly.
• As a WAR Deployment : Spring Boot applications can also be packaged as WAR files and deployed to a servlet container like Tomcat.

The application.properties and application.yml files are used to externalize configuration in a Spring Boot application. These files allow you to define configuration settings, which can be easily modified without changing the application code.

application.properties : A file format using key-value pairs. Example:

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret

application.yml : A YAML format that provides hierarchical data representation. Example:

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret

Both files can be used to configure various aspects of the application, such as server port, datasource settings, logging levels, etc. Spring Boot will automatically load these files from the src/main/resources directory.

Spring Boot profiles provide a way to segregate parts of your application configuration and make it only available in certain environments. This is useful for creating different configurations for development, testing, and production environments.

To define a profile-specific property file, you can name it application-{profile}.properties or application-{profile}.yml . For example, application-dev.properties for the development environment and application-prod.properties for the production environment.

You can activate a profile in several ways:

• Using application.properties :

  spring.profiles.active=dev

• Using Command Line Arguments:

  java -jar myapp.jar --spring.profiles.active=dev

• Using Environment Variables:

  export SPRING_PROFILES_ACTIVE=dev

Example of profile-specific properties:

application-dev.properties :

server.port=8081
spring.datasource.url=jdbc:h2:mem:devdb
spring.datasource.username=devuser
spring.datasource.password=devpass

application-prod.properties :

server.port=80
spring.datasource.url=jdbc:mysql://prodserver:3306/proddb
spring.datasource.username=produser
spring.datasource.password=prodpass

Spring Boot CLI (Command Line Interface) is a tool that allows you to quickly create Spring applications using Groovy scripts. It simplifies the process of writing Spring Boot applications by providing a command-line interface.

To install Spring Boot CLI, you can use SDKMAN! or download it directly from the Spring website.

Basic usage of Spring Boot CLI:

Create a Groovy script ( app.groovy ):

@RestController
class Example {
    @RequestMapping("/")
    String home() {
        "Hello, Spring Boot CLI"
    }
}

Run the script:

spring run app.groovy

Spring Boot CLI will handle all the dependencies and configurations, allowing you to focus on writing code.

Exception handling in a Spring Boot application can be implemented using the @ControllerAdvice annotation along with @ExceptionHandler methods.

Create a GlobalExceptionHandler class:

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity handleResourceNotFoundException(ResourceNotFoundException ex) {
        ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), "Resource not found");
        return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity handleGlobalException(Exception ex) {
        ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), "Internal Server Error");
        return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

Define the custom error details class:

public class ErrorDetails {
    private Date timestamp;
    private String message;
    private String details;

    // Constructor, Getters, and Setters
}

Define the custom exception class:

public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

By using @ControllerAdvice and @ExceptionHandler , you can centralize and manage exception handling across your entire Spring Boot application.

Spring Data JPA is a part of the larger Spring Data family, which simplifies data access and repository management. It provides a higher-level abstraction over the JPA (Java Persistence API) and helps reduce boilerplate code required for database interactions.

Key features and benefits:

• Repositories : Defines repository interfaces for your entities and provides methods for common CRUD operations.
• Query Methods : Allows the definition of query methods directly in the repository interface using method naming conventions.
• Pagination and Sorting : Provides built-in support for pagination and sorting.
• Custom Queries : Supports JPQL and native SQL queries for custom database interactions.
• Auditing : Provides support for auditing entity changes.

Example:

Entity Class:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

Repository Interface:

public interface UserRepository extends JpaRepository {
    List findByName(String name);
}

With Spring Data JPA, you can perform common database operations without writing any implementation code, as Spring Data JPA provides the implementation automatically.

The @RestController annotation in Spring Boot is a specialized version of the @Controller annotation. It is used to create RESTful web services and simplifies the creation of RESTful APIs by combining @Controller and @ResponseBody annotations.

@Controller : Used to define a controller class that handles HTTP requests and returns view names. It is typically used in traditional web applications where views (e.g., JSP, Thymeleaf) are rendered.

@Controller
public class MyController {
    @RequestMapping("/greeting")
    public String greeting(Model model) {
        model.addAttribute("message", "Hello, World!");
        return "greeting";
    }
}

@RestController : Used to define a controller class that handles HTTP requests and returns the response body directly (e.g., JSON, XML). It is used in RESTful web services where data is returned in the response body.

@RestController
public class MyRestController {
    @RequestMapping("/greeting")
    public String greeting() {
        return "Hello, World!";
    }
}

In summary, @RestController is used for RESTful services and returns data directly, whereas @Controller is used for traditional web applications and returns view names.

Handling file uploads in a Spring Boot application can be done using MultipartFile . Spring Boot provides built-in support for handling file uploads with the @RequestParam annotation.

Steps to handle file uploads:

1. Add dependencies:

   
       org.springframework.boot
       spring-boot-starter-web
   

2. Create a controller to handle file uploads:

   @RestController
   public class FileUploadController {
   
       @PostMapping("/upload")
       public ResponseEntity handleFileUpload(@RequestParam("file") MultipartFile file) {
           if (file.isEmpty()) {
               return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("File is empty");
           }
   
           try {
               byte[] bytes = file.getBytes();
               Path path = Paths.get("uploads/" + file.getOriginalFilename());
               Files.write(path, bytes);
               return ResponseEntity.status(HttpStatus.OK).body("File uploaded successfully");
           } catch (IOException e) {
               return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to upload file");
           }
       }
   }

3. Configure file upload settings in application.properties :

   spring.servlet.multipart.max-file-size=2MB
   spring.servlet.multipart.max-request-size=2MB

This setup allows you to handle file uploads in a Spring Boot application, saving the uploaded files to the specified directory.

Spring Boot provides support for scheduling tasks using the @Scheduled annotation. This allows you to execute tasks at fixed intervals or specified times without the need for external cron jobs or task schedulers.

Steps to implement scheduled tasks:

1. Enable scheduling by adding @EnableScheduling to your main application class:

   @SpringBootApplication
   @EnableScheduling
   public class MyApplication {
       public static void main(String[] args) {
           SpringApplication.run(MyApplication.class, args);
       }
   }

2. Create a component with scheduled methods:

   @Component
   public class ScheduledTasks {
   
       @Scheduled(fixedRate = 5000)
       public void reportCurrentTime() {
           System.out.println("The time is now " + new Date());
       }
   
       @Scheduled(cron = "0 0 * * * ?")
       public void performTaskUsingCron() {
           System.out.println("Task executed at " + new Date());
       }
   }

In this example, the reportCurrentTime method is executed every 5 seconds, and the performTaskUsingCron method is executed at the top of every hour using a cron expression.

The @SpringBootTest annotation is used to create an application context for integration tests in a Spring Boot application. It allows you to test your application as if it were running in production by providing a real application context.

Key features:

• Creates an application context: Loads the entire Spring application context, making it suitable for integration tests.
• Configurable: Allows you to customize the application context by specifying properties, profiles, or component scanning configurations.
• Web Environment: Can create a web environment with a mock servlet context or an embedded server.

Example:

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyApplicationTests {

   @Autowired
   private MyService myService;

   @Test
   public void contextLoads() {
       assertNotNull(myService);
   }

   @Test
   public void testServiceMethod() {
       String result = myService.doSomething();
       assertEquals("ExpectedResult", result);
   }
}

In this example, the @SpringBootTest annotation loads the application context and allows you to autowire and test Spring beans within your test methods.