1. Explain the concept of "convention over configuration" in Spring Boot.

Spring Boot uses the idea of "convention over configuration" to make

development easier. Instead of asking you to write long configuration files,
it provides default settings based on common use cases. This means if
you follow standard project structure and naming, Spring Boot will
automatically configure many things for you. You can still customize if
needed, but in most cases, the default settings just work.

Example:

If you place your controller classes inside a specific package, Spring Boot
will automatically scan and register them, no need to manually define
each one.

2. What is the difference between Spring and Spring Boot?

Spring Framework is a powerful tool to build Java applications, but it needs

a lot of setup — like XML or Java-based configuration, server setup,
dependency management, etc.

Spring Boot is built on top of Spring and removes that extra setup work. It
uses auto-configuration, built-in servers (like Tomcat), and ready-to-use
starter dependencies to help you create applications faster.

In short: Spring gives you tools, Spring Boot gives you a complete toolkit
with default setup to start quickly.

3. How does Spring Boot simplify the development of Java applications?

Spring Boot helps developers by handling most of the setup automatically.

Here's how:

Auto-configuration: It configures beans automatically based on the

libraries you include.
Starter dependencies: Just add one starter (like spring-boot-starter-web)
and it brings everything you need to build web apps.

Embedded servers: No need to install Tomcat or Jetty separately — they

come built-in.

Production-ready features: With tools like Spring Boot Actuator, you get
health checks, metrics, and more.

Developer tools: Features like hot-reloading (DevTools) make development

faster and smoother.

4. What are the various ways to create a Spring Boot application?

Spring Initializr ()

A web-based tool where you choose project type, dependencies, and

download a ready-to-run project.

Spring Boot CLI

A command-line tool to quickly run Groovy-based Spring Boot apps.

Manual Setup

You can create a Maven or Gradle project and add Spring Boot
dependencies manually.

Most developers prefer Spring Initializr because it’s simple and fast.

5. What is the role of the @SpringBootApplication annotation?

@SpringBootApplication is a shortcut annotation that combines three key

annotations:

@Configuration – marks the class as a source of bean definitions.

@EnableAutoConfiguration – enables Spring Boot’s auto-configuration

feature.

@ComponentScan – tells Spring to scan the current package and its sub-
packages for components like controllers, services, etc.

So when you use @SpringBootApplication, you don’t need to write all

three separately. It bootstraps the app and sets up everything you need to
start.

6. Explain the concept of auto-configuration in Spring Boot.

Auto-configuration is one of the most useful features in Spring Boot. It
tries to automatically configure your application based on the libraries you
have on your classpath.

For example, if Spring Boot finds the spring-boot-starter-data-jpa

dependency and a database like H2 or MySQL in your project, it will
automatically configure a DataSource, JPA-related beans, and more —
without you writing any configuration.

It works behind the scenes using @Conditional annotations and checks

what classes or beans are present before applying default settings.

Autoconfigurations

7. How does Spring Boot handle dependency management?

Spring Boot simplifies dependency management using starter

dependencies. These are pre-defined sets of libraries bundled together for
common tasks.

For example:

spring-boot-starter-web includes everything needed to build a REST API

(Spring MVC, Jackson, embedded Tomcat, etc.).

spring-boot-starter-data-jpa brings in Hibernate, JPA API, and a database

driver (like H2 for development).

Also, Spring Boot uses a parent POM (in Maven) to manage compatible
versions of libraries, so you don’t have to worry about version conflicts.

8. What is the purpose of the [Link] or [Link] file?

Used for externalized configuration of:

DB connection

Logging

Server port
Custom application settings

9. How can you override the default properties in Spring Boot?

You can override default settings in multiple ways:

[Link] or [Link]

Environment variables

Command-line arguments (like -[Link]=8081)

Programmatically using [Link]()

Spring Boot follows a priority order. The general rule is:

Command-line > Environment variables > [Link]/yml >

Default values

10. What is the purpose of the @Autowired annotation in Spring Boot?

@Autowired is used for dependency injection, which means Spring will

automatically create and inject required objects (beans) for you.

You can use @Autowired in:

Fields

Constructors (recommended)

Setters

For example, if you have a UserService bean and another class needs it,
you just add @Autowired and Spring will handle the wiring — no need to
new the object manually.

11. Explain the concept of profiles in Spring Boot.

Spring Boot profiles help you manage different configurations for different
environments — like development, testing, or production.
Each profile can have its own set of settings and beans. This way, you
don’t have to change your main code when switching environments.

Example:

[Link] for development

[Link] for production

When you activate a profile, Spring Boot will load the related properties
file and beans automatically.

12. How can you enable a specific profile in Spring Boot?

You can activate a profile in several ways:

In [Link] or [Link]:

[Link]=dev

As a command-line argument when starting the app:

java -jar [Link] --[Link]=prod

As an environment variable:

SPRING_PROFILES_ACTIVE=test

Once a profile is active, Spring Boot loads the matching config and beans
for that profile.

13. How does Spring Boot support the creation of RESTful web services?

Spring Boot makes it easy to create REST APIs using Spring MVC. Here's
how:

Use @RestController to create REST controllers (which return JSON/XML by

default).

Use annotations like:

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping for

endpoints
@PathVariable to extract values from URLs

@RequestParam to read query parameters

Supports content negotiation (returns data in requested format)

Integrates easily with tools like Swagger/OpenAPI for API documentation

Supports custom exception handling using @ControllerAdvice

14. What is Spring Data JPA, and how does it integrate with Spring Boot?

Spring Data JPA is a part of the Spring ecosystem that helps simplify
database access using JPA (Java Persistence API).

Instead of writing SQL queries or boilerplate code, you just:

Create Entity classes (for database tables)

Create Repository interfaces (like JpaRepository or CrudRepository)

Spring Boot auto-configures everything based on your setup

Spring Boot automatically:

Sets up JPA configurations

Connects to your database

Implements basic CRUD methods (like save(), findById())

This saves time and reduces repetitive code.

15. Explain the role of Spring Security in Spring Boot applications.

Spring Security provides a complete security solution for your application.

It handles:

Authentication – verifying who the user is

Authorization – checking what the user is allowed to do

With Spring Boot, it’s easy to integrate Spring Security. It secures your
REST endpoints or web pages by default and can support:
Form login

Basic Auth

JWT tokens

OAuth2 login (Google, GitHub, etc.)

It uses security filters and integrates smoothly with Spring MVC, allowing
you to secure routes using annotations like @PreAuthorize.

16. How can you enable logging in a Spring Boot application?

Spring Boot uses Logback as the default logging framework. Logging is

enabled automatically — you don’t need to add any extra setup to start
using it.

To log messages in your code, you can use SLF4J (which works with
Logback):

@Slf4j // Lombok annotation

public class MyService {

public void doSomething() {

[Link]("Processing...");

[Link]("Something went wrong");

You can configure log settings (like log level or log file path) in
[Link]:

[Link]=DEBUG

[Link]=[Link]

You can also use a custom [Link] file for advanced configurations.

17. What is the purpose of the @RestController annotation?

@RestController is a shortcut for two annotations:

@Controller – tells Spring this class handles web requests

@ResponseBody – tells Spring to return the response as JSON or XML

(instead of rendering a view)

So when you use @RestController, all your methods return data (usually
JSON) directly to the client — perfect for building REST APIs.

Example:

@RestController

public class UserController {

@GetMapping("/users")

public List<User> getUsers() {

return [Link]();

18. How can you handle exceptions in a Spring Boot application?

Spring Boot allows you to handle exceptions in a clean and flexible way:

Method-level handling using @ExceptionHandler:

@ExceptionHandler([Link])

public ResponseEntity<String>
handleNotFound(ResourceNotFoundException ex) {

return
[Link](HttpStatus.NOT_FOUND).body([Link]());

Global handling using @ControllerAdvice:

This lets you manage exceptions for all controllers in one place.
@ControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler([Link])

public ResponseEntity<String> handleAll(Exception ex) {

return
[Link](HttpStatus.INTERNAL_SERVER_ERROR).body("Error:
" + [Link]());

19. Explain the difference between @Component, @Service, and

@Repository annotations.

All are Spring stereotypes:

@Component is generic

@Service is used for business logic

@Repository is for database access and enables exception translation

20. What is the purpose of the @Transactional annotation in Spring Boot?

@Transactional is used to manage database transactions automatically. It

ensures that:

If everything in the method runs fine, the changes are committed to the
database.

If an exception happens, Spring will roll back the transaction to keep your
data safe.

You can use it at the method or class level:

@Transactional

public void transferMoney(Account from, Account to, BigDecimal amount)

{

debit(from, amount);

credit(to, amount);
}

It helps maintain ACID properties (Atomicity, Consistency, Isolation,

Durability) in your database operations.

21. How does Spring Boot support database migrations?

Spring Boot supports automatic database schema management using

tools like Flyway and Liquibase.

These tools allow you to write versioned SQL scripts (like

V1__create_table.sql, V2__add_column.sql), and Spring Boot will run them
in order when the application starts.

This helps:

Keep your database schema up to date

Avoid manual changes in each environment

Track version history of schema changes

To use Flyway:

<!-- In [Link] -->

<dependency>

<groupId>[Link]</groupId>

<artifactId>flyway-core</artifactId>

</dependency

22. What is the role of Spring Boot Actuator?

Actuator provides production-ready monitoring features through endpoints

like:

/health – app health

/info – app metadata

/metrics – performance metrics

/env, /loggers, etc.

You can also define custom indicators and endpoints.

23. How can you configure caching in a Spring Boot application?

Steps:

Add a caching library

<dependency>

<groupId>[Link]</groupId>

<artifactId>spring-boot-starter-cache</artifactId>

</dependency>

Use @EnableCaching

@EnableCaching

@SpringBootApplication

public class MyApp {}

Use caching annotations on methods:

@Cacheable – caches method result

@CachePut – updates cache with new value

@CacheEvict – removes cache entry

Configure properties in [Link] or [Link]

[Link]=ehcache

24. Explain the concept of Bean scopes in Spring Boot.

Bean scopes define lifecycle and visibility:

singleton (default): one instance for app

prototype: new instance per request

request: one per HTTP request

session: one per session

application: shared in servlet context

websocket: one per WebSocket session

25. What is the purpose of the @Value annotation in Spring Boot?

@Value injects values from:

Properties file

Environment variables

Command-line args

Example:

@Value("${[Link]}")

private int port;

26. How can you enable Cross-Origin Resource Sharing (CORS) in a Spring
Boot application?

CORS (Cross-Origin Resource Sharing) allows your frontend (like React or

Angular) to call your backend API even if they are on different domains or
ports.

You can enable CORS in two ways:

Two ways:

1. Using @CrossOrigin annotation:

@CrossOrigin(origins = "<[Link]

@RestController

public class MyController {

@GetMapping("/api/data")

public String getData() {

return "Hello from backend!";

}
}

2. Globally using WebMvcConfigurer:

@Configuration

public class WebConfig implements WebMvcConfigurer {

@Override

public void addCorsMappings(CorsRegistry registry) {

[Link]("/**")

.allowedOrigins("<[Link]

.allowedMethods("GET", "POST", "PUT", "DELETE");

27. Explain the concept of a starter dependency in Spring Boot.

A starter dependency is a convenient way to include a group of related

libraries in your project.

For example:

<dependency>

<groupId>[Link]</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

This single dependency brings in:

Spring MVC

Jackson (for JSON)

Embedded Tomcat

Logging

28. What is the purpose of the @Async annotation in Spring Boot?

The @Async annotation makes a method run in a separate thread, so it
doesn’t block the main thread.

This is helpful when doing tasks like sending emails, processing files, or
calling external APIs — things that can take time.

You must:

Enable async support with @EnableAsync

Configure a TaskExecutor if needed

29. How does Spring Boot support the creation of WebSocket applications?

You can:

Use Spring’s WebSocket API

Define handler classes using WebSocketHandler

Annotate config class with @EnableWebSocket

Integrate with SockJS for fallback support

30. Explain the concept of conditional bean registration in Spring Boot.

Spring Boot allows you to create beans only when certain conditions are
met using conditional annotations.

Some common conditional annotations:

@ConditionalOnClass: Bean is created only if a specific class is on the

classpath.

@ConditionalOnMissingBean: Creates a bean only if the same type is not

already defined.

@ConditionalOnProperty: Creates a bean only if a specific property exists

or has a certain value.

31. How can you schedule tasks in a Spring Boot application?

Spring Boot makes it easy to run tasks at regular intervals using the
scheduling feature.

Steps:

Enable scheduling in your main or config class:

@EnableScheduling

@SpringBootApplication

public class MyApp {}

Use @Scheduled on any method:

@Scheduled(fixedRate = 5000) // runs every 5 seconds

public void runTask() {

[Link]("Running scheduled task...");

You can schedule tasks using:

fixedRate – time between method calls

fixedDelay – time after method finishes

cron – for custom scheduling like @Scheduled(cron = "0 0 * * * *") (every

hour)

Useful for tasks like backups, report generation, or sending emails.

32. What is the purpose of the @RequestMapping annotation?

@RequestMapping is used to map HTTP requests to specific controller

methods.

It can define:

The URL path (value)

The HTTP method (GET, POST, etc.)

Optional parameters, headers, or consumes/produces types

Example:

@RequestMapping(value = "/users", method = [Link])

public List<User> getAllUsers() {

return [Link]();

Although @RequestMapping works for all HTTP methods, you can use
shortcuts like @GetMapping, @PostMapping, etc., for better readability.

33. How can you enable HTTPS in a Spring Boot application?

Steps:

Generate SSL certificate and and a .p12 keystore.

Add these properties in [Link]:

[Link]=8443

[Link]-store=classpath:keystore.p12

[Link]-store-password=yourpass

[Link]-store-type=PKCS12

Place the keystore.p12 file inside your resources folder.

Once done, your app will be available at [Link] with SSL

enabled. This is important for securing sensitive data in transit.

34. Explain the concept of externalized configuration in Spring Boot.

Configuration values (like DB URL, ports, etc.) can be moved to external

sources:

[Link]

Environment variables

Command-line args
Config servers (in microservices)

This enables easy environment-specific setups.

35. What is the purpose of the @RestControllerAdvice annotation?

@RestControllerAdvice is a specialized annotation used to handle

exceptions and shared logic for all REST controllers.

It combines:

@ControllerAdvice – to apply common behavior across multiple controllers

@ResponseBody – so the response is returned as JSON/XML, not a view

Use cases:

Global exception handling

Adding common model attributes

Modifying response bodies

Example:

@RestControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler([Link])

public ResponseEntity<String>
handleNotFound(ResourceNotFoundException ex) {

return
[Link](HttpStatus.NOT_FOUND).body([Link]());

This keeps your controller code clean and separates error-handling logic.

36. How does Spring Boot support testing of applications?

Spring Boot provides great support for unit testing and integration testing
with built-in tools and annotations.

Some commonly used features:

Annotations:

@SpringBootTest – loads the full application context for integration testing

@WebMvcTest – tests only the web layer (like controllers)

@DataJpaTest – tests the JPA (database) layer

Mocking support:

@MockBean – create and inject mock beans

Combine with Mockito to simulate behaviors

Test utilities:

TestRestTemplate – to call real endpoints in integration tests

MockMvc – to test controller layer without starting the full server

Spring Boot also runs tests using embedded servers, so you don’t need to
deploy your app externally to run full end-to-end tests.

37. Explain the purpose of the @PathVariable annotation in Spring Boot.

@PathVariable is used to extract values from the URL path and pass them
into your controller method as parameters.

Example:

@GetMapping("/user/{id}")

public User getUser(@PathVariable Long id) { ... }

38. What is the difference between @ControllerAdvice and

@RestControllerAdvice?

Both are used to apply common behavior (like exception handling) across
multiple controllers.
@ControllerAdvice – Used for MVC controllers that return views (like JSP,
Thymeleaf).

@RestControllerAdvice – Used for REST APIs, and it automatically includes

@ResponseBody, so it returns JSON/XML responses.

Use @RestControllerAdvice when building APIs, and @ControllerAdvice

when working with web pages.

39. How can you enable Swagger documentation in a Spring Boot

application?

Steps:

Add Swagger dependencies.

Configure metadata (title, version, etc.)

Use annotations like @Api, @ApiOperation

Access Swagger UI at /[Link]

40. What is the purpose of the @RequestBody annotation in Spring Boot?

@RequestBody is used to bind the HTTP request body (usually JSON or

XML) to a Java object.

Example:

@PostMapping("/user")

public void createUser(@RequestBody User user) { ... }

41. How does Spring Boot support message queuing?

Spring Boot supports message queues like RabbitMQ and Apache Kafka for
building asynchronous and event-driven systems.

Key features:

Add dependencies like:

spring-boot-starter-amqp (for RabbitMQ)

spring-kafka (for Kafka)

Use listeners to consume messages:

@RabbitListener(queues = "order-queue")

public void receiveMessage(String message) {

[Link]("Received: " + message);

@KafkaListener(topics = "user-topic")

public void listen(String data) {

[Link]("Kafka: " + data);

Spring Boot auto-configures connections based on what’s in the classpath

and [Link].

Also, you can use Spring’s messaging abstractions like Message,

MessageChannel, and MessageConverter to work with different formats.

42. What is the purpose of the @Scheduled annotation in Spring Boot?

@Scheduled is used to run methods on a schedule — like running a task

every few seconds, minutes, or at specific times.

Example:

@Scheduled(fixedDelay = 5000)

public void runTask() { ... }

Supports fixedRate, fixedDelay, and cron.

43. Explain the concept of Actuator endpoints in Spring Boot.

Spring Boot Actuator exposes endpoints that give useful information about
the application’s health and internals.

Some commonly used endpoints:

/actuator/health – shows app health status

/actuator/info – displays app info (like version, description)

/actuator/metrics – CPU, memory, HTTP request metrics

/actuator/env – view environment properties

/actuator/beans – see all registered Spring beans

/actuator/loggers – manage logging levels at runtime

To use Actuator:

<dependency>

<groupId>[Link]</groupId>

<artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

You can also customize or secure these endpoints using your

[Link].

44. How can you configure connection pooling in a Spring Boot

application?

Spring Boot uses HikariCP as the default connection pool for managing
database connections efficiently.

You can configure pooling options in [Link]:

[Link]-pool-size=10

[Link]-timeout=30000

You can also use Tomcat JDBC or DBCP2.

45. What is the purpose of the @CrossOrigin annotation in Spring Boot?

@CrossOrigin is used to enable Cross-Origin Resource Sharing (CORS),

which allows your frontend (on a different domain or port) to make API
calls to your backend.
Without CORS enabled, browsers block requests from different origins for
security reasons.

Example:

@CrossOrigin(origins = "<[Link]

@RestController

public class MyController { ... }

46. How does Spring Boot support internationalization and localization?

Spring Boot makes it easy to build apps that support multiple languages
using internationalization (i18n).

Message bundles (messages_en.properties, messages_fr.properties)

MessageSource bean configuration

Resolves locale using Accept-Language header

Enables dynamic text based on user’s locale.

47. Explain the concept of a health indicator in Spring Boot Actuator.

A health indicator shows the status of a specific part of your app, like the
database, disk space, or custom services.

These health indicators are part of the /actuator/health endpoint.

Spring Boot includes built-in health checks:

Database connection (DataSourceHealthIndicator)

Disk space (DiskSpaceHealthIndicator)

RabbitMQ, Redis, etc.

You can also create your own:

@Component

public class MyServiceHealthIndicator implements HealthIndicator {

@Override

public Health health() {

boolean isHealthy = checkSomething();

return isHealthy ? [Link]().build() : [Link]()

.withDetail("error", "Service is down").build();

48. What is the purpose of the @RequestBody annotation in Spring Boot?

@RequestBody is used to bind the HTTP request body (usually JSON) to a

Java object.

It automatically converts JSON into a Java object using Jackson (or any
configured converter).

Example:

@PostMapping("/user")

public void createUser(@RequestBody User user) { ... }

49. How can you enable request logging in a Spring Boot application?

To see incoming HTTP requests and debug better, you can enable request
logging.

Simple way:

Add this to [Link]:

[Link]=DEBUG
Advanced way (using Logback):

Create a [Link] and configure logging pattern and levels.

Third-party option:

Use Spring Boot filters like CommonsRequestLoggingFilter for detailed

logs:

@Bean

public CommonsRequestLoggingFilter logFilter() {

CommonsRequestLoggingFilter filter = new

CommonsRequestLoggingFilter();

[Link](true);

[Link](true);

[Link](10000);

return filter;

50. Explain the purpose of the @ExceptionHandler annotation in Spring

Boot.

@ExceptionHandler is used to catch and handle specific exceptions in

your controller methods.

Why? So your app doesn’t crash and you can send a proper response (like
a 404 or custom error message).

Example:

@ExceptionHandler([Link])

public ResponseEntity<String> handle(MyException ex) {

return [Link](500).body("Error occurred");

}

51. How does Spring Boot support asynchronous processing?

Spring Boot allows methods to run asynchronously in a separate thread

using the @Async annotation. This helps improve performance by not
blocking the main thread during long-running tasks (like sending emails or
processing files).

@Async on methods

@EnableAsync in config

Optional TaskExecutor bean for thread management

Supports returning CompletableFuture, Future, void.

52. What is the purpose of the @EnableAutoConfiguration annotation in

Spring Boot?

@EnableAutoConfiguration tells Spring Boot to automatically configure

beans and settings based on the libraries present in the classpath.

For example:

If Spring MVC is on the classpath, it sets up a web app.

If Spring Data JPA is present, it configures a datasource and JPA

repositories.

This saves a lot of manual configuration and helps you get started quickly.

53. How can you configure a connection pool in Spring Boot?

Spring Boot uses HikariCP as the default connection pool for databases.

You can configure it in [Link]:

[Link]-pool-size=10

[Link]-idle=5
[Link]-url=jdbc:mysql://localhost:3306/mydb

[Link]=root

[Link]=pass

If you prefer other pools like Tomcat JDBC or DBCP2, just exclude Hikari
and add the respective dependency.

Connection pooling is important to reduce the cost of repeatedly opening

and closing DB connections.

54. Explain the concept of transaction management in Spring Boot.

Spring Boot supports transaction management using the @Transactional

annotation.

It helps you in:

ACID compliance

Automatic rollback on exceptions

Clean resource handling

55. What is the purpose of the @Async annotation in Spring Boot?

@Async marks a method to run in the background, freeing the caller

thread to continue execution without waiting.

It’s useful for:

Sending emails

Generating reports

Calling external APIs

Processing background jobs

Remember: To use @Async, you must also enable it with @EnableAsync in

your configuration.
56. How does Spring Boot handle security vulnerabilities like XSS and
CSRF?

Spring Boot (with Spring Security) provides basic protections against

common web vulnerabilities like:

XSS (Cross-Site Scripting):

By default, template engines like Thymeleaf escape user inputs.

You can also add security headers (e.g., Content-Security-Policy) to

prevent script execution from untrusted sources.

CSRF (Cross-Site Request Forgery):

Spring Security automatically generates a CSRF token for every form and
checks it on form submissions.

This prevents unauthorized commands from being executed on behalf of

the user.

Best practices for developers:

Always validate and sanitize user input.

Use HTTPS in production.

Don’t disable CSRF protection unless you know exactly why.

57. What is the purpose of the @Cacheable annotation in Spring Boot?

@Cacheable is used to store the result of a method so that future calls

with the same input don't need to run the method again — it just returns
the cached value.

Example:

@Cacheable("users")

public User getUserById(Long id) { ... }

Improves performance by avoiding repetitive computation or DB calls.

58. How can you handle file uploads in a Spring Boot application?
Spring Boot makes file upload easy using MultipartFile.

Steps:

Controller method:

@PostMapping("/upload")

public String uploadFile(@RequestParam("file") MultipartFile file) {

// save or process the file

return "Uploaded successfully!";

Set size limits in [Link]:

[Link]-file-size=5MB

[Link]-request-size=10MB

Spring Boot handles the rest — parsing multipart requests and converting
uploaded files into MultipartFile.

You can also write files to disk or store them in a database/cloud storage.

59. Explain the concept of circuit breakers in Spring Boot.

A circuit breaker helps prevent your app from failing repeatedly when a
downstream service (like an API or database) is not responding.

It works like this:

If a service fails multiple times, the circuit opens, and further calls are
blocked to avoid stress.

After some time, it enters a half-open state to test if the service is back.

If successful, it closes the circuit and resumes normal flow.

In Spring Boot, use Resilience4j (or Hystrix) for circuit breakers:

@CircuitBreaker(name = "inventoryService", fallbackMethod = "fallback")

public Product getInventory(Long id) {

// call to external service

This improves fault tolerance in microservice architectures.

60. What is the purpose of the @ControllerAdvice annotation in Spring

Boot?

@ControllerAdvice is used to handle common logic across all controllers.

You can define:

Global exception handlers using @ExceptionHandler

Custom model attributes shared across multiple controllers using

@ModelAttribute

Custom data binders with @InitBinder

61. How does Spring Boot handle database connections and pooling?

Spring Boot automatically sets up a connection pool to manage database

connections efficiently.

HikariCP is the default and fastest connection pool in Spring Boot.

Other supported pools: Tomcat JDBC, DBCP2 (you can switch by changing
dependencies).

[Link]=jdbc:mysql://localhost:3306/mydb

[Link]=root

[Link]=pass

[Link]-pool-size=10

Connection pooling:

Reduces overhead of opening/closing DB connections.

Reuses connections to improve performance.

Works well with Spring's transaction management to ensure rollback and

ACID compliance.

62. What is the purpose of the @RestControllerAdvice annotation in Spring

Boot?

@RestControllerAdvice is used to handle exceptions globally in REST APIs

and automatically return responses in JSON/XML format.

It combines:

@ControllerAdvice – for applying global logic to controllers

@ResponseBody – so responses are automatically serialized

Example:

@RestControllerAdvice

public class GlobalRestHandler {

@ExceptionHandler([Link])

public ResponseEntity<String>
handleNotFound(UserNotFoundException ex) {

return [Link](404).body([Link]());

Use this to avoid repeating exception handling code in every controller.

63. Explain the concept of lazy initialization in Spring Boot.

Lazy initialization means Spring creates a bean only when it’s first needed,
instead of at application startup.

Beans are created on first use, not at startup

Saves memory and improves startup time

You can force eager init using @Lazy(false)

64. How can you configure a custom data source in Spring Boot?

If the default [Link].* properties aren't enough, you can define

a custom DataSource bean.

Steps:

Add driver dependency

Create a config class with @Bean returning a DataSource (e.g.,

HikariDataSource)

Set properties like URL, username, password

Example:

@Bean

public DataSource dataSource() {

HikariConfig config = new HikariConfig();

[Link](...);

return new HikariDataSource(config);

65. What is the purpose of the @Profile annotation in Spring Boot?

@Profile is used to load beans or configuration only for specific

environments, such as:

dev – for development

test – for testing

prod – for production

Example:

@Profile("dev")

@Component

public class DevBean { ... }

To activate a profile:

[Link]=dev

This helps you run the same app with different settings in different
environments — without changing code.

66. How does Spring Boot handle authentication and authorization?

Spring Boot uses Spring Security to provide both authentication (who you
are) and authorization (what you're allowed to do).

Authentication: Form login, JWT, OAuth2, DB, LDAP

Authorization: Role/permission-based access control

Declarative rules via annotations like @PreAuthorize, @Secured

67. What is the purpose of the @Bean annotation in Spring Boot?

@Bean is used to tell Spring, “Hey, create and manage this object as a
bean.”

It’s commonly used inside a @Configuration class when you want to

define custom logic for creating an object

Example:

@Bean

public MyService myService() {

return new MyServiceImpl();

68. How can you enable server-side validation in a Spring Boot

application?

Server-side validation checks incoming data before it’s processed or

saved. Spring Boot uses Hibernate Validator (JSR-380) under the hood.
Steps:

Add spring-boot-starter-validation

Use annotations like @NotNull, @Size

Add @Valid or @Validated in controllers

Example:

@PostMapping

public ResponseEntity<?> save(@Valid @RequestBody User user) { ... }

69. Explain the concept of the Spring Boot Starter Parent.

The Spring Boot Starter Parent is a special Maven parent POM that
provides:

Default versions for dependencies

Plugin configs

Java version, encoding

It reduces need for manual configuration.

70. What is the purpose of the @ConfigurationProperties annotation?

@ConfigurationProperties is used to map values from

[Link] or [Link] to a Java class.

This is helpful when you want to group related settings.

Example:

@ConfigurationProperties(prefix="app")

public class AppConfig {

private String name;

}
Requires @EnableConfigurationProperties or be annotated with
@Component.

71. How can you customize error handling in a Spring Boot application?

Spring Boot provides multiple ways to handle and customize errors so

your users don’t see raw stack traces.

Options:

@ControllerAdvice with @ExceptionHandler

Create a CustomErrorController for /error

Customize ErrorAttributes or use ErrorViewResolver

72. What is the purpose of the @ConditionalOnProperty annotation?

@ConditionalOnProperty tells Spring to only create a bean if a specific

property exists and has a certain value.

Useful for feature toggles or enabling/disabling configs based on

environment.

Example:

@ConditionalOnProperty(name = "[Link]", havingValue = "true")

@Bean

public FeatureBean featureBean() { ... }

73. How does Spring Boot support hot reloading during development?

Spring Boot supports hot reloading using the DevTools module.

Via Spring Boot DevTools:

Auto restarts app on classpath changes

Enables live reload (e.g., with browser plugin)

Add this in [Link]:

<dependency>

<groupId>[Link]</groupId>

<artifactId>spring-boot-devtools</artifactId>

<optional>true</optional>

</dependency>

74. What is the purpose of the @EnableScheduling annotation in Spring

Boot?

@EnableScheduling turns on Spring’s scheduling support.

Once enabled, you can run methods automatically using @Scheduled.

@EnableScheduling

@SpringBootApplication

public class App { ... }

Without @EnableScheduling, scheduled methods will be ignored.

75. How can you externalize configuration in a Spring Boot application?

Spring Boot lets you keep configuration outside your code, making it
easier to change values per environment (like dev, test, prod).

Common ways:

[Link] / [Link]

Command-line args

Environment variables

Config servers (Spring Cloud Config)

76. Explain the concept of YAML configuration in Spring Boot.

YAML ([Link]) is an alternative to [Link]. It’s
cleaner and more readable, especially for nested settings.

Example:

server:

port: 8081

spring:

datasource:

url: jdbc:mysql://localhost:3306/db

Indentation is important in YAML, use spaces, not tabs. Spring Boot

supports both .yml and .properties, so you can use what you prefer.

77. What is the purpose of the @ComponentScan annotation?

@ComponentScan tells Spring where to look for your beans

(@Component, @Service, @Repository, etc.).

By default, it scans the package of your main class. But you can customize
it.

Example:

@ComponentScan(basePackages = "[Link]")

78. How does Spring Boot support microservices development?

Spring Boot is a great choice for building microservices because it’s:

Lightweight and fast to start

Comes with embedded servers (no need for external Tomcat)

Has excellent support for REST APIs and Spring Data

With Spring Cloud, it becomes even more powerful:

Eureka – service discovery

Spring Cloud Gateway – routing and load balancing

Config Server – centralized configuration

Circuit breakers – with Resilience4j

It also works well with Docker and Kubernetes, making it ideal for cloud-
native apps.

79. What is the purpose of the @EnableAutoConfiguration annotation?

@EnableAutoConfiguration tells Spring Boot to automatically configure

your application based on the libraries available in the classpath.

Example:

If you have spring-boot-starter-web, it sets up Spring MVC.

If you have Spring Data JPA, it sets up Hibernate and a datasource.

You usually don’t use it directly because it’s part of:

@SpringBootApplication

80. How can you integrate a third-party library with Spring Boot?

You can easily use external libraries (like Apache POI, Stripe, Twilio, etc.)
with Spring Boot.

Add the library dependency (e.g., in [Link])

Configure via @Configuration and @Bean

Inject and use the library as a Spring-managed bean

81. What is the purpose of the @Import annotation in Spring Boot?

@Import is used when you want to include another @Configuration class

into your current configuration.
Instead of using @ComponentScan to pick it up automatically, @Import
lets you add it manually.

Example:

@Import([Link])

public class MainConfig { }

82. How can you run a block of code at Spring Boot startup?

To run code when the application starts, implement one of these

interfaces:

CommandLineRunner – gets raw String[] args

ApplicationRunner – gets parsed ApplicationArguments

Example:

@Bean

public CommandLineRunner run() {

return args -> {

[Link]("App started!");

};

83. What is the purpose of the @ConditionalOnClass annotation?

@ConditionalOnClass makes sure a bean or configuration is only loaded if

a specific class is available in the classpath.

Use case: You want to conditionally enable a feature only if a certain

dependency is present.

Example:
@ConditionalOnClass([Link])

public class DataSourceConfig { ... }

84. How can you create a custom banner in Spring Boot?

Spring Boot shows a banner in the console when the app starts. You can
easily customize it.

Steps:

Create a file named [Link]

Place it in src/main/resources

Add ASCII art, app info, or any message

Want a banner image instead? Use:

[Link]=classpath:[Link]

To disable the banner:

[Link]-mode=off

Try websites like to generate cool ASCII art banners.

85. Explain the concept of Spring Boot auto-configuration report.

When things don’t auto-configure as expected, the auto-configuration

report helps you debug.

Enable it by adding this to [Link]:

debug=true

You get a report of included and excluded auto-configurations in the

console, useful for debugging config issues.

86. How does Spring Boot support configuration metadata generation?

Spring Boot can generate metadata files that help IDEs like IntelliJ or VS
Code offer autocomplete and validation for your custom properties.

This happens when you:

Use @ConfigurationProperties on your config classes.

Add the spring-boot-configuration-processor dependency:

87. What is the purpose of the @ImportResource annotation?

@ImportResource lets you include XML-based Spring configurations in a

Java-based Spring Boot app.

Example:

@ImportResource("classpath:[Link]")

public class AppConfig { }

88. How can you customize the Spring Boot application context?

You can customize the application context (before it's fully initialized)
using:

Creating a subclass of SpringApplication

Using SpringApplicationBuilder

Adding ApplicationContextInitializer or listeners

89. How can you enable or disable specific Spring Boot Actuator
endpoints?

You can manage Actuator endpoints via [Link]:

[Link]=health,info

[Link]=true

[Link]=false

90. How does Spring Boot handle logging?

Spring Boot uses Logback as the default logging framework, but you can
also switch to Log4j2, Java Util Logging, etc.

Basic logging configuration in [Link]:

[Link]=INFO

[Link]=DEBUG

[Link]=[Link]

91. What is the purpose of the @EnableConfigurationProperties

annotation?

This annotation tells Spring Boot to bind configuration properties to a plain

class — even if it’s not a component (@Component or @Service).

It’s mostly used when you want to keep configuration classes clean and
separate.

Example:

@EnableConfigurationProperties([Link])

public class MyAppConfig {

Now Spring Boot will bind values from [Link] or

[Link] to MyAppProperties.

If your @ConfigurationProperties class is already annotated with

@Component, you don’t need this.

92. How can you access command-line arguments in Spring Boot?

Spring Boot apps can read arguments passed from the terminal using:

ApplicationArguments (recommended)
CommandLineRunner or ApplicationRunner

Example with ApplicationArguments:

@Autowired

private ApplicationArguments args;

public void printArgs() {

[Link]("Source Args: " + [Link]());

[Link]("Option Names: " + [Link]());

You can run the app with:

java -jar [Link] --mode=prod --port=8080

93. What is the difference between @Controller and @RestController?

@Controller:

Used in web applications that return views like HTML or JSP pages.

It is part of the Spring MVC pattern.

If you return a string, Spring assumes it is the name of a view (like an

HTML file).

To send JSON from here, you must also add @ResponseBody to the
method.

@RestController:

Used in REST APIs where you want to return JSON or XML directly.

It's the same as using @Controller + @ResponseBody on every method.

Spring automatically converts Java objects to JSON (using Jackson) and

sends them in the response.

94. How can you enable method-level security in Spring Boot?

Spring Boot allows you to secure individual methods using annotations.

Steps:
Enable method-level security:

@EnableGlobalMethodSecurity(prePostEnabled = true)

Use any of these:

@PreAuthorize("hasRole('ADMIN')")

@Secured("ROLE_USER")

@RolesAllowed("ADMIN") (requires additional config)

Example:

@PreAuthorize("hasRole('ADMIN')")

public void deleteUser(Long id) {

// secured method

95. What is the purpose of the @SessionAttributes annotation?

@SessionAttributes is used in Spring MVC to store model data in the HTTP

session so it can survive across multiple requests.

Example:

@Controller

@SessionAttributes("user")

public class UserController {

@ModelAttribute("user")

public User user() {

return new User();

96. How can you configure a Spring Boot app to run on a different port?
By default, Spring Boot apps run on port 8080. To change it, just update
the [Link] or [Link] file.

Example ([Link]):

[Link]=8081

97. What is the difference between @ModelAttribute and

@RequestParam?

@ModelAttribute

Used when you want to bind multiple form fields to a Java object.

Spring automatically fills the fields of the object using the form data.

Very useful when handling HTML forms (like registration or login).

@RequestParam

Used when you want to get a single value from the request, like a query
parameter or a form field.

You manually bind each value to a method parameter.

98. How does Spring Boot support REST API versioning?

Spring Boot doesn’t have built-in versioning, but you can easily implement
it in your controller layer.

Via:

URL versioning: /api/v1/users

Header versioning: X-API-VERSION: 1

Media type versioning: Accept: application/[Link].v1+json

99. What is the purpose of the @InitBinder annotation in Spring Boot?

@InitBinder is used to customize how Spring binds HTTP request data to

Java objects.

Example use cases:

Date formatting

String trimming

Custom type converters

@InitBinder

public void initBinder(WebDataBinder binder) {

[Link]([Link], new CustomDateEditor(

new SimpleDateFormat("yyyy-MM-dd"), false));

}s

Define two DataSource beans

Create two EntityManagerFactory beans

Configure separate TransactionManagers

Use @Primary and @Qualifier to differentiate

Best practice: Keep configs in separate @Configuration classes (e.g.,

PrimaryDBConfig, SecondaryDBConfig).