This repository is aimed at providing a comprehensive introduction to Spring Boot, particularly focusing on three main aspects: basic Spring Boot concepts, building REST APIs, and integrating with a database using Spring Data JPA.

• Spring Beans:

  • Objects managed by Spring IoC container.
  • Core building blocks of a Spring application.
  • Configured with metadata supplied to the container.
  • Typically Java objects.

• Spring Profiles:

  • Segregate parts of application configuration.
  • Available only in specific environments.
  • Enable different configurations for development, testing, production, etc.
  • Control which beans are loaded and which configurations are applied.

• Qualifiers:

  • Resolve ambiguity when multiple beans of the same type are available.
  • Used with @Qualifier annotation.
  • Specify which bean should be autowired into a particular field or parameter.
  • Useful when multiple beans implement the same interface or are of the same type.

The project is organized into three main folders:

1. demo: Basic Spring Boot concepts are covered in this folder including Spring Beans, Qualifier, Spring Profiles, Dependency Injection, and creating the first class and service.

2. rest: This folder covers the basics of building REST APIs with Spring Boot. It includes creating the first controller using @RestController, and utilizing @GetMapping, @PostMapping, @PutMapping, and @DeleteMapping. Path variables and request parameters are also demonstrated, along with creating the first record.

3. rest_database: This folder focuses on integrating Spring Boot with a database using Spring Data JPA. Notably, the application.properties file is updated to application.yaml to configure the database connection. Below is the configuration explained:

• Datasource Configuration: Specifies the URL, username, password, and driver class for connecting to the PostgreSQL database.
• JPA Configuration: Configures Hibernate behavior, including DDL auto, SQL logging, and database dialect.

In each of the students, studentProfile, and School packages within the rest_database folder, the following components are created:

• Controller: Defines endpoints for handling HTTP requests.
• Mapper: Converts between DTOs (Data Transfer Objects) and domain objects.
• Response: Defines response structures for API endpoints.
• DTO: Data Transfer Objects representing the data exchanged between the client and server.
• Repository: Interfaces defining methods for interacting with the database.
• Service: Implements business logic and interacts with repositories.

This structure helps in maintaining a clean and organized codebase, following the principles of separation of concerns and modularity.

In the rest_database module, exception handling and validation are implemented to enhance the robustness and reliability of the REST API endpoints.

• Exception handling is crucial for handling errors and exceptions gracefully in a Spring Boot application.
• In the controller layer, exception handling is implemented using @ControllerAdvice and @ExceptionHandler annotations.
• Custom exception classes can be created to represent different types of errors that may occur during the execution of API endpoints.
• Global exception handlers catch exceptions thrown during request processing and return appropriate HTTP responses with error details.
• This ensures consistent error responses across all endpoints and improves the overall user experience.

• Input validation is important for ensuring that the data sent to the API endpoints is valid and meets the required criteria.
• In the studentDTO layer, input validation is performed using annotations such as @Valid and @Validated.
• Bean validation annotations like @NotBlank, @NotNull, @Size, etc., are used to define validation rules for request parameters, request bodies, and path variables.
• If the incoming data fails validation, Spring Boot automatically detects the validation errors and returns appropriate error responses with details about the validation failures.
• This helps in preventing invalid data from being processed further, improving data integrity and API reliability.