Spring Boot Cheat Sheet

Annotations

Control Flow

1. 
   Initialization: Spring Boot starts by loading application properties and auto-configuring beans.


2. 
   Component Scanning: Spring scans for components like controllers, services, and repositories.


3. 
   Bean Creation: Spring creates beans and resolves dependencies using dependency injection.


4. 
   Request Handling: Incoming HTTP requests are mapped to controller methods based on request mappings.


5. 
   Execution: Controller methods handle requests, interact with services, and return responses.


6. 
   Response Rendering: Spring converts method return values to appropriate HTTP responses (e.g., JSON).

Recommended Folder Structure

src

├── main

│ ├── java

│ │ └── com

│ │ └── example

│ │ ├── controller

│ │ │ └── MyController.java

│ │ ├── service

│ │ │ └── MyService.java

│ │ └── Application.java

│ └── resources

│ ├── application.properties

│ └── templates

│ └── index.html

└── test

└── java

└── com

└── example

└── controller

└── MyControllerTest.java

Error Handling in Spring Boot Cheat Sheet

Error handling is a critical aspect of building robust applications. Spring Boot provides several mechanisms for handling errors and exceptions gracefully, ensuring a smooth user experience.

Types of Errors

• 
  Client Errors: Errors caused by invalid client requests, such as 400 Bad Request or 404 Not Found.


• 
  Server Errors: Errors occurring on the server-side, such as 500 Internal Server Error.


• 
  Validation Errors: Errors due to invalid input or data validation failures.

Error Handling Mechanisms

1. Controller Advice

• 
  @ControllerAdvice: An annotation used to define global exception handlers in Spring MVC.


• 
  @ExceptionHandler: An annotation used to handle specific exceptions within a controller advice.


• 
  Example:
  

@ControllerAdvice

public class GlobalExceptionHandler {



    @ExceptionHandler(MyException.class)

    public ResponseEntity<ErrorResponse> handleMyException(MyException ex) {

        ErrorResponse response = new ErrorResponse("My error message");

        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);

    }



    @ExceptionHandler(Exception.class)

    public ResponseEntity<ErrorResponse> handleException(Exception ex) {

        ErrorResponse response = new ErrorResponse("Internal server error");

        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);

    }

}

ResponseEntityExceptionHandler

• 
  ResponseEntityExceptionHandler: A base class for handling common Spring MVC exceptions.


• 
  Overrides: Override methods like handleMethodArgumentNotValid, handleHttpMessageNotReadable, etc.


• 
  Example:
  

@ControllerAdvice

public class CustomExceptionHandler extends ResponseEntityExceptionHandler {



@Override

protected ResponseEntity<Object> handleMethodArgumentNotValid(

        MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {

    ErrorResponse response = new ErrorResponse("Validation failed");

    return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);

}



// Other overrides for handling specific exceptions

3. Error Attributes

• 
  ErrorAttributes: Interface used to customize the content and format of error responses.


• 
  DefaultErrorAttributes: Default implementation provided by Spring Boot.
  

@Component

public class CustomErrorAttributes extends DefaultErrorAttributes {

@Override

public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {

    Map<String, Object> errorAttributes = super.getErrorAttributes(webRequest, includeStackTrace);

    errorAttributes.put("customAttribute", "Custom value");

    return errorAttributes;

}



}

Using Properties Files

• 
  application.properties: Store application-wide properties like server port, database URL, etc.


• 
  Custom Properties Files: Define custom properties files for different environments (e.g., application-dev.properties).


• 
  Accessing Properties: Access properties using @Value annotation or Spring's Environment API.

Building Project

• 
  Maven: Run mvn clean install to build the project and generate an executable JAR.


• 
  Gradle: Run ./gradlew build to build the project and generate an executable JAR.

Additional Topics

• 
  Spring Boot Starters: Use starters to add dependencies and auto-configuration to your project.


• 
  Logging: Configure logging using Logback, Log4j, or Java Util Logging.


• 
  Error Handling: Implement global exception handling with @ControllerAdvice.


• 
  Testing: Write unit tests and integration tests using JUnit, Mockito, and SpringBootTest.