Dependency Injection in Spring Boot

A design pattern that allows components to be loosely coupled
Spring Boot uses Dependency Injection to manage dependencies between components
Benefits:
- Loose Coupling: components are not tightly coupled to specific implementations
- Testability: components can be easily tested with mock dependencies
- Flexibility: dependencies can be easily swapped or replaced
In Spring Boot, dependencies are managed using the @Bean annotation and the Spring IoC (Inversion of Control) container

Spring Boot's ability to automatically configure the application based on the dependencies present in the classpath
Auto-configuration is achieved using the @SpringBootApplication annotation, which enables auto-configuration and component scanning
Benefits:
- Reduces boilerplate code and configuration
- Simplifies application setup and development
- Allows for easy switching between different environments (e.g. dev, prod)
Auto-configuration can be customized using properties files (e.g. application.properties) and profile-specific configuration files

A architectural style for designing networked applications
Spring Boot provides built-in support for building RESTful APIs using the @RestController annotation
Key features:
- Resource-based: APIs are organized around resources and their corresponding URIs
- Client-Server: separation of concerns between client and server
- Stateless: server does not maintain client state
- Cacheable: responses can be cached to improve performance
- Uniform Interface: APIs use a uniform interface to communicate (e.g. HTTP, JSON)
Spring Boot provides features such as request and response mapping, error handling, and content negotiation

A software architecture pattern that separates application logic into three interconnected components:
1. Model: represents the data and business logic
2. View: responsible for rendering the user interface
3. Controller: handles user input and updates the model and view accordingly
Spring Boot uses the MVC architecture to build web applications
Benefits:
- Separation of Concerns: each component has a specific role and responsibility
- Reusability: components can be reused across different applications
- Flexibility: easy to switch between different view technologies and templates

A Spring-based library that provides a simple and consistent programming model for data access
Spring Data JPA (Java Persistence API) provides a repository abstraction for interacting with databases
Benefits:
- Simplifies data access: reduces boilerplate code and complexity
- Improves data consistency: provides a consistent programming model across different databases
- Supports caching: improves performance by caching frequent queries
Spring Data JPA provides features such as CRUD (Create, Read, Update, Delete) operations, query methods, and transaction management

A design pattern promoting loose coupling among components.
Utilized by Spring Boot for managing inter-component dependencies.
Benefits include:
- Loose Coupling: Components depend on interfaces rather than specific implementations.
- Testability: Enables easy testing with mock dependencies.
- Flexibility: Dependencies can be substituted swiftly.
Managed using the @Bean annotation alongside the Spring IoC (Inversion of Control) container.

Automatically configures applications based on classpath dependencies.
Enabled through the @SpringBootApplication annotation, which combines component scanning and auto-configuration.
Benefits include:
- Reduced Boilerplate: Minimizes repetitive code and configuration practices.
- Simplified Setup: Eases the initial setup process.
- Environment Flexibility: Facilitates transitions between development and production environments.
Customizable using properties files like application.properties and environment-specific configurations.

An architectural style designed for networked applications, focusing on resource manipulation.
Supported in Spring Boot with the @RestController annotation.
Key features:
- Resource-Based Structure: Organizes APIs around resources and unique URIs.
- Client-Server Architecture: Ensures a distinct separation of roles between client and server.
- Stateless Operations: Server does not retain client state between requests.
- Cacheable Responses: Enhances performance through response caching.
- Uniform Interface: Employs standardized communication methods like HTTP and JSON.
Spring Boot offers functionalities for request response mapping, error handling, and content negotiation.

A software architectural pattern splitting application logic into three main components:
1. Model: Manages data and business logic.
2. View: Responsible for displaying user interface elements.
3. Controller: Processes user inputs and coordinates model and view updates.
Adopted by Spring Boot for developing web applications.
Benefits include:
- Separation of Concerns: Each component has a unique responsibility, enhancing modularity.
- Reusability: Promotes component reuse across various applications.
- Flexibility: Simplifies changes between different view technologies and templates.

A library centered on simplifying data access within Spring applications.
Provides a repository abstraction layer for seamless database interaction using Java Persistence API (JPA).
Benefits include:
- Simplified Data Handling: Reduces boilerplate code and complexity in data operations.
- Consistent Programming Model: Enhances compatibility across various database systems.
- Caching Support: Boosts performance by caching repeated queries.
Offers functionalities including CRUD operations, various query methods, and transaction management capabilities.