1. List of basic spring boot annotations- Tested

Basic Spring boot annotations

Spring Boot is a popular Java framework for building production-ready, stand-alone, and easy-to-deploy applications. It simplifies the development of Spring applications by providing pre-configured templates and conventions. Annotations play a crucial role in Spring Boot applications as they help configure various aspects of the application and define the behavior of different components. Here are some common Spring Boot annotations and their purposes:

1) @SpringBootApplication

This spring boot annotations is typically used at the entry point of a Spring Boot application class. It combines several spring boot annotations like @Configuration, @EnableAutoConfiguration, and @ComponentScan, making it a convenient way to set up a Spring Boot application.

@SpringBootApplication
public class MySpringBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

2) @RestController

@RestController is an spring boot annotations in the Spring Framework that is used to indicate that a Java class defines a RESTful web service endpoint. This annotation is typically applied to a class that contains methods responsible for handling HTTP requests and returning responses in a RESTful manner.

Here are some key characteristics and features of classes annotated with @RestController:

1. HTTP Request Handling: Classes marked with @RestController are responsible for handling incoming HTTP requests, such as GET, POST, PUT, DELETE, etc. Each method in the class corresponds to a specific endpoint, and the HTTP method that the method handles is specified using spring boot annotations like @GetMapping, @PostMapping, @PutMapping, and @DeleteMapping.
2. Automatic Response Conversion: Spring automatically converts the return values of methods in a @RestController class into the appropriate HTTP response format based on the request’s Accept header. This can include JSON, XML, HTML, or other response types, depending on the configuration.
3. Simplified RESTful Development: @RestController simplifies the development of RESTful APIs by eliminating the need to manually set headers, construct responses, or manage content negotiation. It provides a clean and straightforward way to define RESTful endpoints.

Here’s an example of a simple @RestController class:

@RestController
@RequestMapping("/api")
public class MyRestController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }

    @PostMapping("/create")
    public String createResource() {
        // Logic to create a resource
        return "Resource created successfully!";
    }
}

3) @RequestMapping

The @RequestMapping spring boot annotations is a versatile and fundamental spring boot annotations used to map HTTP requests to specific controller methods or classes in a Spring application. It allows you to define how incoming HTTP requests should be handled and routed to the appropriate controller methods. The @RequestMapping spring boot annotations can be applied at both the class level (for the entire controller) and the method level (for specific request handling methods).

Here is a description of how @RequestMapping can be used:

• Class-Level @RequestMapping:

When applied at the class level, @RequestMapping specifies a base URL path that is shared by all the request handling methods within that controller. It helps in organizing and grouping related endpoints under a common base path.

@RestController
@RequestMapping("/products")
public class ProductController {
    // Controller methods for handling product-related requests
}

In this example, all the request handling methods within the ProductController will be relative to the “/products” base path.

• Method-Level @RequestMapping:

When applied at the method level, @RequestMapping specifies additional path segments, HTTP methods, and other request details for a specific request handling method.

@RestController
@RequestMapping("/products")
public class ProductController {

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        // Logic to retrieve a product by its ID
    }
}

In this example, the getProductById method is mapped to the “/products/{id}” URL path, and it handles HTTP GET requests for that path. It also uses @PathVariable to extract the “id” parameter from the URL.

• Mapping to Multiple HTTP Methods:

You can map a method to handle multiple HTTP methods using the method attribute. For example, you can use @RequestMapping(method = {RequestMethod.GET, RequestMethod.POST}) to map a method to handle both GET and POST requests.

• Request Parameters and Headers:

@RequestMapping supports mapping based on request parameters and headers. You can specify conditions using the params and headers attributes. For example, you can use @RequestMapping(params = "paramName=value") to map a method only if a specific request parameter is present.

• Content Negotiation:

@RequestMapping allows for content negotiation by specifying the produces and consumes attributes. For example, you can use @RequestMapping(produces = "application/json") to indicate that the method produces JSON responses.

• Ant Path Patterns

You can use Ant-style path patterns with @RequestMapping to match dynamic segments in the URL. For instance, @RequestMapping("/users/{username}") matches URLs like “/users/ram” where “ram” is a dynamic parameter.

@RequestMapping provides a flexible way to define how your Spring controllers handle HTTP requests, making it a fundamental part of building web applications with Spring.

4) @GetMapping

@GetMapping is a specific annotation in Spring that is used to map HTTP GET requests to handler methods in a controller class. It’s a shortcut annotation for specifying that a particular method should handle HTTP GET requests without the need to explicitly specify the HTTP method using @RequestMapping.

Example: Suppose you have a Spring RESTcontroller for handling user-related operations, and you want to create a method to retrieve user details by their ID when a GET request is made to a specific URL. You can use @GetMapping for this purpose:

@RestController
public class UserController {

    // This method will handle GET requests to "/users/{id}/{name}"
    @GetMapping("/users/{id}/{name}")
    public String getUserById(@PathVariable Long id,@PathVariable Long name) {
        // Simulate retrieving user data from a service or database
        String userData = "User ID: " + id + ", Name: " + name;
        return userData;
    }
}

In this example:

• @GetMapping("/users/{id}/{name}") specifies that the getUserById method should handle GET requests to URLs like “/users/{id}/{name}” where {id} and {name} is a placeholder for the user’s ID and NAME.
• @PathVariable is used to capture the id parameter from the URL and pass it as an argument to the getUserById method.

When you make a GET request to a URL like “/users/123/Ram“, the getUserById method will handle the request and return the user’s data, which will be sent as the HTTP response.

5) @PostMapping

@PostMapping is an spring boot annotations used to map HTTP POST requests to specific controller methods. It’s a more specific version of @RequestMapping with the HTTP method set to POST. This spring boot annotations is commonly used for handling form submissions, creating or updating resources on the server, and processing data sent as part of a POST request.

Here’s a brief description and a small example of how to use @PostMapping:

1. Annotation Usage: Apply @PostMapping to a controller method to specify that the method should handle POST requests for a specific URL path.
2. HTTP POST Requests: When a POST request is sent to the URL path associated with a @PostMapping-annotated method, Spring will route the request to that method for processing.

Here’s a simple example:

@RestController
public class UserController {
    @PostMapping("/users")
    public String createUser(@RequestBody User user) {
        // Logic to create a user in the database
        return "User created: " + user.getName();
    }
}

In this example:

• The @RestController annotation marks the class as a Restcontroller.
• The @PostMapping("/users") annotation specifies that the createUser method will handle POST requests to the “/users” endpoint.

The @RequestBody spring boot annotations is used to bind the incoming JSON or form data from the request body to a User object. This allows you to process the data sent by the client.

When a POST request is sent to “/users” with JSON data like this:

{
    "name": "John Doe",
    "email": "johndoe@example.com"
}

The createUser method will receive this data as a User object, and it can then process the data, create a user in the database, and return a response.

6) @PutMapping

@PutMapping is an spring boot annotations used in Spring Framework to map HTTP PUT requests to specific controller methods. It’s commonly used in RESTful web services to update existing resources on the server. Here’s a short description along with an example:

Let’s say you’re building a RESTful API for managing a list of books, and you want to update the details of a specific book using a PUT request. Here’s how you can use @PutMapping:

@RestController
@RequestMapping("/books")
public class BookController {

    @PutMapping("/update/{id}")
    public ResponseEntity<Book> updateBook(@PathVariable Long id, @RequestBody Book updatedBook) {
       //  logic for update book 
    }
}

In this example:

• We define a BookController that handles requests related to books.
• The @PutMapping("/update/{id}") annotation maps HTTP PUT requests to the updateBook method. It expects a Long id as a path variable and a @RequestBody with the updated book information.

When you send a PUT request to /books/update/{id} with updated book information in the request body, the updateBook method will be invoked to update the corresponding book resource.

7) @DeleteMapping

@DeleteMapping is an spring boot annotations used in Spring Framework to map HTTP DELETE requests to specific handler methods in a RestController class.

Here’s a short description of how to use @DeleteMapping with an example:

Annotation Usage:

@DeleteMapping("/delete/{id}")

@RestController
public class UserController {
    @DeleteMapping("/delete/{id}")
    public ResponseEntity<String> deleteUser(@PathVariable Long id) {
        // Logic to delete the user with the given 'id'

    }
}

In this example:

• The @RestController spring boot annotations marks the class as a controller, and it returns data directly to the client as JSON.
• The @DeleteMapping("/delete/{id}") annotation maps HTTP DELETE requests to the deleteUser method, which takes an id as a path variable.
• Inside the deleteUser method, you can implement the logic to delete a user by their ID

8) @PathVariable

@PathVariable is an spring boot annotations used in the Spring Framework to extract values from the URI (Uniform Resource Identifier) of a web request and map them to method parameters in a Restcontroller. It allows you to capture dynamic values from the URL and use them in your controller methods.

Annotation Usage:

@RestController
public class UserController {

    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUserById(@PathVariable("id") Long userId) {
        // Logic to fetch and return user data by the provided 'userId'
    }
}

9) @RequestParam

@RequestParam is a spring boot annotations used in Java to extract request parameters from the URL or query string of an HTTP request. It allows you to access data submitted by the client as part of an HTTP request, such as form fields, query parameters, or other request parameters.

Here’s a short description of how to use @RequestParam:

Annotation Usage:

@RequestParam(name = "paramName", required = true, defaultValue = "defaultValue")

• @RequestParam is a spring boot annotations used as a method parameter-level annotation in a Spring Controller method.
• name specifies the name of the request parameter you want to retrieve. It should match the name of the parameter in the URL or query string.
• required is a boolean attribute that indicates whether the parameter is required. If set to true (default), Spring will throw an exception if the parameter is missing in the request.
• defaultValue is an optional attribute that provides a default value for the parameter in case it is not present in the request.

@RestController
public class ExampleController {

    @GetMapping("/greet")
    public String greet(@RequestParam(name = "name", required = false, defaultValue = "Guest") String name) {
        return "Hello, " + name + "!";
    }
}

In this example:

• The @RestController spring boot annotations marks the class as a controller.
• The greet method has a @RequestParam annotation on the name parameter. It expects a query parameter named “name.”
• The required attribute is set to false, indicating that the “name” parameter is not mandatory in the request.
• The defaultValue attribute is set to “Guest,” providing a default value if the “name” parameter is missing.

When a client sends a GET request to /greet, they can include a query parameter like /greet?name=John.

10) @RequestBody

@RequestParam is an spring boot annotations in Java used with Spring Framework to indicate that a method parameter should be bound to the body of an HTTP request. It’s commonly used in RESTful web services to receive and parse data sent by clients in the request body, typically in JSON or XML format.

Here’s a short description of @RequestBody:

Annotation Usage:

@RequestBody

• @RequestBody is used as a method parameter-level annotation in a Spring Controller class.
• It is often used in conjunction with other HTTP method annotations like @PostMapping, @PutMapping, or @PatchMapping.

Purpose: @RequestBody is used to bind the content of the HTTP request body to a Java object. This allows you to receive and work with data sent by clients in a structured format (e.g., JSON) within your Spring application.

@RestController
public class UserController {
    @PostMapping("/users")
    public ResponseEntity<String> createUser(@RequestBody User user) {
        // Logic to create a new user using the data provided in the request body
        // 'user' object is automatically populated from the JSON data in the request body
        return ResponseEntity.ok("User created successfully");
    }
}

• In this example:
  • The @PostMapping("/users") annotation maps HTTP POST requests to the createUser method.
  • The @RequestBody annotation is used with the User parameter, indicating that the user object should be populated with the JSON data from the request body.
  • Inside the createUser method, you can process the data from the request body to create a new user.

When a POST request is sent to /users with a JSON payload in the request body, Spring will automatically deserialize the JSON into a User object and pass it as the user parameter to the createUser method, allowing you to work with the data in your application.

Other Related Posts: