spring-framework: Rejection of @RequestMapping and @HttpExchange declarations on the same element prevents elegant designs.
Caused by https://github.com/spring-projects/spring-framework/issues/32065
Upgrading Spring version I Just stumbled upon an issue caused from removing the support to have both type of annotations in a single element.
Allowing both annotations provides more flexibility on simpler designs since the API can be defined in a single interface and ensure both controller and clients work by implementing the same root API. It also simplifies quite much when there is inheritance and the need to use @RequestMapping unique features (like multiple URLs or the params condition).
As of this change, where I have a generic interface defining a common API, which is inherited by a domain-based API and finally implemented by a controller and its respective client, I would need to separate from the root API (most generic one) since there are methods that have unique requirements on the @RequestMapping declarations (including Get, Post and the other method variants) and that can’t be set with @HttpExchange (and therefore can’t opt to use that one also for Controllers).
This workaround is less natural and becomes messy very fast.
Would it be possible to review this decision and, maybe, revert it?
Design allowing @RequestMapping and @HttpExchange based declarations on the same element
Design to achieve the same by rejecting @RequestMapping and @HttpExchange based declarations on the same element
About this issue
- Original URL
- State: open
- Created 3 years ago
- Reactions: 2
- Comments: 16 (8 by maintainers)
I’d like to second the issue with my use case which is similar to the author’s. In my setup, this change is a regression and I’d need to stuck with the previous Spring release for now.
My typical project structure is:
In this configuration,
AppApidefines REST API contract:which is then implemented by
AppApiController:and
AppApiClientprovides a handy method that creates a HTTP interface client withHttpServiceProxyFactory.This way, API contract is defined neatly in a central place, neither duplication of code that can vary independently nor repetition of annotations occurs. Any other service in the monorepo that needs to communicate with
appcan simply add dependency to:app:client.I guess this will work but certainly not as clean as pre-change look. It is also confusing for devs who come to see a controller and only see
@RequestMappingbut not all other annotations and wonder how it works.I remember there were some GH issues requesting
HttpServiceProxyFactoryto recognise@RequestMappingannotations (or questioning the need in new@HttpExchange) for similar reuse but it was declined as clients needed another perspective or smth. I can see why one might want to keep them separate. It is weird thatHttpExchange“leaked” backwards into server side tho 😃Actually, given it is supported by the server, I tried using
@HttpExchangealone so that it used both by client and server, but later realised in this use case@HttpExchangeand@RequestMappingare opposite in a way that@GetExchangedefines that a client accept json, while@GetMappingtells the server produces json responses. This is not possible to model with@GetExchangealone.viz: @sbrannen (as a change author)