Redundancy between @ResponseBody and @PostMapping(path = "/test", consumes =..., produces = MediaType.APPLICATION_JSON_VALUE)?

Question

Small question regarding

@ResponseBody and @XXXMapping([...]  produces = MediaType.APPLICATION_JSON_VALUE)

Are they achieving the exact same thing?

Having the two together is redundant?

If no, what are the differences?

If yes, which one should be preferred?

Having the two together can bring anything positive? Any use case where we should have the two together?

Thank you

`@ResponseBody` is legacy annotation since v3.0, while `@XXXMapping` is better alternative introduced in `v4.3` — sidgate, Oct 17 '20 at 02:36
@sidgate You're confusing `@ResponseBody` and `@RequestMapping`. — chrylis -cautiouslyoptimistic-, Oct 17 '20 at 02:44
yeah, right. `@PostMapping` is just a shorthand for `@RequestMapping(method = RequestMethod.POST)` — sidgate, Oct 17 '20 at 02:48
My question is really between @ResponseBody and @PostMapping/@GetMapping/@xxxMapping but with the produces = MediaType.APPLICATION_JSON_VALUE :) — PatPanda, Oct 17 '20 at 02:56

score 1 · Answer 1 · answered Oct 17 '20 at 03:38

@ResponseBody is generally used with @Controller for an ajax endpoint to let spring know you aren't rendering an html page, you want to return json or if you configure it, xml, etc. If you are using an @RestController it's not necessary. This is sort of a duplicate of this but I guess it's kind of different ‍♀️

score 0 · Accepted Answer · answered Oct 17 '20 at 05:23

Specifically, @PostMapping is a composed annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.POST)

The @ResponseBody annotation tells a controller that the object returned is automatically serialized into JSON and passed back into the HttpResponse object.

Suppose we have a custom Response object:

public class ResponseTransfer {
    private String text; 
    
    // standard getters/setters
}
Next, the associated controller can be implemented:

@Controller
@RequestMapping("/post")
public class ExamplePostController {
 
    @Autowired
    ExampleService exampleService;
 
    @PostMapping("/response")
    @ResponseBody
    public ResponseTransfer postResponseController(
      @RequestBody LoginForm loginForm) {
        return new ResponseTransfer("Thanks For Posting!!!");
     }
}

In the developer console of our browser or using a tool like Postman, we can see the following response:

{"text":"Thanks For Posting!!!"} Remember, we don't need to annotate the @RestController-annotated controllers with the @ResponseBody annotation since Spring does it by default

let's implement a new method, mapped to the same /content path, but returning XML content instead:

@PostMapping(value = "/content", produces = MediaType.APPLICATION_XML_VALUE)
@ResponseBody
public ResponseTransfer postResponseXmlContent(
  @RequestBody LoginForm loginForm) {
    return new ResponseTransfer("XML Content!");
}

Redundancy between @ResponseBody and @PostMapping(path = "/test", consumes =..., produces = MediaType.APPLICATION_JSON_VALUE)?

2 Answers2