🌐 Spring Boot REST API Development – Part 1 🚀
REST APIs are the backbone of modern apps, and Spring Boot makes building them fast, easy, and fun! In interviews, knowing why things happen is as important as writing code. 💡
48. Difference between @RestController and @Controller 🏷️
While @Controller renders views (like HTML), @RestController is shorthand for @Controller + @ResponseBody, automatically serializing return objects to JSON/XML. Surprise factor: it’s not new magic — just saves boilerplate! ✨
@Controller
public class WebController {
@GetMapping("/home")
public String home() {
return "home"; // renders home.html
}
}
@RestController
public class ApiController {
@GetMapping("/api/user")
public User getUser() {
return new User("Anand", 30); // returns JSON
}
}Unknown Fact: @RestController uses HttpMessageConverters like MappingJackson2HttpMessageConverter under the hood. 🧩
Common Mistake: Using @Controller for REST endpoints without @ResponseBody — leads to Spring searching for a template. 😱
49. What is @ResponseBody and when is it needed? 📦
@ResponseBody tells Spring: write the method’s return object directly to HTTP response. Essential for @Controller REST endpoints. Mentioning this difference in interviews shows deep understanding. 👀
@Controller
public class ApiController {
@GetMapping("/api/product")
@ResponseBody
public Product getProduct() {
return new Product("Laptop", 1200);
}
}Unknown Fact: Works with any HttpMessageConverter — JSON, XML, YAML, or custom formats! 🌟
Common Mistake: Forgetting @ResponseBody makes Spring look for a view template. 😂
50. How does Spring Boot handle JSON serialization/deserialization? 🔄
Spring Boot uses Jackson by default to convert Java ↔ JSON automatically via @RequestBody and @ResponseBody. Bonus: it supports Java 8 date/time, Optionals, and nested objects out-of-the-box! 🚀
@RestController
public class ApiController {
@PostMapping("/api/users")
public User createUser(@RequestBody User user) {
return user; // auto-serialized
}
}Unknown Fact: Lazy-loaded JPA entities can trigger exceptions during serialization — watch out! 🐇
Common Mistake: Missing @RequestBody leads to query param binding instead of JSON. 🪤
51. How to customize Jackson settings in Spring Boot 🎨
Customize globally via ObjectMapper bean or properties: control naming strategy, date formats, null handling, indentation. Interview tip: show how to change field names globally! 🌈
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
mapper.enable(SerializationFeature.INDENT_OUTPUT);
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
return mapper;
}Unknown Fact: You can register custom serializers/deserializers — e.g., encrypt sensitive fields! 🔐
Common Mistake: Multiple ObjectMappers without @Primary confuse Spring Boot autoconfiguration. 😬
52. How to enable/disable specific REST endpoints 🚦
Control endpoints (especially actuators) via management.endpoints.web.exposure.include/exclude or @ConditionalOnProperty. Critical in production to hide sensitive endpoints. 🔐
management.endpoints.web.exposure.include=health,info
management.endpoints.web.exposure.exclude=beans,envUnknown Fact: Conditional exposure can adapt endpoints dynamically per environment. 🌍
Common Mistake: Leaving sensitive endpoints like /beans open — huge security risk! 😱
53. How to handle exceptions globally in Spring Boot 🛡️
In Spring Boot, centralized exception handling can be done in **two ways** depending on your controllers: MVC or REST. This prevents cluttering each controller with try-catch blocks and ensures consistent error responses across your application. ⚡
1️⃣ Using @ControllerAdvice (Spring MVC)
Works with @Controller endpoints. By default, it returns view names (HTML). To return JSON, add @ResponseBody on the handler method.
@ControllerAdvice
public class GlobalMvcExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
@ResponseBody // needed for JSON
public ResponseEntity<Map<String,String>> handleNotFound(ResourceNotFoundException ex){
Map<String,String> error = new HashMap<>();
error.put("timestamp", LocalDateTime.now().toString());
error.put("message", ex.getMessage());
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
}
}Unknown Fact: You can target specific controllers using basePackages or assignableTypes in @ControllerAdvice. 🎯
Common Mistake: Forgetting @ResponseBody for REST endpoints in MVC controllers leads to Spring trying to render a view — confusing for beginners! 😱
2️⃣ Using @RestControllerAdvice (Spring REST)
@RestControllerAdvice is specialized for REST APIs and automatically returns JSON/XML responses for exceptions. No need for @ResponseBody on each method.
@RestControllerAdvice
public class GlobalRestExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<Map<String,String>> handleNotFound(ResourceNotFoundException ex){
Map<String,String> error = new HashMap<>();
error.put("timestamp", LocalDateTime.now().toString());
error.put("error", ex.getMessage());
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
}
}Unknown Fact: Perfect for REST APIs; works with multiple exception types and custom payloads like timestamps, error codes, and debug info. 🧙♂️
Common Mistake: Using only @ControllerAdvice for REST endpoints without @ResponseBody leads to unexpected view rendering or 404 errors. 😅
✅ Key Takeaways
- Use
@ControllerAdvicefor MVC controllers and HTML views. - Use
@RestControllerAdvicefor REST controllers; always returns JSON/XML. - Mixing both in a project is possible if you have MVC and REST controllers together.
- This approach keeps exception handling clean, consistent, and interview-proof!
Wrapping Up 🌟
REST API mastery in Spring Boot means more than returning JSON — it’s about **robust, maintainable, secure APIs**. Knowing hidden facts, pitfalls, and under-the-hood magic will make you shine in interviews and production alike. 🧙♂️✨
Comments
Post a Comment