Summary of Spring Boot Interview Questions and Concepts

Video Duration: 00:00:00 to 01:09:08

---

#### [00:00:00 !’ 00:01:30] Introduction to Java and Spring Boot

- Java development is often seen as more complex than languages like JavaScript, Ruby,
Go, and C due to verbose syntax and configuration requirements.
- Platform independence and automatic memory management are key strengths of Java.
- Java is widely used in web development, largely due to frameworks like Spring Boot.
- Spring Boot is a powerful, open-source Java framework built on top of Spring, designed to
create Java applications with minimal configuration.
- It hides Java’s complexity and lets developers focus on business logic.
- Spring Boot is among the top 10 rising developer skills and used by over 12% of web
developers worldwide (Statista).
- The video will cover 30 common Spring Boot interview questions divided into basic,
intermediate, and advanced sections.

---

#### [00:01:30 !’ 00:04:44] What is Spring Boot & How It Differs from Spring Framework
- Spring Boot is an open-source Java framework simplifying Spring application development
by eliminating boilerplate configurations.
- Traditional Spring requires manual, error-prone setup; Spring Boot automates configuration to
reduce frustration.
- Difference between Spring and Spring Boot:
- Spring is like renting an empty, unfurnished house — you bring all components yourself.
- Spring Boot is like renting a furnished house — it provides ready-to-use components with
the platform.
- Main features of Spring Boot:
- Auto-configuration: Automatically configures components like server ports when
dependencies are added.
- Spring Boot Starters: Pre-packaged dependency kits for common tasks (e.g., web,
database, security), reducing compatibility issues.
- Spring Boot Actuator: Provides production-ready features to monitor and manage
applications (health, metrics, logs).
- Spring Boot Initializer: Web tool to generate starter projects quickly.

---

#### [00:04:44 !’ 00:08:54] Spring Boot Starters & Creating an Application

- Spring Boot Starters:

Generated with [Link]

- Examples include `spring-boot-starter-web`, `spring-boot-devtools`, `spring-data-jpa`,
`h2-database`, `mysql`, `postgresql`, and `spring-security`.
- Categorized by domain: Web, Database, Security, etc.
- They bundle compatible default versions of dependencies to avoid version clashes.
- Spring Web Starter includes an embedded Tomcat server, Spring MVC, Jackson for JSON
processing, and REST API support.
- Creating a Spring Boot app using Spring Initializer:
- Generate a starter project online with selected dependencies (e.g., spring-web).
- Import the Maven project into IDE (e.g., Eclipse).
- Run the main class to start the application on default port 8080.
- To display content, create a RestController with a root mapping returning a welcome
message.
- This process demonstrates the ease of startup and configuration with Spring Boot.

---

#### [00:08:54 !’ 00:16:19] Key Annotations and Configuration in Spring Boot

- @SpringBootApplication is a meta-annotation combining:
- `@Configuration` (marks class as configuration source),
- `@EnableAutoConfiguration` (triggers auto-configuration based on dependencies),
- `@ComponentScan` (scans for components/services/controllers).
- This reduces boilerplate; instead of three annotations, one annotation suffices.
- [Link] file:
- Centralized place for application-specific settings like server port, database credentials, etc.
- Allows changing behavior without modifying source code.
- To run Spring Boot on a custom port, add `[Link]=8081` in `[Link]`.
- Spring Boot DevTools:
- Provides automatic restart and live reload during development to avoid manual restarts
after every code change.
- Added as a dependency from Spring Initializer (`spring-boot-devtools`).
- Embedded servers:
- Spring Boot includes embedded web servers like Tomcat (default), Jetty, or Undertow.
- Tomcat is included automatically with `spring-boot-starter-web`.
- To switch servers, exclude Tomcat and add the desired one manually.

---

#### [00:16:19 !’ 00:26:20] Spring Boot Actuator & Auto-Configuration

- Spring Boot Actuator:
- Provides production-ready features to monitor and manage applications.
- Exposes endpoints such as `/actuator/health`, `/actuator/metrics` to view application health,
logs, and metrics.

Generated with [Link]

- Requires adding actuator dependency and enabling endpoints in `[Link]`.
- Auto-configuration workings:
- Based on `@EnableAutoConfiguration`, Spring Boot configures beans automatically
depending on present dependencies.
- Example: adding actuator starter automatically sets up health endpoints without manual
coding.
- Spring Boot Starter Parent:
- Defined in `[Link]`, this manages versions of dependencies used in the project.
- It selects default compatible versions (not necessarily the latest), ensuring compatibility
and reducing conflicts.
- Also manages Java version (default is Java 17).

---

#### [00:26:20 !’ 00:34:08] Defining Properties, RestController & Basic REST API
- Spring Boot properties:
- Stored in `[Link]` or `[Link]`.
- Control app behavior at runtime, avoiding hardcoding values.
- @RestController annotation:
- Used to build RESTful APIs serving data in lightweight formats like JSON or XML.
- Enables methods to respond directly with serialized data without view resolution.
- Creating a basic REST API:
- Define a controller class annotated with `@RestController`.
- Use `@GetMapping` and `@PostMapping` to handle HTTP GET and POST requests
respectively.
- Example: a simple API to add and retrieve greeting messages or books.
- This demonstrates how REST APIs in Spring Boot facilitate client-server communication.

---

#### [00:34:08 !’ 00:36:37] Difference Between @Component, @Service, @Repository,

@Controller
| Annotation | Purpose | Example Use
Case |

|-----------------|-----------------------------------------------------------------------------------------|-----------------------------
| @Component | Generic stereotype to mark a class as Spring-managed bean
| Utility class generating order IDs |
| @Service | Specialization of `@Component` for classes holding business logic
| Calculating total price in a shopping cart |
| @Repository | Specialization for data access objects (DAO) interacting with databases
| Saving order/product details in DB |

Generated with [Link]

| @Controller | Marks classes handling HTTP requests/responses in MVC pattern
| Handling user actions like Add to Cart APIs |

- Example of e-commerce app:

- Component: generates random order IDs.
- Service: calculates order totals.
- Repository: handles DB operations for orders.
- Controller: manages user interaction endpoints.

---

#### [00:36:37 !’ 00:43:56] Dependency Management & @Value Annotation

- Dependency management:
- Spring Boot manages external libraries via starters (web, data JPA, security, actuator, etc.).
- Each starter bundles required dependencies including embedded servers and JSON
processors (Jackson).
- @Value annotation:
- Injects values from `[Link]` into Spring-managed beans.
- Example: `@Value("${[Link]}")` injects the value of `[Link]` property into a
field.
- Useful for managing configurable variables like usernames, passwords, URLs dynamically.

---

#### [00:43:56 !’ 00:45:42] Exception Handling in Spring Boot

- Exception handling can be custom or global.
- Example of global exception handler using:
- `@ControllerAdvice` for global scope,
- `@ExceptionHandler` to handle specific exceptions.
- Returns a custom error response encapsulating error message, details, and status,
avoiding default white-label errors.
- Helps in centralized handling of exceptions and consistent error responses.

---

#### [00:45:42 !’ 00:47:11] Purpose of @Configuration and Externalized Configuration

- @Configuration:
- Marks a class as a source of bean definitions and configuration blueprint.
- Useful for defining bean templates reused across the app.
- Externalized Configuration:
- Allows specifying app settings outside source code (in properties or YAML files).
- Enables environment-specific behavior (e.g., city vs highway mode analogy for cars).

Generated with [Link]

- Facilitates changing configs without recompiling or altering source.

---

#### [00:47:11 !’ 00:51:01] Packaging Spring Boot Applications

| Packaging Type | Description |
Use Case/Analogy |

|--------------------|---------------------------------------------------------------------------------------------------|----------------
| Executable JAR | Self-contained, easy to deploy app with no external dependencies
| Moving with just a suitcase; minimal, simple setup |
| Executable WAR | For enterprise environments requiring external web servers and
dependencies | Moving with a van including external items |
| Docker Image | Portable container encapsulating app and environment for cloud
deployment | Moving entire house in a container for consistent environment
|
| Native Image | Lightweight, performance-optimized binaries with fast startup and low
memory usage | Lightweight backpack for fast and efficient travel |

---

#### [00:51:01 !’ 00:54:44] Securing Spring Boot Applications

- Security essentials for apps like banking:
- Authentication: Username and password for user login.
- Authorization: Admin-only access to sensitive features.
- Data protection: Use HTTPS for secure communication.
- Vulnerability patching: Prevent injection attacks (e.g., SQL injection).
- Tools:
- Spring Security starter for authentication and authorization.
- BCrypt or similar libraries for password hashing.
- JWT (JSON Web Tokens) for secure session management with automatic expiry.

---

#### [00:54:44 !’ 00:56:10] @EnableAutoConfiguration Annotation

- It automatically configures Spring Boot app based on dependencies and needs.
- Simplifies setup like a personal assistant automating trip planning by managing all details
(route, car rental, playlist).
- Enables developers to focus on business logic instead of infrastructure.

---

Generated with [Link]

#### [00:56:10 !’ 01:02:28] Creating a RESTful Web Service Example
- Defines a `Book` class with fields: `id`, `title`, `author`.
- Creates a `BookController` with:
- `@RestController` and `@RequestMapping("/books")`.
- `@GetMapping` to fetch all books.
- `@PostMapping` to add new books (accepting JSON in request body).
- Demonstrates using Postman to test GET and POST requests.
- Note: Without a database configured, storage is temporary and resets on server restart.

---

#### [01:02:28 !’ 01:03:31] @Entity Annotation

- Marks a class as a JPA entity, mapping it to a database table.
- Defines how class fields correspond to database columns.
- Enables automatic generation of SQL statements for CRUD operations.

---

#### [01:03:31 !’ 01:06:35] Common Testing Annotations in Spring Boot

| Annotation | Purpose |
Analogy/Example |

|---------------------|------------------------------------------------------------------------------------------------|------------------
| @SpringBootTest | Integration testing of the whole application with real configurations
| Testing the entire restaurant workflow with customers, chef, waiter |
| @Test | Marks individual methods as unit tests |
Testing if a waiter can correctly calculate a bill |
| @Autowired | Injects dependencies automatically into test classes
| Manager hiring staff on your behalf |
| @MockBean | Creates mock implementations for services/components during testing
| Using an actor pretending to be a chef for testing kitchen flow |
| @DataJpaTest | Focused testing on JPA repositories for database interactions
| Testing database connection and queries |

---

#### [01:06:35 !’ 01:08:12] [Link] vs [Link]

- [Link] advantages over properties:
- Centralized, hierarchical, and readable configuration.
- Supports environment-specific profiles (dev, prod, test).
- Easier nesting and organization of related settings.
- Dynamically read and applied at application startup.

Generated with [Link]

- YAML syntax is cleaner and more structured compared to flat properties format.

---

#### [01:08:12 !’ 01:09:08] Monitoring and Managing Spring Boot Applications in Production
- Spring Boot provides built-in tools such as Actuator for monitoring metrics, logs, and
health.
- Can be integrated with external tools like Prometheus for visualized application monitoring.
- These tools help maintain application performance and stability in production environments.

---

Key Insights and Takeaways

- Spring Boot drastically simplifies Java web development by automating configuration
and packaging.
- It offers starters, auto-configuration, embedded servers, and actuator for streamlined
development and monitoring.
- Configuration is externalized via `[Link]` or `[Link]` for flexibility.
- Spring Boot supports easy creation of REST APIs with minimal code using
`@RestController` and mapping annotations.
- It supports robust security through Spring Security, session management, and encryption
libraries.
- Testing is well-supported with annotations for integration, unit, mock testing, and database
testing.
- Packaging options range from simple JARs to Docker images, facilitating deployment in
varied environments.
- Actuator and monitoring tools are essential for production-grade application
management.

This comprehensive overview equips developers for Spring Boot interview preparation and
practical application development.

Generated with [Link]