Annotations used with Spring Boot Applications

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class MyRestController {
    @GetMapping("/greeting")
    public String greeting() {
        return "Hello, World!";
    }
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class MyApiController {
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        // Fetch user by id
        return new User(id, "John Doe");
    }
    @PostMapping("/user")
    public User createUser(@RequestBody User user) {
        // Create and return new user
        return user;
    }
}

import org.springframework.stereotype.Service;
@Service
public class UserService {
    public User getUserById(Long id) {
        return new User(id, "John Doe");
    }
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // Constructors, getters, and setters
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class MyController {
    private final UserService userService;
    @Autowired
    public MyController(UserService userService) {
        this.userService = userService;
    }
    public User getUser(Long id) {
        return userService.getUserById(id);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService();
    }
}

import org.springframework.stereotype.Component;
@Component
public class MyComponent {
    public void performTask() {
        System.out.println("Task performed");
    }
}

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableAutoConfiguration
public class MyAutoConfig {
    // Configuration beans
}

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.http.ResponseEntity;
import org.springframework.http.HttpStatus;
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleResourceNotFound(ResourceNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable("id") Long userId) {
        return new User(userId, "John Doe");
    }
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
public class SearchController {
    @GetMapping("/search")
    public List<User> searchUsers(@RequestParam("name") String name) {
        // Search logic here
        return List.of(new User(1L, "John Doe"), new User(2L, "Jane Doe"));
    }
}

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class ApplicationConfig {
    @Value("${app.name}")
    private String appName;
    public String getAppName() {
        return appName;
    }
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class ScheduledTasks {
    @Scheduled(fixedRate = 5000)
    public void performTask() {
        System.out.println("Task performed at " + System.currentTimeMillis());
    }
    @Scheduled(cron = "0 0 * * * ?")
    public void performTaskUsingCron() {
        System.out.println("Task performed using cron at " + System.currentTimeMillis());
    }
}

16. @Transactional

Theory

The @Transactional annotation is used to manage transaction boundaries around method execution. It helps in maintaining data integrity and consistency.

Code Example

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class TransactionalService {
    @Transactional
    public void performTransactionalOperation() {
        // Perform operations within a transaction
    }
}

17. @Profile

Theory

The @Profile annotation is used to specify the profile(s) under which a bean should be created. It helps in segregating beans for different environments like development, testing, and production.

Code Example

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
@Configuration
public class ProfileConfig {
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new HikariDataSource();
    }
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return new DataSource();
    }
}

18. @Conditional

Theory

The @Conditional annotation is used to conditionally register beans based on a given condition.

Code Example

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ConditionalConfig {
    @Bean
    @Conditional(MyCondition.class)
    public MyBean myBean() {
        return new MyBean();
    }
}

19. @Cacheable

Theory

The @Cacheable annotation is used to indicate that the result of a method should be cached.

Code Example

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class CacheService {
    @Cacheable("users")
    public User getUserById(Long id) {
        // Simulate a slow method
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new User(id, "John Doe");
    }
}

20. @EventListener

Theory

The @EventListener annotation is used to mark a method as an event listener, which will be invoked when an event is published.

Code Example

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
@Component
public class UserEventListener {
    @EventListener
    public void handleUserCreatedEvent(UserCreatedEvent event) {
        System.out.println("User created: " + event.getUser().getName());
    }
}

21. @ResponseStatus

Theory

The @ResponseStatus annotation is used to mark a method or an exception class with a status code and a reason message that should be returned.

Code Example

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class StatusController {
    @GetMapping("/success")
    @ResponseStatus(HttpStatus.OK)
    public String success() {
        return "Request was successful";
    }
    @GetMapping("/not-found")
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public String notFound() {
        return "Resource not found";
    }
}

22. @CrossOrigin

Theory

The @CrossOrigin annotation is used to enable Cross-Origin Resource Sharing (CORS) on the server side, allowing requests from different origins.

Code Example

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://example.com")
public class CorsController {
    @GetMapping("/data")
    public String getData() {
        return "Cross-origin data";
    }
}

23. @RequestBody

Theory

The @RequestBody annotation is used to bind the HTTP request body with a domain object in method parameters. This is often used in POST and PUT requests.

Code Example

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class RequestBodyController {
    @PostMapping("/user")
    public User createUser(@RequestBody User user) {
        // Handle user creation
        return user;
    }
}

24. @ResponseBody

Theory

The @ResponseBody annotation indicates that the return value of a method should be bound to the web response body. This is useful in RESTful web services where you need to return data rather than a view.

Code Example

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class ResponseBodyController {
    @GetMapping("/message")
    @ResponseBody
    public String getMessage() {
        return "This is a response message";
    }
}

25. @Valid

Theory

The @Valid annotation is used to indicate that a method parameter should be validated against the constraints defined in its class.

Code Example

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.Valid;
@RestController
@RequestMapping("/api")
public class ValidationController {
    @PostMapping("/user")
    public User createUser(@Valid @RequestBody User user) {
        // Handle user creation
        return user;
    }
}

26. @JsonProperty

Theory

The @\JsonProperty annotation is used to map JSON property names to Java field names. This is useful when there is a mismatch between the JSON data structure and the Java object fields.

Code Example

import com.fasterxml.jackson.annotation.JsonProperty;
public class User {
    @JsonProperty("user_id")
    private Long id;
    @JsonProperty("user_name")
    private String name;
    // Constructors, getters, and setters
}

27. @JsonIgnore

Theory

The @JsonIgnore annotation is used to prevent a field from being serialized or deserialized.

Code Example

import com.fasterxml.jackson.annotation.JsonIgnore;
public class User {
    private Long id;
    @JsonIgnore
    private String password;
    // Constructors, getters, and setters
}

28. @ExceptionHandler

Theory

The @ExceptionHandler annotation is used to define a method that handles exceptions thrown by controller methods.

Code Example

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.http.ResponseEntity;
import org.springframework.http.HttpStatus;
@RestController
@RequestMapping("/api")
public class ExceptionHandlingController {
    @GetMapping("/exception")
    public String throwException() {
        throw new RuntimeException("An error occurred");
    }
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

29. @PatchMapping

Theory

The @PatchMapping annotation is a specialized version of @RequestMapping for PATCH requests, used to apply partial updates to resources.

Code Example

import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
@RestController
@RequestMapping("/api")
public class PatchController {
    @PatchMapping("/user/{id}")
    public User updateUserPartially(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
        // Apply partial updates to the user
        User user = findUserById(id);
        // Update user fields with values from updates map
        return user;
    }
}

30. @DeleteMapping

Theory

The @DeleteMapping annotation is a specialized version of @RequestMapping for DELETE requests, used to delete resources.

Code Example

import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

    @DeleteMapping("/user/{id}")
    public void deleteUser(@PathVariable Long id) {
        // Delete user by id
    }
}

Conclusion

Spring Boot annotations play a pivotal role in simplifying and accelerating the development of enterprise-level applications. By abstracting and automating configuration details, these annotations allow developers to focus more on business logic and less on boilerplate code. Mastery of these annotations is essential for any developer looking to excel in real-time Spring Boot projects.

Spring Boot annotations further enhance the capabilities of a Spring Boot application, providing more tools for configuration, data handling, and event management. Understanding and leveraging these annotations can significantly improve the efficiency and maintainability of real-time Spring Boot projects.

These annotations enhance the ability to build robust and flexible APIs with Spring Boot. By understanding and utilizing these annotations, developers can handle various aspects of web requests and responses, validation, error handling, and more, leading to more efficient and maintainable code.