SPRINGBOOT

1. What is a Spring Boot?

Spring Boot is an open-source Java framework designed to simplify the development of stand-
alone, production-grade Spring-based applications. It provides a streamlined experience by
offering auto-configuration, starter dependencies, and an embedded HTTP server, allowing
developers to quickly set up and run Spring applications with minimal configuration.

2. What are all the advantages of using spring boot-based applications?

The main advantages of using Spring Boot include rapid development due to its
convention-over-configuration approach, simplified dependency management, built-in
support for various technologies such as embedded servers and databases, seamless
integration with Spring ecosystem components, and enhanced productivity through
features like auto-configuration and starters.

3. How does Spring Boot simplify the configuration of Spring applications?

Spring Boot simplifies the configuration of Spring applications by providing sensible

defaults and auto-configuration. It eliminates the need for manual setup and
boilerplate code by automatically configuring Spring beans and components based on
class path and application properties. This greatly reduces the development time and
effort required for setting up and maintaining Spring applications.

4. How does Spring Boot handle dependency management?

Spring Boot simplifies dependency management through its use of starter

dependencies, which are curated sets of dependencies that fulfil specific application
needs. These starters provide a convenient way to add dependencies to the project
without needing to manage individual versions manually.

5. Can you explain the concept of auto-configuration in Spring Boot?

Auto-configuration in Spring Boot automatically configures Spring beans and

components based on the class path and detected dependencies. It leverages the
`@Conditional` annotations to conditionally enable configuration based on the
presence or absence of certain classes or properties. This feature simplifies
application setup and reduces manual configuration.

SUMATHI R 1
6. What is the purpose of the @SpringBootApplication annotation in a Spring Boot
application?

The `@SpringBootApplication` annotation is a convenience annotation in Spring Boot

that combines `@Configuration`, `@EnableAutoConfiguration`, and
`@ComponentScan`. It marks the entry point of a Spring Boot application and enables
auto-configuration and component scanning.

7. Some common annotations used in Spring Boot along with their uses.

1. **@SpringBootApplication**:

- Use: Marks the main class of a Spring Boot application. It combines

`@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan`, enabling
auto-configuration and component scanning.

2. **@Controller**:

- Use: Marks a class as a Spring MVC controller. It handles incoming web requests and
returns the appropriate response.

3. **@RestController**:

- Use: Like `@Controller`, but specifically tailored for RESTful web services. It
combines `@Controller` and `@ResponseBody`, indicating that methods return data
to be serialized directly into the response body.

4. **@Service**:

- Use: Marks a class as a service component in the business logic layer. It

encapsulates business logic and transaction management.

5. **@Repository**:

- Use: Marks a class as a repository component, typically used for data access
operations. It facilitates interaction with databases or other external data sources.

6. **@Component**:

- Use: Annotates a class as a Spring component. It serves as a generic stereotype for

any Spring-managed component.

SUMATHI R 2
 7. **@Autowired**:

- Use: Injects a dependency into a Spring-managed bean. It automatically wires beans

together by type.

8. **@Value**:

- Use: Injects a value from properties files, environment variables, or other sources
into a Spring bean's field, constructor, or method parameter.

9. **@Configuration**:

- Use: Indicates that a class provides bean definitions and should be processed by the
Spring IoC container to generate bean definitions at runtime.

10. **@EnableAutoConfiguration**:

- Use: Enables Spring Boot's auto-configuration feature, which automatically

configures the Spring application based on class path dependencies and properties.

11. **@RequestMapping**:

- Use: Maps HTTP requests to handler methods in a Spring MVC controller. It

specifies the URL pattern and HTTP method for request mapping.

12. **@PathVariable**:

- Use: Binds a method parameter to a value extracted from the URI path in a Spring
MVC controller.

13. **@RequestParam**:

- Use: Binds a method parameter to a query parameter or form data submitted

with an HTTP request in a Spring MVC controller.

14. **@ResponseBody**:

- Use: Indicates that a method return value should be serialized directly into the
response body in a Spring MVC controller, typically used with `@RestController`.

15. **@ExceptionHandler**:

- Use: Defines methods to handle specific exceptions globally within a Spring MVC
controller, allowing centralized exception handling.

SUMATHI R 3
8. Stereotype Annotations?

In Spring, stereotype annotations are a set of annotations used to indicate the role or
purpose of a class within the Spring application context. These annotations help
Spring to understand how the class should be treated and managed by the Spring IoC
container. There are several stereotype annotations in Spring:

@Component`: Indicates that the class is a generic Spring-managed component. It

serves as a general-purpose stereotype annotation and can be used for any class.

@Controller`: Indicates that the class is a controller in a Spring MVC application. It

typically handles incoming HTTP requests, processes them, and returns an
appropriate response.

@Service`: Indicates that the class is a service or business logic component in the
application. It encapsulates business logic and performs specific tasks.

@Repository`: Indicates that the class is a repository or data access component. It

typically interacts with a database, provides CRUD operations, and manages data
access logic.

@Configuration`: Indicates that the class is a configuration class for the Spring
application context. It typically contains bean definitions and configuration settings
using annotations such as `@Bean`, `@ComponentScan`, etc.

These stereotype annotations provide metadata to Spring, allowing it to automatically

detect, create, and manage instances of these components within the application
context. By using these annotations, you can keep your code clean, concise, and
modular, following best practices for building Spring applications.

9. Explain the difference between `@RestController` and `@Controller` in Spring Boot?

How can you handle exceptions in Spring Boot RESTful APIs?

"`@RestController` is a specialized version of `@Controller` in Spring Boot that is used

for creating RESTful web services. It automatically converts the return value of
methods to JSON or XML, making it suitable for RESTful APIs."

- "Exception handling in Spring Boot RESTful APIs can be done using

`@ControllerAdvice` to define global exception handling logic or by using
`@ExceptionHandler` within specific controllers to handle exceptions locally."

SUMATHI R 4
10. Dependency Injection?

Dependency Injection is a design pattern used in software development, particularly

in frameworks like Spring Boot. It allows for the external provision of dependencies to
a class or component, rather than the class creating them itself. This promotes loose
coupling, modular design, and easier testing by making components more reusable
and easier to manage.

Here's an example to illustrate dependency injection in a Spring Boot application:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
private final MyRepository repository;
@Autowired
public MyService(MyRepository repository) {
this.repository = repository;
} // Other methods using repository
}

In this example:MyService is a Spring-managed service component.MyRepository is a

dependency of MyService.The constructor of MyService is annotated with
@Autowired, indicating that MyRepository should be injected into MyService when it
is created.Spring automatically identifies MyRepository as a dependency and provides
an instance of it to MyService when it is created.This way, your MyService class
doesn't need to know how to create instances of MyRepository. Spring Boot handles
this dependency injection for you, making your code more modular and easier to
maintain.

11. What is a bean in Spring boot?

In Spring Boot, a bean is simply an object that is managed by the Spring framework's
Inversion of Control (IoC) container. The IoC container, also known as the Spring
container, is responsible for instantiating, configuring, and managing these beans
throughout the lifecycle of a Spring application.

Beans in Spring Boot are typically Java objects annotated with Spring's stereotype
annotations such as `@Component`, `@Service`, `@Repository`, or `@Controller`,
among others. These annotations allow Spring to automatically detect and register
beans during application startup.

SUMATHI R 5
 Beans can represent various components of the application, including controllers,
services, repositories, configuration classes, etc. By leveraging dependency injection,
Spring Boot wires these beans together, allowing them to collaborate and work
seamlessly within the application context.

Overall, beans play a central role in Spring Boot applications, providing a flexible and
modular way to structure and manage application components.

12. What is the role of the application.properties or application.yml file in a Spring Boot
application?

These configuration files are used in Spring Boot to externalize application

configuration. They allow developers to specify properties such as database
connection settings, server ports, logging levels, etc., without modifying the source
code. Spring Boot automatically loads and applies these properties during application
startup.

13. What are Spring Boot profiles, and how are they used? Can you explain how to define
and activate profiles in a Spring Boot application?

Spring Boot profiles allow developers to customize application behaviour for different
environments, such as development, testing, and production. Profiles are activated
using environment-specific properties or command-line arguments.

//application.properties file
//Spring.profiles.active = development

14. How does Spring Boot support externalized configuration? What are the different
sources of externalized configuration in Spring Boot?

Spring Boot supports externalized configuration through properties files

(application.properties or application.yml), environment variables, system properties,
and command-line arguments. Externalized configuration allows developers to modify
application settings without changing code.

SUMATHI R 6
15. How can you override default Spring Boot configurations? What is the purpose of the
`@ConfigurationProperties` annotation, and how is it used in Spring Boot?

To override default Spring Boot configurations, you can provide custom configuration
properties in `application.properties` or `application.yml` files. These properties will
take precedence over the default values defined by Spring Boot."

"`@ConfigurationProperties` annotation is used in Spring Boot to bind external

configuration properties to Java objects. It allows you to inject properties from the
configuration files directly into your beans."

16. What are Spring Boot starters, and how do they simplify project setup?

Spring Boot starters are pre-configured sets of dependencies that simplify project
setup by providing a cohesive set of libraries for common tasks such as web
development, database access, security, etc. They eliminate the need for manual
dependency management and reduce the complexity of configuring Spring
applications.

17. How can you deploy a Spring Boot application?

Spring Boot applications can be deployed in various ways, including standalone JAR
files, WAR files deployed to servlet containers like Tomcat or Jetty, or as Docker
containers. The choice of deployment method depends on factors such as application
requirements, scalability, and infrastructure setup.

18. What is Spring Boot Actuator and what functionality does it provide?

Spring Boot Actuator is a sub-project of Spring Boot that provides production-ready

features to help monitor and manage Spring Boot applications. It includes built-in
endpoints for health checks, metrics, info, environment, and more, which can be
accessed over HTTP or JMX.

Spring Boot Actuator is not compulsory, but it's highly recommended for production-
grade applications. It provides essential features for monitoring and managing your
Spring Boot application in production environments. While you're not required to use
it, integrating Spring Boot Actuator can greatly enhance your ability to monitor
application health, gather metrics, and troubleshoot issues.

SUMATHI R 7
19. How does Spring Boot support security in web applications? Can you explain the
various authentication and authorization mechanisms provided by Spring Security in
Spring Boot?

Spring Boot integrates with Spring Security to provide authentication and

authorization mechanisms for securing web applications. It supports features such as

If your application deals with sensitive data, user authentication, or access control,
then incorporating Spring Boot Security becomes essential to ensure proper
protection against unauthorized access and security threats. However, for simple
projects without security requirements, you may choose not to include Spring Boot
Security.

20. What is Spring Data JPA, and how does it simplify data access in Spring Boot
applications? Can you demonstrate how to define and use repositories in Spring Data
JPA?

Spring Data JPA is a part of the larger Spring Data project that simplifies data access in
Spring applications, particularly when working with relational databases. It provides
repository support for CRUD operations, query methods, pagination, and more, with
minimal boilerplate code."

Spring Data JPA works with relational databases like Oracle by providing layer of
abstraction and convenience on top of JPA, which itself is a standard Java API for
accessing, persisting and managing data in relational databases.

21. What is Swagger?

Swagger is an open-source framework that provides tools for designing, building,

documenting, and consuming RESTful APIs. It allows developers to describe the
structure and functionality of APIs using a standard format (Open API Specification)
and generate interactive API documentation."

Swagger is incredibly useful for drawing blueprints or documenting APIs during the
design phase. It allows developers to define the structure, endpoints,
request/response formats, and even authentication mechanisms in a standardized
format. This documentation serves as a blueprint that can be shared with team
members, stakeholders, and even external consumers of the API. It ensures
consistency, clarity, and ease of understanding, making the API design process more
efficient and collaborative. Additionally, Swagger's interactive documentation feature,
such as Swagger UI, provides a user-friendly interface for exploring and testing APIs,
further aiding in the design and validation process.

SUMATHI R 8
22. How does Swagger benefit API development in Spring Boot?

Swagger simplifies API development in Spring Boot by providing a standardized way to

document APIs. It helps maintain consistency, improves communication between
developers, and enables automatic generation of interactive API documentation,
client SDKs, and server stubs."

23. How do you integrate Swagger with a Spring Boot application?

Swagger can be integrated with a Spring Boot application using the Springfox library,
which provides annotations and configuration classes to generate Swagger
documentation from Spring MVC controllers. By adding Springfox dependencies and
configuring Docket beans, Swagger UI is automatically generated.

24. What are some common annotations used with Swagger in Spring Boot?

Common annotations used with Swagger in Spring Boot include `@Api` to annotate
controller classes, `@ApiOperation` to annotate API operations, `@ApiParam` to
describe method parameters, `@ApiResponse` to define response messages, and
`@ApiModel` to annotate model classes."

25. How can you customize Swagger documentation in a Spring Boot application?

Swagger documentation in a Spring Boot application can be customized using various

configuration options provided by Springfox, such as specifying API version, setting
base path, including/excluding specific packages or classes, defining security schemes,
and adding custom documentation annotations.

26. Can Swagger be used for API testing?

Yes, Swagger can be used for API testing by leveraging its interactive documentation
feature, Swagger UI. Developers and testers can directly interact with API endpoints,
submit requests, and view responses using the Swagger UI interface, making it a
valuable tool for manual and exploratory testing.

SUMATHI R 9
27. What are the different testing techniques available in Spring Boot? How do you write
unit tests and integration tests for Spring Boot applications?

Spring Boot supports various testing techniques, including unit testing with JUnit and
Mockito, integration testing with Spring Boot's testing annotations and embedded
databases, and end-to-end testing with tools like Selenium or REST Assured.

28. How does Spring Boot integrate with Spring Cloud for building distributed systems?
Can you explain some of the key components of Spring Cloud and how they are used
with Spring Boot?

Spring Boot seamlessly integrates with Spring Cloud to build distributed systems.
Spring Cloud provides tools and libraries for common distributed system patterns
such as service discovery (Netflix Eureka), distributed configuration (Spring Cloud
Config), intelligent routing (Netflix Zuul), and more.

29. How can you monitor and manage a Spring Boot application's performance? What
logging frameworks does Spring Boot support, and how can you configure logging
levels and appenders?

Spring Boot applications can be monitored using built-in features like Spring Boot
Actuator endpoints for health checks and metrics. For logging, Spring Boot supports
various logging frameworks such as Logback, Log4j2, and JUL, with configurable
logging levels, appenders, and log formats.

30. What is Spring Boot DevTools, and how do they enhance the development
experience? Can you explain some of the features provided by Spring Boot DevTools?

Spring Boot DevTools is a set of tools designed to enhance the development

experience. It includes features like automatic application restarts, live reload for
static resources, enhanced error reporting, and built-in support for remote
debugging.

31. How can you perform input validation in Spring Boot? What is the purpose of the
`@Validated` annotation, and how is it used for method-level validation?

SUMATHI R 10
 Input validation in Spring Boot can be performed using Bean Validation API
annotations such as `@NotNull`, `@NotBlank`, `@Size`, etc., along with the `@Valid`
annotation to trigger validation."

"`@Validated` annotation is used to apply validation constraints at the method level

in Spring Boot. It allows you to specify groups for validation and supports method
parameter validation."

32. What are some commonly used endpoints provided by Spring Boot Actuator? How
can you customize and secure Spring Boot Actuator endpoints?

Commonly used endpoints provided by Spring Boot Actuator include `/health`, `/info`,
`/metrics`, `/env`, `/beans`, `/mappings`, etc."

"Spring Boot Actuator endpoints can be customized and secured by configuring

access rules in the `application.properties` or `application.yml` file. You can also
create custom endpoints by implementing `Endpoint` interfaces."

33. How does Spring Boot support caching, and what caching providers does it integrate
with? How can you configure caching in a Spring Boot application?

Spring Boot supports caching through integration with caching providers like Ehcache,
Redis, Caffeine, etc. You can enable caching by adding appropriate dependencies and
annotating methods with `@Cacheable`, `@CacheEvict`, etc."

"Caching can be configured in a Spring Boot application by specifying cache properties

in the `application.properties` or `application.yml` file, including cache names,
expiration policies, and cache managers."

34. How can you implement messaging in Spring Boot applications using technologies like
RabbitMQ or Apache Kafka? What is the role of Spring Integration in Spring Boot
messaging?

Messaging in Spring Boot applications can be implemented using technologies like

RabbitMQ or Apache Kafka by integrating corresponding Spring Boot starters and
configuring messaging components such as queues, topics, etc."

Spring Integration provides support for building messaging-based applications in

Spring Boot by offering components like message channels, message handlers, and
adapters for integration with messaging systems.

SUMATHI R 11
35. How can you implement internationalization and localization in a Spring Boot
application? What are some common strategies for managing localized messages and
resources in Spring Boot?

Internationalization (i18n) and localization (l10n) in Spring Boot involve externalizing

message strings into property files, using `MessageSource` to resolve messages based
on locale, and configuring locale resolution strategies.

"Common strategies for managing localized messages and resources in Spring Boot
include using message bundles for different languages, organizing message files based
on locales, and supporting dynamic locale changes based on user preferences."

36. Spring Container vs IOC container?

Spring container" and "IoC container" are often used interchangeably.

The Spring container is responsible for managing the components (beans) of a Spring
application, including their instantiation, configuration, and lifecycle management. It
achieves this through the concept of Inversion of Control (IoC), where the control
over object instantiation and management is inverted from the application code to
the container.

So, when we talk about the Spring container or IoC container, we are referring to the
same thing: the core mechanism provided by the Spring Framework for managing
beans and their dependencies. This container is responsible for implementing the
principles of IoC, such as dependency injection and loose coupling, which are central
to the design philosophy of the Spring Framework.

37. Components vs Beans?

"components" and "beans" are closely related but not the same.

**Components**: In Spring, a component is any class that is managed by the Spring

IoC container. Components are typically annotated with stereotype annotations such
as `@Component`, `@Service`, `@Repository`, or `@Controller` to indicate to the
container that they should be instantiated and managed as beans.

**Beans**: A bean is an instance of a class that is managed by the Spring IoC

container. In other words, a bean is an object that is instantiated, configured, and
managed by the container. Beans can be any Java object, including components

SUMATHI R 12
 annotated with stereotype annotations or beans defined explicitly in configuration
classes using `@Bean`.

So, while all beans are components, not all components are beans. Components are
classes that are managed by the Spring container, and beans are instances of those
classes that are managed by the container. The term "bean" is often used more
specifically to refer to instances of classes managed by the container.

38. Spring MVC?

"Spring MVC is a web framework built on top of the Spring Framework, designed to
simplify the development of web applications in Java. It follows the Model-View-
Controller (MVC) architectural pattern, which separates the application into three
main components:

1. **Model**: Represents the application's data and business logic. In Spring MVC,
model objects are typically Java objects (POJOs) that encapsulate data and behavior
relevant to the application.

2. **View**: Renders the user interface and presents data to the user. Views in
Spring MVC are often implemented using technologies like JSP (JavaServer Pages),
Thymeleaf, or FreeMarker.

3. **Controller**: Handles user requests, processes input, and coordinates with the
model and view components. Controllers in Spring MVC are implemented as Java
classes annotated with `@Controller`, which handle specific URL mappings and HTTP
methods.

Overall, Spring MVC offers a flexible and powerful framework for building web applications in
Java, leveraging the features and capabilities of the underlying Spring Framework to simplify
development, improve maintainability, and enhance scalability."

SUMATHI R 13